设计模式：策略设计模式+工厂设计模式

一 业务场景

根据不同的条件，执行不同的业务逻辑。传统的if else/switch case等判断的写法，造成很多业务代码掺杂在一起，后期不方便扩展及维护。可以使用策略设计模式+工厂设计模式来解决。

二 实现方式

方式一

实现类的路由策略是静态获取的，可以通过在类名上注解。通过@Service注解将实现类注入spring工厂管理，默认bean名字是类名（开头小写）。采用策略涉及模式实现。

1、定义策略接口：

/**
 * @Description:策略接口
 */
public interface AbstractStrategyService {

    /**
     * 执行方法
     *
     * @return
     */
    String execute();
}

2、定义策略接口的实现类：

实例1策略实现类：

import org.springframework.stereotype.Service;

/**
 * @Description: 实例1策略实现类
 */
@Service
public class Instance1StrategyService implements AbstractStrategyService {
    @Override
    public String execute() {
        return "Instance1StrategyService execute success!";
    }
}

实例2策略实现类：

import org.springframework.stereotype.Service;

/**
 * @Description:实例1策略实现类
 */
@Service
public class Instance2StrategyService implements AbstractStrategyService{
    @Override
    public String execute() {
        return "Instance2StrategyService execute success!";
    }
}

3、策略使用

import org.springframework.context.ApplicationContext;

/**
 * @Description:策略使用
 */
public class StrategyProcess {

    private static ApplicationContext applicationContext;

    public static void main(String[] args) {
        //根据类实例名获取实现类
        AbstractStrategyService abstractStrategyService = applicationContext.getBean("instance1StrategyService",
            AbstractStrategyService.class);
        String result = abstractStrategyService.execute();
        System.out.println(result);

    }
}

方式二

如果实现类的路由策略是动态获取的，可以采用策略设计模式+工厂设计模式解决

1、定义策略接口：

/**
 * @Description: 策略接口
 */
public interface AbstractStrategyService {

    /**
     * 执行方法
     * @return
     */
    String execute();

    /**
     * 路由策略ID。动态变化
     * @return
     */
    Long getRoutingId();

}

2、定义策略接口的实现类：

实例1策略实现类：

import org.springframework.stereotype.Service;

/**
 * @Description: 实例1策略实现类
 */
@Service
public class Instance1StrategyService implements AbstractStrategyService{
    @Override
    public String execute() {
        return "Instance1StrategyService execute success!";
    }

    @Override
    public Long getRoutingId() {
        return 1L;
    }
}

实例2策略实现类：

import org.springframework.stereotype.Service;

/**
 * @Description:实例1策略实现类
 */
@Service
public class Instance2StrategyService implements AbstractStrategyService{
    @Override
    public String execute() {
        return "Instance2StrategyService execute success!";
    }

    @Override
    public Long getRoutingId() {
        return 2L;
    }
}

3、策略工厂类，初始化策略Map

import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.function.Function;
import java.util.stream.Collectors;

import org.apache.commons.collections.MapUtils;
import org.springframework.beans.BeansException;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.stereotype.Component;

/**
 * @Description:策略工厂类，初始化策略Map
 */
@Component
public class StrategyServiceFactory implements ApplicationContextAware {

    private static Map<Long, AbstractStrategyService> strategyServiceMap = new ConcurrentHashMap<>();

    /**
     * 根据策略ID获取实现类
     * @param routingId
     * @return
     */
    public static AbstractStrategyService getStrategyService(Long routingId){
        return strategyServiceMap.get(routingId);
    }

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        Map<String, AbstractStrategyService> beanMap = applicationContext.getBeansOfType(AbstractStrategyService.class);

        if (MapUtils.isEmpty(beanMap)) {
            throw new RuntimeException("AbstractStrategyService can not empty!");
        }
        strategyServiceMap = beanMap.values().stream().collect(Collectors.toMap(AbstractStrategyService::getRoutingId,
            Function.identity()));
    }
}

4、使用策略

/**
 * @Description:策略使用
 */
public class StrategyProcess {
    public static void main(String[] args){
        //根据策略ID获取实现类
        String result = StrategyServiceConfig.getStrategyService(1L).execute();
        System.out.println(result);
    }
}

三 总结

使用策略设计模式，代码更优雅，扩展性可读性都会更好。如果新增实例，只需要增加一个实例的实现类即可。另外，可能也会因为过度设计，为了使用策略设计模式而使用，也会有一定的冗余：

策略模式的优点：

1）去除大量的if else/switch case判断逻辑，代码更简洁；

2）代码优雅、提高代码的可读性；

3）符合代码开闭原则、后期扩展性好、方便后期维护；

策略模式的缺点：

1）如果策略实现类很多，会造成策略类膨胀，不易管理；

2）策略类的实现功能和用途需要清楚。