### 什么是設計模式
* 設計模式,是一套被反復使用、多數人知曉的、經過分類編目的、代碼設計經驗的總結。使用設計模式是為了可重用代碼、讓代碼更容易被他人理解、保證代碼可靠性、程序的重用性。
### 為什么要學習設計模式
* 看懂源代碼:如果你不懂設計模式去看Jdk、Spring、SpringMVC、IO等等等等的源碼,你會很迷茫,你會寸步難行
* 看看前輩的代碼:你去個公司難道都是新項目讓你接手?很有可能是接盤的,前輩的開發難道不用設計模式?
* 編寫自己的理想中的好代碼:我個人反正是這樣的,對于我自己開發的項目我會很認真,我對他比對我女朋友還好,把項目當成自己的兒子一樣
### 設計模式分類

* 創建型模式,共五種:**工廠方法模式、抽象工廠模式**、**單例模式**、建造者模式、**原型模式。**
* 結構型模式,共七種:適配器模式、裝飾器模式、代理模式、外觀模式、橋接模式、組合模式、享元模式。
* 行為型模式,共十一種:策略模式、模板方法模式、觀察者模式、迭代子模式、責任鏈模式、命令模式、備忘錄模式、狀態模式、訪問者模式、中介者模式、解釋器模式。
### 設計模式的六大原則

