Java中的23个设计模式 【创造型模式】 中的 【工厂模式】

设计模式分类

• 创建型模式
  • 单例模式、工厂模式、抽象工厂模式、建造者模式、原型模式
  • 关注对象的创建过程
• 结构型模式
  • 适配器模式、桥接模式、装饰模式、组合模式、外观模式、享元模式、代理模式
  • 关注对象和类的组织
• 行为型模式
  • 模板方法模式、命令模式、迭代器模式、观察者模式、中介模式、备忘录模式、解释器模式、状态模式、策略模式、责任链模式、访问者模式
  • 关注系统同对象之间的相互交互，研究系统在运行时对象之间的相互通信和协作，进一步明确对象的职责

工厂模式

• 实现了创建者和调用者的分离
• 详细分类：
  • 简单工厂模式(最常用)
  • 工厂方法模式
  • 抽象工厂模式
• 面向对象设计的基本原则
  • OCP(开闭原则，Open-Closed Principle)：一个软件的实体应当对扩展开放，对修改关闭
  • DIP(依赖倒转原则，Dependence Inversion Principle)：要针对接口编程，不要针对实现编程
  • LoD(迪米特法则，Law of Demeter)：只与你直接的朋友通信，而避免和陌生人通信
• 核心本质
  • 实例化对象，用工厂方法代替new操作
  • 将选择实现类、创建对象统一管理和控制。从而将调用者跟我们的实现类解耦

工厂模式分类：

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

简单工厂模式于工厂方法模式比较

• 结构复杂度
  • 从这个角度比较，显然简单工厂模式要占优。简单工厂模式只需一个工厂类，而工厂方法模式的工厂类随着产品类个数增加而增加，这无疑会使类的个数越来越多，从而增加了结构的复杂程度。
• 代码复杂度(简单工厂模式复杂)
  • 代码复杂度和结构复杂度是一对矛盾，既然简单工厂模式在结构方面相对简洁，那么它在代码方面肯定是比工厂方法模式复杂的了。简单工厂模式的工厂类随着产品类的增加需要增加很多方法（或代码），而工厂方法模式每个具体工厂类只完成单一任务，代码简洁。
• 客户端编程难度(简单工厂简单)
  • 工厂方法模式虽然在工厂类结构中引入了接口从而满足了OCP，但是在客户端编码中需要对工厂类进行实例化。而简单工厂模式的工厂类是个静态类，在客户端无需实例化，这无疑是个吸引人的优点
• 管理上的难度
  • 扩展性角度：两者同样具备良好的扩展性，尽管简单工厂模式没有完全满足OCP
  • 维护性角度：当需要修改多个产品类时，工厂类的修改会变得相当麻烦；反而简单工厂模式仅仅需要改唯一的工厂类（无论怎样都能改到满足要求吧？大不了把这个类重写）
• 建议：
  • 根据设计理论建议：工厂方法模式
  • 实际开发：一般使用简单工厂模式

简单工厂模式

要点

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

代码

• 接口

  public interface Car {
         
  	void run();
  
  }
  

• 具体的类（Audi，Byd）

  //Audi类
  package simplefactory;
  
  public class Audi implements Car{
         
  
  	@Override
  	public void run() {
         
  
  		System.out.println("奥迪再跑");
  	}
  
  }
  //-----------------------------------------------------------------
  //Byd类
  package simplefactory;
  
  public class Byd implements Car{
         
  
  	@Override
  	public void run() {
         
  
  		System.out.println("比亚迪再跑");
  	}
  
  }
  
  

• 工厂类写法一：

  package simplefactory;
  
  public class CarFactory {
         
  
  	public static Car creatCar(String type) {
         
  		if("奥迪".equals(type)) {
         
  			return new Audi();
  		}else if("比亚迪".equals(type)) {
         
  			return new Byd();
  		}else {
         
  			return null;
  		}
  	}
  }
  
  

• 工厂类写法二

  package simplefactory;
  
  public class CarFactory2 {
         
  
  	public static Car createAudi() {
         
  		return new Audi();
  	}
  	public static Car createByd() {
         
  		return new Byd();
  	}
  }
  
  

• 工厂类写法三：

  package simplefactory;
  
  public class CarFactory3 {
         
  
  	public static Car createCar(String type) {
         
  		Car c = null;
  		if("奥迪".equals(type)) {
         
  			c = new Audi();
  		}else if("比亚迪".equals(type)) {
         
  			c = new Byd();
  		}
  		
  		return c;
  	}
  }
  
  

• 调用者：

  package simplefactory;
  //使用工厂类一
  public class Client02 {
         
  
  	public static void main(String[] args) {
         
  		Car c1 = CarFactory.creatCar("奥迪");
  		Car c2 = CarFactory.creatCar("比亚迪");
  		 
  		c1.run();
  		c2.run();
  		
  	}
  }
  
  

工厂方法模式

要点：

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

代码

• 汽车接口和工厂接口

  //汽车接口，规范汽车模型
  package factorymethod;
  
  public interface Car {
         
  	void run();
  
  }
  
  //工厂接口，规范造车
  package factorymethod;
  
  public interface CarFactory {
         
  
  	Car createCar();
  }
  
  
  

