Spring框架學習之AOP詳解

Posted on 2021-05-07 by WalkonNet

一、概念

1.面向切面編程（方面），利用 AOP 可以對業務邏輯的各個部分進行隔離，從而使得業務邏輯各部分之間的耦合度降低，提高程序的可重用性，同時提高瞭開發的效率。

2.通俗描述：不通過修改源代碼方式，在主幹功能裡面添加新功能

二、底層原理:動態代理

有兩種情況動態代理

2.1 有接口, JDK 動態代理

1.被代理的對象

public class UserDaoImpl implements UserDao {

    @Override
    public int add(int a, int b) {
        System.out.println("add執行");
        return a + b;
    }

    @Override
    public String update(String id) {
        System.out.println("update執行");
        return id;
    }

}

2.代理

package cn.zj.proxy;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.Arrays;

import cn.zj.dao.UserDao;
import cn.zj.dao.impl.UserDaoImpl;

public class JDKProxy {

    public static void main(String[] args) {
        // 創建接口實現類代理對象
        Class[] interfaces = { UserDao.class };
        UserDaoImpl userDao = new UserDaoImpl();
        UserDao dao = (UserDao) Proxy.newProxyInstance(JDKProxy.class.getClassLoader(), interfaces,
                new UserDaoProxy(userDao));
        
        int result = dao.add(1, 2);
        System. out .println( "result:"+result);
    }
}

//創建代理對象代碼
class UserDaoProxy implements InvocationHandler {

    private Object target;// 目標類

    public UserDaoProxy(Object target) {
        this.target = target;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        // 方法執行之前
        System.out.println("方法執行之前.." + method.getName() + ";傳遞的參數:" + Arrays.toString(args));
        // 增強方法
        Object res = method.invoke(target, args);
        // 方法執行之後
        System.out.println("方法執行之後.." + target);
        return res;
    }

}

3.打印

方法執行之前..add;傳遞的參數:[1, 2]
add執行
方法執行之後..cn.zj.dao.impl.UserDaoImpl@6c629d6e
result:3

2.2 無接口, CGLIB 動態代理

1.被代理的對象

public class Cat {

    public void eat() {
        System.out.println("貓吃魚");
    }
}

2.代理

public class CglibProxy {

    public static void main(String[] args) {
        Cat c = new CglibProxy().createProxyObject(Cat.class);
        c.eat();
    }

    // JDK代理是對對象做代理，cglib代理是對類做代理
    public Cat createProxyObject(Class clazz) {
        // 1.創建內存中的動態類 Enhance
        // 內存中造出一個沒有名稱的動態類
        Enhancer enhancer = new Enhancer();
        // 2.現在的類最終完成原始類的功能，同時對其進行功能的增強，必須先具有原始類對應的功能————繼承
        enhancer.setSuperclass(clazz);
        // 3.進行功能的增強
        // 設置瞭方法的調用攔截
        // 設置具體的回調操作
        Callback callback = new MethodInterceptor() {
            // proxy:代理對象
            // method:被攔截的方法對象
            // args:調用參數
            // methodProxy:
            public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy)
                    throws Throwable {
                // 做增強
                System.out.println("執行前");
                // Object obj=method.invoke(proxy, args);//這種執行是代理類的方法,而不是目標類的,會造成內存溢出
                // 以下的兩種都是執行目標類的方法
                // Object obj = methodProxy.invokeSuper(proxy, args);//執行目標類的方法
                // Object obj=method.invoke(proxy, args);
                Object res = methodProxy.invokeSuper(proxy, args);
                System.out.println("執行後");
                return res;
            }
        };
        enhancer.setCallback(callback);
        // 4.創建內存中的全新的類的對象
        Object proxyObj = enhancer.create();
        return (Cat) proxyObj;
    }

}

三、術語

1.連接點(Joinpoint)

類中的任意方法的運行時表示，可以簡單理解為類中的方法,也就是可以被增強的方法

2.切入點(Pointcut)

具有共性功能的方法的運行時表示，可以簡單理解為具有共性功能的方法,也就是實際被增強的方法

註意：切入點對應的是被挖去瞭共性功能後的方法執行時匹配斷言（格式）

