• Redis在springboot项目的使用


    一、在pom.xml配置redis依赖

    <!-- redis客户端代码 -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-redis</artifactId>
    </dependency>
    <!-- json工具 -->
    <dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>fastjson</artifactId>
        <version>1.2.49</version>
    </dependency>
    <!-- redis需要用到这个依赖,否则报错 -->
    <dependency>
        <groupId>org.apache.commons</groupId>
        <artifactId>commons-pool2</artifactId>
    </dependency>
    

    二、在common包中自定义一个RedisService以及其实现类

    Redis的方法比较复杂,可以将经常使用的抽取成方法,形成工具类,方便调用(使用接口加实现类的方式);调用redis时,如下

    @Autowired
    private RedisService redisService;

    RedisService.java接口

    package cn.kooun.common.redis;
    
    import cn.kooun.common.redis.entity.MessageCommon;
    
    /**
     * redis service
     */
    public interface RedisService {
    	/**
    	 * 添加
    	 * 
    	 * @param key
    	 * @param value
    	 * @return
    	 */
    	boolean set(final String key, Object value);
    	/**
    	 * 添加 有生命周期
    	 * 
    	 * @param key
    	 * @param value
    	 * @param expireTime
    	 * @return
    	 */
    	boolean set(final String key, Object value, Long expireTime);
    	/**
    	 * 获取
    	 * 
    	 * @param key
    	 * @return
    	 */
    	Object get(String key);
    	/**
    	 * 删除
    	 * 
    	 * @param key
    	 */
    	void delete(final String key);
    	/**
    	 * 	发送广播消息
    	 * @param topic
    	 * @param body
    	 */
    	void sendTopic(String topic, MessageCommon body);
    }
    

    实现类RedisServiceImpl.java

    package cn.kooun.common.redis.impl;
    
    import java.util.concurrent.TimeUnit;
    
    import javax.annotation.Resource;
    
    import org.springframework.data.redis.core.RedisTemplate;
    import org.springframework.data.redis.core.ValueOperations;
    import org.springframework.stereotype.Service;
    
    import com.alibaba.fastjson.JSON;
    
    import cn.kooun.common.redis.RedisService;
    import cn.kooun.common.redis.entity.MessageCommon;
    
    /**
     * redis工具类
     */
    @Service
    public class RedisServiceImpl implements RedisService{
    	@Resource
        private RedisTemplate<String, Object> redisTemplate;
    	
    	/**
    	 * 添加
    	 * 
    	 * @param key
    	 * @param value
    	 * @return
    	 */
    	@SuppressWarnings("all")
    	@Override
        public boolean set(final String key, Object value) {
            boolean result = false;
        	ValueOperations<String, Object> operations = redisTemplate.opsForValue();
        	operations.set(key, value);
        	return true;
        }
    	/**
    	 * 添加带生命周期
    	 */
    	@Override
        public boolean set(final String key, Object value, Long expireTime) {
            boolean result = false;
            ValueOperations<String, Object> operations = redisTemplate.opsForValue();
            operations.set(key, value, expireTime, TimeUnit.SECONDS);
            result = true;
            return result;
        }
    	/**
    	 * 获取
    	 */
    	@Override
    	public Object get(final String key) {
    		ValueOperations<String, Object> operations = redisTemplate.opsForValue();
    		return operations.get(key);
    	}
    	/**
    	 * 删除
    	 */
    	@Override
    	@SuppressWarnings("all")
        public void delete(final String key) {
    		redisTemplate.delete(key);
        }
    	
    	/**
    	 * 	发送广播消息
    	 */
    	@Override
    	public void sendTopic(String topic,MessageCommon body) {
    		body.setConsumerTopic(topic);
    		redisTemplate.convertAndSend(topic,JSON.toJSONString(body));
    	}
    }
    

    redis广播消息体实体类MessageCommon

    package cn.kooun.common.redis.entity;
    
    /**
     *  redis广播消息体实体类
     * @author chenWei
     * @date 2019年11月7日 上午10:47:08
     */
    public class MessageCommon {
    	/**对方监听器执行回调的方法名*/
    	private String method;
    	/**消息体*/
    	private String body;
    	/**消息生产者的消费主题,便于回复消息*/
    	private String producerTopic;
    	/**消费者消费的主题*/
    	private String consumerTopic;
    	
    	public MessageCommon(String method, String body) {
    		this.method = method;
    		this.body = body;
    	}
    	
    	public String getMethod() {
    		return method;
    	}
    	public void setMethod(String method) {
    		this.method = method;
    	}
    	public String getBody() {
    		return body;
    	}
    	public void setBody(String body) {
    		this.body = body;
    	}
    
    	public String getProducerTopic() {
    		return producerTopic;
    	}
    
    	public void setProducerTopic(String producerTopic) {
    		this.producerTopic = producerTopic;
    	}
    
    	public String getConsumerTopic() {
    		return consumerTopic;
    	}
    
    	public void setConsumerTopic(String consumerTopic) {
    		this.consumerTopic = consumerTopic;
    	}
    
    	@Override
    	public String toString() {
    		return "MessageCommon [method=" + method + ", body=" + body + ", producerTopic=" + producerTopic
    				+ ", consumerTopic=" + consumerTopic + "]";
    	}
    	
    }
    

    三、redis可视化工具乱码(springboot中添加一个类)

    package cn.kooun.common.redis;
    
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.data.redis.connection.RedisConnectionFactory;
    import org.springframework.data.redis.core.RedisTemplate;
    import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;
    import org.springframework.data.redis.serializer.StringRedisSerializer;
    
    /**
     * 	解决redis可视化工具乱码问题
     * @author HuangJingNa
     * @date 2019年12月21日 下午3:15:19
     *
     */
    @Configuration
    public class RedisConfigBean {
    
        /**
         * redis 防止key value 前缀乱码.
         *
         * @param factory redis连接 factory
         * @return redisTemplate
         */
        @Bean(name = "redisTemplate")
        public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
            RedisTemplate<String, Object> template = new RedisTemplate<>();
            template.setConnectionFactory(factory);
            template.setKeySerializer(new StringRedisSerializer());
            template.setValueSerializer(new GenericJackson2JsonRedisSerializer());
            template.setHashKeySerializer(new GenericJackson2JsonRedisSerializer());
            template.setHashValueSerializer(new GenericJackson2JsonRedisSerializer());
            template.afterPropertiesSet();
            return template;
        }
    
    }
    

    package cn.kooun.core.config;
    
    import java.lang.reflect.Method;
    
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.cache.annotation.CachingConfigurerSupport;
    import org.springframework.cache.annotation.EnableCaching;
    import org.springframework.cache.interceptor.KeyGenerator;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.data.redis.connection.RedisConnectionFactory;
    import org.springframework.data.redis.core.RedisTemplate;
    import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
    import org.springframework.data.redis.serializer.StringRedisSerializer;
    
    import com.fasterxml.jackson.annotation.JsonAutoDetect;
    import com.fasterxml.jackson.annotation.PropertyAccessor;
    import com.fasterxml.jackson.databind.ObjectMapper;
    /**
     * redis配置
     * 
     * @author chenWei
     * @date 2019年9月12日 上午11:00:27
     *
     */
    @Configuration
    @EnableCaching
    //自动注入自定义对象到参数列表
    @SuppressWarnings("all")
    public class RedisConfig  extends CachingConfigurerSupport {
    	
    	/**
    	 * key的生成策略
    	 */
    	@Bean
        public KeyGenerator keyGenerator() {
            return new KeyGenerator() {
                @Override
                public Object generate(Object target, Method method, Object... params) {
                    StringBuilder sb = new StringBuilder();
                    sb.append(target.getClass().getName());
                    sb.append(method.getName());
                    for (Object obj : params) {
                        sb.append(obj.toString());
                    }
                    return sb;
                }
    
            };
        }
        /**
         * RedisTemplate配置
         * @author chenwei
         * @date 2019年7月2日 上午10:31:44
         * @param factory
         * @return
         */
        @Bean
        public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
        	RedisTemplate<String, Object> template = new RedisTemplate<>();
            // 配置连接工厂
            template.setConnectionFactory(factory);
    
            //使用Jackson2JsonRedisSerializer来序列化和反序列化redis的value值(默认使用JDK的序列化方式)
            Jackson2JsonRedisSerializer jacksonSeial = new Jackson2JsonRedisSerializer(Object.class);
    
            ObjectMapper om = new ObjectMapper();
            // 指定要序列化的域,field,get和set,以及修饰符范围,ANY是都有包括private和public
            om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
            // 指定序列化输入的类型,类必须是非final修饰的,final修饰的类,比如String,Integer等会跑出异常
            om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
            jacksonSeial.setObjectMapper(om);
    
            // 值采用json序列化
            template.setValueSerializer(jacksonSeial);
            //使用StringRedisSerializer来序列化和反序列化redis的key值
            template.setKeySerializer(new StringRedisSerializer());
    
            // 设置hash key 和value序列化模式
            template.setHashKeySerializer(new StringRedisSerializer());
            template.setHashValueSerializer(jacksonSeial);
            template.afterPropertiesSet();
    
            return template;
        }
        
        
    }
    
  • 相关阅读:
    Servlet设置Cookie无效
    IOS即时通讯XMPP搭建openfire服务器
    IOS之富文本编辑
    unittest单元测试框架总结
    杀死future处理的阻塞线程
    APP的UI设计原则
    如何降低一个程序的耦合性
    Hyperopt中文文档导读
    Hyperopt中文文档导读
    AdaBoost算法特性
  • 原文地址:https://www.cnblogs.com/nadou/p/14003652.html
Copyright © 2020-2023  润新知