【Spring】代理模式和AOP切片編程

文章目錄

代理模式和AOP切片編程

代理模式和AOP切片編程

代理模式是AOP（面向切面編程）的底層實現機制，分為靜態代理和動態代理。AOP利用代理模式實現橫向切面功能（如日志、事務），在不修改原有代碼的情況下增強業務邏輯，體現了"縱向開發，橫向切入"的編程思想。動態代理相比靜態代理更靈活，減少了重復代碼量。

代理模式

為什么要學習代理模式，因為AOP的底層機制就是動態代理 ！

代理模式：

靜態代理
動態代理

學習aop之前 , 我們要先了解一下代理模式！

我們(Client)想要做一個事情（AbstractSubject），可以直接去找合作方（RealSubject），也可以找代理商中介（Proxy），都可以把這件事情完成。

使用代理（Proxy）可以省略許多過程；只需要最終結果就可以了。

1、靜態代理

靜態代理角色分析

抽象角色（AbstractSubject）: 一般使用接口或者抽象類來實現
真實角色 : 被代理的角色
代理角色（Proxy） : 代理真實角色 ; 代理真實角色后 , 一般會做一些附屬的操作 .
客戶 : 使用代理角色來進行一些操作 .

代碼實現

Rent.java 即抽象接口動作

//抽象角色：租房
public interface Rent {
    public void rent();
}

Host.java 即真實角色

//真實角色: 房東，房東要出租房子
public class Host implements Rent{
    public void rent() {
        System.out.println("房屋出租");
    }
}

Proxy.java 即代理角色

//代理角色：中介
public class Proxy implements Rent {

    private Host host;
    public Proxy() { }
    public Proxy(Host host) {
        this.host = host;
    }

    //租房
    public void rent(){
        seeHouse();
        host.rent();
        fare();
    }
    //看房
    public void seeHouse(){
        System.out.println("帶房客看房");
    }
    //收中介費
    public void fare(){
        System.out.println("收中介費");
    }
}

Client.java 即客戶

//客戶類，一般客戶都會去找代理！
public class Client {
    public static void main(String[] args) {
        //房東要租房
        Host host = new Host();
        //中介幫助房東
        Proxy proxy = new Proxy(host);

        //你去找中介！
        proxy.rent();
    }
}

分析：在這個過程中，你直接接觸的就是中介，就如同現實生活中的樣子，你看不到房東，但是你依舊租到了房東的房子通過代理，這就是所謂的代理模式，程序源自于生活，所以學編程的人，一般能夠更加抽象的看待生活中發生的事情。

2、靜態代理的好處和缺點

優點

可以使得我們的真實角色更加純粹 . 不再去關注一些公共的事情 .
公共的業務由代理來完成 . 實現了業務的分工 ,
公共業務發生擴展時變得更加集中和方便 .

缺點 :

類多了 ,多了代理類 , 工作量變大了，開發效率降低。

我們想要靜態代理的好處，又不想要靜態代理的缺點，所以 , 就有了動態代理 !

3、靜態代理再理解

同學們練習完畢后，我們再來舉一個例子，鞏固大家的學習！

練習步驟：

創建一個抽象角色，比如咋們平時做的用戶業務，抽象起來就是增刪改查！

//抽象角色：增刪改查業務
public interface UserService {
    void add();
    void delete();
    void update();
    void query();
}

我們需要一個真實對象來完成這些增刪改查操作

//真實對象，完成增刪改查操作的人
public class UserServiceImpl implements UserService {

    public void add() {
        System.out.println("增加了一個用戶");
    }

    public void delete() {
        System.out.println("刪除了一個用戶");
    }

    public void update() {
        System.out.println("更新了一個用戶");
    }

    public void query() {
        System.out.println("查詢了一個用戶");
    }
}

需求來了，現在我們需要增加一個日志功能，怎么實現！
- 思路1 ：在實現類上增加代碼【麻煩！】
- 思路2：使用代理來做，能夠不改變原來的業務情況下，實現此功能就是最好的了！
設置一個代理類來處理日志！代理角色

//代理角色，在這里面增加日志的實現
public class UserServiceProxy implements UserService {
    private UserServiceImpl userService;

    public void setUserService(UserServiceImpl userService) {
        this.userService = userService;
    }

    public void add() {
        log("add");
        userService.add();
    }

    public void delete() {
        log("delete");
        userService.delete();
    }

    public void update() {
        log("update");
        userService.update();
    }

    public void query() {
        log("query");
        userService.query();
    }

    public void log(String msg){
        System.out.println("執行了"+msg+"方法");
    }

}

