spring+redis+mysql做缓存操作

idea创建普通java项目

修改pom.xml文件

<?xml version="1.0" encoding="UTF-8"?>


  4.0.0

  com.sxt
  03redis-spring-mysql
  1.0

  03redis-spring-mysql
  
  http://www.example.com


  
    UTF-8
    1.7
    1.7
    3.5.2
    2.0.2
    4.3.24.RELEASE
    1.0.18
    8.0.17
    1.2.59
    
    1.2.17
    3.1.0
1.18.10

  

  
    
    
      org.mybatis
      mybatis
      ${mybatis.version}
    
    
    
      org.mybatis
      mybatis-spring
      ${mybatis-spring.version}
    
    
    
      org.springframework
      spring-aspects
      ${spring.version}
    
    
      org.springframework
      spring-aop
      ${spring.version}
    
    
      org.springframework
      spring-context-support
      ${spring.version}
    
    
      org.springframework
      spring-context
      ${spring.version}
    
    
      org.springframework
      spring-core
      ${spring.version}
    
    
      org.springframework
      spring-jdbc
      ${spring.version}
    
    
    
      mysql
      mysql-connector-java
      ${mysql.version}
    
    
    
      com.alibaba
      fastjson
      ${fastjson.version}
    
    
    
      log4j
      log4j
      ${log4j.version}
    
    
      redis.clients
      jedis
      ${jedis.version}
    


  org.projectlombok
  lombok
  ${lombok.verison}
  provided



  

  
    
      
        
        
          maven-clean-plugin
          3.1.0
        
        
        
          maven-resources-plugin
          3.0.2
        
        
          maven-compiler-plugin
          3.8.0
        
        
          maven-surefire-plugin
          2.22.1
        
        
          maven-jar-plugin
          3.0.2
        
        
          maven-install-plugin
          2.5.2
        
        
          maven-deploy-plugin
          2.8.2
        
        
        
          maven-site-plugin
          3.7.1
        
        
          maven-project-info-reports-plugin
          3.0.0
        
      
    
  

我这里用的是Mybatisgenerator插件

生成User实体类

import java.io.Serializable;
import java.util.Date;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@AllArgsConstructor
@NoArgsConstructor
public class User implements Serializable {
    /**
    * 用户编号
    */
    private Integer id;

    /**
    * 用户姓名
    */
    private String name;

    /**
    * 用户地址
    */
    private String address;

    /**
    * 出生时间
    */
    private Date birth;

    /**
    * 是否删除1删除0未删除
    */
    private Integer flag;

    private static final long serialVersionUID = 1L;
}

生成UserMapper

import com.sxt.domain.User;

import java.util.List;

public interface UserMapper {
    int deleteByPrimaryKey(Integer id);

    int insert(User record);

    int insertSelective(User record);

    User selectByPrimaryKey(Integer id);

    int updateByPrimaryKeySelective(User record);

    int updateByPrimaryKey(User record);

    List queryAllUser();
}

生成UserMapper.xml

