首页 > 编程语言 >Java设计模式-策略模式-基于Spring实现

Java设计模式-策略模式-基于Spring实现

时间：2023-10-13 14:34:16浏览次数：39  
标签：Java String Spring beanName import 设计模式 type public 策略

1、策略模式

1.1、概述

策略模式是一种行为设计模式，它允许在运行时选择算法的行为。它将算法封装在独立的策略类中，使得它们可以相互替换，而不影响客户端代码。这种模式通过将算法的选择从客户端代码中分离出来，提供了更大的灵活性和可维护性。

在Java中，策略模式的设计理念可以通过以下步骤实现：

  1. 定义一个策略接口（或抽象类），该接口定义了所有具体策略类都必须实现的方法。
  2. 创建具体的策略类，实现策略接口，并提供具体的算法实现。
  3. 在客户端代码中，创建一个策略对象，并将其传递给需要使用算法的对象。
  4. 客户端对象使用策略对象来执行特定的算法。

在你提供的代码片段中，我无法确定与策略模式相关的代码。如果你有更多的上下文或示例代码，我可以更好地帮助你理解和应用策略模式。

1.2、优缺点

策略模式具有以下优点：

  • 可以代替if-else

  1. 算法的独立性：策略模式将算法封装在独立的策略类中，使得算法可以独立于客户端代码进行修改和扩展。这样可以提高代码的灵活性和可维护性。

  2. 可替换性：由于策略模式将算法封装在不同的策略类中，因此可以在运行时动态地切换和替换算法。这样可以根据不同的需求选择最合适的算法，而无需修改客户端代码。

  3. 单一职责原则：策略模式将不同的算法封装在不同的策略类中，使得每个策略类只负责一个具体的算法。这样符合单一职责原则，提高了代码的可读性和可维护性。

  4. 扩展性：由于策略模式将算法封装在独立的策略类中，因此可以很容易地添加新的策略类来扩展系统的功能。

策略模式也有一些缺点：

  1. 增加了类的数量：使用策略模式会增加系统中的类的数量，因为每个具体的算法都需要一个对应的策略类。这可能会增加代码的复杂性和理解难度。

  2. 客户端必须了解所有的策略类：客户端必须了解所有可用的策略类，并在运行时选择合适的策略。这可能会增加客户端代码的复杂性。

  3. 策略切换的开销：在运行时切换策略可能会带来一定的开销，特别是在需要频繁切换策略的情况下。这可能会影响系统的性能。

综上所述，策略模式在提供灵活性、可维护性和可扩展性方面具有很多优点，但也需要权衡其增加的类数量和策略切换的开销。在设计和使用策略模式时，需要根据具体的需求和情况进行权衡和选择。

2、SpringBean方式实现

  • bean的名字（默认）：实现策略类的名字首字母小写

2.1、实现步奏

image

2.2、实现

①定义策略接口

package com.cc.eed.strategy;

/**
 * <p>基于SpringBean的策略模式</p>
 *
 * @author CC
 * @since 2023/10/13
 */
public interface ISpringBeanStrategy {

    /**
     * 吃饭
     */
    String eating();

    /**
     * 玩
     */
    String play();
}

②定义实现类1

package com.cc.eed.strategy.impl;

import com.cc.eed.strategy.ISpringBeanStrategy;
import org.springframework.stereotype.Component;

/**
 * <p>小美</p>
 *
 * @author CC
 * @since 2023/10/13
 */
@Component
public class MeiSpringBeanImpl implements ISpringBeanStrategy {

    /**
     * 吃饭
     */
    @Override
    public String eating() {
        return "小美，吃饭！";
    }

    /**
     * 玩
     */
    @Override
    public String play() {
        return "小美，玩！";
    }
}

定义实现类2

package com.cc.eed.strategy.impl;

import com.cc.eed.strategy.ISpringBeanStrategy;
import org.springframework.stereotype.Component;

/**
 * <p>小明</p>
 *
 * @author CC
 * @since 2023/10/13
 */
