摘要
本文简单介绍软件开发过程中面临的痛点和几个总体原则。详细介绍了简单工厂、工厂方法、抽象工厂和策略模式的实现，以及各种模式之间的相似、区别。
背景
开发面临哪些问题（痛点）？
相信做过大型软件开发的tx都遇到过以下类似问题。在原有代码基础上扩展新功能，需修改历史代码，又会影响已交付功能。且还需同步修改测试用例。debug时则陷入“无尽”的方法调用、分支逻辑判断中。
软件开发大致包括扩展软件新功能、维护旧功能、测试和debug。如何减少上述过程耗费的时间精力，是设计模式方法论的最终目的：降低软件开发、测试、变更、维护成本。
代码需具备哪些特性（需求）？
代码需具备高内聚，低耦合总特性才能减缓软件开发中面临的痛点。代码结构清晰易看懂，易维护、可复用，容易扩展，且灵活性好。
tips：如何学习设计模式？
- 学习过程中，一定要按照自己对知识的理解，独立输出一份可以表达某一种模式思想的toy代码。
- 有开发经验的同学，可以从软件开发过程中遇到的痛点、需求出发，尝试用不同的设计模式解决相同的问题，思考总结出各种设计模式之间的联系和区别，而不是生搬硬套。
总体原则
单一职责
一个类/方法应该仅有一个引起它变化的原因
开放-封闭原则
软件实体（类、模块、函数等）应该可以扩展，但不可修改。已完成的抽象应尽可能覆盖后续可能的变化
依赖倒置原则
高层不应该依赖底层模模块，两者都应依赖抽象接口
抽象不应该依赖细节。细节应该依赖抽象。针对接口编程而非实现编程
里氏替换原则
子类必须能替换它们的父类
只有当子类可以替换父类，父类才能真正被复用，子类也能够在父类基础上增加新的行为。例如：在软件设计领域，鸟会飞，企鹅不会飞，企鹅不是鸟的子类，两者没有继承关系
tips：实现总体原则的方法论：24个设计模式
设计模式的目的是开发出高内聚、低耦合的软件系统，高内聚、低耦合离不开面向对象中封装、继承、多态特性。封装、继承、多态在java中的实现则是类、接口父子类、接口引用不同实现对象。
面向对象三大特性：封装、继承、多态。
- 封装，即隐藏对象的属性和实现细节，仅对外公开接口。将数据（属性）和操作数据的行为（方法）组合为类。
- 继承，即已有的类中派生出新的类，新的类具备已有类的数据属性和行为，并能扩展新的能力
- 多态，即可以用一种类型的变量引用另一种类型的对象，例如在java中，接口可以引用不同接口实现类对象。
简单工厂模式
简单工厂类通过输入参数创建具体对象的模式，简化client调用负担。简单工厂类不必单独创建，可结合在其他类中。
适用于接口/父类有多个实现/子类、且可能继续扩展的创建对象（关注点在创建对象）的场景
需求举例
实现加法、减法、乘法、除法，后续还可能扩展根号、乘方等
分析
定义操作符父类，实现不同加、减等子类，简单工厂方法根据输入参数创建并返回不同的操作符子类。后续扩展，只需新增子类，并在简单工厂类中新增条件分支。
Java实现
抽象操作符父类
定义操作符父类，抽象出getResult()方法
public abstract class Operation {
private double numberA = 0;
private double numberB = 0;
/**省略get和set方法*/
public double getResult(){
return 0;
}
}加法子类
加法子类实现操作符父类的getResult()方法
public class AddOperation extends Operation{
@Override
public double getResult(){
return super.getNumberA() + super.getNumberB();
}
}简单工厂类
简单工厂类封装client需要判断的逻辑，根据传入参数返回不同的操作符子类对象。
public class OperationFactory {
public static Operation createOperation(String opr){
Operation operation = null;
switch (opr){
case "+":
operation = new AddOperation();
break;
default:
}
return operation;
}
}客户端调用
public static void main(String[]args){
Operation opr ;
opr = OperationFactory.createOperation("+");
opr.setNumberA(1);
opr.setNumberB(2);
System.out.println(opr.getResult());
}扩展新功能
扩展减法子类
减法子类实现操作符父类的getResult()方法
public class SubOperation extends Operation{
@Override
public double getResult(){
return super.getNumberA() - super.getNumberB();
}
}修改简单工厂类
简单工厂类扩展case条件分支，提供创建减法操作对象功能
public static Operation createOperation(String opr){
Operation operation = null;
switch (opr){
case "+":
operation = new AddOperation();
break;
case "-"://添加减法类
operation = new SubOperation();
break;
default:
}
return operation;
}存在的问题？
新增操作符子类，需要修改简单工厂类，添加case语句。扩展新业务需要修改历史业务代码，不符合“开闭原则”。后续工厂方法模式，通过抽象工厂类接口，满足“开闭原则”。
策略模式
定义不同算法簇并分别封装，不同算法之间可相互替换，算法的变化不会影响使用算法的人
适用于同一个类中出现不同的业务规则场景，通过策略模式封装处理不同变化。
不同的行为堆砌在一个类中，很难避免用条件语句选择合适行为，将行为封装在独立的strategy类中，可在类中消除条件语句。
Java实现
策略接口
public interface IStrategy {
double algorithm(double money);
}业务策略1
public class CashReturn implements IStrategy{
private double moneyCondition = 0.d;
private double moneyReturn = 0.d;
public CashReturn(double moneyCondition,double moneyReturn){
this.moneyCondition = moneyCondition;
this.moneyReturn = moneyReturn;
}
@Override
public double algorithm(double money) {
if(money > moneyCondition){
return money - Math.floor( money/moneyCondition) * moneyReturn;
}
return money;
}
}业务策略2
public class CashRebate implements IStrategy{
private double rebate = 1d;
public CashRebate(double rebate){
this.rebate = rebate;
}
@Override
public double algorithm(double money) {
return money*rebate;
}
}策略上下文类
public class CashContext {
IStrategy strategy;
public CashContext(String type){
switch (type){
case "discount":
strategy = new CashRebate(0.8);
break;
case "return":
strategy = new CashReturn(200,30);
break;
default:
}
}
public double getResult(double money){
return strategy.algorithm(money);
}
}client调用
public static void main(String[]args){
double inputMoney = 100;
String type = "discount";
//1.简单工厂方法：类型为参数通过工厂方法返回不同计算对象，对象计算最终值。
//client需要使用工厂类 + 不同计算类
//2.类型作为参数，通过上下文对象，直接获取最终值。将不同计算对象封装入上下文对象。
//client只需要使用上下文类。
double outputMoney = new CashContext(type).getResult(inputMoney);
System.out.println(outputMoney);
}简单工厂和策略模式区别
策略模式将简单工厂创建对象过程封装在上下文类内部，不再对外暴露具体对象，降低了client使用类的难度。本质是在继承、多态的基础上新增了一层上下文类，达到client和业务逻辑类之间的解耦。
具体选择：从业务角度考虑，如果仅创建对象，使用工厂模式。如果业务存在不同的规则，使用策略模式。
从侧重点理解：
- 简单工厂关注对象的创建。例如实例化不同对象。
- 策略模式关注业务行为封装。例如实现某一系列算法。
从client角度理解：
- 简单工厂先实例化对象，再调用对象的方法
- 策略模式直接调用上下文对象的方法。实例化对象放在了上下文类中。
从测试角度理解：
- 简单工厂模式需要测试对象的每个方法
- 策略模式只需要调用上下文对象的方法即可
工厂方法模式
定义创建对象的工厂接口，让类的实例化延迟到工厂子类。工厂方法模式，通过抽象出工厂接口，解决了简单工厂模式无法满足“开闭原则”的问题。
需求举例
同样以简单工厂模式中介绍的加、减操作实现为例。
Java实现
操作符父类
定义操作符父类抽象方法getResult()
public abstract class IOperation {
public double numA = 0;
public double numB = 0;
abstract double getResult();
}加法子类
定义加法操作符子类，并实现getResult()
public class AddOperation extends IOperation{
public AddOperation(double numA,double numB){
super.numA = numA;
super.numB = numB;
}
@Override
public double getResult() {
return numA + numB;
}
}
工厂方法接口
定义工厂类接口createOperation()
public interface IFactory {
IOperation createOperation(double numA,double numB);
}加法工厂子类
定义加法工厂子类，并实现createOperation()方法
public class AddFactory implements IFactory{
@Override
public IOperation createOperation(double numA,double numB) {
return new AddOperation(numA,numB);
}
}客户端调用
public static void main(String[]args){
IOperation opr = new AddFactory().createOperation(1,3);
System.out.println(opr.getResult());
}扩展新功能
减法子类
public class SubOperation extends IOperation{
public SubOperation(double numA,double numB){
super.numA = numA;
super.numB = numB;
}
@Override
public double getResult() {
return numA - numB;
}
}减法工厂子类
public class SubFactory implements IFactory{
@Override
public IOperation createOperation(double numA,double numB) {
return new SubOperation(numA,numB);
}
}优缺点
满足开放封闭原则
- 扩展新业务，例如新增减法操作，只需新增减法子类和减法工厂子类，无需修改历史代码。
- client调用，仅需修改new AddFactory()为new SubFactory()。
业务扩展产生过多工厂子类
不同于简单工厂模式，新增业务只需增加switch分支，工厂方法模式新增业务需要新增工厂子类。不断扩充业务时，工厂子类也会不断扩充冗余。
简单工厂与工厂方法区别
- 简单工厂使用工厂类直接创建对象，而工厂方法则定义工厂接口，工厂子类负责创建对象。
- 简单工厂不满足“开闭原则”，工厂方法满足。
- 简单工厂扩充业务无需新增工厂类，工厂方法会不断扩充工厂子类。
抽象工厂模式
抽象工厂模式，类似工厂方法模式，提供创建不同种类对象的接口方法。例如提供创建A对象、B对象方法。
需求举例
支持sqlserver、access类型数据库连接user表、department表，后续还可能扩展mysql方式，以及其他表
分析
目的是方便替换不同访问数据库的方式，因此需要在访问数据库方式上使用继承和多态特性。需要抽象出顶层接口，创建不同方式访问对象。具体实现思路：
- 抽象出user、department表行为接口，分别以sqlserver、access方式实现上述的表接口。
- 工厂模式创建user、department对象
- client利用工厂方法直接调用user、department行为接口
Java实现
user、department接口和实现
//接口定义
public interface IUserService {
User getUser();
}
//Access实现
public class AccessUser implements IUserService {
@Override
public User getUser() {
System.out.println("访问access get user");
return null;
}
}
//Sqlserver实现
public class SqlserverUser implements IUserService {
@Override
public User getUser() {
System.out.println("访问Sqlserver get user");
return null;
}
}//接口定义
public interface IDepartmentService {
Department getDepartment();
}
//Access实现
public class AccessDepartment implements IDepartmentService {
@Override
public Department getDepartment() {
System.out.println("访问access get department");
return null;
}
}
//Sqlserver实现
public class SqlserverDepartment implements IDepartmentService {
@Override
public Department getDepartment() {
System.out.println("访问Sqlserver get department");
return null;
}
}优化简单工厂类
使用反射替代switch条件语句，且反射的参数值，还可以通过配置文件得到。达到了解耦+开闭原则。
public class DataAccessFactory {
//根据变量的值，选择Access或Sqlserver方式访问数据库。该值可以写入配置文件中，更加方便
String dbAccessMethod = "test.factory.abstfactory.impl.access.";
public IUserService createUserService() throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException {
String className =dbAccessMethod + "AccessUser";
Class clazz = Class.forName(className);
return (IUserService) clazz.getDeclaredConstructor().newInstance();
}
public IDepartmentService creteDeparmentService() throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException {
String className =dbAccessMethod + "AccessDepartment";
Class clazz = Class.forName(className);
return (IDepartmentService) clazz.getDeclaredConstructor().newInstance();
}
}client调用
public static void main(String[]args) throws ClassNotFoundException, InvocationTargetException, NoSuchMethodException, InstantiationException, IllegalAccessException {
DataAccessFactory dataAccess = new DataAccessFactory();
IUserService userService = dataAccess.createUserService();
userService.getUser();
IDepartmentService departmentService = dataAccess.creteDeparmentService();
departmentService.getDepartment();
}优缺点
抽象工厂类似工厂方法，但是抽象工厂提供多个接口。扩展业务时新增工厂子类，造成工厂类簇冗余，但是具备开闭原则。而简单工厂模式扩展业务时，只需在工厂类中新增判断分支，不需要新增工厂子类，但是不能满足开闭原则。
抽象工厂总结
在抽象工厂模式中，可以使用简单工厂模式中的工厂类 + 反射技术，替换简单工厂方法中switch分支语句，再+配置文件，可以将反射需要的变量配置在配置文件中。这种方式解决了工厂类冗余问题，又满足开闭原则
觉得不错，点个👍吧，(*^▽^*)
1853
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
