Detailed SpringBoot tutorial for cache development

Writing in the front

This preliminary set down a series of blog posts including SpringBoot introduction, introduction, configuration, log, web development, data access, combined with related docker, caching, message queue, retrieve, tasks, security, distributed and so on a series of blog posts, a lot of work, is a long process, every step I have detailed as far as possible, deserve to go up screenshot shows, I hope it’s really useful for those of you who are watching. I just want to share technical blog posts, but also want to say that if you think it is useful, please click on the following, give a like, also a relief to me, after all, I have to lose a lot of hair, hey hey hey

Serial article transport bar

Why cache

Cache is an essential optimization point in development. Many points about cache have been optimized. For example, in the scene of loading a lot of data, cache mechanism will be used to improve interface response speed and indirectly improve user experience. Of course, there is also a need to pay attention to the use of cache, for example, if it is not well handled, not good such as LRU strategy, not timely update the data of the database will lead to data lag, and then produce user misread, or confusion. But for all of this, SpringBoot has provided us with handy development tools.

JSR107

Spring cache abstraction

Spring since 3.1 defines the org. Springframework. Cache. The cache and org., springframework. Cache. CacheManager unified interface to different caching technology, It also supports using JCache (JSR-107) annotations to simplify our development.

• The Cache interface is defined by the component specification of the Cache and contains various operations of the Cache.
• Spring provides various implementations of xxxCache under the Cache interface. Such as RedisCache, EhCacheCache, ConcurrentMapCache, etc.
• Each time a method is called that requires caching, Spring checks to see if the specified target method with the specified parameter has already been called. If so, Spring fetches the result of the method call directly from the cache. If not, Spring fetches the result directly from the cache for the next call.
• There are two things we need to focus on when using Spring cache abstraction: first, identifying methods that need to be cached and their caching strategy, and second, reading data from the cache stored in the previous cache

SpringBoot enables annotations

@SpringBootApplication @EnableAutoConfiguration @EnableCaching public class SpringbootcacheApplication { public static void main(String[] args) { SpringApplication.run(SpringbootcacheApplication.class, args); }}Copy the code

Common cache annotations

@CacheConfig

@Cacheable

This annotation is the most important, main implementation of the function of the next read operation. If we can’t find it, we go to the database execution method. This is the most important method for caching annotations, and basically all of our caching implementations rely on it.

@CacheEvict

@CachePut

This annotation it always interpreted the data cache, rather than every time I do check it exists, compared with its usage scenario is less, after all we want is not always give out to all of the data, we still hope to be able to find the cached data, direct return, so that can improve efficiency of our software.

@cache

Using the instance

Let’s create a new table, meaning for the article, the following example will operate in this table, the framework used for SSM+SpringBoot, the following is to create a database table.

CREATE TABLE Artile (
`id`  int(11) NOT NULL AUTO_INCREMENT ,
`title`  varchar(30) CHARACTER SET gbk COLLATE gbk_chinese_ci NULL DEFAULT NULL ,
`author`  varchar(30) CHARACTER SET gbk COLLATE gbk_chinese_ci NULL DEFAULT NULL ,
`content`  mediumtext CHARACTER SET gbk COLLATE gbk_chinese_ci NULL ,
`file_name`  varchar(30) CHARACTER SET gbk COLLATE gbk_chinese_ci NULL DEFAULT NULL ,
`state`  smallint(2) NULL DEFAULT 1 COMMENT 'state'. PRIMARY KEY (`id`) ) ENGINE=InnoDB DEFAULT CHARACTER SET=gbk COLLATE=gbk_chinese_ci AUTO_INCREMENT=11 ROW_FORMAT=COMPACTCopy the code

Then we create the Mapper layer, which is basically the business operations of adding, deleting, modifying and querying articles, and map them to the specific SQL of XML (the principle of mapping is described in the previous post on data access, of course, we can also directly write the @select annotation in Mapper layer to write SQL statements). Then call it with service

Public interface ArticleMapper {/** * insert an article * @param title * @param author * @param content * @param fileName * @return
	 */
	public Integer addArticle(@Param("title") String  title,@Param("author")String author,
	                              @Param("content")String content,@Param("fileName")String fileName); /** * get articles by id * @param id * @return
	 */
	public Article getArticleById(@Param("id") Integer id); /** * updateContentById(@param)"content")String content,@Param("id")Integer id); /** * delete articles by id * @param id * @return
	 */
	public Integer removeArticleById(@Param("id")Integer id); /** * gets the id * @ of the last insertionreturn
	 */
	public Integer getLastInertId();

}
Copy the code

