涨姿势，Java 重构设计模式，厉害！
点击上方“Java基基”，选择“设为星标”
做积极的人，而不是积极废人！
每天 14:00 更新文章，每天掉亿点点头发...
源码精品专栏
原创 | Java 2021 超神之路，很肝~
中文详细注释的开源项目
RPC 框架 Dubbo 源码解析
网络应用框架 Netty 源码解析
消息中间件 RocketMQ 源码解析
数据库中间件 Sharding-JDBC 和 MyCAT 源码解析
作业调度中间件 Elastic-Job 源码解析
分布式事务中间件 TCC-Transaction 源码解析
Eureka 和 Hystrix 源码解析
Java 并发源码
来源：cnblogs.com/yjmyzz/p/refactor
-design-pattern-using-java8.html
一、策略模式
二、模板方法
三、观察者模式
四、责任链/职责链模式
java8中提供的很多新特性可以用来重构传统设计模式中的写法，下面是一些示例：
一、策略模式
上图是策略模式的类图，假设我们现在要保存订单，OrderService接口定义要做什么，而NoSqlSaveOrderStragegy以及MySqlSaveOrderStrategy则提供了二种策略，分别是保存到nosql数据库，以及传统的mysql关系型数据库，最后在OrderServiceExecutor中通过构造函数注入最终要使用的策略。
传统写法，这个场景至少得4个类，代码如下：
OrderService接口：
public interface OrderService {void saveOrder(String orderNo);
}Mysql策略实现：
public class MySqlSaveOrderStrategy implements OrderService {@Overridepublic void saveOrder(String orderNo) {System.out.println("order:" + orderNo + " save to mysql");}
}Nosql策略实现
public class NoSqlSaveOrderStrategy implements OrderService {@Overridepublic void saveOrder(String orderNo) {System.out.println("order:" + orderNo + " save to nosql");}
}使用策略的辅助"容器"
public class OrderServiceExecutor {private final OrderService service;public OrderServiceExecutor(OrderService service) {this.service = service;}public void save(String orderNo) {this.service.saveOrder(orderNo);}}运行测试类：
public class OrderServiceTest {public static void main(String[] args) {OrderServiceExecutor executor1 = new OrderServiceExecutor(new MySqlSaveOrderStrategy());executor1.save("001");OrderServiceExecutor executor2 = new OrderServiceExecutor(new NoSqlSaveOrderStrategy());executor2.save("002");}
}重构后，可以省去2个策略实现类，代码如下：
public static void main(String[] args) {OrderServiceExecutor executor1 = new OrderServiceExecutor((String orderNo) -> System.out.println("order:" + orderNo + " save to mysql"));executor1.save("001");OrderServiceExecutor executor2 = new OrderServiceExecutor((String orderNo) -> System.out.println("order:" + orderNo + " save to nosql"));executor2.save("002");
}基于 Spring Boot + MyBatis Plus + Vue & Element 实现的后台管理系统 + 用户小程序，支持 RBAC 动态权限、多租户、数据权限、工作流、三方登录、支付、短信、商城等功能
项目地址：https://gitee.com/zhijiantianya/ruoyi-vue-pro
视频教程：https://doc.iocoder.cn/video/
二、模板方法
类图如下，核心思路是把一些通用的标准方法，在抽象父类里仅定义方法签名，实现逻辑交给子类。
比如：会员系统中，每个商家都会有一些营销活动，需要推送某种信息给会员，但是不同的商家推送的内容可能不同，有些需要推送优惠券，有些需要积分通知。
抽象模板类：
public abstract class AbstractPushTemplate {public void push(int customerId, String shopName) {System.out.println("准备推送...");execute(customerId, shopName);System.out.println("推送完成\n");}abstract protected void execute(int customerId, String shopName);
}优惠券的具体模板
public class PushCouponTemplate extends AbstractPushTemplate {@Overrideprotected void execute(int customerId, String shopName) {System.out.println("会员:" + customerId + ",你好，" + shopName + "送您一张优惠券");}
}积分的具体模板
public class PushScoreTemplate extends AbstractPushTemplate {@Overrideprotected void execute(int customerId, String shopName) {System.out.println("会员:" + customerId + ",你好，" + shopName + "送您10个积分");}
}使用示例：
AbstractPushTemplate template1 = new PushCouponTemplate();
template1.push(1, "糖果店");AbstractPushTemplate template2 = new PushScoreTemplate();
template2.push(1, "服装店");显然如果模板的实现方式越多，子类就越多。使用java8重构后，可以把上面的3个模板（包括抽象类模板）减少到1个，参考下面：
public class PushTemplateLambda {public void push(int customerId, String shopName, Consumer execute) {System.out.println("准备推送...");Object[] param = new Object[]{customerId, shopName};execute.accept(param);System.out.println("推送完成\n");}
} 借助Consumer，可以省去实现子类，具体的实现留到使用时再来决定，如：
new PushTemplateLambda().push(1, "糖果店", (Object[] obj) -> {System.out.println("会员:" + obj[0] + ",你好，" + obj[1] + "送您一张优惠券");
});new PushTemplateLambda().push(1, "服装店", (Object[] obj) -> {System.out.println("会员:" + obj[0] + ",你好，" + obj[1] + "送您10个积分");
});基于 Spring Cloud Alibaba + Gateway + Nacos + RocketMQ + Vue & Element 实现的后台管理系统 + 用户小程序，支持 RBAC 动态权限、多租户、数据权限、工作流、三方登录、支付、短信、商城等功能
项目地址：https://gitee.com/zhijiantianya/yudao-cloud
视频教程：https://doc.iocoder.cn/video/
三、观察者模式
思路：基于某个Subject主题，然后一堆观察者Observer注册到主题上，有事件发生时，subject根据注册列表，去通知所有的observer。
Observer接口:
public interface Observer {void notify(String orderNo);
}Subject接口:
public interface Subject {void registerObserver(Observer o);void notifyAllObserver(String orderNo);
}Subject接口实现：
public class SubjectImpl implements Subject {private final List list = new ArrayList<>();@Overridepublic void registerObserver(Observer o) {list.add(o);}@Overridepublic void notifyAllObserver(String orderNo) {list.forEach(c -> c.notify(orderNo));}
} 观察者的二个实现：
OrderObserver:
public class OrderObserver implements Observer {@Overridepublic void notify(String orderNo) {System.out.println("订单 " + orderNo + " 状态更新为【已支付】");}
}StockObserver:
public class StockObserver implements Observer {@Overridepublic void notify(String orderNo) {System.out.println("订单 " + orderNo + " 已通知库房发货！");}
}测试一把：
static void test1() {Subject subject = new SubjectImpl();subject.registerObserver(new OrderObserver());subject.registerObserver(new StockObserver());subject.notifyAllObserver("001");
}用java8重构后，接口可以提供默认实现方法，我们弄一个新的主题接口
public interface NewSubject {List list = new ArrayList<>();default void registerObserver(Observer o) {list.add(o);}default void nofityAllObserver(String orderNo) {list.forEach(c -> c.notify(orderNo));}
} 使用:
static void test2() {NewSubject subject = new NewSubject() {};subject.registerObserver((String orderNo) -> System.out.println("订单 " + orderNo + " 状态更新为【已支付】"));subject.registerObserver((String orderNo) -> System.out.println("订单 " + orderNo + " 已通知库房发货！"));subject.nofityAllObserver("002");
}只用2个接口实现了观察者模式。
四、责任链/职责链模式
核心思想：每个处理环节，都有一个“指针”指向下一个处理者，类似链表一样。
Processor接口：
public interface Processor {Processor getNextProcessor();void process(String param);
}抽象实现类
public abstract class AbstractProcessor implements Processor {private Processor next;public AbstractProcessor(Processor processor) {this.next = processor;}@Overridepublic Processor getNextProcessor() {return next;}@Overridepublic abstract void process(String param);
}定义2个具体的实现
public class ProcessorImpl1 extends AbstractProcessor {public ProcessorImpl1(Processor processor) {super(processor);}@Overridepublic void process(String param) {System.out.println("processor 1 is processing:" + param);if (getNextProcessor() != null) {getNextProcessor().process(param);}}
}及
public class ProcessorImpl2 extends AbstractProcessor {public ProcessorImpl2(Processor next) {super(next);}@Overridepublic void process(String param) {System.out.println("processor 2 is processing:" + param);if (getNextProcessor() != null) {getNextProcessor().process(param);}}
}使用示例：
static void test1() {Processor p1 = new ProcessorImpl1(null);Processor p2 = new ProcessorImpl2(p1);p2.process("something happened");
}用java8重构后，只需要一个新接口
@FunctionalInterface
public interface NewProcessor {Consumer process(String param);
} 同样的效果，可以写得很简洁：
static void test2() {Consumer p1 = param -> System.out.println("processor 1 is processing:" + param);Consumer p2 = param -> System.out.println("processor 2 is processing:" + param);p2.andThen(p1).accept("something happened");
} andThen天然就是getNextProcessor的另一种表达。
重要提示：什么时候该用lambda，什么时候不用，这是要看情况的，如果处理逻辑相对比较简单，可以用lamdba来重构，以便让代码更简洁易读，如果处理逻辑很复杂，应该还是用“类”。
欢迎加入我的知识星球，一起探讨架构，交流源码。加入方式，长按下方二维码噢：
已在知识星球更新源码解析如下：
最近更新《芋道 SpringBoot 2.X 入门》系列，已经 101 余篇，覆盖了 MyBatis、Redis、MongoDB、ES、分库分表、读写分离、SpringMVC、Webflux、权限、WebSocket、Dubbo、RabbitMQ、RocketMQ、Kafka、性能测试等等内容。
提供近 3W 行代码的 SpringBoot 示例，以及超 6W 行代码的电商微服务项目。
获取方式：点“在看”，关注公众号并回复 666 领取，更多内容陆续奉上。
文章有帮助的话，在看，转发吧。
谢谢支持哟 (*^__^*）本文来自互联网用户投稿，文章观点仅代表作者本人，不代表本站立场，不承担相关法律责任。如若转载，请注明出处。 如若内容造成侵权/违法违规/事实不符，请点击【内容举报】进行投诉反馈！