设计模式——工厂模式

工厂模式：工厂模式主要是为创建对象提供过渡接口，以便将创建对象的具体过程屏蔽隔离起来，达到提高灵活性的目的。

1）简单工厂模式（Simple Factory）：不利于产生系列产品；

2）工厂方法模式：

（生产同一种类型的产品，不同风味） 将生产产品的类做成抽象类，抽象方法中创建产品。由子类处理对象的实例化。

3）抽象工厂模式（Abstract Factory）：又称为工具箱，产生产品族，但不利于产生新的产品；

一·首先我们实现简单工厂模式：

我们的需求是建立交通工具类，该类有移动的功能，因为交通工具有很多种具体的产品，所以我们抽象出Moveable接口：

package com.lcq.factory;
 
 public interface Moveable {
     public void run();
 }

然后我们创建具体的实现类：

package com.lcq.factory;
 
 public class Plane implements Moveable{
 
     @Override
     public void run() {
         System.out.println("扇着翅膀飞奔而来。。。");
     }
 
 }

接下来我们将Plane类创建对象的过程进行封装，实现工厂。在实现工厂类之前，我们可以对工厂类进行抽象，创建抽象工厂类：

package com.lcq.factory;
 
 public abstract class VehicleFactory {
     public abstract Moveable create();
 }

在具体的工厂类中继承抽象的工厂类：

package com.lcq.factory;
 
 public class PlaneFactory extends VehicleFactory{
 
     @Override
     public Moveable create() {
         return new Plane();
     }
 }

这样客户就可以使用工厂进行对象的创建和使用了：

package com.lcq.factory;
 
 public class Test2 {
     public static void main(String[] args) {
         
         VehicleFactory factory = new PlaneFactory();
 //        VehicleFactory factory = new BroomFactory();
         
         Moveable m = factory.create();
         m.run();
     }
 
 }

假如我们想提供另外的交通工具类就会非常灵活。比如我们想将交通工具换成扫帚，则可以创建Broom对象：

package com.lcq.factory;
 
 public class Broom implements Moveable{
 
     @Override
     public void run() {
         System.out.println("刮着沙尘暴呼啸而来。。。");
     }
 
 }

实现它的工厂生产类：

package com.lcq.factory;
 
 public class BroomFactory extends VehicleFactory{
 
     @Override
     public Moveable create() {
         return new Broom();
     }
 
 }

在客户类中替换掉工厂就可以了：

VehicleFactory factory = new BroomFactory();

所以简单工厂模式对于创建新的产品是比较方便灵活的；

简单工厂类图：

二.工厂方法


简单的模拟一下工厂方法：

interface IProduct { 
    public void productMethod(); 
} 
   
class Product implements IProduct { 
    public void productMethod() { 
        System.out.println("产品"); 
    } 
} 
   
interface IFactory { 
    public IProduct createProduct(); 
} 
   
class Factory implements IFactory { 
    public IProduct createProduct() { 
        return new Product(); 
    } 
} 
   
public class Client { 
    public static void main(String[] args) { 
        IFactory factory = new Factory(); 
        IProduct prodect = factory.createProduct(); 
        prodect.productMethod(); 
    } 
} 

工厂方法类图：

三·抽象工厂实现

我们的需求是客户需要一系列的产品，比如这些产品包括：交通工具，武器，食物。

我们首先创建这些产品：

交通工具：

package com.lcq.factory.abstractfactory;
 
 public abstract class Vehicle {
     public abstract void run();
 }

具体的交通工具Car：

package com.lcq.factory.abstractfactory;
 /**
  * 单例模式和工厂方法模式
  * @author lcq
  *
  */
 
 public class Car extends Vehicle{
 
     @Override
     public void run() {
         System.out.println("开车去东北。。。");
         
     }
     
 }

武器：

package com.lcq.factory.abstractfactory;
 
 public abstract class Weapon {
     public abstract void shoot();
 
 }

具体的武器实现：

package com.lcq.factory.abstractfactory;
 
 public class AK47 extends Weapon {
 
     @Override
     public void shoot() {
         System.out.println("da da da...");
     }
 
 }

食物：

