<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>

# springboot所有的配置類都有一個自動配置類， xxxAutoConfiguration
# 自動配置類都會綁定一個properties 的配置文件，xxxProperties
???????
spring.redis.host=127.0.0.1   #localhost
spring.redis.port=6379
spring.redis.database=0

@Bean
@ConditionalOnMissingBean(name = "redisTemplate") 
// 可以自己定義一個redisTemplate來替換這個默認的！
public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory)
    throws UnknownHostException {
    // 默認的 RedisTemplate 沒有過多的設(shè)置，redis 對象都是需要序列化！
    // 兩個泛型都是 Object, Object 的類型，我們后使用需要強制轉(zhuǎn)換 <String, Object>
    RedisTemplate<Object, Object> template = new RedisTemplate<>();
    template.setConnectionFactory(redisConnectionFactory);
    return template;
}

@Bean
@ConditionalOnMissingBean 
//由于String是redis中最常使用的類型，所以單獨提一個bean！
public StringRedisTemplate stringRedisTemplate(RedisConnectionFactory redisConnectionFactory)
    throws UnknownHostException {
    StringRedisTemplate template = new StringRedisTemplate();
    template.setConnectionFactory(redisConnectionFactory);
    return template;
}

RedisConnection connection = redisTemplate.getConnectionFactory().getConnection();
connection.flushDb();
connection.flushAll();

	@Autowired
    private StringRedisTemplate stringRedisTemplate;  //對字符串支持比較友好,不能存儲對象
    @Autowired
    private RedisTemplate redisTemplate;  //存儲對象

    @Test
    public void testRedisTemplate(){
        System.out.println(redisTemplate);
        //設(shè)置redistemplate值使用對象序列化策略
        redisTemplate.setValueSerializer(new JdkSerializationRedisSerializer());//指定值使用對象序列化
        //redisTemplate.opsForValue().set("user",new User("1","qinyu",99,new Date()));
        User user = (User) redisTemplate.opsForValue().get("user");
        System.out.println(user);
        //Set keys = redisTemplate.keys("*");
        //keys.forEach(key -> System.out.println(key));
        /*Object name = redisTemplate.opsForValue().get("name");
        System.out.println(name);*/

        //Object qinyu= redisTemplate.opsForValue().get("qinyu");
        //System.out.println(qinyu);
        /*redisTemplate.opsForValue().set("name","xxxx");
        Object name = redisTemplate.opsForValue().get("name");
        System.out.println(name);*/
        /*redisTemplate.opsForList().leftPushAll("lists","xxxx","1111");
        List lists = redisTemplate.opsForList().range("lists", 0, -1);
        lists.forEach(list-> System.out.println(list));*/
    }


    /*key的綁定操作 如果日后對某一個key的操作及其頻繁,可以將這個key綁定到對應(yīng)redistemplate中,日后基于綁定操作都是操作這個key
      boundValueOps 用來對String值綁定key
      boundListOps 用來對List值綁定key
      boundSetOps 用來對Set值綁定key
      boundZsetOps 用來對Zset值綁定key
      boundHashOps 用來對Hash值綁定key
    */

    @Test
    public void testBoundKey(){
        BoundValueOperations<String, String> nameValueOperations = stringRedisTemplate.boundValueOps("name");
        nameValueOperations.set("1");
        //yuew
        nameValueOperations.set("2");
        String s = nameValueOperations.get();
        System.out.println(s);

    }


    //hash相關(guān)操作 opsForHash
    @Test
    public void testHash(){
        stringRedisTemplate.opsForHash().put("maps","name","qinyu");
        Object o = stringRedisTemplate.opsForHash().get("maps", "name");
        System.out.println(o);
    }

    //zset相關(guān)操作 opsForZSet
    @Test
    public void testZSet(){
        stringRedisTemplate.opsForZSet().add("zsets","qinyu",10);
        Set<String> zsets = stringRedisTemplate.opsForZSet().range("zsets", 0, -1);
        zsets.forEach(value-> System.out.println(value));
    }

    //set相關(guān)操作 opsForSet
    @Test
    public void testSet(){
        stringRedisTemplate.opsForSet().add("sets","xiaosan","xiaosi","xiaowu");
        Set<String> sets = stringRedisTemplate.opsForSet().members("sets");
        sets.forEach(value-> System.out.println(value));
    }

    //list相關(guān)的操作opsForList
    @Test
    public void testList(){
        // stringRedisTemplate.opsForList().leftPushAll("lists","張三","李四","王五");
        List<String> lists = stringRedisTemplate.opsForList().range("lists", 0, -1);
        lists.forEach(key -> System.out.println(key));
    }


    //String相關(guān)的操作 opsForValue
    @Test
    public void testString(){
        //stringRedisTemplate.opsForValue().set("166","好同學");
        String s = stringRedisTemplate.opsForValue().get("166");
        System.out.println(s);
        Long size = stringRedisTemplate.opsForValue().size("166");
        System.out.println(size);
    }


    //key相關(guān)的操作
    @Test
    public void test(){
        Set<String> keys = stringRedisTemplate.keys("*");//查看所有key
        Boolean name = stringRedisTemplate.hasKey("name");//判斷某個key是否存在
        stringRedisTemplate.delete("age");//根據(jù)指定key刪除
        stringRedisTemplate.rename("","");//修改key的名稱
        stringRedisTemplate.expire("key",10, TimeUnit.HOURS);
      	//設(shè)置key超時時間 參數(shù)1:設(shè)置key名 參數(shù)2:時間 參數(shù)3:時間的單位
        stringRedisTemplate.move("",1);//移動key
    }

