• 极客专栏正式上线!欢迎访问 https://www.jikewenku.com/topic.html
  • 极客专栏正式上线!欢迎访问 https://www.jikewenku.com/topic.html

深入理解工厂模式

技术杂谈 勤劳的小蚂蚁 3个月前 (01-31) 68次浏览 已收录 0个评论 扫描二维码

一 工厂模式介绍

1.1 工厂模式的定义

先来看一下GOF为工厂模式的定义:
“Define an interface for creating an object, but let subclasses decide which class to instantiate. Factory Method lets a class defer instantiation to subclasses.”(在基类中定义创建对象的一个接口,让子类决定实例化哪个类。工厂方法让一个类的实例化延迟到子类中进行。)

1.2 工厂模式的分类:

(1)简单工厂(Simple Factory)模式,又称静态工厂方法模式(Static Factory Method Pattern)。
(2)工厂方法(Factory Method)模式,又称多态性工厂(Polymorphic Factory)模式或虚拟构造子(Virtual Constructor)模式;
(3)抽象工厂(Abstract Factory)模式,又称工具箱(Kit 或Toolkit)模式。

1.3 在开源框架中的使用

举两个比较常见的例子(我暂时可以准确想到的,当然还有很多很多):
(1)Spring中通过getBean(“xxx”)获取Bean;
(2) Java消息服务JMS中(下面以消息队列ActiveMQ为例子)
  1.     // 1、创建一个连接工厂对象,需要指定服务的ip及端口。
  2.    ConnectionFactory connectionFactory =newActiveMQConnectionFactory("tcp://192.168.25.155:61616");
  3.        // 2、使用工厂对象创建一个Connection对象。
  4.        Connection connection = connectionFactory.createConnection();

1.4 为什么要用工厂模式

(1) 解耦 :把对象的创建和使用的过程分开
(2)降低代码重复: 如果创建某个对象的过程都很复杂,需要一定的代码量,而且很多地方都要用到,那么就会有很多的重复代码。
(3) 降低维护成本 :由于创建过程都由工厂统一管理,所以发生业务逻辑变化,不需要找到所有需要创建某个对象的地方去逐个修正,只需要在工厂里修改即可,降低维护成本。
关于工厂模式的作用,Mark一篇文章:https://blog.csdn.net/lovelion/article/details/7523392

二 简单工厂模式

2.1 介绍

严格的说,简单工厂模式并不是23种常用的设计模式之一,它只算工厂模式的一个特殊实现。简单工厂模式在实际中的应用相对于其他2个工厂模式用的还是相对少得多,因为它只适应很多简单的情况。
最重要的是它违背了我们在概述中说的 开放-封闭原则 (虽然可以通过反射的机制来避免,后面我们会介绍到) 。因为每次你要新添加一个功能,都需要在生switch-case 语句(或者if-else 语句)中去修改代码,添加分支条件。

2.2 适用场景

(1)需要创建的对象较少。
(2)客户端不关心对象的创建过程。

2.3 简单工厂模式角色分配:

  1. 工厂(Factory)角色 :简单工厂模式的核心,它负责实现创建所有实例的内部逻辑。工厂类可以被外界直接调用,创建所需的产品对象。
  2. 抽象产品(Product)角色 :简单工厂模式所创建的所有对象的父类,它负责描述所有实例所共有的公共接口。
  3. 具体产品(Concrete Product)角色:简单工厂模式的创建目标,所有创建的对象都是充当这个角色的某个具体类的实例。

2.4 简单工厂实例

创建一个可以绘制不同形状的绘图工具,可以绘制圆形,正方形,三角形,每个图形都会有一个draw()方法用于绘图.
(1)创建Shape接口
  1. publicinterfaceShape{
  2.    void draw();
  3. }
(2)创建实现该接口的具体图形类
圆形
  1. publicclassCircleimplementsShape{
  2.    publicCircle(){
  3.        System.out.println("Circle");
  4.    }
  5.    @Override
  6.    publicvoid draw(){
  7.        System.out.println("Draw Circle");
  8.    }
  9. }
