springboot提升-扩展接口的实现样例

1. FactoryBean实现

FactoryBean 是 Spring 框架中的一个重要接口，它允许开发者以一种灵活的方式创建和管理 Bean。FactoryBean 的主要用途在于它提供了一种机制，使得开发者可以自定义 Bean 的创建过程，并且可以在创建过程中执行一些额外的逻辑，比如缓存、代理或其他形式的包装。

FactoryBean 接口定义

FactoryBean 接口定义如下：

public interface FactoryBean<T> {

    T getObject() throws Exception;

    Class<?> getObjectType();

    default boolean isSingleton() {
        return true;
    }
}

• getObject() 方法：用于创建并返回 Bean 的实例。
• getObjectType() 方法：返回由 getObject() 方法创建的对象类型。
• isSingleton() 方法：返回一个布尔值，指示这个 Bean 是否是单例模式，默认为 true。

使用 FactoryBean 的步骤

1. 实现 FactoryBean 接口：首先，你需要创建一个类来实现 FactoryBean 接口。
2. 重写必要的方法：重写 getObject()、getObjectType() 方法，并可选择性地重写 isSingleton() 方法。
3. 注册 FactoryBean：将实现类注册到 Spring 容器中，通常通过 @Bean 注解或 XML 配置来完成。

示例

下面是一个简单的 FactoryBean 实现示例：

@Component
public class MyBeanFactory implements FactoryBean<MyBean> {

    @Override
    public MyBean getObject() throws Exception {
        // 创建 MyBean 的实例
        return new MyBean();
    }

    @Override
    public Class<?> getObjectType() {
        // 返回 MyBean 类的类型
        return MyBean.class;
    }

    @Override
    public boolean isSingleton() {
        // 返回 false 表示每次获取都是一个新的实例
        return false;
    }
}

在这个例子中，MyBeanFactory 实现了 FactoryBean<MyBean> 接口，其中 MyBean 是我们希望由工厂创建的 Bean 类型。当 Spring 容器需要这个 Bean 的实例时，它会调用 getObject() 方法来创建实例。

获取 FactoryBean 创建的 Bean

当你从 Spring 容器中获取一个由 FactoryBean 创建的 Bean 时，实际上获取的是 getObject() 方法返回的对象。如果你想要获取 FactoryBean 本身，可以使用 & 前缀来获取：

// 假设 FactoryBean 的 bean 名称为 myBeanFactory
FactoryBean<MyBean> factory = (FactoryBean<MyBean>) context.getBean("&myBeanFactory");

使用场景

• 复杂对象创建：如果创建一个 Bean 的过程比较复杂，或者需要执行额外的初始化逻辑，可以使用 FactoryBean。
• 懒加载：对于那些不需要立即初始化的对象，可以使用 FactoryBean 来实现懒加载。
• 代理对象：如果需要为某个 Bean 创建代理对象，也可以通过 FactoryBean 来实现。

通过使用 FactoryBean，你可以更加灵活地控制 Bean 的创建过程，这对于一些复杂的场景非常有用。

2. InitializingBean 实现

在 Spring 框架中，InitializingBean 接口是一个用于执行初始化逻辑的回调接口。它允许开发者在 Bean 被 Spring 容器初始化之后执行一些特定的初始化操作。这在 Bean 的依赖关系已经被解决并且所有的属性已经被设置之后发生。

InitializingBean 接口定义

InitializingBean 接口定义如下：

public interface InitializingBean {

    void afterPropertiesSet() throws Exception;
}

• afterPropertiesSet() 方法：当 Bean 的所有属性被设置完毕后，Spring 会调用此方法。如果 Bean 实现了这个接口，那么这个方法会在 Bean 被完全初始化之前执行。

使用场景

InitializingBean 接口主要用于以下几种情况：

1. 执行复杂的初始化逻辑：例如，连接数据库、初始化缓存、加载配置信息等。
2. 验证 Bean 的状态：确保 Bean 在使用之前处于正确的状态。
3. 资源的预加载：预先加载一些资源，如预热缓存、加载静态数据等。

