SpringBoot中利用AOP和攔截器實現自定義註解

Posted on by

前言

最近遇到瞭這樣一個工作場景，需要寫一批dubbo接口，再將dubbo接口註冊到網關中，但是當dubbo接口異常的時候會給前端返回非常不友好的異常。所以就想要對異常進行統一捕獲處理，但是對於這種service接口使用@ExceptionHandler註解進行異常捕獲也是捕獲不到的，應為他不是Controller的接口。這時就想到瞭自定義一個註解去實現異常捕獲的功能。

Spring實現自定義註解

通過攔截器+AOP實現自定義註解的實現，在這裡攔截器充當在指定註解處要執行的方法，aop負責將攔截器的方法和要註解生效的地方做一個織入（通過動態註解生成代理類實現）。

1.引入相關依賴

spring-boot-starter：spring的一些核心基礎依賴

spring-boot-starter-aop：spring實現Aop的一些相關依賴

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

2.相關類

1.自定義註解類

@Target({ElementType.TYPE})  //說明瞭Annotation所修飾的對象范圍,這裡，的作用范圍是類、接口(包括註解類型) 或enum
@Retention(RetentionPolicy.RUNTIME)  //自定義註解的有效期，Runtime：註解不僅被保存到class文件中，jvm加載class文件之後，仍然存在
@Documented //標註生成javadoc的時候是否會被記錄
public @interface EasyExceptionResult {
}

2.攔截器類

/**
 * MethodInterceptor是AOP項目中的攔截器（註：不是動態代理攔截器），
 * 區別與HandlerInterceptor攔截目標時請求，它攔截的目標是方法。
 */
public class EasyExceptionIntercepter implements MethodInterceptor {
    @Override
    public Object invoke(MethodInvocation invocation) throws Throwable {
        AnnotatedElement element=invocation.getThis().getClass();
        EasyExceptionResult easyExceptionResult=element.getAnnotation(EasyExceptionResult.class);
        if (easyExceptionResult == null) {
            return invocation.proceed();
        }
        try {
            return invocation.proceed();
        } catch (Exception rpcException) {
            //不同環境下的一個異常處理
            System.out.println("發生異常瞭");
            return null;
        }
    }
}

3.切點切面類

MethodInterceptor的實現類能作為切面的執行方式是應為Interceptor的父類是Advice。

@Configuration
public class EasyExceptionAdvisor {
 
    /**
     * 放在最後執行
     * 等待ump/日志等記錄結束
     *
     * @return {@link DefaultPointcutAdvisor}對象
     */
    @Bean
    @Order(Integer.MIN_VALUE)
    public DefaultPointcutAdvisor easyExceptionResultAdvisor() {
        DefaultPointcutAdvisor advisor = new DefaultPointcutAdvisor();
        //針對EasyExceptionResult註解創建切點
        AnnotationMatchingPointcut annotationMatchingPointcut = new AnnotationMatchingPointcut(EasyExceptionResult.class, true);
        EasyExceptionIntercepter interceptor = new EasyExceptionIntercepter();
        advisor.setPointcut(annotationMatchingPointcut);
        //在切點執行interceptor中的invoke方法
        advisor.setAdvice(interceptor);
        return advisor;
    }
 
}

4.自定義註解的使用

@Service
@EasyExceptionResult  //自定義異常捕獲註解
public class EasyServiceImpl {
 
    public void testEasyResult(){
        throw new NullPointerException("測試自定義註解");
    }
 
}

5.效果

@SpringBootApplication
public class JdStudyApplication {
 
    public static void main(String[] args) {
        ConfigurableApplicationContext context=SpringApplication.run(JdStudyApplication.class, args);
        EasyServiceImpl easyService=context.getBean(EasyServiceImpl.class);
        easyService.testEasyResult();
    }
 
}

至此就實現瞭通過spring實現自定義註解。

Java實現自定義註解

雖然通過Spring實現瞭自定義註解但是還有辦法讓我們不通過Spring也能實現自定義註解，畢竟註解是早於Spring的。

JDK中有一些元註解，主要有@Target，@Retention,@Document,@Inherited用來修飾註解,如下為一個自定義註解。

@Target({ElementType.TYPE})  //說明瞭Annotation所修飾的對象范圍,這裡，的作用范圍是類、接口(包括註解類型) 或enum
@Retention(RetentionPolicy.RUNTIME)  //自定義註解的有效期，Runtime：註解不僅被保存到class文件中，jvm加載class文件之後，仍然存在
@Documented //標註生成javadoc的時候是否會被記錄
public @interface EasyExceptionResult {
}

@Target

表明該註解可以應用的java元素類型

