设计模式-策略模式与工厂模式的在项目中的结合使用

这个模式涉及到三个角色：

● 环境(Context)角色：持有一个Strategy的引用。

● 抽象策略(Strategy)角色：这是一个抽象角色，通常由一个接口或抽象类实现。此角色给出所有的具体策略类所需的接口。

● 具体策略(ConcreteStrategy)角色：包装了相关的算法或行为。

 

工厂模式与策略模式的不同之处：

1.工厂模式是创建型模式（关注对象的创建），策略模式是行为型模式（关注行为的封装）

2.工厂模式不需要关注怎么时间，但是策略模式针对每个功能实现不同的策略。

3.策略模式是对算法的包装

 

优点：

1.扩展性好

2.高内聚低耦合

 

缺点：

1.所有策略类都需要对外暴露

2.策略类会很多

 

 

 

举例说明：

•  

  工厂模式 

  有一天你决定去吃培根披萨，首先得选择店铺，A店和B店都有培根披萨； 

  你点了A店的培根披萨，过了二十分钟，你的披萨就来了就可以吃到了。但这个披萨是怎么做的，到底面粉放了多少，培根放了多少，佐料放了多少，有多少道工序，你是不需要管的，你需要的是一个美味培根披萨。

•  

  策略模式 

  在披萨店，你要一个培根披萨，老板说有标准的pizza，也可以自己去做。原料有培根、面粉、佐料。工序有1、2、3工序，你自己去做吧。然后你就需要自己去做，到底放多少培根，放多少面粉，放多少佐料，这都你自己来决定，工序1、2、3，你是怎么实现的，都你自己决定。最后你得到了披萨。

Springboot-demo实例（策略与工厂结合）：

环境(Context)角色：
@Component
public class RuleContext {

    @Resource
    private rulesFactory bizRuleFactory;

    public void process(RulesProcessorBO rulesProcessorBO) {

        bizRuleFactory.creator(rulesProcessorBO.getRuleCode()).process(rulesProcessorBO);

    }

}

抽象策略(Strategy)角色：
public interface RuleStrategy<T extends RulesProcessorBO> {
    
    void process(T t);
}

具体策略(ConcreteStrategy)角色：
@Component
@Transactional(propagation = Propagation.REQUIRED, rollbackFor = Exception.class)
public class selectStrategy implements RuleStrategy<selectProcessorBo> {

    @Autowired
    private ManagerMapper managerMapper;

    @Override
    public void process(selectProcessorBo rulesProcessorBO) {
        Manager m = managerMapper.getById("1");
        System.out.println(m.toString());

    }
}
添加一个算法工厂，调用的之后来工厂取出相应的策略。
@Component
public class rulesFactory {
    private static final Map<Integer,RuleStrategy> map = new HashMap<>(20);

    @Resource
    public selectStrategy selectStrategy;

    //@PostConstruct 用来修饰一个非静态的void()方法.而且这个方法不能有抛出异常声明。在服务器加载Servlet的时候运行,并且只会被服务器调用一次
    @PostConstruct
    public void init(){
        map.put(1,selectStrategy);
    }

    public RuleStrategy creator(Integer type) {
        return map.get(type);
    }
}

另外一种写法也很巧妙：
 

/**
* 规则处理工厂类
*
* @author 
* @version V1.0
* @since 2018-12-03 15:26
*/
public class RulesProcessorFactory {

    public Map<String, RulesProcessor> map = new ConcurrentHashMap<>();

    public RulesProcessorFactory(List<RulesProcessor> list) {
        for (RulesProcessor processor : list) {
            map.put(processor.getRuleType(), processor);
        }
    }

    public RulesProcessor getRulesProcessor(String ruleType) {
        return map.get(ruleType);
    }
}

/**
* 规则处理器接口
*
* @author 
* @version V1.0
* @since 2018-12-03 15:02
*/
public interface RulesProcessor<T extends RulesProcessorBo> {
    String getRuleType();

    boolean process(T t);
}

/**
* 处理器数据封装，如有自定义数据，请继承此类
*
* @author 
* @version V1.0
* @since 2018-12-03 15:18
*/
public class RulesProcessorBo implements Serializable {

    private String projectCode;
    private String userCode;

    public String getProjectCode() {
        return projectCode;
    }

    public void setProjectCode(String projectCode) {
        this.projectCode = projectCode;
    }

    public String getUserCode() {
        return userCode;
    }

    public void setUserCode(String userCode) {
        this.userCode = userCode;
    }
}

调用：
/**
*
* @author Guoz
* @version V1.0
* @since 2018-12-03 19:13
*/
public class ProductSelectRuleBo extends RulesProcessorBo {
    private ProductSelectBO productSelectBO;

    public ProductSelectBO getProductSelectBO() {
        return productSelectBO;
    }

    public void setProductSelectBO(ProductSelectBO productSelectBO) {
        this.productSelectBO = productSelectBO;
    }
}


/**
* @author Guoz
* @version V1.0
* @since 2018-12-03 16:54
*/
@Component
public class productSelectRuleProcessor implements RulesProcessor<ProductSelectRuleBo> {

    @Autowired
    private ProductSelectCsMapper productSelectCsMapper;

    /**
     * 入围规则名称规范：RULES_模块名_功能名_1234
     *
     * @return
     */
    @Override
    public String getRuleType() {
        return "RULES_AM_SELECT_PRODUCT";
    }

    @Override
    public boolean process(ProductSelectRuleBo productSelectRuleBo) {
        return true;
    }

}