01.策略模式

已于 2022-02-21 13:36:15 修改
阅读量136 收藏
点赞数
分类专栏： 001.设计模式 文章标签： 策略模式 java 开发语言
于 2022-02-18 16:55:20 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_26477149/article/details/123006416
版权

1.为什么要使用设计模式

使用设计模式可以重构整体架构代码、提高代码复用性、扩展性、减少代码冗余

2.什么是策略模式

将算法的责任和本身分割开，委派给不同的对象进行管理，最终解决多重if判断的问题

3.策略模式角色

1.环境角色：context上下文，客户端通过上下文获取具体的策略
2.抽象策略：定义共同行为方法的接口
3.具体策略：不同的策略不同的实现


4.通过枚举加工厂实现策略模式

链接：https://pan.baidu.com/s/1eDKSaH5njISprY3DMqMcuQ 
提取码：p29b 

 

1）pom依赖

 <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.11.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.16.10</version>
        </dependency>
        <dependency>
            <groupId>commons-lang</groupId>
            <artifactId>commons-lang</artifactId>
            <version>2.6</version>
        </dependency>
    </dependencies>

2）抽象策略

public interface PayStrategy {

    /**
     * 共同方法的行为
     * @return
     */
    String toPayHtml();
}

3）具体策略

import com.demo.strategy.PayStrategy;
import org.springframework.stereotype.Component;

@Component
public class AlipayStrategy implements PayStrategy {

    @Override
    public String toPayHtml() {
        return "调用支付宝接口...AliPayStrategy";
    }
}
import com.demo.strategy.PayStrategy;
import org.springframework.stereotype.Component;

@Component
public class WeChatPayStrategy implements PayStrategy {

    public String toPayHtml() {
        return "调用微信支付接口...WeChatPayStrategy";
    }
}

4）工厂

import com.demo.enumeration.PayEnumStrategy;
import com.demo.strategy.PayStrategy;

public class StrategyFactory {

    /**
     * 通过工厂获取具体的策略
     */
    public static PayStrategy getPayStrategy(String strategyType) {
        try {
            String className = PayEnumStrategy.valueOf(strategyType).getClassName();
            PayStrategy payStrategy = (PayStrategy)Class.forName(className).newInstance();
            return payStrategy;
        } catch (Exception e) {
            return null;
        }
    }

}

5）枚举

public enum PayEnumStrategy {

    /**
     * 支付宝支付
     */
    ALI_PAY("com.demo.strategy.impl.AlipayStrategy"),
    /**
     * 微信支付
     */
    WECHAT_PAY("com.demo.strategy.impl.WeChatPayStrategy");

    PayEnumStrategy(String className) {
        this.setClassName(className);
    }

    private String className;

    public String getClassName() {
        return className;
    }

    public void setClassName(String className) {
        this.className = className;
    }
}

6）环境角色上下文

import com.demo.factory.StrategyFactory;
import com.demo.strategy.PayStrategy;
import org.springframework.stereotype.Component;

@Component
public class PayContextStrategy {

    /**
     * 通过上下文获取具体的策略
     */
    public String toPayHtml(String payCode) {
        PayStrategy payStrategy = StrategyFactory.getPayStrategy(payCode);
        if (payStrategy == null) {
            return "没有找到具体的实现策略";
        }
        return payStrategy.toPayHtml();
    }
}

7）控制层

import com.demo.context.PayContextStrategy;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
import javax.annotation.Resource;

@RestController
public class PayController {

    @Resource
    private PayContextStrategy payContextStrategy;

    /**
     * 调用支付接口
     */
    @GetMapping("/toPayHtml")
    public String toPayHtml(String payCode) {
        return payContextStrategy.toPayHtml(payCode);
    }
}

8）启动类

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class DemoApplication {

    public static void main(String[] args) {
        SpringApplication.run(DemoApplication.class, args);
    }
}

9）测试

http://localhost:8080/toPayHtml?payCode=ALI_PAY

5.通过数据库实现策略模式

链接：https://pan.baidu.com/s/1sHYlTzTL2CZOn3_5FYfruw 
提取码：bqjv 

 

1）数据库

/*
 Navicat Premium Data Transfer

 Source Server         : localhost
 Source Server Type    : MySQL
 Source Server Version : 50727
 Source Host           : localhost:3306
 Source Schema         : design_pattern

 Target Server Type    : MySQL
 Target Server Version : 50727
 File Encoding         : 65001

 Date: 18/02/2022 16:49:34
*/

