设计模式学习

摘要：作用不改变原类的代码，而增强原类对象的功能可以选择前置，后置，环绕，异常处理增强与装饰者模式的区别意图的不同代理模式意在在代理中控制使用者对目标对象的访问

设计思想:
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与实现类对应的关系

工厂方法模式： 父类中定义工厂方法，各子类实现具体的实例创建

抽象工厂模式：定义一个工厂接口，所以具体工厂实现接口

装饰者模式
以装饰的方式，动态的将责任附加到对象上

代理模式
为其他对象提供一种代理以控制对这个对象的访问
在某些情况下，一个对象不适合或者不能直接引用另一个对象，而代理对象可以在客户端和目标对象之间起到中介的作用。
作用：不改变原类的代码，而增强原类对象的功能
可以选择前置，后置，环绕，异常处理增强
与装饰者模式的区别
意图的不同：代理模式意在在代理中控制使用者对目标对象的访问