工厂模式介绍

工厂模式是我们最常用的实例化对象模式了，是用工厂方法代替new操作的一种模式。它是创建型模式。

简单工厂

简单工厂模式是指由一个工厂对象决定创建出哪一种产品类的实例, 但它不属于GOF 23种设计模式

简单工厂适用于工厂类负责创建的对象较少的场景, 且客户端只需要传入工厂类的参数, 对于如何创建对象的逻辑不需要关心

适用场景: 工厂类负责创建的对象较少 对于如何创建对象的逻辑不需要关心

优点: 只需要传入一个正确的参数 就可以获取所需要的对象 无需知道创建细节

缺点: 违背开闭原则 不易于扩展过于复杂的产品结构 新增产品需要修改工厂类的代码

以下我们用支付场景演示简单工厂用法

1.定义支付接口

/*** 支付接口** @author Lion Li*/
public interface IPay {void payment();
}

2.编写工厂实例

/*** 付款方式工厂** @author Lion Li*/
public class PayFactory {/*** 创建付款实例* Class<? extends IPay> 单一原则 限制必须是 IPay 的子类*/public IPay create(Class<? extends IPay> clazz) {if (null != clazz) {try {return clazz.newInstance();} catch (Exception e) {throw new RuntimeException(e);}}return null;}}

3.编写具体的支付类 例如: 微信 支付宝

/*** 微信支付** @author Lion Li*/
public class WxPay implements IPay {public void payment() {System.out.println("微信支付");}
}
/*** 支付宝支付** @author Lion Li*/
public class ZfbPay implements IPay {public void payment() {System.out.println("支付宝支付");}
}

4.编写测试类并运行测试

/*** @author Lion Li*/
public class Test {public static void main(String[] args) {IPay wx = new PayFactory().create(WxPay.class);IPay zfb = new PayFactory().create(ZfbPay.class);wx.payment();zfb.payment();}
}

工厂方法模式

工厂方法模式是指定义一个创建对象的接口, 但让实现这个接口的类来觉得实例化哪个类, 工厂方法让类的实例化推迟到子类中进行

适用场景: 创建对象需要大量重复的代码 不依赖于产品类实例如何被创建 实现等细节

优点: 用户只需要关心所需要产品对应的工厂 无需关心创建细节 加入新产品符合开闭原则 提供了系统的可扩展性

缺点: 类的个数容易过多 增加的代码的结构负责都 增加了系统的抽象性和理解难度

以下我们用汽车场景工厂方法模式用法

1.定义汽车接口规范

/*** 汽车接口规范** @author Lion Li*/
public interface ICar {void name();
}

2.编写汽车工厂接口规范

/*** 汽车工厂接口规范** @author Lion Li*/
public interface ICarFactory {ICar create();
}

3.编写具体的汽车种类 例如: 宝马 大众

/*** 宝马汽车** @author Lion Li*/
public class BaoMaCar implements ICar {public void name() {System.out.println("我是宝马");}
}
/*** 大众汽车** @author Lion Li*/
public class DaZhongCar implements ICar {public void name() {System.out.println("我是大众");}
}

4.编写具体的汽车工厂 例如: 宝马工厂 大众工厂

/*** 宝马汽车工厂** @author Lion Li*/
public class BaoMaCarFactory implements ICarFactory {public ICar create() {return new BaoMaCar();}
}
/*** 大众汽车工厂** @author Lion Li*/
public class DaZhongCarFactory implements ICarFactory {public ICar create() {return new DaZhongCar();}
}

5.编写测试类并运行测试

/*** @author Lion Li*/
public class Test {public static void main(String[] args){ICarFactory baomaFactory = new BaoMaCarFactory();ICar baoma = baomaFactory.create();baoma.name();ICarFactory dazhongFactory = new DaZhongCarFactory();ICar dazhong = dazhongFactory.create();dazhong.name();}}

抽象工厂

抽象工厂模式是指提供一个创建一系列相关或相互依赖对象的接口 无需指定他们具体的类

适用场景:

