springboot+hibernate+springmvc+mysql+redis

这里跟大家分享一个ssh集成redis的小案例，本人在这上面吃了不少苦头啊，希望我们程序同胞们能少走弯路啊！很简单，看下面demo

在pom文件中加入redis相关的jar包和依赖项：

​
 <parent>
    <groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-starter-parent</artifactId>
	<version>2.0.4.RELEASE</version>
	<relativePath /> 
</parent>
<dependencys>
<dependency>
<artifactId>spring-boot-starter-data-redis</artifactId>
    <exclusions>
        <exclusion>
            <groupId>redis.clients</groupId>
            <artifactId>jedis</artifactId>
        </exclusion>
        <exclusion>
            <groupId>io.lettuce</groupId>
            <artifactId>lettuce-core</artifactId>
        </exclusion>
    </exclusions>
</dependency>
<dependency>
    <groupId>redis.clients</groupId>
    <artifactId>jedis</artifactId>
</dependency>
</dependencys>

​

application.properties文件中reids配置项，也有的使用yml文件设置的，其实两种文件设置的东西是一样的：

spring.redis.database=0//redis默认为第0个数据库
spring.redis.host=127.0.0.1
spring.redis.port=6379
spring.redis.password=//密码一般没有
spring.redis.pool.max-active=8
spring.redis.pool.max-wait=-1
spring.redis.pool.max-idle=8
spring.redis.pool.min-idle=0
spring.redis.timeout=50

然后是redis的config文件配置，我们在这里采用的是类文件方式，我在学校的时候是用的xml文件的方式，个人觉得xml简单一些：

@Configuration
@EnableCaching
public class RedisConfig extends CachingConfigurerSupport {
	/**
    * 注入 RedisConnectionFactory
    */
   @Autowired
   RedisConnectionFactory redisConnectionFactory;

   /**
    * 实例化 RedisTemplate 对象
    *
    * @return
    */
   @Bean
   public RedisTemplate<String, Object> functionDomainRedisTemplate() {
       RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
       initDomainRedisTemplate(redisTemplate, redisConnectionFactory);
       return redisTemplate;
   }

   /**
    * 设置数据存入 redis 的序列化方式
    *
    * @param redisTemplate
    * @param factory
    */
   private void initDomainRedisTemplate(RedisTemplate<String, Object> redisTemplate, RedisConnectionFactory factory) {
       //定义key生成策略
       redisTemplate.setKeySerializer(new StringRedisSerializer());
       redisTemplate.setHashKeySerializer(new StringRedisSerializer());
       redisTemplate.setHashValueSerializer(new JdkSerializationRedisSerializer());
       redisTemplate.setValueSerializer(new JdkSerializationRedisSerializer());
       redisTemplate.setConnectionFactory(factory);
   }

   /**
    * 缓存管理器
    * @param redisTemplate
    * @return
    *//*
   @Bean
   public CacheManager cacheManager(RedisTemplate<?,?> redisTemplate) {
          CacheManager cacheManager = new RedisCacheManager(redisTemplate);
          return cacheManager;
   }
*/
   /**
    * 实例化 HashOperations 对象,可以使用 Hash 类型操作
    *
    * @param redisTemplate
    * @return
    */
   @Bean
   public HashOperations<String, String, Object> hashOperations(RedisTemplate<String, Object> redisTemplate) {
       return redisTemplate.opsForHash();
   }

   /**
    * 实例化 ValueOperations 对象,可以使用 String 操作
    *
    * @param redisTemplate
    * @return
    */
   @Bean
   public ValueOperations<String, Object> valueOperations(RedisTemplate<String, Object> redisTemplate) {
       return redisTemplate.opsForValue();
   }

   /**
    * 实例化 ListOperations 对象,可以使用 List 操作
    *
    * @param redisTemplate
    * @return
    */
   @Bean
   public ListOperations<String, Object> listOperations(RedisTemplate<String, Object> redisTemplate) {
       return redisTemplate.opsForList();
   }

   /**
    * 实例化 SetOperations 对象,可以使用 Set 操作
    *
    * @param redisTemplate
    * @return
    */
   @Bean
   public SetOperations<String, Object> setOperations(RedisTemplate<String, Object> redisTemplate) {
       return redisTemplate.opsForSet();
   }

   /**
    * 实例化 ZSetOperations 对象,可以使用 ZSet 操作
    *
    * @param redisTemplate
    * @return
    */
   @Bean
   public ZSetOperations<String, Object> zSetOperations(RedisTemplate<String, Object> redisTemplate) {
       return redisTemplate.opsForZSet();
   }
}

实体类  注解标注@Entity @Table（name="你的实体表名"）：

@Entity
@Table(name="camerainfo")
public class CameraInfo implements Serializable {
	/**
	 * 
	 */
	private static final long serialVersionUID = 1L;

	@Id
	private String id;
	
	private String name;
	private String imagsa_ip;
	private String remark;
	
	private String redisKey;//redis中的key
	public String getRedisKey() {
        return redisKey;
    }

    public void setRedisKey(String keyStr) {
        this.redisKey = "user_"+keyStr;
    }
	public String getId() {
		return id;
	}

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

	public String getName() {
		return name;
	}

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

	public String getImagsa_ip() {
		return imagsa_ip;
	}

