【Spring Boot学習まとめ】14.Spring Boot統合Redis-従来方式との比較

Spring Bootを使用してトランザクションを制御する方法について説明しました.次に、Spring Bootを使用してRedisを統合する方法について説明します.従来のエンジニアリングとSpring Bootの統合の違いを比較し、Spring Bootの統合の優位性を明らかにするために、従来の統合方法とSpring Bootの統合方法を一つ一つ分析します.

一、従来方式の統合Redis

Spring Bootを使用しない従来のエンジニアリングでは、XMLプロファイルを使用してRedisを統合しています.まず、POMファイルにRedisの依存関係を導入します.

    org.springframework.data
    spring-data-redis
    1.6.0.RELEASE


    redis.clients
    jedis
    2.7.3

次にredisを作成します.propertiesファイル、redisの接続情報を構成するために使用されます.

# Redis     
redis.host=127.0.0.1
# Redis       
redis.port=6379  
# Redis       （    ）
redis.pass=password
redis.dbIndex=0  
# Redis Key     
redis.expiration=3000  
#            
redis.maxIdle=300  
#         （          ）
redis.maxActive=600  
#            （          ）
redis.maxWait=1000  
redis.testOnBorrow=true

次にSpringのプロファイル(データソース、セッションファクトリなどのBean構成を含むファイル)にRedisのプロファイルを追加します.

ここで、JedisPoolConfig、JedisConnectionFactory、RedisTemplate、RedisCacheManager、RedisCacheConfigがそれぞれ構成されている.ここで、(1)JedisPoolConfig JedisPoolConfigクラスには、redis接続プールの構成情報が設定されており、構成情報によってredisデータベース接続プールのいくつかの接続操作を制御する.
(2)JedisConnectionFactory JedisConnectionFactoryクラスはredisデータベースの接続ファクトリクラスであり,DataSourceを導入したSqlSessionFactoryデータベースセッションファクトリに類似している.このクラスは、構成されたredisデータベースの接続情報によってredisデータベースと接続操作を行い、対応する接続インスタンスオブジェクトを返します.
(3)RedisTemplate RedisTemplateクラスはredis操作クラスであり、JedisConnectionFactory接続ファクトリを導入して接続を取得し、redisの各種操作APIを対外的に提供し、プロジェクトでは直接RedisTemplateクラスを使用してredisデータベースの操作を行うことができる.
(4)RedisCacheManager RedisCacheManagerはredisカスタムのツールクラスであり、構築方法にRedisTemplateを導入し、redisデータベースにおけるkey-valueデータの管理を目的としており、例えばkeyの失効時間を設定しているなどである.
(5)RedisCacheConfig RedisCacheConfigクラスは,redisの統一的なスケジューリングと管理のために開発者がカスタマイズする必要があるクラスである.このクラスは、JedisConnectionFactory、RedisTemplate、RedisCacheManagerをそれぞれ注入するCachingConfigurerSupportの親クラスを継承する必要があります.以下はカスタムRedisCacheConfigです.

package com.ssm.utils;
import java.lang.reflect.Method;
import org.springframework.cache.annotation.CachingConfigurerSupport;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.cache.interceptor.KeyGenerator;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.cache.RedisCacheManager;
import org.springframework.data.redis.connection.jedis.JedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;

/**
 *   spring  redis    
 * @author Administrator
 */
@Configuration  
@EnableCaching 
public class RedisCacheConfig extends CachingConfigurerSupport {
    private volatile JedisConnectionFactory jedisConnectionFactory;
    private volatile RedisTemplate redisTemplate;
    private volatile RedisCacheManager redisCacheManager;

    public RedisCacheConfig() {
        super();
    }

    /**
     *                    
     * 
     * @param jedisConnectionFactory
     * @param redisTemplate
     * @param redisCacheManager
     */
    public RedisCacheConfig(JedisConnectionFactory jedisConnectionFactory, RedisTemplate redisTemplate,
            RedisCacheManager redisCacheManager) {
        this.jedisConnectionFactory = jedisConnectionFactory;
        this.redisTemplate = redisTemplate;
        this.redisCacheManager = redisCacheManager;
    }

