微服务架构Day36-Dubbo之数据缓存

原创

攻城狮Chova 2022-03-09 17:44:52 ©著作权

文章标签 redis ide 缓存 文章分类 架构后端开发

©著作权归作者所有：来自51CTO博客作者攻城狮Chova的原创作品，请联系作者获取转载授权，否则将追究法律责任

Redis实现数据缓存

创建缓存服务

创建缓存服务接口项目
创建缓存服务提供者项目
创建缓存服务消费者项目

MyBatis Redis二级缓存

MyBatis缓存
配置MyBatis二级缓存

SpringBoot中开启MyBatis二级缓存
实体类实现序列化接口并声明序列号
实现Mybatis Cache接口,自定义缓存为Redis
Mapper接口类中标注注解

创建缓存服务

创建缓存服务接口项目

创建myshop-service-redis-api项目,该项目只负责定义接口
创建项目的pom.xml:

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>com.oxford</groupId>
        <artifactId>myshop-dependencies</artifactId>
        <version>1.0.0-SNAPSHOT</version>
        <relativePath>../myshop-dependencies/pom.xml</relativePath>
    </parent>

    <artifactId>myshop-service-redis-api</artifactId>
    <packaging>jar</packaging>
</project>

定义数据Redis接口RedisService:

package com.oxford.myshop.service.redis.api

public interface RedisService{
  void set(String key,Object value);

  void set(String key,Object value,int seconds);

  void del(String key);

  Object get(String key);
}

创建缓存服务提供者项目

创建myshop-service-redis-provider项目,该项目用作缓存服务提供者
创建项目的pom.xml:

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>com.oxford</groupId>
        <artifactId>myshop-dependencies</artifactId>
        <version>1.0.0-SNAPSHOT</version>
        <relativePath>../myshop-dependencies/pom.xml</relativePath>
    </parent>

    <artifactId>myshop-service-redis-api</artifactId>
    <packaging>jar</packaging>

    <dependencies>
        <!-- Spring Boot Starter Settings-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>


        <!--Common Setting-->
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-pool2</artifactId>
        </dependency>
        <dependency>
            <groupId>de.javakaffee</groupId>
            <artifactId>kryo-serializers</artifactId>
        </dependency>

        <!--Project Settings-->
        <dependency>
            <groupId>com.oxford</groupId>
            <artifactId>my-shop-commons-dubbo</artifactId>
            <version>${Project.parent.version}</version>
        </dependency>
        <dependency>
            <groupId>com.oxford</groupId>
            <artifactId>my-shop-service-redis-api</artifactId>
            <version>${Project.parent.version}</version>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <configuration>
                    <mainClass>com.oxford.myshop.service.redis.provider.MyshopServiceRedisProviderApplication</mainClass>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>

Redis底层实现的Java的lettuce客户端

创建缓存服务接口实现类RedisServiceImpl

package com.oxford.myshop.service.redis.provider.api.impl;

@Service(version="${service.versions.redis.v1}")
public class RedisServiceImpl implements RedisService{

  @Override
  public void set(String key,Object value){
    redisTemplate.opsForValue().set(key,value);
  }

  @Override
  public void set(String key,Object value,int seconds){
    redisTemplate.opsForValue().set(key,value,seconds,TimeUnit.SECONDS);
  }

  @Override
  public void del(String key){
    redisTemplate.delete(key);
  }

  @Override
  public Object get(String key){
    return redisTemplate.opsForValue().get(key);
  }
}

创建启动类SpringBootApplication

package com.oxford.myshop.service.redis.provider;

import com.alibaba.dubbo.container.Main;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.hystrix.EnableHystrix;
import org.springframework.cloud.netflix.hystrix.dashboard.EnableHystrixDashboard;



@EnableHystrix
@EnableHystrixDashboard
public class MyShopServiceRedisrProviderApplication {
    public static void main(String[]args) {
        SpringApplication.run(MyShopServiceRedisProviderApplication.class,args);
        Main.main(args);
    }
}

创建配置文件application.yml

spring:
  application:
    name: myshop-service-redis-provider
  redis:
    lettuce:
      pool:
        max-active: 8
        max-idle: 8
        max-wait: -1ms
        min-idle: 0
    sentinel:
      master: mymaster
      nodes: 192.168.32.255:26379,192.168.32.255:26380,192.168.32.255:26381
server:
  port: 8503

services:
  version:
    redis:
      v1: 1.0.0
    user:
      v1: 1.0.0

dubbo:
  scan:
    basePackages: com.oxford.myshop.service.redis.provider.api.impl
  application:
    id: com.oxford.myshop.service.redis.provider.api
    name: com.oxford.myshop.service.redis.provider.api
    qos-port: 22224
    qos-enable: true
  protocal:
    id: dubbo
    name: dubbo
    port: 20883
    status: server
    serialization: kryo

  regitry:
    id: zookeeper
    address: zookeeper://localhost:2181?backup=192.168.32.255:2182,192.168.32.255:2183

