程序员社区
当前位置：IDEA激活码 > 未分类 > 正文

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

2022-02-04 分类：未分类 阅读(234)

创建缓存服务

创建缓存服务接口项目

  • 创建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)
赞(0) 打赏
未经允许不得转载：IDEA激活码 » 微服务架构Day36-Dubbo之数据缓存

相关推荐

IDEA永久激活破解教程,IDEA激活码

pycharm激活破解教程,pycharm激活码

Java视频资源

Java电子书

DataGrip激活教程 Docker Git教程 IntellIJ idea IntelliJ IDEA激活码 Java Java IO Java基础 Java基础面试题 Java集合面试题 Java面试题 JVM JVM面试题 Linux MySQL MySQL面试题 Nginx PyCharm PyCharm激活 redis Redis SpringBoot SpringBoot SpringBoot面试题 Web开发 剑指Offer系列 多线程 多线程并发面试题 字符串面试题 数据库 数据库 数据结构与算法 未分类 爬虫 电子书 软件下载

一个分享Java & Python知识的社区