SET NAMES utf8mb4;
SET FOREIGN_KEY_CHECKS = 0;

-- ----------------------------
-- Table structure for payment_channel
-- ----------------------------
DROP TABLE IF EXISTS `payment_channel`;
CREATE TABLE `payment_channel`  (
  `id` int(11) NOT NULL,
  `channel_name` varchar(100) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
  `channel_id` varchar(100) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
  `strategy_bean_id` varchar(100) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL,
  PRIMARY KEY (`id`) USING BTREE
) ENGINE = InnoDB CHARACTER SET = utf8 COLLATE = utf8_general_ci ROW_FORMAT = Dynamic;

-- ----------------------------
-- Records of payment_channel
-- ----------------------------
INSERT INTO `payment_channel` VALUES (1, '支付宝支付', 'alipay', 'alipayStrategy');
INSERT INTO `payment_channel` VALUES (2, '微信支付', 'wechat', 'weChatPayStrategy');

SET FOREIGN_KEY_CHECKS = 1;

2）pom依赖

<parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.11.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>

    <dependencies>
        <!-- sprinboot web -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.16.10</version>
        </dependency>
        <dependency>
            <groupId>commons-lang</groupId>
            <artifactId>commons-lang</artifactId>
            <version>2.6</version>
        </dependency>
        <!-- mysql 依赖 -->
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>1.1.1</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>
    </dependencies>

3）yml

###服务启动端口号
server:
  port: 8080
spring:
  ###数据库相关连接
  datasource:
    username: root
    password: root
    driver-class-name: com.mysql.jdbc.Driver
    url: jdbc:mysql://127.0.0.1:3306/design_pattern?useUnicode=true&characterEncoding=UTF-8&serverTimezone=GMT%2B8
####打印MyBatias日志    
logging:
  level:
    ### 开发环境使用DEBUG 生产环境info或者error
    com.demo.mapper: DEBUG

4）渠道Entity

import lombok.Data;

@Data
public class PaymentChannelEntity {

    /**
     * ID
     */
    private Integer id;
    /**
     * 渠道名称
     */
    private String channelName;
    /**
     * 渠道ID
     */
    private String channelId;
    /**
     * 策略执行beanId
     */
    private String strategyBeanId;

}

5）渠道Mapper

import com.demo.entity.PaymentChannelEntity;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Select;

@Mapper
public interface PaymentChannelMapper {

    @Select("SELECT  id as id ,CHANNEL_NAME as CHANNELNAME ,CHANNEL_ID as CHANNELID,strategy_bean_id AS strategybeanid FROM payment_channel where CHANNEL_ID=#{payCode}")
    PaymentChannelEntity getPaymentChannel(String payCode);
}

6）抽象策略

public interface PayStrategy {

    /**
     * 共同方法的行为
     * @return
     */
    String toPayHtml();
}

7）具体策略

import com.demo.strategy.PayStrategy;
import org.springframework.stereotype.Component;

@Component
public class AlipayStrategy implements PayStrategy {

    @Override
    public String toPayHtml() {
        return "调用支付宝接口...AliPayStrategy";
    }
}
import com.demo.strategy.PayStrategy;
import org.springframework.stereotype.Component;

@Component
public class WeChatPayStrategy implements PayStrategy {

    public String toPayHtml() {
        return "调用微信支付接口...WeChatPayStrategy";
    }
}

 8）spring上下文工具类

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

@Component
public class SpringUtils implements ApplicationContextAware {

    private static ApplicationContext applicationContext;

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        this.applicationContext = applicationContext;
    }

    /**
     * 获取applicationContext
     */
    public static ApplicationContext getApplicationContext() {
        return applicationContext;
    }

    /**
     * 通过name获取 Bean
     */
    public static Object getBean(String name) {
        return getApplicationContext().getBean(name);
    }

    /**
     * 通过class获取Bean
     */
    public static <T> T getBean(Class<T> clazz) {
        return getApplicationContext().getBean(clazz);
    }

    /**
     * 通过name,以及Clazz返回指定的Bean
     */
    public static <T> T getBean(String name, Class<T> clazz) {
        return getApplicationContext().getBean(name, clazz);
    }

}

9）环境角色Context上下文

import com.demo.entity.PaymentChannelEntity;
import com.demo.mapper.PaymentChannelMapper;
import com.demo.strategy.PayStrategy;
import com.demo.utils.SpringUtils;
import org.apache.commons.lang.StringUtils;
import org.springframework.stereotype.Component;

