工厂模式

 

工厂模式：

实现了创建者和调用者的分离。

详细分类：

简单工厂模式（静态工厂模式）

• 虽然某种程度不符合设计原则，但实际使用最多。

工厂方法模式

• 不修改已有类的前提下，通过增加新的工厂类实现扩展。

抽象工厂模式

• 不可以增加产品，可以增加产品族

 

面向对象设计的基本原则：

OCP（开闭原则，Open-Closed Principle）：一个软件的实体应当对扩展开放，对修改关闭。

DIP（依赖倒转原则，Dependence Inversion Principle）：要针对接口编程，不要针对实现编程。

LOD（迪米特法则，Law of Demeter）：只与你直接的朋友通信，而避免和陌生人通信。

 

核心本质：

1. 实例化对象，用工厂方法代替new操作。
2. 将选择实现类，创建对象统一管理和控制。从而将调用者跟我们的实现类解耦。

工厂模式：

• 简单工厂模式：用来生产同一等级结构中的任意产品。（对于增加新的产品，需要修改已有代码）
• 工厂方法模式：用来生产同一等级结构中的固定产品。（支持增加任意产品）
• 抽象工厂模式：用来生产不同产品族的全部产品。（对于增加新的产品，无能为力；支持增加产品族）

 

需要使用的类和接口

package com.kevin.创建型模式.工厂模式.simplefactory;/*** @author kevin* @version 1.0* @description     实现的接口类* @createDate 2019/2/17*/
public interface Car {void run();
}

package com.kevin.创建型模式.工厂模式.simplefactory;/*** @author kevin* @version 1.0* @description* @createDate 2019/2/17*/
public class Audi implements Car {@Overridepublic void run() {System.out.println("奥迪行驶中");}
}

package com.kevin.创建型模式.工厂模式.simplefactory;/*** @author kevin* @version 1.0* @description* @createDate 2019/2/17*/
public class Byd implements Car {@Overridepublic void run() {System.out.println("比亚迪行驶中");}
}

不使用简单工厂的情况

package com.kevin.创建型模式.工厂模式.simplefactory;/*** @author kevin* @version 1.0* @description     测试未使用工厂模式* @createDate 2019/2/17*/
public class Test {public static void main(String[] args) {// 普通创建方式，需要选择调用哪个类Car c1 = new Audi();Car c2 = new Byd();c1.run();c2.run();}
}

UML类图

问题：调用方需要知道创建哪个类？比较麻烦

 

使用简单工厂模式

package com.kevin.创建型模式.工厂模式.simplefactory;/*** @author kevin* @version 1.0* @description     简单工厂模式* 1.简单工厂模式也叫做静态工厂模式，就是工厂类一般使用静态方法，通过接收的参数的不同来返回不同的对象实例。* 2.对于增加新产品无能为力，不修改代码的话是无法扩展的。* @createDate 2019/2/17*/
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 static Car createAudi(){return new Audi();}public static Car createByd(){return new Byd();}}