#### 開放封閉原則(Open Close Principle)
* 原則思想:盡量通過擴展軟件實體來解決需求變化,而不是通過修改已有的代碼來完成變化
* 描述:一個軟件產品在生命周期內,都會發生變化,既然變化是一個既定的事實,我們就應該在設計的時候盡量適應這些變化,以提高項目的穩定性和靈活性。
* 優點:單一原則告訴我們,每個類都有自己負責的職責,里氏替換原則不能破壞繼承關系的體系。
#### 里氏代換原則(Liskov Substitution Principle)
* 原則思想:使用的基類可以在任何地方使用繼承的子類,完美的替換基類。
* 大概意思是:子類可以擴展父類的功能,但不能改變父類原有的功能。子類可以實現父類的抽象方法,但不能覆蓋父類的非抽象方法,子類中可以增加自己特有的方法。
* 優點:增加程序的健壯性,即使增加了子類,原有的子類還可以繼續運行,互不影響。
#### 依賴倒轉原則(Dependence Inversion Principle)
* 依賴倒置原則的核心思想是面向接口編程.
* 依賴倒轉原則要求我們在程序代碼中傳遞參數時或在關聯關系中,盡量引用層次高的抽象層類,
* 這個是開放封閉原則的基礎,具體內容是:對接口編程,依賴于抽象而不依賴于具體。
#### 接口隔離原則(Interface Segregation Principle)
* 這個原則的意思是:使用多個隔離的接口,比使用單個接口要好。還是一個降低類之間的耦合度的意思,從這兒我們看出,其實設計模式就是一個軟件的設計思想,從大型軟件架構出發,為了升級和維護方便。所以上文中多次出現:降低依賴,降低耦合。
* 例如:支付類的接口和訂單類的接口,需要把這倆個類別的接口變成倆個隔離的接口
#### 迪米特法則(最少知道原則)(Demeter Principle)
* 原則思想:一個對象應當對其他對象有盡可能少地了解,簡稱類間解耦
* 大概意思就是一個類盡量減少自己對其他對象的依賴,原則是低耦合,高內聚,只有使各個模塊之間的耦合盡量的低,才能提高代碼的復用率。
* 優點:低耦合,高內聚。
#### 單一職責原則(Principle of single responsibility)
* 原則思想:一個方法只負責一件事情。
* 描述:單一職責原則很簡單,一個方法 一個類只負責一個職責,各個職責的程序改動,不影響其它程序。 這是常識,幾乎所有程序員都會遵循這個原則。
* 優點:降低類和類的耦合,提高可讀性,增加可維護性和可拓展性,降低可變性的風險。
## 單例模式
### 1.什么是單例
* 保證一個類只有一個實例,并且提供一個訪問該全局訪問點
### 2.那些地方用到了單例模式
1. 網站的計數器,一般也是采用單例模式實現,否則難以同步。
2. 應用程序的日志應用,一般都是單例模式實現,只有一個實例去操作才好,否則內容不好追加顯示。
3. 多線程的線程池的設計一般也是采用單例模式,因為線程池要方便對池中的線程進行控制
4. Windows的(任務管理器)就是很典型的單例模式,他不能打開倆個
5. windows的(回收站)也是典型的單例應用。在整個系統運行過程中,回收站只維護一個實例。
### 3.單例優缺點
**優點:**
1. 在單例模式中,活動的單例只有一個實例,對單例類的所有實例化得到的都是相同的一個實例。這樣就防止其它對象對自己的實例化,確保所有的對象都訪問一個實例
2. 單例模式具有一定的伸縮性,類自己來控制實例化進程,類就在改變實例化進程上有相應的伸縮性。
3. 提供了對唯一實例的受控訪問。
4. 由于在系統內存中只存在一個對象,因此可以節約系統資源,當需要頻繁創建和銷毀的對象時單例模式無疑可以提高系統的性能。
5. 允許可變數目的實例。
6. 避免對共享資源的多重占用。
**缺點:**
1. 不適用于變化的對象,如果同一類型的對象總是要在不同的用例場景發生變化,單例就會引起數據的錯誤,不能保存彼此的狀態。
2. 由于單利模式中沒有抽象層,因此單例類的擴展有很大的困難。
3. 單例類的職責過重,在一定程度上違背了“單一職責原則”。
4. 濫用單例將帶來一些負面問題,如為了節省資源將數據庫連接池對象設計為的單例類,可能會導致共享連接池對象的程序過多而出現連接池溢出;如果實例化的對象長時間不被利用,系統會認為是垃圾而被回收,這將導致對象狀態的丟失。
### 4.單例模式使用注意事項:
1. 使用時不能用反射模式創建單例,否則會實例化一個新的對象
2. 使用懶單例模式時注意線程安全問題
3. 餓單例模式和懶單例模式構造方法都是私有的,因而是不能被繼承的,有些單例模式可以被繼承(如登記式模式)
### 5.單例防止反射漏洞攻擊
~~~
private static boolean flag = false;
private Singleton() {
if (flag == false) {
flag = !flag;
} else {
throw new RuntimeException("單例模式被侵犯!");
}
}
public static void main(String[] args) {
}
復制代碼
~~~
### 6.如何選擇單例創建方式
* 如果不需要延遲加載單例,可以使用枚舉或者餓漢式,相對來說枚舉性好于餓漢式。 如果需要延遲加載,可以使用靜態內部類或者懶漢式,相對來說靜態內部類好于懶韓式。 最好使用餓漢式
### 7.單例創建方式
**(主要使用懶漢和懶漢式)**
1. 餓漢式:類初始化時,會立即加載該對象,線程天生安全,調用效率高。
2. 懶漢式: 類初始化時,不會初始化該對象,真正需要使用的時候才會創建該對象,具備懶加載功能。
3. 靜態內部方式:結合了懶漢式和餓漢式各自的優點,真正需要對象的時候才會加載,加載類是線程安全的。
4. 枚舉單例: 使用枚舉實現單例模式 優點:實現簡單、調用效率高,枚舉本身就是單例,由jvm從根本上提供保障!避免通過反射和反序列化的漏洞, 缺點沒有延遲加載。
5. 雙重檢測鎖方式 (因為JVM本質重排序的原因,可能會初始化多次,不推薦使用)
#### 1.餓漢式
1. 餓漢式:類初始化時,會立即加載該對象,線程天生安全,調用效率高。
~~~
package com.lijie;
//餓漢式
public class Demo1 {
// 類初始化時,會立即加載該對象,線程安全,調用效率高
private static Demo1 demo1 = new Demo1();
private Demo1() {
System.out.println("私有Demo1構造參數初始化");
}
public static Demo1 getInstance() {
return demo1;
}
public static void main(String[] args) {
Demo1 s1 = Demo1.getInstance();
Demo1 s2 = Demo1.getInstance();
System.out.println(s1 == s2);
}
}
復制代碼
~~~
#### 2.懶漢式
2. 懶漢式: 類初始化時,不會初始化該對象,真正需要使用的時候才會創建該對象,具備懶加載功能。
~~~
package com.lijie;
//懶漢式
public class Demo2 {
//類初始化時,不會初始化該對象,真正需要使用的時候才會創建該對象。
private static Demo2 demo2;
private Demo2() {
System.out.println("私有Demo2構造參數初始化");
}
public synchronized static Demo2 getInstance() {
if (demo2 == null) {
demo2 = new Demo2();
}
return demo2;
}
public static void main(String[] args) {
Demo2 s1 = Demo2.getInstance();
Demo2 s2 = Demo2.getInstance();
System.out.println(s1 == s2);
}
}
復制代碼
~~~
#### 3.靜態內部類
3. 靜態內部方式:結合了懶漢式和餓漢式各自的優點,真正需要對象的時候才會加載,加載類是線程安全的。
~~~
package com.lijie;
// 靜態內部類方式
public class Demo3 {
private Demo3() {
System.out.println("私有Demo3構造參數初始化");
}
public static class SingletonClassInstance {
private static final Demo3 DEMO_3 = new Demo3();
}
// 方法沒有同步
public static Demo3 getInstance() {
return SingletonClassInstance.DEMO_3;
}
public static void main(String[] args) {
Demo3 s1 = Demo3.getInstance();
Demo3 s2 = Demo3.getInstance();
System.out.println(s1 == s2);
}
}
復制代碼
~~~
#### 4.枚舉單例式
4. 枚舉單例: 使用枚舉實現單例模式 優點:實現簡單、調用效率高,枚舉本身就是單例,由jvm從根本上提供保障!避免通過反射和反序列化的漏洞, 缺點沒有延遲加載。
~~~
package com.lijie;
//使用枚舉實現單例模式 優點:實現簡單、枚舉本身就是單例,由jvm從根本上提供保障!避免通過反射和反序列化的漏洞 缺點沒有延遲加載
public class Demo4 {
public static Demo4 getInstance() {
return Demo.INSTANCE.getInstance();
}
public static void main(String[] args) {
Demo4 s1 = Demo4.getInstance();
Demo4 s2 = Demo4.getInstance();
System.out.println(s1 == s2);
}
//定義枚舉
private static enum Demo {
INSTANCE;
// 枚舉元素為單例
private Demo4 demo4;
private Demo() {
System.out.println("枚舉Demo私有構造參數");
demo4 = new Demo4();
}
public Demo4 getInstance() {
return demo4;
}
}
}
復制代碼
~~~
#### 5.雙重檢測鎖方式
5. 雙重檢測鎖方式 (因為JVM本質重排序的原因,可能會初始化多次,不推薦使用)
~~~
package com.lijie;
//雙重檢測鎖方式
public class Demo5 {
private static Demo5 demo5;
private Demo5() {
System.out.println("私有Demo4構造參數初始化");
}
public static Demo5 getInstance() {
if (demo5 == null) {
synchronized (Demo5.class) {
if (demo5 == null) {
demo5 = new Demo5();
}
}
}
return demo5;
}
public static void main(String[] args) {
Demo5 s1 = Demo5.getInstance();
Demo5 s2 = Demo5.getInstance();
System.out.println(s1 == s2);
}
}
復制代碼
~~~
## 工廠模式
### 1.什么是工廠模式
* 它提供了一種創建對象的最佳方式。在工廠模式中,我們在創建對象時不會對客戶端暴露創建邏輯,并且是通過使用一個共同的接口來指向新創建的對象。實現了創建者和調用者分離,工廠模式分為簡單工廠、工廠方法、抽象工廠模式
### 2.工廠模式好處
* 工廠模式是我們最常用的實例化對象模式了,是用工廠方法代替new操作的一種模式。
* 利用工廠模式可以降低程序的耦合性,為后期的維護修改提供了很大的便利。
* 將選擇實現類、創建對象統一管理和控制。從而將調用者跟我們的實現類解耦。
### 3.為什么要學習工廠設計模式
* 不知道你們面試題問到過源碼沒有,你知道Spring的源碼嗎,MyBatis的源碼嗎,等等等 如果你想學習很多框架的源碼,或者你想自己開發自己的框架,就必須先掌握設計模式(工廠設計模式用的是非常非常廣泛的)
### 4.Spring開發中的工廠設計模式
**1.Spring IOC**
* 看過Spring源碼就知道,在Spring IOC容器創建bean的過程是使用了工廠設計模式
* Spring中無論是通過xml配置還是通過配置類還是注解進行創建bean,大部分都是通過簡單工廠來進行創建的。
* 當容器拿到了beanName和class類型后,動態的通過反射創建具體的某個對象,最后將創建的對象放到Map中。
**2.為什么Spring IOC要使用工廠設計模式創建Bean呢**
* 在實際開發中,如果我們A對象調用B,B調用C,C調用D的話我們程序的耦合性就會變高。(耦合大致分為類與類之間的依賴,方法與方法之間的依賴。)
* 在很久以前的三層架構編程時,都是控制層調用業務層,業務層調用數據訪問層時,都是是直接new對象,耦合性大大提升,代碼重復量很高,對象滿天飛
* 為了避免這種情況,Spring使用工廠模式編程,寫一個工廠,由工廠創建Bean,以后我們如果要對象就直接管工廠要就可以,剩下的事情不歸我們管了。Spring IOC容器的工廠中有個靜態的Map集合,是為了讓工廠符合單例設計模式,即每個對象只生產一次,生產出對象后就存入到Map集合中,保證了實例不會重復影響程序效率。
### 5.工廠模式分類
* 工廠模式分為簡單工廠、工廠方法、抽象工廠模式
~~~
簡單工廠 :用來生產同一等級結構中的任意產品。(不支持拓展增加產品)
工廠方法 :用來生產同一等級結構中的固定產品。(支持拓展增加產品)
抽象工廠 :用來生產不同產品族的全部產品。(不支持拓展增加產品;支持增加產品族)
復制代碼
~~~
`我下面來使用代碼演示一下:`
#### 5.1 簡單工廠模式
**什么是簡單工廠模式**
* 簡單工廠模式相當于是一個工廠中有各種產品,創建在一個類中,客戶無需知道具體產品的名稱,只需要知道產品類所對應的參數即可。但是工廠的職責過重,而且當類型過多時不利于系統的擴展維護。
**代碼演示:**
1. 創建工廠
~~~
package com.lijie;
public interface Car {
public void run();
}
復制代碼
~~~
2. 創建工廠的產品(寶馬)
~~~
package com.lijie;
public class Bmw implements Car {
public void run() {
System.out.println("我是寶馬汽車...");
}
}
復制代碼
~~~
3. 創建工另外一種產品(奧迪)
~~~
package com.lijie;
public class AoDi implements Car {
public void run() {
System.out.println("我是奧迪汽車..");
}
}
復制代碼
~~~
4. 創建核心工廠類,由他決定具體調用哪產品
~~~
package com.lijie;
public class CarFactory {
public static Car createCar(String name) {
if ("".equals(name)) {
return null;
}
if(name.equals("奧迪")){
return new AoDi();
}
if(name.equals("寶馬")){
return new Bmw();
}
return null;
}
}
復制代碼
~~~
5. 演示創建工廠的具體實例
~~~
package com.lijie;
public class Client01 {
public static void main(String[] args) {
Car aodi =CarFactory.createCar("奧迪");
Car bmw =CarFactory.createCar("寶馬");
aodi.run();
bmw.run();
}
}
復制代碼
~~~
**單工廠的優點/缺點**
* 優點:簡單工廠模式能夠根據外界給定的信息,決定究竟應該創建哪個具體類的對象。明確區分了各自的職責和權力,有利于整個軟件體系結構的優化。
* 缺點:很明顯工廠類集中了所有實例的創建邏輯,容易違反GRASPR的高內聚的責任分配原則
#### 5.2 工廠方法模式
**什么是工廠方法模式**
* 工廠方法模式Factory Method,又稱多態性工廠模式。在工廠方法模式中,核心的工廠類不再負責所有的產品的創建,而是將具體創建的工作交給子類去做。該核心類成為一個抽象工廠角色,僅負責給出具體工廠子類必須實現的接口,而不接觸哪一個產品類應當被實例化這種細節
**代碼演示:**
1. 創建工廠
~~~
package com.lijie;
public interface Car {
public void run();
}
復制代碼
~~~
2. 創建工廠方法調用接口(所有的產品需要new出來必須繼承他來實現方法)
~~~
package com.lijie;
public interface CarFactory {
Car createCar();
}
復制代碼
~~~
3. 創建工廠的產品(奧迪)
~~~
package com.lijie;
public class AoDi implements Car {
public void run() {
System.out.println("我是奧迪汽車..");
}
}
復制代碼
~~~
4. 創建工廠另外一種產品(寶馬)
~~~
package com.lijie;
public class Bmw implements Car {
public void run() {
System.out.println("我是寶馬汽車...");
}
}
復制代碼
~~~
5. 創建工廠方法調用接口的實例(奧迪)
~~~
package com.lijie;
public class AoDiFactory implements CarFactory {
public Car createCar() {
return new AoDi();
}
}
復制代碼
~~~
6. 創建工廠方法調用接口的實例(寶馬)
~~~
package com.lijie;
public class BmwFactory implements CarFactory {
public Car createCar() {
return new Bmw();
}
}
復制代碼
~~~
7. 演示創建工廠的具體實例
~~~
package com.lijie;
public class Client {
public static void main(String[] args) {
Car aodi = new AoDiFactory().createCar();
Car jili = new BmwFactory().createCar();
aodi.run();
jili.run();
}
}
復制代碼
~~~
#### 5.3 抽象工廠模式
**什么是抽象工廠模式**
* 抽象工廠簡單地說是工廠的工廠,抽象工廠可以創建具體工廠,由具體工廠來產生具體產品。

