使用InitializingBean实现工厂模式
前言
在实际开发过程中，工厂模式的使用是比较频繁的，而使用InitializingBean可以简化工厂处理器类的初始化与注册。
下面就简单演示如何创建一个完整的工厂模式。
类结构
整体结构如下图所示：
OrderFactory: 订单工厂类，用于获取处理器以及注册处理器。
OrderHandler: 订单处理器接口 Interface，继承 InitializingBean，定义处理器的方法。
AbstractOrderHandler: 订单处理器抽象实现，实现 OrderHandler ，可以给一些接口中的方法定义一个默认实现。
FlightOrderHandler: 飞机票订单处理器，继承 AbstractOrderHandler ，处理飞机票订单的自定义实现，并将处理器注册至工厂中。
TrainOrderHandler: 火车票订单处理器，继承 AbstractOrderHandler ，处理火车票订单的自定义实现，并将处理器注册至工厂中。
HotelOrderHandler: 酒店订单处理器，继承 AbstractOrderHandler ，处理酒店订单的自定义实现，并将处理器注册至工厂中。
具体实现
OrderFactory
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
|
public class OrderFactory {
public enum OrderType {
HOTEL, FLIGHT, TRAIN
}
private static final Map<OrderType, OrderHandler> HANDLER_MAP = new HashMap<>();
public static OrderHandler getHandler(OrderType orderType) {
if (HANDLER_MAP.containsKey(orderType)) {
OrderHandler handler = HANDLER_MAP.get(orderType);
Log.info("获取处理器：{}", handler.getClass().getName());
return handler;
} else {
throw new UnsupportedOperationException("不支持的处理类型：" + orderType);
}
}
public static void register(OrderType orderType, OrderHandler orderHandler) {
Log.info("注册处理器：{}", orderHandler.getClass().getName());
if (HANDLER_MAP.containsKey(orderType)) {
throw new UnexpectedTypeException("当前处理类型已被注册：" + orderType);
}
HANDLER_MAP.put(orderType, orderHandler);
}
}
|
OrderHandler
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
|
public interface OrderHandler extends InitializingBean {
Order order(OrderRequest request);
PayResult pay(PayRequest request);
void callback(CallbackRequest request);
}
|
AbstractOrderHandler
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
@Slf4j
public abstract class AbstractOrderHandler implements OrderHandler {
@Override
public PayResult pay(PayRequest request) {
log.info("通用的支付处理");
return new PayResult();
}
}
|
FlightOrderHandler
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
|
@Component
@Slf4j
public class FlightOrderHandler extends AbstractOrderHandler {
@Override
public Order order(OrderRequest request) {
log.info("飞机票下单处理");
return new Order();
}
@Override
public void callback(CallbackRequest request) {
log.info("飞机票回调处理");
}
@Override
public void afterPropertiesSet() {
OrderFactory.register(OrderFactory.OrderType.FLIGHT, this);
}
}
|
TrainOrderHandler
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
|
@Component
@Slf4j
public class TrainOrderHandler extends AbstractOrderHandler {
@Override
public Order order(OrderRequest request) {
log.info("火车票下单处理");
return new Order();
}
@Override
public void callback(CallbackRequest request) {
log.info("火车票回调处理");
}
@Override
public void afterPropertiesSet() {
OrderFactory.register(OrderFactory.OrderType.TRAIN, this);
}
}
|
HotelOrderHandler
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
|
@Component
@Slf4j
public class HotelOrderHandler extends AbstractOrderHandler {
@Override
public Order order(OrderRequest request) {
log.info("酒店下单处理");
return new Order();
}
@Override
public PayResult pay(PayRequest request) {
log.info("酒店支付特殊处理");
return super.pay(request);
}
@Override
public void callback(CallbackRequest request) {
log.info("酒店回调处理");
}
@Override
public void afterPropertiesSet() {
OrderFactory.register(OrderFactory.OrderType.HOTEL, this);
}
}
|
使用示例
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
|
@Slf4j
@Service
public class OrderService {
public void orderConfirm(OrderFactory.OrderType orderType, OrderRequest orderRequest, PayRequest payRequest) {
log.info("接收到确认订单请求，订单类型：{}，下单请求：{}，支付请求：{}", orderType, orderRequest, payRequest);
OrderHandler handler = OrderFactory.getHandler(orderType);
Order order = handler.order(orderRequest);
log.info("订单信息：{}", order);
payRequest.setOrder(order);
PayResult payResult = handler.pay(payRequest);
log.info("支付结果：{}", payResult);
}
public void orderCallback(OrderFactory.OrderType orderType, CallbackRequest callbackRequest) {
log.info("接收到订单回调请求，订单类型：{}，回调请求：{}", orderType, callbackRequest);
OrderHandler handler = OrderFactory.getHandler(orderType);
handler.callback(callbackRequest);
}
}
|
总结
其实整体上来说和普通的工厂模式没有很大的区别，主要是利用了InitializingBean接口在Spring初始化Bean之后的钩子，方便我们在应用启动时就注册装载好工厂的处理器。