import javax.annotation.Resource;

@Component
public class PayContextStrategy {

    @Resource
    private PaymentChannelMapper paymentChannelMapper;

    /**
     * 通过上下文获取具体的策略
     */
    public String toPayHtml(String payCode) {
        if (StringUtils.isEmpty(payCode)) {
            return "payCode不能为空!.....";
        }
        // 1.查询数据库获取具体策略实现
        PaymentChannelEntity paymentChannel = paymentChannelMapper.getPaymentChannel(payCode);
        if (paymentChannel == null) {
            return "没有查询支付渠道";
        }

        // 2.获取spring注入的bean的id
        String strategyBeanId = paymentChannel.getStrategyBeanId();
        if (StringUtils.isEmpty(strategyBeanId)) {
            return "数据库没有配置strategyBeanId";
        }

        //3.通过spring上下文获取策略
        PayStrategy payStrategy = SpringUtils.getBean(strategyBeanId, PayStrategy.class);
        return payStrategy.toPayHtml();
    }
}

10）控制层 

import com.demo.context.PayContextStrategy;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

import javax.annotation.Resource;

@RestController
public class PayController {

    @Resource
    private PayContextStrategy payContextStrategy;

    /**
     * 调用支付接口
     */
    @GetMapping("/toPayHtml")
    public String toPayHtml(String payCode) {
        return payContextStrategy.toPayHtml(payCode);
    }
}

 10）测试

http://localhost:8080/toPayHtml?payCode=alipay

6.spring框架中哪些地方使用到了策略模式

new ClassPathXmlApplicationContext()  读取配置文件