import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
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;
@Configuration
public class RedisConfig {
    // 自己定義一個 RedisTemplate
    @Bean
    @SuppressWarnings("all")
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
        // 我們?yōu)榱俗约洪_發(fā)方便，一般直接使用 <String, Object>
        RedisTemplate<String, Object> template = new RedisTemplate<String,Object>();
        template.setConnectionFactory(factory);
        // Json序列化配置
        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
        ObjectMapper om = new ObjectMapper();
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        jackson2JsonRedisSerializer.setObjectMapper(om);
        // String 的序列化
        StringRedisSerializer stringRedisSerializer = new  StringRedisSerializer();
        // key采用String的序列化方式
        template.setKeySerializer(stringRedisSerializer);
        // hash的key也采用String的序列化方式
        template.setHashKeySerializer(stringRedisSerializer);
        // value序列化方式采用jackson
        template.setValueSerializer(jackson2JsonRedisSerializer);
        // hash的value序列化方式采用jackson
        template.setHashValueSerializer(jackson2JsonRedisSerializer);
        template.afterPropertiesSet();
        return template;
    }
}

bind 127.0.0.1 # 綁定的ip
protected-mode yes # 保護模式
port 6379 # 端口設(shè)置

daemonize yes # 以守護進程的方式運行(就是后臺運行)，默認是 no，我們需要自己開啟為yes！
pidfile /var/run/redis_6379.pid # 如果以后臺的方式運行，我們就需要指定一個 pid 文件！
# 日志
# Specify the server verbosity level.
# This can be one of:
redis 是內(nèi)存數(shù)據(jù)庫，如果沒有持久化，那么數(shù)據(jù)斷電及失！
REPLICATION 復制，我們后面講解主從復制的，時候再進行講解
SECURITY 安全
可以在這里設(shè)置redis的密碼，默認是沒有密碼！
# debug (a lot of information, useful for development/testing)
# verbose (many rarely useful info, but not a mess like the debug level)
# notice (moderately verbose, what you want in production probably) 生產(chǎn)環(huán)境
# warning (only very important / critical messages are logged)
loglevel notice
logfile "" # 日志的文件位置名
databases 16 # 數(shù)據(jù)庫的數(shù)量，默認是 16 個數(shù)據(jù)庫
always-show-logo yes # 是否總是顯示LOGO

# 如果900s內(nèi)，如果至少有一個1 key進行了修改，我們及進行持久化操作
save 900 1
# 如果300s內(nèi)，如果至少10 key進行了修改，我們及進行持久化操作
save 300 10
# 如果60s內(nèi)，如果至少10000 key進行了修改，我們及進行持久化操作
save 60 10000
# 之后學習持久化，會自己定義這個測試！
stop-writes-on-bgsave-error yes # 持久化如果出錯，是否還需要繼續(xù)工作！ 默認保存出錯的話停止操作
rdbcompression yes # 是否壓縮 rdb 文件，需要消耗一些cpu資源！
rdbchecksum yes # 保存rdb文件的時候，進行錯誤的檢查校驗！
dir ./ # rdb 文件保存的目錄！

127.0.0.1:6379> ping
PONG
127.0.0.1:6379> config get requirepass # 獲取redis的密碼
1) "requirepass"
2) ""
127.0.0.1:6379> config set requirepass "123456" # 設(shè)置redis的密碼
OK
127.0.0.1:6379> config get requirepass # 發(fā)現(xiàn)所有的命令都沒有權(quán)限了
(error) NOAUTH Authentication required.
127.0.0.1:6379> ping
(error) NOAUTH Authentication required.
127.0.0.1:6379> auth 123456 # 使用密碼進行登錄！
OK
127.0.0.1:6379> config get requirepass
1) "requirepass"
2) "123456"

maxclients 10000 # 設(shè)置能連接上redis的最大客戶端的數(shù)量
maxmemory <bytes> # redis 配置最大的內(nèi)存容量
maxmemory-policy noeviction # 內(nèi)存到達上限之后的處理策略
 # redis 中的默認的過期策略是 volatile-lru 。
1、volatile-lru：只對設(shè)置了過期時間的key進行LRU（默認值）
2、allkeys-lru ： 刪除lru算法的key
3、volatile-random：隨機刪除即將過期key
4、allkeys-random：隨機刪除
5、volatile-ttl ： 刪除即將過期的
6、noeviction ： 永不過期，返回錯誤
------------------------------------------------
# 設(shè)置方式
config set maxmemory-policy volatile-lru 

appendonly no # 默認是不開啟aof模式的，默認是使用rdb方式持久化的，在大部分所有的情況下，
rdb完全夠用！
appendfilename "appendonly.aof" # 持久化的文件的名字
# appendfsync always # 每次修改都會 sync。消耗性能
appendfsync everysec # 每秒執(zhí)行一次 sync，可能會丟失這1s的數(shù)據(jù)！
# appendfsync no # 不執(zhí)行 sync，這個時候操作系統(tǒng)自己同步數(shù)據(jù)，速度最快！