測試訪問類：

public class Client {
    public static void main(String[] args) {
        //真實業務
        UserServiceImpl userService = new UserServiceImpl();
        //代理類
        UserServiceProxy proxy = new UserServiceProxy();
        //使用代理類實現日志功能！
        proxy.setUserService(userService);

        proxy.add();
    }
}

OK，到了現在代理模式大家應該都沒有什么問題了，重點大家需要理解其中的思想；

我們在不改變原來的代碼的情況下，實現了對原有功能的增強，這是AOP中最核心的思想

【聊聊AOP：縱向開發，橫向開發】

4、動態代理

動態代理的角色和靜態代理的一樣。
動態代理的代理類是動態生成的 . 靜態代理的代理類是我們提前寫好的
動態代理分為兩類 :
- 一類是基于接口動態代理 ,，
  - 基于接口的動態代理——JDK動態代理
- 一類是基于類的動態代理，
  - 基于類的動態代理—cglib
  - 現在用的比較多的是 Java字節碼（Javassist）來生成動態代理，百度一下javasistJAVAssist
我們這里使用JDK的原生代碼來實現，其余的道理都是一樣的！

JDK的動態代理需要了解兩個類

核心 : InvocationHandler 和 Proxy ，打開JDK幫助文檔看看

搜索

在線文檔-jdk-zh

【InvocationHandler：調用處理程序】

Object invoke(Object proxy, 方法 method, Object[] args)；
//參數 
//proxy - 調用該方法的代理實例 
//method -所述方法對應于調用代理實例上的接口方法的實例。 方法對象的聲明類將是該方法聲明的接口，它可以是代理類繼承該方法的代理接口的超級接口。 
//args -包含的方法調用傳遞代理實例的參數值的對象的陣列，或null如果接口方法沒有參數。 原始類型的參數包含在適當的原始包裝器類的實例中，例如java.lang.Integer或java.lang.Boolean 。

【Proxy : 代理】

//生成代理類
public Object getProxy(){
    return Proxy.newProxyInstance(this.getClass().getClassLoader(),
                                  rent.getClass().getInterfaces(),this);
}

代碼實現

抽象角色和真實角色和之前的一樣！

Rent.java 即抽象角色

//抽象角色：租房
public interface Rent {
    public void rent();
}

Host.java 即真實角色

//真實角色: 房東，房東要出租房子
public class Host implements Rent{
    public void rent() {
        System.out.println("房屋出租");
    }
}

ProxyInvocationHandler. java 即代理角色

public class ProxyInvocationHandler implements InvocationHandler {
    private Rent rent;

    public void setRent(Rent rent) {
        this.rent = rent;
    }

    //生成代理類，重點是第二個參數，獲取要代理的抽象角色！之前都是一個角色，現在可以代理一類角色
    public Object getProxy(){
        return Proxy.newProxyInstance(this.getClass().getClassLoader(),
                                      rent.getClass().getInterfaces(),this);
    }

    // proxy : 代理類 method : 代理類的調用處理程序的方法對象.
    // 處理代理實例上的方法調用并返回結果
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        seeHouse();
        //核心：本質利用反射實現！
        Object result = method.invoke(rent, args);
        fare();
        return result;
    }

    //看房
    public void seeHouse(){
        System.out.println("帶房客看房");
    }
    //收中介費
    public void fare(){
        System.out.println("收中介費");
    }

}

Client.java

//租客
public class Client {

    public static void main(String[] args) {
        //真實角色
        Host host = new Host();
        //代理實例的調用處理程序
        ProxyInvocationHandler pih = new ProxyInvocationHandler();
        pih.setRent(host); //將真實角色放置進去！
        Rent proxy = (Rent)pih.getProxy(); //動態生成對應的代理類！
        proxy.rent();
    }

}

核心：一個動態代理 , 一般代理某一類業務 , 一個動態代理可以代理多個類，代理的是接口！

5、深化理解

我們來使用動態代理實現代理我們后面寫的UserService！

我們也可以編寫一個通用的動態代理實現的類！所有的代理對象設置為Object即可！

public class ProxyInvocationHandler implements InvocationHandler {
    private Object target;

    public void setTarget(Object target) {
        this.target = target;
    }

    //生成代理類
    public Object getProxy(){
        return Proxy.newProxyInstance(this.getClass().getClassLoader(),
                                      target.getClass().getInterfaces(),this);
    }

