Spring FactoryBean源码详解（详细注释版）
1. FactoryBean接口源码
/*
* FactoryBean接口是Spring框架中用于创建复杂Bean的重要扩展点
* 允许开发者自定义Bean的创建过程
* 是Spring框架中实现复杂对象创建的核心机制
*
* FactoryBean的作用：
* 1. 创建复杂的Bean实例
* 2. 实现延迟初始化
* 3. 创建代理对象
* 4. 实现单例和原型模式的自定义控制
* 5. 集成第三方框架
*
* 注意事项：
* - FactoryBean创建的Bean与FactoryBean本身是不同的对象
* - 可以通过&前缀获取FactoryBean本身
* - 需要正确实现isSingleton方法
*/
package org.springframework.beans.factory;
import org.springframework.lang.Nullable;
/**
* 由BeanFactory用于以工厂方式创建Bean的接口
*
* FactoryBean是Spring框架中最重要的扩展点之一
* 当BeanFactory发现一个Bean实现了FactoryBean接口时
* 它会调用getObject()方法来获取实际的Bean实例
* 而不是直接使用FactoryBean实例
*
* 获取FactoryBean创建的对象：直接使用Bean名称
* 获取FactoryBean本身：使用&前缀（如&myFactoryBean）
*
* 使用场景：
* - 创建复杂的对象（如MyBatis的SqlSessionFactory）
* - 实现延迟初始化
* - 创建代理对象（如AOP代理）
* - 集成第三方框架
* - 实现自定义的单例控制
*
* 注意：FactoryBean的生命周期由Spring容器管理
*/
public interface FactoryBean<T> {
/**
* 返回此工厂管理的对象的实例（可能是共享的或独立的）
*
* 此方法在每次调用时返回对象的新实例是可接受的
* 如果返回null，Spring容器会抛出异常
*
* @return 由此工厂创建的对象实例
* @throws Exception 如果创建对象实例时发生错误
*
* 使用建议：
* - 实现适当的单例或原型模式
* - 处理创建过程中的异常
* - 确保返回的对象是线程安全的（如果是单例）
* - 可以返回null，但需要在isSingleton中正确处理
*/
@Nullable
T getObject() throws Exception;
/**
* 返回此工厂创建的对象的类型
*
* 如果getObject()方法返回null，则此方法可以返回null
* 此方法可以在getObject()方法返回null时调用
*
* @return 此工厂创建的对象的类型，如果未知则返回null
*
* 使用建议：
* - 返回实际对象的类型
* - 如果对象类型不确定，可以返回null
* - 用于类型检查和自动装配
*/
@Nullable
Class<?> getObjectType();
/**
* 此工厂管理的对象是单例还是原型？
*
* 如果返回true，则getObject()方法在每次调用时返回相同的实例
* 如果返回false，则getObject()方法在每次调用时返回新的实例
*
* @return 如果此工厂创建的对象是单例，返回true；否则返回false
*
* 使用建议：
* - 正确实现单例控制逻辑
* - 考虑性能和内存使用
* - 与getObject()方法的行为保持一致
*/
default boolean isSingleton() {
return true;
}
}
2. AbstractFactoryBean抽象类
/*
* AbstractFactoryBean是FactoryBean的抽象实现
* 提供了常用的模板方法和默认实现
* 简化了FactoryBean的实现过程
*/
package org.springframework.beans.factory.config;
import org.springframework.beans.factory.*;
import org.springframework.beans.factory.support.*;
import org.springframework.core.*;
import org.springframework.lang.*;
import org.springframework.util.*;
import java.util.*;
/**
* FactoryBean接口的抽象实现
* 提供了常用的模板方法和默认实现
*
* 这个抽象类实现了以下功能：
* 1. 单例对象的缓存管理
* 2. 对象创建的同步控制
* 3. 销毁回调的支持
* 4. Aware接口的自动实现
* 5. BeanFactoryAware的自动实现
*
* 子类只需要实现createInstance()方法
* 其他方法可以按需重写
*/
public abstract class AbstractFactoryBean<T>
implements FactoryBean<T>, BeanClassLoaderAware, BeanFactoryAware, InitializingBean, DisposableBean {
// 日志记录器
protected final Log logger = LogFactory.getLog(getClass());
// 是否为单例
private boolean singleton = true;
// BeanClassLoader
@Nullable
private ClassLoader beanClassLoader;
// BeanFactory
@Nullable
private BeanFactory beanFactory;
// 单例对象缓存
@Nullable
private T singletonInstance;
// 早期单例对象引用（用于解决循环依赖）
@Nullable
private T earlySingletonInstance;
/**
* 设置是否为单例
*
* @param singleton true表示单例，false表示原型
*/
public void setSingleton(boolean singleton) {
this.singleton = singleton;
}
@Override
public boolean isSingleton() {
return this.singleton;
}
/**
* 设置BeanClassLoader
*
* @param classLoader 类加载器
*/
@Override
public void setBeanClassLoader(ClassLoader classLoader) {
this.beanClassLoader = classLoader;
}
/**
* 获取BeanClassLoader
*
* @return 类加载器
*/
@Nullable
protected ClassLoader getBeanClassLoader() {
return this.beanClassLoader;
}
/**
* 设置BeanFactory
*
* @param beanFactory Bean工厂
*/
@Override
public void setBeanFactory(BeanFactory beanFactory) {
this.beanFactory = beanFactory;
}
/**
* 获取BeanFactory
*
* @return Bean工厂
*/
@Nullable
protected BeanFactory getBeanFactory() {
return this.beanFactory;
}
/**
* 初始化Bean
* 在Bean属性设置完成后调用
*/
@Override
public void afterPropertiesSet() throws Exception {
// 如果是单例，预初始化对象
if (isSingleton()) {
this.singletonInstance = createInstance();
}
}
/**
* 获取对象实例
* FactoryBean接口的核心方法
*
* @return 对象实例
* @throws Exception 如果创建对象时发生错误
*/
@Override
@Nullable
public final T getObject() throws Exception {
if (isSingleton()) {
// 单例模式：返回缓存的实例
return (this.singletonInstance != null ? this.singletonInstance : obtainFromEarlySingleton());
}
else {
// 原型模式：每次创建新实例
return createInstance();
}
}
/**
* 从早期单例引用获取实例
* 用于解决循环依赖问题
*
* @return 对象实例
* @throws Exception 如果创建对象时发生错误
*/
@SuppressWarnings("unchecked")
private T obtainFromEarlySingleton() throws Exception {
Object earlySingleton = this.earlySingletonInstance;
if (earlySingleton != null) {
return (T) earlySingleton;
}
// 同步创建单例实例
return (T) (this.earlySingletonInstance = createInstance());
}
/**
* 获取对象类型
*
* @return 对象类型
*/
@Override
@Nullable
public Class<?> getObjectType() {
T product = this.singletonInstance;
return (product != null ? product.getClass() : null);
}
/**
* 创建对象实例
* 子类必须实现此方法
*
* @return 对象实例
* @throws Exception 如果创建对象时发生错误
*/
protected abstract T createInstance() throws Exception;
/**
* 销毁Bean
* 在容器关闭时调用
*/
@Override
public void destroy() throws Exception {
if (isSingleton()) {
destroyInstance(this.singletonInstance);
}
}
/**
* 销毁对象实例
* 子类可以重写此方法以执行清理操作
*
* @param instance 要销毁的对象实例
* @throws Exception 如果销毁时发生错误
*/
protected void destroyInstance(@Nullable T instance) throws Exception {
// 默认实现为空，子类可以重写
}
/**
* 返回对象的早期引用
* 用于解决循环依赖
*
* @param beanName Bean名称
* @param mbd 合并的Bean定义
* @return 早期引用
*/
protected Object getEarlySingletonInstance(String beanName, RootBeanDefinition mbd) {
if (isSingleton()) {
try {
return obtainFromEarlySingleton();
}
catch (Exception ex) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName,
"FactoryBean threw exception from getEarlyBeanReference", ex);
}
}
else {
return null;
}
}
}
3. FactoryBean在BeanFactory中的处理
/*
* BeanFactory中对FactoryBean的处理逻辑
*/
public class FactoryBeanHandling {
/**
* DefaultListableBeanFactory中获取Bean的逻辑
* 处理FactoryBean的特殊情况
*/
public class DefaultListableBeanFactory extends AbstractAutowireCapableBeanFactory
implements ConfigurableListableBeanFactory, BeanDefinitionRegistry {
/**
* 获取Bean实例的核心方法
* 处理FactoryBean的逻辑
*
* @param name Bean名称
* @param requiredType 需要的类型
* @param args 构造参数
* @param typeCheckOnly 是否仅用于类型检查
* @return Bean实例
*/
@Override
protected <T> T doGetBean(
String name, @Nullable Class<T> requiredType, @Nullable Object[] args, boolean typeCheckOnly)
throws BeansException {
// 解析Bean名称，处理FactoryBean的&前缀
String beanName = transformedBeanName(name);
Object bean;
// 检查是否已经创建了单例Bean
Object sharedInstance = getSingleton(beanName);
if (sharedInstance != null && args == null) {
if (logger.isTraceEnabled()) {
if (isSingletonCurrentlyInCreation(beanName)) {
logger.trace("Returning eagerly cached instance of singleton bean '" + beanName +
"' that is not fully initialized yet - a consequence of a circular reference");
}
else {
logger.trace("Returning cached instance of singleton bean '" + beanName + "'");
}
}
// 如果是FactoryBean，获取实际的对象实例
bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
}
else {
// 处理原型Bean和依赖注入
// ... 省略其他逻辑
// 创建Bean实例
if (mbd.isSingleton()) {
// 单例Bean的创建逻辑
sharedInstance = getSingleton(beanName, () -> {
try {
return createBean(beanName, mbd, args);
}
catch (BeansException ex) {
// 显式从单例缓存中删除实例
destroySingleton(beanName);
throw ex;
}
});
bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
}
else if (mbd.isPrototype()) {
// 原型Bean的创建逻辑
Object prototypeInstance = null;
try {
beforePrototypeCreation(beanName);
prototypeInstance = createBean(beanName, mbd, args);
}
finally {
afterPrototypeCreation(beanName);
}
bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
}
else {
// 其他作用域Bean的创建逻辑
// ... 省略
}
}
return (T) bean;
}
/**
* 获取Bean实例，处理FactoryBean的情况
* 这是处理FactoryBean的核心方法
*
* @param beanInstance Bean实例（可能是FactoryBean）
* @param name 原始Bean名称
* @param beanName 转换后的Bean名称
* @param mbd Bean定义
* @return 实际的Bean实例
*/
protected Object getObjectForBeanInstance(
Object beanInstance, String name, String beanName, @Nullable RootBeanDefinition mbd) {
// 如果名称以&开头，表示要获取FactoryBean本身
if (BeanFactoryUtils.isFactoryDereference(name)) {
if (beanInstance instanceof NullBean) {
return beanInstance;
}
if (!(beanInstance instanceof FactoryBean)) {
throw new BeanIsNotAFactoryException(beanName, beanInstance.getClass());
}
if (mbd != null) {
mbd.isFactoryBean = true;
}
return beanInstance;
}
// 如果不是FactoryBean，直接返回
if (!(beanInstance instanceof FactoryBean)) {
return beanInstance;
}
// 处理FactoryBean创建的对象
Object object = null;
if (mbd != null) {
mbd.isFactoryBean = true;
}
else {
// 从FactoryBean缓存中获取
object = getCachedObjectForFactoryBean(beanName);
}
if (object == null) {
// 从FactoryBean获取对象
FactoryBean<?> factory = (FactoryBean<?>) beanInstance;
// 包含从BeanDefinition中获取单例状态的检查
boolean synthetic = (mbd != null && mbd.isSynthetic());
object = getObjectFromFactoryBean(factory, beanName, !synthetic);
}
return object;
}
/**
* 从FactoryBean获取对象
*
* @param factory FactoryBean实例
* @param beanName Bean名称
* @param shouldPostProcess 是否需要后处理
* @return FactoryBean创建的对象
*/
private Object getObjectFromFactoryBean(FactoryBean<?> factory, String beanName, boolean shouldPostProcess) {
// 如果是单例FactoryBean
if (factory.isSingleton() && containsSingleton(beanName)) {
synchronized (getSingletonMutex()) {
Object object = this.factoryBeanObjectCache.get(beanName);
if (object == null) {
// 调用FactoryBean的getObject方法
object = doGetObjectFromFactoryBean(factory, beanName);
// 只有在临时性离开此方法时，才进行后处理
Object alreadyThere = this.factoryBeanObjectCache.get(beanName);
if (alreadyThere != null) {
object = alreadyThere;
}
else {
if (shouldPostProcess) {
if (isSingletonCurrentlyInCreation(beanName)) {
// 在单例创建过程中暂时返回非后处理对象
return object;
}
beforeSingletonCreation(beanName);
try {
// 应用BeanPostProcessor后处理
object = postProcessObjectFromFactoryBean(object, beanName);
}
catch (Throwable ex) {
throw new BeanCreationException(beanName,
"Post-processing of FactoryBean's singleton object failed", ex);
}
finally {
afterSingletonCreation(beanName);
}
}
if (containsSingleton(beanName)) {
this.factoryBeanObjectCache.put(beanName, object);
}
}
}
return object;
}
}
else {
// 原型FactoryBean，直接创建对象
Object object = doGetObjectFromFactoryBean(factory, beanName);
if (shouldPostProcess) {
try {
// 应用BeanPostProcessor后处理
object = postProcessObjectFromFactoryBean(object, beanName);
}
catch (Throwable ex) {
throw new BeanCreationException(beanName, "Post-processing of FactoryBean's object failed", ex);
}
}
return object;
}
}
/**
* 调用FactoryBean的getObject方法
*
* @param factory FactoryBean实例
* @param beanName Bean名称
* @return FactoryBean创建的对象
*/
private Object doGetObjectFromFactoryBean(final FactoryBean<?> factory, final String beanName)
throws BeanCreationException {
Object object;
try {
// 如果有安全管理器，使用特权操作
if (System.getSecurityManager() != null) {
AccessControlContext acc = getAccessControlContext();
try {
object = AccessController.doPrivileged((PrivilegedExceptionAction<Object>) factory::getObject, acc);
}
catch (PrivilegedActionException pae) {
throw pae.getException();
}
}
else {
// 直接调用FactoryBean的getObject方法
object = factory.getObject();
}
}
catch (FactoryBeanNotInitializedException ex) {
throw new BeanCurrentlyInCreationException(beanName, ex.toString());
}
catch (Throwable ex) {
throw new BeanCreationException(beanName, "FactoryBean threw exception on object creation", ex);
}
// 如果返回null且是单例，抛出异常
if (object == null) {
if (isSingletonCurrentlyInCreation(beanName)) {
throw new BeanCurrentlyInCreationException(
beanName, "FactoryBean which is currently in creation returned null from getObject");
}
object = new NullBean();
}
return object;
}
}
}
4. FactoryBean的实际应用
/*
* FactoryBean的实际应用场景
*/
/**
* 数据库连接池FactoryBean
* 创建和管理数据库连接池
*/
@Component
public class ConnectionPoolFactoryBean implements FactoryBean<DataSource>, InitializingBean, DisposableBean {
// 数据库连接配置
private String url;
private String username;
private String password;
private int maxPoolSize = 10;
private int minPoolSize = 5;
// 连接池实例
private HikariDataSource dataSource;
// Setters for configuration
public void setUrl(String url) { this.url = url; }
public void setUsername(String username) { this.username = username; }
public void setPassword(String password) { this.password = password; }
public void setMaxPoolSize(int maxPoolSize) { this.maxPoolSize = maxPoolSize; }
public void setMinPoolSize(int minPoolSize) { this.minPoolSize = minPoolSize; }
/**
* 初始化连接池
*/
@Override
public void afterPropertiesSet() throws Exception {
Assert.hasText(url, "数据库URL不能为空");
Assert.hasText(username, "用户名不能为空");
dataSource = new HikariDataSource();
dataSource.setJdbcUrl(url);
dataSource.setUsername(username);
dataSource.setPassword(password);
dataSource.setMaximumPoolSize(maxPoolSize);
dataSource.setMinimumIdle(minPoolSize);
dataSource.setConnectionTimeout(30000);
dataSource.setIdleTimeout(600000);
dataSource.setMaxLifetime(1800000);
}
/**
* 创建并返回DataSource实例
*
* @return DataSource实例
* @throws Exception 如果创建失败
*/
@Override
public DataSource getObject() throws Exception {
return dataSource;
}
/**
* 返回对象类型
*
* @return DataSource类型
*/
@Override
public Class<?> getObjectType() {
return dataSource != null ? dataSource.getClass() : DataSource.class;
}
/**
* 是否为单例
*
* @return true表示单例
*/
@Override
public boolean isSingleton() {
return true;
}
/**
* 销毁连接池
*/
@Override
public void destroy() throws Exception {
if (dataSource != null) {
dataSource.close();
}
}
}
/**
* 代理对象FactoryBean
* 创建AOP代理对象
*/
@Component
public class ProxyFactoryBean implements FactoryBean<Object>, BeanFactoryAware {
// 目标对象
private Object target;
// 拦截器列表
private List<MethodInterceptor> interceptors = new ArrayList<>();
// 目标接口
private Class<?>[] proxyInterfaces;
// BeanFactory引用
private BeanFactory beanFactory;
// 代理对象缓存
private Object proxyObject;
// Setters
public void setTarget(Object target) { this.target = target; }
public void setInterceptors(List<MethodInterceptor> interceptors) { this.interceptors = interceptors; }
public void setProxyInterfaces(Class<?>[] proxyInterfaces) { this.proxyInterfaces = proxyInterfaces; }
@Override
public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
this.beanFactory = beanFactory;
}
/**
* 创建代理对象
*
* @return 代理对象
* @throws Exception 如果创建失败
*/
@Override
public Object getObject() throws Exception {
if (proxyObject == null) {
proxyObject = createProxy();
}
return proxyObject;
}
/**
* 创建代理对象的具体实现
*/
private Object createProxy() {
ProxyFactory proxyFactory = new ProxyFactory();
// 设置目标对象
if (target != null) {
proxyFactory.setTarget(target);
}
// 设置代理接口
if (proxyInterfaces != null) {
for (Class<?> proxyInterface : proxyInterfaces) {
proxyFactory.addInterface(proxyInterface);
}
}
// 添加拦截器
for (MethodInterceptor interceptor : interceptors) {
proxyFactory.addAdvice(interceptor);
}
return proxyFactory.getProxy();
}
/**
* 返回代理对象类型
*/
@Override
public Class<?> getObjectType() {
if (proxyObject != null) {
return proxyObject.getClass();
}
if (proxyInterfaces != null && proxyInterfaces.length > 0) {
return proxyInterfaces[0];
}
if (target != null) {
return target.getClass();
}
return null;
}
/**
* 是否为单例
*/
@Override
public boolean isSingleton() {
return true;
}
}
/**
* 配置驱动的FactoryBean
* 根据配置创建不同的对象
*/
@Component
public class ConfigurationDrivenFactoryBean<T> implements FactoryBean<T> {
// 配置属性
private String objectType;
private Map<String, Object> properties = new HashMap<>();
private boolean singleton = true;
// 创建的对象缓存
private T singletonInstance;
// Setters
public void setObjectType(String objectType) { this.objectType = objectType; }
public void setProperties(Map<String, Object> properties) { this.properties = properties; }
public void setSingleton(boolean singleton) { this.singleton = singleton; }
/**
* 根据配置创建对象
*/
@Override
@SuppressWarnings("unchecked")
public T getObject() throws Exception {
if (singleton && singletonInstance != null) {
return singletonInstance;
}
T instance = (T) createInstanceFromConfiguration();
if (singleton) {
this.singletonInstance = instance;
}
return instance;
}
/**
* 根据配置创建实例
*/
private Object createInstanceFromConfiguration() throws Exception {
if (objectType == null || objectType.isEmpty()) {
throw new IllegalArgumentException("对象类型不能为空");
}
// 加载类
Class<?> clazz = Class.forName(objectType);
// 创建实例
Object instance = clazz.getDeclaredConstructor().newInstance();
// 设置属性
setPropertiesOnInstance(instance);
return instance;
}
/**
* 设置实例属性
*/
private void setPropertiesOnInstance(Object instance) throws Exception {
Class<?> clazz = instance.getClass();
for (Map.Entry<String, Object> entry : properties.entrySet()) {
String propertyName = entry.getKey();
Object propertyValue = entry.getValue();
// 查找setter方法
String setterName = "set" + Character.toUpperCase(propertyName.charAt(0)) + propertyName.substring(1);
Method setter = findSetterMethod(clazz, setterName, propertyValue.getClass());
if (setter != null) {
setter.invoke(instance, propertyValue);
}
}
}
/**
* 查找setter方法
*/
private Method findSetterMethod(Class<?> clazz, String methodName, Class<?> parameterType) {
try {
return clazz.getMethod(methodName, parameterType);
} catch (NoSuchMethodException e) {
// 尝试查找兼容的setter方法
Method[] methods = clazz.getMethods();
for (Method method : methods) {
if (method.getName().equals(methodName) && method.getParameterCount() == 1) {
Class<?> paramType = method.getParameterTypes()[0];
if (paramType.isAssignableFrom(parameterType) ||
isPrimitiveWrapper(paramType, parameterType)) {
return method;
}
}
}
return null;
}
}
/**
* 检查是否为基本类型包装类
*/
private boolean isPrimitiveWrapper(Class<?> wrapperType, Class<?> primitiveType) {
if (wrapperType == Integer.class && primitiveType == int.class) return true;
if (wrapperType == Long.class && primitiveType == long.class) return true;
if (wrapperType == Boolean.class && primitiveType == boolean.class) return true;
if (wrapperType == Double.class && primitiveType == double.class) return true;
if (wrapperType == Float.class && primitiveType == float.class) return true;
if (wrapperType == Character.class && primitiveType == char.class) return true;
if (wrapperType == Byte.class && primitiveType == byte.class) return true;
if (wrapperType == Short.class && primitiveType == short.class) return true;
return false;
}
/**
* 返回对象类型
*/
@Override
public Class<?> getObjectType() {
if (singletonInstance != null) {
return singletonInstance.getClass();
}
if (objectType != null) {
try {
return Class.forName(objectType);
} catch (ClassNotFoundException e) {
return null;
}
}
return null;
}
/**
* 是否为单例
*/
@Override
public boolean isSingleton() {
return singleton;
}
}
/**
* 延迟初始化FactoryBean
* 实现对象的延迟初始化
*/
@Component
public class LazyInitFactoryBean<T> implements FactoryBean<T> {
// 对象创建器
private Supplier<T> objectCreator;
// 对象类型
private Class<T> objectType;
// 是否为单例
private boolean singleton = true;
// 单例实例缓存
private volatile T singletonInstance;
private final Object lock = new Object();
// Setters
public void setObjectCreator(Supplier<T> objectCreator) { this.objectCreator = objectCreator; }
public void setObjectType(Class<T> objectType) { this.objectType = objectType; }
public void setSingleton(boolean singleton) { this.singleton = singleton; }
/**
* 获取对象实例（延迟初始化）
*/
@Override
public T getObject() throws Exception {
if (singleton) {
if (singletonInstance == null) {
synchronized (lock) {
if (singletonInstance == null) {
singletonInstance = createInstance();
}
}
}
return singletonInstance;
} else {
return createInstance();
}
}
/**
* 创建实例
*/
private T createInstance() throws Exception {
if (objectCreator == null) {
throw new IllegalStateException("对象创建器未设置");
}
return objectCreator.get();
}
/**
* 返回对象类型
*/
@Override
public Class<?> getObjectType() {
return objectType;
}
/**
* 是否为单例
*/
@Override
public boolean isSingleton() {
return singleton;
}
}
5. 第三方框架集成示例
/*
* 第三方框架集成的FactoryBean示例
*/
/**
* MyBatis SqlSessionFactory FactoryBean
* 集成MyBatis框架
*/
@Component
public class SqlSessionFactoryBean implements FactoryBean<SqlSessionFactory>, InitializingBean, DisposableBean {
// MyBatis配置
private DataSource dataSource;
private String configLocation;
private String[] mapperLocations;
private Properties configurationProperties;
// SqlSessionFactory实例
private SqlSessionFactory sqlSessionFactory;
// Setters
public void setDataSource(DataSource dataSource) { this.dataSource = dataSource; }
public void setConfigLocation(String configLocation) { this.configLocation = configLocation; }
public void setMapperLocations(String[] mapperLocations) { this.mapperLocations = mapperLocations; }
public void setConfigurationProperties(Properties configurationProperties) {
this.configurationProperties = configurationProperties;
}
/**
* 初始化SqlSessionFactory
*/
@Override
public void afterPropertiesSet() throws Exception {
Assert.notNull(dataSource, "数据源不能为空");
// 创建SqlSessionFactoryBuilder
SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
// 加载MyBatis配置
XMLConfigBuilder xmlConfigBuilder = new XMLConfigBuilder(
getResourceAsStream(configLocation),
null,
configurationProperties
);
Configuration configuration = xmlConfigBuilder.parse();
configuration.setEnvironment(new Environment("development",
new JdbcTransactionFactory(), dataSource));
// 加载Mapper文件
if (mapperLocations != null) {
for (String mapperLocation : mapperLocations) {
loadMapper(configuration, mapperLocation);
}
}
// 创建SqlSessionFactory
sqlSessionFactory = builder.build(configuration);
}
/**
* 加载Mapper文件
*/
private void loadMapper(Configuration configuration, String mapperLocation) throws Exception {
Resource[] resources = new PathMatchingResourcePatternResolver().getResources(mapperLocation);
XMLMapperBuilder xmlMapperBuilder;
for (Resource resource : resources) {
xmlMapperBuilder = new XMLMapperBuilder(
resource.getInputStream(),
configuration,
resource.toString(),
configuration.getSqlFragments()
);
xmlMapperBuilder.parse();
}
}
/**
* 获取资源输入流
*/
private InputStream getResourceAsStream(String location) throws IOException {
return new PathMatchingResourcePatternResolver().getResource(location).getInputStream();
}
/**
* 返回SqlSessionFactory实例
*/
@Override
public SqlSessionFactory getObject() throws Exception {
return sqlSessionFactory;
}
/**
* 返回对象类型
*/
@Override
public Class<?> getObjectType() {
return sqlSessionFactory != null ? sqlSessionFactory.getClass() : SqlSessionFactory.class;
}
/**
* 是否为单例
*/
@Override
public boolean isSingleton() {
return true;
}
/**
* 销毁资源
*/
@Override
public void destroy() throws Exception {
// MyBatis SqlSessionFactory不需要特殊销毁
}
}
/**
* Redis客户端FactoryBean
* 集成Redis客户端
*/
@Component
public class RedisClientFactoryBean implements FactoryBean<JedisPool>, InitializingBean, DisposableBean {
// Redis配置
private String host = "localhost";
private int port = 6379;
private int timeout = 2000;
private String password;
private int maxTotal = 20;
private int maxIdle = 10;
private int minIdle = 5;
// Jedis连接池
private JedisPool jedisPool;
// Setters
public void setHost(String host) { this.host = host; }
public void setPort(int port) { this.port = port; }
public void setTimeout(int timeout) { this.timeout = timeout; }
public void setPassword(String password) { this.password = password; }
public void setMaxTotal(int maxTotal) { this.maxTotal = maxTotal; }
public void setMaxIdle(int maxIdle) { this.maxIdle = maxIdle; }
public void setMinIdle(int minIdle) { this.minIdle = minIdle; }
/**
* 初始化Jedis连接池
*/
@Override
public void afterPropertiesSet() throws Exception {
// 配置连接池
JedisPoolConfig poolConfig = new JedisPoolConfig();
poolConfig.setMaxTotal(maxTotal);
poolConfig.setMaxIdle(maxIdle);
poolConfig.setMinIdle(minIdle);
poolConfig.setTestOnBorrow(true);
poolConfig.setTestOnReturn(true);
poolConfig.setTestWhileIdle(true);
// 创建Jedis连接池
if (password != null && !password.isEmpty()) {
jedisPool = new JedisPool(poolConfig, host, port, timeout, password);
} else {
jedisPool = new JedisPool(poolConfig, host, port, timeout);
}
}
/**
* 返回Jedis连接池实例
*/
@Override
public JedisPool getObject() throws Exception {
return jedisPool;
}
/**
* 返回对象类型
*/
@Override
public Class<?> getObjectType() {
return jedisPool != null ? jedisPool.getClass() : JedisPool.class;
}
/**
* 是否为单例
*/
@Override
public boolean isSingleton() {
return true;
}
/**
* 销毁连接池
*/
@Override
public void destroy() throws Exception {
if (jedisPool != null) {
jedisPool.close();
}
}
}
6. 现代化替代方案
/*
* 现代化的替代方案
* 使用@Configuration和@Bean注解替代FactoryBean
*/
/**
* 使用@Configuration和@Bean注解
* 现代化的配置方式
*/
@Configuration
@EnableConfigurationProperties
public class ModernConfiguration {
/**
* 配置数据源
*/
@Bean
@ConfigurationProperties(prefix = "spring.datasource")
public DataSource dataSource() {
return DataSourceBuilder.create().build();
}
/**
* 配置MyBatis SqlSessionFactory
*/
@Bean
public SqlSessionFactory sqlSessionFactory(DataSource dataSource) throws Exception {
SqlSessionFactoryBean sessionFactory = new SqlSessionFactoryBean();
sessionFactory.setDataSource(dataSource);
sessionFactory.setMapperLocations(
new PathMatchingResourcePatternResolver().getResources("classpath*:mapper/*.xml"));
return sessionFactory.getObject();
}
/**
* 配置Redis连接池
*/
@Bean
public JedisPool jedisPool(
@Value("${redis.host:localhost}") String host,
@Value("${redis.port:6379}") int port,
@Value("${redis.timeout:2000}") int timeout) {
JedisPoolConfig poolConfig = new JedisPoolConfig();
poolConfig.setMaxTotal(20);
poolConfig.setMaxIdle(10);
poolConfig.setMinIdle(5);
return new JedisPool(poolConfig, host, port, timeout);
}
/**
* 配置代理对象
*/
@Bean
public UserService userServiceProxy(UserService userService) {
ProxyFactory proxyFactory = new ProxyFactory();
proxyFactory.setTarget(userService);
proxyFactory.addInterface(UserService.class);
proxyFactory.addAdvice(new LoggingInterceptor());
return (UserService) proxyFactory.getProxy();
}
}
/**
* 使用@Conditional注解的条件化Bean创建
*/
@Configuration
public class ConditionalConfiguration {
/**
* 根据条件创建不同的Bean
*/
@Bean
@ConditionalOnProperty(name = "app.database.type", havingValue = "mysql")
public DataSource mysqlDataSource() {
// MySQL数据源配置
return DataSourceBuilder.create()
.url("jdbc:mysql://localhost:3306/mydb")
.username("user")
.password("password")
.driverClassName("com.mysql.cj.jdbc.Driver")
.build();
}
@Bean
@ConditionalOnProperty(name = "app.database.type", havingValue = "postgresql")
public DataSource postgresqlDataSource() {
// PostgreSQL数据源配置
return DataSourceBuilder.create()
.url("jdbc:postgresql://localhost:5432/mydb")
.username("user")
.password("password")
.driverClassName("org.postgresql.Driver")
.build();
}
/**
* 使用自定义条件
*/
@Bean
@Conditional(CustomCondition.class)
public CustomService customService() {
return new CustomServiceImpl();
}
}
/**
* 自定义条件类
*/
class CustomCondition implements Condition {
@Override
public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
String property = context.getEnvironment().getProperty("app.custom.enabled");
return "true".equals(property);
}
}
/**
* 使用@Import注解导入配置
*/
@Configuration
@Import({DatabaseConfiguration.class, CacheConfiguration.class})
public class MainConfiguration {
// 主配置类
}
/**
* 数据库配置
*/
@Configuration
public class DatabaseConfiguration {
@Bean
public JdbcTemplate jdbcTemplate(DataSource dataSource) {
return new JdbcTemplate(dataSource);
}
}
/**
* 缓存配置
*/
@Configuration
@EnableCaching
public class CacheConfiguration {
@Bean
public CacheManager cacheManager() {
return new ConcurrentMapCacheManager("default");
}
}
7. 最佳实践和注意事项
/*
* FactoryBean最佳实践
*/
/**
* 正确的FactoryBean实现
*/
@Component
public class GoodFactoryBean<T> implements FactoryBean<T>, InitializingBean, DisposableBean {
private Class<T> objectType;
private boolean singleton = true;
private T singletonInstance;
private final Object lock = new Object();
// 配置属性
private String configuration;
// Setters
public void setObjectType(Class<T> objectType) { this.objectType = objectType; }
public void setSingleton(boolean singleton) { this.singleton = singleton; }
public void setConfiguration(String configuration) { this.configuration = configuration; }
/**
* 初始化检查
*/
@Override
public void afterPropertiesSet() throws Exception {
Assert.notNull(objectType, "对象类型不能为空");
Assert.hasText(configuration, "配置不能为空");
// 可以在这里进行初始化验证
}
/**
* 创建对象实例
*/
@Override
public T getObject() throws Exception {
if (singleton) {
if (singletonInstance == null) {
synchronized (lock) {
if (singletonInstance == null) {
singletonInstance = createInstance();
}
}
}
return singletonInstance;
} else {
return createInstance();
}
}
/**
* 创建实例的具体实现
*/
private T createInstance() throws Exception {
// 实际的对象创建逻辑
// 这里应该包含错误处理和日志记录
try {
T instance = objectType.getDeclaredConstructor().newInstance();
configureInstance(instance);
return instance;
} catch (Exception e) {
// 记录错误日志
throw new BeanCreationException("创建对象实例失败", e);
}
}
/**
* 配置实例
*/
private void configureInstance(T instance) throws Exception {
// 根据配置设置实例属性
if (instance instanceof Configurable) {
((Configurable) instance).configure(configuration);
}
}
/**
* 返回对象类型
*/
@Override
public Class<?> getObjectType() {
return objectType;
}
/**
* 是否为单例
*/
@Override
public boolean isSingleton() {
return singleton;
}
/**
* 销毁资源
*/
@Override
public void destroy() throws Exception {
if (singletonInstance != null) {
destroyInstance(singletonInstance);
singletonInstance = null;
}
}
/**
* 销毁实例
*/
protected void destroyInstance(T instance) throws Exception {
if (instance instanceof DisposableBean) {
((DisposableBean) instance).destroy();
}
// 其他清理逻辑
}
/**
* 可配置接口
*/
public interface Configurable {
void configure(String configuration) throws Exception;
}
}
/**
* 避免的错误实现
*/
@Component
public class BadFactoryBean<T> implements FactoryBean<T> {
private Class<T> objectType;
@Override
public T getObject() throws Exception {
// 错误1: 没有错误处理
return objectType.newInstance(); // 已废弃的方法
// 错误2: 每次都创建新实例（即使声明为单例）
// return createInstance();
// 错误3: 不处理null情况
// return null;
}
@Override
public Class<?> getObjectType() {
// 错误: 没有处理null情况
return objectType;
}
@Override
public boolean isSingleton() {
// 错误: 硬编码返回值
return true;
}
}
/**
* 线程安全的FactoryBean实现
*/
@Component
public class ThreadSafeFactoryBean<T> implements FactoryBean<T> {
private final Class<T> objectType;
private final boolean singleton;
private volatile T singletonInstance;
private final Object lock = new Object();
public ThreadSafeFactoryBean(Class<T> objectType, boolean singleton) {
this.objectType = Assert.notNull(objectType, "对象类型不能为空");
this.singleton = singleton;
}
@Override
public T getObject() throws Exception {
if (singleton) {
if (singletonInstance == null) {
synchronized (lock) {
if (singletonInstance == null) {
singletonInstance = createInstance();
}
}
}
return singletonInstance;
} else {
return createInstance();
}
}
private T createInstance() throws Exception {
return objectType.getDeclaredConstructor().newInstance();
}
@Override
public Class<?> getObjectType() {
return objectType;
}
@Override
public boolean isSingleton() {
return singleton;
}
}
/**
* 使用泛型的类型安全实现
*/
@Component
public class GenericFactoryBean<T> implements FactoryBean<T> {
private final Supplier<T> supplier;
private final Class<T> objectType;
private final boolean singleton;
private volatile T singletonInstance;
public GenericFactoryBean(Supplier<T> supplier, Class<T> objectType, boolean singleton) {
this.supplier = Assert.notNull(supplier, "Supplier不能为空");
this.objectType = Assert.notNull(objectType, "对象类型不能为空");
this.singleton = singleton;
}
@Override
public T getObject() throws Exception {
if (singleton) {
if (singletonInstance == null) {
synchronized (this) {
if (singletonInstance == null) {
singletonInstance = supplier.get();
}
}
}
return singletonInstance;
} else {
return supplier.get();
}
}
@Override
public Class<?> getObjectType() {
return objectType;
}
@Override
public boolean isSingleton() {
return singleton;
}
}
8. 核心设计要点总结
8.1 设计目的
- 提供自定义Bean创建机制
- 支持复杂对象的创建
- 实现延迟初始化
- 集成第三方框架
- 实现单例和原型模式的自定义控制
8.2 核心方法
- getObject(): 创建并返回对象实例
- getObjectType(): 返回对象类型
- isSingleton(): 指定是否为单例
8.3 使用建议
- 正确实现单例控制: 确保isSingleton()与getObject()行为一致
- 异常处理: 适当处理创建过程中的异常
- 线程安全: 确保单例模式下的线程安全
- 资源管理: 实现DisposableBean进行资源清理
- 类型安全: 使用泛型确保类型安全
8.4 获取方式
- 获取对象实例: 直接使用Bean名称
- 获取FactoryBean本身: 使用&前缀（如&myFactoryBean）
8.5 常见应用场景
- 数据库连接池创建
- 第三方框架集成
- 代理对象创建
- 延迟初始化
- 条件化Bean创建
- 复杂对象配置
8.6 现代化替代方案
- @Configuration + @Bean: 更简洁的配置方式
- @Conditional注解: 条件化Bean创建
- @Import注解: 配置导入
- 自动配置: Spring Boot自动配置机制
8.7 最佳实践
- 实现InitializingBean和DisposableBean接口
- 使用AbstractFactoryBean简化实现
- 确保线程安全
- 适当的日志记录
- 错误处理和异常转换
- 资源的正确释放
FactoryBean作为Spring框架的强大扩展点，为开发者提供了灵活的Bean创建机制，但在现代Spring开发中，推荐使用更简洁的注解配置方式。
扫一扫
1452
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
