巧用 Spring 自动注入实现策略模式升级版

已于 2022-02-25 22:59:21 修改
阅读量3.4k 收藏 36
点赞数 20
分类专栏： 问题积累 通用方案 文章标签： spring 策略模式 java
于 2021-11-12 00:05:04 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/w605283073/article/details/121278803
版权

一、前言

1.1 背景

在工作过程中，有时候需要根据不同的枚举（常量）执行不同的逻辑。

比如不同的用户类型，使用不同的优惠政策；不同的配置变化，走不同的处理逻辑等。

下面模拟一个根据不同用户类型，走不同业务逻辑的案例。

不同的用户类型有不同的处理方式，接口为 Handler ,示例代码如下：

public interface Handler {

    void someThing();
}

1.2 不同同学的做法

在这里插入图片描述

1.2.1 switch case 模式

小A同学，通过编写 switch 来判断当前类型，去调用对应的 Handler:

@Service
public class DemoService {

    @Autowired
    private CommonHandler commonHandler;

    @Autowired
    private VipHandler vipHandler;

    public void test(){
      String type ="Vip";
      switch (type){
          case "Vip":
              vipHandler.someThing();
              break;
          case "Common":
              commonHandler.someThing();
              break;
          default:
              System.out.println("警告");
      }
    }
}

这样新增一个类型，需要写新的 case 语句，不太优雅。

1.2.2 xml 注入 type 到 bean 的映射

小B 同学选择在 Bean 中定义一个 Map<String,Handler> 的 type2BeanMap，然后使用 xml 的方式，将常量和对应 bean 注入进来。

【注意】： 这里的 key 并不是 beanName ，而是某个业务枚举值，如用户类型

<bean id="demoService" class="com.demo.DemoService">
	<property name="type2BeanMap">
		<map>
			<entry key="Vip" value-ref="vipHandler"></entry>
			<entry key="Common" value-ref="commonHandler"></entry>
		</map>
	</property>
</bean>

这样拿到用户类型（vip 或 common）之后，就可以通过该 map 拿到对应的处理 bean 去执行，代码清爽了好多。

@Service
public class DemoService {

    @Setter
    private Map<String,Handler> type2BeanMap;

    public void test(){
        String type ="Vip";
        type2BeanMap.get(type).someThing();
    }
}

这样做会导致，新增一个策略虽然不用修改代码，但是仍然需要修改SomeService 的 xml 配置，本质上和 switch 差不多。

如新增一个 superVip 类型

<bean id="demoService" class="com.demo.DemoService">
	<property name="type2BeanMap">
		<map>
			<entry key="Vip" value-ref="vipHandler"></entry>
			<entry key="Common" value-ref="commonHandler"></entry>
				<entry key="SuperVip" value-ref="superVipHandler"></entry>
		</map>
	</property>
</bean>

那么有没有更有好的解决办法呢？如果脱离 Spring 又该如何实现？

二、解法

2.1 自动注入

import org.springframework.stereotype.Component;

@Component("Vip")
public class VipHandler implements Handler{
   
    @Override
    public void someThing() {
        System.out.println("Vip用户，走这里的逻辑");
    }


}

使用 @Autowired 注解 自动注入 beanName -> Bean 即可使用：

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

import java.util.HashMap;
import java.util.Map;


@Service
public class DemoService {

    @Autowired
    private   Map<String,Handler> beanMap = new HashMap<>();

    public void test()  {

        // 执行逻辑
        String type ="Vip";
        beanMap.get(type).someThing();
    }

}

这样写法比较简洁，很好的解决了问题。

如果当前场景比较简单，建议可以采用这种办法。

值得探讨的是，使用业务类型当做 Bean 的 name 是否合适？（中性的描述）

（1）同一个业务枚举可能会有多种策略，如果每种策略都以业务类型作为 name 会出现很多重名不同类型的 Bean，是否会造成困惑？

