设计模式(二)-------------- 工厂模式

这篇博客我想来说一下关于工厂模式的一些知识，工厂模式在Spring框架中运用是十分广泛的。由于Spring的控制反转思想，使得我们的一些bean都交由BeanFactory统一进行管理。

那么今天我就来讲述一下关于工厂模式的一些知识，下方是视频连接

https://www.bilibili.com/video/av29579073/?p=4

https://www.bilibili.com/video/av29579073/?p=5

https://www.bilibili.com/video/av29579073/?p=6

首先来讲述一下工厂模式的概念，在工厂模式中，我们在创建对象时不会对客户端暴露创建逻辑，并且是通过使用一个共同的接口来指向新创建的对象。这句话的意思就是创建实体对象的过程对用户来说是透明的，用户只需要调用一些接口方法和相应的实现类即可完成实例对象的创建。

工厂方法的应用还是比较多的，比如在springboot中关于数据源的选择，用户只需要输入数据源连接，用户名，密码，以及驱动。springboot就可以自动进行数据源的匹配了。总之，工厂模式就是让不同的子类在不同的条件下生成不同的产品，而暴露给用户的则是统一的接口，所有的子类做的就是实现这个接口中的方法。

应用实例： 1、您需要一辆汽车，可以直接从工厂里面提货，而不用去管这辆汽车是怎么做出来的，以及这个汽车里面的具体实现。

目录

1.简单工厂模式实现

2.工厂方法

3.抽象工厂模式

---

1.简单工厂模式实现

就以汽车的建造为例，在之前我们需要创建汽车时我们都是通过直接去实例化汽车对象的。但是简单工厂方法则是通过工厂方法来获取汽车对象的。

先来看一下我们之前是怎么实现获取一个汽车对象的。

声明一个汽车接口，它有一个run方法。

public interface Car {
	void run();
}

接下来是两个实现类

public class Byd implements Car {

	@Override
	public void run() {
		System.out.println("比亚迪再跑！");
	}

}

public class Audi implements Car {

	@Override
	public void run() {
		System.out.println("奥迪再跑！");
	}

}

测试方法如下：

public class Client01 {   //调用者
	
	public static void main(String[] args) {
		Car c1 = new Audi();
		Car c2 = new Byd();
		
		c1.run();
		c2.run();
		
	}
}

那么简单工厂实际上就是将创建对象的过程交由一个工厂类进行统一的托管，实现方法有一下两种。

public class CarFactory {
	
	public static  Car createCar(String type){
		if("奥迪".equals(type)){
			return new Audi();
		}else if("比亚迪".equals(type)){
			return new Byd();
		}else{
			return null;
		}
	}
	
}

public class CarFactory2 {
	
	public static  Car createAudi(){
		return new Audi();
	}
	public static  Car createByd(){
		return new Byd();
	}
	
}

这两种方法大同小异，但是我们应该思考一个问题。如果我们需要添加新的车型的时候该怎么做呢，当然方法很简单，只要修改CarFactory的代码就可以了，但是这违反了面向对象设计的基本原则中的OCP原则。

– OCP（开闭原则，Open-Closed Principle）：一个软件的实体应当对扩展开 放，对修改关闭。那么改进方法就是接下来要介绍的工厂方法实现了

2.工厂方法

工厂方法模式要点：

– 为了避免简单工厂模式的缺点，不完全满足OCP。

– 工厂方法模式和简单工厂模式最大的不同在于，简单工厂模式只有一个（对于一个项目 或者一个独立模块而言）工厂类，而工厂方法模式有一组实现了相同接口的工厂类。

可以看到，工厂方法实际上包括的是实现了相同接口的类组。

那么还以上面的车型举例。

我为不同的车型声明不同的工厂。

public class AudiFactory implements CarFactory {

	@Override
	public Car createCar() {
		return new Audi();
	}

}

public class BenzFactory implements CarFactory {

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

}

public class BydFactory implements CarFactory {

	@Override
	public Car createCar() {
		return new Byd();
	}

}

在调用的时候只需要根据不同的工厂就可以声明相应的对象了。

public class Client {
	public static void main(String[] args) {
		Car c1 = new AudiFactory().createCar();
		Car c2 = new BydFactory().createCar();
		
		c1.run();
		c2.run();
	}
}

讲到这里，实际上工厂方法的使用还是把创建对象的决定权交给子类去实现，也就是由子类决定使用哪一个工厂创建系统所需要的对象。

接下来我要说的就是抽象工厂模式，它会更为复杂。

3.抽象工厂模式

首先来解释一下抽象工厂模式，它是围绕一个超级工厂创建其他工厂。该超级工厂又称为其他工厂的工厂。换句话说，如果我们要生产的产品包含了一个产品族，也就是说它是由许多细小的部分组成的。就像汽车是由引擎，座椅，轮胎等等构成的，不同档次的汽车对应的引擎，座椅，轮胎的型号，质量也是不同的。

看到了抽象工厂模式我才明白了这样设计的原因是为了将对象的创建进行分离和托管，这样可以使对象的构造更加清晰，增强代码的复用性。

我用代码对这个设计模式进行讲解。

public interface CarFactory {
	Engine createEngine();
	Seat createSeat();
	Tyre createTyre();
}

可以看到CarFactory已经不是简单的生产一辆汽车了，而是要生产汽车的许多零件。

三个产品的类如下

public interface Engine {
	void run();
	void start();
}


class LuxuryEngine implements Engine{

	@Override
	public void run() {
		System.out.println("转的快！");
	}

	@Override
	public void start() {
		System.out.println("启动快!可以自动启停！");
	}
	
}

class LowEngine implements Engine{
	
	@Override
	public void run() {
		System.out.println("转的慢！");
	}
	
	@Override
	public void start() {
		System.out.println("启动慢!");
	}
	
}

public interface Seat {
	void massage();
}

class LuxurySeat implements Seat {

	@Override
	public void massage() {
		System.out.println("可以自动按摩！");
	}
	
}
class LowSeat implements Seat {

	@Override
	public void massage() {
		System.out.println("不能按摩！");
	}
	
}

 

public interface Tyre {
	void revolve();
}

class LuxuryTyre implements Tyre {

	@Override
	public void revolve() {
		System.out.println("旋转不磨损！");
	}
	
}

class LowTyre implements Tyre {

	@Override
	public void revolve() {
		System.out.println("旋转磨损快！");
	}
	
}

可以看到这三个都是接口，每个接口里面都对应了高低两个档次的产品。那么对应的也要有两种汽车的生产工厂。

public class LowCarFactory implements CarFactory {

	@Override
	public Engine createEngine() {
		return new LowEngine();
	}

	@Override
	public Seat createSeat() {
		return new LowSeat();
	}

	@Override
	public Tyre createTyre() {
		return new LowTyre();
	}


}

public class LuxuryCarFactory implements CarFactory {

	@Override
	public Engine createEngine() {
		return new LuxuryEngine();
	}

	@Override
	public Seat createSeat() {
		return new LuxurySeat();
	}

	@Override
	public Tyre createTyre() {
		return new LuxuryTyre();
	}


}

 可以看出和整个产品的生成变成了一个产品的部件生成，这就是抽象工厂设计模式

以上就是我对工厂模式的理解了，每天时间有限，所以篇幅不是很长的。