    // proxy : 代理類
    // method : 代理類的調用處理程序的方法對象.
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        log(method.getName());
        Object result = method.invoke(target, args);
        return result;
    }

    public void log(String methodName){
        System.out.println("執行了"+methodName+"方法");
    }

}

測試！

public class Test {
    public static void main(String[] args) {
        //真實對象
        UserServiceImpl userService = new UserServiceImpl();
        //代理對象的調用處理程序
        ProxyInvocationHandler pih = new ProxyInvocationHandler();
        pih.setTarget(userService); //設置要代理的對象
        UserService proxy = (UserService)pih.getProxy(); //動態生成代理類！
        proxy.delete();
    }
}

【測試，增刪改查，查看結果】

6、動態代理的好處

靜態代理有的它都有，靜態代理沒有的，它也有！

可以使得我們的真實角色更加純粹 . 不再去關注一些公共的事情 ;
公共的業務由代理來完成 . 實現了業務的分工 ;
公共業務發生擴展時變得更加集中和方便 ;
一個動態代理 , 一般代理某一類業務(一個大類) ;
一個動態代理可以代理多個類，代理的是接口！

AOP

1、什么是AOP

AOP（Aspect Oriented Programming）意為：面向切面編程，通過預編譯方式和運行期動態代理實現程序功能的統一維護的一種技術。

AOP是 OOP 思想的的延續，是軟件開發中的一個熱點，也是Spring框架中的一個重要內容，是函數式編程的一種衍生范型。利用AOP可以對業務邏輯的各個部分進行隔離，從而使得業務邏輯各部分之間的耦合度降低，提高程序的可重用性，同時提高了開發的效率。

2、 Aop在Spring中的作用

提供聲明式事務；允許用戶自定義切面

橫切關注點：跨越應用程序多個模塊的方法或功能。
- 與我們業務邏輯無關的，但是我們需要關注的部分，就是橫切關注點。如日志 , 安全 , 緩存 , 事務等等 ….
切面（ASPECT）：橫切關注點 被模塊化的特殊對象。即，它是一個類(Classs)。
通知（Advice）：切面必須要完成的工作。即，它是類中的一個方法(Function)。
目標（Target）：被通知對象。
代理（Proxy）：向目標對象應用通知之后創建的對象。
切入點（PointCut）：切面通知執行的 “地點”的定義。
連接點（JointPoint）：與切入點匹配的執行點。

SpringAOP中，通過Advice定義橫切邏輯，Spring中支持5種類型的Advice:

即 Aop 在不改變原有代碼的情況下 , 去增加新的功能。

通過method判斷再去執行內容；

3、使用Spring實現`AOP`

【重點】使用AOP織入，需要導入一個依賴包！

<!-- https://mvnrepository.com/artifact/org.aspectj/aspectjweaver -->
<dependency>
  <groupId>org.aspectj</groupId>
  <artifactId>aspectjweaver</artifactId>
  <version>1.9.4</version>
</dependency>

第一種方式：使用Spring接口實現

通過 Spring API 實現

首先編寫我們的業務接口和實現類

public interface UserService {

    public void add();

    public void delete();

    public void update();

    public void search();

}

public class UserServiceImpl implements UserService{

    @Override
    public void add() {
        System.out.println("增加用戶");
    }

    @Override
    public void delete() {
        System.out.println("刪除用戶");
    }

    @Override
    public void update() {
        System.out.println("更新用戶");
    }

    @Override
    public void search() {
        System.out.println("查詢用戶");
    }
}

然后去寫我們的增強類 , 我們編寫兩個 , 一個前置增強一個后置增強

public class Log implements MethodBeforeAdvice {

    //method : 要執行的目標對象的方法
    //objects : 被調用的方法的參數
    //Object : 目標對象
    @Override
    public void before(Method method, Object[] objects, Object o) throws Throwable {
        System.out.println( o.getClass().getName() + "的" + method.getName() + "方法被執行了");
    }
}

public class AfterLog implements AfterReturningAdvice {
    //returnValue 返回值
    //method被調用的方法
    //args 被調用的方法的對象的參數
    //target 被調用的目標對象
    @Override
    public void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable {
        System.out.println("執行了" + target.getClass().getName()
                           +"的"+method.getName()+"方法,"
                           +"返回值："+returnValue);
    }
}

最后去spring的文件中注冊 , 并實現aop切入實現 , 注意導入約束 .

