代码重构之设计模式

1、什么是重构？

重构大致可以理解为，在保持功能不变的前提下，利用设计思想、原则、模式、编程规范等理论来优化代码，修改设计上的不足，提高代码质量。

2、为什么要重构？

首先随着项目的不断演进，代码在堆砌，不免会产生一些过时的、冗余代码等。就需要重新整理，重新设计，使代码恢复设计模式和设计原则的限制。当然这里对于设计而言，重构是避免过度设计的有效手段。同时对于个人而言，重构也很锻炼程序员的功底，这是对设计模式，设计原则的实际应用，能快速提升程序员的水平。

3、介绍本次讲解重构中用到的4种设计模式：

1 工厂方法

追 MM 少不了请吃饭了，麦当劳的鸡翅和肯德基的鸡翅都是 MM 爱吃的东西，虽然口味有所不同，但不管你带 MM 去麦当劳或肯德基，只管向服务员说「来四个鸡翅」就行了。麦当劳和肯德基就是生产鸡翅的 Factory 工厂模式：客户类和工厂类分开。

消费者任何时候需要某种产品，只需向工厂请求即可。消费者无须修改就可以接纳新产品。缺点是当产品修改时，工厂类也要做相应的修改。如：如何创建及如何向客户端提供。

2 策略模式

跟不同类型的 MM 约会，要用不同的策略，有的请电影比较好，有的则去吃小吃效果不错，有的去海边浪漫最合适，其实都是为了得到 MM 的芳心，追 MM 锦囊中有好多 Strategy 哦。策略模式：策略模式针对一组算法，将每一个算法封装到具有共同接口的独立的类中，从而使得它们可以相互替换。

策略模式使得算法可以在不影响到客户端的情况下发生变化。策略模把行为和环境分开。环境类负责维持和查询行为类，各种算法在具体的策略类中提供。由于算法和环境独立开来，算法的增减，修改都不会影响到环境和客户端。

3 模板方法模式

比如说追女孩子步骤分为巧遇、打破僵局、展开追求、约会等步骤 (Template method)，但每个步骤针对不同的情况，都有不一样的做法，这就要看你随机应变啦 (具体实现)；

模板方法模式：模板方法模式准备一个抽象类，将部分逻辑以具体方法以及具体构造子类的形式实现，然后声明一些抽象方法来迫使子类实现剩余的逻辑。不同的子类可以以不同的方式实现这些抽象方法，从而对剩余的逻辑有不同的实现。先制定一个顶级逻辑框架，而将逻辑的细节留给具体的子类去实现。

4 责任链模式

晚上去上英语课，为了好开溜坐到了最后一排，哇，前面坐了好几个漂亮的 MM 哎，找张纸条，写上 “Hi, 可以做我的女朋友吗？如果不愿意请向前传”，纸条就一个接一个的传上去了，糟糕，传到第一排的 MM 把纸条传给老师了，听说是个老处女呀，快跑！

责任链模式：在责任链模式中，很多对象由每一个对象对其下家的引用而接起来形成一条链。请求在这个链上传递，直到链上的某一个对象决定处理此请求。客户并不知道链上的哪一个对象最终处理这个请求，系统可以在不影响客户端的情况下动态的重新组织链和分配责任。处理者有两个选择：承担责任或者把责任推给下家。一个请求可以最终不被任何接收端对象所接受。

在我们的项目中if ... else往往是用的最多的，而且到处都能看到大量的if ... else。那么if ... else 如果太多就会存在以下缺点：

a、代码逻辑复杂，维护性差，极容易引发 bug。

b、耦合性强，不利于拓展。

c、容易引起误解和理解困难。

d、业务复杂还会导致代码臃肿。

4、常用的场景案例讲解：

