一、简单工厂模式
简单工厂的定义:提供一个创建对象实例的功能,而无须关心其具体实现。被创建实例的类型可以是接口、抽象类,也可以是具体的类。
(1)实现汽车接口
public interface Car {
String getName();
}
(2)奔驰类
public class Benz implements Car {
@Override
public String getName() {
return "Benz";
}
}
(3)宝马类
public class BMW implements Car {
@Override
public String getName() {
return "BMW";
}
}
(4)简单工厂,既能生产宝马又能生产奔驰
public class SimpleFactory {
public Car getCar(String name) {
if (name.equals("Benz")) {
return new Benz();
} else if (name.equals("BMW")) {
return new BMW();
} else {
return null;
}
}
}
(5)测试类
public class SimpleFactoryTest {
public static void main(String[] args) {
SimpleFactory simpleFactory = new SimpleFactory();
Car car = simpleFactory.getCar("BMW");
System.out.println(car.getName());
}
}
(6)测试结果
BMW
根据简单工厂的定义,用户只要产品而不在乎产品如何生产,看起来好像很完美的样子。但大家想想,这个世界存在什么都生产的工厂吗?
显然是不存在的,每一个汽车品牌都有自己的生产工厂,都有自己生产技术。映射到spring框架中,我们有很多很多种的bean需要生产,如果只依靠一个简单工厂来实现,那么我们得在工厂类中嵌套多少个if..else if啊?
而且我们在代码中生产一辆汽车只是new一下就出来了,但实际操作中却不知道需要进行多少操作,加载、注册等操作都将体现在工厂类中,那么这个类就会变得紊乱,管理起来也很不方便,所以说每个品牌应该有自己的生产类。
因为专一,所以专业嘛,这个时候工厂方法就出现了。
二、工厂方法
(1)工厂接口
// 定义一个工厂接口,功能就是生产汽车
public interface Factory {
Car getCar();
}
(2)奔驰工厂
public class BenzFactory implements Factory {
@Override
public Car getCar() {
return new Benz();
}
}
(3)宝马工厂
public class BMWFactory implements Factory {
@Override
public Car getCar() {
return new BMW();
}
}
(4)测试类
public class FactoryTest {
public static void main(String[] args) {
Factory bmwFactory = new BMWFactory();
System.out.println(bmwFactory.getCar().getName());
Factory benzFactory = new BenzFactory();
System.out.println(benzFactory.getCar().getName());
}
}
(5)测试结果
BMW
Benz
根据上述代码可以看出,不同品牌的汽车是由不同的工厂生产的,貌似又是很完美的。但大家看一下测试类,当一个人想要去买一辆宝马汽车的时候(假设没有销售商),那么他就要去找宝马工厂给他生产一辆,过几天又想要买一辆奔驰汽车的时候,又得跑到奔驰工厂请人生产,这无疑就增加了用户的操作复杂性。所以有没有一种方便用户操作的方法呢?这个时候抽象工厂模式就出现了。
三、抽象工厂
(1)抽象工厂
public abstract class AbstractFactory {
protected abstract Car getCar(String name);
}
(2)默认工厂
public class DefaultFactory extends AbstractFactory {
@Override
protected Car getCar(String name) {
if ("Benz".equalsIgnoreCase(name)) {
return new BenzFactory().getCar();
} else if ("BMW".equalsIgnoreCase(name)) {
return new BMWFactory().getCar();
} else {
System.out.println("这个产品生产不出来");
return null;
}
}
}
(3)测试类
public class AbstractFactoryTest {
public static void main(String[] args) {
DefaultFactory defaultFactory = new DefaultFactory();
System.out.println(defaultFactory.getCar("Benz").getName());
}
}
(4)测试结果
Benz
根据上述代码可以看出,用户需要一辆汽车,只需要去找默认的工厂提出自己的需求(传入参数),便能得到自己想要产品,而不用根据产品去寻找不同的生产工厂,方便用户操作。
注:对于设计模式,有些人嗤之以鼻,有些人敬若神明,但我是认可的。
按我粗浅的理解,设计模式的经典之处,就在于解决了编写代码的人和调用代码的人双方的痛楚,不同的设计模式也只适用于不同的场景。至于用或者不用,如何使用,那就需要各位看官着重考虑了。
但为了使用而使用是不应该的,细微之处,只有留给大家慢慢品味了。