使用Spring-data-redis框架 注解 集成spring与redis

环境：项目采用springMvc+spring4.25+hibernate5.08+Mysql 

目的：将Redis作为缓存数据库,具体Redis的优势网上都有，就不在赘述了。

1.所需jar包 

除了spring以及与hibnenate 相关的依赖包外  spring-data-redis-1.7.2.RELEASE.jar     jedis-2.9.0.jar

commons-pool2-2.5.0.jar redis配置线程池

2.配置文件

springMVC.xml  

    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context"
    xmlns:mvc="http://www.springframework.org/schema/mvc"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
            http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
            http://www.springframework.org/schema/context
            http://www.springframework.org/schema/context/spring-context-4.0.xsd
            http://www.springframework.org/schema/mvc
            http://www.springframework.org/schema/mvc/spring-mvc-4.0.xsd">
   
   
   
   
     

            class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter">
       
           
                text/html;charset=UTF-8
           
       
        
   
    
    
    
        
      
   
            class="org.springframework.web.servlet.view.InternalResourceViewResolver">
       
       
       
       
   
    
   
        
            
                error
            
        
        

   
            class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
       
       
       
       
       
       
   

springCore2.xml

xmlns:cache="http://www.springframework.org/schema/cache"  
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:tx="http://www.springframework.org/schema/tx"
    xmlns:aop="http://www.springframework.org/schema/aop" xmlns:context="http://www.springframework.org/schema/context"
    xmlns:task="http://www.springframework.org/schema/task"
    xsi:schemaLocation="
        http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
        http://www.springframework.org/schema/tx
        http://www.springframework.org/schema/tx/spring-tx-4.0.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context-4.0.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop-4.0.xsd
        http://www.springframework.org/schema/task  
        http://www.springframework.org/schema/task/spring-task-4.0.xsd
        http://www.springframework.org/schema/cache
        http://www.springframework.org/schema/cache/spring-cache-4.0.xsd">     
    
   
     
    
    
   
    
     
          
   
    
    
    
      
     
         
            classpath:public.properties  
         
     
    
    
            class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
        
            
                classpath:jdbc.properties
                classpath:redis.properties
            
        
        
    
    
        
        
        
        
        
        
        
    
    
    
            destroy-method="close">
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
        
    
    
            class="org.springframework.orm.hibernate5.LocalSessionFactoryBean">
        
        
        
        
            
                ${hibernate.dialect}
                ${hibernate.show_sql}
                ${hibernate.format_sql}
                ${hibernate.hbm2ddl.auto}
                
                ${hibernate.cache.use_second_level_cache}
                ${hibernate.cache.use_query_cache}
                ${hibernate.cache.region.factory_class}
                ${hibernate.cache.provider_configuration_file_resource_path}
                
                false
            
        
        
        
    

    
            class="org.springframework.orm.hibernate5.HibernateTransactionManager">
        
    
    
    
    
    
        
        
    
    
    
    
        
                    
            
            
            
            
            
            
            
            
                            
        
    
    
      
   

   
       
   
    
        
        
            
         
         
         
            
            
         
           
         
           
         
           
            
            
         
            
     
      
     
     
           
         
           
         
           
         
         
         
           
        
      
     
        
            
            
            
                
            
            
                
            
            
                
            
            
                
            
         
         
        
      
 
 
     
 
 

 

redis.properties

redis.hostName=127.0.0.1  
redis.port=6379  
redis.password=  
redis.timeout=10000  
redis.maxIdle=300  
redis.maxTotal=1000  
redis.maxWaitMillis=1000  
redis.minEvictableIdleTimeMillis=300000  
redis.numTestsPerEvictionRun=1024  
redis.timeBetweenEvictionRunsMillis=30000  
redis.testOnBorrow=true  

redis.testWhileIdle=true

3.实现代码

RedisCacheUser.java 实体类 对应Mysql字段

@Entity
@Table(name="rediscacheuser")
public class RedisCacheUser {


