代码都成屎山了，还在用if-else？不如试试我的这套工厂模式+Map+自定义注解+枚举

前言

看到同事的代码，想到多年以前自己刚开始工作的时候写的代码，即使有再多的需求，再多的业务逻辑，都是满屏的if-else解决的，全然忘记什么叫做“面向对象编程”，但是写的多了都忘记了哪里是头，哪里是尾，但是当时并没有感觉到有多别扭，等慢慢的工作之后，回头再去看之前的代码，我艹，这是哪个**写的代码。

可能刚入门的同行可能会忽略一点，if-else可能是面向过程的实现。

那么如何解决掉满屏的if-else呢？让代码看起来变的更加的优雅、简洁呢？

我一般都是使用工厂模式 + 自定义注解 + 反射 + 枚举 +
Map集合来实现一个策略模式，但也不是只要出现if-else就使用策略模式，当if-else => 4 , 我就会考虑使用这一套策略模式。

那么具体如何使用呢？我们通过一段业务来说明。

比如现在某一个平台有不同等级的用户，分别分为普通用户、黄金用户、铂金用户、钻石用户，需要通过不同的等级的用户查询相关的数据，比如优惠力度等。

一、首先定义一个自定义注解 ：StrategyType，用于标记具体的策略类。

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public @interface StrategyType {
    /**
     * 策略类型对应的具体的策略的编码
     * @return 策略类型对应的具体的策略的编码
     */
    String code() ;

    /**
     * 策略类型枚举编码
     * @return 枚举类型编码
     */
    StrategyTypeEnum type() ;

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

二、然后定义一个枚举类 ：StrategyTypeEnum，用于列举所有支持的策略。

public enum StrategyTypeEnum {

    USER_STRATEGY_TYPE("userStrategyType" , "用户类型策略枚举编码");
    /*
     * @TODO 如果有其它策略也可以加，比如根据不同的角色加载不同的数据 RoleStrategyType
     * ROLE_STRATEGY_TYPE("roleStrategyType" ," 角色策略枚举编码")
     */

    /**
     * 策略类型编码
     */
    private final String strategyTypeCode;

    /**
     * 策略类型描述
     */
    private final String strategyTypeDesc;

    /**
     *
     * @param strategyTypeCode 策略类型编码
     * @param strategyTypeDesc 策略类型描述
     */
    StrategyTypeEnum(String strategyTypeCode, String strategyTypeDesc) {
        this.strategyTypeCode = strategyTypeCode;
        this.strategyTypeDesc = strategyTypeDesc;
    }

    public String getStrategyTypeCode() {
        return strategyTypeCode;
    }

    public String getStrategyTypeDesc() {
        return strategyTypeDesc;
    }

    /**
     * 根据策略类型编码获取枚举
     * @param strategyTypeCode 策略类型编码
     * @return StrategyTypeEnum 策略类型枚举
     * @throws NullPointerException
     */
    public static StrategyTypeEnum getUserTypeEnumByCode(String strategyTypeCode) throws NullPointerException {
        if(strategyTypeCode.isEmpty()){
            throw new NullPointerException("策略类型编码不能为空");
        }
        for (StrategyTypeEnum strategyTypeEnum : StrategyTypeEnum.values()) {
            if(strategyTypeEnum.strategyTypeCode.equals(strategyTypeCode)){
                return strategyTypeEnum;
            }
        }

        return null;
    }

}
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
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56

三、再然后、定义一个策略类型编码常量类 ：StrategyTypeConstant，用来放不同策略对应的具体的策略的编码。

public interface StrategyTypeConstant {

    /**
     * 普通用户
     */
    public static final String USER_TYPE_NORMAL = "NORMAL";
    /**
     * 普通用户
     */
    public static final String USER_TYPE_GOLD = "GOLD";
    /**
     * 普通用户
     */
    public static final String USER_TYPE_PLATINUM = "PLATINUM";
    /**
     * 普通用户
     */
    public static final String USER_TYPE_DIAMOND = "DIAMOND";

    /*
     * @TODO 可以进行扩展 ， 其它策略的编码
     */

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

四、接着，我们创建一个策略工厂StrategyFactory，负责根据注解值获取对应的策略实例。

@Component
public class StrategyTypeFactory implements ApplicationContextAware {

    private final Map<String, UserDataHandler> handlerMap = new HashMap<>();

    public UserDataHandler getUserDataHandler(String userTypeCode) {
        return handlerMap.get(userTypeCode);
    }

    /**
     * Set the ApplicationContext that this object runs in.
     * Normally this call will be used to initialize the object.
     * 
Invoked after population of normal bean properties but before an init callback such
     * as {@link InitializingBean#afterPropertiesSet()}
     *
     * @param applicationContext the ApplicationContext object to be used by this object
     * @throws BeansException              if thrown by application context methods
     * @see BeanInitializationException
     */
    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {

        // 添加用户数据处理策略
        addUserDataHandlerStrategy(applicationContext);
        // @TODO 可以进行扩展 ， 添加其它策略....
    }

    private void addUserDataHandlerStrategy(ApplicationContext applicationContext){

        Map<String, Object> beansWithAnnotation = applicationContext.getBeansWithAnnotation(StrategyType.class);
        beansWithAnnotation.entrySet().iterator().forEachRemaining(entrySet ->{
            StrategyType annotation = entrySet.getValue().getClass().getAnnotation(StrategyType.class);
            // 获取到用户类型枚举
            String userTypeCode = annotation.code();
            // 获取到策略类型枚举
            String strategyTypeCode = annotation.type().getStrategyTypeCode();
            // 策略的类型编码以及用户类型编码拼接为key ， 表示某某策略类型的某某编码对应的策略
            // key : strategyTypeCode + ":" +  userTypeCode表示 : 用户类型策略的普通用户
            // value : 对应的普通用户的处理类
            this.handlerMap.put(strategyTypeCode + ":" +  userTypeCode , (UserDataHandler) entrySet.getValue());
        });
    }
}
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
30
31
32
33
34
35
36
37
38
39
40
41
42
43

五、继续、定义一个接口：UserDataHandler，所有具体用户策略类都要实现该接口。

public interface UserDataHandler {

    /**
     * 处理用户数据
     */
    Object handleUserData();
}
1
2
3
4
5
6
7

六、然后，我们创建四个具体的用户策略类NormalUserStrategy、GoldUserStrategy、PlatinumUserStrategy、DiamondUserStrategy，并使用@StrategyType注解标记每个策略类的类型：

@StrategyType(code = StrategyTypeConstant.USER_TYPE_DIAMOND , type = StrategyTypeEnum.USER_STRATEGY_TYPE)
@Service
public class DiamondUserDataHandler implements UserDataHandler{
    /**
     * 处理用户数据
     *
     * @return 处理结果
     */
    @Override
    public Object handleUserData() {
      // @TODO 对应的业务逻辑
        System.out.println("钻石用户业务逻辑");
        return "钻石用户业务逻辑";
    }
}

@StrategyType(code = StrategyTypeConstant.USER_TYPE_GOLD , type = StrategyTypeEnum.USER_STRATEGY_TYPE)
@Service
public class GoldUserDataHandler implements UserDataHandler{
    /**
     * 处理用户数据
     *
     * @return 处理结果
     */
    @Override
    public Object handleUserData() {
    // @TODO 对应的业务逻辑
        System.out.println("黄金用户业务逻辑");
        return "黄金用户业务逻辑";
    }
}

@StrategyType(code = StrategyTypeConstant.USER_TYPE_NORMAL , type = StrategyTypeEnum.USER_STRATEGY_TYPE)
@Service
public class NormalUserDataHandler implements UserDataHandler{
    /**
     * 处理用户数据
     *
     * @return 处理结果
     */
    @Override
    public Object handleUserData() {
      // @TODO 对应的业务逻辑
        System.out.println("普通用户业务逻辑");
        return "普通用户业务逻辑";
    }
}

@StrategyType(code = StrategyTypeConstant.USER_TYPE_PLATINUM , type = StrategyTypeEnum.USER_STRATEGY_TYPE)
@Service
public class PlatinumUserDataHandler implements UserDataHandler{
    /**
     * 处理用户数据
     *
     * @return 处理结果
     */
    @Override
    public Object handleUserData() {
      // @TODO 对应的业务逻辑
        System.out.println("铂金用户业务逻辑");
        return "铂金用户业务逻辑";
    }
}
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
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63

七、测试：

@RestController
@RequestMapping("sysUser")
public class UserDataController {

    @Resource
    private StrategyTypeFactory strategyTypeFactory;

    @RequestMapping("userDataHandle")
    public Result<Object> userDataHandle(String userTypeCode){
        // 根据不同的用户类型执行不同的策略
        UserDataHandler userDataHandler = strategyTypeFactory.getUserDataHandler(StrategyTypeEnum.USER_STRATEGY_TYPE.getStrategyTypeCode() + ":" + userTypeCode);
        if(userDataHandler == null){
            return Result.error(HttpStatusCodeEnum.ERROR);
        }
        return Result.success(userDataHandler.handleUserData());
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

八、测试结果

普通用户

黄金用户

铂金用户

钻石用户

如果现在又出现了一个超级VIP用户，那么只需要加一个对应的实现类就行，然后使用注解标记，就不用再屎山中找到对应的if-else，然后进行判断…等等一些列操作。

如果有别的业务逻辑也需要策略，比如根据角色获取对应的数据，只需要在StrategyTypeConstant常量类中加入对应的策略key(编码)，然后写上具体的实现类，并且在工厂中把策略类添加到Map中即可。

这样的代码正好运用了面向对象的多态性 ：

多态性是面向对象编程中的一个重要概念，它允许不同类的对象对同一消息作出不同的响应，即同一操作可以在不同的对象上有不同的行为。多态性的好处包括提高代码的灵活性和可扩展性，实现了封装和抽象，降低代码的耦合性。

低耦合是指软件架构中各模块之间的相互依赖程度较低的设计原则。通过低耦合的设计，可以增强系统的模块化程度，提高代码的可维护性和可扩展性。低耦合的方法包括使用接口或抽象类定义公共接口、避免直接调用具体实现、使用代理和中间件等。

综上所述，多态性和低耦合都是面向对象编程中的重要概念，它们能够提高代码的灵活性、可重用性和可维护性。通过运用多态性和低耦合的设计原则，可以使得程序更加易于理解、扩展和维护。

觉得文章写的不错的话 ， 可以来个一键三连 ， 同时可以关注我微信公众号 ，猿人刘先生 ，有各种面试题， 简历模板，电子书等资料相送哦！