Spring AOP系列（一）— 代理模式

AOP（Aspect Oriented Programming）并沒有創造或使用新的技術，其底層就是基于代理模式實作，因此我們先來學習一下代理模式，

基本概念

定義

代理模式，為物件提供一種代理，以控制對這個物件的訪問，

角色

代理模式也稱為委托模式，一般有以下三個角色
Alt 代理模式的通用類圖

抽象主題角色：抽象主題類可以是抽象類也可以是介面，是一個最普通的業務型別定義，無特殊要求，
具體主題角色：也被稱為被委托角色、被代理角色，是具體業務邏輯的實際執行者，
抽象主題角色：也被稱為委托類，代理類，負責控制具體主題角色的訪問和應用，并且可以在具體主題角色的業務邏輯執行前后進行預處理和后處理的邏輯，
從“具體主題角色”的定義我們可以明確一點：代理模式中的被代理類和代理類的關系，并非是說代理類幫助被代理類完成了所有的作業，反而是最核心的作業仍然是由被代理類自己來完成，代理類在其中起的作用就是控制被代理類的訪問、應用，以及在被代理類執行核心業務邏輯的前后進行其它的處理，
下面的實踐將會幫助我們更好地理解，

簡單代理模式的基本實作

這里我們先按斬訓本概念中內容，完成一個簡單代理模式的基本實作，設想這樣一個場景：明星與經紀人，經紀人幫明星與外界洽談合作，簽訂合同，計算傭金；明星完成演戲、唱歌等作業，
首先定義一個Actor.java

package com.leng.proxy;

/**
 * @Classname Actor
 * @Date 2020/9/12 23:30
 * @Autor lengxuezhang
 */
public interface Actor {
    /**
     * 演戲
     */
    public void act();

    /**
     * 唱歌
     */
    public void sing();
}

藝人一般需要會唱歌和演戲，
接著分別實作明星類，實作Actor介面，并傳入姓名，

package com.leng.proxy;

/**
 * @Classname Star
 * @Date 2020/9/12 23:32
 * @Autor lengxuezhang
 */
public class Star implements Actor {

    private String name;

    public Star(String name) {
        this.name = name;
    }

    @Override
    public void act() {
        System.out.println(name + "在演戲");
    }

    @Override
    public void sing() {
        System.out.println(name + "在唱歌");
    }
}

最后實作經紀人

package com.leng.proxy;

/**
 * @Classname Agent
 * @Date 2020/9/12 23:36
 * @Autor lengxuezhang
 */
public class Agent implements Actor {

    private Actor actor = null;

    // 要想實作經紀人代理明星，需要將被代理類物件傳遞給代理類
    public Agent(Actor actor) {
        this.actor = actor;
    }
    
    @Override
    public void act() {
        this.before();
        // 實際呼叫的是明星的act(),經紀人接活，但最后去演戲的肯定是明星自己
        actor.act();
        this.after();
    }

    @Override
    public void sing() {
        this.before();
        actor.sing();
        this.after();
    }

    // 預處理方法
    private void before() {
        System.out.println("談好價錢，簽好合同");
    }

    // 后處理方法
    private void after() {
        System.out.println("清算演出費，和明星分錢");
    }
}

客戶端呼叫Client.java：

package com.leng;

import com.leng.proxy.Agent;
import com.leng.proxy.Star;

/**
 * @Classname Client
 * @Date 2020/9/12 2:40
 * @Autor lengxuezhang
 */
public class Client {
    public static void main(String[] args) {
        Star star = new Star("劉德華");
        Agent agent = new Agent(star);
        agent.act();
        agent.sing();
    }
}

運行結果：

談好價錢，簽好合同
劉德華在演戲
清算演出費，和明星分錢
談好價錢，簽好合同
劉德華在唱歌
清算演出費，和明星分錢

小結：

代理模式實作的關鍵是，代理類持有被代理類物件，這樣才能執行被代理類本身想要執行的業務邏輯，
代理類可以定義自己的預處理和后處理方法，使之在被代理類的業務邏輯前后執行，
以上被稱為基于代理模式概念的一個例子，實際上代理模式在不同場景或要求下會有一些新的特性，如接下來要介紹的普通代理和強制代理，