Target類型 描述
ElementType.TYPE 應用於類、接口（包括註解類型）、枚舉
ElementType.FIELD 應用於屬性（包括枚舉中的常量）
ElementType.METHOD 應用於方法
ElementType.PARAMETER 應用於方法的形參
ElementType.CONSTRUCTOR 應用於構造函數
ElementType.LOCAL_VARIABLE 應用於局部變量
ElementType.ANNOTATION_TYPE 應用於註解類型
ElementType.PACKAGE 應用於包
ElementType.TYPE_PARAMETER 1.8版本新增，應用於類型變量）
ElementType.TYPE_USE 1.8版本新增，應用於任何使用類型的語句中（例如聲明語句、泛型和強制轉換語句中的類型）

@Retention

表明該註解的生命周期

生命周期類型 描述
RetentionPolicy.SOURCE 編譯時被丟棄，不包含在類文件中
RetentionPolicy.CLASS JVM加載時被丟棄，包含在類文件中，默認值
RetentionPolicy.RUNTIME 由JVM 加載，包含在類文件中，在運行時可以被獲取到

@Document

表明該註解標記的元素可以被Javadoc 或類似的工具文檔化

@Inherited

表明使用瞭@Inherited註解的註解，所標記的類的子類也會擁有這個註解

通過Cglib實現

在我們定義好註解之後就需要考慮如何將註解和類綁定到一起，在運行期間達到我們想要的效果，這裡就可以引入動態代理的機制，將註解想要做的操作在方法執行前，類編譯時就進行一個織入的操作如下。  

public static void main(String[] args) {
        Class easyServiceImplClass=EasyServiceImpl.class;
        //判斷該對象是否有我們自定義的@EasyExceptionResult註解
        if(easyServiceImplClass.isAnnotationPresent(EasyExceptionResult.class)){
            final EasyServiceImpl easyService=new EasyServiceImpl();
            //cglib的字節碼加強器
            Enhancer enhancer=new Enhancer();
            將目標對象所在的類作為Enhaner類的父類
            enhancer.setSuperclass(EasyServiceImpl.class);
            通過實現MethodInterceptor實現方法回調，MethodInterceptor繼承瞭Callback
            enhancer.setCallback(new MethodInterceptor() {
                @Override
                public Object intercept(Object proxy, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
                    try{
                        method.invoke(easyService, args);
                        System.out.println("事務結束...");
                    }catch (Exception e){
                        System.out.println("發生異常瞭");
                    }
                    return proxy;
                }
            });
 
            Object obj= enhancer.create();;
            EasyServiceImpl easyServiceProxy=(EasyServiceImpl)obj;
            easyServiceProxy.testEasyResult();
        }
 
    }

運行效果：

通過JDk動態代理實現

public class EasyServiceImplProxy implements InvocationHandler {
 
    private EasyServiceImpl target;
 
    public void setTarget(EasyServiceImpl target)
    {
        this.target = target;
    }
 
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        // 這裡可以做增強
        System.out.println("已經是代理類啦");
        try{
            return  method.invoke(proxy, args);
        }catch (Exception e){
            System.out.println("發生異常瞭");
            return null;
        }
    }
 
 
    /**
     * 生成代理類
     * @return 代理類
     */
    public Object CreatProxyedObj()
    {
        return Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), this);
    }
}

Cglib和JDK動態代理的區別

java動態代理是利用反射機制生成一個實現代理接口的匿名類，在調用具體方法前調用InvokeHandler來處理。

而cglib動態代理是利用asm開源包，對代理對象類的class文件加載進來，通過修改其字節碼生成子類來處理。

1、如果目標對象實現瞭接口，默認情況下會采用JDK的動態代理實現AOP 

2、如果目標對象實現瞭接口，可以強制使用CGLIB實現AOP 

3、如果目標對象沒有實現瞭接口，必須采用CGLIB庫，spring會自動在JDK動態代理和CGLIB之間轉換

如何強制使用CGLIB實現AOP？

（1）添加CGLIB庫，SPRING_HOME/cglib/*.jar

（2）在spring配置文件中加入<aop:aspectj-autoproxy proxy-target-class="true"/>

JDK動態代理和CGLIB字節碼生成的區別？

（1）JDK動態代理隻能對實現瞭接口的類生成代理，而不能針對類

（2）CGLIB是針對類實現代理，主要是對指定的類生成一個子類，覆蓋其中的方法

因為是繼承，所以該類或方法最好不要聲明成final 

寫在最後

@ExceptionHandler註解的使用可參考文章Java實現優雅的參數校驗方法詳解

到此這篇關於SpringBoot中利用AOP和攔截器實現自定義註解的文章就介紹到這瞭,更多相關SpringBoot自定義註解內容請搜索WalkonNet以前的文章或繼續瀏覽下面的相關文章希望大傢以後多多支持WalkonNet！

推薦閱讀：