@Component
public class MingSpringBeanImpl implements ISpringBeanStrategy {

    /**
     * 吃饭
     */
    @Override
    public String eating() {
        return "小明，吃饭！";
    }

    /**
     * 玩
     */
    @Override
    public String play() {
        return "小明，玩！";
    }
}

③定义beanName的枚举

  • 用于使用类型int获取对应的beanName
package com.cc.eed.enums;

import lombok.Getter;
import org.springframework.util.Assert;

import java.util.Arrays;

/**
 * <p></p>
 *
 * @author CC
 * @since 2023/10/13
 */
@Getter
public enum PeopleEnum {

    MING(1, "小明", "mingSpringBeanImpl"),
    MEI(2, "小美", "meiSpringBeanImpl")
    ;

    public Integer type;

    public String name;

    public String beanName;

    /** <p>根据类型获取beanName<p>
     * @param type type
     * @return {@link String}
     * @since 2023/10/13
     * @author CC
     **/
    public static String getBeanName(Integer type) {
        PeopleEnum peopleEnum = Arrays.stream(values())
                .filter(p -> p.getType().equals(type))
                .findAny().orElse(null);
        Assert.notNull(peopleEnum, "暂不支持的策略模式！");
        return peopleEnum.getBeanName();
    }


    PeopleEnum(Integer type, String name, String beanName) {
        this.type = type;
        this.name = name;
        this.beanName = beanName;
    }

    public void setType(Integer type) {
        this.type = type;
    }

    public void setName(String name) {
        this.name = name;
    }

    public void setBeanName(String beanName) {
        this.beanName = beanName;
    }
}

④使用springBean工具类获取beanName

⑤使用

  • 传入不同的类型，获取不同的策略
@Test
public void test02()throws Exception{
    //根据BeanName获取具体的bean，实现策略模式
    //根据人员ID（或者类型）获取不同的bean
    String beanName = PeopleEnum.getBeanName(1);
    ISpringBeanStrategy bean = (ISpringBeanStrategy) SpringBeanUtil.getBean(beanName);

    String eating = bean.eating();
    System.out.println(eating);

    String play = bean.play();
    System.out.println(play);
}
  • 结果：
    传入1
    image
    传入2
    image
    传入除了1/2的
    image

3、简单工厂模式实现（推荐）

  • 加自定义Bean的名字

3.1、实现步奏

3.2、实现

①定义策略接口

package com.cc.eed.strategy;

/**
 * <p>简单工厂模式 - 实现的策略模式</p>
 *
 * @author CC
 * @since 2023/10/13
 */
public interface IFactoryStrategy {

    /**
     * 吃饭
     */
    String eating();

    /**
     * 玩
     */
    String play();
}

②生产策略bean的工厂

  • 由于使用的@Resource注解，BUSINESS_FACTORY会自动注入所有实现了IFactoryStrategy接口的Bean。@Resource注解是Spring提供的一种依赖注入的方式，它会根据类型进行自动装配。在这个例子中，BUSINESS_FACTORY是一个Map类型的成员变量，它的键是字符串类型，值是IFactoryStrategy类型。当Spring容器启动时，会扫描并找到所有实现了IFactoryStrategy接口的Bean，并将它们自动注入到BUSINESS_FACTORY中。
  • 由于BUSINESS_FACTORY使用了ConcurrentHashMap作为实现，它会根据PirateEnum.values().length的大小来初始化容量。这样可以确保BUSINESS_FACTORY的大小与实际注入的Bean数量一致，提高性能和效率。
package com.cc.eed.strategy;

import com.cc.eed.enums.PirateEnum;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Component;
import org.springframework.util.Assert;

import javax.annotation.Resource;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

/**
 * <p>简单工厂</p>
 * <li>可以生产多个策略</li>
 *
 * @author CC
 * @since 2023/10/13
 */
@Component
public class StrategyByFactory {

