Redis - Java操作Redis - 《NoSql数据库》

修改redis.conf配置
- 1 注释掉bind
- 2 protected-mode
连接
- 添加依赖
实例
springBoot整合redis

修改redis.conf配置

1 注释掉bind

默认情况bind=127.0.0.1只能接受本机的访问请求

2 protected-mode

将本机访问保护模式设置no

连接

添加依赖

<dependency>
     <groupId>redis.clients</groupId>
     <artifactId>jedis</artifactId>
     <version>3.2.0</version>
</dependency>

@Test
public void demo1(){
    Jedis jedis = new Jedis("121.199.40.145",6379);
    jedis.set("name", "b");
    System.out.println(jedis.get("backup4"));
    System.out.println(jedis.ttl("name"));
    jedis.keys("*").forEach(System.out::println);
}

实例

手机验证码功能
要求：
1、输入手机号，点击发送后随机生成6位数字码，2分钟有效
2、输入验证码，点击验证，返回成功或失败
3、每个手机号每天只能输入3次

public class jedisDemo {
    public static void main(String[] args) {
        //模拟验证码发送
        verifyCode("156188");
        getRedisCode("156188","1943");
    }
    //验证码校验
    public static void getRedisCode(String phone,String code){
        Jedis jedis = new Jedis("121.199.40.145",6379);
        String codeKey = phone+":code";
        String redisCode = jedis.get(codeKey);
        if(redisCode.equals(code)){
            System.out.println("success");
        }else {
            System.out.println("failure");
        }
    }
    //每个手机每天只能发送三次，验证码放redis中，设置过期时间
    public static void verifyCode(String phone){
        Jedis jedis = new Jedis("121.199.40.145",6379);
        String countKey = phone+":count";
        String codeKey = phone+":code";
        //设置每天只能发送三次
        String count = jedis.get(countKey);
        if(count == null){
            //首次发送
            jedis.setex(countKey, 24 * 60 * 60, "1");
        }else if(Integer.parseInt(count)<=2){
            //发送次数+1
            jedis.incr(countKey);
        }else if(Integer.parseInt(count)==3){
            //达到三次
            System.out.println("发送次数到三次了");
            jedis.close();
        }
        String vcode = getCode();
        jedis.setex(codeKey, 120, vcode);
        jedis.close();
    }
    //生成验证码
    public static String getCode(){
        Random random = new Random();
        String code = "";
        for (int i = 0; i < 5; i++) {
            int m = random.nextInt(10);
            code+=m;
        }
        return code;
    }
}

springBoot整合redis

引入依赖

<dependency>
     <groupId>org.springframework.boot</groupId>
     <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
<!-- spring2.X集成redis所需common-pool2-->
<dependency>
     <groupId>org.apache.commons</groupId>
     <artifactId>commons-pool2</artifactId>
     <version>2.6.0</version>
</dependency>

配置文件

spring:
  redis:
#    Redis服务器地址
    host: 121.199.40.145
    port: 6379
#    Redis数据库索引（默认为0
    database: 0
#    连接超时时间（毫秒）
    timeout: 1800000
    #默认使用lettuce连接
    lettuce:        
      pool:
#        连接池最大连接数（使用负值表示没有限制）
        max-active: 20
#        最大阻塞等待时间(负数表示没限制)
        max-wait: -1
#        连接池中的最大空闲连接
        max-idle: 5
#        连接池中的最小空闲连接
        min-idle: 0

Jedis：
Jedis 是直连模式，在多个线程间共享⼀个 Jedis 实例时是线程不安全的,需要使⽤连接池，为每个jedis实例分配一个连接。使⽤阻塞的I/O，⽅法调⽤同步，程序流需要等到socket处理完I/O才能执⾏，不⽀持异步操作

Lettuce：
Lettuce底层使用的是Netty，当有多个线程都需要连接Redis服务器的时候，可以保证只创建一个Lettuce连接，使所有的线程共享这一个Lettuce连接，这样可以减少创建关闭一个Lettuce连接时候的开销；而且这种方式也是线程安全的，可以在多个线程间并发访问, 通过异步的⽅式可以更好的利用系统资源

#可以通过排除lettuce的包依赖 切换成jedis连接 
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
    <exclusions>
        <exclusion>
            <groupId>io.lettuce</groupId>
            <artifactId>lettuce-core</artifactId>
        </exclusion>
    </exclusions>
</dependency>
<dependency>
    <groupId>redis.clients</groupId>
    <artifactId>jedis</artifactId>
</dependency>

创建配置类（固定模板）

对象缓存入redis要注意序列化的格式

不同的序列化方式性能不一样

采用默认的jdk方式会乱码(POJO类需要实现Serializable接口)
采用JSON方式则不用序列化

JdkSerializationRedisSerializer

pojo对象的存取场景，使用JDK本身序列化机制
默认机制ObjectinputStream/0bjectOutputStream进行序列化操作

StringRedisSerializer

Key或者value为字符串时使用

Jackson2JsonRedisSerializer

利用jacksonjson工具，将pojo实例序列化成json格式存储

GenericFastJsonRedisSerializer

另一种javabean与json之间的转换，同时也需要指定Class类型 ```java @Configuration public class RedisConfig extends CachingConfigurerSupport { @Bean public RedisTemplate redisTemplate(RedisConnectionFactory factory) {

  RedisTemplate<String, Object> template = new RedisTemplate<>();
  RedisSerializer<String> redisSerializer = new StringRedisSerializer();
  Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
  ObjectMapper om = new ObjectMapper();
  om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
  // 指定序列化输入的类型，类必须是非final修饰的，final修饰的类，
  //比如String,Integer等会跑出异常
  //om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
  jackson2JsonRedisSerializer.setObjectMapper(om);
  template.setConnectionFactory(factory);
  //key序列化方式
  template.setKeySerializer(redisSerializer);
  //value序列化
  template.setValueSerializer(jackson2JsonRedisSerializer);
  //value hashmap序列化
  template.setHashValueSerializer(jackson2JsonRedisSerializer);
  return template;

}

**注：Jackson2JsonRedisSerializer反序列化是不可以将map解析成对象，可以在序列化时把对象转换成Json存入**
```java
public User test() {
    User user = new User("hhh这里", 21);
    System.out.println(user);
    //存入redis时先做了把对象转换成json
    redisTemplate.opsForValue().set("user用户", JSON.toJSONString(user));
    User redisUser = JSON.parseObject(String.valueOf(redisTemplate.opsForValue().get("user用户")), User.class);
    return redisUser;
}