Spring中实现策略模式的几种方式小结_F11 - 专业站长和开发者的学习网站

分享到

Spring中实现策略模式的几种方式小结

java 来源：互联网作者：佚名发布时间：2024-05-01 22:01:34 人浏览

摘要

一.背景在写业务代码的时候，难免会遇到很多if-else，这个时候如果if-else不是很多可以用if-else。如果此时场景过多，太多的if-else会导致代码比较臃肿，所以这个时候就需要抽象化，将每个场

一.背景

在写业务代码的时候，难免会遇到很多if-else，这个时候如果if-else不是很多可以用if-else。如果此时场景过多，太多的if-else会导致代码比较臃肿，所以这个时候就需要抽象化，将每个场景独立开来，定义一个顶层接口，不同场景有不同实现，这个时候策略模式就出现了。本文主要阐述工作中常用的实现策略模式的几种方式。

二.实现一

2.1 定义接口

package com.ljm.service;

import com.ljm.constant.StrategyEnum;

/**

* @Author: ljm

* @Date: 2024/4/29 15:09

* @Version: v1.0.0

* @Description: TODO

**/

public interface IHandler {

void handler();

StrategyEnum getHandleStrategy();

}

2.2 定义枚举

package com.ljm.constant;

/**

* @Author: ljm

* @Date: 2024/4/29 15:10

* @Version: v1.0.0

* @Description: TODO

**/

public enum StrategyEnum {

FIRST, SECOND, THIRD, FOUR

}

2.3 定义实现类

import com.ljm.constant.StrategyEnum;

import com.ljm.service.IHandler;

import org.springframework.stereotype.Service;

/**

* @Author: ljm

* @Date: 2024/4/29 15:12

* @Version: v1.0.0

* @Description: TODO

**/

@Service