    /**
     * 1、批量注入实现了 IFactoryStrategy 的Bean。
     * 2、用bean的数量当做map的大小
     */
    @Resource
    private final Map<String, IFactoryStrategy> BUSINESS_FACTORY = new ConcurrentHashMap<>(PirateEnum.values().length);

    //生成的策略...
    /** <p>根据类获取不同的Bean<p>
     * @param type type
     * @return {@link IFactoryStrategy}
     * @since 2023/10/13
     * @author CC
     **/
    public IFactoryStrategy getBusinessMap(Integer type){
        Assert.notNull(type, "类型不能为空！");
        String beanName = PirateEnum.getBeanName(type);
        return BUSINESS_FACTORY.get(beanName);
    }

    //生成的其他策略...

}

③策略实现类1

package com.cc.eed.strategy.impl;

import com.cc.eed.enums.PirateEnum;
import com.cc.eed.strategy.IFactoryStrategy;
import org.springframework.stereotype.Component;

/**
 * <p>路飞</p>
 *
 * @author CC
 * @since 2023/10/13
 */
@Component(PirateEnum.LF_BEAN_NAME)
public class LuFeiFactoryStrategy implements IFactoryStrategy {
    /**
     * 吃饭
     */
    @Override
    public String eating() {
        return "路飞，吃饭！";
    }

    /**
     * 玩
     */
    @Override
    public String play() {
        return "路飞，玩！";
    }
}

③策略实现类2

package com.cc.eed.strategy.impl;

import com.cc.eed.enums.PirateEnum;
import com.cc.eed.strategy.IFactoryStrategy;
import org.springframework.stereotype.Component;

/**
 * <p>明哥</p>
 *
 * @author CC
 * @since 2023/10/13
 */
@Component(PirateEnum.MG_BEAN_NAME)
public class MingGgFactoryStrategy implements IFactoryStrategy {
    /**
     * 吃饭
     */
    @Override
    public String eating() {
        return "明哥，吃饭！";
    }

    /**
     * 玩
     */
    @Override
    public String play() {
        return "明哥，玩！";
    }
}

④定义beanName的枚举

package com.cc.eed.enums;

import org.springframework.util.Assert;

import java.util.Arrays;

/**
 * <p></p>
 *
 * @author CC
 * @since 2023/10/13
 */
public enum PirateEnum {

    MG(11, "明哥", PirateEnum.MG_BEAN_NAME),

    LF(22, "路飞", PirateEnum.LF_BEAN_NAME)

    ;

    public Integer type;

    public String name;

    public String beanName;

    /**
     * 自定义的beanName
     */
    public static final String MG_BEAN_NAME = "mingGg_11";
    public static final String LF_BEAN_NAME = "luFei_22";

    /** <p>根据类型获取beanName<p>
     * @param type type
     * @return {@link String}
     * @since 2023/10/13
     * @author CC
     **/
    public static String getBeanName(Integer type) {
        PirateEnum pirateEnum = Arrays.stream(values())
                .filter(p -> p.getType().equals(type))
                .findAny().orElse(null);
        Assert.notNull(pirateEnum, "暂不支持的策略模式！");
        return pirateEnum.getBeanName();
    }

    PirateEnum(Integer type, String name, String beanName) {
        this.type = type;
        this.name = name;
        this.beanName = beanName;
    }

    public Integer getType() {
        return type;
    }

    public void setType(Integer type) {
        this.type = type;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getBeanName() {
        return beanName;
    }

    public void setBeanName(String beanName) {
        this.beanName = beanName;
    }
}

⑤使用springBean工具类获取beanName

⑥使用

  • 需要注入工厂来调用方法即可
    @Resource
    private StrategyByFactory strategyByFactory;

    @Test
    public void test03()throws Exception{
        //使用简单工厂生产的策略模式 —— 明显发现使用起来更简单，把创建bean的权利交给了简单工厂
        IFactoryStrategy businessMap = strategyByFactory.getBusinessMap(33);

        System.out.println(businessMap.eating());
        System.out.println(businessMap.play());

    }

结果：

