看清楚是FactoryBean,不是BeanFactory,虽然他们长得很像,但作用确实天差地别,BeanFactory是bean工厂,前面的博客已经介绍过了,他们工厂类的基础接口,而FactoryBean是一种bean,那为什么要有这种bean呢,和一般的bean有什么区别呢?下面跟大家分享一下FactoryBean。
一、为什么需要FactoryBean
我们知道spring里一切皆是bean,Spring通过反射机制利用<bean>的class属性指定实现类实例化Bean,但是有些情况下,实例化Bean过程比较复杂,如果按照传统的方式,则需要在<bean>中提供大量的配置信息。配置方式的灵活性是受限的,这时采用编码的方式可能会得到一个简单的方案。这时FactoryBean就出现了,FactoryBean就是通过编码的方式灵活的创建bean的实例,这也是工厂模式设计模式的运用。
二、什么是FactoryBean
FactoryBean是一个接口,getObject就是创建bean实例的关键方法。
public interface FactoryBean {
/**
* Return an instance (possibly shared or independent) of the object
* managed by this factory. As with a BeanFactory, this allows
* support for both the Singleton and Prototype design pattern.
* @return an instance of the bean (should never be null)
* @throws Exception in case of creation errors
*/
Object getObject() throws Exception;
/**
* Return the type of object that this FactoryBean creates, or null
* if not known in advance. This allows to check for specific types of
* beans without instantiating objects, e.g. on autowiring.
* <p>For a singleton, this can simply return getObject().getClass(),
* or even null, as autowiring will always check the actual objects
* for singletons. For prototypes, returning a meaningful type here
* is highly advisable, as autowiring will simply ignore them else.
* @return the type of object that this FactoryBean creates, or null
* @see ListableBeanFactory#getBeansOfType
*/
Class getObjectType();
/**
* Is the bean managed by this factory a singleton or a prototype?
* That is, will getObject() always return the same object?
* <p>The singleton status of the FactoryBean itself will
* generally be provided by the owning BeanFactory.
* @return if this bean is a singleton
*/
boolean isSingleton();
}
getObject():返回由FactoryBean创建的bean实例,如果isSingleton()返回true,则该实例会放到Spring容器中单实例缓存池中。
boolean isSingleton():返回由FactoryBean创建的bean实例的作用域是singleton还是prototype。
Class<T> getObjectType():返回FactoryBean创建的bean类型。
bean工厂创建bean对象时要判断改对象是否是FactoryBean,如果是FactoryBean则调用他的getObject()方法获取实例化bean。AbstractBeanFactory源码如下:
protected Object getObjectForSharedInstance(String name, Object beanInstance) {
String beanName = transformedBeanName(name);
// Don't let calling code try to dereference the
// bean factory if the bean isn't a factory
if (isFactoryDereference(name) && !(beanInstance instanceof FactoryBean)) {
throw new BeanIsNotAFactoryException(beanName, beanInstance);
}
// Now we have the bean instance, which may be a normal bean
// or a FactoryBean. If it's a FactoryBean, we use it to
// create a bean instance, unless the caller actually wants
// a reference to the factory.
if (beanInstance instanceof FactoryBean) {
if (!isFactoryDereference(name)) {
// return bean instance from factory
FactoryBean factory = (FactoryBean) beanInstance;
logger.debug("Bean with name '" + beanName + "' is a factory bean");
try {
beanInstance = factory.getObject();
}
catch (BeansException ex) {
throw ex;
}
catch (Exception ex) {
throw new BeanCreationException("FactoryBean threw exception on object creation", ex);
}
if (beanInstance == null) {
throw new FactoryBeanCircularReferenceException(
"Factory bean '" + beanName + "' returned null object - " +
"possible cause: not fully initialized due to circular bean reference");
}
}
else {
// the user wants the factory itself
logger.debug("Calling code asked for FactoryBean instance for name '" + beanName + "'");
}
}
return beanInstance;
}
三、demo
(转自:https://www.jianshu.com/p/6f0a59623090)
当前微服务日趋流行,项目开发中不可避免的需要去调用一些其他系统接口,这个时候选择一个合适的HTTP client library 就很关键了,本人项目开发中使用 Square 开源的OkHttp 。
OkHttp本身的API 已经非常好用了,结合Spring 以及在其他项目中复用的目的,对OkHttp 创建过程做了一些封装,例如超时时间、连接池大小、http代理等。
maven依赖:
<dependency>
<groupId>com.squareup.okhttp3</groupId>
<artifactId>okhttp</artifactId>
<version>3.6.0</version>
</dependency>
首先,是OkHttpClientFactoryBean ,代码如下:
package com.bytebeats.codelab.http.okhttp;
import com.bytebeats.codelab.http.util.StringUtils;
import okhttp3.*;
import org.springframework.beans.factory.DisposableBean;
import org.springframework.beans.factory.FactoryBean;
import java.io.IOException;
import java.net.InetSocketAddress;
import java.net.Proxy;
import java.util.concurrent.TimeUnit;
/**
* ${DESCRIPTION}
*
* @author Ricky Fung
* @create 2017-03-04 22:18
*/
public class OkHttpClientFactoryBean implements FactoryBean, DisposableBean {
private int connectTimeout;
private int readTimeout;
private int writeTimeout;
/**http proxy config**/
private String host;
private int port;
private String username;
private String password;
/**OkHttpClient instance**/
private OkHttpClient client;
@Override
public Object getObject() throws Exception {
ConnectionPool pool = new ConnectionPool(5, 10, TimeUnit.SECONDS);
OkHttpClient.Builder builder = new OkHttpClient.Builder();
builder.connectTimeout(connectTimeout, TimeUnit.MILLISECONDS)
.readTimeout(readTimeout, TimeUnit.MILLISECONDS)
.writeTimeout(writeTimeout, TimeUnit.MILLISECONDS)
.connectionPool(pool);
if(StringUtils.isNotBlank(host) && port>0){
Proxy proxy = new Proxy(Proxy.Type.HTTP,new InetSocketAddress(host, port));
builder.proxy(proxy);
}
if(StringUtils.isNotBlank(username) && StringUtils.isNotBlank(password)){
Authenticator proxyAuthenticator = new Authenticator() {
@Override
public Request authenticate(Route route, Response response) throws IOException {
String credential = Credentials.basic(username, password);
return response.request().newBuilder()
.header("Proxy-Authorization", credential)
.build();
}
};
builder.proxyAuthenticator(proxyAuthenticator);
}
client = builder.build();
return client;
}
@Override
public Class<?> getObjectType() {
return OkHttpClient.class;
}
@Override
public boolean isSingleton() {
return true;
}
@Override
public void destroy() throws Exception {
if(client!=null){
client.connectionPool().evictAll();
client.dispatcher().executorService().shutdown();
client.cache().close();
client = null;
}
}
public void setConnectTimeout(int connectTimeout) {
this.connectTimeout = connectTimeout;
}
public void setReadTimeout(int readTimeout) {
this.readTimeout = readTimeout;
}
public void setWriteTimeout(int writeTimeout) {
this.writeTimeout = writeTimeout;
}
public void setHost(String host) {
this.host = host;
}
public void setPort(int port) {
this.port = port;
}
public void setUsername(String username) {
this.username = username;
}
public void setPassword(String password) {
this.password = password;
}
}
项目中引用 applicationContext.xml:
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:util="http://www.springframework.org/schema/util"
xsi:schemaLocation="
http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">
<bean id="okHttpClient" class="com.bytebeats.codelab.http.okhttp.OkHttpClientFactoryBean">
<property name="connectTimeout" value="2000" />
<property name="readTimeout" value="2000" />
<property name="writeTimeout" value="2000" />
<property name="host" value="" />
<property name="port" value="0" />
<property name="username" value="" />
<property name="password" value="" />
</bean>
</beans>
写个测试类测试一下:
@Resource
private OkHttpClient client;
public void run() throws Exception {
Request request = new Request.Builder()
.url("https://www.baidu.com/")
.build();
Response response = client.newCall(request).execute();
if (!response.isSuccessful()) throw new IOException("Unexpected code " + response);
System.out.println(response.body().string());
}