public interface PayService {
    void toPay(String code);
}
@Service
public class AliPay implements IPay {
    @Override
    public void pay() {
        // 处理支付宝支付逻辑
        System.out.println("===支付宝支付===");
    }
}
@Service
public class UnionPay implements IPay {
    @Override
    public void pay() {
        // 银联支付逻辑
        System.out.println("===银联支付===");
    }
}
@Service
public class WechatPay implements IPay {
    @Override
    public void pay() {
        // 微信支付逻辑
        System.out.println("===微信支付===");
    }
}
@Service
public class PayServiceImpl implements PayService {
    @Autowired
    private AliPay aliPay;
    @Autowired
    private UnionPay unionPay;
    @Autowired
    private WechatPay wechatPay;
    @Override
    public void toPay(String code) {
        // 支付宝支付
        if (PayCodeEnum.ALI_PAY.getCode().equals(code)) {
            aliPay.pay();
            // 银联支付
        } else if (PayCodeEnum.UNION_PAY.getCode().equals(code)) {
            unionPay.pay();
            // 微信支付
        } else if (PayCodeEnum.WECHAT_PAY.getCode().equals(code)) {
            wechatPay.pay();
        } else {
            System.out.println("找不到支付方式");
        }
    }
}

思考下，这段代码应该如何去优化？？？这段代码存在哪些问题？？？

存在问题：

试想一下，如果支付方式越来越多，比如：后续项目需要增加京东支付、百度支付、美团支付等等，就需要修改toPay方法的代码，增加更多的else...if判断，业务越来越多，判断多了就会导致逻辑越来越多。

同时也违反了设计模式六大原则的：“开闭原则” 和“单一职责原则”

开闭原则：对扩展开放，对修改关闭。就是说增加新功能要尽量少改动已有代码。

单一职责原则：逻辑尽量单一，不要太复杂，便于复用。

有哪些优化方案????

5、优化方案：

优化方案一：注解

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public @interface PayCode {
    String value();
    String name();
}
@PayCode(value = "ALI_PAY",name = "支付宝支付")
@Service
public class AliPay implements IPay {
    @Override
    public void pay() {
        // 处理支付宝支付逻辑
        System.out.println("===支付宝支付===");
    }
}
@PayCode(value = "UNION_PAY", name = "银联支付")
@Service
public class UnionPay implements IPay {
    @Override
    public void pay() {
        // 银联支付逻辑
        System.out.println("===银联支付===");
    }
}
@PayCode(value = "WECHAT_PAY", name = "微信支付")
@Service
public class WechatPay implements IPay {
    @Override
    public void pay() {
        // 微信支付逻辑
        System.out.println("===微信支付===");
    }
}
@Service
public class PayServiceAnnotationImpl implements PayService, ApplicationListener<ContextRefreshedEvent> {
    private static Map<String, IPay> payMap = null;
    @Override
    public void onApplicationEvent(ContextRefreshedEvent contextRefreshedEvent) {
        ApplicationContext applicationContext = contextRefreshedEvent.getApplicationContext();
        Map<String, Object> beansWithAnnotation = applicationContext.getBeansWithAnnotation(PayCode.class);
        if (null != beansWithAnnotation) {
            payMap = new HashMap<>();
            beansWithAnnotation.forEach((key, value) -> {
                String bizType = value.getClass().getAnnotation(PayCode.class).value();
                payMap.put(bizType, (IPay) value);
            });
        }
    }
    @Override
    public void toPay(String code) {
        payMap.get(code).pay();
    }
}

优化方案二：模板方法

public interface IPay {
    void pay();
    Boolean support(String code);
}
@Service
public class AliPay implements IPay {
    @Override
    public void pay() {
        // 处理支付宝支付逻辑
        System.out.println("===支付宝支付===");
    }
    @Override
    public Boolean support(String code) {
        return PayCodeEnum.ALI_PAY.getCode().equals(code);
    }
}
@Service
public class UnionPay implements IPay {
    @Override
    public void pay() {
        // 银联支付逻辑
        System.out.println("===银联支付===");
    }
    @Override
    public Boolean support(String code) {
        return PayCodeEnum.UNION_PAY.getCode().equals(code);
    }
}
@Service
public class WechatPay implements IPay {
    @Override
    public void pay() {
        // 微信支付逻辑
        System.out.println("===微信支付===");
    }
    @Override
    public Boolean support(String code) {
        return PayCodeEnum.WECHAT_PAY.getCode().equals(code);
    }
}
@Service
public class PayServiceTemplateMethodImpl implements PayService, ApplicationContextAware, InitializingBean {
    private ApplicationContext applicationContext;
    private List payList = null;
    @Override
    public void afterPropertiesSet() throws Exception {
        if (null != payList) {
            payList = new ArrayList<>();
            Map beansOfType = applicationContext.getBeansOfType(IPay.class);
            beansOfType.forEach((key, value) -> payList.add(value));
        }
    }
    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
            this.applicationContext = applicationContext;
    }
    @Override
    public void toPay(String code) {
        for (IPay iPay : payList) {
            if (iPay.support(code)) {
                iPay.pay();
            }
        }
    }
}

