Spring AOP怎么使用切入點創建通知

這篇文章主要介紹“Spring AOP怎么使用切入點創建通知”，在日常操作中，相信很多人在Spring AOP怎么使用切入點創建通知問題上存在疑惑，小編查閱了各式資料，整理出簡單好用的操作方法，希望對大家解答”Spring AOP怎么使用切入點創建通知”的疑惑有所幫助！接下來，請跟著小編一起來學習吧！

一、什么是切入點

通過之前的例子中，我們可以創建ProxyFactory的方式來創建通知，然后獲取目標類中的方法。通過不同類型的通知，能對這些方法做不同的事。但是，這種方式會對整個類中的所有方法都有作用，但是很多時間我們只想對這個類中的部分方法進行通知處理，那就要使用切入點來精確地控制到特定的方法

• 也就是說，我們的切入點就是用來確定一個類中的方法（精確到方法），類似于定義一些規則一樣，來找到和這個規則相匹配的類，知道這一點，往下看就容易多了。

二、切入點的分類

在Spring中的要創建切入點時，就要實現Pointcut類。

package org.springframework.aop;

public interface Pointcut{
    ClassFilter getClassFilter();
    MethodMatcher getMethodMacher();
}

以上兩個方法返回的類的源碼如下：

• ClassFilter

package org.springframework.aop;
/**
*   這是一個函數式接口，就是傳入一個類，
*   如果這個類滿足我們的要求，就返回true
*   也就是說這個切入點適用于這個類（也就是這個類不匹配我們的規則）
*/
@FunctionalInterface
public interface ClassFilter {
    boolean matches(Class<?> var1);
}

• MethodMatcher

package org.springframework.aop;

import java.lang.reflect.Method;
/**
*   這個當然就是用來匹配方法了，
*   有兩種類型，動態和靜態，這個由isRuntime()的返回值來決定，true就是動態，false就是靜態。這個類型就是決定了這個切入點是動態的還是靜態的
*   
*/
public interface MethodMatcher {
    MethodMatcher TRUE = TrueMethodMatcher.INSTANCE;
    //用于靜態匹配，就是和方法的參數無關
    boolean matches(Method var1, Class<?> var2);

    boolean isRuntime();
    //用于動態匹配，也就是和方法的參數有關，因為參數是會變的
    boolean matches(Method var1, Class<?> var2, Object... var3);
}

綜上，切入點分為兩種，動態切入點和靜態切入點，動態切入點要每次檢查方法的實參是不是滿足要求，這會產生額外的開支。如果可以，如果可以，盡可能使用靜態切入點。

三、切入點的八個實現類

四、使用StaticMethodMatcherPointcut來創建靜態切入點

• 創建一個類，兩個方法。我們的目的就是只在walk()方法中創建環繞通知，打印一句，"I am a cute cat."

public class Cat {
    public void sleep(){
        System.out.println("sleep....");
    }
    public void walk(){
        System.out.println("walking....");
    }
}

• 創建切入點

public class MethodPointcutDemo extends StaticMethodMatcherPointcut {

    @Override
    public boolean matches(Method method, Class<?> aClass) {
        return method.getName().equals("walk");
    }

    @Override
    public ClassFilter getClassFilter() {
        return clz -> clz == Cat.class;
        
//        上邊的lambda表達式等于下邊的這個
//        return new ClassFilter() {
//            @Override
//            public boolean matches(Class<?> clz) {
//                return clz == Cat.class;
//            }
//        };
    }
}

在上邊這個方法中，當然，我們可以不用實現getClassFilter()方法，因為這個方法已經被上級實現過了，我們就可以在matches方法中直接去判斷這個類是不是Cat.class

• 通知類（這個和上一次是一樣的，創建一個環繞通知）

import org.aopalliance.intercept.MethodInterceptor;
import org.aopalliance.intercept.MethodInvocation;

public class CatAdvisor implements MethodInterceptor{

    @Override
    public Object invoke(MethodInvocation invocation) throws Throwable {
        //最不靠譜的方法，我們可以在這里判斷這個method的是不是walk,從而要不要進行通知
        System.out.println("I am a cute Cat.");
        Object proceed = invocation.proceed();
        return proceed;
    }
}

當然，我們在這里也是可以判斷這個方法名和類名的，為什么還要用切入點呢。可是這并不靠譜，我們中需要在這里實現我們的邏輯代碼，而通過切入點來控制哪個類，哪個方法要被通知，這樣更靈活。

• 測試方法

public static void main(String[] args) {
        Cat cat = new Cat();

        Pointcut pointcut = new MethodPointcutDemo();//切入點實例
        Advice advice = new CatAdvisor();//通知類實例（就是我們的通知代碼存放的類的對象）

        Advisor advisor = new DefaultPointcutAdvisor(pointcut, advice);//切面類，就是切入點和通知類的集合

        ProxyFactory proxyFactory = new ProxyFactory();
        //和之前代碼的區別就是這一句，這里我們使用的是切入點控制，如果把這句注釋了，就要用設置通知類
        proxyFactory.addAdvisor(advisor);//設置切面類，包含切入點（控制通知點）和通知類（邏輯代碼）
        
        //如果注釋了上面一句，用這一句的話，就會對這個類中的所有方法都通知
//        proxyFactory.addAdvice(advice);//設置通知類
        proxyFactory.setTarget(cat);
        Cat proxy = (Cat) proxyFactory.getProxy();

        proxy.sleep();
        proxy.walk();
    }

