使用抽象工厂设计一个简单的交易模块

　　

整理一下工作中用过的一些设计模式，为了尽量贴近实际应用，这里使用一个电商平台来模拟在不同模块下使用设计模式。

本文主要讲解用抽象工厂来编写交易模块的代码（订单、支付、评论）：

 

如上图示，先声明三个接口IEval、IPay、IOrder，分别表示三个功能，然后将这三个功能的入口集成在抽象工厂里，然后用BussinesFactory继承抽象工厂，在其内部完成对这三个工程的创造，下面我们用代码来实现：

• 首先声明三个接口，对应支付、订单、评价三个功能
  

//支付接口
public interface IPay {
    public boolean pay(OrderEntity orderEntity);
    public boolean backPay(OrderEntity orderEntity);
}

//订单接口
public interface IOrder {
    public List<OrderEntity> findOrder(OrderEntity orderCondition);
    public List<OrderEntity> updateOrder(OrderEntity order);
    public OrderEntity addOrder(OrderEntity order);
}
//评价接口
public interface IEval {
    public EvalEntity addEval(EvalEntity evalEntity);
    public EvalEntity appendEval(EvalEntity evalEntity);
}

 

•  然后对这三个接口进行具体的实现

//评价的实现类
public class EvalService implements IEval {
    @Override
    public EvalEntity addEval(EvalEntity evalEntity) {
　　　　 System.out.println("完成了一次评价");
        return null;
    }
    @Override
    public EvalEntity appendEval(EvalEntity evalEntity) {
        return null;
    }
}
//订单的实现类
public class OrderService implements IOrder {
    @Override
    public List<OrderEntity> findOrder(OrderEntity orderCondition) { return null; }
    @Override
    public List<OrderEntity> updateOrder(OrderEntity order) { return null;}
    @Override
    public OrderEntity addOrder(OrderEntity order) {
        System.out.println("创建了一个订单");
        return null;
    }
}
public class PayService implements IPay {
    private String payType = "";
    //这里使用带参的构造，传入哪种实体类，就决定当前对象的支付形态
    //当然后续我们可以改造这个类，实现IPay接口，实现支付的解耦，使用多态的方式来进行支付的实现
    public PayService(AlipayModel alipayModel) {
        payType = alipayModel.PAY_TYPE;
    }
    public PayService(WePayModel wePayModel) {
        payType = wePayModel.PAY_TYPE;
    }
    public PayService(ApplePayModel applePayModel) {
        payType = applePayModel.PAY_TYPE;
    }
    @Override
    public boolean pay(OrderEntity orderEntity) {
        System.out.println("使用了"+payType+"支付!");
        return false;
    }

    @Override
    public boolean backPay(OrderEntity orderEntity) {
        return false;
    }
}

 

• 编写抽象工厂和具体的工厂对象

public abstract class AbstractFactory {
    public abstract IEval createEval();
    public abstract IOrder createOrder();
    public abstract IPay createPay(PayModel payModel);
}
public class BussinesFactory extends AbstractFactory {
    @Override
    public IEval createEval() {
        return new EvalService();
    }
    @Override
    public IOrder createOrder() { return new OrderService(); }
    @Override
    public IPay createPay(PayModel payModel) {
        if(payModel instanceof AlipayModel){
            return new PayService((AlipayModel)payModel);
        }
        if(payModel instanceof WePayModel){
            return new PayService((WePayModel)payModel);
        }
        return new PayService((ApplePayModel)payModel);
    }
}

 

• 编写测试类

public static void main(String[] args) {
    AbstractFactory factory = new BussinesFactory();
    AlipayModel alipayModel = new AlipayModel();
    factory.createOrder().addOrder(null);
    IPay payService = factory.createPay(alipayModel);
    payService.pay(null);
    factory.createEval().addEval(null);
}

 

执行之后可以看到以下输出结果：

创建了一个订单
使用了阿里支付!
完成了一次评价

以上就完成了一个很简单的抽象工程，各个模块之间只关注model的传递，完全解耦，比如后续还需要添加一个express功能，也不会对已有的功能代码产生影响。