【二三方】_工厂模式的应用进化版

发表于 | 分类于

工厂模式的应用进化版

之前介绍过借助Spring依赖注入来创建工厂的工厂模式应用，但是那种方式存在一定局限，一定要为实例bean创建别名，且要通过别名来获取到实例bean。现在依然是依赖Spring框架，介绍一种采用applicationContext.getBean(Class<T> var1)方法通过Class类来获取实例bean的工厂模式应用。

1.创建实例bean接口

1
2
3
public interface FailedStrategy {
    void dealFailedOrder(int orderNum);
}

2.创建实例bean实现类

创建工厂对象类，并将他们放入Spring容器中。

1
2
3
4
5
6
7
@Service
public class UnRechargeFailedStrategy implements FailedStrategy {
    @Override
    public void dealFailedOrder(int orderNum) {
        System.out.println("UnRechargeFailedStrategy_ReRecharge_" + orderNum);
    }
}
1
2
3
4
5
6
7
8
@Service
public class UnCallBackFailedStrategy implements FailedStrategy {

    @Override
    public void dealFailedOrder(int orderNum) {
        System.out.println("UnCallBackFailedStrategy_ReRecharge_" + orderNum);
    }
}

3.创建枚举类

创建枚举类，该枚举类中的一个最重要属性就是实例bean实现类的Class类对象，然后可以再任意创建其他属性，这些其他属性都可以用来作为工厂类中Map的key，使得工厂类可以根据key获得对应的实例bean实现类的Class类对象，然后再用applicationContext.getBean()方法来获取到实例bean。

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
public enum OrderStatusEnum {
    /**
     * 订单已落库未充值
     */
    IN_DB_UN_RECHARGE("1", "", UnRechargeFailedStrategy.class),
    /**
     * 订单已充值未回调状态通知接口
     */
    RECHARGE_UN_CALLBACK("2", "", UnCallBackFailedStrategy.class),
    /**
     * 订单成功
     */
    RECHARGE_CALLBACK("0", "", null)
    ;

    private String status;
    private String desc;
    private Class<? extends FailedStrategy> beanClass;

    OrderStatusEnum(String status, String desc, Class<? extends FailedStrategy> beanClass) {
        this.status = status;
        this.desc = desc;
        this.beanClass = beanClass;
    }

    public String getStatus() {
        return status;
    }

    public void setStatus(String status) {
        this.status = status;
    }

    public String getDesc() {
        return desc;
    }

    public void setDesc(String desc) {
        this.desc = desc;
    }

    public Class<? extends FailedStrategy> getBeanClass() {
        return beanClass;
    }

    public void setBeanClass(Class<? extends FailedStrategy> beanClass) {
        this.beanClass = beanClass;
    }
}

4.创建工厂类

创建工厂类，使用Map类型的静态变量获取并保存所有的枚举对象，依赖注入Spring容器对象，该工厂可以根据输入参数找到对应的实例bean。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
@Component
public class FailedStrategyFactory {
    private static final Map<String, OrderStatusEnum> FAILED_STRATEGY_FACTORY_MAP = new HashMap<>();

    static {
        for (OrderStatusEnum item : OrderStatusEnum.values()) {
            FAILED_STRATEGY_FACTORY_MAP.put(item.getStatus(), item);
        }
    }

  	//注入Spring容器对象
    @Autowired
    private ApplicationContext applicationContext;

    public FailedStrategy getBean(int status) {
        return applicationContext.getBean(FAILED_STRATEGY_FACTORY_MAP.get(String.valueOf(status)).getBeanClass());
    }
}

5.单元测试调用工厂实现功能

在测试包中创建单元测试类，注入工厂类并进行使用测试。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
import jingzhao.newFactory.test.factory.FailedStrategyFactory;
import jingzhao.newFactory.test.interfaces.FailedStrategy;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;

@RunWith(SpringRunner.class)
@SpringBootTest(classes = Application.class)
public class ApplicationTest {

    @Autowired
    FailedStrategyFactory failedStrategyFactory;

    @Test
    public void test() {
        FailedStrategy failedStrategy1 = failedStrategyFactory.getBean(1);
        FailedStrategy failedStrategy2 = failedStrategyFactory.getBean(2);
        failedStrategy1.dealFailedOrder(316438);
        failedStrategy2.dealFailedOrder(684470);
    }
}