3.通知/增強(Advice)

共性功能模塊化，可以簡單理解為將共性功能抽取出來制作成獨立的方法,實際增強的邏輯部分

類型:前置，後置，異常，最終，環繞

4.切面(Aspect)

切入點與通知的對應關系，可以簡單理解為被抽取的共性功能與共性功能被抽取位置對應的方法之間的關系,把通知應用到切入點的過程

5.目標對象(Target Object)

包含切入點的運行時對象，開發階段制作的是目標對象對應的類

6.AOP代理(AOP Proxy)

使用AOP的代理機制創建目標對象運行時代理對象，完成原始的功能

註意：原始目標對象已經被挖去瞭共性功能，此時使用目標對象執行任務無法完成原始任務，使用AOP代理機制，創建一個代理對象來完成原始目標對象的功能

7.織入(Weaving)

是一個將通知功能加入原始字節碼的動態過程，將增強添加對目標類具體連接點上的過程

Spring使用的是運行時織入機制

8.引入(Introduction)

一種特殊的機制，可以為一個類的字節碼動態的加入變量或方法

四、操作

4.1 Spring 框架一般都是基於 AspectJ 實現 AOP

AspectJ 不是 Spring 組成部分，獨立 AOP 框架，一般把 AspectJ 和 Spirng 框架一起使

用，進行 AOP 操作

4.2 實踐

1.jar包引入

<dependencies>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>5.3.6</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-beans</artifactId>
            <version>5.3.6</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.3.6</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.springframework/spring-expression -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-expression</artifactId>
            <version>5.3.6</version>
        </dependency>



        <!-- https://mvnrepository.com/artifact/org.springframework/spring-aop -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aop</artifactId>
            <version>5.3.6</version>
        </dependency>

        <!-- https://mvnrepository.com/artifact/commons-logging/commons-logging -->
        <dependency>
            <groupId>commons-logging</groupId>
            <artifactId>commons-logging</artifactId>
            <version>1.2</version>
        </dependency>

        <!-- https://mvnrepository.com/artifact/com.alibaba/druid -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.2.6</version>
        </dependency>

        <!-- @Resource註解需要 -->
        <dependency>
            <groupId>javax.annotation</groupId>
            <artifactId>javax.annotation-api</artifactId>
            <version>1.3.1</version>
        </dependency>


        <!-- https://mvnrepository.com/artifact/org.springframework/spring-aspects -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aspects</artifactId>
            <version>5.3.6</version>
        </dependency>

        <!-- https://mvnrepository.com/artifact/net.sourceforge.cglib/com.springsource.net.sf.cglib -->
        <dependency>
            <groupId>net.sourceforge.cglib</groupId>
            <artifactId>com.springsource.net.sf.cglib</artifactId>
            <version>2.2.0</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.aopalliance/com.springsource.org.aopalliance -->
        <dependency>
            <groupId>org.aopalliance</groupId>
            <artifactId>com.springsource.org.aopalliance</artifactId>
            <version>1.0.0</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.aspectj/com.springsource.org.aspectj.weaver -->
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>com.springsource.org.aspectj.weaver</artifactId>
            <version>1.6.8.RELEASE</version>
        </dependency>



    </dependencies>

2.切入點表達式

作用：知道對哪個類裡面的哪個方法進行增強

語法結構： execution([權限修飾符] [返回類型] [類全路徑] 方法名稱 )

舉例 1：對 com.zj.dao.BookDao 類裡面的 add 進行增強

execution(* com.zj.dao.BookDao.add(…))

舉例 2：對 com.zj.dao.BookDao 類裡面的所有的方法進行增強

execution(* com.zj.dao.BookDao.* (…))

舉例 3：對 com.zj.dao 包裡面所有類，類裡面所有方法進行增強

execution(* com.zj.dao.. (…))

3.xml方式

1.創建類

package cn.zj.aop.xml;

public class Book {
    public void buy() {
        System.out.println("buy.............");
    }
}

2.增強類

package cn.zj.aop.xml;

public class BookProxy {
    public void before() {
        System.out.println("before.........");
    }
}

