1、简介
工厂模式是一种创建型设计模式， 是用工厂方法代替new操作的一种模式。工厂模式能大量减少if-else，减少大量冗余代码，也能够更好的提高代码复用性 ，减少耦合，也就是我们常说的高内聚低耦合。
2、分类和比较
工厂模式可以分为：简单工厂模式，工厂方法模式、抽象工厂模式
| 分类 | 介绍 |
|---|---|
| 简单工厂模式 | 用于生产同一等级结构中得任何产品（对于生产新的产品，需要修改已有得代码） |
| 工厂方法模式 | 用于生产同一等级结构中得固定产品（支持增加任意产品） |
| 抽象工厂模式 | 用于生产不同产品族得全部产品 |
3、简单工厂模式
/**
* 汽车接口
*/
public interface ICar {
void carRun();
}
/**
* @Author charles.yao
* @Description 奥迪车
* @Date 2023/1/29 13:43
*/
public class AudiCar implements ICar {
@Override
public void carRun() {
System.out.println("奥迪车在跑~");
}
}
/**
* @Author charles.yao
* @Description 奔驰车
* @Date 2023/1/29 13:44
*/
public class BenzCar implements ICar {
@Override
public void carRun() {
System.out.println("奔驰车再跑~");
}
}
简单工厂实现
/**
* @Author charles.yao
* @Description 汽车工厂
* @Date 2023/1/29 13:45
*/
public class CarFactory {
/**
* 创建一个汽车
*
* @param num
* @return
*/
public static ICar createCar(Integer num) {
if (num == 1) {
return new AudiCar();
} else {
return new BenzCar();
}
}
}
简单测试一下
/**
* @Author charles.yao
* @Description 简单工厂测试
* @Date 2023/1/29 13:48
*/
public class CarTest {
public static void main(String[] args) {
ICar car = CarFactory.createCar(1);
car.carRun();
}
}
总结：
1、简单工厂模式也叫静态工厂模式，一般是使用静态方法，通过接收不同的参数来返回不同得实例对象
2、如果需要增加新的产品，需要修改代码
4、工厂方法模式
car类使用上边类即可
工厂方法类接口
/**
* 工厂方法接口类
*/
public interface CarFactory {
ICar createCar();
}
实现类
/**
* @Author charles.yao
* @Description 奥迪工厂类
* @Date 2023/1/29 13:56
*/
public class AudiCarFactory implements CarFactory{
@Override
public ICar createCar() {
return new AudiCar();
}
}
/**
* @Author charles.yao
* @Description 奔驰工厂类
* @Date 2023/1/29 13:57
*/
public class BenzFactory implements CarFactory{
@Override
public ICar createCar() {
return new BenzCar();
}
}
测试类
/**
* @Author charles.yao
* @Description 工厂方法类
* @Date 2023/1/29 13:57
*/
public class MethodTest {
public static void main(String[] args) {
CarFactory audiCarFactory = new AudiCarFactory();
CarFactory benzFactory = new BenzFactory();
audiCarFactory.createCar().carRun();
benzFactory.createCar().carRun();
}
总结：
优点：
- 用户只需要知道具体工厂的名称就可得到所要的产品，无须知道产品的具体创建过程。
- 灵活性增强，对于新产品的创建，只需多写一个相应的工厂类。
- 典型的解耦框架。高层模块只需要知道产品的抽象类，无须关心其他实现类，满足迪米特法则、依赖倒置原则和里氏替换原则。
缺点：
- 类的个数容易过多，增加复杂度
- 增加了系统的抽象性和理解难度
- 抽象产品只能生产一种产品，此弊端可使用抽象工厂模式解决
5、抽象工厂模式
抽象工厂模式（Abstract Factory Pattern）是围绕一个超级工厂创建其他工厂。该超级工厂又称为其他工厂的工厂。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。
- 用来生产不同产品族的全部产品。（对于增加新的产品，无能为力；支持增加产品族）
- 抽象工厂模式是工厂方法模式的升级版本，在有多个业务品种、业务分类时，通过抽象工厂模式产生需要的对象是一种非常好的解决方式。
发动机相关
/**
* 发动机接口
*/
public interface IEngine {
void run();
void start();
}
/**
* @Author charles.yao
* @Description 高功率发动机
* @Date 2023/2/7 16:08
*/
public class HighEngine implements IEngine {
@Override
public void run() {
System.out.println("高功率发动机在运行");
}
@Override
public void start() {
System.out.println("高功率发动机启动啦~");
}
}
/**
* @Author charles.yao
* @Description 低功率发动机
* @Date 2023/2/7 16:09
*/
public class LowEngine implements IEngine {
@Override
public void run() {
System.out.println("低功率发动机运行ing");
}
@Override
public void start() {
System.out.println("低功率发动机启动啦~");
}
}
座椅相关
/**
* 座椅接口
*/
public interface ISeat {
void msg();
}
/**
* @Author charles.yao
* @Description 高端座椅类
* @Date 2023/2/7 16:11
*/
public class HighSeat implements ISeat{
@Override
public void msg() {
System.out.println("高端座椅自动加热ing");
}
}
/**
* @Author charles.yao
* @Description 低端座椅
* @Date 2023/2/7 16:11
*/
public class LowSeat implements ISeat {
@Override
public void msg() {
System.out.println("低端座椅屁都没有，凑合坐着吧");
}
}
工厂相关，工厂能生成高端低端，汽车相关不同产品
/**
* @Author charles.yao
* @Description 抽象工厂接口
* @Date 2023/2/7 16:13
*/
public interface ICarFactory {
ISeat createSeat();
IEngine createEngine();
}
/**
* @Author charles.yao
* @Description 低端工厂类
* @Date 2023/2/7 16:17
*/
public class LowCarFactory implements ICarFactory {
@Override
public ISeat createSeat() {
return new LowSeat();
}
@Override
public IEngine createEngine() {
return new LowEngine();
}
}
/**
* @Author charles.yao
* @Description 高端工厂类
* @Date 2023/2/7 16:16
*/
public class HighCarFactory implements ICarFactory {
@Override
public ISeat createSeat() {
return new HighSeat();
}
@Override
public IEngine createEngine() {
return new HighEngine();
}
}
测试类：
/**
* @Author charles.yao
* @Description 抽象工厂模式test
* @Date 2023/2/7 16:18
*/
public class AbstractFactoryTest {
public static void main(String[] args) {
ICarFactory highCarFactory = new HighCarFactory();
IEngine engine = highCarFactory.createEngine();
engine.start();
engine.run();
ISeat seat = highCarFactory.createSeat();
seat.msg();
}
}
6、springboot中应用
工厂模式+策略模式 会涉及公司代码，我会删除部分逻辑，请见谅
策略接口：
/**
* 股东导入公共接口
*/
public interface HolderImportInterface {
/**
* 处理股东数据
*
* @param stockBasisBOList
*/
void dealHolderData(List<StockBasisBO> stockBasisBOList, Integer comCodeType);
//获取类型
Integer getType();
}
实现类（可以使用若干类，我就写了一个）
@Slf4j
@Service
public class AService implements HolderImportInterface {
@Override
public void dealHolderData(List<StockBasisBO> stockBasisBOList, Integer comCodeType) {
//数据处理逻辑
}
@Override
public Integer getType() {
//使用枚举类，
return HolderTypeEnum.DERI_STK_LTD_GEN.type();
}
}
工厂类
/**
* @Author charles.yao
* @Description 股东类数据导入工厂类
* @Date 2022/4/22 10:39
*/
@Component
public class HolderImportFactory implements ApplicationContextAware {
public Map<Integer, HolderImportInterface> holderImportMap = new ConcurrentHashMap<>();
@Override
public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
//根据接口类型返回相应的所有bean
Map<String, HolderImportInterface> map = applicationContext.getBeansOfType(HolderImportInterface.class);
for (Map.Entry<String, HolderImportInterface> data : map.entrySet()) {
Integer keyType = data.getValue().getType();
holderImportMap.put(keyType, data.getValue());
}
}
/**
* 获取股东导入service
*
* @param type
* @return
*/
public HolderImportInterface getHolderImport(Integer type) {
HolderImportInterface holderImportInterface = holderImportMap.get(type);
if (ObjectUtil.isNotNull(holderImportInterface)) {
return holderImportInterface;
} else {
return null;
}
}
}