工厂模式

最新推荐文章于 2021-02-26 16:34:09 发布

今天你学习了么

最新推荐文章于 2021-02-26 16:34:09 发布

阅读量177

点赞数

分类专栏： Java设计模式

本文链接：https://blog.csdn.net/weixin_43907800/article/details/104783123

版权

Java设计模式专栏收录该内容

21 篇文章 0 订阅

订阅专栏

JAVA设计模式之工厂模式(简单工厂模式+工厂方法模式)
JAVA设计模式之抽象工厂模式

1. 概念

在面向对象编程中, 最通常的方法是一个new操作符产生一个对象实例,new操作符就是用来构造对象实例的。

但是在一些情况下, new操作符直接生成对象会带来一些问题。举例来说, 许多类型对象的创造需要一系列的步骤: 你可能需要计算或取得对象的初始设置; 选择生成哪个子对象实例; 或在生成你需要的对象之前必须先生成一些辅助功能的对象。在这些情况,新对象的建立就是一个 “过程”，不仅是一个操作，像一部大机器中的一个齿轮传动。

模式的问题： 你如何能轻松方便地构造对象实例，而不必关心构造对象实例的细节和复杂过程呢？

解决方案： 建立一个工厂来创建对象

2. 背景

1. 还没有工厂时代：假如还没有工业革命，如果一个客户要一款车,一般的做法是客户去创建一款车，然后拿来用
在这里插入图片描述

public class Benz{
	public Benz(){
		System.out.println("制造-->Benz");
	}
}
 
public class Bmw{
	public Bmw(){
		System.out.println("制造-->Bmw");
	}
}
 
public class Company{
	public static void main(String[] args) {
		Bmw bmw = new Bmw();
		Benz benz = new Benz();
	}
}

2. 简单工厂模式： 后来出现工业革命。用户不用去创建宝马车。因为客户有一个工厂来帮他创建宝马.想要什么车，这个工厂就可以建。比如想要320i系列车。工厂就创建这个系列的车。即工厂可以创建产品。

3. 工厂方法模式时代 ：为了满足客户，车的品牌越来越多，不仅有宝马还要奔驰。于是由单独分出来多个具体的工厂。每个具体工厂创建一种品牌。即具体工厂类只能创建一个具体品牌的汽车。但是汽车工厂还是个抽象。你需要指定某个具体的工厂才能生产车出来。

4. 抽象工厂模式时代： 随着时代的发展，对于宝马汽车工厂，他不仅仅生产小汽车，还生产suv了，可想而知宝马小汽车和宝马suv的生产流程肯定大不相同，所以这个时候我们的宝马工厂就不能仅仅有一个生产汽车的方法，还需要有生产suv的方法

这就是工厂模式

3. 简单工厂模式

可以看到没有工厂的时候，客户需要知道怎么去创建一款车,客户和车就紧密耦合在一起了.

为了降低耦合,就出现了工厂类，把创建宝马的操作细节都放到了工厂里面去，客户直接使用工厂的创建工厂方法，传入想要的宝马车型号就行了，而不必去知道创建的细节
这就是工业革命了：简单工厂模式
在这里插入图片描述
产品类

abstract class Car{
	public Car(){
		
	}
}
 
public class Bmw extends Car{
	public Bmw() {
		System.out.println("制造-->Bmw");
	}
}

public class Benz extends Car{
	public Benz(){
		System.out.println("制造-->Benz ");
	}
}

工厂类

public class Factory {
	public Car createCar(String type) {
		switch (type) {
		
		case "bmw":
			return new Bmw();
 
		case "benz":
			return new Benz ();
 
		default:
			break;
		}
		return null;
	}
}

客户类：

public class Company{
	public void dealOrder() {
		Factory factory = new Factory();
		BMW bmw320 = factory.createCar("bmw");
		BMW bmw523 = factory.createBMW("benz");
	}
}

简单工厂模式又称静态工厂方法模式。从命名上就可以看出这个模式一定很简单。它存在的目的很简单：定义一个用于创建对象的方法

看看它的组成：

工厂类角色： 这是本模式的核心，含有一定的商业逻辑和判断逻辑，用来创建产品
抽象产品角色： 它一般是具体产品继承的父类或者实现的接口。
具体产品角色： 工厂类所创建的对象就是此角色的实例。在java中由一个具体类实现。

