基于starter-自定义缓存框架

最新推荐文章于 2023-01-28 00:29:46 发布

LuckyToMeet-Dian叶

最新推荐文章于 2023-01-28 00:29:46 发布

阅读量411

点赞数

分类专栏：个人随笔

本文链接：https://blog.csdn.net/weixin_41622183/article/details/105665862

版权

个人随笔专栏收录该内容

12 篇文章 0 订阅

订阅专栏

浅谈

编写目的

学习一下 @EnableXXX 在 SpringBoot 中是如何做到可插拔的
学习在 starter 中使用代理方式来解析自定义注解并进行方法增强
网上 starter 案例千篇一律，感觉都是复制粘贴，没有找到一篇有价值的文章。只好逼迫自己看源码学习。

带来收获

了解@EnableXXX注解是如何起作用的
了解 AOP 是如何做到方法增强
了解如何基于 SpringBoot 编写一个自定义 starter

源码地址

GitHub 地址：
https://github.com/LuckyToMeet-Dian-N/cache-spring-boot-starter

Gitee 地址
https://gitee.com/reway_wen/cache-spring-boot-starter

框架介绍

缓存框架目前支持注解方式进行对象缓存
缓存方面目前仅支持本地内存存储，多级缓存待支持
暂不支持过期策略。

使用方式

打包项目

下载源代码，将代码 install 到本地仓库中，在 SpringBoot 项目中引入即可。

<dependency>
    <groupId>com.gentle.cache</groupId>
    <artifactId>cache-spring-boot-starter</artifactId>
    <version>1.0-SNAPSHOT</version>
</dependency>

如何使用框架

启用缓存

@EnableCacheManager 注解开启缓存支持。

@SpringBootApplication
@EnableCacheManager  //启用缓存
public class TestApplication {
    public static void main(String[] args) {
        SpringApplication.run(TestApplication.class, args);
    }
}

测试Controller

支持的注解：
@PutCache（用于放入缓存与读取缓存）
@RemoveCache（用于移除缓存）

使用过程中多个参数中间使用下划线分隔，如果参数参数不存在，则会打印异常提示。

@RestController
public class TestCache {
    @GetMapping(value = "test1")
    @PutCache(key = "abc")
    public String  test1(String abc){
        return "aaa";
    }
    
    @GetMapping(value = "test2")
    @PutCache(key = "users.id")
    public Users  test2(Users users){
        return users;
    }

    @GetMapping(value = "test3")
    @PutCache(key = "name_id")
    public String  test3(String name,Integer id){
        return name+"     "+id;
    }

    @GetMapping(value = "test4")
    @PutCache(key = "users.id_users.name_test")
    public String  test4(Users users,Integer test){
        return users.toString()+"    "+test;
    }

    @GetMapping(value = "test5")
    @RemoveCache(key = "users.id_users.name_test")
    public String  test5(Users users,Integer test){
        return users.toString()+"    "+test;
    }
}
@Data
public class Users {
    private String name;
    private Integer id;
}

源码解析

开启缓存

@Target(ElementType.TYPE)
@Documented
@Retention(RetentionPolicy.RUNTIME)
 //缓存配置选择器，这里是核心。加载是从此处开始
@Import(CacheConfigurationSelector.class)
public @interface EnableCacheManager {
    /**
     * 优先级
     * @return 级别
     */
    int order() default  Ordered.LOWEST_PRECEDENCE;

    /**
     * 代理模式
     * @return
     */
    AdviceMode mode() default AdviceMode.PROXY;

    /**
     * 存储类型
     * @return
     */
    ExecuteTypeEnum type() default ExecuteTypeEnum.MEMORY;

    /**
     * 是否启用异步更新缓存
     * @return
     */
    boolean asyn() default false;

    /**
     * 代理 class，默认为动态代理，
     * 为 true 需要引入 aspectJ 包
     * 目前框架不支持
     * @return
     */
    boolean proxyTargetClass() default false;
}

缓存配置装载

SpringBoot 中导入需要装载 @EnableXXX 注解的配置类需要继承 AdviceModeImportSelector，在 selectImports 方法中选择需要导入的类的全限定名称。

public class CacheConfigurationSelector  extends AdviceModeImportSelector<EnableCacheManager> {
    private String[] getProxyImports() {
        List<String> result = new ArrayList<>(3);
        //自动代理注册，Spring 已经提供
        result.add(AutoProxyRegistrar.class.getName());
        //框架核心配置类
        result.add(ProxyCacheConfiguration.class.getName());
        return StringUtils.toStringArray(result);
    }
    @Override
    protected String[] selectImports(AdviceMode adviceMode) {
       //默认模式是动态代理，目前不支持 ASPECTJ
        switch (adviceMode) {
            case PROXY:
                return getProxyImports();
            case ASPECTJ:
                return null;
            default:
                return null;
        }
    }
}

核心配置类

ProxyCacheConfiguration是我们框架整个核心配置类，其中创建的拦截器、advisor、参数解析器、注解解析器等对象交由 Spring 管理。

