Java進階篇設計模式之七 ----- 享元模式和代理模式

時間 2019-11-17

標籤 java 進階設計模式之七代理欄目 Java 简体版

原文原文鏈接

前言

在上一篇中咱們學習告終構型模式的組合模式和過濾器模式。本篇則來學習下結構型模式最後的兩個模式，享元模式和代理模式。html

享元模式

簡介java

享元模式主要用於減小建立對象的數量，以減小內存佔用和提升性能。這種類型的設計模式屬於結構型模式，它提供了減小對象數量從而改善應用所需的對象結構的方式。git

用通俗的話來講就是進行共用。生活中也有一些例子，好比以前很火的共享單車，更早以前的圖書館，編程中常常用的String類，數據庫鏈接池等等。固然，享元模式主要的目的是複用，若是該對象沒有的話，就會進行建立。程序員

享元模式的角色主要分爲三大類，抽象享元類、具體享元類以及享元工廠類。github

抽象享元類：全部具體享元類的超類或者接口，經過這個接口，能夠接受並做用於外部專題。
具體享元類：實現抽象享元類接口的功能並增長存儲空間。
享元工廠類：用來建立並管理抽象享元類對象，它主要用來確保合理地共享。每當接受到一個請求是，便會提供一個已經建立的抽象享元類對象或者新建一個。享元模式的核心在於享元工廠類，享元工廠類的做用在於提供一個用於存儲享元對象的享元池，用戶須要對象時，首先從享元池中獲取，若是享元池中不存在，則建立一個新的享元對象返回給用戶，並在享元池中保存該新增對象。

其它的就再也不多說，這裏依舊使用一個簡單的示例來加以說明。在咱們之前讀書的時候，常常會用到筆，其中鉛筆又是最先接觸的，咱們最開始使用鉛筆可能不是寫字，而是進行畫畫。這裏咱們能夠把筆看成一個抽象享元類，鉛筆看成一個具體享元類，而後再建立一個享元工廠類，用於建立和管理，最後再由調用者決定用鉛筆進行幹嗎。spring

首先，咱們建立一個接口。數據庫

interface Pen {
   void write();
}
複製代碼

而後再建立一個享元工廠類，指定須要內部須要作的事情。編程

class Penil implements Pen {
   private String name;
   private String something; 
   private  int i;
   
   public Penil(String name) {
   	this.name = name;
   	i++;
   	System.out.println(name+" 第:"+i+"次建立");
   }
   
   public String getName() {
   	return name;
   }
   
   public void setName(String name) {
   	this.name = name;
   }
   
   public String getSomething() {
   	return something;
   }
   
   public void setSomething(String something) {
   	this.something = something;
   }
   
   @Override
   public void write() {
   	System.out.println(name+" 用於鉛筆 "+something);
   }
}
複製代碼

繼而再建立一個工廠類，用於建立和管理。設計模式

class PenFactory {
   private static final Map<String, Penil> map = new HashMap<String, Penil>();

   public static Penil get(String name) {
   	Penil penil = map.get(name);
   	if (penil == null) {
   		penil = new Penil(name);
   		map.put(name, penil);
   	}
   	return penil;
   }
}
複製代碼

最後再來進行調用測試。安全

public class FlyweightTest {
	public static void main(String[] args) {
		String names[] = { "張三", "李四", "王五", "虛無境" };
		for (int i = 0; i < 8; i++) {
			Penil penil = PenFactory.get(names[i>3?i-4:i]);
			penil.setSomething("畫了一條魚");
			penil.write();
		}
	}
}
複製代碼

輸出結果:

張三 第:1次建立
			張三 用於鉛筆  畫了一條魚
			李四 第:1次建立
			李四 用於鉛筆  畫了一條魚
			王五 第:1次建立
			王五 用於鉛筆  畫了一條魚
			虛無境 第:1次建立
			虛無境 用於鉛筆  畫了一條魚
			張三 用於鉛筆  畫了一條魚
			李四 用於鉛筆  畫了一條魚
			王五 用於鉛筆  畫了一條魚
			虛無境 用於鉛筆  畫了一條魚
複製代碼

上述示例中，每一個對象都使用了兩次，可是每一個對象都只是建立了一次而已，而享元模式核心的目的其實就是複用，只要咱們理解了這一點，想必掌握該模式也就不在話下了。

享元模式優勢：

極大的減小對象的建立，從而下降了系統的內存，提高了效率。

享元模式缺點：

提升了系統的複雜度，由於須要將狀態進行分離成內部和外部，而且也使外部狀態固有化，使得隨着內部狀態的變化而變化，會形成系統的混亂。

使用場景：

系統有大量類似對象。

注意事項：

須要注意劃分外部狀態和內部狀態，不然可能會引發線程安全問題。這些類必須有一個工廠對象加以控制。

與單例模式比較