運行結果肯定就是我們想的那樣

sleep....
I am a cute Cat.
walking....

五、使用DyanmicMatcherPointcut創建動態切入點

這個和上邊的靜態切入點是一樣的，只不過是讓傳入方法的參數滿足一定要求時，才會執行通知。由于篇幅原因，就不寫了，在本文最后下載代碼就能看懂。

六、其他類型的PointCut的實現類

1.簡單的名稱匹配 ( NameMatchMethodPointcut )

目標類和通知類還是之前的Cat類，之前的切入點的實現類不用寫，因為這個類已經做了默認實現,感興趣的可以看下它的源碼，很簡單的，就是匹配類名，和我們剛才創建的靜態切入點差不多。

public class NameMatchPointcutDemo {
    public static void main(String[] args) {
        Cat cat = new Cat();

        //這個類已經是個實現類，我們就不需要再去寫實現類了
        NameMatchMethodPointcut pointcut = new NameMatchMethodPointcut();
        pointcut.addMethodName("walk");

        Advisor advisor = new DefaultPointcutAdvisor(pointcut,new CatAdvisor());

        ProxyFactory proxyFactory = new ProxyFactory();
        proxyFactory.addAdvisor(advisor);
        proxyFactory.setTarget(cat);
        Cat proxy = (Cat) proxyFactory.getProxy();

        proxy.sleep();
        proxy.walk();
    }
}

2.使用正則表達式創建切入點 ( JdkRegexpMethodPointcut )

只寫測試類，其他的都和上邊一樣

public class JdkRegexpPointcutDemo {

    public static void main(String[] args) {
        Cat cat = new Cat();

        JdkRegexpMethodPointcut pointcut = new JdkRegexpMethodPointcut();
        pointcut.setPattern(".*ee.*");//匹配中間有ee字母的，sleep()

        Advisor advisor = new DefaultPointcutAdvisor(pointcut,new CatAdvisor());

        ProxyFactory proxyFactory = new ProxyFactory();
        proxyFactory.addAdvisor(advisor);
        proxyFactory.setTarget(cat);
        Cat proxy = (Cat) proxyFactory.getProxy();

        proxy.sleep();
        proxy.walk();
    }
}

3.使用AspectJ切入點表達式創建切入點 ( AspectJExpressionPointcut )

使用AspectJ時要加入相關依賴

<dependency>
      <groupId>org.aspectj</groupId>
      <artifactId>aspectjrt</artifactId>
      <version>1.9.1</version>
    </dependency>
    <dependency>
      <groupId>org.aspectj</groupId>
      <artifactId>aspectjweaver</artifactId>
      <version>1.9.1</version>
    </dependency>

public class AspectJExpressionPointcutDemo {
    public static void main(String[] args) {
        Cat cat = new Cat();

        AspectJExpressionPointcut pointcut = new AspectJExpressionPointcut();
        pointcut.setExpression("execution(* walk*(..))");

        Advisor advisor = new DefaultPointcutAdvisor(pointcut, new CatAdvisor());

        ProxyFactory proxyFactory = new ProxyFactory();
        proxyFactory.addAdvisor(advisor);
        proxyFactory.setTarget(cat);
        Cat proxy = (Cat) proxyFactory.getProxy();

        proxy.sleep();
        proxy.walk();
    }
}

這個execution表達式的意思是：任何以walk開頭的，具有任何參數和任何返回值的方法

4.創建注解匹配的切入點 ( AnnotationMatchingPointcut )

首先自定義一個注解，如果不是很懂，參考Java中自定義注解類，并加以運用

/**
 * 這個注解是用于運行時期、可用于類、方法上
 */
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.TYPE,ElementType.METHOD})
public @interface MyAdvice {
}

然后在目標方法上添加這個注解（要被通知的類）

/**
     * 為了不與之前的沖突，就新寫了一個方法
     */
    @MyAdvice
    public void eat(){
        System.out.println("eating....");
    }

然后在main方法中指定這個注解名：

public class AnnotationPointcutDemo {
    public static void main(String[] args) {
        Cat cat = new Cat();

        AnnotationMatchingPointcut pointcut = AnnotationMatchingPointcut
                .forMethodAnnotation(MyAdvice.class);
        //這個類還有一個.forClassAnnotation()方法，就是指定類的

        Advisor advisor = new DefaultPointcutAdvisor(pointcut, new CatAdvisor());

        ProxyFactory proxyFactory = new ProxyFactory();
        proxyFactory.addAdvisor(advisor);
        proxyFactory.setTarget(cat);
        Cat proxy = (Cat) proxyFactory.getProxy();

        proxy.sleep();//不會被通知
        proxy.walk();//不會被通知
        proxy.eat();//會被通知
    }
}

到此，關于“Spring AOP怎么使用切入點創建通知”的學習就結束了，希望能夠解決大家的疑惑。理論與實踐的搭配能更好的幫助大家學習，快去試試吧！若想繼續學習更多相關知識，請繼續關注億速云網站，小編會繼續努力為大家帶來更多實用的文章！