本例主要演示如何通过aop解析spel表达式实现一个不一样的切面

Author: lyb-geek

.gitignore

@@ -660,3 +660,5 @@
 /springboot-mybatisplus-tenant/target/classes/META-INF/
 /springboot-xxl-job-executor/target/classes/
 /springboot-xxl-job-executor/springboot-xxl-job-executor.iml
+/springboot-aop-spel/springboot-aop-spel.iml
+/springboot-aop-spel/target/classes/

pom.xml

@@ -37,6 +37,7 @@
         <module>springboot-generate-sqlscript</module>
         <module>springboot-mybatisplus-tenant</module>
         <module>springboot-xxl-job-executor</module>
+        <module>springboot-aop-spel</module>
     </modules>
     <parent>
         <groupId>org.springframework.boot</groupId>

springboot-aop-spel/pom.xml

@@ -0,0 +1,69 @@
+<?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 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <parent>
+        <artifactId>springboot-learning</artifactId>
+        <groupId>com.github.lybgeek</groupId>
+        <version>0.0.1-SNAPSHOT</version>
+    </parent>
+    <modelVersion>4.0.0</modelVersion>
+
+    <artifactId>springboot-aop-spel</artifactId>
+
+
+    <dependencies>
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-cache</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-web</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-aop</artifactId>
+        </dependency>
+
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-configuration-processor</artifactId>
+            <optional>true</optional>
+        </dependency>
+        <dependency>
+            <groupId>org.projectlombok</groupId>
+            <artifactId>lombok</artifactId>
+            <optional>true</optional>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-test</artifactId>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>cn.hutool</groupId>
+            <artifactId>hutool-all</artifactId>
+        </dependency>
+    </dependencies>
+
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>org.springframework.boot</groupId>
+                <artifactId>spring-boot-maven-plugin</artifactId>
+                <configuration>
+                    <excludes>
+                        <exclude>
+                            <groupId>org.projectlombok</groupId>
+                            <artifactId>lombok</artifactId>
+                        </exclude>
+                    </excludes>
+                </configuration>
+            </plugin>
+        </plugins>
+    </build>
+
+
+
+</project>

springboot-aop-spel/readMe.md

@@ -0,0 +1,3 @@
+本文通过自定义注解+AOP+SPEL实现一个自定义缓存切面
+
+亮点在于利用aop加SpelExpressionParser解析器解析spel实现更灵活的切面

springboot-aop-spel/src/main/java/com/github/lybgeek/SpringbootAopSpelApplication.java

@@ -0,0 +1,16 @@
+package com.github.lybgeek;
+
+import org.springframework.boot.SpringApplication;
+import org.springframework.boot.autoconfigure.SpringBootApplication;
+import org.springframework.scheduling.annotation.EnableScheduling;
+
+@SpringBootApplication
+@EnableScheduling
+public class SpringbootAopSpelApplication{
+
+	public static void main(String[] args) {
+		SpringApplication.run(SpringbootAopSpelApplication.class, args);
+	}
+
+
+}

springboot-aop-spel/src/main/java/com/github/lybgeek/cache/LocalCache.java

@@ -0,0 +1,26 @@
+package com.github.lybgeek.cache;
+
+
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+
+public enum LocalCache {
+
+    INSTANCE;
+
+    private  Map<String,Object> localCacheMap = new ConcurrentHashMap<>();
+
+    public void put(String key,Object obj){
+        localCacheMap.put(key,obj);
+    }
+
+    public Object get(String key){
+        return localCacheMap.get(key);
+    }
+
+    public void printCacheInfo(){
+        System.out.println(String.format("cacheInfo:%s",localCacheMap));
+
+    }
+
+}

springboot-aop-spel/src/main/java/com/github/lybgeek/cache/annotation/LocalCacheable.java

@@ -0,0 +1,13 @@
+package com.github.lybgeek.cache.annotation;
+
+import java.lang.annotation.*;
+
+@Target({ElementType.TYPE, ElementType.METHOD})
+@Retention(RetentionPolicy.RUNTIME)
+@Inherited
+@Documented
+public @interface LocalCacheable {
+    String key() default "";
+    String condition() default "";
+
+}

