SpringBoot结合策略模式实战套路

程序员文章站 2022-05-29 16:23:57

1. SpringBoot结合策略模式实战套路 1.1. 前言我们都知道设计模式好，可以让我们的代码更具可读性，扩展性，易于维护，但大部分程序猿一开始都学过至少一遍设计模式吧，实战中不知用到了几成。接下来让我介绍一个结合SpringBoot的策略模式套路，让你的代码少些if else 1.2. 开 ......

1. springboot结合策略模式实战套路

1.1. 前言

我们都知道设计模式好，可以让我们的代码更具可读性，扩展性，易于维护，但大部分程序猿一开始都学过至少一遍设计模式吧，实战中不知用到了几成。接下来让我介绍一个结合springboot的策略模式套路，让你的代码少些if-else

1.2. 开撸

废话不多说，直接告诉你今天的核心是@autowired，看到这个是不是很熟悉，你每天都在用，不就是自动注入spring管理的bean吗？但我们对它的用法很多时候就局限在全局变量的注入了，忘记了，它其实还可以构造器注入，类型注入或命名注入，那么结合策略模式会绽放怎样的火花呢？跟着我的代码来看

1.2.1. 计算策略接口

/**
 * @author laoliangliang
 * @date 2019/10/28 10:10
 */
public interface calculatestrategy {
    int dooperation(int num1,int num2);
}

1.2.2. 实现类

分别实现加减乘三个运算，可以看到我用了spring的注解@component，也就是实例由spring管理了

@component
public class addoperation implements calculatestrategy {
    @override
    public int dooperation(int num1, int num2) {
        return num1 + num2;
    }

}

@component
public class substractoperation implements calculatestrategy {
    @override
    public int dooperation(int num1, int num2) {
        return num1 - num2;
    }

}

@component
public class multiplyoperation implements calculatestrategy {
    @override
    public int dooperation(int num1, int num2) {
        return num1 * num2;
    }

}

1.2.3. 上下文

之后创建上下文管理，用于提取策略。这个上下文才是本文的重点，注意到@autowired注解放的位置和对应的参数列表了吗？实际上它还可以注入到map和list，map的key就是它注入时的名，list则是存放全部实例对象

import com.google.common.base.preconditions;
import org.springframework.beans.factory.annotation.autowired;
import org.springframework.stereotype.component;
import org.springframework.util.stringutils;

import java.util.list;
import java.util.map;
import java.util.concurrent.concurrenthashmap;

/**
 * @author laoliangliang
 * @date 2019/10/28 10:14
 */
@component
public class calculateloperationcontext {

//    @autowired
//    private map<string, calculatestrategy> strategymap;

    private final map<string, calculatestrategy> strategymap = new concurrenthashmap<>();

    @autowired
    public void stragegyinteface(map<string, calculatestrategy> strategymap) {
        this.strategymap.clear();
        strategymap.foreach(this.strategymap::put);
        system.out.println(this.strategymap);
    }


    @autowired
    public void stragegyinteface2(list<calculatestrategy> strategymap) {
        strategymap.foreach(system.out::println);
    }

    public calculatestrategy strategyselect(string mode) {
        preconditions.checkargument(!stringutils.isempty(mode), "不允许输入空字符串");
        return this.strategymap.get(mode);
    }
}

打印结果：

{multiplyoperation=com.laoliang.springboot.pattern.strategy.multiplyoperation@372ea2bc, addoperation=com.laoliang.springboot.pattern.strategy.addoperation@4cc76301, substractoperation=com.laoliang.springboot.pattern.strategy.substractoperation@2f08c4b}
com.laoliang.springboot.pattern.strategy.addoperation@4cc76301
com.laoliang.springboot.pattern.strategy.multiplyoperation@372ea2bc
com.laoliang.springboot.pattern.strategy.substractoperation@2f08c4b

可以看到map中key，value的关系，key的默认值为类的第一个字母小写

1.2.4. 控制层

/**
 * @author laoliangliang
 * @date 2019/10/28 10:52
 */
@restcontroller
public class strategycontroller {

    @autowired
    private calculateloperationcontext calculateloperationcontext;

    @requestmapping(value = "/operation")
    public string strategyselect(@requestparam("mode") string mode) {
        return string.valueof(calculateloperationcontext.strategyselect(mode).dooperation(20, 5));
    }
}

启动springboot，浏览器调用http://localhost:8080/operation?mode=multiplyoperation，结果100。模式可以选择另外两个addoperation和substractoperation

我这里就做个演示，输入参数就写固定了，可以看到我们通过上下文calculateloperationcontext调用其方法strategyselect，通过不同的调用参数获得不同的策略，所以业务中只要可以抽象的方法都可以改写成这样的模式。

这种模式套路的好处就是当你要新增一种策略，比如除法，你不需要修改原来的代码，只要抽象不变，你新增一个divideoperation类实现calculatestrategy策略接口加上spring注解即可，调用时模式修改为divideoperation就可以实现调用了，耦合性大大降低，不需要再改原来那一坨自己都看不下去的代码了