  • 传入：11
    image

  • 传入：22
    image

  • 传入：33
    image

4、总结-工具类

标签：Java,String,Spring,beanName,import,设计模式,type,public,策略
From： https://www.cnblogs.com/kakarotto-chen/p/17761621.html

相关文章

  • Java多态及类初始化顺序
    多态多态是Java面向对象的三大特性之一，多态建立于封装和继承之上，指对于父类中定义的属性和方法被子类继承后，可以具有不同的数据类型或表现出不同的行为。可分为编译时多态和运行时多态，编译时多态是静态的，通过方法的重载体现，通过编译之后会产生不同的方法；运行时多态通过动态绑定......
  • Java SWT Image 图像 —— 透明度 alpha数组
    对于图像深度是2、4、8的图像，可以指定transparentPixel。对于直接图像，要使用alpha或者alpha数组，alpha值0到255，0表示完全透明的，数值越大表示越是不透明，255表示完全不透明，可以只是设置一个alpha值，作用于所有的像素点，也可以给所有的像素点设置自己的透明的值。 如： 的alpha的数组值为......
  • Java SWT Image 图像 —— mask
    原文链接：http://www.eclipse.org/articles/Article-SWT-images/graphics-resources.htmlPaletteDatapaletteData=newPaletteData(newRGB[]{newRGB(0,0,0),newRGB(255,255,255)});ImageDatasourceData=newImageData(32,32,1,paletteData);ImageDatamaskData=......
  • Java SWT Image 图像 —— 变灰、变亮变黑、旋转、反色、拉伸、透明叠加
    图像变灰图像变灰在桌面应用程序中有着广泛的应用。例如，一个图标被作为一个按钮的背景，我们需要一个灰色效果的图标作为按钮的背景来表示这个按钮处于禁用状态。在SWT中，基于已经存在的图像来创建一个具有灰色效果的图像，我们可以使用构造函数Image(Displaydisplay,Imageimage,in......
  • 采用SpringBoot+原生HTML+MySQL开发的电子病历系统源码
    电子病历系统采用“所见即所得、一体化方式”，协助医生和护士准确、标准、快捷实现病历书写、修改、审阅、打印、体温单浏览、医嘱管理等，是提供病历快速简洁化完成的一系列综合型医生病历工作平台。本套电子病历系统主要面向医疗机构医生、护士，提供对住院病人的电子病历书写、保存......
  • Java并发之AQS
    一、AQS是什么AbstractQueuedSynchronizer抽象同步队列，简称AQS，它是Java并发包的根基，并发包中的锁就是基于AQS实现的。AQS是基于一个FIFO的双向队列，其内部定义了一个节点类Node，Node节点内部的SHARED用来标记该线程是获取共享资源时被阻挂起后放入AQS队列的，EXCLUSIVE用来标记......
  • Java内存模型-JMM
    内存模型与内存区域 很多时候，二者会混淆，所以咱们先做区分：内存模型与内存区域内存区域是指JVM运行时将数据分区域存储，强调的是对空间的分配内存模型（JMM）是定义了线程和主内存之间的抽象关系。即定义了JVM在计算机内存中的工作方式内存模型抽象关系定义线程之间的共享区......
  • springboot2.4下使用JUnit依赖注入失败的解决方案
    首先在pom.xml下引入JUnit必须的包：<dependency><groupId>junit</groupId><artifactId>junit</artifactId></dependency><dependency><groupId>org.springframework.boot</groupId><artifactId&......
  • java学习日记day02
    java学习日记day02冯诺伊曼体系)cmd指令......
  • SpringBoot 1项目创建及Mybatis-plus实现数据增删改查
    一.项目创建及配置1.项目创建点击finish完成创建pom.xml加上以下依赖<dependency><groupId>com.baomidou</groupId><artifactId>mybatis-plus-boot-starter</artifactId><version>3.4.1</version>......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99