management:
  endpoint:
    dubbo:
      enabled: true
    dubbo-shutdown:
      enabled: true
    dubbo-configs:
      enabled: true
    dubbo-sevicies:
      enabled: true
    dubbo-reference:
      enabled: true
    dubbo-properties:
      enabled: true
  health:
    dubbo:
      status:
        defaults: memory
        extras: load,threadpool

创建缓存服务消费者项目

在pom文件中引入redis接口依赖
在缓存服务消费者项目的ServiceImpl中调用RedisService

@Reference(version="services.versions.redis.v1")
private RedisService redisService;

MyBatis Redis二级缓存

MyBatis缓存

一级缓存:

MyBatis会在表示会话的SqlSession对象中建立一个简单的缓存: 将每次查询到的结果缓存起来,当下次查询的时候,如果判断先前有个完全一样的查询,会直接从缓存中直接将结果取出,返回给用户,不需要再进行一次数据库查询
一级缓存是SqlSession级别的缓存:

在操作数据库时需要构造SqlSession对象
对象中有一个(内存区域)数据结构(HashMap)用于存储缓存数据
不同的SqlSession之间的缓存数据区域(HashMap)互不影响,
一级缓存的作用域是同一个SqlSession
在同一个SqlSession中两次执行相同的SQL语句: 第一次执行完毕会将数据库中查询的数据写到缓存(内存),第二次会从缓存中获取数据,将不再从数据库查询,从而提高查询效率
当一个SqlSession结束后该SqlSession中的一级缓存就不存在了
MyBatis默认开启一级缓存

二级缓存:

二级缓存是Mapper级别的缓存: 多个SqlSession去操作同一个Mapper的SQL语句,多个SqlSession去操作数据库得到数据会存在二级缓存区域,多个SqlSession可以共用二级缓存,二级缓存是跨SqlSession的
二级缓存的作用域是mapper的同一个namespace
不同的SqlSession两次执行相同namespace下的SQL语句且向SQL中传递参数也相同即最终执行相同的SQL语句: 第一次执行完毕会将数据库中查询的数据写到缓存(内存),第二次会从缓存中获取数据将不再从数据库查询,从而提高查询效率
MyBatis默认没有开启二级缓存,需要在setting全局参数中配置开启二级缓存

配置MyBatis二级缓存

SpringBoot中开启MyBatis二级缓存

在myshop-service-user-provider的配置文件中开启MyBatis二级缓存

spring:
  application:
    name: myshop-service-user-provider
  datasource:
    druid:
      url: jdbc:mysql://localhost:3306/myshop?useUnicode=true&characterEncoding=utf-8&useSSL=false
      username: root
      password: 123456
      initial-size: 1
      min-idle: 1
      main-active: 20
      test-on-borrow: true
      driver-class-name: com.mysql.cj.jdbc.Driver
  redis:
    lettuce:
      pool:
        max-active: 8
        max-idle: 8
        max-wait: -1ms
        min-idle: 0
    sentinel:
      master: mymaster
      nodes: 192.168.32.255:26379,192.168.32.255:26380,192.168.32.255:26381

server:
  port: 8501

# MyBatis Config properties
mybatis:
  configuration:
    cache-enabled: true
  type-aliases-package: com.oxford.myshop.commons.domain
  mapper-location: classpath:mapper/*.xml

services:
  version:
    redis:
      v1: 1.0.0
    user:
      v1: 1.0.0

dubbo:
  scan:
    basePackages: com.oxford.myshop.service.user.provider.api.impl
  application:
    id: com.oxford.myshop.service.user.provider.api
    name: com.oxford.myshop.service.user.provider.api
    qos-port: 22222
    qos-enable: true
  protocal:
    id: dubbo
    name: dubbo
    port: 20001
    status: server
    serialization: kryo

  regitry:
    id: zookeeper
    address: zookeeper://localhost:2181?backup=192.168.32.255:2182,192.168.32.255:2183

management:
  endpoint:
    dubbo:
      enabled: true
    dubbo-shutdown:
      enabled: true
    dubbo-configs:
      enabled: true
    dubbo-sevicies:
      enabled: true
    dubbo-reference:
      enabled: true
    dubbo-properties:
      enabled: true
  health:
    dubbo:
      status:
        defaults: memory
        extras: load,threadpool

在myshop-commons-mapper的pom.xml中增加redis依赖:

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

<dependency>
  <groupId>org.apache.commons</groupId>
  <artifactId>commons-pool2</artifacted>
</dependency>

实体类实现序列化接口并声明序列号

private static final long serialVersionUID = 82897704415244673535L

IDEA生成序列号方法:
- 使用GenerateSerialVersionUID插件生成,安装完插件后在实现了序列化接口的类中
- 使用快捷键Alt+Insert即可呼出生成菜单,即可自动生成序列号

实现Mybatis Cache接口,自定义缓存为Redis

在myshop-commons项目中创建ApplicationContextHolder类

package com.oxford.myshop.commons.context;

@Component
public class ApplicationContextHolder implements ApplicationContextAware,DisposableBean{

  private static final Logger logger=LoggerFactory.getLogger(ApplicationContext.class);

  private static ApplicationContext applicationContext;

  /**
   * 获取存储在静态变量中的ApplicationContext
   */
   public static ApplicationContext getApplicationContext(){
    assertContextInjected();
    return applicationContext;
   }

  /**
   * 从静态变量applicationContext中获取Bean,自动转型成所赋值对象的类型
   */
   public static <T> T getBean(String name){
    assertContextInjected();
    return (T) applicationContext.getBean(name);
   }

  /**
   * 从静态变量applicationContext中获取Bean,自动转型成所赋值对象的类型
   */
  public static <T> T getBean(Class<T> clazz){
    assertContextInjected();
    return (T) applicationContext.getBean(clazz);
   }

  /**
   * 实现DisposableBean接口,在Context关闭时清理静态变量
   */
   public void destroy() throws Exception{
    logger.debug("清除 SpringContext 中的 ApplicationContext: {}",applicationContext);
    applicationContext=null;
   }

  /**
   * 实现ApplicationContextAware接口,注入Context到静态变量中
   */
   public void setApplicationContext(ApplicationContext applicationContext) throws BeanException{
    ApplicationContext.applicationContext=applicationContext;
   }

  /**
   * 断言Context已经注入
   */
   private static void assertContextInjected(){
    Validate.validState(applicationContext !=null,"applicationContext 属性未注入,请在配置文件中配置定义ApplicationContextContext");
  }
}

