SpringBoot学习笔记6_整合Redis

三十四  SpringBoot整合Redis(结合 SpringBoot整合Mybatis)

34.0 该案例是实现单机版Redis整合

 34.1 相关依赖

          <dependency>
          <groupId>org.springframework.boot</groupId>
          <artifactId>spring-boot-starter-web</artifactId>  
       </dependency>
  
           <!-- mybatis(注解方式) -->
       <dependency>
               <groupId>org.mybatis.spring.boot</groupId>
               <artifactId>mybatis-spring-boot-starter</artifactId>
               <version>1.3.1</version>
       </dependency>
       
       <!-- Mysql -->
       <dependency>
               <groupId>mysql</groupId>
               <artifactId>mysql-connector-java</artifactId>
       </dependency>
       
       <!-- redis依赖 -->
       <dependency>  
            <groupId>org.springframework.boot</groupId>  
            <artifactId>spring-boot-starter-data-redis</artifactId>  
       </dependency>

34.2  mysql和redis的配置

#数据库配置
spring.datasource.driver-class-name=com.mysql.jdbc.Driver
spring.datasource.username=root
spring.datasource.password=
spring.datasource.url=jdbc:mysql://localhost:3306/springboot

#redis单服务器配置
spring.redis.database=0
spring.redis.host=127.0.0.1
spring.redis.port=6379
spring.redis.pool.max-active=8
spring.reids.pool.max-wait=-1
spring.redis.pool.max-idle=8
spring.redis.pool.min-idle=0
spring.redis.timeout=0
    

34.3 开启缓存

在启动类上添加@EnableCaching 注解 

package com.wu.app;

import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cache.annotation.EnableCaching;


@SpringBootApplication(scanBasePackages={"com.wu.controller","com.wu.service"})
@MapperScan("com.wu.mapper")//需要单独扫描
@EnableCaching//开启缓存
public class SpringApplications {
        //程序启动入口
        public static void main(String []args){
            SpringApplication.run(SpringApplications.class, args);
        }
}

在需要缓存的service层方法中添加@Cacheable 注解

package com.wu.service;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Service;

import com.wu.mapper.UsersMapper;
import com.wu.pojo.Users;
@Service
public class UsersServiceImp implements UsersService {
    @Autowired
    private UsersMapper mapper;
    
    @Cacheable(value="user")//设置键值
    @Override
    public Users selectByName(String name) {
        System.out.println("从数据库中查找");
        return mapper.selectByName(name);
    }
    
    
}

实体类需要实现序列化接口 implements Serializable

public class Users implements Serializable{
    private Integer id;

    private String name;

    private String password;

    private String email;

    private Date birthday;

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name == null ? null : name.trim();
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password == null ? null : password.trim();
    }

    public String getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email == null ? null : email.trim();
    }

    public Date getBirthday() {
        return birthday;
    }

    public void setBirthday(Date birthday) {
        this.birthday = birthday;
    }

 34.4 结果

这样第一次查询时即从数据库查询，再次查询即从缓存中加载 

三十五 SpringBoot整合Redis集群

35.0 搭建redis集群     参考文档

35.1 相关依赖（跟单机版一样）

35.2 相关配置

#数据库配置
spring.datasource.driver-class-name=com.mysql.jdbc.Driver
spring.datasource.username=root
spring.datasource.password=
spring.datasource.url=jdbc:mysql://localhost:3306/springboot

#redis cluster配置
spring.redis.cluster.nodes=192.168.198.129:7001,192.168.198.129:7002,192.168.198.129:7003,192.168.198.129:7004,192.168.198.129:7005,192.168.198.129:7006
    

35.3 编写Redis集群的配置类

package com.wu.configure;

import java.util.HashSet;
import java.util.Set;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import redis.clients.jedis.HostAndPort;
import redis.clients.jedis.JedisCluster;

@Configuration
public class RedisClusterConfigrue {
    @Value("${spring.redis.cluster.nodes}")
    private String nodes;