    public JedisConnectionFactory getJedisConnecionFactory() {
        return jedisConnectionFactory;
    }

    public RedisTemplate getRedisTemplate() {
        return redisTemplate;
    }

    public RedisCacheManager getRedisCacheManager() {
        return redisCacheManager;
    }

    @Bean
    public KeyGenerator customKeyGenerator() {
        return new KeyGenerator() {
            @Override
            public Object generate(Object target, Method method, Object... objects) {
                StringBuilder sb = new StringBuilder();
                sb.append(target.getClass().getName());
                sb.append(method.getName());
                for (Object obj : objects) {
                    sb.append(obj.toString());
                }
                return sb.toString();
            }
        };
    }
}

このクラスはCachingConfigurerSupportを継承し、redis関連設定を手動で変更します.ここでcustomKeyGeneratorメソッドを書き換え,keyのデフォルト生成方式(クラス名+メソッド名)を提供する.次に、私たちのサービスでキャッシュを使用します.2つの方法があります.1つ目は、ツールクラスxxxRedisUtilsを開発し、RedisTemplateクラスをクラスに注入し、次のような操作を提供することです.

@Service
public class RedisCacheUtil{

     @Autowired @Qualifier("jedisTemplate")
     public RedisTemplate redisTemplate;

     /**
      *        ，Integer、String、    
      * @param key      
      * @param value     
      * @return       
      */
     public  ValueOperations setCacheObject(String key,T value){
          ValueOperations operation = redisTemplate.opsForValue(); 
          operation.set(key,value);
          return operation;
     }
     
     //        ...
}

次に、サービスにRedisCacheUtilクラスを注入してキャッシュする操作を行います.

@Autowired
private RedisCacheUtil redisCache;

2つ目は、サービスで直接注釈を使用してキャッシュの操作を行うことです.これも便利な方法です.@Cacheableと@CacheEveictの2つの一般的な注釈があります.キャッシュの設定とクリーンアップに使用されます.(1)@Cacheable(「a」)この注釈の意味は、この方法のクエリー結果をredisに入れ、次のクエリーを開始するとredisに取りに行きます.redisに存在するデータのkeyはaです.(2)@CacheEveict(value={"a","b"},allEntries=true)この注記は、このメソッドを実行した後にredisのkey名がa,bのデータを消去することを意味する.使用例:

@Cacheable("getUserById")//              ，               
@Override
public User getUserById(int userId) {
    return this.iUserDao.selectByPrimaryKey(userId);
}

@CacheEvict(value= {"getAllUser","getUserById","findUsers"},allEntries=true)//    ，allEntries              
@Override
public void insertUser(User user) {
    this.iUserDao.insertUser(user);
}

以上,従来方式を用いてredisを統合する操作方式である.構成手順が煩雑であることがわかります.

二、Spring Bootを用いてRedis原理剖析を統合する

はっきり言って、Spring BootはRedisの統合に対して、一部Spring Bootの自動配置メカニズムに依存している.Spring BootのSpring Bootの自動化構成の原理について説明します.一般的にSpring Bootを使用するときに起動クラスを作成します.

package cn.com.springboot;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
//Sprnig Boot       ，           
public class MainApplication {
    // main           
    public static void main(String[] args) {
        SpringApplication.run(MainApplication.class, args);
    }
}

Spring Bootは自動構成(@SpringBootApplicationの@EnableAutoConfiguration)をオンにできるため、SpringBootApplicationオブジェクトがインスタンス化されるとspring-bootのjarのMETA-INF/springがロードする.factoriesファイル.redisに関連する自動構成クラスを含む、自動構成ロードが必要なエンティティクラスが設定されています.

org.springframework.boot.autoconfigure.data.redis.RedisAutoConfiguration,\
org.springframework.boot.autoconfigure.data.redis.RedisRepositoriesAutoConfiguration,\