下面我们从开闭原则（对扩展开放；对修改封闭）上来分析下简单工厂模式。

当客户不再满足现有的车型号的时候，想要一种速度快的新型车，只要这种车符合抽象产品制定的合同，那么只要通知工厂类知道就可以被客户使用了。所以对产品部分来说，它是符合开闭原则的；

但是工厂部分好像不太理想，因为每增加一种新型车，都要在工厂类中增加相应的创建业务逻辑（createCar(String type)方法需要新增case），这显然是违背开闭原则的。可想而知对于新产品的加入，工厂类是很被动的。对于这样的工厂类，我们称它为全能类或者上帝类。

我们举的例子是最简单的情况，而在实际应用中，很可能产品是一个多层次的树状结构。由于简单工厂模式中只有一个工厂类来对应这些产品，所以这可能会把我们的上帝累坏了，也累坏了我们这些程序员。

于是工厂方法模式作为救世主出现了。工厂类定义成了接口,而每新增的车种类型,就增加该车种类型对应工厂类的实现,这样工厂的设计就可以扩展了,而不必去修改原来的代码。

4. 工厂方法模式

定义了一个创建对象的抽象方法，由子类决定要实例化的类，达到了将对象创造过程封装的目的，工厂方法模式把对象的实例化推迟到了子类

1. 抽象工厂角色： 这是工厂方法模式的核心，它与应用程序无关。是具体工厂角色必须实现的接口或者必须继承的父类。在java中它由抽象类或者接口来实现。

2. 具体工厂角色： 它含有和具体业务逻辑有关的代码。由应用程序调用以创建对应的具体产品的对象。

3. 抽象产品角色： 它是具体产品继承的父类或者是实现的接口。在java中一般有抽象类或者接口来实现。

4. 具体产品角色： 具体工厂角色所创建的对象就是此角色的实例。在java中由具体的类来实现。

工厂方法模式使用继承自抽象工厂角色的多个子类来代替简单工厂模式中的“上帝类”。正如上面所说，这样便分担了对象承受的压力；而且这样使得结构变得灵活起来——当有新的产品产生时，只要按照抽象产品角色、抽象工厂角色提供的合同来生成，那么就可以被客户使用，而不必去修改任何已有的代码。可以看出工厂角色的结构也是符合开闭原则的！
在这里插入图片描述

产品类

public abstract class Car {

}

public class Benz extends Car {

    public Benz() {
        //create
    }

    @Override
    public String toString() {
        return "Benz";
    }
}

public class Bmw extends Car {

    public Bmw() {
       //create
    }

    @Override
    public String toString() {
        return "Bmw";
    }
}

创建工厂类

public interface IFactory {
    Car createCar();
}
public class BenzFactory implements IFactory {

    public Car createCar() {
        return new Benz();
    }
}

public class BmwFactory implements IFactory {
    public Car createCar() {
        return new Bmw();
    }
}

客户类：

public class Company {
    public static void dealOrder(){
        Map<String, IFactory> factoryMap = new HashMap<String, IFactory>();
        factoryMap.put("benz", new BenzFactory());
        factoryMap.put("bmw",new BmwFactory());
        List<Car> list= new ArrayList<Car>();
        Scanner input = null;
        try {
            input = new Scanner(new FileInputStream(new File("order.txt")));
            while (input.hasNext()){
                String typeToCreate = input.next();
                IFactory factory = factoryMap.get(typeToCreate);
                System.out.println(typeToCreate);
                list.add(factory.createCar());
            }
        }catch (IOException e){
            e.printStackTrace();
        }finally {
            input.close();
        }

        for (Car car : list) {
            System.out.println(car);
        }
    }
}

订单文件内容

benz
bmw
benz
benz
bmw
bmw
benz
benz
bmw
bmw

可以看到对应于不同的品牌的汽车有不同的工厂来进行生产，我们只需要相对应的工厂就能进行生产，注意在Company 类中，我们把汽车的品牌和起对于的工厂建立了一个映射关系，存在map中，这样就可以取得相对应的工厂，而对于car抽象类和ifactory接口，在company中只依赖这两个接口而不依赖于具体的实现类，具体的实现类是在运行的过程使用多态绑定的