<?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: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/aop
  http://www.springframework.org/schema/aop/spring-aop.xsd">

  <!--注冊bean-->
  <bean id="userService" class="com.kuang.service.UserServiceImpl"/>
  <bean id="log" class="com.kuang.log.Log"/>
  <bean id="afterLog" class="com.kuang.log.AfterLog"/>

  <!--aop的配置-->
  <aop:config>
    <!--切入點  expression:表達式匹配要執行的方法-->
    <aop:pointcut id="pointcut" expression="execution(* com.kuang.service.UserServiceImpl.*(..))"/>
    <!--執行環繞; advice-ref執行方法 . pointcut-ref切入點-->
    <aop:advisor advice-ref="log" pointcut-ref="pointcut"/>
    <aop:advisor advice-ref="afterLog" pointcut-ref="pointcut"/>
  </aop:config>

</beans>

測試

public class MyTest {
    @Test
    public void test(){
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
        UserService userService = (UserService) context.getBean("userService");
        userService.search();
    }
}

Aop的重要性 : 很重要 . 一定要理解其中的思路 , 主要是思想的理解這一塊 .

Spring的Aop就是將公共的業務 (日志 , 安全等) 和領域業務結合起來 , 當執行領域業務時 , 將會把公共業務加進來 . 實現公共業務的重復利用 . 領域業務更純粹 , 程序猿專注領域業務 , 其本質還是動態代理 .

第二種方式 : 自定義類來實現Aop

自定義類來實現Aop

目標業務類不變依舊是userServiceImpl

第一步 : 寫我們自己的一個切入類

public class DiyPointCut {

    public void before()
    {
        System.out.println("方法執行前");
    }

    public void after()
    {
        System.out.println("方法執行后");
    }
}

去spring中配置

<!--第二種方式自定義實現-->
<!--注冊bean-->
<bean id="diy" class="com.kuang.config.DiyPointcut"/>

<!--aop的配置-->
<aop:config>
  <!--第二種方式：使用AOP的標簽實現-->
  <aop:aspect ref="diy">
    <aop:pointcut id="diyPonitcut" expression="execution(* com.kuang.service.UserServiceImpl.*(..))"/>
    <aop:before pointcut-ref="diyPonitcut" method="before"/>
    <aop:after pointcut-ref="diyPonitcut" method="after"/>
  </aop:aspect>
</aop:config>

測試：

public class MyTest {
    @Test
    public void test02_query(){
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
        UserService userService =  context.getBean("userService", UserService.class);
        userService.query();
    }
}

方法執行前
UserServiceImpl.....query
方法執行后

第三種方式: 使用注解實現

使用注解實現

第一步：編寫一個注解實現的增強類

package com.kuang.config;

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;

@Aspect
public class AnnotationPointcut {
    @Before("execution(* com.kuang.service.UserServiceImpl.*(..))")
    public void before(){
        System.out.println("---------方法執行前---------");
    }

    @After("execution(* com.kuang.service.UserServiceImpl.*(..))")
    public void after(){
        System.out.println("---------方法執行后---------");
    }

    @Around("execution(* com.kuang.service.UserServiceImpl.*(..))")
    public void around(ProceedingJoinPoint jp) throws Throwable {
        System.out.println("環繞前");
        System.out.println("簽名:"+jp.getSignature());
        //執行目標方法proceed
        Object proceed = jp.proceed();
        System.out.println("環繞后");
        System.out.println(proceed);
    }
}

第二步：在Spring配置文件中，注冊bean，并增加支持注解的配置

<!--第三種方式:注解實現-->
<bean id="annotationPointcut" class="com.kuang.config.AnnotationPointcut"/>
<aop:aspectj-autoproxy/>

aop:aspectj-autoproxy ：說明

通過aop命名空間的<aop:aspectj-autoproxy />聲明自動為spring容器中那些配置@aspectJ切面的bean創建代理，織入切面。當然，spring 在內部依舊采用AnnotationAwareAspectJAutoProxyCreator進行自動代理的創建工作，但具體實現的細節已經被<aop:aspectj-autoproxy />隱藏起來了

proxy-target-class ：false

<aop:aspectj-autoproxy />有一個proxy-target-class屬性，默認為false，表示使用jdk動態代理織入增強，當配為<aop:aspectj-autoproxy poxy-target-class="true"/>時，表示使用CGLib``動態代理技術織入增強。不過即使proxy-target-class設置為false，如果目標類沒有聲明接口，則spring將自動使用**CGLib**動態代理。

4、總結：

實現方式	實現難度	功能性	優先度
Spring Api	高	強	高
自定義類	中	中	中
使用注解實現	底	弱	底

posted @ 2025-07-25 09:00 柯基大大閱讀(40) 評論(0) 收藏舉報來源

刷新頁面返回頂部

柯基大大