java設計模式6——代理模式

1、代理模式介紹：

1.1、為什么要學習代理模式？因為這就是Spring Aop的底層！（SpringAop 和 SpringMvc）

1.2、代理模式的分類：

靜態代理
動態代理

1.3、代理模式關系圖（以租房子為例）

2、靜態代理

2.1、角色分析：

抽象角色：一般會使用介面或者抽象類來解決
真實角色：被代理的角色
代理客戶：代理真實角色，代理真實角色后，我們一般會做一些附屬的操作
客戶：訪問代理物件的人

2.2、例1（租房子演示）

2.2.1、抽象角色實作（房東抽象類）

package com.xgp.company.結構性模式.代理模式.靜態代理.Demo1;
/**


租房

*/

public interface Rent {
void rent();

}

2.2.2、真實角色實作（房東的實作類）

package com.xgp.company.結構性模式.代理模式.靜態代理.Demo1;
/**


房東

*/

public class Host implements Rent {
@Override

public void rent() {

System.out.println("房東要出租房子！");

}

}

2.2.3、不通過代理進行租房

package com.xgp.company.結構性模式.代理模式.靜態代理.Demo1;
public class Client {

public static void main(String[] args) {

//直接找房東

Host host = new Host();

host.rent();

}

}

運行結果：

房東要出租房子！

2.2.4、弊端

在實際的生活場景中，房東可能只賣房，而不負責租房
如果要提高租房子的成功率，必然還需要一些其他的服務，如：看房、談價錢、簽合同等，而這些房東并不想參與，因此產生了中介，也就是代理，

2.2.5、代理出現

package com.xgp.company.結構性模式.代理模式.靜態代理.Demo1;
public class Proxy implements Rent {
private Host host;

public Proxy() {

}

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

@Override
public void rent() {
    seeHouse();
    host.rent();
    fare();
    hetong();
}

//看房
public void seeHouse() {
    System.out.println(&quot;中介代理看房&quot;);
}

//收中介費
public void fare() {
    System.out.println(&quot;收中介費&quot;);
}

public void hetong() {
    System.out.println(&quot;簽合同&quot;);
}

}

2.2.6、通過代理來租房子

package com.xgp.company.結構性模式.代理模式.靜態代理.Demo1;
public class Client {

public static void main(String[] args) {

/*        //直接找房東

Host host = new Host();

host.rent();*/
    //通過代理去租房子
    //房東要租房子
    Host host = new Host();
    //代理
    //中介幫房東租房子，但是，中介一半都會有一些附屬操作
    Proxy proxy = new Proxy(host);
    proxy.rent();
}

}

運行結果：

中介代理看房
房東要出租房子！
收中介費
簽合同

2.3、分析：

代理模式的好處

可以使真實角色的操作更加純粹，不用去關注一些公共的業務，
公共的業務交給了代理角色去完成，實作了業務的分工，
公共業務發生擴展的時候，方便集中管理，

缺點：

一個真實角色就會產生一個代理的角色，代碼量翻倍，開發效率變低，

2.4、例1（增刪改查業務的演示）

2.4.1、撰寫service的抽象類

package com.xgp.company.結構性模式.代理模式.靜態代理.Demo2;
public interface UserService {

void add();

void del();

void update();

void query();

}

2.4.2、撰寫service的實作類

package com.xgp.company.結構性模式.代理模式.靜態代理.Demo2;
/**


真實物件

*/

public class UserServiceImpl implements UserService {

@Override

public void add() {

System.out.println("增加了一個用戶");

}
@Override

public void del() {

System.out.println("洗掉了一個用戶");

}
@Override

public void update() {

System.out.println("更新了一個用戶");

}
@Override

public void query() {

System.out.println("查詢了一個用戶");

}

}

2.4.3、如果此時想不改變原有的代碼，而增加方法日志列印的功能，此時代理誕生

package com.xgp.company.結構性模式.代理模式.靜態代理.Demo2;
/**


代理角色，增加日志的功能

*/

public class UserServiceProxy implements UserService {
private UserService userService;
public void setUserService(UserService userService) {

this.userService = userService;

}
@Override

public void add() {

userService.add();

log("add");

}
@Override

public void del() {

userService.del();

log("del");

}
@Override

public void update() {

userService.update();

log("update");

}
@Override

public void query() {

userService.query();

log("query");

}
public void log(String msg) {

System.out.println("使用了" + msg + "方法！");

}

}

2.4.4、撰寫客戶端類，使用service的方法，并列印日志

package com.xgp.company.結構性模式.代理模式.靜態代理.Demo2;
public class Client {

public static void main(String[] args) {

UserService userService = new UserServiceImpl();
    UserServiceProxy proxy = new UserServiceProxy();
    proxy.setUserService(userService);

    proxy.add();
    proxy.del();
    proxy.update();
    proxy.query();
}

}

