2. 程式人生 > >GOF23種設計模式

GOF23種設計模式

阿新 • • 發佈：2018-11-16

代理模式（Proxy pattern）

  1. 核心作用：
    通過代理，控制對物件的訪問,可以詳細控制訪問某個（某類）物件的方法，在呼叫這個方法前做前置處理，呼叫這個方法後做後置處理。
    AOP(Aspect Oriented Programming面向切面程式設計）的核心實現機制。
  2. 核心角色：
    **抽象角色：**定義代理角色和真實角色的公共對外方法。
    **真實角色：**實現抽象角色，定義真實角色所要實現的業務邏輯，供代理角色呼叫。
    關注真正的業務邏輯
    **代理角色：**實現抽象角色，是真實角色的代理，通過真實角色的業務邏輯方法來實現抽象方法，並附加自己的操作。
    將統一的流程控制放到代理角色中處理。
  3. 應用場景：
    安全代理：遮蔽對真實決角色的直接訪問
    遠端代理：通過代理類處理遠端方法呼叫（RMI）
    延遲載入：先載入輕量級的代理物件，真正需要再載入真實物件。
  4. 分類：
    4.1靜態代理：
    在這裡插入圖片描述
    介面類定義Star：
public interface Star {
	/**面試*/
	void confer();
	/**籤合同*/
	void signContract();
	/**訂機票*/
	void bookTicket();
	/**唱歌*/
	void sing();
	/**收沒款*/
	void collectMoney();
}

真實物件RealStar:

public class
 
 RealStar implements Star {

	@Override
	public void confer() {
		System.out.println("RealStar confer()");
	}

	@Override
	public void signContract() {
		System.out.println("RealStar signContract()");
	}

	public void bookTicket() {
		System.out.println("RealStar bookTicket()");
	}

	@Override
	public
 
 void sing() {
		System.out.println("RealStar(明星) sing()");
	}

	@Override
	public void collectMoney() {
		System.out.println("RealStar collectMoney()");
	}

}

代理類ProxyStar：

public class ProxyStar implements Star {

	RealStar realStar;
	
	public ProxyStar(RealStar realStar) {
		super();
		this.realStar = realStar;
	}

	@Override
	public void confer() {
		System.out.println("ProxyStar confer");
	}

	@Override
	public void signContract() {
		System.out.println("ProxyStar signContract");
	}

	@Override
	public void bookTicket() {
		System.out.println("ProxyStar bookTicket");
	}

	@Override
	public void sing() {
		realStar.sing();//真實的物件去做
	}

	@Override
	public void collectMoney() {
		System.out.println("ProxyStar collectMoney");
	}

}

測試：

public class Testd {

	public static void main(String[] args) {
		RealStar realStar=new RealStar();
		ProxyStar proxyStar=new ProxyStar(realStar);
		proxyStar.confer();
		proxyStar.signContract();
		proxyStar.sing();
		proxyStar.collectMoney();
	}
}

結論
在這裡插入圖片描述
4.2動態代理：
相比靜態代理優先：抽象角色中（介面）宣告的所以方法都被轉移待呼叫處理器一個集中的方法處理，這樣，我們可以使用更加靈活和統一的處理眾多的方法。
4.2.1 JDK自帶動態代理
java.lang.reflect.InvocationHandler (處理器介面)
可以通過invoke方法實現對真實角色的代理訪問
每次通過Proxy生成代理類物件時都要指定對應的處理器物件

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;

public class MyInvocationHandler implements InvocationHandler {
	
	JdkInterface jdk;
	
	public MyInvocationHandler(JdkInterface jdk) {
		this.jdk = jdk;
	}

	//java.lang.reflect.InvocationHandler (處理器介面)
	//可以通過invoke方法實現對真實角色的代理訪問
	//每次通過Proxy生成代理類物件時都要指定對應的處理器物件
	@Override
	public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
		System.out.println("前置處理：目標方法執行之前");//目標方法執行之前處理邏輯與業務
		method.invoke(jdk, args);//執行目標方法
		System.out.println("後置處理：目標方法執行之後");//目標方法執行之後處理邏輯
		return null;
	}

}

介面定義：

public interface JdkInterface {
	void say(String message);
}

實現類：

public class JDKInterfaceImpl implements JdkInterface {

	@Override
	public void say(String message) {
		System.out.println("輸出語句："+message);
	}
}

測試方法

import java.lang.reflect.Proxy;
public class TestMy {
	public static void main(String[] args) {
		JdkInterface jdkInterfaceImpl=new JDKInterfaceImpl();
		MyInvocationHandler my=new MyInvocationHandler(jdkInterfaceImpl);
		JdkInterface projdk=	(JdkInterface)Proxy.newProxyInstance(jdkInterfaceImpl.getClass().getClassLoader(), jdkInterfaceImpl.getClass().getInterfaces(), my);
		//Proxy.newProxyInstance(loader, interfaces, h);
		//ClassLoader loader :指定當前目標物件使用類載入器，寫法固定
		//Class<?>[] interfaces:目標物件實現的介面的型別，寫法固定
		//InvocationHandler h :事件處理介面，需傳入一個實現類，一般使用匿名內部類
		projdk.say("目標方法執行");
	}
}