（2）如果业务枚举名称有修改，Bean 是否能更快感知到影响（如 这里的 VIp 被改为了 Star 那么每个 策略的 name 都要进行修改)
（3）有时候不是简单的类型 -> bean 的映射，可能是每个 Class -> Bean 或者 Bean -> Bean 的映
此时这种方法就不太能完美的解决。

如果不希望业务类型影响到 Bean 的 name ，当业务枚举修改时，可强感知到影响的地方，可以使用下面几种解法。

2.2 PostConstruct

对 Handler 接口新增一个方法，用于区分不同的用户类型。

public interface Handler {

    String getType();

    void someThing();
}

每个子类都给出自己可以处理的类型，如：

import org.springframework.stereotype.Component;

@Component
public class VipHandler implements Handler{
    @Override
    public String getType() {
        return "Vip";
    }

    @Override
    public void someThing() {
        System.out.println("Vip用户，走这里的逻辑");
    }
}

普通用户：

@Component
public class CommonHandler implements Handler{

    @Override
    public String getType() {
        return "Common";
    }

    @Override
    public void someThing() {
        System.out.println("普通用户，走这里的逻辑");
    }
}

然后在使用的地方自动注入目标类型的 bean List 在初始化完成后构造类型到bean 的映射：


import javax.annotation.PostConstruct;
import java.util.List;
import java.util.Map;
import java.util.function.Function;
import java.util.stream.Collectors;

@Service
public class DemoService {

    @Autowired
    private List<Handler> handlers;

    private Map<String, Handler> type2HandlerMap;

    @PostConstruct
    public void init(){
        type2HandlerMap= handlers.stream().collect(Collectors.toMap(Handler::getType, Function.identity()));
    }
    public void test(){
      String type ="Vip";
      type2HandlerMap.get(type).someThing();
    }
}

此时，Spring 会自动将 Handler 类型的所有 bean 注入 List<VipHandler> handlers 中。

注意：如果同一个类型可以有多处理器，需定义为 private Map<String, List<Handler> type2HandlersMap 然后在 init 方法进行构造即可，示例代码：

@Service
public class DemoService {

    @Autowired
    private List<Handler> handlers;

    private Map<String, List<Handler>> type2HandlersMap;

    @PostConstruct
    public void init(){
        type2HandlersMap= handlers.stream().collect(Collectors.groupingBy(Handler::getType));
    }

    public void test(){
      String type ="Vip";
      for(Handler handler : type2HandlersMap.get(type)){
          handler.someThing();;
      }
    }
}

2.3 实现 InitializingBean 接口

然后 init 方法将在依赖注入完成后构造类型到 bean 的映射。（也可以通过实现 InitializingBean 接口，在 afterPropertiesSet 方法中编写上述 init 部分逻辑。
）

在执行业务逻辑时，直接可以根据类型获取对应的 bean 执行即可。

测试类：

public class AnnotationConfigApplication {
    
    public static void main(String[] args) throws Exception {
        ApplicationContext ctx = new AnnotationConfigApplicationContext(QuickstartConfiguration.class);
        DemoService demoService = ctx.getBean(DemoService.class);
        demoService.test();
    }
}

运行结果：

Vip用户，走这里的逻辑

当然这里的 getType 的返回值也可以直接定义为枚举类型，构造类型到bean 的 Map 时 key 为对应枚举即可。

大家可以看到这里注入进来的 List<Handler> 其实就在构造type 到 bean 的映射 Map 时用到，其他时候用不到，是否可以消灭掉它呢？

2.4 实现 ApplicationContextAware 接口

我们可以实现 ApplicationContextAware 接口，在 setApplicationContext 时，通过 applicationContext.getBeansOfType(Handler.class) 拿到 Hander 类型的 bean map 后映射即可：

@Service
public class DemoService implements ApplicationContextAware {


    private Map<String, List<Handler>> type2HandlersMap;