优化方案三：工厂+策略模式

最优方案

/**
* 支付策略工厂类
*/
public class PayStrategyFactory {
    private static Map payMap = new HashMap<>();
    public static void register(String code, IPay iPay) {
        if (StringUtils.isNotEmpty(code)) {
            payMap.put(code, iPay);
        }
    }
    public static IPay get(String code) {
        return payMap.get(code);
    }
}
@Service
public class AliPay implements IPay {
    @PostConstruct
    public void init(){
        PayStrategyFactory.register(PayCodeEnum.ALI_PAY.getCode(),this);
    }
    @Override
    public void pay() {
        // 处理支付宝支付逻辑
        System.out.println("===支付宝支付===");
    }
}
@Service
public class UnionPay implements IPay {
    @PostConstruct
    public void init(){
        PayStrategyFactory.register(PayCodeEnum.UNION_PAY.getCode(),this);
    }
    @Override
    public void pay() {
        // 银联支付逻辑
        System.out.println("===银联支付===");
    }
}
@Service
public class WechatPay implements IPay {
    @PostConstruct
    public void init(){
        PayStrategyFactory.register(PayCodeEnum.WECHAT_PAY.getCode(),this);
    }
    @Override
    public void pay() {
        // 微信支付逻辑
        System.out.println("===微信支付===");
    }
}
@Service
public class PayServiceStrategyFactoryImpl implements PayService {
    @Override
    public void toPay(String code) {
        PayStrategyFactory.get(code).pay();
    }
}

优化方案四：责任链模式（只为解释该设计模式使用）

@Data
public abstract class PayHandler {
    private PayHandler nextPayHandler;
    public abstract void pay(String code);
}
@Service
public class AliPayHandler extends PayHandler {
    @Override
    public void pay(String code) {
        if (PayCodeEnum.ALI_PAY.getCode().equals(code)) {
            System.out.println("===支付宝支付===");
        } else {
            getNextPayHandler().pay(code);
        }
    }
}
@Service
public class UnionPayHandler extends PayHandler {
    @Override
    public void pay(String code) {
        if (PayCodeEnum.UNION_PAY.getCode().equals(code)) {
            System.out.println("===银联支付===");
        } else {
            getNextPayHandler().pay(code);
        }
    }
}
@Service
public class WechatPayHandler extends PayHandler {
    @Override
    public void pay(String code) {
        if (PayCodeEnum.WECHAT_PAY.getCode().equals(code)) {
            System.out.println("===微信支付===");
        } else {
            getNextPayHandler().pay(code);
        }
    }
}
@Service
public class PayHandlerChainServiceImpl implements PayService, ApplicationContextAware, InitializingBean {
    private ApplicationContext applicationContext;
    private PayHandler payHandler;
    @Override
    public void afterPropertiesSet() throws Exception {
        Map beansOfType = applicationContext.getBeansOfType(PayHandler.class);
        if (beansOfType.isEmpty()) {
            return;
        }
        List handlers = beansOfType.values().stream().collect(Collectors.toList());
        for(int i = 0 ; i < handlers.size(); i++ ) {
            PayHandler handler = handlers.get(i);
            if (i != handlers.size() - 1) {
                handler.setNextPayHandler(handlers.get(i + 1));
            }
        }
        payHandler = handlers.get(0);
    }
    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
            this.applicationContext = applicationContext;
    }
    @Override
    public void toPay(String code) {
        payHandler.pay(code);
    }
}

6、思考：如何利用设计模式优化

if ("文本".equals(type)) {
            // do something
        } else if ("图片".equals(type)) {
            // do something
        } else if ("视频".equals(type)) {
            // do something
        } else {
            // do something
        }

answer:

