摘要：作用不改變原類的代碼，而增強原類對象的功能可以選擇前置，后置，環繞，異常處理增強與裝飾者模式的區別意圖的不同代理模式意在在代理中控制使用者對目標對象的訪問

設計思想:
OOP 類是做什么用的？
封裝數據和代碼
接口是做什么用的？
定義相接的口子，定義功能使用者和提供者之間的接口
為什么要有接口？
隔離變化的
抽象類是做什么的？
包含變與不變的
OOP 三大特性：封裝 繼承 多態

多態
類與類的關系
繼承 和 組合類1持有類2的實例

OO的設計原則
找出變化，分開變化和不變的
隔離，封裝變化的部分，讓其他部分不受它的影響
面向接口編程 隔離變化的方式
使用者使用接口，提供者實現接口。接口可以是超類
依賴倒置原則
依賴抽象，不要依賴具體類
對修改閉合，對擴展開放 隔離變化的方式
多用組合，少用繼承 靈活變化的方式
有一個 可能比是一個 更好
單一職責原則 方法設計的原則

設計模式
目的
易擴展，易維護
少改代碼，不改代碼

策略模式
促銷活動 實現訂單金額的計算
一般模式
@RestController
@RequestMapping("/order")
public class OrderController{

@Autowired
private OrderService orderService;

//計算訂單金額
@RequestMapping("/prepare")
public Order prepareOrder() {

    .....//業務代碼
    return this.orderService.prepareOrder(order,promotion);
}

}

@Service
public class OrderService {

public Order prepareOrder(Order order,String promotion) {
    //如何寫
    return order;
} 

}
//一般都這樣寫 代碼太多 不好維護
@Service
public class OrderService {

public Order prepareOrder(Order order,String promotion) {
    switch(promotion) {
    case "promotion-1":
            //促銷一的算法
        ...
        break;
    case "promotion-2":
            //促銷一的算法
        ...
        break;
    case "promotion-3":
            //促銷一的算法
        ...
        break;
    ......    
    }
    return order;
} 

}

//改進一下 封裝一下 單一職責
@Service
public class OrderService {

public Order prepareOrder(Order order,String promotion) {
    switch(promotion) {
    case "promotion-1":
            //促銷一的算法
        ...
        return calPromotion1(order);
    case "promotion-2":
            //促銷一的算法
        ...
        return calPromotion2(order);
    case "promotion-3":
            //促銷一的算法
        ...
        return calPromotion3(order);
    ......    
    }
    return order;
} 

private Order calPromotion(Order order) {
    System.out.println("促銷一的計算");
    return order;
}

}

//再次改進 同一行為的不同算法實現 ,我們可以定義接口,不同的算法分別去實現接口
設計原則 對修改關閉 對擴展開放
策略模式 定義一系列的算法,并將每一個算法封裝起來,而且使他們可以相互替換,讓算法獨立于使用他的用戶而獨立變化
interface PromotionCalculation{

public static Order culation(order);
}
public class Promotion1Calculation implements  PromotionCalculation {
    public static Order culation(order) {
        //算法
        return order；
    }
}
public class Promotion2Calculation implements  PromotionCalculation {
    public static Order culation(order) {
        //算法
        return order；
    }

}
//再次改進
@Service
public class OrderService {

public Order prepareOrder(Order order,String promotion) {
    switch(promotion) {
    case "promotion-1":
            //促銷一的算法
        ...
       return new Promotion1Calculation().culation(order);
    case "promotion-2":
            //促銷一的算法
        ...
        return new Promotion2Calculation().culation(order);
    case "promotion-3":
            //促銷一的算法
        ...
        return new Promotion3Calculation().culation(order);
    ......    
    }
    return order;
} 

}

工廠模式
簡單工廠 ： 一個工廠負責創建所有的實例
通過一個工廠來專門負責創建各種促銷計算，把變化移出來
@Component
public class PromotionCalculationFactory {

public PromotionCalculation getPromotionCalculation(String promotion) {
    switch(promotion) {
    case "promotion-1":
            //促銷一的算法
        ...
       return new Promotion1Calculation();
    case "promotion-2":
            //促銷一的算法
        ...
        return new Promotion2Calculation();
    case "promotion-3":
            //促銷一的算法
        ...
        return new Promotion3Calculation();
    ......   
    }
}

}
//現在的service
@Service
public class OrderService {

public Order prepareOrder(Order order,String promotion) {
@Autowired
private PromotionCalculationFactory promotionCalculationFactory;
    
public Order  prepareOrder(Order order,String promotion) {
    return promotionCalculationFactory.getPromotionCalculation(promotion).calculation(order);
    }
} 

}
//想要工廠的代碼也不要變
方式一 promotion = beanName; //getBean(); 在xml中配置
方式二 配置promotion與實現類對應的關系

工廠方法模式： 父類中定義工廠方法，各子類實現具體的實例創建

抽象工廠模式：定義一個工廠接口，所以具體工廠實現接口

裝飾者模式
以裝飾的方式，動態的將責任附加到對象上

代理模式
為其他對象提供一種代理以控制對這個對象的訪問
在某些情況下，一個對象不適合或者不能直接引用另一個對象，而代理對象可以在客戶端和目標對象之間起到中介的作用。
作用：不改變原類的代碼，而增強原類對象的功能
可以選擇前置，后置，環繞，異常處理增強
與裝飾者模式的區別
意圖的不同：代理模式意在在代理中控制使用者對目標對象的訪問