package com.kevin.创建型模式.工厂模式.simplefactory;/*** @author kevin* @version 1.0* @description     测试工厂模式* @createDate 2019/2/17*/
public class Test {public static void main(String[] args) {// 简单工厂模式// 方式一：调用方便，不需要有调用方选择调用那个实例，只需要传入参数CarFactory.createCar("奥迪").run();CarFactory.createCar("比亚迪").run();//c3.run();// 方式二：CarFactory.createAudi().run();CarFactory.createByd().run();}
}

UML类图

注：

• 简单工厂模式也叫做静态工厂模式，就是工厂类一般使用静态方法，通过接收的参数的不同来返回不同的对象实例。
• 对于增加新产品无能为力，不修改代码的话是无法扩展的。

 

工厂方法模式

package com.kevin.创建型模式.工厂模式.factorymethod;/*** @author kevin* @version 1.0* @description     工厂方法模式* @createDate 2019/2/17*/
public interface CarFactory {Car createCar();
}

package com.kevin.创建型模式.工厂模式.factorymethod;/*** @author kevin* @version 1.0* @description* 为了避免简单工厂模式的缺点，不完全满足OCP。* 工厂方法模式和简单工厂模式最大的不同在于，简单工厂模式只有一个（对于一个项目或者一个独立模块而言）工厂类，* 而工厂方法模式有一组实现了相同接口的工厂类。* @createDate 2019/2/17*/
public class AudiFactory implements CarFactory{@Overridepublic Car createCar() {return new Audi();}
}

package com.kevin.创建型模式.工厂模式.factorymethod;/*** @author kevin* @version 1.0* @description* @createDate 2019/2/17*/
public class BydFactory implements CarFactory{@Overridepublic Car createCar() {return new Byd();}
}

package com.kevin.创建型模式.工厂模式.factorymethod;/*** @author kevin* @version 1.0* @description     测试工厂方法模式* @createDate 2019/2/17*/
public class Test {public static void main(String[] args) {Car c1 = new AudiFactory().createCar();Car c2 = new BydFactory().createCar();c1.run();c2.run();}
}

UML类图

注：

* 为了避免简单工厂模式的缺点，不完全满足OCP。
* 工厂方法模式和简单工厂模式最大的不同在于，简单工厂模式只有一个（对于一个项目或者一个独立模块而言）工厂类，
* 而工厂方法模式有一组实现了相同接口的工厂类。

 

抽象工厂模式

用于生产不同产品族的全部产品。（对于增加新的产品，无能为力；支持增加产品族）

抽象工厂模式是工厂方法模式的升级版本，在有多个业务品种、业务分类时，通过抽象工厂模式产生需要的对象是一种非常好的解决方式。

发动机

package com.kevin.创建型模式.工厂模式.abstractfactory;/*** @author kevin* @version 1.0* @description     发动机* @createDate 2019/2/17*/
public interface Engine {void run();void start();
}class LuxuryEngine implements Engine{@Overridepublic void run() {System.out.println("转的快");}@Overridepublic void start() {System.out.println("启动快。可以自动启停");}
}class LowEngine implements Engine{@Overridepublic void run() {System.out.println("转的慢");}@Overridepublic void start() {System.out.println("启动慢");}
}

座椅

package com.kevin.创建型模式.工厂模式.abstractfactory;/*** @author kevin* @version 1.0* @description     座椅* @createDate 2019/2/17*/
public interface Seat {void massage();
}class LuxurySeat implements Seat{@Overridepublic void massage() {System.out.println("可以自动按摩");}
}class LowSeat implements Seat{@Overridepublic void massage() {System.out.println("不能按摩");}
}

轮胎

package com.kevin.创建型模式.工厂模式.abstractfactory;import javax.swing.plaf.synth.SynthOptionPaneUI;/*** @author kevin* @version 1.0* @description     轮胎* @createDate 2019/2/17*/
public interface Tyre {void revolve();
}class LuxuryTyre implements Tyre {@Overridepublic void revolve() {System.out.println("旋转不磨损。");}
}class LowTyre implements Tyre {@Overridepublic void revolve() {System.out.println("旋转磨损快。");}
}

工厂

package com.kevin.创建型模式.工厂模式.abstractfactory;/*** @author kevin* @version 1.0* @description     工厂* @createDate 2019/2/17*/
public interface CarFactory {Engine createEngine();Seat createSeat();Tyre createTyre();
}

高端产品族工厂

package com.kevin.创建型模式.工厂模式.abstractfactory;/*** @author kevin* @version 1.0* @description 高端产品族工厂* @createDate 2019/2/17*/
public class LuxuryCarFactory implements CarFactory{@Overridepublic Engine createEngine() {return new LuxuryEngine();}@Overridepublic Seat createSeat() {return new LuxurySeat();}@Overridepublic Tyre createTyre() {return new LuxuryTyre();}
}

低端产品族工厂

package com.kevin.创建型模式.工厂模式.abstractfactory;/*** @author kevin* @version 1.0* @description 低端产品族工厂* @createDate 2019/2/17*/
public class LowCarFactory implements CarFactory {@Overridepublic Engine createEngine() {return new LowEngine();}@Overridepublic Seat createSeat() {return new LowSeat();}@Overridepublic Tyre createTyre() {return new LowTyre();}
}

测试抽象工厂模式

package com.kevin.创建型模式.工厂模式.abstractfactory;/*** @author kevin* @version 1.0* @description     测试抽象工厂模式* @createDate 2019/2/17*/
public class Test {public static void main(String[] args) {// 高端工厂Engine luxuryEngine = new LuxuryCarFactory().createEngine();luxuryEngine.run();luxuryEngine.start();// 低端工厂Engine lowEngine = new LowCarFactory().createEngine();lowEngine.run();lowEngine.start();}
}

UML类图

注：抽象工厂模式，通过不同的产品族创建产品。

 

应用场景：

1. JDK中Calendar的getInstance方法
2. JDBC中Connection对象的获取
3. Hibernate中SessionFactory创建Session
4. spring中IOC容器创建管理bean对象
5. XML解析时的DocumentBuilderFactory创建解析器对象
6. 反射中Class对象的newInstance()