package com.lcq.factory.abstractfactory;
 
 public abstract class Food {
     public abstract void print();
 }

具体的食物：

package com.lcq.factory.abstractfactory;
 
 public class Apple extends Food {
 
     @Override
     public void print() {
         System.out.println("eat apple");
     }
 
 }

接下来定义我们的抽象工厂类，在该类中我们定义抽象的创建交通工具和武器以及食品的抽象方法：

package com.lcq.factory.abstractfactory;
 
 public abstract class AbstractFactory {
     public abstract Vehicle createVehicle();
     public abstract Weapon createWeapon();
     public abstract Food createFood();
     
 }

定义具体生产产品的工厂类：

package com.lcq.factory.abstractfactory;
 
 public class DefaultFactory extends AbstractFactory {
 
     @Override
     public Vehicle createVehicle() {
         return new Car();
     }
 
     @Override
     public Weapon createWeapon() {
         return new AK47();
     }
 
     @Override
     public Food createFood() {
         return new Apple();
     }
 
 }

这样客户就可以利用工厂类去使用系列产品了：

package com.lcq.factory.abstractfactory;
 /**
  * 测试抽象工厂
  * @author lcq
  *
  */
 public class test {
     public static void main(String[] args) {
         
         AbstractFactory factory = new DefaultFactory();
         
         Vehicle vehicle = factory.createVehicle();
         vehicle.run();
         Weapon weapon = factory.createWeapon();
         weapon.shoot();
         Food food = factory.createFood();
         food.print();
         
         
         
         
     }
 
 }

以上是实现了一个系列的产品，如果想改成其他系列的产品，可以比较方便的实现：

创建另外系列的产品：

交通工具：

package com.lcq.factory.abstractfactory;
 
 public class Broom extends Vehicle {
 
     @Override
     public void run() {
         System.out.println("冒着沙尘暴一路飞奔而来。。。");
     }
 
 }

武器：

package com.lcq.factory.abstractfactory;
 
 public class MagicStick extends Weapon {
 
     @Override
     public void shoot() {
         System.out.println("fire hu hu hu...");
     }
 
 }

食品：

package com.lcq.factory.abstractfactory;
 
 public class MushRoom extends Food {
 
     @Override
     public void print() {
         System.out.println("mushroom");
     }
 
 }

创建好对应的工厂类：

package com.lcq.factory.abstractfactory;
 
 public class MagicFactory extends AbstractFactory{
 
     @Override
     public Vehicle createVehicle() {
         return new Broom();
     }
 
     @Override
     public Weapon createWeapon() {
         return new MagicStick();
     }
 
     @Override
     public Food createFood() {
         return new MushRoom();
     }
 
 }

在客户类中修改即可更换产品系列：

AbstractFactory factory = new MagicFactory();

抽象工厂类图：

三·模拟spring实现工厂模式

基本思路是结合配置文件实现工厂模式。

和先前的流程相似，创建Moveable接口和其实现类Car：

package com.spring.factory;
 
 public interface Moveable {
     public void run();
 }

package com.spring.factory;
 /**
  * 单例模式和工厂方法模式
  * @author lcq
  *
  */
 
 public class Car implements Moveable{
 
     @Override
     public void run() {
         System.out.println("开车去东北。。。");
     }
 }

再添加一个实现类Train；

package com.spring.factory;
 
 public class Train implements Moveable {
 
     @Override
     public void run() {
         System.out.println("开着火车冒着烟。。。");
     }
 
 }

创建配置文件spring.properties：

vehicleType=com.spring.factory.Train

在客户类中使用工厂：

package com.spring.factory;
 
 import java.util.Properties;
 
 public class Test {
     public static void main(String[] args) throws Exception {
         Properties properties = new Properties();
         properties.load(Test.class.getClassLoader().getResourceAsStream(
                 "com/spring/factory/spring.properties"));
         String vehicleTypeName = properties.getProperty("vehicleType");
         Object o = Class.forName(vehicleTypeName).newInstance();
 
         Moveable m = (Moveable) o;
         m.run();
     }
 }

这样在更改产品时可以直接修改配置文件，比如：

vehicleType=com.spring.factory.Car

即可。