2021SC@SDUSC

This article focuses on code modules jpress-service,jpress-service-provider, analysis menuService、menuServiceProvider Two classes . Because this kind of design is at the bottom JFinal、Jboot Secondary development and use of various caches , So I will add some cache related knowledge , So that we can better understand the code .

One 、MenuService

1.1 menu Database table

Through the attributes of the table in the database, it is more conducive to understand the relevant operations in the function . Here are menu surface ：

1.2 MenuService

MenuService Defines the relevant interface of menu operation , stay provider Will give detailed implementation , Here briefly describe the purpose of the interface .

Menu findById(Object id);

adopt id Value to find the corresponding menu

List<Menu> findAll();

Query all menu data

boolean delete(Menu model);

adopt menu Type of model Delete menu data

Object saveOrUpdate(Menu model);

Add or update Model data , After adding or updating successfully , Return to the Model The primary key value

int sync(List<Menu> menus);

Achieve menu synchronization

List<Menu> findListByParentId(Object id);

Through the parent menu ID Find the submenu list

List<Menu> findListByRelatives(String table, Object id);

Find the list of submenus through the associated table , There are... In the database table definition of the menu relative_table One value 、

Two 、Cache cache

First, show the part MenuServiceProvider Code for ：

@Cacheable(name = "menu", key = "type:#(type)")
public List<Menu> findListByTypeInDb(String type) {
    
    return DAO.findListByColumn(Column.create("type", type), "order_number asc, id desc");
}

We can see , If you don't understand the purpose and use of annotations , Can't have a good interpretation of the code , Next, we will first analyze the code of the caching mechanism , Proceed again MenuServiceProvider Code analysis of .

import io.jboot.components.cache.annotation.CacheEvict;
import io.jboot.components.cache.annotation.Cacheable;

MenuServiceProvider Use Jboot Provide annotations to use the caching mechanism .

2.1 Cache description

Jboot Positioned as a high-performance microservice framework , However, high performance is inseparable from reasonable cache design .Jboot Built in rich framework support , such as ：

• ehcache
• redis
• ehredis
• caffeine
• caredis
• j2cache

By default Jboot It's using caffeine As Jboot Caching scheme for

JFinal The default cache implementation in is ehcache, Need to introduce ehcache Of jar Package and its configuration file

EhCache It's pure. Java In process caching framework for , With fast 、 Characteristics such as ability , yes Hibernate The default CacheProvider.Ehcache Is a widely used open source Java Distributed cache . Mainly for general purpose cache ,Java EE And lightweight containers . It has memory and disk storage , Cache loader , Cache extension , Cache exception handler , One gzip cache servlet filter , Support REST and SOAP api Other characteristics .

In terms of integration , Can be used alone , It is generally used in third-party libraries （ Such as mybatis、shiro etc. ）ehcache Not good enough for distributed support , Multiple nodes cannot be synchronized , Usually and redis Use it together .

2.2 Using cache via annotations

• @Cacheable
• @CacheEvict
• @CachesEvict
• @CachePut

stay service in ,Jboot Provides the above 4 A component , It is convenient for us to cache , Without having to use CacheUtil To display the call .

for example ：

@Bean
public class CommentServiceImpl implements CommentService {
    

    @Override
    public String getCommentById(String id) {
    
        return "id:" + id + " data:" + UUID.randomUUID();
    }

    @Override
    @Cacheable(name = "cacheName", key = "#(id)")
    public String getCommentByIdWithCache(String id) {
    
        return "id:" + id + " data:" + UUID.randomUUID();
    }

    @Override
    @Cacheable(name = "cacheName", key = "#(id)", liveSeconds = 5)
    public String getCommentByIdWithCacheTime(String id) {
    
        return "id:" + id + " data:" + UUID.randomUUID();
    }

    @Override
    @CachePut(name = "cacheName", key = "#(id)")
    public String updateCache(String id) {
    
        return "id:" + id + " data:" + UUID.randomUUID();
    }

    @Override
    @CacheEvict(name = "cacheName", key = "#(id)")
    public void delCache(String id) {
    
    }
}

• getCommentById Method does not use any annotations , Every time it's called ,data What follows is a new random number .
• getCommentByIdWithCache Use @Cacheable annotation , The cache key It came in id, So as long as it's the same id value , The random number returned each time is the same , Because random numbers have been cached .
• getCommentByIdWithCacheTime Use @Cacheable annotation , But added 5 second Time limit of , therefore , stay 5 In seconds , No matter how many times you call , The random numbers returned are the same ,5 Seconds later, the cache is deleted , After calling again, there will be a new random number , The new random number will continue to be cached 5 Second .
• updateCache Using annotations @CachePut , After each call to this method , It will be updated id Value cache .
• delCache Used @CacheEvict annotation , Each call deletes the id Value cache .

3、 ... and 、MenuServiceProvider

Realized menuService The important function in , To the top Controller Provide interface for menu operation . Next, we will provider Detailed analysis of the main method .

3.1 shouldUpdateCache

@Override
@CacheEvict(name = "menu", key = "*")
public void shouldUpdateCache(int action, Model model, Object id) {
    
    super.shouldUpdateCache(action, model, id);
}

This method updates the cache , Input action Parameter values for , When the function is called , Will delete the id Value cache , Achieve the update effect . But because key The choice is “*”, So whatever it is id value , Will be in the cache with the name menu Objects deleted from the cache .

3.2 findListByType

@Override
public List<Menu> findListByType(String type) {
    
    return ModelUtil.copy(findListByTypeInDb(type));
}
// The method called in the above method 
@Cacheable(name = "menu", key = "type:#(type)")
    public List<Menu> findListByTypeInDb(String type) {
    
        return DAO.findListByColumn(Column.create("type", type), "order_number asc, id desc");
    }

The purpose of this method is to type Type find a list of this type .

First, through DAO Find the whole list , By order number and id Arrange in order .

Next use @Cacheable annotation , take key by type Information stored in the cache .

Four 、 summary

In this article , This paper introduces the relevant important methods of menu function , It also introduces the cache mechanism in JPress Through the use and implementation of annotations in the project . In the next article , The explicit call and implementation of caching mechanism will be introduced .