• 汽车类和工厂类

  //汽车类
  package factorymethod;
  
  public class Audi implements Car{
         
  
  	@Override
  	public void run() {
         
  
  		System.out.println("奥迪再跑");
  	}
  
  }
  
  //对应汽车的工厂类
  package factorymethod;
  
  public class AudiFactory implements CarFactory{
         
  
  	@Override
  	public Car createCar() {
         
  		return new Audi();
  	}
  
  }
  
  

• 调用者

  package factorymethod;
  
  public class Client {
         
  	public static void main(String[] args) {
         
  		Car c1 = new AudiFactory().createCar();//通过工厂去创建一个车
  		c1.run();
  	}
  
  }
  
  
  

应用：

每增加一个新的事物，就要创建一个该事物的类以及能创建该事物对象的工厂类

调用者，通过对应工厂去创建对应的对象

抽象工厂模式

要点

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

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

  发动机	座椅	轮胎	——》一个产品族
  高端发动机	高端座椅	高端轮胎
  低端发动机	低端座椅	低端轮胎

代码

产品族中每个产品对应有：

• 抽象类（产品模子）
• 产品实现类（具体实现）

工厂：

• 抽象工厂类（工厂创建产品的规则）
• 工厂实现类（按规则具体生产产品）

调用者：

• 通过工厂接口创建需要的工厂
• 通过对应的产品接口，在创建出的工厂中生产产品

• 发动机抽象类和实现类

  //发动机抽象类
  package abstractFactory;
  
  public interface Engine {
         
  
  	void run();
  	void start();
  }
  
  //发动机的实现类（LuxuryEngine高端发动机，LowEngine低端发动机）
  class LuxuryEngine implements Engine{
         
  
  	@Override
  	public void run() {
         
  		System.out.println("高端引擎，转的快");
  	}
  
  	@Override
  	public void start() {
         
  		System.out.println("高端引擎，启动快！可以自动启停");
  	}
  	
  }
  class LowEngine implements Engine{
         
  	
  	@Override
  	public void run() {
         
  		System.out.println("低端引擎转的慢");
  	}
  	
  	@Override
  	public void start() {
         
  		System.out.println("低端，启动慢！不可以自动启停");
  	}
  	
  }
  
  
  

• 座椅抽象类和实现类

  //座椅抽象类
  package abstractFactory;
  
  public interface Seat {
         
  	
  	void massage();
  	
  }
  
  //座椅实现类（LuxurySet高端座椅，LowSeat低端座椅）
  class LuxurySeat implements Seat{
         
  
  	@Override
  	public void massage() {
         
  		System.out.println("高端，可以自动按摩");
  	}
  	
  }
  class LowSeat implements Seat{
         
  	
  	@Override
  	public void massage() {
         
  		System.out.println("低端，不可以自动按摩");
  	}
  	
  }
  
  
  

• 轮胎抽象类和实现类

  //轮胎抽象类
  package abstractFactory;
  
  public interface Tyre {
         
  
  	void revolve();
  }
  
  //轮胎的实现类（LuxuryTyre高端轮胎，LowTyre低端轮胎）
  class LuxuryTyre implements Tyre{
         
  
  	@Override
  	public void revolve() {
         
  		System.out.println("高端，旋转不磨损");
  	}
  
  
  	
  }
  class LowTyre implements Tyre{
         
  
  	@Override
  	public void revolve() {
         
  		System.out.println("低端，旋转磨损");
  	}
  	
  	
  	
  }
  
  
  

• 工厂抽象类

  package abstractFactory;
  
  public interface CarFactory {
         
  	Engine createEngine();
  	Seat createSeat();
  	Tyre createTyre();
  
  }
  
  
  

• 工厂实现类（高端工厂和低端工厂）

  //高端工厂实现类
  package abstractFactory;
  
  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();
  	}
  
  }
  
  //低端工厂实现类
  package abstractFactory;
  
  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();
  	}
  
  }
  
  
  

• 客户端：

  package abstractFactory;
  
  public class Client {
         
  
  	public static void main(String[] args) {
         
  		CarFactory factory = new LuxuryCarFactory();
  		Engine e = factory.createEngine();
  		e.run();
  		e.start();
  	}
  }
  //结果————————————————————————————————————————————————————————————
  高端引擎，转的快
  高端引擎，启动快！可以自动启停
  
  

总结

• 工厂模式要点：
  • 简单工厂模式（静态工厂模式）
    • 虽然某种程度不符合设计原则，但实际使用最多
  • 工厂方法模式
    • 不修改已有类的前提下，通过增加新的工厂类实现扩展
  • 抽象工厂模式
    • 不可以增加产品，可以增加产品族
• 应用场景
  • JDK中Calendar的getInstance方法
  • JDBC中Connection对象的获取
  • Hibernate中SessionFactory创建Session
  • spring中IOC容器创建管理bean对象
  • XML解析时的DocumentBuilderFactory创建解析器
  • 反射中Class对象的newInstance()