@Data
public class MessageInfo {
    private Integer type;
    private String content;
}
public interface MessageService {
   void handleMessage(MessageInfo messageInfo);
}
@MessageHandlerAnnotation(value = MsgTypeEnum.TEXT)
@Service
public class TextMessageService implements MessageService{
    @Override
    public void handleMessage(MessageInfo messageInfo) {
        System.out.println("===文本消息===" + messageInfo.getContent());
    }
}
@MessageHandlerAnnotation(value = MsgTypeEnum.IMAGE)
@Service
public class ImageMessageService implements MessageService{
    @Override
    public void handleMessage(MessageInfo messageInfo) {
        System.out.println("===图片消息===" + messageInfo.getContent());
    }
}
@MessageHandlerAnnotation(value = MsgTypeEnum.VIDEO)
@Service
public class VideoMessageService implements MessageService{
    @Override
    public void handleMessage(MessageInfo messageInfo) {
        System.out.println("===视频消息===" + messageInfo.getContent());
    }
}
@Retention(value = RetentionPolicy.RUNTIME)
@Target(value = ElementType.TYPE)
public @interface MessageHandlerAnnotation {
    MsgTypeEnum value();
}
public enum MsgTypeEnum {
    TEXT(1, "文本"),
    IMAGE(2, "图片"),
    VIDEO(3, "视频");
    public final int code;
    public final String name;
    MsgTypeEnum(int code, String name){
        this.code = code;
        this.name = name;
    }
}
@Component
public class MessageServiceContext {
    private final Map handlerMap = new HashMap<>();
    public MessageService getMessageService(Integer code) {
       return handlerMap.get(code);
    }
    public void putMessageService(Integer code, MessageService messageService) {
        handlerMap.put(code, messageService);
    }
}
@Component
public class MessageServiceListener implements ApplicationListener {
    @Override
    public void onApplicationEvent(ContextRefreshedEvent contextRefreshedEvent) {
        Map beansWithAnnotation = contextRefreshedEvent.getApplicationContext().getBeansWithAnnotation(MessageHandlerAnnotation.class);
        MessageServiceContext messageServiceContext = contextRefreshedEvent.getApplicationContext().getBean(MessageServiceContext.class);
        beansWithAnnotation.forEach((key, value) -> {
            MessageHandlerAnnotation messageHandler = value.getClass().getAnnotation(MessageHandlerAnnotation.class);
            messageServiceContext.putMessageService(messageHandler.value().code, (MessageService) value);
        });
    }
}
@SpringBootTest
class DesignModeApplicationTests {
    @Autowired
    private MessageServiceContext messageServiceContext;
    @Test
    void contextLoads() {
        MessageInfo messageInfo = new MessageInfo();
        messageInfo.setType(1);
        messageInfo.setContent("文本文本");
        MessageService messageService = messageServiceContext.getMessageService(messageInfo.getType());
        messageService.handleMessage(messageInfo);
    }
}

【长沙研发中心】代码重构之设计模式

代码重构之设计模式

1、什么是重构？

2、为什么要重构？

3、介绍本次讲解重构中用到的4种设计模式：

4、常用的场景案例讲解：

5、优化方案：

优化方案一：注解

优化方案二：模板方法

优化方案三：工厂+策略模式

优化方案四：责任链模式（只为解释该设计模式使用）

6、思考：如何利用设计模式优化

阿里云GTS能力中心-浩鲸智能

热门文章

最新文章

相关课程

相关电子书

相关实验场景

探索云世界

热门

云计算

大数据

云原生

人工智能

数据库

开发与运维

活动广场

任务中心

训练营

直播

乘风者计划

下载

镜像站

技术资料

【长沙研发中心】代码重构之设计模式

代码重构之设计模式

1、什么是重构？

2、 为什么要重构？

3、介绍本次讲解重构中用到的4种设计模式：

4、常用的场景案例讲解：

5、优化方案：

优化方案一：注解

优化方案二：模板方法

优化方案三：工厂+策略模式

优化方案四：责任链模式 （只为解释该设计模式使用）

6、思考：如何利用设计模式优化

阿里云GTS能力中心-浩鲸智能

热门文章

最新文章

相关课程

相关电子书

相关实验场景

2、为什么要重构？

优化方案四：责任链模式（只为解释该设计模式使用）