长方形
  1. publicclassRectangleimplementsShape{
  2.    publicRectangle(){
  3.        System.out.println("Rectangle");
  4.    }
  5.    @Override
  6.    publicvoid draw(){
  7.        System.out.println("Draw Rectangle");
  8.    }
  9. }
正方形
  1. publicclassSquareimplementsShape{
  2.    publicSquare(){
  3.        System.out.println("Square");
  4.    }
  5.    @Override
  6.    publicvoid draw(){
  7.        System.out.println("Draw Square");
  8.    }
  9. }
(3)创建工厂类:
  1. publicclassShapeFactory{
  2.    // 使用 getShape 方法获取形状类型的对象
  3.    publicstaticShape getShape(String shapeType){
  4.        if(shapeType ==null){
  5.            returnnull;
  6.        }
  7.        if(shapeType.equalsIgnoreCase("CIRCLE")){
  8.            returnnewCircle();
  9.        }elseif(shapeType.equalsIgnoreCase("RECTANGLE")){
  10.            returnnewRectangle();
  11.        }elseif(shapeType.equalsIgnoreCase("SQUARE")){
  12.            returnnewSquare();
  13.        }
  14.        returnnull;
  15.    }
  16. }
(4)测试方法:
  1. publicclassTest{
  2.    publicstaticvoid main(String[] args){
  3.        // 获取 Circle 的对象,并调用它的 draw 方法
  4.        Shape circle =ShapeFactory.getShape("CIRCLE");
  5.        circle.draw();
  6.        // 获取 Rectangle 的对象,并调用它的 draw 方法
  7.        Shape rectangle =ShapeFactory.getShape("RECTANGLE");
  8.        rectangle.draw();
  9.        // 获取 Square 的对象,并调用它的 draw 方法
  10.        Shape square =ShapeFactory.getShape("SQUARE");
  11.        square.draw();
  12.    }
  13. }
输出结果:
  1. Circle
  2. DrawCircle
  3. Rectangle
  4. DrawRectangle
  5. Square
  6. DrawSquare
这样的实现有个问题,如果我们新增产品类的话,就需要修改工厂类中的getShape()方法,这很明显不符合 开放-封闭原则

2.5 使用反射机制改善简单工厂

将工厂类改为下面的形式:
  1. package factory_pattern;
  2. /**
  3. * 利用反射解决简单工厂每次增加新了产品类都要修改产品工厂的弊端
  4. *
  5. * @author Administrator
  6. *
  7. */
  8. publicclassShapeFactory2{
  9.    publicstaticObject getClass(Class<?extendsShape> clazz){
  10.        Object obj =null;
  11.        try{
  12.            obj =Class.forName(clazz.getName()).newInstance();
  13.        }catch(ClassNotFoundException e){
  14.            e.printStackTrace();
  15.        }catch(InstantiationException e){
  16.            e.printStackTrace();
  17.        }catch(IllegalAccessException e){
  18.            e.printStackTrace();
  19.        }
  20.        return obj;
  21.    }
  22. }
测试方法:
  1. package factory_pattern;
  2. publicclassTest2{
  3.    publicstaticvoid main(String[] args){
  4.        Circle circle =(Circle)ShapeFactory2.getClass(factory_pattern.Circle.class);
  5.        circle.draw();
  6.        Rectangle rectangle =(Rectangle)ShapeFactory2.getClass(factory_pattern.Rectangle.class);
  7.        rectangle.draw();
  8.        Square square =(Square)ShapeFactory2.getClass(factory_pattern.Square.class);
  9.        square.draw();
  10.    }
  11. }
这种方式的虽然符合了 开放-关闭原则 ,但是每一次传入的都是产品类的全部路径,这样比较麻烦。如果需要改善的话可以通过 反射+配置文件 的形式来改善,这种方式使用的也是比较多的。

3 工厂方法模式

3.1 介绍

工厂方法模式应该是在工厂模式家族中是用的最多模式,一般项目中存在最多的就是这个模式。
工厂方法模式是简单工厂的仅一步深化, 在工厂方法模式中,我们不再提供一个统一的工厂类来创建所有的对象,而是针对不同的对象提供不同的工厂。也就是说 每个对象都有一个与之对应的工厂