代理模式的擴展

普通代理

明星的作業一般比較忙，沒有時間和外界有太多溝通和接觸，導演想要找明星演戲，一般只能先去聯系他的公司經紀人，是聯系不到明星本人，“導演只能聯系到經紀人，而不能聯系明星”，這樣的模式就被稱為“普通代理”，換句話說：普通代理模式下，客戶端只能訪問代理類，不能訪問被代理類，
上面的Client.java中，直接new了一個明星物件，這就算是直接訪問了被代理類，不能稱為普通代理，那如何才能實作普通代理呢，關鍵是讓被代理類的創建只能由代理類來完成，修改代碼如下：
只需要修改建構式

package com.leng.proxy;

/**
 * @Classname Star
 * @Date 2020/9/12 23:32
 * @Autor lengxuezhang
 */
public class Star implements Actor {

    private String name;

    public Star(Agent agent, String name) throws Exception {
        // 必須是經紀人才能創建明星
        if(agent == null) {
            throw new Exception("非經紀人，不能創造明星");
        } else {
            this.name = name;
        }
    }

    @Override
    public void act() {
        System.out.println(name + "在演戲");
    }

    @Override
    public void sing() {
        System.out.println(name + "在唱歌");
    }
}

package com.leng.proxy;

/**
 * @Classname Agent
 * @Date 2020/9/12 23:36
 * @Autor lengxuezhang
 */
public class Agent implements Actor {

    private Actor actor = null;

    // 告訴agent，我需要聯系哪一個"明星"
    public Agent(String name) {
        try {
            this.actor = new Star(this, name);
        } catch (Exception e) {
            System.out.println("創建agent例外");
        }
    }

    @Override
    public void act() {
        this.before();
        actor.act();
        this.after();
    }

    @Override
    public void sing() {
        this.before();
        actor.sing();
        this.after();
    }

    // 預處理方法
    private void before() {
        System.out.println("談好價錢，簽好合同");
    }

    // 后處理方法
    private void after() {
        System.out.println("清算演出費，和明星分錢");
    }
}

客戶端類在使用時，也需要做修改，此時客戶端可以不直接訪問Star

package com.leng;
import com.leng.proxy.Agent;
/**
 * @Classname Client
 * @Date 2020/9/12 2:40
 * @Autor lengxuezhang
 */
public class Client {
    public static void main(String[] args) {
        Agent agent = new Agent("劉德華");
        agent.act();
        agent.sing();
    }
}

運行結果：

談好價錢，簽好合同
劉德華在演戲
清算演出費，和明星分錢
談好價錢，簽好合同
劉德華在唱歌
清算演出費，和明星分錢
可以看到運行結果并沒有發生改變，但確實已經實作了只能以訪問代理類方式訪問非代理類，假如客戶端直接訪問代理類的話，是會拋出例外的，
普通代理模式的優點：

呼叫者不關心被代理類的實作，被代理類的修改不會影響高層模塊的呼叫，
被代理類的訪問權限收口在代理類，

強制代理

先來看一個場景：

王晶想找華仔拍戲，兩人老相識了，于是王晶直接打電話問華仔：“華仔啊，有咩時間？搵你拍片喔"”，
華仔回復：“你先找我的經紀人談一下吧，看一下我的作業安排”，
然后華仔給王晶自己經紀人的聯系方式，王晶和經紀人談好之后，華仔就準備去拍王晶的電影了，
這個場景里有個點，首先王晶實際上是不能直接找華仔拍戲，即使有聯系方式，華仔也不一定給你拍；其次是王晶必須與華仔指定的經紀人溝通具體的拍戲作業，
強制代理的要求是：

不能直接通過代理類訪問被代理類，
不能直接訪問被代理類，
只能聽過被代理類指定的代理類訪問被代理類，
接下來逐個講解如何修改之前的代碼，首先抽象主題角色中需要增加一個獲取自己代理類的方法，其它不變：

public interface Actor {
	...
    public Actor getProxy();
}

