SpringBoot中优雅的编写服务工厂的方法示例_Java

在基于 spring boot 的业务开发中，我们有时会遇到这样的场景：即定义了一个通用接口，而该接口拥有多个实现类。在调用这些实现类时，我们通常需要编写一个工厂方法，该工厂方法可以根据指定的参数获取到对应的实现类。

那么，提供该工厂方法的类就是一个服务工厂，本文即是探讨如何优雅的编写这个服务工厂。

1 场景描述

为了将所描述的场景具像化，下面举一个易于理解的例子：「假定我们正在使用 spring boot 做一个对接多个第三方支付平台的支付服务。」

我们在实现这个支付服务时，定义了一个通用的支付接口 paymentservice，其拥有一个 pay() 方法。该接口可以对订单（order）进行支付，支付后会得到一个支付结果 paymentresult。

public interface paymentservice {
    paymentresult pay(order order);
}

public class order {
}

public class paymentresult {
    private boolean success;
    private string message;
}

目前这个支付服务需要支持三种支付类型：alibaba、wechat 和银联。

public enum paymenttype {
    alibaba,
    wechat,
    union
}

那么 paymentservice 就会拥有三个不同的实现类：alibabapaymentserviceimpl、wechatpaymentserviceimpl 和 unionpaymentserviceimpl。

@service("alibabapaymentservice")
public class alibabapaymentserviceimpl implements paymentservice {
    @override
    public paymentresult pay(order order) {
        return ...;
    }
}

@service("wechatpaymentservice")
public class wechatpaymentserviceimpl implements paymentservice {
    @override
    public paymentresult pay(order order) {
        return ...;
    }
}

@service("unionpaymentservice")
public class unionpaymentserviceimpl implements paymentservice {
    @override
    public paymentresult pay(order order) {
        return ...;
    }
}

为了方便调用，我们需要编写一个工厂类 paymentfactory，其能够提供一个方法：可以根据不同的支付类型（paymenttype）获取到 paymentservice 的具体实现。

public class paymentfactory {

    public paymentservice getservice(paymenttype paymenttype) {
        return xxx;
    }
}

这样调用者需要使用某种方式进行支付时，只需要指定支付类型，通过工厂类拿到 paymentservice，然后调用 pay() 方法就可以了。

paymentservice paymentservice = paymentfactory.getservice(paymenttype.wechat);
paymentresult paymentresult = paymentservice.pay(new order());

system.out.println(paymentresult);

2 paymentfactory 基础实现

那么如何编写这个 paymentfactory 呢？一种最基础的写法就是在 paymentfactory 中将 paymentservice 所有的实现类都以属性的方式注入进来，然后在 getservice() 方法中使用 if-else 或 switch 语句根据 paymenttype 来返回不同的实现类。

@component
public class paymentfactory {

    @qualifier("alibabapaymentservice")
    @autowired
    private paymentservice alibabapaymentservice;

    @qualifier("wechatpaymentservice")
    @autowired
    private paymentservice wechatpaymentservice;

    @qualifier("unionpaymentservice")
    @autowired
    private paymentservice unionpaymentservice;

    public paymentservice getservice(paymenttype paymenttype) {
        return switch (paymenttype) {
            case alibaba -> alibabapaymentservice;
            case wechat -> wechatpaymentservice;
            case union -> unionpaymentservice;
            default -> throw new illegalargumentexception("paymenttype is not supported");
        };
    }
}

这种写法能用，但代码行数有点多且有点笨拙，有没有更高级一点的写法呢？

3 paymentfactory 高级实现

paymentfactory 稍微高级一点的写法是不用将实现类一一声明为属性，且不使用上述诸如 if-else 或 switch 等条件判断语句来根据不同参数返回不同的实现。

而是声明一个存放 paymenttype 和实现类的 map，然后在构造方法中将实现类注入为方法参数，然后建立该 map，这样在 getservice() 方法中只需根据 paymenttype 从 map 中直接获取实现类即可。

@component
public class paymentfactory {

    private final map<paymenttype, paymentservice> paymentservices;

    @autowired
    public paymentfactory(
            @qualifier("alibabapaymentservice") paymentservice alibabapaymentservice,
            @qualifier("wechatpaymentservice") paymentservice wechatpaymentservice,
            @qualifier("unionpaymentservice") paymentservice unionpaymentservice) {
        paymentservices = map.of(
                paymenttype.alibaba, alibabapaymentservice,
                paymenttype.wechat, wechatpaymentservice,
                paymenttype.union, unionpaymentservice
        );
    }

    public paymentservice getservice(paymenttype paymenttype) {
        return optional.ofnullable(paymentservices.get(paymenttype))
                .orelsethrow(() -> new illegalargumentexception("paymenttype is not supported"));
    }
}

上面的实现比较优雅，但代码行数仍有点多，有没有更简便的写法呢？

有。因为 paymentservice 的实现类命名是有规则的，所以更简便的写法即是借助 spring beanfactory 直接根据 bean 名称获取对应的实现。

@component
public class paymentfactory {

    @autowired
    private beanfactory beanfactory;

    public paymentservice getservice(paymenttype paymenttype) {
        string beanname = paymenttype.name().tolowercase() + "paymentservice";
        if (!beanfactory.containsbean(beanname)) {
            throw new illegalargumentexception("paymenttype is not supported");
        }
        return (paymentservice) beanfactory.getbean(beanname);
    }
}

上述代码的确简洁了不少，但其与前面的写法均有一个同样的问题，即类上均含有 @component 注解，即均需要交给 spring 实例化。在静态方法或由 java 反射实例化的类中无法直接使用。

下面就尝试编写一个纯静态的 paymentfactory，使得调用者可以直接像下面这样通过 paymentfactory.getservice() 的方式获取 paymentservice 的实现类。

paymentservice paymentservice = paymentfactory.getservice(paymenttype.wechat);

这样就需要依赖一个保存 spring 应用上下文的工具类了：

@component
public class springcontextholder implements applicationcontextaware {

    private static applicationcontext context;

    @override
    public void setapplicationcontext(applicationcontext applicationcontext) throws beansexception {
        context = applicationcontext;
    }

    public static <t> t getbean(string beanname, class<t> clazz) {
        return context.getbean(beanname, clazz);
    }
}

springcontextholder 工具类可以在 spring 加载完成后自动持有 spring 的 applicationcontext。然后在后期有需要时，调用者可以使用一个纯静态方法来获取任意 spring 管理的 bean。

这样，有了 springcontextholder 工具类后，我们的静态 paymentfactory 就可以像下面这样实现了。

public class paymentfactory {

    public static paymentservice getservice(paymenttype paymenttype) {
        string beanname = paymenttype.name().tolowercase() + "paymentservice";
        return springcontextholder.getbean(beanname, paymentservice.class);
    }
}