@Role(BeanDefinition.ROLE_INFRASTRUCTURE)
@Configuration
public class ProxyCacheConfiguration extends AbstractCacheConfiguration {
    /**
     *  通知，AOP 实现方式之一。
     *  需要放入拦截器等信息
     * @return BeanFactoryCacheInstacneAdvisor 
     */
    @Bean
    @Role(BeanDefinition.ROLE_INFRASTRUCTURE)
    public BeanFactoryCacheInstacneAdvisor cacheAdvisor() {
        BeanFactoryCacheInstacneAdvisor advisor = new BeanFactoryCacheInstacneAdvisor();
        //放入拦截器
        advisor.setAdvice(createBeanRouteInterceptor());
        //获取 EnableCacheManager 中配置的全局信息
        //此处设计不好，待改善。CacheContext 对外暴露了
        if (Objects.nonNull(this.enableCaching)) {
            advisor.setOrder(this.enableCaching.<Integer>getNumber("order"));
            CacheContext.STORE_TYPE = this.enableCaching.getEnum("type");
            CacheContext.ASYN = this.enableCaching.getBoolean("asyn");
        }
        return advisor;
    }
    /**
     * 注解解析器，解析注解中配置的key、prefix、time 等信息
     * @return CacheOperationSource
     */
    @Bean
    @Role(BeanDefinition.ROLE_INFRASTRUCTURE)
    public CacheOperationSource createCacheOperationSource() {
        return new AnnotationCacheOperationSource();
    }

    /**
     * 参数解析器，根据用户提供的key，解析得到具体传入值
     * 将值拼装成缓存 key
     * @return ParameterResolver
     */
    @Bean
    @Role(BeanDefinition.ROLE_INFRASTRUCTURE)
    public ParameterResolver createParameterResolver() {
        return new LocalParameterResolver();
    }

    /**
     * 拦截器，拦截被自定义注解标记的方法
     * @return  CacheInterceptor
     */
    @Bean
    @Role(BeanDefinition.ROLE_INFRASTRUCTURE)
    public CacheInterceptor createBeanRouteInterceptor() {
        CacheInterceptor interceptor = new CacheInterceptor();
        interceptor.setCacheOperationSource(createCacheOperationSource());
        interceptor.setParameterResolver(createParameterResolver());
        return interceptor;
    }
}

切点切面

核心切面以及切点类，CacheChooseSourcePointcut 中的 matches方法告知遇到我们自定义注解时，要进行增强。

public class BeanFactoryCacheInstanceAdvisor extends AbstractBeanFactoryPointcutAdvisor {
    private CacheChooseSourcePointcut pointcut = new CacheChooseSourcePointcut();
    @Override
    public Pointcut getPointcut() {
        return pointcut;
    }

}
// 切点
public class CacheChooseSourcePointcut extends StaticMethodMatcherPointcut implements Serializable {

    @Override
    public boolean matches(Method method, Class<?> aClass) {
        return method.isAnnotationPresent(PutCache.class)||method.isAnnotationPresent(RemoveCache.class);
    }

}

拦截器

类实现MethodInterceptor接口，invoke可以理解为JDK中反射中的Method.invoke调用原来方法，可以在该方法前后进行增强其他操作。比如打印日志等。下面逻辑较简单，不做阐述。

public class CacheInterceptor extends AbstractCacheSupport implements MethodInterceptor, Serializable {


    @Override
    public Object invoke(MethodInvocation invocation) throws Throwable {
        Collection<CacheOperation> cacheOperations = getCacheOperationSource().getCacheOperations(invocation.getMethod(), invocation.getMethod().getClass());

        Object o = postProcessBefore(invocation.getMethod(), invocation.getArguments(), cacheOperations);
        if (Objects.nonNull(o)) {
            return o;
        }
        Object proceed = invocation.proceed();

        postProcessAfter(proceed, invocation.getMethod(), invocation.getArguments(), cacheOperations);

        return proceed;
    }


    @Override
    protected Object postProcessBefore(Method method, Object[] args, Collection<CacheOperation> cacheOperations) {

        CacheOperation cacheOperation = cacheOperations.stream().filter(operation -> operation.getType().equals(0)).findAny().orElse(null);
        if (Objects.isNull(cacheOperation)) {
            return null;
        }
        String cacheKey = getCacheKey(method, args, cacheOperation);
        return get(cacheKey, method.getReturnType());
    }

    @Override
    protected void postProcessAfter(Object value, Method method, Object[] args, Collection<CacheOperation> cacheOperations) {
        cacheOperations.forEach(cacheOperation -> {
            String cacheKey = getCacheKey(method, args, cacheOperation);
            switch (cacheOperation.getType()) {
                case 0:
                    put(cacheKey, value, cacheOperation.getTime());
                    break;
                case 1:
                    remove(cacheKey);
                    break;
                default:
                    break;
            }
        });
    }
}

注解解析器

注解解析器接口如下，主要将我们加在某个方法的缓存注解的信息转为对象，便于后续使用。代码较多，此处不放代码。

public interface AnnotationParser {
    @Nullable
    Collection<CacheOperation> parseCacheAnnotations(Method method);
}

参数解析器

参数解析器目的是将注解解析器解析得到的对象和方法传入参数进行匹配，匹配后以传入值方式拼接为缓存存储的 key。代码较多，此处不放代码。

public interface ParameterResolver {
    String resolverParameter(Method method, Object[] args,CacheOperation cacheOperation);

}

最后

按照当前思路，是可以完成一个基于SpringBoot 的 starter 来编写自定义注解，如果你了解了基本流程，那么SpringBoot 提供的大部分 @EnableXXX 的注解实现有了个基本概念，接着可以深入了解Spring 是怎么设计的。

LuckyToMeet-Dian叶

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
基于starter-自定义缓存框架

浅谈编写目的学习一下 @EnableXXX 在 SpringBoot 中是如何做到可插拔的学习在 starter 中使用代理方式来解析自定义注解并进行方法增强网上 starter 案例千篇一律，感觉都是复制粘贴，没有找到一篇有价值的文章。只好逼迫自己看源码学习。带来收获了解@EnableXXX注解是如何起作用的了解 AOP 是如何做到方法增强了解如何基于 SpringBoot...
复制链接

扫一扫