示例

下面是一个简单的示例，展示了如何实现 InitializingBean 接口：

@Component
public class MyBean implements InitializingBean {

    private Logger logger = LoggerFactory.getLogger(MyBean.class);

    @Override
    public void afterPropertiesSet() throws Exception {
        // 执行初始化逻辑
        logger.info("Initializing MyBean...");
        // 这里可以执行任何需要的初始化操作
    }

    // 其他方法...
}

在这个例子中，MyBean 类实现了 InitializingBean 接口，并重写了 afterPropertiesSet() 方法。当 MyBean 的所有属性被 Spring 容器正确设置后，afterPropertiesSet() 方法将被执行。

注意事项

• 异常处理：如果 afterPropertiesSet() 方法抛出了异常，那么 Spring 会认为 Bean 初始化失败，并且不会将这个 Bean 加载到容器中。
• 生命周期顺序：如果一个 Bean 同时实现了 InitializingBean 和 DisposableBean 接口（用于销毁时的清理工作），那么 afterPropertiesSet() 方法会在 Bean 初始化阶段调用，而 destroy() 方法会在容器关闭时调用。
• 与 @PostConstruct 注解的关系：@PostConstruct 注解也可以用来指定初始化方法，并且在 Spring 中，它通常被视为比实现 InitializingBean 更加轻量级的选择。如果一个类上有 @PostConstruct 注解的方法，那么 Spring 会在依赖注入完成后调用该方法。

结合使用

有时候，你可能会在一个类上同时使用 InitializingBean 接口和 @PostConstruct 注解。在这种情况下，Spring 会先调用 @PostConstruct 注解的方法，然后调用 afterPropertiesSet() 方法。这是因为 @PostConstruct 注解的方法更早被调用，而 InitializingBean 的方法则是在所有属性都被正确设置之后调用。

总之，InitializingBean 接口为开发者提供了一个标准的方式来执行初始化操作，确保 Bean 在使用之前已经完成了所有必要的准备工作。

3. BeanPostProcessor 实现

在Spring Boot中，BeanPostProcessor是一个非常有用的接口，它允许你在Bean初始化前后执行一些操作。这对于自定义初始化逻辑或者对Bean进行装饰（如AOP）非常有用。下面是如何实现一个简单的BeanPostProcessor的示例：

创建一个简单的Bean

首先，我们需要有一个普通的Spring管理的Bean：

public class SimpleBean {

    private String message;

    public SimpleBean() {
        this.message = "Hello from SimpleBean";
    }

    public String getMessage() {
        return message;
    }
}

实现BeanPostProcessor接口

接下来，我们需要创建一个实现了BeanPostProcessor接口的类：

import org.springframework.stereotype.Component;
import org.springframework.beans.factory.config.BeanPostProcessor;

@Component
public class MyBeanPostProcessor implements BeanPostProcessor {

    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) {
        if (bean instanceof SimpleBean) {
            System.out.println("Before initialization of " + beanName);
        }
        return bean;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) {
        if (bean instanceof SimpleBean) {
            System.out.println("After initialization of " + beanName);
            // 对象初始化后可以修改这个对象
            ((SimpleBean)bean).setMessage(((SimpleBean)bean).getMessage() + " - Modified by BeanPostProcessor");
        }
        return bean;
    }
}

在这个例子中，我们在postProcessBeforeInitialization方法中打印了一条信息来表示我们正在处理这个Bean，在postProcessAfterInitialization中修改了SimpleBean的消息。

注册BeanPostProcessor

通常情况下，如果你将MyBeanPostProcessor类标记为@Component，那么Spring会自动检测到它并注册为BeanPostProcessor。如果你不想使用组件扫描或者你的类不在扫描路径内，你可以通过配置类显式地注册它：

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class AppConfig {

    @Bean
    public BeanPostProcessor myBeanPostProcessor() {
        return new MyBeanPostProcessor();
    }
}