springboot-aop-spel/src/main/java/com/github/lybgeek/cache/aspect/CacheAspect.java

@@ -0,0 +1,47 @@
+package com.github.lybgeek.cache.aspect;
+
+
+import com.github.lybgeek.cache.LocalCache;
+import com.github.lybgeek.cache.annotation.LocalCacheable;
+import com.github.lybgeek.util.SpELParserUtils;
+import org.aspectj.lang.ProceedingJoinPoint;
+import org.aspectj.lang.annotation.Around;
+import org.aspectj.lang.annotation.Aspect;
+import org.aspectj.lang.reflect.MethodSignature;
+import org.springframework.stereotype.Component;
+import org.springframework.util.StringUtils;
+
+import java.lang.reflect.Method;
+
+@Component
+@Aspect
+public class CacheAspect {
+
+
+    @Around("@annotation(localCacheable)")
+    public Object around(ProceedingJoinPoint pjp, LocalCacheable localCacheable) throws Throwable{
+        MethodSignature methodSignature = (MethodSignature)pjp.getSignature();
+        Method method = methodSignature.getMethod();
+        Object[] args = pjp.getArgs();
+        Object result = pjp.proceed();
+        String key = pjp.getTarget().getClass().getName() + "_" + method.getName() + "_" + args.length;
+
+        if(!StringUtils.isEmpty(localCacheable.key())){
+           key = SpELParserUtils.parse(method,args,localCacheable.key(),String.class);
+        }
+
+        System.out.println("key:"+key);
+
+        if(!StringUtils.isEmpty(localCacheable.condition())){
+            boolean condition = SpELParserUtils.parse(method,args,localCacheable.condition(),Boolean.class);
+            if(condition){
+                LocalCache.INSTANCE.put(key,result);
+            }
+        }else{
+            LocalCache.INSTANCE.put(key,result);
+        }
+
+        return result;
+
+    }
+}

springboot-aop-spel/src/main/java/com/github/lybgeek/cache/event/CacheContextEvent.java

@@ -0,0 +1,31 @@
+package com.github.lybgeek.cache.event;
+
+
+import com.github.lybgeek.cache.LocalCache;
+import org.springframework.context.ApplicationListener;
+import org.springframework.context.event.ContextRefreshedEvent;
+import org.springframework.stereotype.Component;
+
+import java.util.concurrent.Executors;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicInteger;
+
+@Component
+public class CacheContextEvent implements ApplicationListener<ContextRefreshedEvent> {
+
+    private AtomicInteger atomicInteger = new AtomicInteger();
+
+    private ScheduledExecutorService executorService = Executors.newScheduledThreadPool(10, runnable -> {
+        Thread thread = new Thread(runnable);
+        thread.setName("cache-pool-"+atomicInteger.getAndIncrement());
+        return thread;
+    });
+
+    @Override
+    public void onApplicationEvent(ContextRefreshedEvent event) {
+        executorService.scheduleWithFixedDelay((Runnable) () -> {
+            LocalCache.INSTANCE.printCacheInfo();
+        },5,5, TimeUnit.SECONDS);
+    }
+}

springboot-aop-spel/src/main/java/com/github/lybgeek/dao/ProductMockDao.java

@@ -0,0 +1,27 @@
+package com.github.lybgeek.dao;
+
+
+import com.github.lybgeek.entity.Product;
+import org.springframework.stereotype.Repository;
+
+import java.util.Map;
+import java.util.Objects;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.atomic.LongAdder;
+
+@Repository
+public class ProductMockDao {
+    private LongAdder idIncrService = new LongAdder();
+
+    private static Map<Long, Product> mockDb = new ConcurrentHashMap<>();
+
+    public Product save(Product product) {
+        if(Objects.isNull(product.getId()) || !mockDb.containsKey(product.getId())){
+            idIncrService.increment();
+            product.setId(idIncrService.longValue());
+        }
+        mockDb.put(product.getId(),product);
+
+        return product;
+    }
+}