Spring5中更优雅的第三方Bean注入

小伙伴们知道，当我们使用 Spring 容器的时候，如果遇到一些特殊的 Bean，一般来说可以通过如下三种方式进行配置：

  • 静态工厂方法
  • 实例工厂方法
  • FactoryBean

不过从 Spring5 开始，在 AbstractBeandefinition 类中多了一个属性，对于特殊的 Bean 我们有了更多的选择：

/**
 * Specify a callback for creating an instance of the bean,
 * as an alternative to a declaratively specified factory method.
 * 
If such a callback is set, it will override any other constructor
 * or factory method metadata. However, bean property population and
 * potential annotation-driven injection will still apply as usual.
 * @since 5.0
 * @see #setConstructorArgumentValues(ConstructorArgumentValues)
 * @see #setPropertyValues(MutablePropertyValues)
 */
public void setInstanceSupplier(@Nullable Supplier instanceSupplier) {
 this.instanceSupplier = instanceSupplier;
}

/**
 * Return a callback for creating an instance of the bean, if any.
 * @since 5.0
 */
@Nullable
public Supplier getInstanceSupplier() {
 return this.instanceSupplier;
}

接下来松哥就来和大家简单聊一聊这个话题。

1. 传统解决方案

1.1 问题

不知道各位小伙伴们有没有用过 OkHttp，这是一个专门做网络请求的工具，在微服务的 HTTP 调用组件中，我们可以配置底层使用 OkHttp 这个工具。

一般来说，如果我们想直接使用 OkHttp，代码如下：

OkHttpClient client = new OkHttpClient.Builder()
        .connectTimeout(5, TimeUnit.SECONDS)
        .readTimeout(5, TimeUnit.SECONDS)
        .build();
Request getReq = new Request.Builder().get().url("http://www.javaboy.org").build();
Call call = client.newCall(getReq);
call.enqueue(new Callback() {
    @Override
    public void onFailure(@NotNull Call call, @NotNull IOException e) {
        System.out.println("e.getMessage() = " + e.getMessage());
    }
    @Override
    public void onResponse(@NotNull Call call, @NotNull Response response) throws IOException {
        System.out.println("response.body().string() = " + response.body().string());
    }
});

先通过建造者模式创建出来一个 OkHttpClient 对象，然后还是建造者模式创建出来 Request 对象，接下来去发送请求就可以了。那么对于这样的代码，我们可以将 OkHttpClient 对象交由 Spring 容器统一管理，那么该如何将 OkHttpClient 注册到 Spring 容器中呢？

1.2 静态工厂方法

首先可以采用静态工厂方法，也就是工厂方法是一个静态方法，如下：

public class OkHttpStaticFactory {
    private static OkHttpClient okHttpClient;
    static {
        okHttpClient = new OkHttpClient.Builder()
                .connectTimeout(5, TimeUnit.SECONDS)
                .readTimeout(5, TimeUnit.SECONDS)
                .build();
    }
    
    public static OkHttpClient getOkHttpClient() {
        return okHttpClient;
    }
}

然后在 Spring 配置文件中进行注入：

静态工厂的特点是静态方法可以直接调用，并必须要获取到工厂类的实例，所以上面配置的时候只需要指定 factory-method 就可以了。

这就可以了，将来我们去 Spring 容器中查找一个名为 httpClient 的对象，拿到手的就是 OkHttpClient 了。

1.3 实例工厂方法

实例工厂方法意思就是说工厂方法是一个实例方法。如下：

public class OkHttpInstanceFactory {
    private volatile static OkHttpClient okHttpClient;

    public OkHttpClient getInstance() {
        if (okHttpClient == null) {
            synchronized (OkHttpInstanceFactory.class) {
                if (okHttpClient == null) {
                    okHttpClient = new OkHttpClient.Builder()
                            .connectTimeout(5, TimeUnit.SECONDS)
                            .readTimeout(5, TimeUnit.SECONDS)
                            .build();
                }
            }
        }
        return okHttpClient;
    }
}

这是一个简单的单例模式。但是这里的工厂方法是一个实例方法，实例方法的调用必须得先获取到对象然后才能调用实例方法，因此配置方式如下：

好啦，接下来我们就可以去 Spring 容器中获取一个名为 httpClient 的对象了，拿到手的就是 OkHttpClient 实例。

1.4 FactoryBean

当然，也可以通过 FactoryBean 来解决上述问题，FactoryBean 松哥在之前的文章中刚刚和大家介绍过，我们来看下：

public class OkHttpClientFactoryBean implements FactoryBean {
    @Override
    public OkHttpClient getObject() throws Exception {
        return new OkHttpClient.Builder()
                .connectTimeout(5, TimeUnit.SECONDS)
                .readTimeout(5, TimeUnit.SECONDS)
                .build();
    }

    @Override
    public Class getObjectType() {
        return OkHttpClient.class;
    }

    @Override
    public boolean isSingleton() {
        return true;
    }
}

最后在 Spring 中配置即可：

这个就不做过多解释了，不熟悉的小伙伴可以翻看前面的文章。

上面这三种方案都是传统方案。