Then there is the Service layer. The main thing to note is that the caching annotations we described above are based on the Service layer (not on the Contoller and DAO layers). First we configure a CacheConfig on the class and then cacheNames. The following methods all use this cache name as their default value, and they all use this cache name without additional configuration. When performing a select query, we configure @cacheable and specify a key so that all but the first result is cached, and all subsequent results are returned directly from that cache. When updating data (delete or update operations), use @cacheevict to clear the cache in case the cache is not updated when calling @cacheabel

@Service
@CacheConfig(cacheNames = "articleCache") public class ArticleService { private AtomicInteger count =new AtomicInteger(0); @Autowired private ArticleMapper articleMapper; /** * add an article to the cache each time * @return
     */
    @CachePut
    public Integer addArticle(Article article){
        Integer result = articleMapper.addArticle(article.getTitle(), article.getAuthor(), article.getContent(), article.getFileName());
        if (result>0) {
            Integer lastInertId = articleMapper.getLastInertId();
            System.out.println("-- add operation --id:" + lastInertId);
        }
        returnresult; } /** ** if state is 0, no caching is performed * @param id article id * @return
     */
    @Cacheable(key = "#id",unless = "#result.state==0") public Article getArticle(Integer ID) {try {thread.sleep (5000); } catch (InterruptedException e) { e.printStackTrace(); } final Article artcile = articleMapper.getArticleById(id); System.out.println("-- perform database query operation"+count.incrementAndGet()+"Time"+"id:"+id);
        returnartcile; } /** * clear the cache with id as key ** @param id * @ with id update contentreturn
     */
    @CacheEvict(key = "#id")
    public Integer updateContentById(String contetnt, Integer id) {
        Integer result = articleMapper.updateContentById(contetnt, id);
        System.out.println("-- perform update operation id:--"+id);
        returnresult; } /** ** removes articles by ID * @param id clears cache with id as key * @return
     */
    @CacheEvict(key = "#id")
    public Integer removeArticleById(Integer id){
        final Integer result = articleMapper.removeArticleById(id);
        System.out.println("Execute delete operation with id:"+id);
        returnresult; }}Copy the code

Then we write the Controller layer, which is mainly to accept requests from clients. We configure @RestController to indicate that it is a REST style application. When receiving an ADD request, it will add a data, get request will query a data, RESH will update a data, and REM will delete a data

@RestController
@ComponentScan(basePackages = {"com.wyq.controller"."com.wyq.service"})
@MapperScan(basePackages = {"com.wyq.dao"})
public class ArticleController {

    @Autowired
    private ArticleService articleService;

    @Autowired
    ArticleMapper articleMapper;

    @PostMapping("/add")
    public ResultVo addArticle(@RequestBody Article article) {

        System.out.println(article.toString());
        Integer result = articleService.addArticle(article);

        if (result >= 0) {
            return ResultVo.success(result);
        }
        return ResultVo.fail();
    }


    @GetMapping("/get")
    public ResultVo getArticle(@RequestParam("id") Integer id) {

        Long start = System.currentTimeMillis();
        Article article = articleService.getArticle(id);
        Long end = System.currentTimeMillis();
        System.out.println("Time:"+(end-start));

        if(null ! = article)return ResultVo.success(article);
        returnResultVo.fail(); } /** * update a post ** @param conteTNT * @param id * @return
     */
    @GetMapping("/resh")
    public ResultVo update(@RequestParam("content") String contetnt, @RequestParam("id") Integer id) {
        final Integer result = articleService.updateContentById(contetnt, id);
        if (result > 0) {
            return ResultVo.success(result);
        } else {
            returnResultVo.fail(); }} /** * Delete an article ** @param id * @return
     */
    @GetMapping("/rem")
    public ResultVo remove(@RequestParam("id") Integer id) {

        final Integer result = articleService.removeArticleById(id);
        if (result > 0) {
            return ResultVo.success(result);
        } else {
            returnResultVo.fail(); }}}Copy the code

Test case

Id :--11Copy the code

Redis cache integration

SpringBoot is very easy to integrate with Redis (ok, SpringBoot is very easy to integrate everything), we just need to import spring-boot-starter-data-redis, and then configure the redis connection address in application.yml. We then use the RestTemplate to manipulate Redis, and here’s how redis handles the cache

• redisTemplate.opsForValue(); // Operation string
• redisTemplate.opsForHash(); / / the hash operation
• redisTemplate.opsForList(); / / the list to operate
• redisTemplate.opsForSet(); / / set operation
• redisTemplate.opsForZSet(); // set in order
• Configure caching and CacheManagerCustomizers
• Test using cache, switch cache, CompositeCacheManager

The next article