设计模式学习

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

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

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

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

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

    原文作者:设计模式
    原文地址: https://segmentfault.com/a/1190000017151662
    本文转自网络文章,转载此文章仅为分享知识,如有侵权,请联系博主进行删除。
点赞