如果新加入一个品牌的汽车，我们需要实现IFactory接口实现一个新的创建该汽车的工厂，对于Company中生产汽车的核心代码我们实际上不需要修改，因为我们在company中并不依赖与car和factory的具体实现类，而是依赖于car的抽象类和IFactory的抽象工厂，所以能做到对修改封闭对扩展开放

至于Company中的汽车和工厂的映射map，虽然看起来需要修改，不符合开闭原则，但是这一部分可以通过读取配置文件的方式，通过反射创建具体工厂类，创建map，如下所示

xml配置文件

<?xml version="1.0" encoding="GB2312"?>
<Factroy>
    <Node>　　
        <carName>benz</carName>　　
        <factoryClass>com.minifull.methodFactory.factory.BenzFactory</factoryClass>
    </Node>
    <Node>　　
        <carName>bmw</carName>　　
        <factoryClass>com.minifull.methodFactory.factory.BmwFactory</factoryClass>
    </Node>


</Factroy>

改进的company

public class Company {
    public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException, InstantiationException {
        Map<String, IFactory> factoryMap = new HashMap<String, IFactory>();
//        factoryMap.put("benz", new BenzFactory());
//        factoryMap.put("bmw",new BmwFactory());

        try {
            //dom4j读取配置文件
            File file = new File("D:\\ideaProject\\Pro_Factroy\\src\\main\\resources\\factory.xml");
            SAXReader reader = new SAXReader();
            Document document = reader.read(file);
            Element root = document.getRootElement();
            Element node;
            for (Iterator i = root.elementIterator("Node");i.hasNext();) {
                node = (Element) i.next();
                System.out.println(node.elementText("factoryClass"));
                //通过反射创建工厂
                Class<?> factoryClass = Class.forName(node.elementText("factoryClass"));
                IFactory factory = (IFactory)factoryClass.newInstance();
                System.out.println(factory);
                //加入map
                System.out.println(node.elementText("carName"));
                factoryMap.put(node.elementText("carName"),factory);
            }
        } catch (DocumentException e) {
            e.printStackTrace();
        }
        List<Car> list= new ArrayList<Car>();
        Scanner input = null;
        try {
            input = new Scanner(new FileInputStream(new File("D:\\学业为重\\作业\\设计模式\\实验2\\order.txt")));
            while (input.hasNext()){
                String typeToCreate = input.next();
                IFactory factory = factoryMap.get(typeToCreate);
                System.out.println(typeToCreate);
                list.add(factory.createCar());
            }
        }catch (IOException e){
            e.printStackTrace();
        }finally {
            input.close();
        }

        for (Car car : list) {
            System.out.println(car);
        }
    }
}

这样以后修改只需要修改配置文件，依旧遵守开闭原则

工厂方法模式仿佛已经很完美的对对象的创建进行了包装，使得客户程序中仅仅处理抽象产品角色提供的接口，但使得对象的数量成倍增长。当产品种类非常多时，会出现大量的与之对应的工厂对象，这不是我们所希望的。

6. 抽象工厂方法

6.1 背景

随着时代的发展，对于宝马汽车工厂，他不仅仅生产小汽车，还生产suv了，可想而知宝马小汽车和宝马suv的生产流程肯定大不相同，所以这个时候我们的宝马工厂就不能仅仅有一个生产汽车的方法，还需要有生产suv的方法

6.2 概念

抽象工厂模式是工厂方法模式的升级版本，他用来创建一组相关或者相互依赖的对象。比如宝马汽车和suv，相当于工厂方法模式增加了一个维度

在这里插入图片描述
但是我们每次增加一个产品系列，都要打开IFactory新增方法，所以并没有严格的遵守开闭原则，只有在产品的设计的确不止一个维度才使用

今天你学习了么

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
工厂模式

JAVA设计模式之工厂模式(简单工厂模式+工厂方法模式)JAVA设计模式之抽象工厂模式1. 概念在面向对象编程中, 最通常的方法是一个new操作符产生一个对象实例,new操作符就是用来构造对象实例的。但是在一些情况下, new操作符直接生成对象会带来一些问题。举例来说, 许多类型对象的创造需要一系列的步骤: 你可能需要计算或取得对象的初始设置; 选择生成哪个子对象实例; 或在生成你需要的对...
复制链接

扫一扫