centos7 redis安装

1、下载

wget http://download.redis.io/releases/redis-4.0.6.tar.gz

2、解压

tar -zxvf redis-4.0.6.tar

3、将解压后文件夹移动到/usr/local/redis

mv redis-4.0.6 /usr/local/redis

4、进入文件夹

cd /usr/local/redis

5、make

make
make install

6、修改redis.conf

vim redis.conf

6.1、找到 bind 127.0.0.1 (命令模式下输入/^bind ，然后回车)

修改为：bind 0.0.0.0，意思是原本只能本地访问redis，现在修改后，所有ip都能访问

6.2 找到daemonize(命令模式输入/^daemonize)，如下：

no修改为yes，表示允许后台执行。

6.3 设置密码

找到（输入# requirepass foobard）：

修改为：

7、启动

启动服务端

redis-server redis.conf

启动客户端 

redis-cli

输入密码 

auth 密码

关闭客户端

shutdown save

8、执行以下两个命令

/usr/local/redis/redis.conf

/usr/local/redis/redis.log

/usr/local/redis/data

停止

启动

查看是否启动

启动客户端

 

spring boot连接：

application.properties

##redis
redis.host=49.235.207.227
redis.port=6379
redis.timeout=3
redis.password=666666
##redis连接池
redis.poolMaxTotal=10
redis.poolMaxIdle=10
redis.poolMaxWait=3

 定义RedisPoolFactory

package com.mqb.miaosha.redis;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.stereotype.Service;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;
@Service
public class RedisPoolFactory {

    @Autowired
    RedisConfig redisConfig;

    @Bean
    public JedisPool JedisPoolFactory(){
        JedisPoolConfig poolConfig = new JedisPoolConfig();
        poolConfig.setMaxIdle(redisConfig.getPoolMaxIdle());
        poolConfig.setMaxTotal(redisConfig.getPoolMaxTotal());
        poolConfig.setMaxWaitMillis(redisConfig.getPoolMaxWait()*1000);
        JedisPool jp = new JedisPool(poolConfig,redisConfig.getHost(),redisConfig.getPort(),
                redisConfig.getTimeout()*1000,redisConfig.getPassword(),0);
        return jp;
    }
}

RedisConfig 

package com.mqb.miaosha.redis;

import lombok.Data;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;

@Component
@ConfigurationProperties(prefix = "redis")
@Data
public class RedisConfig {
    private String host;
    private int port;
    private int timeout;
    private String password;
    private int poolMaxTotal;
    private int poolMaxIdle;
    private int poolMaxWait;
}

封装一个RedisService

Jedis jedis = jedisPool.getResource();

jedis.get();

jedis.set();

jedis.setex();

jedis.exists();

jedis.incr();

jedis.decr();

package com.mqb.miaosha.redis;

import com.alibaba.fastjson.JSON;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.util.StringUtils;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;

@Service
public class RedisService {
    @Autowired
    JedisPool jedisPool;

    public <T> T get(KeyPrefix keyPrefix,String key,Class<T> clazz){
        Jedis jedis = null;
        try{
            jedis = jedisPool.getResource();
            //生成真正的key
            String realKey = keyPrefix.getPrefix()+key;
            String str = jedis.get(realKey);
            T t = StringToBean(str,clazz);
            return t;
        }catch(Exception e) {
            e.printStackTrace();
        }finally{
            returnToPool(jedis);
        }
        return null;
    }
    public <T> Boolean set(KeyPrefix prefix,String key,T value){
        Jedis jedis = null;
        try{
            jedis = jedisPool.getResource();

            String str = beanToString(value);
            if (StringUtils.isEmpty(str)){
                return false;
            }
            //生成真正的key
            String realKey = prefix.getPrefix()+key;
            int seconds = prefix.expireSeconds();
            if(seconds<=0){
                jedis.set(realKey,str);
            }else{
                jedis.setex(realKey,seconds,str);
            }
            return true;
        }catch(Exception e) {
            e.printStackTrace();
        }finally{
            returnToPool(jedis);
        }
        return false;
    }
    public <T> Boolean exist(KeyPrefix prefix,String key){
        Jedis jedis = null;
        try{
            jedis = jedisPool.getResource();
            //生成真正的key
            String realKey = prefix.getPrefix()+key;
            return jedis.exists(realKey);
        }finally {
            returnToPool(jedis);
        }
    }

    /**
     * 增加值
     * @param prefix
     * @param key
     * @param <T>
     * @return
     */
    public <T> Long incr(KeyPrefix prefix,String key){
        Jedis jedis = null;
        try{
            jedis = jedisPool.getResource();
            //生成真正的key
            String realKey = prefix.getPrefix()+key;
            return jedis.incr(realKey);
        }finally {
            returnToPool(jedis);
        }
    }

    /**
     * 减少值
     * @param prefix
     * @param key
     * @param <T>
     * @return
     */
    public <T> Long decr(KeyPrefix prefix,String key){
        Jedis jedis = null;
        try{
            jedis = jedisPool.getResource();
            //生成真正的key
            String realKey = prefix.getPrefix()+key;
            return jedis.decr(realKey);
        }finally {
            returnToPool(jedis);
        }
    }

    private <T> String beanToString(T value) {
        if (value == null){
            return null;
        }
        Class<?> clazz = value.getClass();
        if (clazz == int.class || clazz == Integer.class){
            return ""+value;
        }else if(clazz == String.class){
            return (String)value;
        }else if(clazz == long.class||clazz == Long.class){
            return ""+value;
        }else{
            return JSON.toJSONString(value);
        }

    }

    private <T> T StringToBean(String str,Class<T> clazz) {
        if(StringUtils.isEmpty(str) || clazz == null){
            return null;
        }
        if (clazz == int.class || clazz == Integer.class){
            return (T)Integer.valueOf(str);
        }else if(clazz == String.class){
            return (T)str;
        }else if(clazz == long.class||clazz == Long.class){
            return (T)Long.valueOf(str);
        }else{
            return (T)JSON.parseObject(str).toJavaObject(clazz);
        }
    }

    private void returnToPool(Jedis jedis) {
        if(jedis!=null){
            jedis.close(); //返回到连接池
        }
    }

}