特别是前两种，其实我们用的比较少，前两种有一个缺陷，就是我们配置的的 factory-method 都是通过反射来调用的，通过反射调用的话，多多少少性能受点影响。

这种 factory-method 在 Spring 中处理的源码执行时序图如下：

图片

所以最终反射是在 SimpleInstantiationStrategy#instantiate 方法中执行的，就是大家非常熟悉的反射代码了：

@Override
public Object instantiate(RootBeanDefinition bd, @Nullable String beanName, BeanFactory owner,
  @Nullable Object factoryBean, final Method factoryMethod, Object... args) {
  ReflectionUtils.makeAccessible(factoryMethod);
  Method priorInvokedFactoryMethod = currentlyInvokedFactoryMethod.get();
  try {
   currentlyInvokedFactoryMethod.set(factoryMethod);
   Object result = factoryMethod.invoke(factoryBean, args);
   if (result == null) {
    result = new NullBean();
   }
   return result;
  }
  finally {
   if (priorInvokedFactoryMethod != null) {
    currentlyInvokedFactoryMethod.set(priorInvokedFactoryMethod);
   }
   else {
    currentlyInvokedFactoryMethod.remove();
   }
  }
}

好了，这是传统的解决方案。

2. Spring5 解决方案

Spring5 中开始提供了 Supplier，可以通过接口回调获取到一个 Bean 的实例，这种方式显然性能更好一些。

如下：

AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext();
GenericBeanDefinition definition = new GenericBeanDefinition();
definition.setBeanClass(Book.class);
definition.setInstanceSupplier((Supplier) () -> {
    Book book = new Book();
    book.setName("深入浅出 Spring Security");
    book.setAuthor("江南一点雨");
    return book;
});
ctx.registerBeanDefinition("b1", definition);
ctx.refresh();
Book b = ctx.getBean("b1", Book.class);
System.out.println("b = " + b);

关键就是通过调用 BeanDefinition 的 setInstanceSupplier 方法去设置回调。当然，上面这段代码还可以通过 Lambda 进一步简化：

public class BookSupplier {
    public Book getBook() {
        Book book = new Book();
        book.setName("深入浅出 Spring Security");
        book.setAuthor("江南一点雨");
        return book;
    }
}

然后调用这个方法即可：

AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext();
GenericBeanDefinition definition = new GenericBeanDefinition();
definition.setBeanClass(Book.class);
BookSupplier bookSupplier = new BookSupplier();
definition.setInstanceSupplier(bookSupplier::getBook);
ctx.registerBeanDefinition("b1", definition);
ctx.refresh();
Book b = ctx.getBean("b1", Book.class);
System.out.println("b = " + b);

这是不是更有一点 Lambda 的感觉了～

在 Spring 源码中，处理获取 Bean 实例的时候，有如下一个分支，就是处理 Supplier 这种情况的：

AbstractAutowireCapableBeanFactory#createBeanInstance

protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) {
 // Make sure bean class is actually resolved at this point.
 Class beanClass = resolveBeanClass(mbd, beanName);
 if (beanClass != null && !Modifier.isPublic(beanClass.getModifiers()) && !mbd.isNonPublicAccessAllowed()) {
  throw new BeanCreationException(mbd.getResourceDescription(), beanName,
    "Bean class isn't public, and non-public access not allowed: " + beanClass.getName());
 }
 Supplier instanceSupplier = mbd.getInstanceSupplier();
 if (instanceSupplier != null) {
  return obtainFromSupplier(instanceSupplier, beanName);
 }
 if (mbd.getFactoryMethodName() != null) {
  return instantiateUsingFactoryMethod(beanName, mbd, args);
 }
 //...
 return instantiateBean(beanName, mbd);
}

@Nullable
private Object obtainInstanceFromSupplier(Supplier supplier, String beanName) {
 String outerBean = this.currentlyCreatedBean.get();
 this.currentlyCreatedBean.set(beanName);
 try {
  if (supplier instanceof InstanceSupplier instanceSupplier) {
   return instanceSupplier.get(RegisteredBean.of((ConfigurableListableBeanFactory) this, beanName));
  }
  if (supplier instanceof ThrowingSupplier throwableSupplier) {
   return throwableSupplier.getWithException();
  }
  return supplier.get();
 }
}

上面 obtainFromSupplier 这个方法，最终会调用到第二个方法。第二个方法中的 supplier.get(); 其实最终就调用到我们自己写的 getBook 方法了。

本文名称：Spring5中更优雅的第三方Bean注入
网页路径：http://www.shufengxianlan.com/qtweb/news19/432069.html

网站建设、网络推广公司-创新互联，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等

广告

声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源： 创新互联

猜你还喜欢下面的内容

做网站知识

分类信息网站

青羊区雕琢时光　　 　成都免费做网站　　 　宣传册设计　　 　温江网站建设　　 　网站seo　　 　成都服务器租用　　 　成都雨棚定制　　 　网站排名　　 　手机网站制作　　 　成都广告设计公司　　 　蓬溪网站建设　　 　成都户外广告牌设计　　 　四川电信高防服务器托管　　 　成都网站建设　　 　手机网站建设公司　　 　眉山做网站　　 　重庆电信回兴机房　　 　小谭建站　　 　成都水电改造　　 　成都二枢机房