设计模式三：工厂模式

工厂模式包括简单工厂模式、工厂方法模式和抽象工厂模式，其中后两者属于23中设计模式

各种模式中共同用到的实体对象类：

//汽车类：宝马X3/X5/X7；发动机类：B48TU、B48//宝马汽车接口
public interface BMWCar {void show();
}//发动机接口
public interface Engine {void show();
}//宝马X3
public class BMWX3 implements BMWCar {@Overridepublic void show() {System.out.println("华晨宝马X3：39.96-48.69万");}
}//宝马X5
public class BMWX5 implements BMWCar {@Overridepublic void show() {System.out.println("华晨宝马X5：58.75-80万");}
}//宝马X7
public class BMWX7 implements BMWCar {@Overridepublic void show() {System.out.println("华晨宝马X3：89.35-102.25万");}
}//B48TU发动机
public class B48TUEngine implements Engine {@Overridepublic void show() {System.out.println("B48TU：涡轮增压 压缩比 11:1");}
}//B48发动机
public class B48Engine implements Engine {@Overridepublic void show() {System.out.println("B48：涡轮增压 压缩比 10.2:1");}
}

1、简单工厂模式

• 模型

​ 用户只需要使用汽车生产工厂，告诉其想要生产的车型，具体生产细节不需要了解即可得到希望车型

• 实现

//简单工厂类
public class BMWCarFactory {public static BMWCar buy(String carName){switch (carName){case "BMWX5":return new BMWX5();case "BMWX3":return new BMWX3();default:return null;}}
}//测试
public class Consumer {public static void main(String[] args) {BMWCar bmwCar = BMWCarFactory.buy("BMWX5");if (bmwCar == null){System.out.println("无该车型");}assert bmwCar != null;bmwCar.show();}
}

简单工厂模式：

再添加一个宝马产品，就要修改factory类

1、使用进阶版简单工厂模式

2、使用工厂方法模式，即有自工厂生产对应车型，X5由X5Factory生产，X3由X3Factory生产，在添加一种车型，则对应添加一个工厂类型

简单工厂模式适用于的场景：

1、适用 于工厂类负责创建的对象较少的场景，

2、且客户端只需要传入工厂类的参数，对于如何创 建对象的逻辑不需要关心。

简单工厂模式缺点：

1、工厂类的职业相对过重，增加新的产品时需要修改工厂类的判断逻辑，违背开闭原则

2、不易于扩展过于复杂的产品结构

2、进阶版简单工厂模式

//工厂类
public class BMWFactory {public static <T> T buy(Class<T> clazz){try {return clazz.newInstance();} catch (Exception e) {return null;}}
}//测试
public class Consumer {public static void main(String[] args) {BMWCar newCar = BMWFactory.buy(BMWX3.class);if (newCar == null){System.out.println("无该车型");}newCar.show();}
}

3、工厂方法模式

• 模型
  