    public void test(){
      String type ="Vip";
      for(Handler handler : type2HandlersMap.get(type)){
          handler.someThing();;
      }
    }


    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {

        Map<String, Handler> beansOfType = applicationContext.getBeansOfType(Handler.class);
        beansOfType.forEach((k,v)->{
            type2HandlersMap = new HashMap<>();
            String type =v.getType();
            type2HandlersMap.putIfAbsent(type,new ArrayList<>());
            type2HandlersMap.get(type).add(v);
        });
    }
}

在实际开发中，可以结合根据实际情况灵活运用。

可能很多人思考到这里就很满足了，但是作为有追求的程序员，我们不可能止步于此。

三、More

3.1 如果 SomeService 不是 Spring Bean 又该如何解决？

如果 Handler 是 Spring Bean 而 SomeService 不是 Spring 的 Bean，可以同样 @PostConstruct 使用 ApplicationHolder 的方式构造映射。

构造 ApplicationHolder ：

import org.springframework.beans.BeansException;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.stereotype.Component;

import java.util.Map;

@Component
public class ApplicationContextHolder implements ApplicationContextAware {
    private static ApplicationContext context;
    
    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        ApplicationContextHolder.context = applicationContext;
    }

    public static <T> T getBean(String id, Class<T> tClass) {
        return context.getBean(id,tClass);
    }

    public static <T> Map<String,T> getBeansOfType(Class<T> tClass){
        return context.getBeansOfType(tClass);
    }

}

编写 DemoService:


public class DemoService {

        private static final Map<String,Handler> TYPE_TO_BEAN_MAP = null;


    public void test(){
        // 构造 map
        initType2BeanMap();

        // 执行逻辑
        String type ="Vip";
        type2BeanMap.get(type).someThing();
    }

    private  synchronized void initType2BeanMap() {
        if (TYPE_TO_BEAN_MAP == null) {
            TYPE_TO_BEAN_MAP = new HashMap<>();

            Map<String, Handler> beansOfType = ApplicationContextHolder.getBeansOfType(Handler.class);
            beansOfType.forEach((k,v)->{
                TYPE_TO_BEAN_MAP.put(v.getType(),v);
            });
        }
    }
}

加上锁，避免首次构造多个 DemoService 时，多次执行 initType2BeanMap。

3.2 如果 Handler 也不是 Spring 的Bean 怎么办？

3.2.1 基于反射

      <!-- https://mvnrepository.com/artifact/org.reflections/reflections -->
        <dependency>
            <groupId>org.reflections</groupId>
            <artifactId>reflections</artifactId>
            <version>0.10.2</version>
        </dependency>

示例代码：

import org.reflections.Reflections;

import java.util.HashMap;
import java.util.Map;
import java.util.Set;

import static org.reflections.scanners.Scanners.SubTypes;


public class DemoService {

    private static final Map<String,Handler> TYPE_TO_BEAN_MAP = new HashMap<>();

    private  synchronized void initType2BeanMap()  {
        try{
        // 构造方法中传入扫描的目标包名
                Reflections reflections = new Reflections("com.demo.xxx");
                Set<Class<?>> subTypes =  reflections.get(SubTypes.of(Handler.class).asClass());
                for(Class<?> clazz : subTypes){
                    Handler  handler = (Handler)clazz.newInstance();
                    TYPE_TO_BEAN_MAP.put(handler.getType(),handler);
                }
        }catch(Exception ignore){
            // 实际编码时可忽略，也可以抛出
        }

    }

    public void test()  {

        // 构造 map
        initType2BeanMap();

        // 执行逻辑
        String type ="Vip";
        TYPE_TO_BEAN_MAP.get(type).someThing();
    }


}

运行测试代码正常：

public class Demo {
    public static void main(String[] args) {
        DemoService demoService = new DemoService();
        demoService.test();
    }
}

运行结果

Vip用户，走这里的逻辑

本质上是通过 Java 反射机制来扫描某个接口子类型来代替 Spring 通过 BeanFactory 扫描里面某种类型的 Bean 机制，大同小异。

虽然这里用到了反射，但是只执行一次，不会存在性能问题。

3.2.2 基于 SPI