3.2 适用场景

  • 一个类不知道它所需要的对象的类:在工厂方法模式中,客户端不需要知道具体产品类的类名,只需要知道所对应的工厂即可,具体的产品对象由具体工厂类创建;客户端需要知道创建具体产品的工厂类。
  • 一个类通过其子类来指定创建哪个对象:在工厂方法模式中,对于抽象工厂类只需要提供一个创建产品的接口,而由其子类来确定具体要创建的对象,利用面向对象的多态性和里氏
  • 将创建对象的任务委托给多个工厂子类中的某一个,客户端在使用时可以无需关心是哪一个工厂子类创建产品子类,需要时再动态指定,可将具体工厂类的类名存储在配置文件或数据库中。

3.3 工厂方法模式角色分配:

  1. 抽象工厂(Abstract Factory)角色:是工厂方法模式的核心,与应用程序无关。任何在模式中创建的对象的工厂类必须实现这个接口。
  2. 具体工厂(Concrete Factory)角色 :这是实现抽象工厂接口的具体工厂类,包含与应用程序密切相关的逻辑,并且受到应用程序调用以创建某一种产品对象。
  3. 抽象产品(AbstractProduct)角色 :工厂方法模式所创建的对象的超类型,也就是产品对象的共同父类或共同拥有的接口。
  4. 具体产品(Concrete Product)角色 :这个角色实现了抽象产品角色所定义的接口。某具体产品有专门的具体工厂创建,它们之间往往一一对应

3.4 工厂方法模式实例

上面简单工厂例子中的图形接口以及相关图像实现类不变。我们只需要增加一个工厂接口以及实现这个接口的工厂类即可。
(1)增加一个工厂接口:
  1. publicinterfaceFactory{
  2.    publicShape getShape();
  3. }
(2)增加相关工厂类:
圆形工厂类
  1. publicclassCircleFactoryimplementsFactory{
  2.    @Override
  3.    publicShape getShape(){
  4.        // TODO Auto-generated method stub
  5.        returnnewCircle();
  6.    }
  7. }
长方形工厂类
  1. publicclassRectangleFactoryimplementsFactory{
  2.    @Override
  3.    publicShape getShape(){
  4.        // TODO Auto-generated method stub
  5.        returnnewRectangle();
  6.    }
  7. }
圆形工厂类
  1. publicclassSquareFactoryimplementsFactory{
  2.    @Override
  3.    publicShape getShape(){
  4.        // TODO Auto-generated method stub
  5.        returnnewSquare();
  6.    }
  7. }
(3)测试:
  1. publicclassTest{
  2.    publicstaticvoid main(String[] args){
  3.        Factory circlefactory =newCircleFactory();
  4.        Shape circle = circlefactory.getShape();
  5.        circle.draw();
  6.    }
  7. }
输出结果:
  1. Circle
  2. DrawCircle

4 抽象工厂模式

4.1 介绍

在工厂方法模式中,其实我们有一个潜在意识的意识。那就是我们生产的都是同一类产品。抽象工厂模式是工厂方法的仅一步深化,在这个模式中的工厂类不单单可以创建一种产品,而是可以创建一组产品。
抽象工厂应该是比较最难理解的一个工厂模式了。

4.2 适用场景

  • 和工厂方法一样客户端不需要知道它所创建的对象的类。
  • 需要一组对象共同完成某种功能时,并且可能存在多组对象完成不同功能的情况。(同属于同一个产品族的产品)
  • 系统结构稳定,不会频繁的增加对象。(因为一旦增加就需要修改原有代码,不符合开闭原则)

4.3 抽象工厂方法模式角色分配:

  1. 抽象工厂(AbstractFactory)角色 :是工厂方法模式的核心,与应用程序无关。任何在模式中创建的对象的工厂类必须实现这个接口。
  2. 具体工厂类(ConreteFactory)角色 :这是实现抽象工厂接口的具体工厂类,包含与应用程序密切相关的逻辑,并且受到应用程序调用以创建某一种产品对象。
  3. 抽象产品(Abstract Product)角色 :工厂方法模式所创建的对象的超类型,也就是产品对象的共同父类或共同拥有的接口。
  4. 具体产品(Concrete Product)角色 :抽象工厂模式所创建的任何产品对象都是某一个具体产品类的实例。在抽象工厂中创建的产品属于同一产品族,这不同于工厂模式中的工厂只创建单一产品,我后面也会详解介绍到。

