SpringBoot工程中Redis与Aop技术的整合

SpringBoot工程中Redis与Aop技术的整合
业务描述
基于AOP与Redis技术实现mysql,redis数据库中数据操作.

项目准备工作
第一步:打开sca-template工程,添加访问MySql数据库的依赖(两个)

<!--mysql依赖-->
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
    </dependency>
    <!--mybatis plus (简化mybatis操作)-->
    <dependency>
        <groupId>com.baomidou</groupId>
        <artifactId>mybatis-plus-boot-starter</artifactId>
        <version>3.4.2</version>
    </dependency>

第二步:修改sca-template工程的配置文件,添加连接mysql数据库的配置

spring:
  datasource:
    url: jdbc:mysql:///jt-sso?serverTimezone=Asia/Shanghai&characterEncoding=utf8
    username: root
    password: root

Pojo逻辑对象定义
定义一个Menu对象,用户封装tb_menus表中的数据,例如:

package com.jt.pojo;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import org.springframework.data.annotation.Id;

import java.io.Serializable;

@TableName(value = "tb_menus")
public class Menu implements Serializable {
    private static final long serialVersionUID = -577747732166248365L;
    @TableId(type = IdType.AUTO)
    private Long id;
    private String name;
    private String permission;

    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getPermission() {
        return permission;
    }

    public void setPermission(String permission) {
        this.permission = permission;
    }

    @Override
    public String toString() {
        return "Menu{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", permission='" + permission + '\'' +
                '}';
    }
}

Dao逻辑对象设计及实现
创建用于操作数据库中tb_menus表中数据的Mapper对象,例如:

package com.jt.dao;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.jt.pojo.Menu;
import org.apache.ibatis.annotations.Mapper;

@Mapper
public interface MenuMapper extends BaseMapper<Menu> {
}
Service逻辑对象设计及实现
第一步:定义用于处理菜单业务的业务接口,例如:

package com.jt.service;
import com.jt.pojo.Menu;
import java.io.Serializable;
public interface MenuService {
    /**
     * 基于id查找菜单对象,先查redis,redis没有再查数据库
     * @param id
     * @return
     */
    Menu selectById(Long id);
    /**
     * 向表中写入一条菜单信息,与此同时也要向redis写入一样的数据
     * @param menu
     * @return
     */
    Menu insertMenu(Menu menu);
    /**
     * 更新表中数据,与此同时也要更新redis中的数据
     * @param menu
     * @return
     */
    Menu updateMenu(Menu menu);
    //.....
}

第二步:定义用于处理菜单业务的业务接口实现类,
在这个实现类中自己基于RedisTemplate对象操作Redis缓存,例如:

package com.jt.service;
import com.jt.dao.MenuMapper;
import com.jt.pojo.Menu;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.ValueOperations;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import java.time.Duration;

@Service
public class MenuServiceImpl implements MenuService{
    @Autowired
    private MenuMapper menuMapper;

   // @Autowired
   // private RedisTemplate redisTemplate;

    @Resource(name="redisTemplate")
    private ValueOperations valueOperations;//从spring.io官方的data项目中去查这种注入方式
    /**
     * 基于id查询菜单信息,要求:
     * 1)先查redis,redis没有去查mysql
     * 2)将从mysql查询到的数据存储到redis
     * @param id
     * @return
     */
    @Override
    public Menu selectById(Long id) {
        //ValueOperations valueOperations = redisTemplate.opsForValue();
        Object obj=valueOperations.get(String.valueOf(id));
        if(obj!=null){
            System.out.println("Get Data from redis");
            return (Menu)obj;
        }
        Menu menu=menuMapper.selectById(id);
        valueOperations.set(String.valueOf(id), menu, Duration.ofSeconds(120));
        return menu;
    }
    @Override
    public Menu insertMenu(Menu menu) {
        menuMapper.insert(menu);
       // ValueOperations valueOperations = redisTemplate.opsForValue();
        valueOperations.set(String.valueOf(menu.getId()), menu, Duration.ofSeconds(120));
        return menu;
    }
    @Override
    public Menu updateMenu(Menu menu) {
        menuMapper.updateById(menu);
       // ValueOperations valueOperations = redisTemplate.opsForValue();
        valueOperations.set(String.valueOf(menu.getId()), menu, Duration.ofSeconds(120));
        return menu;
    }
}

第三步:定义用于处理菜单业务的业务接口实现类,基于AOP方式操作redis缓存,比较
与第二步写的Redis操作方式的不同,例如:

package com.jt.service;