明星類實作該方法，一方面要找到自己的代理，另一方面其它的唱歌、演戲方法也需要檢查是否是自己指定的代理類訪問的，

package com.leng.proxy;

/**
 * @Classname Star
 * @Date 2020/9/12 23:32
 * @Autor lengxuezhang
 */
public class Star implements Actor {

    private String name;

    private Agent agent = null;

    public Star(String name) {
        this.name = name;
    }

    @Override
    public void act() {
        if (isProxy()) {
            System.out.println(name + "在演戲");
        } else {
            System.out.println("請使用指定的代理訪問");
        }
    }

    @Override
    public void sing() {
        if (isProxy()) {
            System.out.println(name + "在唱歌");
        }else {
            System.out.println("請使用指定的代理訪問");
        }
    }

    @Override
    public Actor getProxy() {
        this.agent = new Agent(this);
        return this.agent;
    }

    /**
     * 判斷是否是指定的代理
     * @return
     */
    private boolean isProxy() {
        if(agent == null) {
            return false;
        }
        return true;
    }
}

經紀人類

package com.leng.proxy;

/**
 * @Classname Agent
 * @Date 2020/9/12 23:36
 * @Autor lengxuezhang
 */
public class Agent implements Actor {

    private Actor actor = null;

    // 告訴agent，我需要聯系哪一個"明星"
    public Agent(Actor actor) {
        this.actor = actor;
    }

    @Override
    public void act() {
        this.before();
        actor.act();
        this.after();
    }

    @Override
    public void sing() {
        this.before();
        actor.sing();
        this.after();
    }

    @Override
    public Actor getProxy() {
        //經紀人沒有自己的經紀人，所以就回傳自己
        return this;
    }

    // 預處理方法
    private void before() {
        System.out.println("談好價錢，簽好合同");
    }

    // 后處理方法
    private void after() {
        System.out.println("清算演出費，和明星分錢");
    }
}

現在來測驗一下，首先看看如果直接訪問被代理類，是否可行

public class Client {
    public static void main(String[] args) {

        Star star = new Star("劉德華");
        star.act();
        star.sing();

    }
}

運行結果：

請使用指定的代理訪問
請使用指定的代理訪問

顯然訪問失敗了，接下來嘗試一下如果通過代理類訪問呢

package com.leng;

import com.leng.proxy.Actor;
import com.leng.proxy.Agent;
import com.leng.proxy.Star;

/**
 * @Classname Client
 * @Date 2020/9/12 2:40
 * @Autor lengxuezhang
 */
public class Client {
    public static void main(String[] args) {
        Actor star = new Star("劉德華");
        Actor agent = new Agent(star);
        agent.act();
        agent.sing();
    }
}

談好價錢，簽好合同
請使用指定的代理訪問
清算演出費，和明星分錢
談好價錢，簽好合同
請使用指定的代理訪問
清算演出費，和明星分錢
可以看到中間業務邏輯部分還是錯誤的，ok，那我就按照強制代理的規定來：

package com.leng;

import com.leng.proxy.Actor;
import com.leng.proxy.Star;

/**
 * @Classname Client
 * @Date 2020/9/12 2:40
 * @Autor lengxuezhang
 */
public class Client {
    public static void main(String[] args) {
        // 先定義一個明星
        Actor star = new Star("劉德華");
        // 由這個明星指定經紀人
        Actor agent = star.getProxy();
        agent.act();
        agent.sing();
    }
}

談好價錢，簽好合同
劉德華在演戲
清算演出費，和明星分錢
談好價錢，簽好合同
劉德華在唱歌
清算演出費，和明星分錢
運行結果顯示成功，

小結：強制代理的核心就是通過被代理類指定的代理類，去訪問被代理類的方法，

總結

本篇文章首先介紹了代理模式的基本概念和基本代碼實作，然后進行了一些擴展，介紹了普通代理和強制代理的概念和實作，下一篇將會詳細介紹動態代理的知識，

參考文獻
《設計模式之禪》

轉載請註明出處，本文鏈接：https://www.uj5u.com/houduan/29068.html

標籤：Java

上一篇：Java三大特性【繼承、封裝、多型】

下一篇：面試題精選:資料偽造