redis分兩種，一種單機 http://www.lxweimin.com/p/6ac1a3b7745e，一種集群 http://www.lxweimin.com/p/d44aa9a8be2c
首先看spring操作redis的配置，我項目只用到這些，其他的自行百度。
首先添加依賴包

    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-redis</artifactId>
        <version>1.4.7.RELEASE</version>
    </dependency>

然后寫類RedisClient

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.geo.Circle;
import org.springframework.data.geo.Distance;
import org.springframework.data.geo.Metrics;
import org.springframework.data.geo.Point;
import org.springframework.data.redis.connection.RedisGeoCommands;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;
import java.util.List;
import java.util.concurrent.TimeUnit;

@Component
public class RedisClient {  

    @Autowired
    private RedisTemplate redisTemplate;
      //set值
    public void set(String key, String value) {
        try {
            redisTemplate.opsForValue().set(key,value);
        }catch (Exception e){
            e.printStackTrace();
        }
    }
      //get值
    public String get(String key) {

        try {
            return ""+redisTemplate.opsForValue().get(key);
        }catch (Exception e){
            e.printStackTrace();
            return "";
        }
    }
   //自增1
    public void incr(String key) {
        int num = Integer.parseInt(""+redisTemplate.opsForValue().get(key));
        num=num+1;
        redisTemplate.opsForValue().set(key,num);
    }
   //到期時間
    public boolean expire(String key, int second) {
        boolean result = redisTemplate.expire(key,second, TimeUnit.SECONDS);
        return result;
    }

   //刪除
    public void del(String key) {
        redisTemplate.delete(key);
    }
   //是否存在key
    public boolean hasKey(String s) {
        Boolean flag =  redisTemplate.hasKey(s);
        return flag;

    }
   //左push
    public boolean lpush(String key, String value){
        boolean flag =false;
        try{
            redisTemplate.boundListOps(key).leftPush(value);
            flag =true;
        }catch (Exception e){
            e.printStackTrace();
        }
        return flag;

    }
    //右push
    public boolean rpush(String key, String value){
        boolean flag =false;
        try{
            redisTemplate.boundListOps(key).rightPush(value);
            flag =true;
        }catch (Exception e){
            e.printStackTrace();
        }
        return flag;

    }
   //添加附近的人
    public boolean geoadd(String key,double longitude,double latitude){
        boolean flag = false;
        try{
            redisTemplate.boundGeoOps("nearPeople").geoAdd(new Point(longitude,latitude),key);
            flag = true;
        }catch (Exception e){
            e.printStackTrace();
        }

        return flag;
    }
   //查詢附近的人
    public List geoQuery(double longitude,double latitude) {
        List  list = null;
        try{
            list = redisTemplate.opsForGeo().geoRadius("nearPeople", new Circle(new Point(longitude, latitude),
                    new Distance(500,Metrics.KILOMETERS)),
                    RedisGeoCommands.GeoRadiusCommandArgs.newGeoRadiusArgs().includeDistance().includeCoordinates()).getContent();

        }catch (Exception e){
            e.printStackTrace();
        }

        return list;
    }
}

注意：

我用的是RedisTemplate，在這之前我用的是redis.clients.jedis.JedisPool，但是每次操作就第一次，可以，稍微快速刷新兩次就一直阻塞，代碼

public void set(String key, String value) {
    Jedis jedis = null;
    try {  
        jedis = jedisPool.getResource();  
        jedis.set(key, value);  
    } finally {  
        //返還到連接池  
        jedis.close();  
    }  
}

具體原因沒弄明白，好像和最大連接數有關，之后發現不行，才換成RedisTemplate

單機配置

配置文件application.properties添加

# Redis數據庫索引（默認為0）
spring.redis.database=0
# Redis服務器地址
spring.redis.host=172.16.255.231
# Redis服務器連接端口
spring.redis.port=6379
# Redis服務器連接密碼（默認為空）
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=1
# 連接超時時間（毫秒）
spring.redis.timeout=5000

類Controller中測試

@Controller
@RequestMapping("/hello")
public class HelloController {

@Autowired
private HelloService helloService;
@Autowired
private RedisClient redisClient;
@RequestMapping(value = "/testRedis",method = RequestMethod.GET)
@ResponseBody
public String testRedis(@RequestParam String userId){
    if (redisClient.hasKey(userId)){
        System.out.println("redis中用戶存在");
        return redisClient.get(userId);
    }
    User user = new User();
    user.setId("1");
    user.setUsername("lijia");

    redisClient.set(userId,JSON.toJSONString(user));
    System.out.println("redis中用戶不存在,現在已設定");
    return JSON.toJSONString(user);
}
}

啟動Application，然后再瀏覽器中輸入 http://localhost:8080/hello/testRedis?userId=1
兩次都能返回結果，但是一次是從redis中讀取的，一次是直接獲取的

這樣redis單機環境就搭建好了。

集群配置

還是修改application.properties

spring.redis.cluster.nodes=172.16.255.231:7001,172.16.255.231:7002,172.16.255.231:7003,172.16.255.231:7004,172.16.255.231:7005,172.16.255.231:7006

然后讀取這個配置文件