    //用户ID
    private String redisuserid;
    //名字
    private String  redisusername;
    //密码
    private String  redispassword;    
    //ID
    private String  redisddid;
    //用户电话
    private String  redismobile;
    
    public RedisCacheUser(){        
    }

    @Id    
    public String getUserid() {
        return  redisuserid;
    }

    public void setUserid(String userid) {
        this. redisuserid = userid;
    }

    @Column(name="USERNAME",nullable=false,length=32)
    public String getUsername() {
        return  redisusername;
    }

    public void setUsername(String username) {
        this. redisusername = username;
    }

    @Column(name="PASSWORD",nullable=false,length=64)
    public String getPassword() {
        return  redispassword;
    }

    public void setPassword(String password) {
        this. redispassword = password;
    }

    @Column(name="DDID",nullable=false,length=128)
    public String getDdid() {
        return  redisddid;
    }

    public void setDdid(String ddid) {
        this.redisddid = ddid;
    }

    @Column(name="MOBILE",length=32)
    public String getMobile() {
        return  redismobile;
    }

    public void setMobile(String mobile) {
        this.redismobile = mobile;
    }

    @Override
    public String toString() {
        return "RedisCacheUser [redisuserid=" + redisuserid + ", redisusername=" + redisusername + ", redispassword="
                + redispassword + ", redisddid=" + redisddid + ", redismobile=" + redismobile + ", getUserid()="
                + getUserid() + ", getUsername()=" + getUsername() + ", getPassword()=" + getPassword() + ", getDdid()="
                + getDdid() + ", getMobile()=" + getMobile() + ", getClass()=" + getClass() + ", hashCode()="
                + hashCode() + ", toString()=" + super.toString() + "]";
    }
       
}

RedisCacheTestService.java  BaseTxService 里面封装了hibernate操作 可以通过hibernateTemplate操作Mysql

@Service
public class RedisCacheTestService extends BaseTxService {
    
    @CachePut(key="#redisCacheUser.getUserid()",value="RedisCacheUser")
    public String addRedisCacheTestUser(RedisCacheUser redisCacheUser) {
        this.hibernateTemplate.save(redisCacheUser);
        return JSONObject.fromObject(redisCacheUser).toString();
    }
    @CachePut(key="#redisCacheUser.getUserid()",value="RedisCacheUser")
    public RedisCacheUser addRedisCacheTestUser1(RedisCacheUser redisCacheUser) {
        this.hibernateTemplate.save(redisCacheUser);
        return redisCacheUser;
    }
    /**
     * 根据userId查询对象  先从缓存 没有则再数据库
     * @param userId
     * @return
     */
    @Cacheable(key="#userId",value="RedisCacheUser")
    @SuppressWarnings("unchecked")
    public String  getRedisCacheUserByuserId(String userId) {
        
            String string = getRedisCacheUserByuserIdDB(userId);
            return string;
    }
    public String getRedisCacheUserByuserIdDB(String userId) {
        List   redisCacheUsers = new ArrayList () ;
        RedisCacheUser  redisCacheUser = new RedisCacheUser() ;
        redisCacheUsers =   (List) this.hibernateTemplate.find("from RedisCacheUser where userid = '" + userId + "'");
        if(redisCacheUsers.size()>0) {
            redisCacheUser = redisCacheUsers.get(0);
            return JSONObject.fromObject(redisCacheUser).toString();
        }
        return null;
    }
    /**
     * 根据userName模糊查询多个对象  先从缓存 没有则再数据库
     * @param userId
     * @return
     */
    /*@Cacheable(key="#username",value="RedisCacheUser")
    @SuppressWarnings("unchecked")*/
    public String  getRedisCacheUsers(String username) {
        
            String string = getRedisCacheUsersDB(username);
            return string;
    }
    public String getRedisCacheUsersDB(String username) {
        List   redisCacheUsers = new ArrayList () ;
        RedisCacheUser  redisCacheUser = new RedisCacheUser() ;
        redisCacheUsers =   (List) this.hibernateTemplate.find("from RedisCacheUser where username like '%" + username + "%'");
        if(redisCacheUsers.size()>0) {
            System.out.println("redisCacheUsers:"+redisCacheUsers);
            return JSONObject.fromObject(redisCacheUsers).toString();
            
        }
        return null;
    }
    /**
     * 根据userName模糊查询多个对象  先从缓存 没有则再数据库
     * @param username
     * @return List
     */
    /*@Cacheable(key="#username",value="RedisCacheUser")
    @SuppressWarnings("unchecked")*/
    public List  getRedisCacheUsers1(String username) {
        List   redisCacheUsers = new ArrayList () ;
        redisCacheUsers =   (List) this.hibernateTemplate.find("from RedisCacheUser where username like '%" + username + "%'");
        return redisCacheUsers;
    }
    /**
     * 根据userId删除对象
     * @param userId
     * @return
     */
    @CacheEvict(key="#redisCacheUser.getUserid()",value="RedisCacheUser")
    public Boolean deleteRedisCacheUserByuserId(RedisCacheUser redisCacheUser) {
        
        this.hibernateTemplate.delete(redisCacheUser);
        // TODO Auto-generated method stub
        return true;

    }

/**
     * 清空所有缓存  只是清除了Redis中的RedisCacheUser 但要删除数据库的需自己实现
     * @return
     */
    @CacheEvict(value="RedisCacheUser",allEntries=true)
    public void deleteRedisCacheUsers() {
        // TODO Auto-generated method stub
        
    }

}