運行結果：

增加了一個用戶
使用了add方法！
洗掉了一個用戶
使用了del方法！
更新了一個用戶
使用了update方法！
查詢了一個用戶
使用了query方法！

2.5、反思：在實際的業務中，橫向開發的好處

可以保證原有代碼的可行性，不會對軟體原來的版本進行破壞，向過去兼容，

3、動態代理

3.1、動態代理的特點

動態代理和靜態代理一樣
動態代理的代理類是動態生成的，不是我們直接寫的

3.2、動態代理實作方式的分類

基于介面——JDK動態代理（本節需要講述的方式）
基于類：cglib
java位元組碼實作：javasist

3.3、需要了解的兩個類

Proxy:代理類
InvocationHandler:呼叫處理程式類

具體的使用參照java的api

3.4、例1——房東租房的例子

3.4.1、房東的介面和實作類不變

3.4.2、實作自動生成代理的類

package com.xgp.company.結構性模式.代理模式.動態代理.Demo1;
import java.lang.reflect.InvocationHandler;

import java.lang.reflect.Method;

import java.lang.reflect.Proxy;
/**


等下我們會用這個類，自動生成代理類

*/

public class ProxyInvocationHandler implements InvocationHandler {
/**

被代理的介面

*/

private Rent rent;

public void setRent(Rent rent) {

this.rent = rent;

}
/**

獲得一個代理
@return

*/

public Object getProxy() {

return Proxy.newProxyInstance(this.getClass().getClassLoader(),rent.getClass().getInterfaces(),this);

}

/**

處理代理實體，并放回結果
@param proxy
@param method
@param args
@return
@throws Throwable

*/

@Override

public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

//用反射來執行方法

seeHouse();     //呼叫代理自身的方法

//動態代理的本質，就是使用反射機制來實作

Object result = method.invoke(rent, args);

fare();

hetong();

return result;

}

public void seeHouse() {

System.out.println("中介帶看房子！");

}
//收中介費

public void fare() {

System.out.println("收中介費");

}
public void hetong() {

System.out.println("簽合同");

}

}

3.4.3、實作客戶端使用代理來租房子

package com.xgp.company.結構性模式.代理模式.動態代理.Demo1;
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();
}

}

運行結果：

中介帶看房子！
房東要出租房子！
收中介費
簽合同

3.5、例2——增刪改查的例子

3.5.1、先來實作一個萬能的代理生成類

package com.xgp.company.結構性模式.代理模式.動態代理.Demo2;
import java.lang.reflect.InvocationHandler;

import java.lang.reflect.Method;

import java.lang.reflect.Proxy;
/**


萬能代理類

*/

public class ProxyInvocationHandler implements InvocationHandler {
/**

被代理的介面

*/

private Object target;

public void setTarget(Object target) {

this.target = target;

}
/**

獲得一個代理
@return

*/

public Object getProxy() {

return Proxy.newProxyInstance(this.getClass().getClassLoader(),target.getClass().getInterfaces(),this);

}

/**

處理代理實體，并放回結果
@param proxy
@param method
@param args
@return
@throws Throwable

*/

@Override

public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

//用反射來執行方法

//動態代理的本質，就是使用反射機制來實作

Object result = method.invoke(target, args);

log(method.getName());

return result;

}

public void log(String msg) {

System.out.println("使用了" + msg + "方法！");

}

}

也就是將上一個例子的具體實作類——房東類，替換成Object類

3.5.2、UserService的介面和實作類不變

3.5.3、撰寫客戶端類使用代理呼叫增刪改查方法

package com.xgp.company.結構性模式.代理模式.動態代理.Demo2;
public class Client {

public static void main(String[] args) {

//真實角色

UserService userService = new UserServiceImpl();

//代理角色

ProxyInvocationHandler pih = new ProxyInvocationHandler();

pih.setTarget(userService);

UserService proxy = (UserService) pih.getProxy();
    proxy.add();
    proxy.del();
    proxy.update();
    proxy.query();
}

}

運行結果：

增加了一個用戶
使用了add方法！
洗掉了一個用戶
使用了del方法！
更新了一個用戶
使用了update方法！
查詢了一個用戶
使用了query方法！

3.6、弊端分析：

雖然使用動態代理能夠節省代碼量，并且實作靜態代理的全部優點，但是，動態代理的核心是反射技術，通過反射技術呼叫方法效率較大，因此也可能影響系統效率，

3.7、動態代理的好處

一個動態代理的是一個介面，一般就是對應的一類業務，

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

標籤：設計模式

上一篇：java設計模式5——配接器模式

下一篇：java設計模式7——橋接模式