通过具体业务场景学习工厂模式与策略模式

• 入职新公司后熟悉业务过程中收到一个需求，优化一部分代码逻辑，优化时考虑业务的复杂性于是就想到使用设计模式优化这部分逻辑，将原来强耦合的逻辑拆分，便于以后的维护，分析之后确定使用工厂模式与策略模式。

• 先说下具体业务逻辑：首先业务逻辑中对象分为三个维度，分别为单票、大包、批次，每个维度需要执行不同的逻辑，执行逻辑就需要不同的策略来判断；这里策略有两种情况，分别为首次和重算，最后执行的逻辑则是请求其它服务的具体实现。

• 基于这种场景，首先考虑就是对于维度的拆分，单票、大包、批次都有不同的枚举状态来判断，这里我考虑的就是通过工厂模式判断枚举值创建对象。第二，对于首次和重算的策略，单票和大包触发策略的逻辑又不相同，这里我就考虑使用策略模式首先不同维度下的不同策略的生成。

工厂模式实现：

代码如下：

创建通用维度的一个对象Dimension，该对象是一个接口呈现的

public interface Dimension {
    public void create();
}

创建两个具体的对象Parcel、Container实现Dimension，重写方法

public class Parcel implements Dimension {
    @Override
    public void create() {
        //具体逻辑
    }
}
public class Container implements Dimension {
    @Override
    public void create() {
        //具体逻辑
    }
}

创建工厂及实现类

//创建一个工厂接口，定义一个创建对象的方法
public interface DimensionFactory {
    public Dimension create(Class c) throws ClassNotFoundException, IllegalAccessException, InstantiationException;
}


//创建工厂接口的实现类，用于实现具体的维度对象
public class Factory implements DimensionFactory {
    @Override
    public Dimension create(Class c) throws ClassNotFoundException, IllegalAccessException, InstantiationException {
        Dimension dimension = (Dimension)Class.forName(c.getName()).newInstance();
        return dimension;
    }
}

• 工厂模式主要实现为创建不同的维度对象，具体需要创建哪个对象不需要我自己去判断，在工厂中实现这个判断逻辑，我最终只负责接收创建的对象即可，这也是我对工厂模式的理解。将创建对象的具体业务逻辑封装在工厂中，使用时只传递对象的状态即可，最终在工厂中会生产出我们想要的对象。并且这样很好的封装了业务逻辑，将对象的创建与业务逻辑拆分，由工厂实现即可。

策略模式实现：

策略模式：可以理解为定义多种策略，每种策略都进行封装，这是对象的一种行为实现。

策略模式实现如下：

创建策略接口
创建具体策略实现类实现策略接口

//策略接口
public interface Tactics {
    void router();
}




//具体策略实现，首次路由策略
public class FirstRouter implements Tactics {
    @Override
    public void router() {
        //首次路由逻辑
    }
}


//具体策略实现，二次路由实现
public class SecondRouter implements Tactics {
    @Override
    public void router() {
        //路由重算逻辑
    }
}

创建封装策略类，封装策略的具体实现

//封装策略，将策略的具体实现进行封装，禁止外部直接访问该具体实现过程
public class RouterPackage {
    private Tactics tactics = null;
    public RouterPackage(Tactics tactics) {
        this.tactics = tactics;
    }
    public void toDo() {
        tactics.router();
    }
}

通过业务具体实现过程：

//创建父类接口
public abstract class RouterImpl {
    public abstract void router(long dimensionId);
    
    public void doRouter(long dimensionId,int router) {
        
    }
}



//单票首次路由逻辑：
public class ParcelFirstRouter extends RouterImpl{
    @Override
    public void router(long dimensionId) {
        //实现逻辑
    }
}




//包裹首次路由实现：
public class ContainerFirstRouter extends RouterImpl{
    @Override
    public void router(long dimensionId) {
        //实现逻辑
    }
}

工厂实现：

//创建工厂

public abstract class RouterFactory {
    abstract RouterImpl createRouter(Class c);
}




//工厂实现类实现具体的策略
public class FirstRouterFactory extends RouterFactory
{
    @Override
    RouterImpl createRouter(Class c) {
        RouterImpl router = null;
        try {
            router = (RouterImpl)Class.forName(c.getName()).newInstance();
        }catch (Exception e) {
            e.printStackTrace();
        }
        return router;
    }
}

将生成的策略执行具体的策略逻辑

public class RouterContext {
    private RouterImpl routerImpl;

    public RouterContext(RouterImpl router) {
        this.routerImpl = router;
    }

    public void doRouter(long id) {
        //具体的执行逻辑
    }
}

将工厂模式与策略模式结合实现

public class FactoryAndTactis {
    public void sendRouter(long id) {
        //创建工厂
        ParcelFirstRouterFactory firstRouterFactory = new ParcelFirstRouterFactory();

        DimensionEntity parcel = getDimension(id);
        //执行首次路由
        if (parcel.getType == Dimension.PARCEL_FIRST) {
            //首次路由
            ParcelFirstRouter  parcelFirstRouter = firstRouterFactory.createRouter(ParcelFirstTactis.class);
            RouterContext routerContext = new RouterContext(parcelFirstRouter);
            routerContext.doRouter(parcel.getId);
        } else if (parcel.getType == Dimension.PARCEL_SECOND) {
            //二次路由
        }
    }
}

通过以上实现，工厂模式可以帮助我们生产具体的策略对象，策略模式保证策略对象可以自由的切换而不需要改动其它逻辑，从而达到解耦的目的。如果需要新增一种策略时，直接实现RouterImpl接口即可，无需其它改动。