在平常的代码中,难免会去new一个对象,这样调用者与实体类之间就会存在耦合关系,如果创建多个对象调用者就会存在多层耦合关系,而工厂模式就是代替new,实现解耦。工厂模式在我们平常的使用中非常常见,比如 mybatis中的SqlSessionFactory,JDBC中Connection的获取,spring中IOC容器创建管理bean,反射中的newInstance,XML解析时DocumentBuilderFactory创建解析器对象
先举例说明一般的代码,比如我们现在要创建一个奥迪车,创建一个大众车,
两种车的抽象代码:
public interface Car {
void run();
}
public class Audi implements Car {
@Override
public void run() {
System.out.println("Audi在跑");
}
}
public class Dazhong implements Car {
@Override
public void run() {
System.out.println("大众在跑");
}
}
在客户端代码中,我们这样写:
Car audi = new Audi();
Car dazhong = new Dazhong();
这样写,该代码块会与两个类耦合
简单工厂模式
简单工厂模式顾名思义,就是最简单的工厂模式,而工厂就是加工产品的,调用者只需要把提起规范好的要求传给工厂,工厂就可以返回给调用者需要的对象,这里写一个简单工厂类
/**
* 简单工厂
*/
public class SimpleCarFactory {
public static Car getCar(String carName) {
if("audi".equals(carName)) {
return new Audi();
} else if("dazhong".equals(carName)) {
return new Dazhong();
} else {
return null;
}
}
}
这时调用方的代码就可以这样写:
Car audi = SimpleCarFactory.getCar("audi");
Car dazhong = SimpleCarFactory.getCar("dazhong");
可以看到,现在的调用者只与工厂类有耦合关系
但是想一个问题,我们如果要增加一个汽车类-奔驰,那么代码该如何更改,首先我们需要创建一个奔驰类
public class Benchi implements Car {
@Override
public void run() {
System.out.println("奔驰");
}
}
还要在简单工厂中添加代码
public class SimpleCarFactory {
public static Car getCar(String carName) {
if("audi".equals(carName)) {
return new Audi();
} else if("dazhong".equals(carName)) {
return new Dazhong();
} else if("benchi".equals(carName)) {
return new Benchi();
} else {
return null;
}
}
}
这样工厂类SimpleCarFactory就要增加代码了,不符合软件设计的开闭原则
OCP开闭原则:一个软件的实体应当对扩展开放,对修改关闭
这就要引入工厂方法模式
工厂方法模式
工厂方法模式是每一种产品对应一种工厂,所有的工厂都实现了工厂接口
public interface Factory {
void createCar();
}
奥迪工厂:
public class AudiFactory implements Factory {
@Override
public Car createCar() {
return new Audi();
}
}
在代码中创建奥迪车就变成了这样
Car car = new AudiFactory().createCar();
这时,新增加了需求,要增加一辆比亚迪车,工厂方法模式会怎么做
首先,创建比亚迪类
public class Biyadi implements Car {
@Override
public void run() {
System.out.println("byd...");
}
}
这时候,直接增加一个比亚迪工厂即可,不用修改原来的代码:
public class BiyadiFactory implements Factory {
@Override
public Car createCar() {
return new Biyadi();
}
}
创建比亚迪车:
Car car = new BiyadiFactory().createCar();
比较:可以看到,工厂方法模式遵循了开闭原则,稍微比简单工厂模式要复杂一些,但工厂方法模式会随着业务的复杂,类数量越来越多。在平常的代码编写中,我们一般使用简单工厂模式
抽象工厂模式
工厂方法模式是简单工厂模式的升级版,抽象工厂模式是什么呢?抽象工厂模式(Abstract Factory Pattern)是围绕一个超级工厂创建其他工厂,超级工厂定义了不止生产一种产品,该超级工厂又称为其他工厂的工厂。举个例子,我们现在有一个超级工厂,定义了生产汽车零件,通过超级工厂,可以生产出高配车的工厂,低配车的工厂,高配车的工厂是生产高级零件的,低配车的工厂是生产低配零件的,通过例子来看一下
public interface CarFactory {
/**
* 生产 发动机
* @return
*/
Engine createEngine();
/**
* 生产座椅
* @return
*/
Seat createSeat();
/**
* 生产轮胎
* @return
*/
Tyre createTyre();
}
/**
* 低配工厂
*/
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();
}
}
抽象工厂模式的特点就是不可以增加产品,增加的是产品族