	public void setImagsa_ip(String imagsa_ip) {
		this.imagsa_ip = imagsa_ip;
	}

	public String getRemark() {
		return remark;
	}

	public void setRemark(String remark) {
		this.remark = remark;
	}

	public CameraInfo(String id, String name, String imagsa_ip, String remark) {
		super();
		this.id = id;
		this.name = name;
		this.imagsa_ip = imagsa_ip;
		this.remark = remark;
	}

	public CameraInfo() {
		super();
	}

	@Override
	public String toString() {
		return "CameraInfo [id=" + id + ", name=" + name + ", imagsa_ip=" + imagsa_ip + ", remark=" + remark + "]";
	}


	
}

redis服务类 用注解@Service标注：

@Service
public abstract class RedisServer<T> {

    /**
     * 实例化 RedisTemplate对象
     */
    @Autowired
    protected RedisTemplate<String, Object> redisTemplate;

    /**
     * 定义Hash结构 操作存储实体对象
     */
    @Resource
    protected HashOperations<String, String, T> hashOperations;

    /**
     * 定义Hash表的redis key名称
     *
     * @return
     */
    protected abstract String getRedisKey();

    /**
     * 在相应Hash表中添加键值对 key:Object(doamin)
     *
     * @param key    key
     * @param doamin 对象
     * @param expire 过期时间(单位:秒),传入 -1 时表示不设置过期时间
     */
    public void put(String key, T doamin, long expire) {
        hashOperations.put(getRedisKey(), key, doamin);
        if (expire != -1) {
            redisTemplate.expire(getRedisKey(), expire, TimeUnit.SECONDS);
        }
    }

    /**
     * 在相应Hash表中删除key名称的元素
     *
     * @param key 传入key的名称
     */
    public void remove(String key) {
        hashOperations.delete(getRedisKey(), key);
    }

    /**
     * 在相应Hash表中查询key名称的元素
     *
     * @param key 查询的key
     * @return
     */
    public T get(String key) {
        return hashOperations.get(getRedisKey(), key);
    }

    /**
     * 获取在相应Hash表下的所有实体对象
     *
     * @return
     */
    public List<T> getAll() {
        return hashOperations.values(getRedisKey());
    }

    /**
     * 查询在相应Hash表下的所有key名称
     *
     * @return
     */
    public Set<String> getKeys() {
        return hashOperations.keys(getRedisKey());
    }

    /**
     * 判断在相应Hash表下key是否存在
     *
     * @param key 传入key的名称
     * @return
     */
    public boolean isKeyExists(String key) {
        return hashOperations.hasKey(getRedisKey(), key);
    }

    /**
     * 查询相应Hash表的缓存数量
     *
     * @return
     */
    public long count() {
        return hashOperations.size(getRedisKey());
    }

    /**
     * 清空相应Hash表的所有缓存
     */
    public void empty() {
        Set<String> set = hashOperations.keys(getRedisKey());
        set.stream().forEach(key -> hashOperations.delete(getRedisKey(), key));
    }
}

 

重点来了redis增删盖查：

​
    //这里用@Autowired也是可以的
    @Resource
	private CameraInfoDao cameraInfoDao;
	
	@Resource
	private UserRedisimple userRedisimple;
	
	public CameraInfoManagerImpl(CameraInfoDao CameraInfoDao) {
		super(CameraInfoDao);
	}


    //修改添加
	@Override
	@CacheEvict( value="userCache", allEntries=true)
	public void saveTest(CameraInfo cameraInfo) {
		cameraInfoDao.save(cameraInfo);
		 if(cameraInfo.getRedisKey()==null||"".equals(cameraInfo.getRedisKey().trim())){
			 cameraInfo.setRedisKey(cameraInfo.getId().toString());
			 cameraInfoDao.save(cameraInfo);
	        }
	        userRedisimple.put(cameraInfo.getRedisKey(), cameraInfo, -1);
	}

    //删除
	@Override
	@CacheEvict(value="userCache", allEntries=true)
	public void deleteId(String id) {
		CameraInfo cameraInfo=new CameraInfo();
		cameraInfo.setId(id); 
		cameraInfo.setRedisKey(id);
		userRedisimple.remove(cameraInfo.getRedisKey());
		cameraInfoDao.remove(cameraInfo);
	}
	
    //查询全部
	@Override
	@Cacheable(value="userCache")
	public List<CameraInfo> getAllusers() {
		List<CameraInfo> list=cameraInfoDao.findByHQL("from CameraInfo");
		for(CameraInfo ca:list){
			ca.setRedisKey(ca.getId());
		}
		
		userRedisimple.getAll();
		return list;
	}

​

最后就是我们的启动类了，在启动类上添加注解@EnableCaching：

@Configuration
@EnableCaching
@SpringBootApplication
public class CoreApplication {

	public static void main(String[] args) {
		SpringApplication.run(CoreApplication.class, args);
	}
}

redis我在学习期间常看到的注解有三种：

        @Cacheable:有缓存取缓存，没有则放入缓存

        @Cacheput：有缓存刷新缓存，没有则放入缓存

        @CacheEvit：有缓存则清除，可以指定在执行方法前还是执行方法后

好啦，今天的分享就到这里啦！希望各位指出错误！

学习更多IT知识，加qq群：260292706