import com.jt.dao.MenuMapper;
import com.jt.pojo.Menu;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.annotation.CachePut;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Service;

@Service
public class DefaultMenuService implements MenuService{
    @Autowired
    private MenuMapper menuMapper;

    /**
     * 由此注解描述的方法为切入点方法,此方法执行时,底层会通过AOP机制
     * 先从缓存取数据,缓存有则直接返回,缓存没有则查数据,最后将查询的数据
     * 还会向redis存储一份
     * @param id
     * @return
     */
    @Cacheable(value = "menuCache",key="#id")
    @Override
    public Menu selectById(Long id) {
        return menuMapper.selectById(id);
    }

    /**
     * CachePut注解的意思是更新缓存
     * @param menu
     * @return
     */
    @CachePut(value = "menuCache",key="#menu.id")
    @Override
    public Menu insertMenu(Menu menu) {
         menuMapper.insert(menu);
         return menu;
    }

    @CachePut(value = "menuCache",key="#menu.id")
    @Override
    public Menu updateMenu(Menu menu) {
        menuMapper.updateById(menu);
        return menu;
    }
}
说明,启动AOP方式的缓存应用,需要在启动类上添加@EnableCaching注解:

第四步:定义单元测试类,基于单元测试类测试缓存应用.例如:

package com.jt;

import com.jt.pojo.Menu;
import com.jt.service.MenuService;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.test.context.SpringBootTest;

import javax.annotation.Resource;

@SpringBootTest
public class MenuServiceTests {
    @Autowired
    @Qualifier("defaultMenuService")
    //@Resource(name="defaultMenuService")
    private MenuService menuService;
    @Test
    void testSelectById(){
        Menu menu = menuService.selectById(1L);
        System.out.println(menu);
    }
    @Test
    void testUpdateMenu(){
        Menu menu = menuService.selectById(1L);
        menu.setName("select res");
        menuService.updateMenu(menu);
    }
    @Test
    void testInertMenu(){
        Menu menu = new Menu();
        menu.setName("insert res");
        menu.setPermission("sys:res:insert");
        menuService.insertMenu(menu);
    }
}

第五步:改变AOP方式中redis数据存储时的序列化方式(假如业务上需要).其实现上要借助
CacheManager对象,例如:

package com.jt;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.CacheManager;
import org.springframework.cache.annotation.CachingConfigurerSupport;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;
import org.springframework.data.redis.cache.RedisCacheConfiguration;
import org.springframework.data.redis.cache.RedisCacheManager;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.RedisSerializationContext;
import org.springframework.data.redis.serializer.RedisSerializer;

/**
 * 重构CacheManager对象,其目的是改变AOP方式应用redis的序列化和反序列化的方式.
 */
@Configuration
public class CacheManagerConfig {
    /**
     * 重构CacheManager对象
     * @return
     */
    @Bean
    public CacheManager cacheManager(RedisConnectionFactory redisConnectionFactory) {
        //定义RedisCache配置
        RedisCacheConfiguration cacheConfig=
                RedisCacheConfiguration.defaultCacheConfig()
        //定义key的序列化方式
        .serializeKeysWith(
                RedisSerializationContext.
                   SerializationPair.fromSerializer(RedisSerializer.string()))
        //定义value的序列化方式
        .serializeValuesWith(
                RedisSerializationContext.SerializationPair
                .fromSerializer(RedisSerializer.json()));

        return  RedisCacheManager.builder(redisConnectionFactory)
               .cacheDefaults(cacheConfig)
               .build();//建造者模式(复杂对象的创建,建议使用这种方式,封装了对象的创建细节)
    }
}

写好这个对象后,可以再次基于MenuService中的方法进行单元测试,检测redis数据的存储.

Controller逻辑对象设计及实现
第一步:定义Controller处理,处理客户端对菜单数据的请求操作,例如:

package com.jt.controller;
import com.jt.pojo.Menu;
import com.jt.service.MenuService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.web.bind.annotation.*;
@RestController
@RequestMapping("/menu")
public class MenuController{
    @Autowired
    @Qualifier("defaultMenuService")
    private MenuService menuService;

    @GetMapping("/{id}")
    public Menu doSelectById(@PathVariable("id") Long id){
        return menuService.selectById(id);
    }
    @PutMapping
    public String doUpdate(@RequestBody Menu menu){
         menuService.updateMenu(menu);
         return "update ok";
    }
    @PostMapping
    public String doInsert(@RequestBody Menu menu){
        menuService.insertMenu(menu);
        return "insert ok";
    }
}

第二步:打开postman进行访问测试.检测redis数据存储与更新