import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Configuration;
import java.util.ArrayList;
import java.util.List;
@Configuration
@ConfigurationProperties(prefix = "spring.redis.cluster")
public class RedisClusterProperties {
    //集群節點
    private List<String> nodes=new ArrayList<>();
    public List<String> getNodes() {
        return nodes;
    }
    public void setNodes(List<String> nodes) {
        this.nodes = nodes;
    }
}

配置

import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.util.Assert;
import org.springframework.util.StringUtils;
import redis.clients.jedis.HostAndPort;
import redis.clients.jedis.JedisCluster;
import javax.annotation.Resource;
import java.util.Arrays;
import java.util.HashSet;
import java.util.Set;

@Configuration
@ConditionalOnClass(RedisClusterConfig.class)
@EnableConfigurationProperties(RedisClusterProperties.class)
public class RedisClusterConfig {
    @Resource
    private RedisClusterProperties redisClusterProperties;
    @Bean
    public JedisCluster redisCluster(){
        Set<HostAndPort> nodes = new HashSet<>();
        for (String node:redisClusterProperties.getNodes()){
            String[] parts= StringUtils.split(node,":");
            Assert.state(parts.length==2, "redis node shoule be defined as 'host:port', not '" + Arrays.toString(parts) + "'");
            nodes.add(new HostAndPort(parts[0], Integer.valueOf(parts[1])));
        }  
        return new JedisCluster(nodes);
    }
}

最后還是測試類，上面的一樣，但是判斷key方式不一樣

import com.alibaba.fastjson.JSON;
import com.lijia.bean.User;
import com.lijia.service.HelloService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.ResponseBody;
import redis.clients.jedis.JedisCluster;

@Controller
@RequestMapping("/hello")
public class HelloController {
    @Autowired
    private HelloService helloService;
    @Autowired
    private JedisCluster jedisCluster;
    @RequestMapping(value = "/testRedis",method = RequestMethod.GET)
    @ResponseBody
    public String testRedis(@RequestParam String userId){
        if (jedisCluster.exists(userId)){
            System.out.println("redis集群中用戶存在");
            return jedisCluster.get(userId);
        }
        User user = new User();
        user.setId("1");
        user.setUsername("lijia");
        jedisCluster.set(userId,JSON.toJSONString(user));
        System.out.println("redis集群中用戶不存在,現在已設定");
        return JSON.toJSONString(user);
    }

}

啟動Application，然后再瀏覽器中輸入 http://localhost:8080/hello/testRedis?userId=1
兩次都能返回結果，但是一次是從redis中讀取的，一次是直接獲取的

這集群算是可以用了。
注意：
今天再用linux中連接redis，發現連接集群中，需要加上-c，這個是必須的，不然set和get報錯。

JedisPool假死

如果用jedisPool去set和get。首先會有一段jedis = jedisPool.getResource();，
就是當連接池耗盡的時候

BlockWhenExhausted：連接耗盡時是否阻塞, false報異常,ture阻塞直到超時, 默認true
max-wait：獲取連接時的最大等待毫秒數(如果設置為阻塞時BlockWhenExhausted),如果超時就拋異常,小于零:阻塞不確定的時間, 默認-1

由于BlockWhenExhausted默認為true，連接耗盡時會阻塞到超時，但是MaxWaitMillis默認為-1，超時時間是一個不確定的時間，所以就一直阻塞著了。
設置redis.pool.max-wait值。

RedisTemplate亂碼現象

使用了RedisTemplate之后，今天測試之后發現redis找不到key，但是出現了下面這種情況。

原因是：
spring-data-redis的RedisTemplate<K, V>模板類在操作redis時默認使用JdkSerializationRedisSerializer來進行序列化

因為spring操作redis是在jedis客戶端基礎上進行的，而jedis客戶端與redis交互的時候協議中定義是用byte類型交互，jedis中提供了string類型轉為byte[]類型，
但是看到spring-data-redis中RedisTemplate<K, V>在操作的時候k，v是泛型的，所以RedisTemplate中有了上面那段代碼，在沒有特殊定義的情況下，
spring默認采用defaultSerializer = new JdkSerializationRedisSerializer();來對key，value進行序列化操作。

把原來的

@Autowired
private RedisTemplate redisTemplate;

修改為：

private RedisTemplate redisTemplate;
@Autowired(required = false)
public void setRedisTemplate(RedisTemplate redisTemplate) {
    RedisSerializer stringSerializer = new StringRedisSerializer();
    redisTemplate.setKeySerializer(stringSerializer);
    redisTemplate.setValueSerializer(stringSerializer);
    redisTemplate.setHashKeySerializer(stringSerializer);
    redisTemplate.setHashValueSerializer(stringSerializer);
    this.redisTemplate = redisTemplate;
}

然后再試試就好了。

三个男躁一个女,国精产品一区一手机的秘密,麦子交换系列最经典十句话,欧美国产综合欧美视频

9 springboot集成redis

9 springboot集成redis

注意：

單機配置

集群配置

JedisPool假死

RedisTemplate亂碼現象

推薦閱讀更多精彩內容

三个男躁一个女,国精产品一区一手机的秘密,麦子交换系列最经典十句话,欧美 国产 综合 欧美 视频

9 springboot集成redis

注意：

單機配置

集群配置

JedisPool假死

RedisTemplate亂碼現象

推薦閱讀更多精彩內容

三个男躁一个女,国精产品一区一手机的秘密,麦子交换系列最经典十句话,欧美国产综合欧美视频