脚本之家 服务器常用软件
快捷导航
您的位置：首页 → 软件编程 → java → Spring实现策略模式

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

 更新时间：2024年05月01日 08:04:41   作者：乐嘉明  
在写业务代码的时候,难免会遇到很多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相应的值就可以调用想调用的策略.

以上就是Spring中实现策略模式的几种方式小结的详细内容，更多关于Spring实现策略模式的资料请关注脚本之家其它相关文章！

您可能感兴趣的文章:

相关文章

  • Java中MapStruct的使用详解

    Java中MapStruct的使用详解

    这篇文章主要介绍了Java中MapStruct的使用详解,mapstruct,全称是org.mapstruct.Mapper, 是将接口或抽象类标记为映射器,并通过MapStruct为这个接口或者抽象类生成一个实现类,大大简化了Java bean类型之间转换,需要的朋友可以参考下
    2023-09-09
  • SpringBoot3整合Druid数据源的实现过程

    SpringBoot3整合Druid数据源的实现过程

    文章介绍了一个基于Spring Boot 3的程序实现过程,包括创建项目、引入依赖、编写启动类、配置文件、Controller、启动测试以及问题解决,本文给大家介绍的非常详细,感兴趣的朋友跟随小编一起看看吧
    2025-11-11
  • Java实现Token登录验证的项目实践

    Java实现Token登录验证的项目实践

    本文主要介绍了Java实现Token登录验证的项目实践，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
    2023-03-03
  • Java实现文件变化监控

    Java实现文件变化监控

    这篇文章主要介绍了Java实现文件变化监控的实现代码，代码附有注释，分步骤介绍的非常详细，非常不错，具有参考借鉴价值，,需要的朋友可以参考下
    2016-08-08
  • MybatisPlus批量保存原理及失效原因排查全过程

    MybatisPlus批量保存原理及失效原因排查全过程

    这篇文章主要介绍了MybatisPlus批量保存原理及失效原因排查全过程，具有很好的参考价值，希望对大家有所帮助。如有错误或未考虑完全的地方，望不吝赐教
    2023-01-01
  • JAVA操作MongoDB数据库实例教程

    JAVA操作MongoDB数据库实例教程

    MongoDB是一个文档型数据库,是NOSQL家族中最重要的成员之一,下面这篇文章主要给大家介绍了关于JAVA操作MongoDB数据库的相关资料,文中通过实例代码介绍的非常详细,需要的朋友可以参考下
    2023-05-05
  • 使用JavaSE来模拟斗地主

    使用JavaSE来模拟斗地主

    这篇文章主要介绍了使用JavaSE来模拟斗地主，对棋牌游戏有研究的同学可以参考一下
    2021-04-04
  • 基于hibernate框架在eclipse下的配置方法(必看篇)

    基于hibernate框架在eclipse下的配置方法(必看篇)

    下面小编就为大家带来一篇基于hibernate框架在eclipse下的配置方法(必看篇)。小编觉得挺不错的，现在就分享给大家，也给大家做个参考。一起跟随小编过来看看吧
    2017-09-09
  • Java结合Vue项目打包并进行服务器部署

    Java结合Vue项目打包并进行服务器部署

    本文主要介绍了Java结合Vue项目打包并进行服务器部署，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
    2022-07-07
  • SpringBoot快速实现IP地址解析的全攻略

    SpringBoot快速实现IP地址解析的全攻略

    在当今的互联网应用中,IP地址解析已成为许多系统不可或缺的功能,这篇文章主要为大家详细介绍了如何使用SpringBoot快速实现IP地址解析,有需要的小伙伴可以了解下
    2026-02-02

最新评论