JAVA白名单
关注
专栏目录
策略模式
whiteBearClimb的博客
05-21 4528
（1）是什么？ 策略模式其实很简单，就是针对不同的场景，做出不同的处理策略 （2）策略模式的优缺点： 优点： （1）可以砍掉代码中过多的if else if 和 switch case语句，使代码更加整洁优雅，一定程度上提高了性能。 （2） 新增类型或者场景仅仅需要新增一个处理策略，不需要改动旧代码，遵循了开闭原则，更好维护。 缺点： （1）如果场景过多，会产成过多的策略类，一定程度上增加了理解成本 （3）怎么用？（案例演示） 假设有一个需求，是根据传入的类型Type的不同，构造出不同的对象并且调用相对应的
01策略模式.rar
12-08
在"01策略模式.rar"这个压缩包文件中，可能包含了对策略模式的进一步讲解，包括模式的实现示例、应用场景分析、优缺点分析以及如何在实际项目中有效利用策略模式等内容。学习这个压缩包中的资料，可以帮助你深入理解...
设计模式之策略模式
qq_20376983的博客
05-10 175
什么是策略模式 策略模式是对算法的包装,是把使用算法的责任和算法本身分割开来,委派给不同的对象管理,最终可以实现解决多重if判断问题。 定义策略接口 → 实现不同的策略类 → 利用多台或者其他方式调用策略类 为什么叫做策略模式 每个 if 判断都可以理解为就是一个策略。 策略模式优缺点 优点 1.算法可以自由切换(高层屏蔽算法，角色自由切换） 2.避免使用多重条件判断(如果算法过多就会出现很...
java strategy模式,Java设计模式——策略模式(Strategy pattern)
weixin_39765625的博客
03-13 195
策略模式，在阿里巴巴开发手册中有提到过，可以用来减少if-else嵌套，是一个常用的设计模式。策略模式结构如下图，一个上下文Context只有一个抽象的策略Strategy，可以调用该策略的strategyInterface()执行具体的策略方法。就比如平常用手机支付，我的手机持有系统级别的抽象的支付方式，然后支付宝和微信支付来具体实现我的支付接口，用户需要付款时，弹窗让用户选择使用哪种方式付款，...
01-策略模式 代码实例
06-22
在给定的"01-策略模式"代码实例中，我们可能看到以下几个关键部分： 1. **策略接口（Strategy）**：这是定义了所有支持的算法或行为的公共接口。例如，我们可以有一个`SortingStrategy`接口，其中包含一个`sort()`...
02策略模式.zip
12-04
在"02策略模式.zip"这个压缩包中，包含了多个关于策略模式应用的示例，主要围绕一个商场管理软件的开发。让我们逐一分析这些文件中的知识点： 1. **策略模式-基本代码**：这部分可能包含策略模式的基本实现，包括上...
VCU控制策略整理V01.pdf
05-10
VCU控制策略整理:1、电机运行方向：01：CCW 方向、10：CW 方向，CW 顺时针旋转，CCW 是逆时针旋转？ 行驶与倒车时，发此信号吗？ 2、控制模式：01:转矩模式、10: 转速模式 3、工作模式：01：牵引、10：制动 4、...
PHEV_Control_01.rar_PHEV matlab_PHEV simulink_cruise控制策略_控制策略
07-14
标题中的"PHEV_Control_01.rar"是一个与插电式混合电动汽车（PHEV）相关的项目文件，其中包含了在Matlab/Simulink环境中设计的动力分配控制策略。"PHEV"是Plug-in Hybrid Electric Vehicle的缩写，这类车辆结合了...
策略设计模式
weixin_44730166的博客
09-24 136
策略设计模式（strategy）：定义了一组算法，将每个算法都封装起来，并且使它们之间可以互换 个人理解有点像多态，如：支付，可以由微信支付，支付宝支付，现金支付。因此支付可以定义为一个接口，不同的支付方式都去实现这个支付接口，然后通过用户的选择，来确定执行哪一种支付方式 这种方式 扩展性良好，还可以避免多重 if else 不易维护的问题 应用如下： //支付接口 public interface Pay { void pay(); } //微信支付 public class WeC.
SpringBoot中使用策略模式
qq_38895905的博客
07-30 980
策略模式：定义一组算法，将每个算法都封装起来，相互之间可以互换。 策略模式需要一个抽象算法接口，一组算法，一个容器类（Context） 假设我们有一个场景：根据传值type的不同，调用不同的接口（加减乘除） 抽象算法接口： public interface IZStrategy { /** * 计算 * @param a * @param b * @return */ BigDecimal doCalculate(BigDecima
【设计模式】SpringBoot优雅使用策略模式
积木成林，聚沙成塔
06-21 7759
本篇文章主要会描述SpringBoot与策略模式的结合使用，因为不涉及到理论部分，所以在阅读本篇之前，需要对策略模式的理论已经有了一个基本的了解。通过Spring获取接口的实现，并解析实现类上的注解的方式，可以在程序启动时动态的将策略注入到一个Map中，作为策略的容器。使用时传入标识符就可以获取到对应的策略执行了。
用枚举类写策略模式，codeReview时被“喷”了
最新发布
爱琴孩的博客
06-23 775
经典模式显然不合适了，如果逻辑比较简单，比如说文中这种简单的排序展示，并且策略比较多的时候，选用枚举策略模式是很合适的，这样可以减少策略类，避免造成类泛滥。如果每个策略的业务逻辑比较复杂，策略类比较少，那么结合spring 的工厂模式是比较合适的。
java策略模式 动态_Java 策略模式
weixin_42388485的博客
02-13 449
什么是策略模式？策略模式就是对算法的包装，是把使用算法的责任和算法本身分割开来，委派给不同的对象管理，最终可以实现解决多if重判断问题。实现过程定义策略接口->实现不同的策略类->利用多态或其他方式调用策略. .1.环境(Context)角色:持有一个Strategy的引用。。2.抽象策略(Strategy)角色:这是一个抽象角色，通常由一个接口或抽象类实现。此出所有的具体策略类所需的...
SpringUtils工具类(getBean())
qq_31856061的博客
08-17 9003
代码】SpringUtils工具类(getBean())
Spring的getBean()流程源码解析
qq_42721085的博客
06-08 1521
承接上篇Spring的bean加载流程，这里开始分析Spring的getBean(beanName)方法， 该方法会触发容器对Bean实例化和依赖注入过程： //调用抽象类AbstractBeanFactory的getBean()方法 public Object getBean(String name) throws BeansException { //doGetBean才是真正向IoC容器获取被管理Bean的过程 return doGetBean(name, null, null, false)
Spring之bean生命周期源码解析
2201_75955594的博客
12-21 681
Spring源码解析之getBean()方法底层实现
设计模式入门：模拟鸭子应用与OO设计原则
书中没有立即给出解决方案，但暗示了可能的模式，比如“策略模式”或者“适配器模式”，这些模式可以帮助我们优雅地处理鸭子飞行的能力差异，而不破坏原有的类结构。 此外，书中还强调了设计模式的优点，包括提高...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值