-
入职新公司后熟悉业务过程中收到一个需求,优化一部分代码逻辑,优化时考虑业务的复杂性于是就想到使用设计模式优化这部分逻辑,将原来强耦合的逻辑拆分,便于以后的维护,分析之后确定使用工厂模式与策略模式。
-
先说下具体业务逻辑:首先业务逻辑中对象分为三个维度,分别为单票、大包、批次,每个维度需要执行不同的逻辑,执行逻辑就需要不同的策略来判断;这里策略有两种情况,分别为首次和重算,最后执行的逻辑则是请求其它服务的具体实现。
-
基于这种场景,首先考虑就是对于维度的拆分,单票、大包、批次都有不同的枚举状态来判断,这里我考虑的就是通过工厂模式判断枚举值创建对象。第二,对于首次和重算的策略,单票和大包触发策略的逻辑又不相同,这里我就考虑使用策略模式首先不同维度下的不同策略的生成。
工厂模式实现:
代码如下:
创建通用维度的一个对象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接口即可,无需其它改动。