<?xml version="1.0" encoding="UTF-8"?>


  
    
    
    
    
    
    
    
  
  
    
    id, `name`, address, birth, flag
  
  
    
    select 
    
    from sys_user
    where id = #{id,jdbcType=INTEGER}
  
  
    
    delete from sys_user
    where id = #{id,jdbcType=INTEGER}
  
  
    
    insert into sys_user (`name`, address, birth, 
      flag)
    values (#{name,jdbcType=VARCHAR}, #{address,jdbcType=VARCHAR}, #{birth,jdbcType=DATE}, 
      #{flag,jdbcType=INTEGER})
  
  
    
    insert into sys_user
    
      
        `name`,
      
      
        address,
      
      
        birth,
      
      
        flag,
      
    
    
      
        #{name,jdbcType=VARCHAR},
      
      
        #{address,jdbcType=VARCHAR},
      
      
        #{birth,jdbcType=DATE},
      
      
        #{flag,jdbcType=INTEGER},
      
    
  
  
    
    update sys_user
    
      
        `name` = #{name,jdbcType=VARCHAR},
      
      
        address = #{address,jdbcType=VARCHAR},
      
      
        birth = #{birth,jdbcType=DATE},
      
      
        flag = #{flag,jdbcType=INTEGER},
      
    
    where id = #{id,jdbcType=INTEGER}
  
  
    
    update sys_user
    set `name` = #{name,jdbcType=VARCHAR},
      address = #{address,jdbcType=VARCHAR},
      birth = #{birth,jdbcType=DATE},
      flag = #{flag,jdbcType=INTEGER}
    where id = #{id,jdbcType=INTEGER}
  

  
    
    select
    
    from sys_user

    

生成UserService

import com.sxt.domain.User;

import java.util.List;

public interface UserService{


    int deleteByPrimaryKey(Integer id);

    User insert(User user);


    User selectByPrimaryKey(Integer id);


    User updateByPrimaryKey(User user);

    List queryAllUser();

}

生成UserServiceImpl

import com.sxt.domain.User;
import com.sxt.mapper.UserMapper;
import com.sxt.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;

@Service
public class UserServiceImpl implements UserService{

    @Autowired
    private UserMapper userMapper;


    @Override
    public int deleteByPrimaryKey(Integer id) {
        return this.userMapper.deleteByPrimaryKey(id);
    }

    @Override
    public User insert(User user) {
        this.userMapper.insert(user);
        return user;
    }

    @Override
    public User selectByPrimaryKey(Integer id) {
        return this.userMapper.selectByPrimaryKey(id);
    }

    @Override
    public User updateByPrimaryKey(User user) {
        int index = this.userMapper.updateByPrimaryKey(user);
        return user;
    }

    @Override
    public List queryAllUser() {
        return this.userMapper.queryAllUser();
    }
}

创建application-redis.xml

<?xml version="1.0" encoding="UTF-8"?>


    
    
        
        
        
        
        
    
    
    
        
        
        
        
        
        
    

创建db.properties

driverClassName=com.mysql.cj.jdbc.Driver
url=jdbc:mysql://127.0.0.1:3306/redis-test?useUnicode=true&characterEncoding=UTF-8&serverTimezone=UTC
username=root
password=317311

创建log4j的配置文件

# Global logging configuration
log4j.rootLogger=DEBUG, stdout
# MyBatis logging configuration...
log4j.logger.org.mybatis.example.BlogMapper=TRACE
# Console output...
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%5p [%t] - %m%n

创建application-dao.xml

<?xml version="1.0" encoding="UTF-8"?>


    
    

    
    
        
        
        
        
        
    
    
    
        
        
        
        
            
                classpath:mapper/*Mapper.xml
            
        
    

    
    
        
        
            
                com.sxt.mapper
            
        
        
        
    

创建application-service.xml

<?xml version="1.0" encoding="UTF-8"?>


    

    
    
        
    
    
    
    
    
        
            
            
            
            
            
            
            
            
            
            
            
        
    
    
    
        
        
        
        
    

创建CacheUserAspect（切面）

package com.sxt.cache;

import com.alibaba.fastjson.JSON;
import com.sxt.domain.User;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.EnableAspectJAutoProxy;
import org.springframework.stereotype.Component;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;

import java.io.Serializable;

/**
 * @program: redis-code
 * @author: 雷哥
 * @create: 2019-12-31 16:39
 **/
@Component
@Aspect
@EnableAspectJAutoProxy
public class CacheUserAspect {


    private Log log= LogFactory.getLog(CacheUserAspect.class);

    public static final String POINTCUT_ADD="execution(* com.sxt.service.impl.UserServiceImpl.insert(..))";
    public static final String POINTCUT_UPDATE="execution(* com.sxt.service.impl.UserServiceImpl.updateByPrimaryKey(..))";
    public static final String POINTCUT_DELETE="execution(* com.sxt.service.impl.UserServiceImpl.deleteByPrimaryKey(..))";
    public static final String POINTCUT_GETONE="execution(* com.sxt.service.impl.UserServiceImpl.selectByPrimaryKey(..))";

    //redis里面的前缀
    public static final String PROFIX="user:";

    //注入JedisPool
    @Autowired
    private JedisPool jedisPool;



    @Around(value = CacheUserAspect.POINTCUT_ADD)
    public Object cacheAddUser(ProceedingJoinPoint pjp) throws Throwable {
        //插入数据库
        User user = (User) pjp.proceed();
        Jedis jedis = jedisPool.getResource();

        //把user转成json串
        String json= JSON.toJSONString(user);
        jedis.set(PROFIX+user.getId(),json);
        log.info(PROFIX+user.getId()+"数据已存入到Redis");
        jedis.close();
        return user;
    }

    @Around(value = CacheUserAspect.POINTCUT_UPDATE)
    public Object cacheUpdateUser(ProceedingJoinPoint pjp) throws Throwable {
        //修改数据库
        User user = (User) pjp.proceed();
        Jedis jedis = jedisPool.getResource();
        //把user转成json串
        String json= JSON.toJSONString(user);
        jedis.set(PROFIX+user.getId(),json);
        log.info(PROFIX+user.getId()+"数据已更新到Redis");
        jedis.close();
        return user;
    }

    @Around(value = CacheUserAspect.POINTCUT_DELETE)
    public Object cacheDeleteUser(ProceedingJoinPoint pjp) throws Throwable {
        //删除数据库
        Serializable id = (Serializable) pjp.getArgs()[0];
        log.info(PROFIX+id+"数据库数据已删除");
        Jedis jedis = jedisPool.getResource();
        if(jedis.exists(PROFIX+id)){
            jedis.del(PROFIX+id);
            log.info(PROFIX+id+"数据已从Redis删除");
        }
        jedis.close();
        return id;
    }

    @Around(value = CacheUserAspect.POINTCUT_GETONE)
    public Object cacheGetOneUser(ProceedingJoinPoint pjp) throws Throwable {
        Serializable id = (Serializable) pjp.getArgs()[0];
        if(null==id){
            return null;
        }
        Jedis jedis = jedisPool.getResource();
        String json = jedis.get(PROFIX + id);
        if(null!=json){
            User user=JSON.parseObject(json,User.class);
            log.info(PROFIX+id+"已从redis里机查询到数据");
            jedis.close();
            return user;
        }else{
            log.info(PROFIX+id+"缓存里面没有数据，要从数据库里面查询");
            User user= (User) pjp.proceed();
            if(null!=user){
                jedis.set(PROFIX+user.getId(),JSON.toJSONString(user));
                log.info(PROFIX+id+"数据已存入redis");
            }
            jedis.close();
            return  user;
        }
    }
}

创建application-cache.xml

<?xml version="1.0" encoding="UTF-8"?>


    

创建applicationContext.xml

<?xml version="1.0" encoding="UTF-8"?>



    
    
    
    

测试

public class TestApp {

    public static void main(String[] args) {
        ApplicationContext context=new ClassPathXmlApplicationContext("classpath:applicationContext.xml");

        UserService userService = context.getBean(UserService.class);

        User user=new User();
        user.setName("张三");
        user.setAddress("株洲");
        user.setBirth(new Date());
        user.setFlag(1);
        userService.insert(user);
        System.out.println("成功");
    }
}