//宝马工厂接口
public interface BMWCarFactory {BMWCar buy();
}//BMWX3工厂
public class BMWX3CarFactory implements BMWCarFactory {@Overridepublic BMWCar buy() {//可在这里做一定处理，对客户不可见，即对客户是透明的//......return new BMWX3();}
}//BMWX5工厂
public class BMWX5CarFactory implements BMWCarFactory {@Overridepublic BMWCar buy() {//可在这里做一定处理，对客户不可见，即对客户是透明的//......return new BMWX5();}
}//BMWX7工厂
public class BMWX7CarFactory implements BMWCarFactory {@Overridepublic BMWCar buy() {//可在这里做一定处理，对客户不可见，即对客户是透明的//......return new BMWX7();}
}//测试
public class Consumer {public static void main(String[] args) {BMWCar bmwCar = BMWCarFactory.buy("BMWX5");if (bmwCar == null){System.out.println("无该车型");}assert bmwCar != null;bmwCar.show();}
}

工厂方法模式的适用场景：

1、创建对象需要大量重复的代码

2、客户端（应用层）不依赖于产品类实例如何被创建、实现等细节，一个类通过其子类来指定创建哪个对象。

工厂方法模式的优点：

1、用户只关系所需产品对应的工厂，无须关心创建细节。

2、加入新产品符合开闭原则，提高了系统的可扩展性。

工厂方法模式的缺点：

1、类的个数容易过多，增加了代码结构的复杂度。

2、增加了系统的抽象性和理解难度。

工厂方法模式：

如果处了汽车之外，新增加发动机产品 B48TU发动机(X5搭载) 和 B48发动机(X3搭载)

那么需要新增发动机工厂接口、B48TU工厂、B48工厂、发动机接口、B48TU发动机、B48发动机

如下图所示

4、抽象工厂模式

• 模型

• 实现

//宝马工厂接口
public interface BMWFactory {BMWCar buyCar();Engine buyEngine();
}//宝马X3工厂
public class BMWX3Factory implements BMWFactory {@Overridepublic BMWCar buyCar() {return new BMWX3();}@Overridepublic Engine buyEngine() {return new B48Engine();}
}//宝马X5工厂
public class BMWX5Factory implements BMWFactory {@Overridepublic BMWCar buyCar() {return new BMWX5();}@Overridepublic Engine buyEngine() {return new B48TUEngine();}
}//测试
public class Consumer {public static void main(String[] args) {BMWFactory factory = new BMWX3Factory();factory.buyCar().show();factory.buyEngine().show();}
}

抽象工厂模式：

将不同种类，同一等级的类放在一个工厂加工

但是新增产品时需要修改工厂类

抽象工厂模式使用场景：

1、客户端（应用层）不依赖于产品类实例如何被创建，实现等细节。

2、强调一系列相关的产品对象（属于同一产品族）一起使用创建对象需要大量重复的代码。

3、提供一个产品类的库，所有的产品以同样的接口出现，从而使客户端不依赖于具体的实现。

抽象工厂模式优点：

1、具体产品在应用层代码隔离，无须关系创建细节。

2、将一个系列的产品族统一到一起创建。

抽象工厂模式缺点：

1、规定了所有可能被创建的产品集合，产品族中扩展新的产品困难，需要修改抽象工厂的接口。

2、增加了系统的抽象性和理解难度。

5、spring中的工厂模式

Calendar.getInstance()   //简单工厂模式
LoggerFactory、BeanFactory、FactoryBean   //工厂方法模式

Calendar

if (aLocale.hasExtensions()) {String caltype = aLocale.getUnicodeLocaleType("ca");if (caltype != null) {switch (caltype) {case "buddhist":cal = new BuddhistCalendar(zone, aLocale);break;case "japanese":cal = new JapaneseImperialCalendar(zone, aLocale);break;case "gregory":cal = new GregorianCalendar(zone, aLocale);break;}}
}

BeanFactory

public class TestBeanFactory {public static void main(String[] args) {DefaultListableBeanFactory beanFactory = new DefaultListableBeanFactory();// bean 的定义（class, scope, 初始化, 销毁）AbstractBeanDefinition beanDefinition =BeanDefinitionBuilder.genericBeanDefinition(Config.class).setScope("singleton").getBeanDefinition();beanFactory.registerBeanDefinition("config", beanDefinition);// 给 BeanFactory 添加一些常用的后处理器AnnotationConfigUtils.registerAnnotationConfigProcessors(beanFactory);beanFactory.getBeansOfType(BeanFactoryPostProcessor.class).values().forEach(beanFactoryPostProcessor -> {beanFactoryPostProcessor.postProcessBeanFactory(beanFactory);});// 打印BeanFactory中Beanfor (String name : beanFactory.getBeanDefinitionNames()) {System.out.println(name);}}@Configurationstatic class Config {@Beanpublic Bean1 bean1() {return new Bean1();}@Beanpublic Bean2 bean2() {return new Bean2();}}static class Bean1 {private static final Logger log = LoggerFactory.getLogger(Bean1.class);public Bean1() {log.debug("构造 Bean1()");}@Autowiredprivate Bean2 bean2;public Bean2 getBean2() {return bean2;}}static class Bean2 {private static final Logger log = LoggerFactory.getLogger(Bean2.class);public Bean2() {log.debug("构造 Bean2()");}}
}