【设计模式-4.1】行为型—

【设计模式-4.1】行为型——策略模式

news2025/2/27 1:12:33

说明：本文介绍设计模式中的行为型设计模式中的，策略模式；

计算器

策略模式属于行为型设计模式，关注对象的行为。例如，目前有一个计算器类，可对两个数进行加减计算，如下：

（Calculator，计算器类）

/**
 * 计算器
 */
public class Calculator {
    /**
     * 加法
     */
    public static int add(int a, int b) {
        return a + b;
    }

    /**
     * 减法
     */
    public static int subtract(int a, int b) {
        return a - b;
    }
}

（Client，客户端，使用计算器的加法、减法）

/**
 * 客户端
 */
public class Client {
    public static void main(String[] args) {
        // 1. 加法
        System.out.println(Calculator.add(1, 2));

        // 2. 减法
        System.out.println(Calculator.subtract(1, 2));
    }
}

执行结果；

在这里插入图片描述

从这个简单的例子中就可以看出问题，扩展性差，如果需要增加乘法、减法或其他种种两个数运算的方法，都需要去修改计算器类。

我们可以考虑将计算器类中的计算方法抽出来称为一个抽象方法，让所有计算方法类都去实现这个接口，然后在计算器类中注入一个计算方法。如下：

（Computation，计算接口）

/**
 * 计算接口
 */
public interface Computation {

    /**
     * 计算方法
     */
    int compute(int num1, int num2);
}

（AddCompute，加法实现）

/**
 * 加法计算
 */
public class AddCompute implements Computation{

    @Override
    public int compute(int num1, int num2) {
        return num1 + num2;
    }
}

（SubCompute，减法实现）

/**
 * 减法计算
 */
public class SubCompute implements Computation{

    @Override
    public int compute(int num1, int num2) {
        return num1 - num2;
    }
}

（Calculator，计算器类，注入一个计算对象）

/**
 * 计算器
 */
public class Calculator {

    private Computation computation;

    public void setComputation(Computation computation) {
        this.computation = computation;
    }

    /**
     * 计算方法
     */
    public int compute(int num1, int num2) {
        return this.computation.compute(num1, num2);
    }
}

（Client，客户端，使用什么计算，就new什么计算方式）

/**
 * 客户端
 */
public class Client {
    public static void main(String[] args) {
        Calculator calculator = new Calculator();
        calculator.setComputation(new AddCompute());

        // 1. 加法
        System.out.println(calculator.compute(1, 2));

        // 2. 减法
        calculator.setComputation(new SubCompute());
        System.out.println(calculator.compute(1, 2));
    }
}

运行结果；

在这里插入图片描述

通过策略模式，将多种计算方法，从类中抽出来成一个个具体实现类，再创建一个统一的接口，使其实现该接口。这样，不论以后有多少计算方式，都可以创建具体实现类，实现其接口来添加，而不需要对现有的系统做改动。提高了扩展性。

登录方式

策略模式在项目开发中的一个应用是，对多种登录方式的整合。如下：

（LoginMethod，登录方式接口）

/**
 * 登录方式
 */
public interface LoginMethod {

    /**
     * 登录
     * @return
     */
    String login();
}

（PhoneServiceImpl，具体实现类，手机号登录，Bean名称：phone）

import org.springframework.stereotype.Service;

@Service("phone")
public class PhoneServiceImpl implements LoginMethod {
    @Override
    public String login() {
        return "手机号登录";
    }
}

（PasswordServiceImpl，具体实现类，账号密码登录，Bean名称：password）

import org.springframework.stereotype.Service;

@Service("password")
public class PasswordServiceImpl implements LoginMethod {
    @Override
    public String login() {
        return "账号密码登录";
    }
}

（WXLoginServiceImpl，具体实现类，微信登录，Bean名称：wx）

import org.springframework.stereotype.Service;

@Service("wx")
public class WXLoginServiceImpl implements LoginMethod {
    @Override
    public String login() {
        return "微信登录";
    }
}

（LoginController，登录Controller，传递登录类型）

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping
public class LoginController {

    @Autowired
    private LoginService loginService;

    @PostMapping("/login")
    public String login(String loginType) {
        return loginService.executeLogin(loginType);
    }
}

（LoginService，登录接口）

public interface LoginService {

    /**
     * 根据登录方式执行登录
     *
     * @param loginType
     * @return
     */
    String executeLogin(String loginType);
}

（LoginServiceImpl，登录实现类，使用applicationContext.getBean方法获取对应的登录具体实现类，执行其方法，执行对应的登录方式）

import com.hezy.service.LoginMethod;
import com.hezy.service.LoginService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationContext;
import org.springframework.stereotype.Service;

/**
 * 登录服务实现类
 */
@Service
public class LoginServiceImpl implements LoginService {

    @Autowired
    private ApplicationContext applicationContext;

    @Override
    public String executeLogin(String loginType) {
        LoginMethod loginMethod = (LoginMethod) applicationContext.getBean(loginType);
        return loginMethod.login();
    }
}