雖然它們在某些方面很像，可是實際上倒是不一樣的東西，單例模式的目的是限制建立多個對象，避免衝突，好比使用數據庫鏈接池。而享元模式享元模式的目的是共享，避免屢次建立耗費資源，好比使用String類。

代理模式

簡介

代理模式於結構型模式，主要是經過一個類表明另外一個類的功能。一般，咱們建立具備現有對象的對象，以便向外界提供功能接口。

代理模式，如其名，也就是代理做用。咱們生活中也有很多示例，好比典型的代購，土豪專用的支票，Windows 裏面的快捷方式，以及spring中的aop 等等。

代理模式主要由這三個角色組成，抽象角色、代理角色和真實角色。

抽象角色：經過接口或抽象類聲明真實角色實現的業務方法。
代理角色：實現抽象角色，是真實角色的代理，經過真實角色的業務邏輯方法來實現抽象方法，並能夠附加本身的操做。
真實角色：實現抽象角色，定義真實角色所要實現的業務邏輯，供代理角色調用。

代理模式又分爲靜態代理、動態代理。

靜態代理是由程序員建立或工具生成代理類的源碼，再編譯代理類。所謂靜態也就是在程序運行前就已經存在代理類的字節碼文件，代理類和委託類的關係在運行前就肯定了。
動態代理是在實現階段不用關心代理類，而在運行階段才指定哪個對象。

這裏咱們依舊用一個簡單的示例來進行說明。張三和李四是室友，某天，張三在寢室內玩遊戲正帶勁，感受肚子餓了，本想下樓去吃飯的，可是想起李四可能快要回來，因而打電話給李四，讓李四幫本身帶份盒飯。這裏的李四就扮演着代理者的做用。

靜態代理

首先咱們用靜態代理來實現該功能。

這裏實現相對而言較爲簡單，依舊是定義一個接口，而後定義一個真實的角色，實現該接口的功能，繼而定義一個代理者，也實現該接口，可是添加該真實角色的對象進行相應的業務邏輯處理。那麼該靜態代理代碼實現以下:

interface Shopping {
	void buyFood();
}

class ExecutePerson implements Shopping {
	private String name;
	public ExecutePerson(String name) {
		this.name = name;
	}

	@Override
	public void buyFood() {
		System.out.println(name + " 買東西");
	}
}

class ProxyPerson implements Shopping {
	private ExecutePerson ep;
	public ProxyPerson(ExecutePerson ep) {
		this.ep = ep;
	}
	@Override
	public void buyFood() {
		ep.buyFood();
	}
}


public class ProxyTest {
	public static void main(String[] args) {	
		String name = "李四";
		Shopping shopping = new ProxyPerson(new ExecutePerson(name));
		shopping.buyFood();
	}
}
複製代碼

輸入結果:

李四 買東西
複製代碼

在使用靜態代理實現該功能以後，咱們發現實現起來很簡單，經過一個代理類就能夠在不影響目標對象的前提進行擴展使用。可是咱們也發現一個問題，若是咱們不肯定須要代理某個真實類的時候會比較麻煩，並且在類過多的時候，目標對象與代理對象都要維護，會使系統複雜度提高，維護起來也更加麻煩。不過這時咱們就可使用動態代理來進行解決。

動態代理

所謂動態代理能夠沒必要強行指定某個真實的角色，只須要在運行時決定就能夠了。這裏咱們可使用JDK中java.lang.reflect來進行開發。

JDK對動態代理提供瞭如下支持:

java.lang.reflect.Proxy 動態生成代理類和對象
java.lang.reflect.InvocationHandler
- 能夠經過invoke方法實現對真實角色的代理訪問;
- 每次經過Proxy生成代理類對象時都要指定對象的處理器對象.

那麼廢話不在多說，開始進行代碼改造，以前的接口和真實者不須要更改，咱們只須要更改代理者就能夠了。更改以後的代碼以下:

class ProxyPerson2 implements InvocationHandler {
 private Shopping shopping;
 private final String methodName = "buyFood";
 public ProxyPerson2(Shopping shopping) {
 	this.shopping = shopping;
 }

 @Override
 public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
 	Object result = null;
 	if (methodName.equals(method.getName())) {
 		result = method.invoke(shopping, args);
 	}
 	return result;
 }
}
複製代碼

測試代碼，注意這裏調用和以前不一樣！這裏經過Proxy類中的newProxyInstance方法會動態生成一個代理類，而後進行調用。其中這三個參數的說明以下:

ClassLoader: 生成一個類, 這個類也須要加載到方法區中, 所以須要指定ClassLoader來加載該類
Class[] interfaces: 要實現的接口
InvocationHandler: 調用處理器

public class ProxyTest {
	public static void main(String[] args) {	
		Shopping shopping2 = (Shopping)Proxy.newProxyInstance(ClassLoader.getSystemClassLoader(), new Class[]{Shopping.class}, new ProxyPerson2(new ExecutePerson(name)));
		shopping2.buyFood();
    }
}
複製代碼

代理模式優勢：