zoukankan      html  css  js  c++  java
  • SpringBoot整合Redis

    1.项目结构

    2.pom.xml文件

    <project xmlns="http://maven.apache.org/POM/4.0.0"
    	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    	<modelVersion>4.0.0</modelVersion>
    	<groupId>com.itmayiedu</groupId>
    	<artifactId>springboot-redis</artifactId>
    	<version>0.0.1-SNAPSHOT</version>
    
    	<parent>
    		<groupId>org.springframework.boot</groupId>
    		<artifactId>spring-boot-starter-parent</artifactId>
    		<version>1.5.3.RELEASE</version>
    	</parent>
    
    	<dependencies>
    		 <!-- springboot整合redis -->  
            <dependency>  
                <groupId>org.springframework.boot</groupId>  
                <artifactId>spring-boot-starter-data-redis</artifactId>  
            </dependency> 
    		
    		<dependency>
    			<groupId>org.springframework.boot</groupId>
    			<artifactId>spring-boot-starter-web</artifactId>
    		</dependency>
    
    		<!-- https://mvnrepository.com/artifact/commons-lang/commons-lang     工具包 -->
    		<dependency>
    			<groupId>commons-lang</groupId>
    			<artifactId>commons-lang</artifactId>
    			<version>2.6</version>
    		</dependency>
    
    	</dependencies>
    
    </project>
    

      

    3.application.yml文件

    # redis配置,以下有默认配置的也可以使用默认配置
    spring:
      redis:
        open: true                  # 是否开启redis缓存  true开启   false关闭
        host: 192.168.146.128       # Redis服务器地址  
        database: 0                 # Redis数据库索引(默认为0)  
        password: 123456            # Redis服务器连接密码(默认为空)
        port: 6379                  # Redis服务器连接端口  
        timeout:  1000              # 连接超时时间(毫秒)  
        pool:
          max-active: 1000          # 连接池最大连接数(使用负值表示没有限制)
          max-idle: 10              # 连接池中的最大空闲连接
          min-idle: 5               # 连接池中的最小空闲连接  
          max-wait: -1              # 连接池最大阻塞等待时间(使用负值表示没有限制)  
          
    server:
      port: 8080
    

      

    4.RedisConfig配置类

    package com.qingfeng.configuration;
    
    import org.springframework.beans.factory.annotation.Autowired;
    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.HashOperations;
    import org.springframework.data.redis.core.ListOperations;
    import org.springframework.data.redis.core.RedisTemplate;
    import org.springframework.data.redis.core.SetOperations;
    import org.springframework.data.redis.core.ValueOperations;
    import org.springframework.data.redis.core.ZSetOperations;
    import org.springframework.data.redis.serializer.StringRedisSerializer;
    
    @Configuration
    public class RedisConfig {
    
        @Autowired
        private RedisConnectionFactory factory;
    
        @Bean
        public RedisTemplate<String, Object> redisTemplate() {
            RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
            // key采用String的序列化方式
            redisTemplate.setKeySerializer(new StringRedisSerializer());
            // hash的key也采用String的序列化方式
            redisTemplate.setHashKeySerializer(new StringRedisSerializer());
            // hash的value序列化方式采用jackson
            redisTemplate.setHashValueSerializer(new StringRedisSerializer());
            // value序列化方式采用jackson
            redisTemplate.setValueSerializer(new StringRedisSerializer());
         // 配置连接工厂
            redisTemplate.setConnectionFactory(factory);
            return redisTemplate;
        }
    
        /**
         * 对hash类型的数据操作
         * @param redisTemplate
         * @return
         */
        @Bean
        public HashOperations<String, String, Object> hashOperations(RedisTemplate<String, Object> redisTemplate) {
            return redisTemplate.opsForHash();
        }
    
        /**
         * 对redis字符串类型数据操作
         * @param redisTemplate
         * @return
         */
        @Bean
        public ValueOperations<String, String> valueOperations(RedisTemplate<String, String> redisTemplate) {
            return redisTemplate.opsForValue();
        }
    
        /**
         * 对链表类型的数据操作
         * @param redisTemplate
         * @return
         */
        @Bean
        public ListOperations<String, Object> listOperations(RedisTemplate<String, Object> redisTemplate) {
            return redisTemplate.opsForList();
        }
    
        /**
         * 对无序集合类型的数据操作
         * @param redisTemplate
         * @return
         */
        @Bean
        public SetOperations<String, Object> setOperations(RedisTemplate<String, Object> redisTemplate) {
            return redisTemplate.opsForSet();
        }
    
        /**
         * 对有序集合类型的数据操
         * @param redisTemplate
         * @return
         */
        @Bean
        public ZSetOperations<String, Object> zSetOperations(RedisTemplate<String, Object> redisTemplate) {
            return redisTemplate.opsForZSet();
        }
    
    }
    

      

    5.RedisOperator工具类

    package com.qingfeng.utils;
    
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.dao.DataAccessException;
    import org.springframework.data.redis.connection.RedisClusterConnection;
    import org.springframework.data.redis.connection.RedisConnection;
    import org.springframework.data.redis.connection.StringRedisConnection;
    import org.springframework.data.redis.core.RedisCallback;
    import org.springframework.data.redis.core.RedisOperations;
    import org.springframework.data.redis.core.RedisTemplate;
    import org.springframework.data.redis.core.SessionCallback;
    import org.springframework.data.redis.core.StringRedisTemplate;
    import org.springframework.stereotype.Component;
    
    import java.util.List;
    import java.util.Map;
    import java.util.Set;
    import java.util.concurrent.TimeUnit;
    
    /**
     * Redis 工具类
     */
    @Component
    public class RedisOperator {
    	
    	@Autowired
        private RedisTemplate<String, Object> redisTemplate;
    	
    
    	
    	// Key(键),简单的key-value操作
    
    	/**
    	 * 实现命令:TTL key,以秒为单位,返回给定 key的剩余生存时间(TTL, time to live)。
    	 * 
    	 * @param key
    	 * @return
    	 */
    	public long ttl(String key) {
    		return redisTemplate.getExpire(key);
    	}
    	
    	/**
    	 * 实现命令:expire 设置过期时间,单位秒
    	 * 
    	 * @param key
    	 * @return
    	 */
    	public void expire(String key, long timeout) {
    		redisTemplate.expire(key, timeout, TimeUnit.SECONDS);
    	}
    	
    	/**
    	 * 实现命令:INCR key,增加key一次
    	 * 
    	 * @param key
    	 * @return
    	 */
    	public long incr(String key, long delta) {
    		return redisTemplate.opsForValue().increment(key, delta);
    	}
    
    	/**
    	 * 实现命令:KEYS pattern,查找所有符合给定模式 pattern的 key
    	 */
    	public Set<String> keys(String pattern) {
    		return redisTemplate.keys(pattern);
    	}
    
    	/**
    	 * 实现命令:DEL key,删除一个key
    	 * 
    	 * @param key
    	 */
    	public void del(String key) {
    		redisTemplate.delete(key);
    	}
    
    	// String(字符串)
    
    	/**
    	 * 实现命令:SET key value,设置一个key-value(将字符串值 value关联到 key)
    	 * 
    	 * @param key
    	 * @param value
    	 */
    	public void set(String key, String value) {
    		redisTemplate.opsForValue().set(key, value);
    	}
    
    	/**
    	 * 实现命令:SET key value EX seconds,设置key-value和超时时间(秒)
    	 * 
    	 * @param key
    	 * @param value
    	 * @param timeout
    	 *            (以秒为单位)
    	 */
    	public void set(String key, String value, long timeout) {
    		redisTemplate.opsForValue().set(key, value, timeout, TimeUnit.SECONDS);
    	}
    
    	/**
    	 * 实现命令:GET key,返回 key所关联的字符串值。
    	 * 
    	 * @param key
    	 * @return value
    	 */
    	public String get(String key) {
    		return (String)redisTemplate.opsForValue().get(key);
    	}
    
    	/**
    	 * 批量查询,对应mget
    	 * @param keys
    	 * @return
    	 */
    	public List<Object> mget(List<String> keys) {
    		return redisTemplate.opsForValue().multiGet(keys);
    	}
    
    	/**
    	 * 批量查询,管道pipeline
    	 * @param keys
    	 * @return
    	 */
    	public List<Object> batchGet(List<String> keys) {
    
    
    		List<Object> result = redisTemplate.executePipelined(new RedisCallback<String>() {
    			@Override
    			public String doInRedis(RedisConnection connection) throws DataAccessException {
    				StringRedisConnection src = (StringRedisConnection)connection;
    
    				for (String k : keys) {
    					src.get(k);
    				}
    				return null;
    			}
    		});
    
    		return result;
    	}
    
    
    	// Hash(哈希表)
    
    	/**
    	 * 实现命令:HSET key field value,将哈希表 key中的域 field的值设为 value
    	 * 
    	 * @param key
    	 * @param field
    	 * @param value
    	 */
    	public void hset(String key, String field, Object value) {
    		redisTemplate.opsForHash().put(key, field, value);
    	}
    
    	/**
    	 * 实现命令:HGET key field,返回哈希表 key中给定域 field的值
    	 * 
    	 * @param key
    	 * @param field
    	 * @return
    	 */
    	public String hget(String key, String field) {
    		return (String) redisTemplate.opsForHash().get(key, field);
    	}
    
    	/**
    	 * 实现命令:HDEL key field [field ...],删除哈希表 key 中的一个或多个指定域,不存在的域将被忽略。
    	 * 
    	 * @param key
    	 * @param fields
    	 */
    	public void hdel(String key, Object... fields) {
    		redisTemplate.opsForHash().delete(key, fields);
    	}
    
    	/**
    	 * 实现命令:HGETALL key,返回哈希表 key中,所有的域和值。
    	 * 
    	 * @param key
    	 * @return
    	 */
    	public Map<Object, Object> hgetall(String key) {
    		return redisTemplate.opsForHash().entries(key);
    	}
    
    	// List(列表)
    
    	/**
    	 * 实现命令:LPUSH key value,将一个值 value插入到列表 key的表头
    	 * 
    	 * @param key
    	 * @param value
    	 * @return 执行 LPUSH命令后,列表的长度。
    	 */
    	public long lpush(String key, String value) {
    		return redisTemplate.opsForList().leftPush(key, value);
    	}
    
    	/**
    	 * 实现命令:LPOP key,移除并返回列表 key的头元素。
    	 * 
    	 * @param key
    	 * @return 列表key的头元素。
    	 */
    	public String lpop(String key) {
    		return (String)redisTemplate.opsForList().leftPop(key);
    	}
    
    	/**
    	 * 实现命令:RPUSH key value,将一个值 value插入到列表 key的表尾(最右边)。
    	 * 
    	 * @param key
    	 * @param value
    	 * @return 执行 LPUSH命令后,列表的长度。
    	 */
    	public long rpush(String key, String value) {
    		return redisTemplate.opsForList().rightPush(key, value);
    	}
    
    }
    

      

    6.RedisController类

    package com.qingfeng.controller;
    
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.web.bind.annotation.GetMapping;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RestController;
    
    import com.qingfeng.utils.RedisOperator;
    
    @RestController
    @RequestMapping("/redis")
    public class RedisController {
    
    	@Autowired
    	private RedisOperator redisOperator;
    	
    	@GetMapping("/set")
        public Object set(String key, String value) {
            redisOperator.set(key, value);
            return "OK";
        }
    
        @GetMapping("/get")
        public String get(String key) {
            return redisOperator.get(key);
        }
    
        @GetMapping("/delete")
        public Object delete(String key) {
            redisOperator.del(key);
            return "OK";
        }
    }
    

      

    7.启动项目,在浏览器测试  http://localhost:8080/redis/set?key=name&value=admin

    Redis查看数据

    获取Redis数据   http://localhost:8080/redis/get?key=name

  • 相关阅读:
    Fidder4 顶部提示 “The system proxy was changed,click to reenable fiddler capture”。
    redis 哨兵 sentinel master slave 连接建立过程
    虚拟点赞浏览功能的大数据量测试
    python基础练习题(题目 字母识词)
    python基础练习题(题目 回文数)
    python基础练习题(题目 递归求等差数列)
    python基础练习题(题目 递归输出)
    python基础练习题(题目 递归求阶乘)
    python基础练习题(题目 阶乘求和)
    python基础练习题(题目 斐波那契数列II)
  • 原文地址:https://www.cnblogs.com/Amywangqing/p/12732826.html
Copyright © 2011-2022 走看看