Spring中有哪些扩展点

介绍

什么是spring扩展点

Spring 框架中的扩展点是指一组接口或机制，允许开发者在不修改核心框架源代码的情况下，定制和扩展 Spring 框架的功能、行为或配置。这些扩展点提供了一种方式，使开发者可以通过实现特定的接口、编写特定类型的类或配置特定的元数据，来影响和增强 Spring 框架的行为。

常用的扩展点有哪些

Spring 框架提供了多种可扩展的点，其中一些主要的扩展点包括但不限于：

• BeanPostProcessor 和 BeanFactoryPostProcessor：允许开发者在 Bean 实例化前后或 BeanFactory 加载 Bean 定义后进行处理，例如定制化 Bean 实例化过程、修改 Bean 定义等。
• ApplicationContextInitializer：在 Spring 应用上下文初始化时执行特定逻辑，允许对应用程序上下文进行定制。
• ApplicationListener：允许监听并处理 Spring 应用程序中发布的事件，例如上下文启动、Bean 初始化完成等。
• HandlerInterceptor：用于拦截 Spring MVC 请求处理过程中的请求和响应，执行特定逻辑，例如请求前的处理、请求后的处理等。
• InitializingBean 和 DisposableBean：允许在 Bean 初始化和销毁时执行特定的操作。
• 自定义注解和注解处理器：通过自定义注解和注解处理器，扩展 Spring 框架的功能，例如定制化 Bean 的装配方式、实现特定逻辑等。

使用场景示例

场景一：使用BeanPostProcessor对Bean进行日志记录

有时候，你可能希望在每次 Bean 初始化时记录日志。通过实现 BeanPostProcessor 接口，你可以在 Bean 初始化前后执行自定义的逻辑。

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanPostProcessor;

public class LoggingBeanPostProcessor implements BeanPostProcessor {

    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("Initializing bean: " + beanName);
        return bean;
    }

    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        // 可以在此处进行其他的操作，比如打印日志或执行其他逻辑
        return bean;
    }
}

在这个例子中，LoggingBeanPostProcessor 实现了 BeanPostProcessor 接口，并在每个 Bean 初始化前后输出日志信息。 

场景二：使用自定义注解处理器实现权限校验

假设你需要实现一个权限校验的功能，可以通过自定义注解和注解处理器来完成。

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface RequiresPermission {
    String value(); // 定义权限名称
}

// 自定义注解处理器
import org.springframework.stereotype.Component;
import org.springframework.util.StringUtils;
import java.lang.reflect.Method;

@Component
public class PermissionCheckProcessor {

    public void checkPermission(Object target) {
        Method[] methods = target.getClass().getMethods();
        for (Method method : methods) {
            if (method.isAnnotationPresent(RequiresPermission.class)) {
                RequiresPermission annotation = method.getAnnotation(RequiresPermission.class);
                String permission = annotation.value();
                if (StringUtils.hasText(permission)) {
                    // 执行权限检查逻辑，根据需求进行权限验证
                    System.out.println("Checking permission for method: " + method.getName());
                }
            }
        }
    }
}

在这个场景中，自定义注解 RequiresPermission 定义了权限名称，PermissionCheckProcessor 类则扫描被该注解标记的方法，并执行相应的权限检查逻辑。

场景三：使用ApplicationListener监听应用程序事件

假设你需要在某个特定事件发生时触发某些操作，可以通过实现 ApplicationListener 接口监听相应的事件。

import org.springframework.context.ApplicationEvent;
import org.springframework.context.ApplicationListener;
import org.springframework.stereotype.Component;

@Component
public class CustomEventListener implements ApplicationListener<ApplicationEvent> {

    @Override
    public void onApplicationEvent(ApplicationEvent event) {
        // 这里可以根据不同的事件类型执行相应的操作
        if (event instanceof CustomEvent) {
            System.out.println("Custom event occurred: " + event.toString());
        }
    }
}

 在这个例子中，CustomEventListener 监听所有的应用程序事件，并在自定义事件 CustomEvent 发生时执行相应的操作。

场景四：使用 InitializingBean 和 DisposableBean 完成资源的初始化和销毁

假设你有一个需要在初始化和销毁时释放资源的类，你可以使用 InitializingBean 和 DisposableBean 接口完成这些操作。

import org.springframework.beans.factory.DisposableBean;
import org.springframework.beans.factory.InitializingBean;

public class ResourceHandler implements InitializingBean, DisposableBean {

    private String resource;

    public void setResource(String resource) {
        this.resource = resource;
    }

    @Override
    public void afterPropertiesSet() throws Exception {
        // 在初始化时执行的逻辑，比如资源的加载
        System.out.println("Initializing ResourceHandler with resource: " + resource);
    }

    @Override
    public void destroy() throws Exception {
        // 在销毁时执行的逻辑，比如资源的释放
        System.out.println("Destroying ResourceHandler");
        // 这里进行资源的释放操作，比如关闭连接、释放文件资源等
    }
}

在这个场景中，ResourceHandler 类实现了 InitializingBean 和 DisposableBean 接口。afterPropertiesSet 方法用于在 Bean 初始化后执行逻辑，destroy 方法用于在 Bean 销毁前执行逻辑。

场景五：使用自定义的HandlerInterceptor实现请求拦截

如果你想要在请求到达处理程序之前或之后执行某些逻辑，可以使用 HandlerInterceptor 接口来实现拦截器。

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;

public class CustomHandlerInterceptor implements HandlerInterceptor {

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        // 在处理程序之前执行逻辑，返回true则继续执行，返回false则中断请求
        System.out.println("Before handling the request");
        return true;
    }

    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        // 在处理程序执行后、视图渲染前执行逻辑
        System.out.println("After handling the request, before rendering the view");
    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        // 在视图渲染后执行逻辑
        System.out.println("After rendering the view");
    }
}

在这个示例中，CustomHandlerInterceptor 实现了 HandlerInterceptor 接口，用于在请求处理前后执行自定义的逻辑，比如日志记录、权限校验等。

结语

通过 InitializingBean 和 DisposableBean 接口，可以在 Spring 容器管理的 Bean 的初始化和销毁阶段执行特定的逻辑，这对于资源的初始化和释放是非常有用的。然而，考虑到 Spring 的灵活性，通常推荐使用 @PostConstruct 和 @PreDestroy 注解或者自定义的销毁方法和初始化方法，以提高代码的可读性和易维护性。