SpringBoot整合Mysql、Redis_路上的追梦人的博客-CSDN博客_mysql和redis springboot

spring boot + mysql +mybatis +redis（二级缓存）实例_JasonHector的博客-CSDN博客

一、项目创建

1.1 创建项目

  1. 在IDEA中，File--New--Project--Spring Initializer
  2. 名称为springboot-mysql-redis

[Docker] SpringBoot整合Mysql、Redis - 图1

1.2 目录结构

[Docker] SpringBoot整合Mysql、Redis - 图2

1.3 application配置文件

  1. spring:
  2.   datasource:
  3.     driver-class-name: com.mysql.cj.jdbc.Driver
  4.     url: jdbc:mysql://localhost:3306/mybatis?serverTimezone=UTC
  5.     username: root
  6.     password: 1234
  8.   redis:
  9.     host: localhost
  10.     port: 6379
  11.     password: 1234
  14. server:
  15.   port: 8080
  17. mybatis:
  18.   mapper-locations: classpath:mapper/*xml
  19.   type-aliases-package: com.xsbc.entity
  20.   # 开启驼峰命名
  21.   configuration:
  22.     map-underscore-to-camel-case: true

二、初始化数据库

  1. drop database if exists blog;
  2. create database blog;
  3. user blog;
  4. drop table if exists user;
  5. create table user(
  6.     id int(11) not null,
  7.     name varchar(255) DEFAULT "",
  8.     age int(11) DEFAULT 0,
  9.     PRIMARY KEY(id)
  10. )ENGINE=INNODB DEFAULT CHARSET=utf8;
  12. insert into user values(1,'小王',20);
  13. insert into user values(2,'老李',23);

三、初始化代码

3.1 实体类entity

  1. @Data
  2. @NoArgsConstructor
  3. @AllArgsConstructor
  4. public class User {
  5.     private int id;
  6.     private String name;
  7.     private int age;
  8. }

3.2 Mapper接口类

  1. @Mapper
  2. public interface UserMapper {
  3.     List<User> getAllUsers();
  4.     int updateUser(Integer id);
  5. }
  • xml 映射文件
  1. <?xml version="1.0" encoding="UTF-8" ?>
  2. <!DOCTYPE mapper
  3.         PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
  4.         "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
  5. <mapper namespace="com.xsbc.mapper.UserMapper">
  6.     <select id="getAllUsers" resultType="com.xsbc.entity.User">
  7.         select * from user
  8.     </select>
  10.     <!--   User类的id参数是int类型，mysql默认是Integer -->
  11.     <update id="updateUserAgeById" parameterType="java.lang.Integer">
  12.         update user set age=age+2 where id=#{id}
  13.     </update>
  14. </mapper>

3.3 Redis 工具类

1）config 包创建类

Redis常量类RedisConstant

  1. public class RedisConstant {
  2.     public static String ALL_USER_KEY="allUser";
  3. }

Redis常量类RedisConstant

  1. @Configuration
  2. public class RedisConfig {
  3.     @Resource
  4.     private RedisTemplate redisTemplate;
  6.     @Bean
  7.     public RedisTemplate redisTemplateInit(){
  8.         //序列化key的实例化对象
  9.         redisTemplate.setKeySerializer(new StringRedisSerializer());
  10.         //序列化value的实例化对象
  11.         redisTemplate.setValueSerializer(
  12.             new GenericJackson2JsonRedisSerializer());
  13.         return redisTemplate;
  14.     }
  15. }

2）util包下创建类

  1. @Component
  2. public class RedisUtil {
  3.     @Resource
  4.     private RedisTemplate<String,Object> redisTemplate;
  6.     public void setRedisTemplate(RedisTemplate<String,Object> redisTemplate){
  7.         this.redisTemplate=redisTemplate;
  8.     }
  10.     // 指定缓存失效时间
  11.     public boolean expire(String key,long time) {
  12.         try {
  13.             if (time > 0) {
  14.                 redisTemplate.expire(key, time, TimeUnit.SECONDS);
  15.             }
  16.             return true;
  17.         } catch (Exception e) {
  18.             e.printStackTrace();
  19.             return false;
  20.         }
  21.     }
  23.     // 根据key获取过期时间
  24.     public long getExpire(String key){
  25.         return redisTemplate.getExpire(key,TimeUnit.SECONDS);
  26.     }
  28.     // 判断key是否存在
  29.     public boolean hasKey(String key){
  30.         try {
  31.             return redisTemplate.hasKey(key);
  32.         }catch(Exception e){
  33.             e.printStackTrace();
  34.             return false;
  35.         }
  36.     }
  38.     // 删除缓存
  39.     @SuppressWarnings("unchecked")
  40.     public void del(String... key){
  41.         if (key!=null&&key.length> 0){
  42.             if (key.length==1) {
  43.                 redisTemplate.delete(key[0]);
  44.             }else{
  45.                 redisTemplate.delete(
  46.                     (Collection<String>)CollectionUtils.arrayToList(key));
  47.             }
  48.         }
  49.     }
  51.     // 普通缓存获取
  52.     public Object get(String key){
  53.         return key==null?null:redisTemplate.opsForValue().get(key);
  54.     }
  56.     // 普通缓存放入
  57.     public boolean set(String key,Object value){
  58.         try {
  59.             redisTemplate.opsForValue().set(key,value);
  60.             return true;
  61.         }catch(Exception e){
  62.             e.printStackTrace();
  63.             return false;
  64.         }
  66.     }
  68.     // 普通缓存放入并设置时间
  69.     public boolean set(String key,Object value,long time){
  70.         try{
  71.             if(time>0){
  72.                 redisTemplate.opsForValue()
  73.                 .set(key,value,time,TimeUnit.SECONDS);
  74.             }else{
  75.                 set(key,value);
  76.             }
  77.             return true;
  78.         }catch(Exception e){
  79.             e.printStackTrace();
  80.             return false;
  81.         }
  82.     }
  85.     // 递增
  87.     public long incr(String key,long delta){
  88.         if(delta<0){
  89.             throw new RuntimeException("递增因子必须大于0");
  90.         }
  91.         return redisTemplate.opsForValue().increment(key,delta);
  92.     }
  95.     // 递减
  96.     public long decr(String key, long delta){
  97.         if(delta<0){
  98.             throw new RuntimeException("递减因子必须大于0");
  99.         }
  100.         return redisTemplate.opsForValue().increment(key,-delta);
  101.     }
  104.     // HashGet
  105.     public Object hget(String key,String item){
  106.         return redisTemplate.opsForHash().get(key,item);
  107.     }
  109.     // 获取hashKey对应的所有键值
  110.     public Map<Object, Object> hmget(String key){
  111.         return redisTemplate.opsForHash().entries(key);
  112.     }
  115.     // HashSet
  116.     public boolean hmset(String key,Map<String, Object> map){
  117.         try{
  118.             redisTemplate.opsForHash().putAll(key,map);
  119.             return true;
  120.         }catch(Exception e){
  121.             e.printStackTrace();
  122.             return false;
  123.         }
  124.     }
  126.     // HashSet 并设置时间
  127.     public boolean hmset(String key,Map<String, Object> map,long time){
  128.         try{
  129.             redisTemplate.opsForHash().putAll(key, map);
  130.             if (time>0){
  131.                 expire(key,time);
  132.             }
  133.             return true;
  134.         }catch(Exception e){
  135.             e.printStackTrace();
  136.             return false;
  137.         }
  138.     }
  141.     // 向一张hash表中放入数据,如果不存在将创建
  142.     public boolean hset(String key,String item,Object value){
  143.         try{
  144.             redisTemplate.opsForHash().put(key,item,value);
  145.             return true;
  146.         }catch(Exception e){
  147.             e.printStackTrace();
  148.             return false;
  149.         }
  150.     }
  153.     // 向一张hash表中放入数据,如果不存在将创建
  154.     public boolean hset(String key,String item,Object value,long time){
  155.         try{
  156.             redisTemplate.opsForHash().put(key,item,value);
  157.             if(time>0){
  158.                 expire(key,time);
  159.             }
  160.             return true;
  161.         }catch(Exception e){
  162.             e.printStackTrace();
  163.             return false;
  164.         }
  165.     }
  167.     // 删除hash表中的值
  168.     public void hdel(String key,Object... item) {
  169.         redisTemplate.opsForHash().delete(key,item);
  170.     }
  172.     // 判断hash表中是否有该项的值
  173.     public boolean hHasKey(String key,String item) {
  174.         return redisTemplate.opsForHash().hasKey(key,item);
  175.     }
  177.     // hash递增 如果不存在,就会创建一个 并把新增后的值返回
  178.     public double hincr(String key,String item,double by) {
  179.         return redisTemplate.opsForHash().increment(key,item,by);
  180.     }
  182.     // hash递减
  183.     public double hdecr(String key,String item,double by) {
  184.         return redisTemplate.opsForHash().increment(key,item,-by);
  185.     }
  188.     // 根据key获取Set中的所有值
  189.     public Set<Object> sGet(String key) {
  190.         try{
  191.             return redisTemplate.opsForSet().members(key);
  192.         }catch(Exception e){
  193.             e.printStackTrace();
  194.             return null;
  195.         }
  196.     }
  198.     // 根据value从一个set中查询,是否存在
  199.     public boolean sHasKey(String key,Object value) {
  200.         try{
  201.             return redisTemplate.opsForSet().isMember(key,value);
  202.         }catch(Exception e){
  203.             e.printStackTrace();
  204.             return false;
  205.         }
  206.     }
  208.     // 将数据放入set缓存
  209.     public long sSet(String key,Object... values) {
  210.         try{
  211.             return redisTemplate.opsForSet().add(key,values);
  212.         }catch(Exception e){
  213.             e.printStackTrace();
  214.             return 0;
  215.         }
  216.     }
  218.     // 将set数据放入缓存
  219.     public long sSetAndTime(String key,long time,Object... values){
  220.         try{
  221.             Long count=redisTemplate.opsForSet().add(key,values);
  222.             if (time> 0)expire(key, time);
  223.             return count;
  224.         }catch(Exception e){
  225.             e.printStackTrace();
  226.             return 0;
  227.         }
  228.     }
  231.     // 获取set缓存的长度
  232.     public long sGetSetSize(String key){
  233.         try{
  234.             return redisTemplate.opsForSet().size(key);
  235.         }catch(Exception e){
  236.             e.printStackTrace();
  237.             return 0;
  238.         }
  239.     }
  241.     // 移除值为value的
  242.     public long setRemove(String key,Object... values){
  243.         try{
  244.             Long count=redisTemplate.opsForSet().remove(key,values);
  245.             return count;
  246.         }catch(Exception e){
  247.             e.printStackTrace();
  248.             return 0;
  249.         }
  250.     }
  253.     // 获取list缓存的内容
  254.     public List<Object> lGet(String key,long start,long end){
  255.         try{
  256.             return redisTemplate.opsForList().range(key,start,end);
  257.         }catch(Exception e){
  258.             e.printStackTrace();
  259.             return null;
  260.         }
  261.     }
  263.     // 获取list缓存的长度
  264.     public long lGetListSize(String key){
  265.         try{
  266.             return redisTemplate.opsForList().size(key);
  267.         }catch(Exception e){
  268.             e.printStackTrace();
  269.             return 0;
  270.         }
  271.     }
  273.     // 通过索引 获取list中的值
  274.     public Object lGetIndex(String key,long index){
  275.         try{
  276.             return redisTemplate.opsForList().index(key,index);
  277.         }catch(Exception e){
  278.             e.printStackTrace();
  279.             return null;
  280.         }
  281.     }
  283.     // 将list放入缓存
  284.     public boolean lSet(String key, Object value){
  285.         try{
  286.             redisTemplate.opsForList().rightPush(key,value);
  287.             return true;
  288.         }catch(Exception e){
  289.             e.printStackTrace();
  290.             return false;
  291.         }
  292.     }
  295.     // 将list放入缓存
  296.     public boolean lSet(String key,Object value,long time){
  297.         try{
  298.             redisTemplate.opsForList().rightPush(key,value);
  299.             if (time > 0) expire(key, time);
  300.             return true;
  301.         }catch(Exception e){
  302.             e.printStackTrace();
  303.             return false;
  304.         }
  305.     }
  308.     // 将list放入缓存
  309.     public boolean lSet(String key, List<Object> value){
  310.         try{
  311.             redisTemplate.opsForList().rightPushAll(key,value);
  312.             return true;
  313.         }catch(Exception e){
  314.             e.printStackTrace();
  315.             return false;
  316.         }
  317.     }
  320.     // 将list放入缓存
  321.     public boolean lSet(String key,List<Object> value,long time){
  322.         try{
  323.             redisTemplate.opsForList().rightPushAll(key,value);
  324.             if(time>0) expire(key, time);
  325.             return true;
  326.         }catch(Exception e){
  327.             e.printStackTrace();
  328.             return false;
  329.         }
  330.     }
  333.     // 根据索引修改list中的某条数据
  334.     public boolean lUpdateIndex(String key,long index,Object value){
  335.         try{
  336.             redisTemplate.opsForList().set(key,index,value);
  337.             return true;
  338.         }catch(Exception e){
  339.             e.printStackTrace();
  340.             return false;
  341.         }
  342.     }
  345.     // 移除N个值为value
  346.     public long lRemove(String key,long count,Object value){
  347.         try{
  348.             Long remove=redisTemplate.opsForList().remove(key,count,value);
  349.             return remove;
  350.         }catch(Exception e){
  351.             e.printStackTrace();
  352.             return 0;
  353.         }
  354.     }
  355. }

3.4 Service层

1）UserService接口类

  1. public interface UserService {
  2.     public List<User> getAllUsers();
  3.     public void updateUserAge();
  4. }

2）接口实现类

  1. @Service("userService")
  2. public class UserServiceImpl implements UserService {
  3.     @Resource
  4.     private UserMapper userMapper;
  6.     @Autowired
  7.     private RedisUtil redisUtil;
  9.     @Override
  10.     public List<User> getAllUsers() {
  11.         List<User> users=(List<User>)redisUtil
  12.                           .get(RedisConstant.ALL_USER_KEY);
  13.         if(CollectionUtils.isEmpty(users)){
  14.             users=userMapper.getAllUsers();
  15.             redisUtil.set(RedisConstant.ALL_USER_KEY,users);
  16.         }
  17.         return users;
  18.     }
  20.     @Override
  21.     @Transactional
  22.     public void updateUserAge() {
  23.         redisUtil.del(RedisConstant.ALL_USER_KEY);
  24.         userMapper.updateUserAgeById(1);
  25.         userMapper.updateUserAgeById(2);
  26.     }
  27. }

3.5 Controller层

  1. @Controller
  2. public class UserController {
  3.     @Autowired
  4.     private UserService userService;
  6.     @RequestMapping("/getAll")
  7.     @ResponseBody
  8.     public List<User> getUsers(){
  9.         return userService.getAllUsers();
  10.     }
  12.     @RequestMapping("/update")
  13.     @ResponseBody
  14.     public int updateUser(){
  15.         userService.updateUserAge();
  16.         return 1;
  17.     }
  18. }

四、单元测试

4.1 Respository和Service层单元测试

  1. @SpringBootTest
  2. class SpringbootMysqlRedisApplicationTests {
  4.     @Autowired
  5.     private UserMapper userMapper;
  7.     @Autowired
  8.     private UserService userService;
  10.     @Test
  11.     void testUserMapper(){
  12.         userMapper.updateUserAgeById(1);
  13.         List<User> users=userMapper.getAllUsers();
  14.         for(User user:users){
  15.             System.out.println(user);
  16.         }
  17.     }
  19.     @Test
  20.     void testUserService(){
  21.         userService.updateUserAge();
  22.         List<User> users=userService.getAllUsers();
  23.         for(User user:users){
  24.             System.out.println(user);
  25.         }
  26.     }
  27. }

4.2 Controller层接口测试

[Docker] SpringBoot整合Mysql、Redis - 图3