**代碼演示:**
1. 創建第一個子工廠,及實現類
~~~
package com.lijie;
//汽車
public interface Car {
void run();
}
class CarA implements Car{
public void run() {
System.out.println("寶馬");
}
}
class CarB implements Car{
public void run() {
System.out.println("摩拜");
}
}
復制代碼
~~~
2. 創建第二個子工廠,及實現類
~~~
package com.lijie;
//發動機
public interface Engine {
void run();
}
class EngineA implements Engine {
public void run() {
System.out.println("轉的快!");
}
}
class EngineB implements Engine {
public void run() {
System.out.println("轉的慢!");
}
}
復制代碼
~~~
3. 創建一個總工廠,及實現類(由總工廠的實現類決定調用那個工廠的那個實例)
~~~
package com.lijie;
public interface TotalFactory {
// 創建汽車
Car createChair();
// 創建發動機
Engine createEngine();
}
//總工廠實現類,由他決定調用哪個工廠的那個實例
class TotalFactoryReally implements TotalFactory {
public Engine createEngine() {
return new EngineA();
}
public Car createChair() {
return new CarA();
}
}
復制代碼
~~~
4. 運行測試
~~~
package com.lijie;
public class Test {
public static void main(String[] args) {
TotalFactory totalFactory2 = new TotalFactoryReally();
Car car = totalFactory2.createChair();
car.run();
TotalFactory totalFactory = new TotalFactoryReally();
Engine engine = totalFactory.createEngine();
engine.run();
}
}
復制代碼
~~~
## 代理模式
### 1.什么是代理模式
* 通過代理控制對象的訪問,可以在這個對象調用方法之前、調用方法之后去處理/添加新的功能。(也就是AO的P微實現)
* 代理在原有代碼乃至原業務流程都不修改的情況下,直接在業務流程中切入新代碼,增加新功能,這也和Spring的(面向切面編程)很相似
### 2.代理模式應用場景
* Spring AOP、日志打印、異常處理、事務控制、權限控制等
### 3.代理的分類
* 靜態代理(靜態定義代理類)
* 動態代理(動態生成代理類,也稱為Jdk自帶動態代理)
* Cglib 、javaassist(字節碼操作庫)
### 4.三種代理的區別
1. 靜態代理:簡單代理模式,是動態代理的理論基礎。常見使用在代理模式
2. jdk動態代理:使用反射完成代理。需要有頂層接口才能使用,常見是mybatis的mapper文件是代理。
3. cglib動態代理:也是使用反射完成代理,可以直接代理類(jdk動態代理不行),使用字節碼技術,不能對 final類進行繼承。(需要導入jar包)
### 5.用代碼演示三種代理
#### 5.1.靜態代理
**什么是靜態代理**
* 由程序員創建或工具生成代理類的源碼,再編譯代理類。所謂靜態也就是在程序運行前就已經存在代理類的字節碼文件,代理類和委托類的關系在運行前就確定了。
**代碼演示:**
* 我有一段這樣的代碼:(如何能在不修改UserDao接口類的情況下開事務和關閉事務呢)
~~~
package com.lijie;
//接口類
public class UserDao{
public void save() {
System.out.println("保存數據方法");
}
}
復制代碼
~~~
~~~
package com.lijie;
//運行測試類
public class Test{
public static void main(String[] args) {
UserDao userDao = new UserDao();
userDao.save();
}
}
復制代碼
~~~
**修改代碼,添加代理類**
~~~
package com.lijie;
//代理類
public class UserDaoProxy extends UserDao {
private UserDao userDao;
public UserDaoProxy(UserDao userDao) {
this.userDao = userDao;
}
public void save() {
System.out.println("開啟事物...");
userDao.save();
System.out.println("關閉事物...");
}
}
復制代碼
~~~
~~~
//添加完靜態代理的測試類
public class Test{
public static void main(String[] args) {
UserDao userDao = new UserDao();
UserDaoProxy userDaoProxy = new UserDaoProxy(userDao);
userDaoProxy.save();
}
}
復制代碼
~~~
* 缺點:每個需要代理的對象都需要自己重復編寫代理,很不舒服,
* 優點:但是可以面相實際對象或者是接口的方式實現代理
#### 2.2.動態代理
**什么是動態代理**
* 動態代理也叫做,JDK代理、接口代理。
* 動態代理的對象,是利用JDK的API,動態的在內存中構建代理對象(是根據被代理的接口來動態生成代理類的class文件,并加載運行的過程),這就叫動態代理
~~~
package com.lijie;
//接口
public interface UserDao {
void save();
}
復制代碼
~~~
~~~
package com.lijie;
//接口實現類
public class UserDaoImpl implements UserDao {
public void save() {
System.out.println("保存數據方法");
}
}
復制代碼
~~~
* //下面是代理類,可重復使用,不像靜態代理那樣要自己重復編寫代理
~~~
package com.lijie;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
// 每次生成動態代理類對象時,實現了InvocationHandler接口的調用處理器對象
public class InvocationHandlerImpl implements InvocationHandler {
// 這其實業務實現類對象,用來調用具體的業務方法
private Object target;
// 通過構造函數傳入目標對象
public InvocationHandlerImpl(Object target) {
this.target = target;
}
//動態代理實際運行的代理方法
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("調用開始處理");
//下面invoke()方法是以反射的方式來創建對象,第一個參數是要創建的對象,第二個是構成方法的參數,由第二個參數來決定創建對象使用哪個構造方法
Object result = method.invoke(target, args);
System.out.println("調用結束處理");
return result;
}
}
復制代碼
~~~
* //利用動態代理使用代理方法
~~~
package com.lijie;
import java.lang.reflect.Proxy;
public class Test {
public static void main(String[] args) {
// 被代理對象
UserDao userDaoImpl = new UserDaoImpl();
InvocationHandlerImpl invocationHandlerImpl = new InvocationHandlerImpl(userDaoImpl);
//類加載器
ClassLoader loader = userDaoImpl.getClass().getClassLoader();
Class<?>[] interfaces = userDaoImpl.getClass().getInterfaces();
// 主要裝載器、一組接口及調用處理動態代理實例
UserDao newProxyInstance = (UserDao) Proxy.newProxyInstance(loader, interfaces, invocationHandlerImpl);
newProxyInstance.save();
}
}
復制代碼
~~~
* 缺點:必須是面向接口,目標業務類必須實現接口
* 優點:不用關心代理類,只需要在運行階段才指定代理哪一個對象
#### 5.3.CGLIB動態代理
**CGLIB動態代理原理:**
* 利用asm開源包,對代理對象類的class文件加載進來,通過修改其字節碼生成子類來處理。
**什么是CGLIB動態代理**
* CGLIB動態代理和jdk代理一樣,使用反射完成代理,不同的是他可以直接代理類(jdk動態代理不行,他必須目標業務類必須實現接口),CGLIB動態代理底層使用字節碼技術,CGLIB動態代理不能對 final類進行繼承。(CGLIB動態代理需要導入jar包)
**代碼演示:**
~~~
package com.lijie;
//接口
public interface UserDao {
void save();
}
復制代碼
~~~
~~~
package com.lijie;
//接口實現類
public class UserDaoImpl implements UserDao {
public void save() {
System.out.println("保存數據方法");
}
}
復制代碼
~~~
~~~
package com.lijie;
import org.springframework.cglib.proxy.Enhancer;
import org.springframework.cglib.proxy.MethodInterceptor;
import org.springframework.cglib.proxy.MethodProxy;
import java.lang.reflect.Method;
//代理主要類
public class CglibProxy implements MethodInterceptor {
private Object targetObject;
// 這里的目標類型為Object,則可以接受任意一種參數作為被代理類,實現了動態代理
public Object getInstance(Object target) {
// 設置需要創建子類的類
this.targetObject = target;
Enhancer enhancer = new Enhancer();
enhancer.setSuperclass(target.getClass());
enhancer.setCallback(this);
return enhancer.create();
}
//代理實際方法
public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
System.out.println("開啟事物");
Object result = proxy.invoke(targetObject, args);
System.out.println("關閉事物");
// 返回代理對象
return result;
}
}
復制代碼
~~~
~~~
package com.lijie;
//測試CGLIB動態代理
public class Test {
public static void main(String[] args) {
CglibProxy cglibProxy = new CglibProxy();
UserDao userDao = (UserDao) cglibProxy.getInstance(new UserDaoImpl());
userDao.save();
}
}
復制代碼
~~~
## 建造者模式
### 1.什么是建造者模式
* 建造者模式:是將一個復雜的對象的構建與它的表示分離,使得同樣的構建過程可以創建不同的方式進行創建。
* 工廠類模式是提供的是創建單個類的產品
* 而建造者模式則是將各種產品集中起來進行管理,用來具有不同的屬性的產品
**建造者模式通常包括下面幾個角色:**
1. uilder:給出一個抽象接口,以規范產品對象的各個組成成分的建造。這個接口規定要實現復雜對象的哪些部分的創建,并不涉及具體的對象部件的創建。
2. ConcreteBuilder:實現Builder接口,針對不同的商業邏輯,具體化復雜對象的各部分的創建。 在建造過程完成后,提供產品的實例。
3. Director:調用具體建造者來創建復雜對象的各個部分,在指導者中不涉及具體產品的信息,只負責保證對象各部分完整創建或按某種順序創建。
4. Product:要創建的復雜對象。
### 2.建造者模式的使用場景
**使用場景:**
1. 需要生成的對象具有復雜的內部結構。
2. 需要生成的對象內部屬性本身相互依賴。
* 與工廠模式的區別是:建造者模式更加關注與零件裝配的順序。
* JAVA 中的 StringBuilder就是建造者模式創建的,他把一個單個字符的char數組組合起來
* Spring不是建造者模式,它提供的操作應該是對于字符串本身的一些操作,而不是創建或改變一個字符串。
### 3.代碼案例
1. 建立一個裝備對象Arms
~~~
package com.lijie;
//裝備類
public class Arms {
//頭盔
private String helmet;
//鎧甲
private String armor;
//武器
private String weapon;
//省略Git和Set方法...........
}
復制代碼
~~~
2. 創建Builder接口(給出一個抽象接口,以規范產品對象的各個組成成分的建造,這個接口只是規范)
~~~
package com.lijie;
public interface PersonBuilder {
void builderHelmetMurder();
void builderArmorMurder();
void builderWeaponMurder();
void builderHelmetYanLong();
void builderArmorYanLong();
void builderWeaponYanLong();
Arms BuilderArms(); //組裝
}
復制代碼
~~~
3. 創建Builder實現類(這個類主要實現復雜對象創建的哪些部分需要什么屬性)
~~~
package com.lijie;
public class ArmsBuilder implements PersonBuilder {
private Arms arms;
//創建一個Arms實例,用于調用set方法
public ArmsBuilder() {
arms = new Arms();
}
public void builderHelmetMurder() {
arms.setHelmet("奪命頭盔");
}
public void builderArmorMurder() {
arms.setArmor("奪命鎧甲");
}
public void builderWeaponMurder() {
arms.setWeapon("奪命寶刀");
}
public void builderHelmetYanLong() {
arms.setHelmet("炎龍頭盔");
}
public void builderArmorYanLong() {
arms.setArmor("炎龍鎧甲");
}
public void builderWeaponYanLong() {
arms.setWeapon("炎龍寶刀");
}
public Arms BuilderArms() {
return arms;
}
}
復制代碼
~~~
4. Director(調用具體建造者來創建復雜對象的各個部分,在指導者中不涉及具體產品的信息,只負責保證對象各部分完整創建或按某種順序創建)
~~~
package com.lijie;
public class PersonDirector {
//組裝
public Arms constructPerson(PersonBuilder pb) {
pb.builderHelmetYanLong();
pb.builderArmorMurder();
pb.builderWeaponMurder();
return pb.BuilderArms();
}
//這里進行測試
public static void main(String[] args) {
PersonDirector pb = new PersonDirector();
Arms arms = pb.constructPerson(new ArmsBuilder());
System.out.println(arms.getHelmet());
System.out.println(arms.getArmor());
System.out.println(arms.getWeapon());
}
}
復制代碼
~~~
## 模板方法模式
### 1.什么是模板方法
* 模板方法模式:定義一個操作中的算法骨架(父類),而將一些步驟延遲到子類中。 模板方法使得子類可以不改變一個算法的結構來重定義該算法的
### 2.什么時候使用模板方法
* 實現一些操作時,整體步驟很固定,但是呢。就是其中一小部分需要改變,這時候可以使用模板方法模式,將容易變的部分抽象出來,供子類實現。
### 3.實際開發中應用場景哪里用到了模板方法
* 其實很多框架中都有用到了模板方法模式
* 例如:數據庫訪問的封裝、Junit單元測試、servlet中關于doGet/doPost方法的調用等等
### 4.現實生活中的模板方法
**例如:**
1. 去餐廳吃飯,餐廳給我們提供了一個模板就是:看菜單,點菜,吃飯,付款,走人 (這里 “**點菜和付款**” 是不確定的由子類來完成的,其他的則是一個模板。)
### 5.代碼實現模板方法模式
1. 先定義一個模板。把模板中的點菜和付款,讓子類來實現。
~~~
package com.lijie;
//模板方法
public abstract class RestaurantTemplate {
// 1.看菜單
public void menu() {
System.out.println("看菜單");
}
// 2.點菜業務
abstract void spotMenu();
// 3.吃飯業務
public void havingDinner(){ System.out.println("吃飯"); }
// 3.付款業務
abstract void payment();
// 3.走人
public void GoR() { System.out.println("走人"); }
//模板通用結構
public void process(){
menu();
spotMenu();
havingDinner();
payment();
GoR();
}
}
復制代碼
~~~
2. 具體的模板方法子類 1
~~~
package com.lijie;
public class RestaurantGinsengImpl extends RestaurantTemplate {
void spotMenu() {
System.out.println("人參");
}
void payment() {
System.out.println("5快");
}
}
復制代碼
~~~
3. 具體的模板方法子類 2
~~~
package com.lijie;
public class RestaurantLobsterImpl extends RestaurantTemplate {
void spotMenu() {
System.out.println("龍蝦");
}
void payment() {
System.out.println("50塊");
}
}
復制代碼
~~~
4. 客戶端測試
~~~
package com.lijie;
public class Client {
public static void main(String[] args) {
//調用第一個模板實例
RestaurantTemplate restaurantTemplate = new RestaurantGinsengImpl();
restaurantTemplate.process();
}
}
復制代碼
~~~
## 外觀模式
### 1.什么是外觀模式
* 外觀模式:也叫門面模式,隱藏系統的復雜性,并向客戶端提供了一個客戶端可以訪問系統的接口。
* 它向現有的系統添加一個接口,用這一個接口來隱藏實際的系統的復雜性。
* 使用外觀模式,他外部看起來就是一個接口,其實他的內部有很多復雜的接口已經被實現
### 2.外觀模式例子
* 用戶注冊完之后,需要調用阿里短信接口、郵件接口、微信推送接口。
1. 創建阿里短信接口
~~~
package com.lijie;
//阿里短信消息
public interface AliSmsService {
void sendSms();
}
復制代碼
~~~
~~~
package com.lijie;
public class AliSmsServiceImpl implements AliSmsService {
public void sendSms() {
System.out.println("阿里短信消息");
}
}
復制代碼
~~~
2. 創建郵件接口
~~~
package com.lijie;
//發送郵件消息
public interface EamilSmsService {
void sendSms();
}
復制代碼
~~~
~~~
package com.lijie;
public class EamilSmsServiceImpl implements EamilSmsService{
public void sendSms() {
System.out.println("發送郵件消息");
}
}
復制代碼
~~~
3. 創建微信推送接口
~~~
package com.lijie;
//微信消息推送
public interface WeiXinSmsService {
void sendSms();
}
復制代碼
~~~
~~~
package com.lijie;
public class WeiXinSmsServiceImpl implements WeiXinSmsService {
public void sendSms() {
System.out.println("發送微信消息推送");
}
}
復制代碼
~~~
4. 創建門面(門面看起來很簡單使用,復雜的東西以及被門面給封裝好了)
~~~
package com.lijie;
public class Computer {
AliSmsService aliSmsService;
EamilSmsService eamilSmsService;
WeiXinSmsService weiXinSmsService;
public Computer() {
aliSmsService = new AliSmsServiceImpl();
eamilSmsService = new EamilSmsServiceImpl();
weiXinSmsService = new WeiXinSmsServiceImpl();
}
//只需要調用它
public void sendMsg() {
aliSmsService.sendSms();
eamilSmsService.sendSms();
weiXinSmsService.sendSms();
}
}
復制代碼
~~~
5. 啟動測試
~~~
package com.lijie;
public class Client {
public static void main(String[] args) {
//普通模式需要這樣
AliSmsService aliSmsService = new AliSmsServiceImpl();
EamilSmsService eamilSmsService = new EamilSmsServiceImpl();
WeiXinSmsService weiXinSmsService = new WeiXinSmsServiceImpl();
aliSmsService.sendSms();
eamilSmsService.sendSms();
weiXinSmsService.sendSms();
//利用外觀模式簡化方法
new Computer().sendMsg();
}
}
復制代碼
~~~
## 原型模式
### 1.什么是原型模式
* 原型設計模式簡單來說就是克隆
* 原型表明了有一個樣板實例,這個原型是可定制的。原型模式多用于創建復雜的或者構造耗時的實例,因為這種情況下,復制一個已經存在的實例可使程序運行更高效。
### 2.原型模式的應用場景
1. 類初始化需要消化非常多的資源,這個資源包括數據、硬件資源等。這時我們就可以通過原型拷貝避免這些消耗。
2. 通過new產生的一個對象需要非常繁瑣的數據準備或者權限,這時可以使用原型模式。
3. 一個對象需要提供給其他對象訪問,而且各個調用者可能都需要修改其值時,可以考慮使用原型模式拷貝多個對象供調用者使用,即保護性拷貝。
`我們Spring框架中的多例就是使用原型。`
### 3.原型模式的使用方式
1. 實現Cloneable接口。在java語言有一個Cloneable接口,它的作用只有一個,就是在運行時通知虛擬機可以安全地在實現了此接口的類上使用clone方法。在java虛擬機中,只有實現了這個接口的類才可以被拷貝,否則在運行時會拋出CloneNotSupportedException異常。
2. 重寫Object類中的clone方法。Java中,所有類的父類都是Object類,Object類中有一個clone方法,作用是返回對象的一個拷貝,但是其作用域protected類型的,一般的類無法調用,因此Prototype類需要將clone方法的作用域修改為public類型。
#### 3.1原型模式分為淺復制和深復制
1. (淺復制)只是拷貝了基本類型的數據,而引用類型數據,只是拷貝了一份引用地址。
2. (深復制)在計算機中開辟了一塊新的內存地址用于存放復制的對象。
### 4.代碼演示
1. 創建User類
~~~
package com.lijie;
import java.util.ArrayList;
public class User implements Cloneable {
private String name;
private String password;
private ArrayList<String> phones;
protected User clone() {
try {
User user = (User) super.clone();
//重點,如果要連帶引用類型一起復制,需要添加底下一條代碼,如果不加就對于是復制了引用地址
user.phones = (ArrayList<String>) this.phones.clone();//設置深復制
return user;
} catch (CloneNotSupportedException e) {
e.printStackTrace();
}
return null;
}
//省略所有屬性Git Set方法......
}
復制代碼
~~~
2. 測試復制
~~~
package com.lijie;
import java.util.ArrayList;
public class Client {
public static void main(String[] args) {
//創建User原型對象
User user = new User();
user.setName("李三");
user.setPassword("123456");
ArrayList<String> phones = new ArrayList<>();
phones.add("17674553302");
user.setPhones(phones);
//copy一個user對象,并且對象的屬性
User user2 = user.clone();
user2.setPassword("654321");
//查看倆個對象是否是一個
System.out.println(user == user2);
//查看屬性內容
System.out.println(user.getName() + " | " + user2.getName());
System.out.println(user.getPassword() + " | " + user2.getPassword());
//查看對于引用類型拷貝
System.out.println(user.getPhones() == user2.getPhones());
}
}
復制代碼
~~~
3. 如果不需要深復制,需要刪除User 中的
~~~
//默認引用類型為淺復制,這是設置了深復制
user.phones = (ArrayList<String>) this.phones.clone();
復制代碼
~~~
## 策略模式
### 1.什么是策略模式
* 定義了一系列的算法 或 邏輯 或 相同意義的操作,并將每一個算法、邏輯、操作封裝起來,而且使它們還可以相互替換。(其實策略模式Java中用的非常非常廣泛)
* 我覺得主要是為了 簡化 if...else 所帶來的復雜和難以維護。
### 2.策略模式應用場景
* 策略模式的用意是針對一組算法或邏輯,將每一個算法或邏輯封裝到具有共同接口的獨立的類中,從而使得它們之間可以相互替換。
1. 例如:我要做一個不同會員打折力度不同的三種策略,初級會員,中級會員,高級會員(三種不同的計算)。
2. 例如:我要一個支付模塊,我要有微信支付、支付寶支付、銀聯支付等
### 3.策略模式的優點和缺點
* 優點: 1、算法可以自由切換。 2、避免使用多重條件判斷。 3、擴展性非常良好。
* 缺點: 1、策略類會增多。 2、所有策略類都需要對外暴露。
### 4.代碼演示
* 模擬支付模塊有微信支付、支付寶支付、銀聯支付
1. 定義抽象的公共方法
~~~
package com.lijie;
//策略模式 定義抽象方法 所有支持公共接口
abstract class PayStrategy {
// 支付邏輯方法
abstract void algorithmInterface();
}
復制代碼
~~~
2. 定義實現微信支付
~~~
package com.lijie;
class PayStrategyA extends PayStrategy {
void algorithmInterface() {
System.out.println("微信支付");
}
}
復制代碼
~~~
3. 定義實現支付寶支付
~~~
package com.lijie;
class PayStrategyB extends PayStrategy {
void algorithmInterface() {
System.out.println("支付寶支付");
}
}
復制代碼
~~~
4. 定義實現銀聯支付
~~~
package com.lijie;
class PayStrategyC extends PayStrategy {
void algorithmInterface() {
System.out.println("銀聯支付");
}
}
復制代碼
~~~
5. 定義下文維護算法策略
~~~
package com.lijie;// 使用上下文維護算法策略
class Context {
PayStrategy strategy;
public Context(PayStrategy strategy) {
this.strategy = strategy;
}
public void algorithmInterface() {
strategy.algorithmInterface();
}
}
復制代碼
~~~
6. 運行測試
~~~
package com.lijie;
class ClientTestStrategy {
public static void main(String[] args) {
Context context;
//使用支付邏輯A
context = new Context(new PayStrategyA());
context.algorithmInterface();
//使用支付邏輯B
context = new Context(new PayStrategyB());
context.algorithmInterface();
//使用支付邏輯C
context = new Context(new PayStrategyC());
context.algorithmInterface();
}
}
復制代碼
~~~
## 觀察者模式
### 1.什么是觀察者模式
* 先講什么是行為性模型,行為型模式關注的是系統中對象之間的相互交互,解決系統在運行時對象之間的相互通信和協作,進一步明確對象的職責。
* 觀察者模式,是一種行為性模型,又叫發布-訂閱模式,他定義對象之間一種一對多的依賴關系,使得當一個對象改變狀態,則所有依賴于它的對象都會得到通知并自動更新。
### 2.模式的職責
* 觀察者模式主要用于1對N的通知。當一個對象的狀態變化時,他需要及時告知一系列對象,令他們做出相應。
**實現有兩種方式:**
1. 推:每次都會把通知以廣播的方式發送給所有觀察者,所有的觀察者只能被動接收。
2. 拉:觀察者只要知道有情況即可,至于什么時候獲取內容,獲取什么內容,都可以自主決定。
### 3.觀察者模式應用場景
1. 關聯行為場景,需要注意的是,關聯行為是可拆分的,而不是“組合”關系。事件多級觸發場景。
2. 跨系統的消息交換場景,如消息隊列、事件總線的處理機制。
### 4.代碼實現觀察者模式
1. 定義抽象觀察者,每一個實現該接口的實現類都是具體觀察者。
~~~
package com.lijie;
//觀察者的接口,用來存放觀察者共有方法
public interface Observer {
// 觀察者方法
void update(int state);
}
復制代碼
~~~
2. 定義具體觀察者
~~~
package com.lijie;
// 具體觀察者
public class ObserverImpl implements Observer {
// 具體觀察者的屬性
private int myState;
public void update(int state) {
myState=state;
System.out.println("收到消息,myState值改為:"+state);
}
public int getMyState() {
return myState;
}
}
復制代碼
~~~
3. 定義主題。主題定義觀察者數組,并實現增、刪及通知操作。
~~~
package com.lijie;
import java.util.Vector;
//定義主題,以及定義觀察者數組,并實現增、刪及通知操作。
public class Subjecct {
//觀察者的存儲集合,不推薦ArrayList,線程不安全,
private Vector<Observer> list = new Vector<>();
// 注冊觀察者方法
public void registerObserver(Observer obs) {
list.add(obs);
}
// 刪除觀察者方法
public void removeObserver(Observer obs) {
list.remove(obs);
}
// 通知所有的觀察者更新
public void notifyAllObserver(int state) {
for (Observer observer : list) {
observer.update(state);
}
}
}
復制代碼
~~~
4. 定義具體的,他繼承繼承Subject類,在這里實現具體業務,在具體項目中,該類會有很多。
~~~
package com.lijie;
//具體主題
public class RealObserver extends Subjecct {
//被觀察對象的屬性
private int state;
public int getState(){
return state;
}
public void setState(int state){
this.state=state;
//主題對象(目標對象)值發生改變
this.notifyAllObserver(state);
}
}
復制代碼
~~~
5. 運行測試
~~~
package com.lijie;
public class Client {
public static void main(String[] args) {
// 目標對象
RealObserver subject = new RealObserver();
// 創建多個觀察者
ObserverImpl obs1 = new ObserverImpl();
ObserverImpl obs2 = new ObserverImpl();
ObserverImpl obs3 = new ObserverImpl();
// 注冊到觀察隊列中
subject.registerObserver(obs1);
subject.registerObserver(obs2);
subject.registerObserver(obs3);
// 改變State狀態
subject.setState(300);
System.out.println("obs1觀察者的MyState狀態值為:"+obs1.getMyState());
System.out.println("obs2觀察者的MyState狀態值為:"+obs2.getMyState());
System.out.println("obs3觀察者的MyState狀態值為:"+obs3.getMyState());
// 改變State狀態
subject.setState(400);
System.out.println("obs1觀察者的MyState狀態值為:"+obs1.getMyState());
System.out.println("obs2觀察者的MyState狀態值為:"+obs2.getMyState());
System.out.println("obs3觀察者的MyState狀態值為:"+obs3.getMyState());
}
}
復制代碼
~~~
## 文章就到這了,沒錯,沒了
察者方法 public void removeObserver(Observer obs) { list.remove(obs); }
~~~
// 通知所有的觀察者更新
public void notifyAllObserver(int state) {
for (Observer observer : list) {
observer.update(state);
}
}
復制代碼
~~~
}
~~~
4. 定義具體的,他繼承繼承Subject類,在這里實現具體業務,在具體項目中,該類會有很多。
```java
package com.lijie;
//具體主題
public class RealObserver extends Subjecct {
//被觀察對象的屬性
private int state;
public int getState(){
return state;
}
public void setState(int state){
this.state=state;
//主題對象(目標對象)值發生改變
this.notifyAllObserver(state);
}
}
復制代碼
~~~
5. 運行測試
~~~
package com.lijie;
public class Client {
public static void main(String[] args) {
// 目標對象
RealObserver subject = new RealObserver();
// 創建多個觀察者
ObserverImpl obs1 = new ObserverImpl();
ObserverImpl obs2 = new ObserverImpl();
ObserverImpl obs3 = new ObserverImpl();
// 注冊到觀察隊列中
subject.registerObserver(obs1);
subject.registerObserver(obs2);
subject.registerObserver(obs3);
// 改變State狀態
subject.setState(300);
System.out.println("obs1觀察者的MyState狀態值為:"+obs1.getMyState());
System.out.println("obs2觀察者的MyState狀態值為:"+obs2.getMyState());
System.out.println("obs3觀察者的MyState狀態值為:"+obs3.getMyState());
// 改變State狀態
subject.setState(400);
System.out.println("obs1觀察者的MyState狀態值為:"+obs1.getMyState());
System.out.println("obs2觀察者的MyState狀態值為:"+obs2.getMyState());
System.out.println("obs3觀察者的MyState狀態值為:"+obs3.getMyState());
}
}
復制代碼
~~~
## 文章就到這了,沒錯,沒了
如果不是必要,準備上面那九個設計模式就好了,全部記住有點難
- 常見面試題
- 一.Java常見面試題
- 1.Java基礎
- 3.面向對象概念
- 10.Java面試題
- Java基礎知識面試題(總結最全面的面試題)
- 設計模式面試題(總結最全面的面試題)
- Java集合面試題(總結最全面的面試題)
- JavaIO、BIO、NIO、AIO、Netty面試題(總結最全面的面試題)
- Java并發編程面試題(總結最全面的面試題)
- Java異常面試題(總結最全面的面試題)
- Java虛擬機(JVM)面試題(總結最全面的面試題)
- Spring面試題(總結最全面的面試題)
- Spring MVC面試題(總結最全面的面試題)
- Spring Boot面試題(總結最全面的面試題)
- Spring Cloud面試題(總結最全面的面試題)
- Redis面試題(總結最全面的面試題)
- MyBatis面試題(總結最全面的面試題)
- TCP、UDP、Socket、HTTP面試題(總結最全面的面試題)
- 二、MySQL面試題
- 1.基礎部分
- MySQL面試題(總結最全面的面試題)
- HBase相關面試題整理
- Nginx面試題(總結最全面的面試題)
- RabbitMQ面試題(總結最全面的面試題)
- Dubbo面試題(總結最全面的面試題)
- ZooKeeper面試題(總結最全面的面試題)
- Tomcat面試題(總結最全面的面試題)
- Linux面試題(總結最全面的面試題)
- 超詳細的Django面試題
- SSM面試題
- 15個高頻微信小程序面試題
- VUE面試題
- Python面試題
- 二、常見問題解答列表
- 1.查看端口及殺死進程
- 三、學習電子書