策略模式在不同情况下的使用方法

短命女 2024-04-07 12:20 23阅读 0赞

## 概述 ##

在策略模式（Strategy Pattern）中，一个类的行为或其算法可以在运行时更改。

把行为和环境分割开来。环境类Context负责查询要做什么，各种算法则在具体策略类（ConcreteStrategy）中提供。

![在这里插入图片描述][ad168269d3014832925a006bb796f7f8.png]

## 提出问题 ##

假设有一个`计算的功能，分别有加减乘三种方法，如果需要通过传入的一个type去判断具体执行哪一个方法`，

如果使用传统的方法的话，我们就需要去使用多个if判断，现在只需要两三个，那么如果后面这种有几十种呢？

所以，在这里就需要去使用策略模式去解决，下面便对策略模式进行解决这个问题

## 演示1（Java代码） ##

演示类使用 Context 和策略对象来演示 Context 在它所配置或使用的策略改变时的行为变化

### 接口（Strategy ） ###

策略接口的定义，通常包含：处理策略业务逻辑的方法。

public interface Strategy {
        
       public int doOperation(int num1, int num2);
    }

### 实现（implements） ###

创建实现接口的实体类，这样我们可以灵活的替换不同的实现方法

#### OperationAdd（加） ####

public class OperationAdd implements Strategy{
        
       @Override
       public int doOperation(int num1, int num2) {
        
          return num1 + num2;
       }
    }

#### OperationSubtract（减） ####

public class OperationSubtract implements Strategy{
        
       @Override
       public int doOperation(int num1, int num2) {
        
          return num1 - num2;
       }
    }

#### executeStrategy（乘） ####

public class executeStrategy implements Strategy{
        
       @Override
       public int doOperation(int num1, int num2) {
        
          return num1 * num2;
       }
    }

### 上下文类（Context） ###

策略模式包含一组同类的策略，在使用时我们通常通过类型来判断创建哪种策略来进行使用

上下文类，就是集成算法的类

该类的定义体现了多用组合，少用继承。针对接口，不针对实现两个设计原则。

public class Context {
        
       private Strategy strategy;
     
       public Context(Strategy strategy){
        
          this.strategy = strategy;
       }
     
       public int executeStrategy(int num1, int num2){
        
          return strategy.doOperation(num1, num2);
       }
    }

### 使用 ###

public class StrategyPatternDemo {
        
       public static void main(String[] args) {
        
          Context context = new Context(new OperationAdd());    
          System.out.println("10 + 5 = " + context.executeStrategy(10, 5));
     
          context = new Context(new OperationSubtract());      
          System.out.println("10 - 5 = " + context.executeStrategy(10, 5));
     
          context = new Context(new OperationMultiply());    
          System.out.println("10 * 5 = " + context.executeStrategy(10, 5));
       }
    }

输出结果：

10 + 5 = 15
    10 - 5 = 5
    10 * 5 = 50

## 演示3（使用反射） ##

在这里假设上面的三种实现类都是在`com.app`里面

package com.app;
    
    
    public class T1 {
        
    
    	public static void main(String[] args) {
        
    
    		try {
        
    			//创建类
    			String type = "concreteStrategyA ";
    			Class<?> class1 = Class.forName("com.app" + type);;
    			//创建实例化：相当于 new 了一个对象
    			Object object = class1.newInstance() ;
    			//向下转型				
    			OperationAdd add = (OperationAdd) object ;
    			System.out.println("10 - 5 = " + add.doOperation(10, 5));
    			
    			
    		} catch (ClassNotFoundException e) {
        
    			e.printStackTrace();
    		} catch (InstantiationException e) {
        
    			e.printStackTrace();
    		} catch (IllegalAccessException e) {
        
    			e.printStackTrace();
    		}
    
    	}
    }

## 演示3（Spring简单工厂实现） ##

上面的代码有一点问题，那就是我们需要去new一个对象（反射的也是需要new已一个），`如果在Spring项目中，通过new创建出来的对象中，无法使用@Resource或@Autowired 注解实例化service层注入。`  
`因为Spring的注入是在项目启动的时候执行的，所以后期new出来的实例对象中的注入注解就不会生效了`。

### 接口（Strategy） ###

public interface Strategy {
        
       public int doOperation(int num1, int num2);
    }

### 实现（implements） ###

创建实现接口的实体类，这样我们可以灵活的替换不同的实现方法

#### OperationAdd（加） ####

@Component("add")
    public class OperationAdd implements Strategy{
        
       @Override
       public int doOperation(int num1, int num2) {
        
          return num1 + num2;
       }
    }

#### OperationSubtract（减） ####

@Component("substract")
    public class OperationSubtract implements Strategy{
        
       @Override
       public int doOperation(int num1, int num2) {
        
          return num1 - num2;
       }
    }

#### executeStrategy（乘） ####

@Component("multiply")
    public class executeStrategy implements Strategy{
        
       @Override
       public int doOperation(int num1, int num2) {
        
          return num1 * num2;
       }
    }

### 上下文类/工厂类（Context） ###

策略模式包含一组同类的策略，在使用时我们通常通过类型来判断创建哪种策略来进行使用

上下文类，就是集成算法的类

该类的定义体现了多用组合，少用继承。针对接口，不针对实现两个设计原则。

@Component
    public class Context {
        
       
       	@Autowired
        private Map<String, Strategy> strategyMap;
     
       public Strategy build(String type){
        
          return strategyMap.get(type);
       }
    }

### 使用 ###

@Component
    public class StrategyPatternDemo {
        
        @Autowired
        private Context context;
    	
    	public void test(){
        
    		Strategy strategy = context.build("add");
    		int add = startegy.doOperation(10, 5);
    		System.out.println("10 + 5 = " + add);
    		
    		Strategy strategy = context.build("subtract");
    		int subtract = startegy.doOperation(10, 5);
    		System.out.println("10 - 5 = " + subtract);
    		
    		Strategy strategy = context.build("multiply");
    		int multiply = startegy.doOperation(10, 5);
    		System.out.println("10 * 5 = " + multiply);
    	}
    }

输出结果：

10 + 5 = 15
    10 - 5 = 5
    10 * 5 = 50

[ad168269d3014832925a006bb796f7f8.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/07/0075edccd5a041c7829642fad7a9626f.png