创建型模式之工厂模式

创建型模式：对象实例化的模式，创建型模式用于解耦对象的实例化过程，即创建对象的同时隐藏创建逻辑。

在上一篇行为型模式之策略模式的最后，我们说创建策略角色可以使用工厂模式来创建，这里接着聊工厂模式。

工厂模式分为简单工厂模式，和抽象工厂模式。

简单工厂模式：建立一个工厂类，对实现了同一接口的一些类进行实例的创建。

首先接口和实例类已经有现成的了，我们并不做改动，如下

/**
 * 抽象策略
 **/
public interface PriceStrategy  {
    BigDecimal getPrice(BigDecimal price);
}

/**
 * 会员,六折
 **/
class Member implements PriceStrategy  {
    @Override
    public BigDecimal getPrice(BigDecimal price) {
        return price.multiply(new BigDecimal(0.6 + ""));
    }
}

/**
 * 普通客户 原价
 **/
class Ordinary implements PriceStrategy  {
    @Override
    public BigDecimal getPrice(BigDecimal price) {
        return price;
    }
}

/**
 * 超级会员,4折
 **/ 
class SuperMember implements PriceStrategy {
    @Override
    public BigDecimal getPrice(BigDecimal price) {
        return price.multiply(new BigDecimal(0.4+""));
    }
}

接着创建一个工厂类，来进行实例的创建

public class StrategyFactory {  
   public PriceStrategy  produce(String memberType) {  
        if ("Member".equals(memberType)) {  
            return new Member();  
        } else if ("Ordinary".equals(memberType)) {  
            return new Ordinary();  
        }else if ("SuperMember".equals(memberType)) {  
            return new SuperMember();  
        }else {  
            System.out.println("请输入正确的类型!");  
            return null;  
        }  
    }  
}

到这里，我们创建策略角色时，可以使用简单工厂模式来创建

public class Test {
    public static void main(String[] args) throws Exception {
        //简单工厂模式，根据条件来创建实例
        StrategyFactory  factory = new StrategyFactory();
        PriceStrategy strategy = factory.produce("SuperMember");
        // 创建上下文环境
        PriceContext priceContext = new PriceContext(strategy);
        // 计算价格
        BigDecimal price = priceContext.getPrice(300);
        System.out.println("商品的最终价格为：" + price );
    }
}

抽象工厂模式：可以生产多种相关联产品的超级工厂（简单工厂模式只能上产一种产品）

假如我们再计算完商品价格之后，还要计算本次购买积分，同样的，积分的计算也是不同的策略/算法，我们继续使用策略模式再创建一组积分策略角色，这里不成问题，问题是我们还是需要使用简单工厂模式来创建积分实例。这样不但冗余，而且代码复用性不强，这时候就可以使用抽象工厂模式，创建一个能生产多个对象的超级工厂。

先定义一个抽象工厂，

public interface IAbstractFactory {

    /**
     * 获取价格策略
     */
    PriceStrategy  getPriceStrategy();

    /**
     * 获取积分策略
     */
    PointsStrategy  getPointsStrategy();

}

定义具体的工厂生产类，具体的产品实例返回

会员工厂类，生产会员价格策略实例，和会员积分策略实例

public class MemberFactory implements IAbstractFactory {

    @Override
    public PriceStrategy  getPriceStrategy() {
        return new Member();
    }

    @Override
    public PointsStrategy  getPointsStrategy() {
        return new MemberPoints();
    }

}

普通客户工厂类，生产普通客户价格策略实例，和普通客户积分策略实例

public class OrdinaryFactory implements IAbstractFactory {

    @Override
    public PriceStrategy  getPriceStrategy() {
        return new Ordinary();
    }

    @Override
    public PointsStrategy  getPointsStrategy() {
        return new OrdinaryPoints();
    }

}

超级会员略

创建一个工厂创造器，通过传递会员类型来获取工厂

public class FactoryProducer {
   public static IAbstractFactory getFactory(String memberType){
       if ("Member".equals(memberType)) {  
            return new MemberFactory();  
        } else if ("Ordinary".equals(memberType)) {  
            return new OrdinaryFactory();  
        }else if ("SuperMember".equals(memberType)) {  
            return new SuperMemberFactory();  
        }else {  
            System.out.println("请输入正确的类型!");  
            return null;  
        }  
   }
}

测试

public class Test {
    public static void main(String[] args) throws Exception {
        //抽象工厂模式，根据条件来创建工厂实例
        IAbstractFactory  factory = new FactoryProducer.getFactory("Member");
        PriceStrategy priceStrategy = factory.getPriceStrategy();
        PointsStrategy pointsStrategy = factory.getPointsStrategy();
        // 创建价格策略上下文环境
        PriceContext priceContext = new PriceContext(priceStrategy );
        // 计算价格
        BigDecimal price = priceContext.getPrice(300);

       // 创建积分策略上下文环境
        PointsContext pointsContext = new PointsContext(pointsStrategy );
        // 计算积分
        BigDecimal points = pointsContext.getPoints(300);

    }
}

到此，我们抽象工厂模式就完结了，从上面可以看出抽象工厂模式的主要特点，是创建一个超级工厂/抽象工厂，这个工厂是用来生产多个普通工厂的，每个普通工厂生产不同的实例，同时各个普通工厂又有业务上的关联，比如共同完成某项业务。
简而言之，就是可以生产多种相关联产品的超级工厂（简单工厂模式只能上产一种产品）