在Spring中实现策略模式

在项目中如果遇到业务需要针对不同情况做不同处理的场景，最简单的办法就是在一个方法中使用多个if-else分支进行判断。

但如果分支情况多了之后，后期代码维护将会变得比较困难。

使用策略模式可以优化这个问题。

场景

有一个游戏类，玩不同的游戏时有不同的效果。

1
2
3
4
5
@Data
public class Game {
    private String name; // 游戏名
    private Integer type; //游戏类型
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public class PlayGameOld {
    public static void main(String[] args) {
        // 构造一个游戏类
        Game game = new Game();
        game.setName("守望先锋");
        game.setType(1);
        
        // 业务判断
        if (game.getType() == 1) {
            System.out.println(game.getName() + "：我收到了召唤，我必须回应");
        } else if (game.getType() == 3) {
            System.out.println(game.getName() + "：面对疾风吧");
        }
    }
}

使用多个if-else分支进行判断，当然可以满足业务需求。但当后期增加新游戏时，需要硬编码修改这段代码添加新的分支，后期维护会越来越困难。

使用策略模式+工厂模式改进

本质上多个if-else分支的处理方式是面向过程，策略模式的处理方式则是面向对象

代码实现

首先创建一个顶层的策略模式，里面有两个方法，isSupport方法用于判断实现类是否支持处理，play则是实际的业务逻辑方法。

1
2
3
4
public interface IGameStrategy {
    boolean isSupport(Game game);
    void play(Game game);
}

接着创建两个不同的实现类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
/**
 * 守望先锋策略类
 */
public class OWStrategy implements IGameStrategy {

    @Override
    public boolean isSupport(Game game) {
        return game.getType() == 1;
    }

    @Override
    public void play(Game game) {
        System.out.println(game.getName() + "：我收到了召唤，我必须回应");
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
/**
 * 英雄联盟策略类
 */
@Service
public class LoLStrategy implements IGameStrategy {

    @Override
    public boolean isSupport(Game game) {
        return game.getType() == 3;
    }

    @Override
    public void play(Game game) {
        System.out.println(game.getName() + "：面对疾风吧");
    }
}

接下来创建一个工厂类（该工厂类是一个单例，由于重点不是这个工厂类，所以并没有严格实现double-check，不重要）。

这个工厂类根据传入的Game对象，内部进行判断，返回一个对应的策略实现类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
public class MyFactory {
    private static MyFactory myFactory;
    private final List<IGameStrategy> gameStrategyList;

    private MyFactory() {
      	// 初始化所有策略实现类
        gameStrategyList = new ArrayList<>();
        gameStrategyList.add(new OWStrategy());
        gameStrategyList.add(new LoLStrategy());
    }

    public static MyFactory getInstance() {
        if (myFactory == null) {
            myFactory = new MyFactory();
        }
        return myFactory;
    }

  	/**
 		* 根据条件返回对应的策略实现类
 		*/
    public IGameStrategy getGameStrategy(Game game) {
        Optional<IGameStrategy> optional = gameStrategyList.stream()
                .filter(gameStrategy -> gameStrategy.isSupport(game))
                .findFirst();
        IGameStrategy gameStrategy = optional.orElseThrow(() -> new RuntimeException("找不到游戏！"));
        return gameStrategy;
    }
}

测试

1
2
3
4
5
6
7
8
9
10
@Test
public void test() {
    Game game = new Game();
    game.setName("守望先锋");
    game.setType(1);

    IGameStrategy gameStrategy = MyFactory.getInstance().getGameStrategy(game);
    gameStrategy.play(game);
    // 守望先锋：我收到了召唤，我必须回应
}

优缺点

  • 优点
    • 代码改动小：以后新增游戏时，无需修改获取策略类的代码，因为工厂类内部会自己判断返回哪个策略类
    • 代码层次结构更清晰、利于代码维护。
  • 缺点
    • 不符合开闭原则：以后新增游戏时，仍需在工厂类初始化策略类时新增新的游戏策略类（尽管只需一行改动）
    • 文件数量增加：原来代码逻辑只写在一个文件中，现在每多一个策略就需要多一个代码文件

黑科技：借助Spring进行改进

上面的方式存在一个瑕疵：新增游戏时，仍需在工厂类初始化策略类时硬编码增加新的游戏策略类。

而借助Spring，我们可以将所有策略类注册到Spring容器中，从而使得获取bean更加优雅

代码实现

Game和策略接口IGameStrategy无需改动

两个策略实现类OWStrategy、LoLStrategy都加上注解@Service注册到容器中

修改工厂类：

  • 使用Spring的构造器注入，可以优雅的获得所有策略实现类。
  • 将工厂类也注册进容器中：@Component
1
2
3
4
5
6
7
8
9
10
11
12
13
@Component
@RequiredArgsConstructor
public class GameStrategyFactory {
    private final List<IGameStrategy> gameStrategyList;

    public IGameStrategy getGameStrategy(Game game) {
        Optional<IGameStrategy> optional = gameStrategyList.stream()
                .filter(gameStrategy -> gameStrategy.isSupport(game))
                .findFirst();
        IGameStrategy gameStrategy = optional.orElseThrow(() -> new RuntimeException("找不到游戏！"));
        return gameStrategy;
    }
}

测试

使用Spring Test

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
@SpringBootTest
class GameStrategyFactoryTest {

    @Autowired
    private GameStrategyFactory gameStrategyFactory;

    @Test
    public void test() {
        Game game = new Game();
        game.setName("守望先锋2");
        game.setType(2);

        IGameStrategy gameStrategy = gameStrategyFactory.getGameStrategy(game);
        gameStrategy.play(game);
        // 英雄联盟：面对疾风吧
    }
}

由于工厂类也注册进了容器，我们直接通过容器获取工厂类，代码调用更简洁。

如果后面增加了新的游戏策略，如：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
/**
 * 守望先锋2策略类
 */
@Service
public class OW2Strategy implements IGameStrategy {

    @Override
    public boolean isSupport(Game game) {
        return game.getType() == 2;
    }

    @Override
    public void play(Game game) {
        System.out.println(game.getName() + "：依托答辩！");
    }
}

我们甚至不需要修改原来的任何代码，工厂类会通过容器自动找到这个新的策略实现类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
@SpringBootTest
class GameStrategyFactoryTest {

    @Autowired
    private GameStrategyFactory gameStrategyFactory;

    @Test
    public void test() {
        Game game = new Game();
        game.setName("守望先锋2");
        game.setType(2);

        IGameStrategy gameStrategy = gameStrategyFactory.getGameStrategy(game);
        gameStrategy.play(game);
        // 守望先锋2：依托答辩！
    }
}

优雅！

赏

谢谢你请我吃糖果

扫一扫，分享到微信

微信分享二维码

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

很惭愧<br><br>只做了一点微小的工作<br>谢谢大家