设计模式——工厂模式

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

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

即可。