RedisCacheTest.java  使用Junit4测试

/**
 * 测试redis缓存和Mysql的增删查改DEMO JUnit测试
 * @author Administrator
 *
 */
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = { "classpath:springCore2.xml", "classpath:springMVC.xml" })
public class RedisCacheTest {
    
    @Autowired
    private RedisCacheTestService redisCacheTestService;
    /**
     * 新增一条对象 缓存Redis为String的
     */

    public void saveUser() {
        RedisCacheUser user= new RedisCacheUser();                    
        //构造数据
        user.setUserid("2");
        user.setDdid("1111");
        user.setMobile("183213123");
        user.setPassword("root");
        user.setUsername("root");    
        redisCacheTestService.addRedisCacheTestUser(user);
    }
    /**
     *根据ID获取String的
     */
    public void getUserById() {    
        RedisCacheUser user= new RedisCacheUser();    
        String string  = redisCacheTestService.getRedisCacheUserByuserId("13");
        if(Objects.equals(string, null)) {
            System.out.println("空空");
        }else {
            System.out.println(string);
        }
    }
    /**
     * 根据name 获取多个user string的
     */
    public void getUsers() {    
        RedisCacheUser user= new RedisCacheUser();    
        String string  = redisCacheTestService.getRedisCacheUsers("root");
        if(Objects.equals(string, null)) {
            System.out.println("空空");
        }else {
            System.out.println(string);
        }
    }
    /**
     * 新增一个缓存对象
     */
    public void saveUser1() {
        RedisCacheUser user= new RedisCacheUser();                    
        //构造数据
        user.setUserid("3");
        user.setDdid("1111");
        user.setMobile("183213123");
        user.setPassword("root");
        user.setUsername("root");
        
        redisCacheTestService.addRedisCacheTestUser1(user);
    }
    /**
     * 根据name返回对象List的
     */
    public void getUsers1() {    
        RedisCacheUser user= new RedisCacheUser();    
        List  redisCacheUsers= new ArrayList ();
        redisCacheUsers  = redisCacheTestService.getRedisCacheUsers1("root");
    
        if(redisCacheUsers.size()>0) {
            System.out.println(JSONArray.fromObject(redisCacheUsers));
        }else {
            System.out.println("空空");
            
        }
    }
    /**
     * 删除Mysql数据库和Redis一个User对象
     */
    
    public void deleteUser() {    
        //ArrayList