4.2.2 javaassist位元組碼操作庫實現

4.2.3 CGLIB
目標類不能為final,目標物件的方法如果為final/static,那麼就不會被攔截，即不會執行目標物件額外的業務方法。
該類實現了建立子類的方法與代理的方法。getProxy(SuperClass.class)方法通過入參即父類的位元組碼，通過擴充套件父類的class來建立代理物件。intercept()方法攔截所有目標類方法的呼叫，obj表示目標類的例項，method為目標類方法的反射物件，args為方法的動態入參，proxy為代理類例項。proxy.invokeSuper(obj, args)通過代理類呼叫父類中的方法。

定義目標類：

public class Chinese {
	/**目標方法未實現任何的介面*/
	public  void sing() {
		System.out.println("吃麵條");
	}
}

定義CGLIB代理類工場

public class ProxyFactory implements MethodInterceptor {

	//給目標物件建立一個代理物件
	public Object getProxyInstance(Class target) {
		//1.工具類
		Enhancer enhancer=new Enhancer();
		//2.設定父類
		enhancer.setSuperclass(target);
		//3.設定回撥函式
		enhancer.setCallback(this);
		//4.通過位元組碼技術動態建立子類例項（代理物件）
		return enhancer.create();
	}
 
	//實現MethodInterceptor介面方法
	@Override
	public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
		System.out.println("執行目標方法之前：拿起筷子");
		Object object = proxy.invokeSuper(obj, args);//呼叫父類中的方法，執行目標方法
		System.out.println("執行目標方法之後：放下筷子");
		return object;
	}
}

測試方法：

public class CGLIBMain {
	public static void main(String[] args) {
		ProxyFactory proxyFactory= new ProxyFactory();
		//通過生成子類的方式建立代理類
		Chinese proxyInstance = (Chinese)proxyFactory.getProxyInstance(Chinese.class);
		proxyInstance.sing();
		System.out.println();
		System.out.println(proxyInstance);
	}
}

執行結果：
在這裡插入圖片描述

第二種引數寫法

public class ProxyFactory implements MethodInterceptor {
	private Object target;
	public ProxyFactory(Object target) {
		super();
		this.target = target;
	}

	//給目標物件建立一個代理物件
	public Object getProxyInstance() {
		//1.工具類
		Enhancer enhancer=new Enhancer();
		//2.設定父類
		enhancer.setSuperclass(target.getClass());
		//3.設定回撥函式
		enhancer.setCallback(this);
		//4.通過位元組碼技術動態建立子類例項（代理物件）
		return enhancer.create();
	}
 
	//實現MethodInterceptor介面方法
	@Override
	public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
		System.out.println("執行目標方法之前：拿起筷子");
		Object object = method.invoke(target, args);//呼叫父類中的方法，執行目標方法
		System.out.println("執行目標方法之後：放下筷子");
		return object;
	}
}

測試方法：

public class CGLIBMain {
	public static void main(String[] args) {
		Chinese chinese=new Chinese();
		ProxyFactory proxyFactory= new ProxyFactory(chinese);
		//通過生成子類的方式建立代理類
		Chinese proxyInstance = (Chinese)proxyFactory.getProxyInstance();
		
		proxyInstance.sing();
		System.out.println();
		System.out.println(proxyInstance);
	}
}

測試結果

在這裡插入圖片描述