3.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
                        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd
                        http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">
    <!--創建對象-->
    <bean id="book" class="cn.zj.aop.xml.Book"></bean>
    <bean id="bookProxy" class="cn.zj.aop.xml.BookProxy"></bean>

    <!--配置aop增強-->
    <aop:config>
        <!--切入點-->
        <aop:pointcut id="p" expression="execution(* cn.zj.aop.xml.Book.buy(..))"/>
        <!--配置切面-->
        <aop:aspect ref="bookProxy">
            <!--增強作用在具體的方法上-->
            <aop:before method="before" pointcut-ref="p"/>
        </aop:aspect>
    </aop:config>
</beans>

4.註解方式

1.創建類

public class User {
    public void add() {
        System.out.println("add.......");
    }

}

2.創建增強類

package cn.zj.aop.an;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.AfterThrowing;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Component;

//增強的類
@Component
@Aspect  //生成代理對象

public class UserProxy {

    //前置通知
    @Before(value = "execution(* cn.zj.aop.an.User.add(..))")
    public void before() {
        System.out.println("before.........");
    }

    //後置通知（返回通知）
    @AfterReturning(value = "execution(* cn.zj.aop.an.User.add(..))")
    public void afterReturning() {
        System.out.println("afterReturning.........");
    }

    //最終通知
    @After(value = "execution(* cn.zj.aop.an.User.add(..))")
    public void after() {
        System.out.println("after.........");
    }

    //異常通知
    @AfterThrowing(value = "execution(* cn.zj.aop.an.User.add(..))")
    public void afterThrowing() {
        System.out.println("afterThrowing.........");
    }

    //環繞通知
    @Around(value = "execution(* cn.zj.aop.an.User.add(..))")
    public void around(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
        System.out.println("環繞之前.........");

        //被增強的方法執行
        proceedingJoinPoint.proceed();

        System.out.println("環繞之後.........");
    }
}

3.xml配置註解掃描

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
                        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd
                        http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">
    <!-- 開啟註解掃描 -->
    <context:component-scan base-package="cn.zj.aop.an"></context:component-scan>

    <!-- 開啟Aspect生成代理對象-->
    <aop:aspectj-autoproxy></aop:aspectj-autoproxy>
</beans>

4.測試

ApplicationContext context = new ClassPathXmlApplicationContext("bean1.xml");
        User user = context.getBean("user", User.class);
        user.add();

5.相同點抽取

//相同切入點抽取
    @Pointcut(value = "execution(* cn.zj.aop.an.User.add(..))")
    public void pointdemo() {

    }

    //前置通知
    //@Before註解表示作為前置通知
    @Before(value = "pointdemo()")
    public void before() {
        System.out.println("before.........");
    }

6.有多個增強類多同一個方法進行增強，設置增強類優先級

在增強類上面添加註解 @Order(數字類型值)，數字類型值越小優先級越高

@Component
@Aspect 
@Order(1)
public class PersonProxy {

     //後置通知（返回通知）
    @Before(value = "execution(* cn.zj.aop.an.User.add(..))")
    public void afterReturning() {
        System.out.println("Person Before.........");
    }
}
//增強的類
@Component
@Aspect  //生成代理對象
@Order(2)
public class UserProxy {

到此這篇關於Spring框架學習之AOP詳解的文章就介紹到這瞭,更多相關Spring框架AOP內容請搜索WalkonNet以前的文章或繼續瀏覽下面的相關文章希望大傢以後多多支持WalkonNet！

Spring框架學習之AOP詳解

一、概念

二、底層原理:動態代理

2.1 有接口, JDK 動態代理

2.2 無接口, CGLIB 動態代理

三、術語

四、操作

4.1 Spring 框架一般都是基於 AspectJ 實現 AOP

4.2 實踐

推薦閱讀：

發佈留言取消回覆

近期文章

一、概念

二、底層原理:動態代理

2.1 有接口, JDK 動態代理

2.2 無接口, CGLIB 動態代理

三、術語

四、操作

4.1 Spring 框架一般都是基於 AspectJ 實現 AOP

4.2 實踐

推薦閱讀：

發佈留言 取消回覆

近期文章

標籤

發佈留言取消回覆