可以在外部 Jar 包内定义实现，使用 SPI 机制获取所有实现，执行操作。

3.2.3 其他 （待补充)

可以在构造子类型时自动将自身添加都某个容器中，这样使用时直接从容器拿到当前对象即可。

可能还有其他不错的方式，欢迎补充。

四、总结

本文简单介绍了通过 Spring 自动注入实现策略模式的方法，还提供了在非 Spring 环境下的实现方式。

避免新增一个新的 bean 时，多一处修改（硬编码 or 硬配置）。

对编写新的处理类的同学来说非常友好，符合开闭原则，符合封装复杂度的要求。

创作不易，你的支持和鼓励是我创造的最大动力，如果本文对你有帮助，欢迎点赞、收藏，也欢迎评论和我交流。
在这里插入图片描述

明明如月学长
关注
专栏目录
Spring 结合策略模式，如何优雅的实践（普通注入，Map注入，自定义注解注入）
Crazy_Cw的博客
09-23 3467
Spring 结合策略模式，优雅的实践（普通注入，Map注入，自定义注解注入）
策略模式（Strategy）
xxxxx
06-17 167
分离算法，选择实现。 提供解决某一问题的算法族，允许用户从算法族中任选一个算法解决问题，方便更换算法或增加新算法。客户端决定调用哪个算法。 假设场景：一个报价系统，根据不同类型的用户及采购商品数量，给不同的折扣。 建立一个策略接口。 public interface Strategy { public double getPrice(double standardPrice); } 不同...
Spring中如何优雅的使用策略模式
最新发布
weixin_46425661的博客
08-05 1218
策略模式是什么，在Spring中如何优雅的使用
Spring下使用策略模式
06-08
NULL 博文链接：https://zl4.iteye.com/blog/2333003
巧用 Spring 自动注入快速实现策略模式
qfchenjunbo的博客
12-03 486
最近看同事的代码时候，学到了个小技巧，在某些场景下非常挺有用的，这里分享一下给大家。 Spring 中@Autowired注解，大家应该不会陌生，用过 Spring 的肯定也离不开这个注解，通过这个注解可以帮我们自动注入我们想要的 Bean。 除了这个基本功能之外，@Autowired还有更加强大的功能，还可以注入指定类型的数组，List/Set 集合，甚至还可以是 Map 对象。 比如说当前应用有一个支付接口PayService,分别需要对接支付宝、微信支付、银行卡，所以分别有三个不同实现...
浅谈Spring自动注入实现策略模式
weixin_42552851的博客
08-30 847
前几天，导师分配了一个任务，让我优化几个if语句用策略模式的方法。下面介绍两种实现方法： 1.工厂模式+策略模式 2.spring自动注入 方法一： 首先是工厂模式+策略模式的方案，我们先定义一个技能种类的接口 public interface SkillType { //释放技能 void release(); } 创建实现类 public class SkillTypeImpl_1 implements SkillType { @Override pu
Spring framework Day11:策略模式中注入所有实现类
zhiqiuqiu2的博客
10-12 1213
现在大家可以理解这句话的意思了吧，我把支付的方法抽象出来，定义一个接口，但是具体的实现交给了实现它的实现类去完成，每一种实现都是独立的，如果现在需要新增一个支付方式该怎么办呢？很简单，只需要再新增一个实现类去继承 Payment 支付接口即可，具体的实现也是这个实现类去完成，把每个不同类型的支付方式都分别交给独立的实现类去完成，交给用户去选择。
基于Spring自动注入快速实现策略模式+工厂模式优化过多的if..else
m0_74444744的博客
12-21 2103
基于Spring自动注入快速实现策略模式+工厂模式优化过多的if..else
使用工厂方法模式实现算法管理
06-17
3. **Spring自动装配**：Spring框架的自动装配功能允许开发者声明依赖关系，而无需显式地在代码中创建对象。通过XML配置或注解方式，Spring能自动将所需的服务或对象注入到其他组件中。这极大地简化了代码并提高了可...
MyBatis升级版Dwr+Spring
06-03
【标题】"MyBatis升级版Dwr+Spring"揭示了一个关于将MyBatis与Dwr（Direct Web Remoting）和Spring框架进行整合的主题。在Web应用开发中，这种集成可以提升应用程序的交互性和实时性，同时利用MyBatis的强大数据持久...
使用 Spring Boot Admin 管理和监控 Spring Boot 应用程序
AI天才研究院
08-05 1625
Spring Boot 是一款开源框架，它让初学者能够快速地开发出基于 Spring 框架的应用程序。在过去的一年中，Spring Boot 在 GitHub 上持续活跃，在全球范围内取得了令人瞩目的数据，获得了大量关注。目前，Spring Boot 的版本号已经从 2.x 发展到了 2.5.x、2.6.x 和 2.7.x。
spring如何动态指定具体实现类
09-01
主要为大家详细介绍了spring如何动态指定具体实现类,具有一定的参考价值，感兴趣的小伙伴们可以参考一下
spring项目如何升级mysql包_springboot简单demo实践(IDEA+springBoot2+mysql)-操作数据库
weixin_42365198的博客
01-30 327
参考链接因为参考上面的博文发现有几个问题，解决问题之后把自己的完整步骤整理如下，在搭建项目时遇到的问题也整理出来。我用的springboot的版本是2.1，参考博文应该是1.5，版本不一样有些api就不一样了，遇到问题可以看看参考。springboot项目搭建(更新中)环境：mac系统所需工具：IDEA(jdk1.8)+mysql+postman下载地址：idea、 mysql、mysql w...
Java设计模式综合运用(门面+模版方法+责任链+策略)
landy8530的专栏
06-04 2132
&gt; 引言：很久没有更新了，主要是工作忙。最近，工作中一个子系统升级，把之前不易扩展的缺点给改进了一下，主要是运用了几个设计模式进行稍微改造了一下。#1.项目背景在公司的一个实际项目中，需要做一个第三方公司（以下简称GMG）的系统集成工作，把该公司的一些订单数据集成到自己公司平台下，各个订单具有一些共性，但是也有其特有的特征。 经过设计，目前我把订单分为POLICY和BOB类型（暂且这么说吧，...
基于Spring自动注入的策略模式
kismet2399的博客
10-25 4127
一 背景: 比如我现在要一个具体的活动进行crud 但我的活动分成多种活动模式如:秒杀,折扣等,这样就不能统一对具体活动进行crud 二 传统方式: 1,我就要通过创建不同活动类型的service如:ISeckillActivityService,IDiscountActivityService等 2,在要进行crud的地方,通过活动的类型去做if判断/switch,来调用相应的ser...
Spring自动注入使用工厂策略模式实战
qq_35850889的博客
11-26 841
Spring自动注入使用工厂策略模式实战
Spring中实现策略模式示例
极道Jdon的技术博客
02-24 1504
如果 Spring 的代码或我们的类名在未通知的情况下发生变化，这种对 Spring 内部 Bean 名称的依赖可能会导致问题。此功能允许我们在接口的默认方法中使用 @Autowired，这样我们就可以在向导接口中注册每个 CurseStrategy，而无需在每个策略实现中实现注册方法。Spring 提供了一个神奇的功能，允许我们以 List 的形式注入一个接口的多个实现，这样我们就可以用它来注入策略并在它们之间切换。它简化了代码并提高了效率。我们可以在向导中注入我们的诅咒（策略），并筛选出所需的诅咒。
Spring自动注入实现策略模式+工厂模式，干掉 if else
u010679782的博客
10-25 434
在日常的需求中，难免会遇到各种奇奇怪怪的需求，需要各种if else进行实现，但是如果我们使用if else进行实现，一是代码量比较多，二是可维护性比较不强，特别是改别人的代码通过支付宝、微信、银行卡三种方式进行支付，后期可能会增加其他的支付方式只是以这个为例子，不一定支付场景就需要使用模式来进行实现。
评论 5
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

明明如月学长

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值