一：何为设计模式（Design pattern）？
设计模式是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性、程序的重用性。
二：设计模式六大原则
1：开闭原则（open closed principle）
就是说模块应对扩展开放，而对修改关闭。模块应尽量在不修改原(是"原"，指原来的代码)代码的情况下进行扩展。
2：里氏替换原则（LSP liskov substitution principle）
如果调用的是父类的话，那么换成子类也完全可以运行。子类可以扩展父类的功能，但不能改变原有父类的功能。实际项目中，每个子类对应不同的业务含义，使父类作为参数，传递不同的子类完成不同的业务逻辑。
3：依赖倒转原则（Dependency-Inversion-Principle）
抽象不应该依赖于细节，细节应当依赖于抽象。换言之，要针对接口编程，而非针对实现编程。
依赖倒置原则基于这样一个事实：相对于细节的多变性，抽象的东西要稳定的多。以抽象为基础搭建起来的架构比以细节为基础搭建起来的架构要稳定的多。在java中，抽象指的是接口或者抽象类，细节就是具体的实现类，使用接口或者抽象类的目的是制定好规范和契约，而不去涉及任何具体的操作，把展现细节的任务交给他们的实现类去完成。
- 高层模块不应该依赖于低层模块。两个都应该依赖于抽象。
- 抽象不应该依赖细节。细节应该依赖于抽象。
开闭原则是目标，里氏代换是基础，依赖倒转是手段。
4：单一职责原则（Single-Responsibility-Principle）
一个类只负责一个功能领域中相应的职责，或者可以定义为：就一个类而言，应该只有一个引起它变化的原因。
做编程的时候，如果讲每一个类加上各种各样的功能就意味着，无论任何需求要来，你都需要更改这个类，这样会让维护非常麻烦，复用不可能，也缺乏灵活性。如果一个类承担的职责过多，就等于把这些职责耦合起来，一个职责变化可能会削弱或者抑制这个类完成其他职责的能力。这种耦合会导致脆弱的设计，当变化发生时，设计会遭到很多意想不到的破坏。
5：接口隔离原则（Interface-Segregation-Principle）
使用多个专门的接口，而不使用单一的总接口。即客户端不应该依赖于那些它不需要的接口。
接口的设计粒度越小，系统越灵活，但是灵活的同时结构复杂性提高，开发难度也会变大，维护性降低。
6：迪米特法则（Law-Of-Demeter）
一个软件实体应当尽可能少地与其他实体发生作用。也叫最少知识原则，尽量降低类与类之间的耦合。
迪米特法则的初衷在于降低类之间的耦合。由于每个类尽量减少对其他类的依赖，因此，很容易使得系统的功能模块功能独立，相互之间不存在（或很少有）依赖关系。
迪米特法则不希望类之间建立直接的联系。如果有真的需要建立联系的，也希望能通过他的友元类来转达。因此，应用迪米特法则有可能造成一个后果就是：系统中存在大量的中介类，这些类之所以存在完全是为了传递类之间的相互关系，这在一定程度上增加了系统的复杂度。
三：策略模式
如何理解策略？比如我们去远方旅游，需要选择交通方式，坐火车、坐飞机、自己开车等等，这些交通方式，每一种都是一个策略。
再比如淘宝搞活动，有打折、有满减、有返利的等等，这都是一些算法，这些算法本身只是一种策略，并且这些算法是随时都可能互相替换的，比如针对同一件商品，今天打五折、明天换返利，这些策略间是可以互换的。
不管选择哪种交通方式，最终的目的地都是一样的。不管选择哪种销售方式，最终都是为了卖商品。也就是选择不同的策略，最终的目的都是一样的。
策略模式是对算法的包装，是把使用算法的责任和算法本身分开来，委派给不同的对象管理。整体可以分为三部分：
Context上下文：用一个ConcreteStrategy来配置，维护一个对Strategy对象的引用。Strategy抽象策略类：通常由一个接口或者抽象类实现。用于定义所有支持算法的公共接口。ConcreteStrategy具体策略类：封装了具体的算法或行为，继承于Strategy。
Strategy抽象策略类
package com.nobody.strategy;
/**
* Strategy抽象策略类
*
* @author Μr.ηobοdy
*
* @date 2020-06-07
*
*/
public interface TravelStrategy {
String travel();
}ConcreteStrategy具体策略类
package com.nobody.strategy;
public class TrainTravelStrategy implements TravelStrategy {
@Override
public String travel() {
return "我是坐火车的交通方式...";
}
}package com.nobody.strategy;
public class AirTravelStrategy implements TravelStrategy {
@Override
public String travel() {
return "我是坐飞机的交通方式...";
}
}package com.nobody.strategy;
public class CarTravelStrategy implements TravelStrategy {
@Override
public String travel() {
return "我是自驾的交通方式...";
}
}策略枚举类
package com.nobody.strategy;
/**
* 策略枚举类 保存所有具体策略类
*
* @author Μr.ηobοdy
*
* @date 2020-06-06
*
*/
public enum TravelEnumStrategy {
// 火车方式
TRAIN_TRAVEL("com.nobody.strategy.TrainTravelStrategy"),
// 飞机方式
AIR_TRAVEL("com.nobody.strategy.AirTravelStrategy"),
// 汽车方式
CAR_TRAVEL("com.nobody.strategy.CarTravelStrategy");
// 具体策略类class全路径
private String className;
TravelEnumStrategy(String className) {
this.className = className;
}
public String getClassName() {
return className;
}
}具体策略类生产工厂类
package com.nobody.strategy;
/**
* 具体策略类生产工厂类
*
* @author Μr.ηobοdy
*
* @date 2020-06-07
*
*/
public class StrategyFactory {
public static TravelStrategy getTravelStrategy(String travelType) {
// 通过枚举获取具体策略类名
String className = TravelEnumStrategy.valueOf(travelType).getClassName();
try {
// 反射机制获取具体策略类实例
return (TravelStrategy) Class.forName(className).newInstance();
} catch (InstantiationException | IllegalAccessException | ClassNotFoundException e) {
e.printStackTrace();
}
return null;
}
}Context上下文
package com.nobody.strategy;
import org.springframework.util.StringUtils;
/**
* Context上下文
*
* @author Μr.ηobοdy
*
* @date 2020-06-07
*
*/
public class TravelContextStrategy {
public static String travel(String travelType) {
if (StringUtils.isEmpty(travelType)) {
return "travelType不能为空!";
}
TravelStrategy travelStrategy = StrategyFactory.getTravelStrategy(travelType);
if (travelStrategy == null) {
return "没有找到具体的策略，travelType:" + travelType;
}
return travelStrategy.travel();
}
}测试类
package com.nobody.strategy;
/**
* 测试类
*
* @author Μr.ηobοdy
*
* @date 2020-06-07
*
*/
public class Main {
public static void main(String[] args) {
String travelType = "TRAIN_TRAVEL";
String result = TravelContextStrategy.travel(travelType);
System.out.println(result);
}
}输出结果
我是坐火车的交通方式...策略模式的应用
何时使用：一个系统有许多类，而区分它们的只是他们直接的行为时。- 方法：将这些算法封装成一个一个的类，任意的替换。
优点：1 算法可以自由切换；2 避免使用多重条件判断（如果不用策略模式我们可能会使用多重条件语句，不利于维护）；3 扩展性良好，增加一个策略只需实现接口即可。缺点：策略类数量会增多，每个策略都是一个类，复用的可能性很小
所有的策略类都需要对外暴露。
使用场景：1 多个类只有算法或行为上稍有不同的场景；2 算法需要自由切换的场景；3 需要屏蔽算法规则的场景。
应用实例：1 旅游交通方式，坐火车、坐飞机等，每一种交通方式都是一个策略；2 商场促销方式，打折、满减等；3 网上支付有不同支付方式，例如支付宝支付，银联支付，微信支付等；4 Java AWT中的LayoutManager，即布局管理器.注意事项：如果一个系统的策略多于四个，就需要考虑使用混合模式来解决策略类膨胀的问题。
以上实现是基于枚举保存具体策略类信息，并且自定义工厂类的。以下讲解基于数据库，和基于Spring容器管理具体策略类实例形式的。
定义获取具体策略类实例工具类
package com.nobody.strategy;
import org.springframework.beans.BeansException;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
public class SpringUtils implements ApplicationContextAware {
private static ApplicationContext applicationContext;
@Override
public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
this.applicationContext = applicationContext;
}
public ApplicationContext getApplicationContext() {
return applicationContext;
}
public static Object getBean(String name) {
return applicationContext.getBean(name);
}
public static <T> T getBean(Class<T> requiredType) {
return applicationContext.getBean(requiredType);
}
public static <T> T getBean(String name, Class<T> requiredType) {
return applicationContext.getBean(name, requiredType);
}
}具体策略类加@Component注解注入到Spring容器中
package com.nobody.strategy;
import org.springframework.stereotype.Component;
@Component
public class CarTravelStrategy implements TravelStrategy {
@Override
public String travel() {
return "我是自驾的交通方式...";
}
}测试类
package com.nobody.strategy;
import org.springframework.stereotype.Component;
import org.springframework.util.StringUtils;
/**
* 测试类
*
* @author Μr.ηobοdy
*
* @date 2020-06-07
*
*/
public class Main {
public static void main(String[] args) {
// 基于数据库形式，将具体策略类信息保存在数据库，并且在具体策略类加上@Component注解注入到Spring容器管理
// 通过id和具体策略类beanName映射一起，例如
// {id:1,beanId:"carTravelStrategy"},{id:2,beanId:"airTravelStrategy"}
// 调用方（例如前端）通过参数id，然后通过数据库查找到beanId，再通过Spring容器获取具体策略实例。
String name = "carTravelStrategy"; // 此处省略了数据库获取步骤
TravelStrategy travelStrategy = (TravelStrategy) SpringUtils.getBean(name);
String result1 = travelStrategy.travel();
System.out.println(result1);
}
}代码工程github下载地址：https://github.com/LucioChn/design-pattern-service