ここで、RedisAutoConfigurationクラスは構成項目としてRedisPropertiesクラスのパラメータを読み込みます.RedisPropertiesの接続パラメータは、propertiesで構成されている「spring.redis」で始まる構成項目を読み込みます.ソースコードで次のことがわかります.

package org.springframework.boot.autoconfigure.data.redis;
import java.util.List;
import org.springframework.boot.context.properties.ConfigurationProperties;

@ConfigurationProperties(prefix = "spring.redis")
public class RedisProperties {
    //      ...
}

RedisAutoConfigurationは、いくつかのカラムの構成を自動的に作成してくれます.開発では、少量の構成が自分のredisサービスアドレスを指すように変更するだけです.
では、Spring Bootのpropertiesファイルで「spring.redis」接頭辞を使用してredis接続情報の構成を行うだけで、redisを使用することができます.便利ではないでしょうか.
次はSpring Boot連がredisを統合する方法です.

三、Spring Bootを用いてRedisを統合するステップ

まず、POMファイルにredisの起動依存性を導入します.

    org.springframework.boot
    spring-boot-starter-data-redis

次に、プロジェクト起動クラスを変更し、注記@EnableCachingを追加し、キャッシュ機能を次のように開きます.

package cn.com.springboot;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.scheduling.annotation.EnableScheduling;

@SpringBootApplication
//Sprnig Boot       ，           
@EnableScheduling
@EnableCaching
public class MainApplication {
    // main           
    public static void main(String[] args) {
        SpringApplication.run(MainApplication.class, args);
    }
}

そしてアプリケーションでpropertiesでは、次のようにRedis接続情報を構成します.

# Redis     （   0）
spring.redis.database=0
# Redis     
spring.redis.host=172.31.19.222
# 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=0
#       （  ）
spring.redis.timeout=0

次に、キャッシュキー生成ポリシー、キャッシュマネージャ、RedisTemplateなどを定義するRedisキャッシュ構成クラスRedisConfigを作成します.次のようになります.

package springboot.config;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.cache.CacheManager;
import org.springframework.cache.annotation.CachingConfigurerSupport;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.cache.RedisCacheManager;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;

import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;


/**
 * Redis     
 * @author szekinwin
 *
 */
@Configuration
@EnableCaching
public class RedisConfig extends CachingConfigurerSupport{

    @Value("${spring.redis.host}")
    private String host;
    @Value("${spring.redis.port}")
    private int port;
    @Value("${spring.redis.timeout}")
    private int timeout;
    
    //     key    
    @Bean
    public KeyGenerator keyGenerator() {
        return new KeyGenerator(){
            @Override
                public Object generate(Object target, java.lang.reflect.Method method, Object... params) {
                    StringBuffer sb = new StringBuffer();
                    sb.append(target.getClass().getName());
                    sb.append(method.getName());
                    for(Object obj:params){
                        sb.append(obj.toString());
                    }
                    return sb.toString();
                }
            };
    }
    //     
    @Bean 
    public CacheManager cacheManager(@SuppressWarnings("rawtypes") RedisTemplate redisTemplate) {
        RedisCacheManager cacheManager = new RedisCacheManager(redisTemplate);
        //         
        cacheManager.setDefaultExpiration(10000);
        return cacheManager;
    }
    @Bean
    public RedisTemplate redisTemplate(RedisConnectionFactory factory){
        StringRedisTemplate template = new StringRedisTemplate(factory);
        setSerializer(template);//       
        template.afterPropertiesSet();
        return template;
    }
     private void setSerializer(StringRedisTemplate template){
            @SuppressWarnings({ "rawtypes", "unchecked" })
            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);
            template.setValueSerializer(jackson2JsonRedisSerializer);
     }
}

その後、サービスでredisTemplateを使用するか、@Cacheableと@CacheEveictを直接使用してキャッシュ操作を行えばよい.
もちろん、最初のセクションで述べたように、従来の構成を使用してredisの設定を行うこともできます.異なるのは、XML構成の代わりにJava構成を使用して、redisコアの操作を自分で制御する必要があるプロジェクトに適していることです.Java方式で構成するには、クラスを新規作成して@Configuration注記を使用し、構成されたRedisTemplateクラスを使用してredisデータベースの操作を行います.ここではこれ以上述べない.