    @Bean
    public JedisCluster jedisCluster(){
        //分割
        String[] nodesArray = nodes.split(",");
        Set<HostAndPort> hostAndPorts=new HashSet<>();
        for (String node : nodesArray) {
                //分割
                String[] array = node.split(":");
                HostAndPort hostAndPort=new HostAndPort(array[0],Integer.parseInt(array[1]));
                hostAndPorts.add(hostAndPort);
            }
        JedisCluster jedisCluster=new JedisCluster(hostAndPorts);
        return jedisCluster;
        
    }
}

35.4 简单测试

在service层的实现类中引入 

@Autowired
private JedisCluster JedisCluster;

添加如下方法

@Override
    public String getRedisValue() {
        JedisCluster.set("key","value");
        return JedisCluster.get("key");
    }

在controller层中调用该方法

@RequestMapping("/redis")
    public String getRedisValue(){
        return service.getRedisValue();
    }

 三十六 使用RedisTemplate操作redis

参考： 

36.1 相关依赖

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

36.2 相关配置

spring:
  datasource:
    username: root
    password: '123456'
    driver-class-name: com.mysql.jdbc.Driver
    url: jdbc:mysql://localhost/test
    type: com.alibaba.druid.pool.DruidDataSource
  redis:
    port: 6379
    jedis:
      pool:
        max-active: 50
        min-idle: 20
    host: 127.0.0.1
    database: 11

@Configuration
public class RedisConfig {
    @Bean
    public RedisTemplate redisTemplate(RedisConnectionFactory redisConnectionFactory){
        RedisTemplate redisTemplate=new RedisTemplate();
        redisTemplate.setConnectionFactory(redisConnectionFactory);
        //Key的序列化
        StringRedisSerializer stringRedisSerializer=new StringRedisSerializer();
        redisTemplate.setKeySerializer(stringRedisSerializer);
        //value的序列化
        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer=new Jackson2JsonRedisSerializer(Object.class);

        ObjectMapper objectMapper =  new ObjectMapper();
        
        //定制 DateTime类型的序列化和反序列化
        SimpleModule simpleModule = new SimpleModule();
        simpleModule.addSerializer(DateTime.class,new JodaDateTimeJsonSerializer());
        simpleModule.addDeserializer(DateTime.class,new JodaDateTimeJsonDeserializer());
        
        //设置类信息
        objectMapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        
        //绑定simpleModule
        objectMapper.registerModule(simpleModule);

        //绑定objectMapper
        jackson2JsonRedisSerializer.setObjectMapper(objectMapper);

        redisTemplate.setValueSerializer(jackson2JsonRedisSerializer);
        return redisTemplate;
    }
}

如果需要序列化的实体类中使用了 joda 的 DateTime 类型的属性，（需要引入相关依赖

    <dependency>
      <groupId>joda-time</groupId>
      <artifactId>joda-time</artifactId>
      <version>2.9.1</version>
    </dependency>

 

），对该类型的序列化话可以额外配置，如下：

public class JodaDateTimeJsonSerializer extends JsonSerializer<DateTime> {
    @Override
    public void serialize(DateTime dateTime, JsonGenerator jsonGenerator, SerializerProvider serializerProvider) throws IOException {
        jsonGenerator.writeString(dateTime.toString("yyyy-MM-dd HH:mm:ss"));
    }
}

public class JodaDateTimeJsonDeserializer extends JsonDeserializer<DateTime> {
    @Override
    public DateTime deserialize(JsonParser jsonParser, DeserializationContext deserializationContext) throws IOException, JsonProcessingException {
        String dateString =jsonParser.readValueAs(String.class);
        DateTimeFormatter formatter = DateTimeFormat.forPattern("yyyy-MM-dd HH:mm:ss");

        return DateTime.parse(dateString,formatter);
    }
}

然后引入到RedisConfig配置中

　　36.2.1 拓展  

 RestTemplate 三种常用的序列化规则：具体参考 这里 

序列化规则	说明
JdkSerializationRedisSerializer	默认序列化规则，要求对象必须实现 Serialable 接口
StringRedisSerializer	对象只能为 String
GenericJackson2JsonRedisSerializer	Java 与 JSON 的序列化与反序列化，好处是不需要对象实现 Serialable 接口， 但需要引入 jackson-databind 包

36.3 使用

　　36.3.1 引入

@Autowired
private RedisTemplate redisTemplate;

　　36.3.2 RedisTemplate Api总结