4.4 抽象工厂的工厂和工厂方法中的工厂有什么区别呢?

抽象工厂是生产一整套有产品的(至少要生产两个产品),这些产品必须相互是有关系或有依赖的,而工厂方法中的工厂是生产单一产品的工厂。

4.5 抽象工厂模式实例

不知道大家玩过穿越火线或者吃鸡这类游戏了吗,游戏中存在各种枪。我们假设现在存在AK、M4A1两类枪,每一种枪对应一种子弹。我们现在这样考虑生产AK的工厂可以顺便生产AK使用的子弹,生产M4A1的工厂可以顺便生产M4A1使用的子弹。(AK工厂生产AK系列产品包括子弹啊,AK枪的类型啊这些,M4A1工厂同理)
(1)创建相关接口:
  1. publicinterfaceGun{
  2.    publicvoid shooting();
  3. }
子弹
  1. publicinterfaceBullet{
  2.    publicvoid load();
  3. }
(2)创建接口对应实现类:
AK类
  1. publicclass AK implementsGun{
  2.    @Override
  3.    publicvoid shooting(){
  4.        System.out.println("shooting with AK");
  5.    }
  6. }
M4A1类
  1. publicclass M4A1 implementsGun{
  2.    @Override
  3.    publicvoid shooting(){
  4.        System.out.println("shooting with M4A1");
  5.    }
  6. }
AK子弹类
  1. publicclass AK_Bullet implementsBullet{
  2.    @Override
  3.    publicvoid load(){
  4.        System.out.println("Load bullets with AK");
  5.    }
  6. }
M4A1子弹类
  1. publicclass M4A1
  2. _BulletimplementsBullet{
  3.    @Override
  4.    publicvoid load(){
  5.        System.out.println("Load bullets with M4A1");
  6.    }
  7. }
(3)创建工厂接口
  1. publicinterfaceFactory{
  2.    publicGun produceGun();
  3.    publicBullet produceBullet();
  4. }
(4)创建具体工厂
生产AK和AK子弹的工厂
  1. publicclass AK_Factory implementsFactory{
  2.    @Override
  3.    publicGun produceGun(){
  4.        returnnew AK();
  5.    }
  6.    @Override
  7.    publicBullet produceBullet(){
  8.        returnnew AK_Bullet();
  9.    }
  10. }
生产M4A1和M4A1子弹的工厂
  1. publicclass M4A1_Factory implementsFactory{
  2.    @Override
  3.    publicGun produceGun(){
  4.        returnnew M4A1();
  5.    }
  6.    @Override
  7.    publicBullet produceBullet(){
  8.        returnnew M4A1_Bullet();
  9.    }
  10. }
(5)测试
  1. publicclassTest{
  2.    publicstaticvoid main(String[] args){  
  3.     Factory factory;
  4.     Gun gun;
  5.     Bullet bullet;
  6.     factory =new AK_Factory();
  7.     bullet=factory.produceBullet();
  8.     bullet.load();
  9.     gun=factory.produceGun();
  10.     gun.shooting();
  11.    }
  12. }
输出结果:
  1. Load bullets with AK
  2. shooting with AK

丨极客文库, 版权所有丨如未注明 , 均为原创丨
本网站采用知识共享署名-非商业性使用-相同方式共享 3.0 中国大陆许可协议进行授权
转载请注明原文链接:深入理解工厂模式
喜欢 (0)
[247507792@qq.com]
分享 (0)
勤劳的小蚂蚁
关于作者:
温馨提示:本文来源于网络,转载文章皆标明了出处,如果您发现侵权文章,请及时向站长反馈删除。

您必须 登录 才能发表评论!

  • 精品技术教程
  • 编程资源分享
  • 问答交流社区
  • 极客文库知识库

客服QQ


QQ:2248886839


工作时间:09:00-23:00