public class FirstHandler implements IHandler {

@Override

public void handler() {

System.out.println("Execute First Handler");

}

@Override

public StrategyEnum getHandleStrategy() {

return StrategyEnum.FIRST;

}

package com.ljm.service.impl;

import com.ljm.constant.StrategyEnum;

import com.ljm.service.IHandler;

import org.springframework.stereotype.Service;

/**

* @Author: ljm

* @Date: 2024/4/29 15:12

* @Version: v1.0.0

* @Description: TODO

**/

@Service

public class SecondHandler implements IHandler {

@Override

public void handler() {

System.out.println("Execute Second Handler");

}

@Override

public StrategyEnum getHandleStrategy() {

return StrategyEnum.SECOND;

}

package com.ljm.service.impl;

import com.ljm.constant.StrategyEnum;

import com.ljm.service.IHandler;

import org.springframework.stereotype.Service;

/**

* @Author: ljm

* @Date: 2024/4/29 15:12

* @Version: v1.0.0

* @Description: TODO

**/

@Service

public class ThirdHandler implements IHandler {

@Override

public void handler() {

System.out.println("Execute Third Handler");

}

@Override

public StrategyEnum getHandleStrategy() {

return StrategyEnum.THIRD;

}

package com.ljm.service.impl;

import com.ljm.constant.StrategyEnum;

import com.ljm.service.IHandler;

import org.springframework.stereotype.Service;

/**

* @Author: ljm

* @Date: 2024/4/29 15:12

* @Version: v1.0.0

* @Description: TODO

**/

@Service

public class FourHandler implements IHandler {

@Override

public void handler() {

System.out.println("Execute Four Handler");

}

@Override

public StrategyEnum getHandleStrategy() {

return StrategyEnum.FOUR;

}

2.4 定义策略工厂类

package com.ljm.service;

import com.ljm.constant.StrategyEnum;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.stereotype.Service;

import java.util.List;

import java.util.concurrent.ConcurrentHashMap;

/**

* @Author: ljm

* @Date: 2024/4/29 15:16

* @Version: v1.0.0

* @Description: TODO

**/

@Service

public class HandlerStrategyFactory {

public final ConcurrentHashMap<StrategyEnum,IHandler> handlerStrategyMap = new ConcurrentHashMap<>();

@Autowired

public HandlerStrategyFactory(List<IHandler> iHandlers){

iHandlers.forEach(x -> handlerStrategyMap.put(x.getHandleStrategy(),x));

}

public IHandler getHandleStrategy(StrategyEnum strategyEnum){

return handlerStrategyMap.get(strategyEnum);

}

2.5 测试

package com.ljm;

import com.MyApplication;

import com.ljm.constant.StrategyEnum;

import com.ljm.service.HandlerStrategyFactory;

import org.junit.Test;

import org.junit.runner.RunWith;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.boot.test.context.SpringBootTest;

import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

/**

* @Author: ljm

* @Date: 2024/2/26 10:58

* @Version: v1.0.0

* @Description: TODO

**/

@RunWith(SpringJUnit4ClassRunner.class)

@SpringBootTest(classes = MyApplication.class)

public class MyTest {

@Autowired

private HandlerStrategyFactory handlerStrategyFactory;

@Test

public void testStrategy() {

handlerStrategyFactory.getHandleStrategy(StrategyEnum.FIRST).handler();

handlerStrategyFactory.getHandleStrategy(StrategyEnum.SECOND).handler();

handlerStrategyFactory.getHandleStrategy(StrategyEnum.THIRD).handler();

handlerStrategyFactory.getHandleStrategy(StrategyEnum.FOUR).handler();

/* 测试结果

Execute First Handler

Execute Second Handler

Execute Third Handler

Execute Four Handler*/

}

实现一主要是为IHandler接口新增一个用于区分使用何种策略的方法，再构建一个策略工厂类，利用构造器注入的方式，将Spring中的实现类与相应的枚举类绑定，在使用的时候只需要传入StrategyEnum相应的值就可以调用想调用的策略.

三.实现二

3.1 定义抽象类

package com.ljm.service;

import com.ljm.constant.StrategyEnum;

import org.springframework.beans.factory.InitializingBean;

/**

* @Author: ljm

* @Date: 2024/4/29 15:09

* @Version: v1.0.0

**/

public abstract class AbstractHandler implements InitializingBean {

public abstract void handler();

public abstract StrategyEnum getHandleStrategy();

@Override

public void afterPropertiesSet() throws Exception {

HandlerStrategyFactory.registerHandlerStrategy(this);

}

3.2 定义枚举

package com.ljm.constant;

/**

* @Author: ljm

* @Date: 2024/4/29 15:10

* @Version: v1.0.0

* @Description: TODO

**/

public enum StrategyEnum {

FIRST, SECOND, THIRD, FOUR

}

3.3 定义实现类

package com.ljm.service.impl;

import com.ljm.constant.StrategyEnum;

import com.ljm.service.AbstractHandler;

import org.springframework.stereotype.Service;

/**

* @Author: ljm

* @Date: 2024/4/29 15:12

* @Version: v1.0.0

* @Description: TODO

**/

@Service

public class FirstHandler extends AbstractHandler {

@Override

public void handler() {

System.out.println("Execute First Handler");

}

@Override

public StrategyEnum getHandleStrategy() {

return StrategyEnum.FIRST;

}

package com.ljm.service.impl;

import com.ljm.constant.StrategyEnum;

import com.ljm.service.AbstractHandler;

import org.springframework.stereotype.Service;

/**

* @Author: ljm

* @Date: 2024/4/29 15:12

* @Version: v1.0.0

* @Description: TODO

**/

@Service

public class SecondHandler extends AbstractHandler {

@Override

public void handler() {

System.out.println("Execute Second Handler");

}

@Override

public StrategyEnum getHandleStrategy() {

return StrategyEnum.SECOND;

}

package com.ljm.service.impl;

import com.ljm.constant.StrategyEnum;

import com.ljm.service.AbstractHandler;

import org.springframework.stereotype.Service;

/**

* @Author: ljm

* @Date: 2024/4/29 15:12

* @Version: v1.0.0

* @Description: TODO

**/

@Service

public class ThirdHandler extends AbstractHandler {

@Override

public void handler() {

System.out.println("Execute Third Handler");

}

@Override

public StrategyEnum getHandleStrategy() {

return StrategyEnum.THIRD;

}

package com.ljm.service.impl;

import com.ljm.constant.StrategyEnum;

import com.ljm.service.AbstractHandler;

import org.springframework.stereotype.Service;

/**

* @Author: ljm

* @Date: 2024/4/29 15:12

* @Version: v1.0.0

* @Description: TODO

**/

@Service

public class FourHandler extends AbstractHandler {

@Override

public void handler() {

System.out.println("Execute Four Handler");

}

@Override

public StrategyEnum getHandleStrategy() {

return StrategyEnum.FOUR;

}

3.4 定义策略工厂类

package com.ljm.service;

import com.ljm.constant.StrategyEnum;

import java.util.concurrent.ConcurrentHashMap;

/**

* @Author: ljm

* @Date: 2024/4/29 15:16

* @Version: v1.0.0

* @Description: TODO

**/

public class HandlerStrategyFactory {

public static final ConcurrentHashMap<StrategyEnum, AbstractHandler> handlerStrategyMap = new ConcurrentHashMap<>();

public static void registerHandlerStrategy(AbstractHandler handler) {

handlerStrategyMap.put(handler.getHandleStrategy(), handler);

}

public static AbstractHandler getHandleStrategy(StrategyEnum strategyEnum) {

return handlerStrategyMap.get(strategyEnum);

}

3.5 测试

package com.ljm;

import com.MyApplication;

import com.ljm.constant.StrategyEnum;

import com.ljm.service.HandlerStrategyFactory;

import org.junit.Test;

import org.junit.runner.RunWith;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.boot.test.context.SpringBootTest;

import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

/**

* @Author: ljm

* @Date: 2024/2/26 10:58

* @Version: v1.0.0

* @Description: TODO

**/

@RunWith(SpringJUnit4ClassRunner.class)

@SpringBootTest(classes = MyApplication.class)

public class MyTest {

@Test

public void testStrategy() {

HandlerStrategyFactory.getHandleStrategy(StrategyEnum.FIRST).handler();

HandlerStrategyFactory.getHandleStrategy(StrategyEnum.SECOND).handler();

HandlerStrategyFactory.getHandleStrategy(StrategyEnum.THIRD).handler();

HandlerStrategyFactory.getHandleStrategy(StrategyEnum.FOUR).handler();

/* 测试结果

Execute First Handler

Execute Second Handler

Execute Third Handler

Execute Four Handler*/

}

实现二主要是为AbstractHandler抽象类实现InitializingBean接口,再对象初始化的时候将其注册到我们自己构建的策略工厂类中，此时的对象由Spring生成并与相应的枚举类绑定，在使用的时候只需要传入StrategyEnum相应的值就可以调用想调用的策略.

您可能感兴趣的文章 :

原文链接 :

Tag : spring(73)

Java服务cpu100%的解决过程分享

背景最近一个任务是优化一个导出的功能，但是点击功能时发现，程序长时间无反应，过一段时间又有反应，通过查看服务的监控发现，服
Spring中实现策略模式的几种方式小结

一.背景在写业务代码的时候，难免会遇到很多if-else，这个时候如果if-else不是很多可以用if-else。如果此时场景过多，太多的if-else会导致代
mybatis解决＜foreach＞标签不能超过1000的问题

错误写法： 1 2 3 4 5 6 7 8 select id=getProductInfoList resultType=vo select a.name from A a where a.idin foreach collection=ids item=item index=index open=( close=) separator=
Java如何判断一个整数有多少位

Java判断一个整数有多少位首先，封装一个判断位数的方法；使用for循环进行判断整数的位数。直到传进的整数小于数组中某个值时，停止循
SpringMVC访问controller报错404的解决办法（总结超详

问题描述: 纯注解配置SpringMVC程序，使用tomcat8.5.95版本启动，能启动成功并且访问index.jsp页面，但是访问/save时出现404无法访问，程序如下
SpringBoot启动时执行初始化操作的几种方式总结

场景项目中，经常需要在启动过程中初始化一些数据，如从数据库读取一些配置初始化，或从数据库读取一些热点数据到redis进行初始化缓
java方法重写(重点讲)方法重载问题

一、方法重载定义：一个类中，出现多个方法的名称相同，但是它们的形参列表是不同的，那么这些方法就称为方法重载了。注意：一个类
使用Java实现HTTP和HTTPS代理服务

简单来说就是其他的服务器代替帮你访问HTTP或者HTTPS，当你的网络受限无法访问某些网站时，但是你的代理服务器可以访问某些网站，这时
使用Springboot实现获取某个城市当天的天气预报

获取天气信息作者是通过高德开放平台来实现的。 1、在该平台注册个账号如已经注册，直接登录即可。 2、创建应用创建成功后获取到k
SpringCloud中的服务接口(api)介绍

SpringCloud服务接口(api) SpringCloud的服务接口基本等同于SpringBoot开发的api接口只不过在springCloud需要将自己的服务注册到注册中心，通过网关统