四、補足：redisクラスタ操作

上記の操作はすべてredis単機版に対して行われていますが、現在、私たちの企業レベルのプロジェクトはredisクラスタを構築してredis管理を行っています.ここでは、従来のモードとSpring Bootモードによるredisクラスタの操作を補足します.
(1)従来方式ではredisクラスタを操作するredisを修正する.propertis、クラスタ構成の配置:

redis.host1=192.168.1.235
redis.port1=7001
redis.host2=192.168.1.235
redis.port2=7002
redis.host3=192.168.1.235
redis.port3=7003
redis.host4=192.168.1.235
redis.port4=7004
redis.host5=192.168.1.235
redis.port5=7005
redis.host6=192.168.1.235
redis.port6=7006
 
redis.maxRedirects=3
redis.maxIdle=30
redis.maxTotal=100
redis.minIdle=5
redis.maxWaitMillis=30000 
redis.testOnBorrow=true
redis.testOnReturn=true 
redis.testWhileIdle=true
redis.timeout=3000

次にspringプロファイルで、RedisClusterConfigurationクラスを構成し、クラスタ情報を配置します.

次に、構成済みのRedisClusterConfigurationをパラメータとして、以前に構成したjeidsConnectionFactoryに導入します.

その他の構成は変更する必要はなく(redisTemplateなどの構成)、後でredisを使用する操作も同様です.
redisがプライマリ・スレーブを構成している場合は、プロファイル:

#sentinel1 IP     
sentinel1.host=192.168.1.233
sentinel1.port=26379  
#sentinel2 IP     
sentinel2.host=192.168.1.233
sentinel2.port=26378 
 
im.hs.server.redis.maxIdle=500  
#     ，        redis     
im.hs.server.redis.maxTotal=5000  
im.hs.server.redis.maxWaitTime=1000  
im.hs.server.redis.testOnBorrow=true  
#       ，spring                      ，        。  
im.hs.server.redis.minIdle=300
im.hs.server.redis.sentinel.masterName=mymaster

次に、XMLプロファイルでredisSentinelConfigurationクラスを構成し、redisマスター情報を挿入します.

解釈:sentinelは哨兵を意味し、主従サーバーの運行状況を監視し、主従サーバーが切れた場合、サーバーから主従サーバーとして1つを選択する.その他の構成は変更する必要はなく(redisTemplateなどの構成)、後でredisを使用する操作も同様です.
(2)Spring Boot操作redisクラスタSpring Bootのクラスタ構成は簡単で、元の構成を以下のように修正する.

spring.redis.cluster.nodes=127.0.0.1:26379,127.0.0.1:26479,127.0.0.1:26579
spring.redis.password=password

残りの操作は前の通りです.
主従の構成:

# database name
spring.redis.database=0
# server host1     ，     ip
#spring.redis.host=127.0.0.1  
# server password   ，         
#spring.redis.password=
#connection port      ，     
#spring.redis.port=6379
# pool settings ...   
spring.redis.pool.max-idle=8
spring.redis.pool.min-idle=0
spring.redis.pool.max-active=8
spring.redis.pool.max-wait=-1
# name of Redis server       Redis server   
spring.redis.sentinel.master=mymaster
# comma-separated list of host:port pairs         
spring.redis.sentinel.nodes=127.0.0.1:26379,127.0.0.1:26479,127.0.0.1:26579

以上がSpringおよびSpring Bootのredisへの統合である.
参考:Spring統合redis:https://www.cnblogs.com/hello-daocaoren/p/7891907.htmlSpringBootはRedisキャッシュを使用します.https://www.cnblogs.com/gdpuzxs/p/7222309.htmlSpring統合redis(クラスタ、主従):https://blog.csdn.net/sunqingzhong44/article/details/70976038?locationNum=6&fps=1Spring boot統合redis主従sentinel:https://blog.csdn.net/liuchuanhong1/article/details/54601037
転載は出典を明記してください.https://blog.csdn.net/acmman/article/details/83035604