使用Bean

最后，在应用程序中使用SimpleBean，当Spring初始化这个Bean时，BeanPostProcessor就会被调用。

注意事项

• BeanPostProcessor的顺序很重要，如果你有多个BeanPostProcessor，它们将会按照定义的顺序被执行。
• 如果你修改了返回的对象，那么返回的对象将会替代原始的Bean实例。

这就是一个基本的BeanPostProcessor实现。你可以根据自己的需求扩展或修改这个处理器的功能。

4. DisposableBean实现

在 Spring 框架中，DisposableBean 接口用于执行 Bean 的销毁操作。当 Spring 容器准备销毁一个 Bean 时，它会调用实现了 DisposableBean 接口的 Bean 的 destroy() 方法。这使得开发者可以在 Bean 被销毁之前执行一些清理工作，例如释放资源、关闭连接等。

DisposableBean 接口定义

DisposableBean 接口定义如下：

public interface DisposableBean {

    void destroy() throws Exception;
}

• destroy() 方法：当 Spring 容器决定销毁一个 Bean 时，会调用这个方法。实现该方法的类可以在其中执行必要的清理工作。

使用场景

DisposableBean 接口通常用于以下几种情况：

1. 资源释放：例如关闭数据库连接、释放内存资源、关闭文件句柄等。
2. 状态恢复：将 Bean 的状态恢复到初始状态，以便重新使用。
3. 清理临时文件：删除在应用运行期间创建的临时文件或目录。
4. 通知其他系统：例如发送消息给另一个系统，通知其某个资源已被释放。

示例

下面是一个简单的示例，展示了如何实现 DisposableBean 接口：

@Component
public class MyResourceHolder implements DisposableBean {

    private static final Logger logger = LoggerFactory.getLogger(MyResourceHolder.class);

    private Connection connection;

    @Autowired
    public void setConnection(Connection connection) {
        this.connection = connection;
    }

    @Override
    public void destroy() throws Exception {
        if (connection != null) {
            try {
                logger.info("Closing database connection.");
                connection.close();
            } catch (SQLException e) {
                logger.error("Error closing database connection", e);
            }
        }
    }

    // 其他方法...
}

在这个例子中，MyResourceHolder 类实现了 DisposableBean 接口，并重写了 destroy() 方法。当 Spring 容器决定销毁 MyResourceHolder 时，destroy() 方法将被调用，从而关闭数据库连接。

注意事项

• 异常处理：如果 destroy() 方法抛出了异常，Spring 会记录这个异常，但不会阻止容器继续销毁其他 Bean。
• 生命周期顺序：如果一个 Bean 同时实现了 InitializingBean（或使用了 @PostConstruct 注解）和 DisposableBean 接口，那么 afterPropertiesSet() 或 @PostConstruct 方法会在 Bean 初始化时调用，而 destroy() 方法会在容器销毁 Bean 时调用。
• 与 @PreDestroy 注解的关系：@PreDestroy 注解也可以用来指定销毁方法，并且在 Spring 中，它通常被视为比实现 DisposableBean 更加轻量级的选择。如果一个类上有 @PreDestroy 注解的方法，那么 Spring 会在销毁 Bean 之前调用该方法。

结合使用

有时候，你可能会在一个类上同时使用 DisposableBean 接口和 @PreDestroy 注解。在这种情况下，Spring 会先调用 @PreDestroy 注解的方法，然后再调用 destroy() 方法。这是因为 @PreDestroy 注解的方法优先级更高，可以更早地执行。

总结

DisposableBean 接口为开发者提供了一个标准的方式来执行 Bean 的销毁操作，确保在 Bean 被销毁之前完成必要的清理工作。这对于确保资源得到妥善管理非常重要，尤其是在处理有限资源或昂贵资源时。

5. 总结

以上就是我们常见的几个接口的实现， 后续会不断不同， 希望会对看到文章的朋友有所帮助