4.2.4 ASM(底層使用指令，可維護性較差）

相關推薦

GoF23種設計模式之行為型模式之訪問者模式

部分 strong 操作 定義 狀態 arraylist his tro 不同的 概述 表示一個作用於某對象結構中的各元素的操作。 它使你可以在不改變各元素的類的前提下定義作用於這些元素的新操作。 適用性 1.一個對象結構包含很多

GoF23種設計模式之行為型模式之模板方法

title 開始 gof prim void strong 結構 currency 類圖 概述 定義一個操作中的算法的骨架，而將一些步驟延遲到子類中。 TemplateMethod使得子類可以不改變一個算法的結構即可重定義該算法的某些特定步驟。

GOF23種設計模式

代理模式（Proxy pattern） 核心作用： 通過代理，控制對物件的訪問,可以詳細控制訪問某個（某類）物件的方法，在呼叫這個方法前做前置處理，呼叫這個方法後做後置處理。 AOP(Aspect Oriented Programming面向切面程式設計）的核心實現機制。

GOF23種設計模式概括

GOF23種設計模式分為三種: 建立型模式[工廠方法模式] 結構型模式[（類）介面卡模式] 行為型模式[ 直譯器模式,模板方法模式]   建立型模式Creational Patterns 抽象工廠模式abstract factory：提供了一個建立一系列相關

Gof23種設計模式+簡單工廠設計模式總結（一）

一、軟體設計模式的種類 1.建立型模式 如何建立物件 2.結構型模式 如何實現類和物件的組合 3.行為型模式 類和物件怎麼樣互動以及怎麼樣分配職責 二、設計模式的原則 高內聚、低耦合 1.單一職責原則 類的職責比較

GOF23種設計模式精解

建立型 1. Factory Method（工廠方法） 2. Abstract Factory（抽象工廠） 3. Builder（建造者） 4. Prototype（原型） 5. Singleton（單例） 結構型 6. Adapter Class/Obje

面向物件GOF23種設計模式綜述

一、什麼是設計模式        設計模式，是一套被反覆使用、多數人知曉的、經過分類編目的、程式碼設計經驗的總結。使用設計模式是為了可重用程式碼、讓程式碼更容易被他人理解、保證程式碼可靠性、程式的重用性。        設計模式其

Java中的24種設計模式與7大原則

工廠模式 職責 需要 占位符 ati gre template 層次 cto 一、創建型模式 1、抽象工廠模式(Abstract factory pattern): 提供一個接口, 用於創建相關或依賴對象的家族, 而不需要指定具體類.2、生成器模式(Builder pat

23種設計模式介紹以及單例模式的學習

單例模式 餓漢式 23種設計模式 gof23 1、GOF23 設計模式總共分成創建型模式、結構型模式和行為型模式三種： a、創建型模式： - 單例模式、工廠模式、抽象工廠模式、建造者模式、原型模式 b、構建型模式： - 適配器模式、橋接模式、裝配模式、組合模式、建造者模

23種設計模式介紹（一）---- 創建型模式

接口 ret static 深復制 return 對象 相互 object c png 由於設計模式篇幅比較大，如果在一篇文章講完所有的設計模式的話不利於閱讀。於是我把它分為三篇文章 23種設計模式介紹（一）---- 創建型模式 23種設計模式介紹（二）---- 結構型模

【Unity與23種設計模式】狀態模式（State）

unity public text 開始 sys 狀態模式 改變 val 繼承 定義： “讓一個對象的行為隨著內部狀態的改變而變化，而該對象也像是換了類一樣” 應用場景： 角色AI：控制角色在不同狀態下的AI行為 服務器連接狀態：開始連線、連線中、斷線等狀態 關卡進

轉：23種設計模式的應用場景

橋模式 man 16px pop 表示 black strong art bstr 設計模式主要分三個類型:創建型、結構型和行為型。 其中創建型有： 一、Singleton，單例模式：保證一個類只有一個實例，並提供一個訪問它的全局訪問點 ；

【Unity3D與23種設計模式】建造者模式（Builder）

產出 private 一個 gof 行為 並且 bstr reac 定義 GoF中定義： “將一個復雜的構建流程與它的對象表現分離出來，讓相同的構建流程可以產生不同的對象行為表現。” 建造者模式可以分為兩個步驟來實施： 1.將復雜的構建流程獨立出來，並將整個流程分成

23種設計模式中的叠代器模式

pos over arr imp @override 一個 next() int position 叠代器模式：提供一種方法順序訪問一個聚合對象中的各個對象。 那麽如何提供一個方法順序呢？ public interface Iterator<T>{ 　　publ

23種設計模式中的訪問者模式

功能需求 封裝 改變 擴展 數據結構 模式 困難 操作 如果 訪問者模式：對於一組對象，在不改變數據結構的前提下，增加作用於這些結構元素新的功能。 適用於數據結構相對穩定，它把數據結構和作用於其上的操作解耦，使得操作集合可以相對自由地演化。 優點： 符合單一職責原則 擴展性

23種設計模式中的原型模式

1-1 ... 實例代碼 sets each png 為什麽 .get protect 原型模式：通過復制現有實例來創建新的實例，無須知道相應類的信息。 個人見解：在大量循環時，需要初始化對象，用 原型模式能節省大量的初始化所花費的時間，值得一談的是淺復制和深復制 淺復制：

java 23種設計模式

代理 建造者 學習 article 適配器 htm ava arc 叠代 備註這是別人總結的本來想轉載可惜不會怎麽轉載（感謝） 以下是學習過程中查詢的資料,別人總結的資料,比較容易理解(站在各位巨人的肩膀上,望博主勿究) 創建型抽象工廠模式 http://www.cnblo

23種設計模式之觀察者模式

主題 一個 server bsp 監聽 images 關系 .com 自動更新 觀察者模式（Observer）：定義了一種一對多的關系，讓多個觀察者對象同時監聽某一個主題對象。這個主題對象在狀態發生變化時，會通知所有觀察者對象，使它們能夠自動更新自己。 23種設計模式之

23種設計模式之抽象工廠模式

tor turn sql數據庫 png insert face sign 相關 reat 抽象工廠模式（Abstract Factory）：提供一個創建一系列相關或相互依賴對象的接口，而無需指定它們具體的類。 package designMode.abstractFa

23種設計模式之模板方法模式

技術分享 cnblogs ati strac void package com rim div 模板方法模式（TemplateMethod）：定義一個操作中的算法的骨架，而將一些步驟延遲到子類中。模板方法使得子類可以不改變一個算法的結構即可重定義該算法的某些特定步驟。