1. 不依赖于产品类实例如何被创建等细节 强调一系列相关产品对象一起使用创建对象需要大量重复的代码
2. 提供一个产品类的库 所有产品以同样的接口出现 从而不依赖于具体的实现

优点: 具体产品在应用层代码隔离 无需关心创建细节 将一个系列的产品统一到一起创建

缺点: 规定了所有可能被创建的产品集合 产品中扩展新产品困难 需要修改抽象工厂的接口 增加了系统的理解难度和抽象性

以下我们用多种出行方式来演示抽象工厂用法

1.定义产品接口规范

/*** 汽车接口规范** @author Lion Li*/
public interface ICar {void name();
}
/*** 飞机接口规范** @author Lion Li*/
public interface IAircraft {void name();
}

2.定义产品工厂接口规范

/*** 汽车工厂接口规范** @author Lion Li*/
public interface ICarFactory {ICar create();
}
/*** 飞机工厂接口规范** @author Lion Li*/
public interface IAircraftFactory {IAircraft create();
}

3.定义所有产品实现

/*** 宝马汽车** @author Lion Li*/
public class BaoMaCar implements ICar {public void name() {System.out.println("我是宝马");}
}
/*** 大众汽车** @author Lion Li*/
public class DaZhongCar implements ICar {public void name() {System.out.println("我是大众");}
}
/*** 波音飞机** @author Lion Li*/
public class BoYinAircraft implements IAircraft {public void name() {System.out.println("我是波音");}
}
/*** 空客飞机** @author Lion Li*/
public class KongKeAircraft implements IAircraft {public void name() {System.out.println("我是空客");}
}

4.定义所有产品工厂实现

/*** 宝马汽车工厂** @author Lion Li*/
public class BaoMaCarFactory implements ICarFactory {public ICar create() {return new BaoMaCar();}
}
/*** 大众汽车工厂** @author Lion Li*/
public class DaZhongCarFactory implements ICarFactory {public ICar create() {return new DaZhongCar();}
}
/*** 波音飞机工厂** @author Lion Li*/
public class BoYinAircraftFactory implements IAircraftFactory {public IAircraft create() {return new BoYinAircraft();}
}
/*** 空客飞机工厂** @author Lion Li*/
public class KongKeAircraftFactory implements IAircraftFactory {public IAircraft create() {return new KongKeAircraft();}
}

5.定义交通工具抽象工厂

/*** 交通工具抽象工厂** @author Lion Li*/
public abstract class TransportationFactory {public void init() {System.out.println("初始化数据");}protected abstract ICar createCar(Class<? extends ICarFactory> clazz);protected abstract IAircraft createAircraft(Class<? extends IAircraftFactory> clazz);
}

6.定义出行方式工厂

/*** 出行方式工厂** @author Lion Li*/
public class TravelFactory extends TransportationFactory {@Overrideprotected ICar createCar(Class<? extends ICarFactory> clazz) {super.init();if (null != clazz) {try {return clazz.newInstance().create();} catch (Exception e) {throw new RuntimeException(e);}}return null;}@Overrideprotected IAircraft createAircraft(Class<? extends IAircraftFactory> clazz) {super.init();if (null != clazz) {try {return clazz.newInstance().create();} catch (Exception e) {throw new RuntimeException(e);}}return null;}
}

7.编写测试类并运行测试

/*** @author Lion Li*/
public class Test {public static void main(String[] args){TransportationFactory factory = new TravelFactory();ICar baoma = factory.createCar(BaoMaCarFactory.class);baoma.name();ICar dazhong = factory.createCar(DaZhongCarFactory.class);dazhong.name();IAircraft boyin = factory.createAircraft(BoYinAircraftFactory.class);boyin.name();IAircraft kongke = factory.createAircraft(KongKeAircraftFactory.class);kongke.name();}}

Spring 工厂 BeanFactory 解析

这里由于网上已经有很多成熟的解析文档 就不多做介绍了

推荐文章链接: Spring 的工厂模式 BeanFactory 是什么源码刨析