1. 工厂模式介绍
实现创建者和调用者的分离
1.1 核心本质
- 实例化对象,用工厂方法代替new操作
- 将选择实现类和创建对象统一管理和控制,从而将调用者跟实现类解耦
1.2 详细分类
- 简单工厂模式
- - 用来生产同一等级结构中的任意产品(对于增加新的产品,需要修改代码)
- 工厂方法模式
- - 用来生产同一等级结构中的固定产品(支持增加任意产品)
- 抽象工厂模式
- - 用来生产不同产品族的全部产品(对于增加新的产品无能为力,支持增加产品族)
1.3 应用场景
- JDK 中Calendar的getInstance()方法
- JDBC 中Connection对象的获取
- Hibernate 中SessionFactory创建Session
- Spring 中IOC容器创建管理Bean对象
- XML 解析时的DocumentBuilderFactory创建解析器对象
- 反射 Class对象的newInstance()方法
2. 无工厂模式
2.1 定义接口及实现类
// Car接口
public interface Car {
public void run();
}
// 奥迪实现类
public class Audi implements Car{
@Override
public void run() {
System.out.println("奥迪在跑");
}
}
// 比亚迪实现类
public class Byd implements Car{
@Override
public void run() {
System.out.println("比亚迪在跑");
}
}
2.2 没有使用工厂模式的调用情况
/**
* 没有使用工厂模式的情况(调用和创建在一个类,且和接口及其实现类都关联)
* @author lyyao09 2016-9-30 16:42:27
*/
public class Client1 {
public static void main(String[] args) {
Car car1 = new Audi();
Car car2 = new Byd();
car1.run();
car2.run();
}
}
2.3 无工厂模式的类关系调用图
3. 简单工厂模式
3.1 定义接口及实现类(同上)
3.2 添加工厂方法
public class SimpleFactory {
// 写法1
public static Car createCar(String type) {
if ("奥迪".equals(type)) {
return new Audi();
} else if ("比亚迪".equals(type)) {
return new Byd();
} else {
return null;
}
}
// 写法2
/*public static Car createAudi() {
return new Audi();
}
public static Car createByd() {
return new Byd();
}*/
}
3.3 简单工厂的调用
/**
* 简单工厂模式(调用跟创建分离,仅跟工厂类和接口关联)
* @author lyyao09 2016-9-30 16:42:27
*/
public class Client2 {
public static void main(String[] args) {
Car car1 = SimpleFactory.createCar("奥迪");
Car car2 = SimpleFactory.createCar("比亚迪");
car1.run();
car2.run();
}
}
3.4 简单工厂的类关系调用图
简单工厂模式也叫静态工厂模式,也即工厂类一般使用静态方法,通过接收参数的不同返回不同的对象实例。
对增加新产品无能为力,不修改代码的话,是不能扩展的。
4. 工厂方法模式
4.1 定义接口及实现类(同上)
4.2 工厂接口及实现类
// Car工厂接口
public interface CarFactory {
public Car createCar();
}
// 工厂接口的奥迪实现类
public class AudiFactory implements CarFactory{
@Override
public Car createCar() {
return new Audi();
}
}
// 工厂接口的比亚迪实现类
public class BydFactory implements CarFactory{
@Override
public Car createCar() {
return new Byd();
}
}
4.3 工厂方法的调用
public class Client1 {
public static void main(String[] args) {
Car car1 = new AudiFactory().createCar();
Car car2 = new BydFactory().createCar();
car1.run();
car2.run();
}
}
4.4 工厂方法的类关系调用图
避免了简单工厂模式的缺点(不完全满足OCP原则)
和简单工厂模式的不同:简单工厂模式只有一个工厂类(对于一个项目或一个独立模块),而工厂方法模式有一组实现了相同接口的工厂类。
5. 抽象工厂模式
5.1 接口及其实现类
// 发动机接口
public interface Engine {
void run();
}
// 高端发动机实现类
class LuxuryEngine implements Engine{
@Override
public void run() {
System.out.println("跑得快");
}
}
// 低端发动机实现类
class LowerEngine implements Engine{
@Override
public void run() {
System.out.println("跑得慢");
}
}
// 座椅接口
public interface Seat {
void massage();
}
// 高端座椅实现类
class LuxurySeat implements Seat{
@Override
public void massage() {
System.out.println("可以按摩");
}
}
// 低端座椅实现类
class LowerSeat implements Seat{
@Override
public void massage() {
System.out.println("不可以按摩");
}
}
5.2 工厂类接口及其实现
// 汽车工厂类
public interface CarFactory {
Engine createEngine();
Seat createSeat();
}
// 高端汽车工厂实现类
public class LuxturyCarFactory implements CarFactory{
@Override
public Engine createEngine() {
return new LuxuryEngine();
}
@Override
public Seat createSeat() {
return new LuxurySeat();
}
}
// 低端汽车工厂实现类
public class LowerCarFactory implements CarFactory{
@Override
public Engine createEngine() {
return new LowerEngine();
}
@Override
public Seat createSeat() {
return new LowerSeat();
}
}
5.3 抽象工厂的调用
public class Client {
public static void main(String[] args) {
Engine e1 = new LuxturyCarFactory().createEngine();
Seat s1 = new LuxturyCarFactory().createSeat();
e1.run();
s1.massage();
Engine e2 = new LowerCarFactory().createEngine();
Seat s2 = new LowerCarFactory().createSeat();
e2.run();
s2.massage();
}
}
5.4 抽象工厂的类关系调用图
6. 总结
- 简单工厂模式
-
- 虽然某种程度不符合设计原则,但实际上使用最多
工厂方法模式
-
- 不修改已有类的前提下,通过增加新的工厂扩展功能
抽象工厂模式
-
- 不可用增加产品,可以增加产品族