Java设计模式之策略模式

                                                   设计模式（Design Patterns）

                                                                                      ——可复用面向对象软件的基础

设计模式（Design pattern）是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性。 毫无疑问，设计模式于己于他人于系统都是多赢的，设计模式使代码编制真正工程化，设计模式是软件工程的基石，如同大厦的一块块砖石一样。项目中合理的运用设计模式可以完美的解决很多问题，每种模式在现在中都有相应的原理来与之对应，每一个模式描述了一个在我们周围不断重复发生的问题，以及该问题的核心解决方案，这也是它能被广泛应用的原因。

 

一、设计模式的分类

总体来说设计模式分为三大类：

创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。

结构型模式，共七种：适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。

行为型模式，共十一种：策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器模式。
 

                                                

场景：是否遇到过多个if else 的烦恼，列

或者有人说改成switch

switch虽然代码简洁了 但是还是没有解决改效率，假设又增加了DEF一样需要加入caseDEF所以博主今天推荐一个设计模式  

                                                                 ”Strategy" --策略模式

1 首先创建一个工厂接口

package com.kd.springboot_strategy.common;

/**
 * @author Kodak
 * @version 1.0
 * @create 2019/09/27/17:18
 */
public interface Strategy {

	String getVpcList(String id);

}

2 创建context上下文用于实现策略模式者

package com.kd.springboot_strategy.common;

import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

/**
 * @author Kodak
 * @version 1.0
 * @create 2019/09/27/17:19
 */
@Service
@Slf4j
public class SimpleContext {

	@Autowired
	private final Map<String, Strategy> strategyMap = new ConcurrentHashMap<>();

	public SimpleContext(Map<String, Strategy> strategyMap) {
		this.strategyMap.clear();
		strategyMap.forEach((k, v)-> this.strategyMap.put(k, v));
	}

	public String getResource(String poolId){
		String p=null;
		try {
			p=strategyMap.get(poolId).getVpcList(poolId);
		}catch (Exception e){
			p=poolId;
            log.info("返回原始数据",poolId);
		}finally {
			return  p;
		}
	}

}

3 在创建条件 也就是指判断的条件 A

注：把条件当作component组件去判读

package com.kd.springboot_strategy.common;

import org.springframework.stereotype.Component;

/**
 * @author Kodak
 * @version 1.0
 * @create 2019/09/27/17:18
 */
@Component("A")
public class ResourceA implements Strategy {

	@Override
	public String getVpcList(String id) {
		/*执行A事件*/
		System.out.println("A,getVpcList ==========="+id);
		return "A";
	}
}

B

package com.kd.springboot_strategy.common;

import org.springframework.stereotype.Component;

/**
 * @author Kodak
 * @version 1.0
 * @create 2019/09/27/17:18
 */
@Component("B")
public class ResourceB implements Strategy {
	/*执行B事件*/
	@Override
	public String getVpcList(String id) {
		System.out.println("B,getVpcList ==========="+id);
		return "B";
	}
}

C 

package com.kd.springboot_strategy.common;

import org.springframework.stereotype.Component;

/**
 * @author Kodak
 * @version 1.0
 * @create 2019/09/27/17:18
 */
@Component("C")
public class ResourceC implements Strategy {
	/*执行B事件*/
	@Override
	public String getVpcList(String id) {
		System.out.println("B,getVpcList ==========="+id);

		return "C";
	}
}

最后控制层逻辑就一行解决：

package com.kd.springboot_strategy.controller;


import com.kd.springboot_strategy.common.SimpleContext;

import org.junit.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.ArrayList;
import java.util.Date;
import java.util.List;

/**
 * @author Kodak
 * @version 1.0
 * @create 2019/09/27/17:20
 */
@RestController
@RequestMapping("test")
public class TestController {
    @Autowired
    private SimpleContext simpleContext;

    @RequestMapping("/choose")
    public String choose(String poolId){
        return simpleContext.getResource(poolId);
    }
    
}

最后访问：

 

总结：

优点：降低了耦合性，提高了代码的简洁性。当后期需要加入别的逻辑时只需要创建子类去处理，不需要动逻辑块。

缺点：当子条件越来越多的时候需要创建频繁创建多个子类去实现。