在myshop-commons-mapper项目中创建一个RedisCache的工具类

package com.oxford.myshop.commons.utils;

public class RedisCache implements Cache{
  private static final Logger logger=LoggerFactory.getLogger(RedisCache.class);

  private final ReadWriteLock readWriteLock=new ReentranReadWriteLock();
  private final String id;
  private RedisTemplate redisTemplate;

  private static final long EXPIRE_TIME_IN_MINUTES=30   // redis过期时间

  public RedisCache(String id){
    if(id==null){
      throw new IllegalArgumentException("Cache instances require an ID");
    }
    this.id=id;
  }

  @Override
  public String getId(){
    return id;
  }

  /**
   * Put query result to redis 
   */
  @Override
  public void putObject(Object key,Object value){
    try{
      RedisTemplate redisTemplate=getRedisTemplate();
      ValueOperations opsForValue=redisTemplate.opsForValue();
      opsForValue.set(key, value, EXPIRE_TIME_IN_MINUTES, TimeUnit.MINUTES);
      logger.debug("Put query result to redis");
    }catch(Throwable t){
      logger.error("Redis put failed",t);
    }
  }

  /**
   * Get cached query result from redis 
   */
   @Override
   public Object getObject(Object key){
    try{
      RedisTemplate redisTemplate=getRedisTemplate();
      ValueOperations opsForValue=redisTemplate.opsForValue();
      opsForValue.set(key, value, EXPIRE_TIME_IN_MINUTES, TimeUnit.MINUTES);
      logger.debug("Get cache query result from redis");
      return opsForValue.get(key);
    }catch(Throwable t){
      logger.error("Redis get failed, fail over to db");
      return null;
    }
  }

  /**
   * Get cached query result from redis 
   */
   @Override
   public Object getObject(Object key){
    try{
      RedisTemplate redisTemplate=getRedisTemplate();
      ValueOperations opsForValue=redisTemplate.opsForValue();
      opsForValue.set(key, value, EXPIRE_TIME_IN_MINUTES, TimeUnit.MINUTES);
      logger.debug("Get cache query result from redis");
      return opsForValue.get(key);
    }catch(Throwable t){
      logger.error("Redis get failed, fail over to db");
      return null;
    }
  }

  /**
   * Remove cached query result from redis 
   */
   @Override
   @SuppressWarnings("unchecked")
   public Object removeObject(Object key){
    try{
      RedisTemplate redisTemplate=getRedisTemplate();
      redisTemplate.delete(key);
      logger.debug("Remove cached query result from redis");
    }catch(Throwable t){
      logger.error("Redis remove failed");
    }
      return null;
  }

  /**
   * Clear this cache instance
   */
   @Override
   public void clear(){
    RedisTemplate redisTemplate=getRedisTemplate();
    redisTemplate.execute((RedisCallback)->{
      connection.flushDb();
      return null;
    });
    logger.debug("Clear all the cached query result from redis");
   }

  @Override
  public int getSize(){
    return 0;
  }

  @Override
  public ReadWriteLock getReadWriteLock(){
    return readWriteLock;
  }

  private RedisTemplate getRedisTemplate(){
    if(redisTemplate==null){
      redisTemplate=ApplicationContextHolder.getBean("redisTemplate");
    }
    return redisTemplate;
  }
}

Mapper接口类中标注注解

在Mapper接口类上标注注解,声明使用二级缓存

@CacheNamespace(implementation=RedisCache.class)

上一篇：微服务项目框架技术整理

下一篇：IDEA使用过程的注意点

提问和评论都可以，用心的回复会被更多人看到评论

发布评论

相关文章

官方博客	全部文章	热门标签	班级博客
了解我们	网站地图	意见反馈

鸿蒙开发者社区	51CTO学堂
51CTO	软考资讯