共计 3319 个字符，预计需要花费 9 分钟才能阅读完成。
什么是工厂模式
大家在开发中应该都应用过或者看到过 SqlSessionFactory 或者 BeanFactory，这就是应用工厂模式来生产对象。工厂模式用于封装和治理对象的创立，拆散对象的创建者和调用者，实现与对象解耦的目标。
工厂模式能够分为：
- 简略工厂
- 工厂办法
- 形象工厂
实现形式
简略工厂
简略工厂通过接管的参数的不同来返回不同的对象实例，波及到的角色有：
- 形象产品
- 具体产品
- 具体工厂
- 调用者
代码如下：
// 形象产品
public interface Car {void run();
}
// 具体产品 1
public class Audi implements Car {
@Override
public void run() {System.out.println("audi run");
}
}
// 具体产品 2
public class Benz implements Car{
@Override
public void run() {System.out.println("benz run");
}
}
// 具体工厂，用于生成产品
public class SimpleFactory {
// 形式 1，依据传入的参数生成对应的产品对象
public static Car getCar(String type){if ("audi".equals(type)){return new Audi();
} else if ("benz".equals(type)){return new Benz();
} else {return null;}
}
// 形式 2，间接调用生成对应的产品对象的办法
public static Car getAudi(){return new Audi();
}
public static Car getBenz(){return new Benz();
}
}
// 调用者
public class SimpleFactoryTest {public static void main(String[] args) {
// 没有应用简略工厂，那么客户端就须要和接口 Car 以及其实现类打交道
// Car audi = new Audi();
// Car benz = new Benz();
// audi.run();
// benz.run();
// 应用简略工厂，形式 1
Car audi = SimpleFactory.getCar("audi");
Car benz = SimpleFactory.getCar("benz");
audi.run();
benz.run();
System.out.println("============");
// 应用简略工厂，形式 2
Car audi1 = SimpleFactory.getAudi();
Car benz1 = SimpleFactory.getBenz();
audi1.run();
benz1.run();}
}类图如下：
能够看到，如果再减少一种产品，则须要批改工厂类，故这种工厂模式实用于产品对象较少，且产品固定的需要。其实咱们在个别的我的项目中应用简略工厂就足够了。
工厂办法
为了防止简略工厂不满足开闭准则的毛病，减少产品而不须要去批改工厂类，能够应用工厂办法模式，减少产品的同时通过减少一个对应的工厂类来生产对应的产品，波及的角色有：
- 形象产品
- 具体产品
- 形象工厂
- 具体工厂
- 调用者
代码如下：
// 形象产品
public interface Car {void run();
}
// 具体产品 1
public class Audi implements Car {
@Override
public void run() {System.out.println("audi run");
}
}
// 具体产品 2
public class Benz implements Car {
@Override
public void run() {System.out.println("benz run");
}
}
// 形象工厂
public interface CarFactory {Car createCar();
}
// 具体工厂 1
public class AudiFactory implements CarFactory {
@Override
public Car createCar() {return new Audi();
}
}
// 具体工厂 2
public class BenzFactory implements CarFactory {
@Override
public Car createCar() {return new Benz();
}
}
// 调用者
public class FactoryMethodTest {public static void main(String[] args) {Car audi = new AudiFactory().createCar();
Car benz = new BenzFactory().createCar();
audi.run();
benz.run();}
}类图如下：
能够看到，如果新减少一种具体产品，就须要为其减少一个具体工厂类用于生产该产品。
形象工厂
形象工厂用于生产一族产品。波及的角色有：
- 形象产品
- 具体产品
- 形象工厂
- 具体工厂
- 调用者
代码如下：
// 形象产品 A
public interface Engine {void autoStart();
}
// 具体产品 A1
public class HighEngine implements Engine {
@Override
public void autoStart() {System.out.println("高端发动机有主动启停性能");
}
}
// 具体产品 A2
public class LowEngine implements Engine {
@Override
public void autoStart() {System.out.println("低端发动机没有主动启停性能");
}
}
// 形象产品 B
public interface Tyre {void monitor();
}
// 具体产品 B1
public class HighTyre implements Tyre {
@Override
public void monitor() {System.out.println("高端轮胎有胎压监控性能");
}
}
// 具体产品 B2
public class LowTyre implements Tyre {
@Override
public void monitor() {System.out.println("低端轮胎无监控胎压性能");
}
}
// 形象工厂
public interface CarFactory {Engine createEngine();
Tyre createTyre();}
// 具体工厂 A1B1
public class HighCarFactory implements CarFactory {
@Override
public HighEngine createEngine() {return new HighEngine();
}
@Override
public HighTyre createTyre() {return new HighTyre();
}
}
// 具体工厂 A2B2
public class LowCarFactory implements CarFactory {
@Override
public LowEngine createEngine() {return new LowEngine();
}
@Override
public LowTyre createTyre() {return new LowTyre();
}
}
// 调用者
public class AbstractFactoryTest {public static void main(String[] args) {CarFactory highCar = new HighCarFactory();
highCar.createEngine().autoStart();
highCar.createTyre().monitor();
}
}类图如下：
能够看到通过具体工厂 A1B1 和 A2B2 能够生产出不同的产品族，在产品固定的状况下，能够通过新增具体工厂类，来组合生成不同的产品族，比方 A1B2 或者 A2B1。然而如果要减少新的产品的话，比方减少产品 C，那就须要去批改形象工厂和具体工厂，就不适宜了。
欢送关注我的公众号，一起学习技术。
正文完
