Java中的拦截器是干什么的,有什么作用,怎么用,拦截器中注入bean失败怎么办?

在Java中，拦截器（Interceptor）通常指的是在Spring框架中用于拦截请求的一种机制。在Spring框架中，拦截器是一种AOP（面向切面编程）的实现，它可以在方法执行前、执行后、抛出异常时等不同的时间点执行一些操作。

具体来说，在Spring框架中，可以通过实现`HandlerInterceptor`接口来创建拦截器。这个接口定义了在请求处理的不同阶段执行的方法，包括`preHandle`（在请求处理之前调用）、`postHandle`（在请求处理之后调用，渲染视图之前）和`afterCompletion`（在请求处理完成之后，视图渲染完成后调用）。

拦截器可以用于处理日志记录、权限检查、跨域请求处理等。它们提供了一种灵活的方式来对请求进行预处理和后处理，而不需要修改实际的业务逻辑代码。

总的来说，拦截器是Spring框架中非常有用的一部分，它提供了一种可插拔的机制，可以在不同的阶段对请求进行干预和处理。

 先贴带代码,这是拦截器

/**
 * 检查系统配置的拦截器
 *
 */
@Component
public class SysConfigInterceptor implements HandlerInterceptor {

    /**
     * 正在维护
     */
    public static final String fixxing="1";
    /**
     * 维护成功
     */
    public static final String fixed="0";
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        //获取spring中的bean
        SysConfigMapper sysConfigMapper2 = SpringUtils.getBean(SysConfigMapper.class);

        SysConfig sysConfig = sysConfigMapper2.selectOne(Wrappers.<SysConfig>lambdaQuery().eq(SysConfig::getConfigKey, "xxxx"));
        if (sysConfig!=null&&fixxing.equals(sysConfig.getConfigValue())){
            throw new ServiceException("系统维护中!", HttpStatus.ERROR);
        }
        return true;
    }


}

这是将拦截器注册进配置里

@Configuration
public class WebServiceMvcConfig implements WebMvcConfigurer {
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        //将过滤器注册进系统配置
        registry.addInterceptor(new SysConfigInterceptor()).addPathPatterns("/**");
    }
}

 这是工具类

/**
 * spring工具类 方便在非spring管理环境中获取bean
 *
 * @author system
 */
@Component
public final class SpringUtils implements BeanFactoryPostProcessor, ApplicationContextAware
{
    /** Spring应用上下文环境 */
    private static ConfigurableListableBeanFactory beanFactory;

    private static ApplicationContext applicationContext;

    @Override
    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException
    {
        SpringUtils.beanFactory = beanFactory;
    }

    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException
    {
        SpringUtils.applicationContext = applicationContext;
    }

    /**
     * 获取对象
     *
     * @param name
     * @return Object 一个以所给名字注册的bean的实例
     * @throws BeansException
     *
     */
    @SuppressWarnings("unchecked")
    public static <T> T getBean(String name) throws BeansException
    {
        return (T) beanFactory.getBean(name);
    }

    /**
     * 获取类型为requiredType的对象
     *
     * @param clz
     * @return
     * @throws BeansException
     *
     */
    public static <T> T getBean(Class<T> clz) throws BeansException
    {
        T result = (T) beanFactory.getBean(clz);
        return result;
    }

    /**
     * 如果BeanFactory包含一个与所给名称匹配的bean定义，则返回true
     *
     * @param name
     * @return boolean
     */
    public static boolean containsBean(String name)
    {
        return beanFactory.containsBean(name);
    }

    /**
     * 判断以给定名字注册的bean定义是一个singleton还是一个prototype。 如果与给定名字相应的bean定义没有被找到，将会抛出一个异常（NoSuchBeanDefinitionException）
     *
     * @param name
     * @return boolean
     * @throws NoSuchBeanDefinitionException
     *
     */
    public static boolean isSingleton(String name) throws NoSuchBeanDefinitionException
    {
        return beanFactory.isSingleton(name);
    }

    /**
     * @param name
     * @return Class 注册对象的类型
     * @throws NoSuchBeanDefinitionException
     *
     */
    public static Class<?> getType(String name) throws NoSuchBeanDefinitionException
    {
        return beanFactory.getType(name);
    }

    /**
     * 如果给定的bean名字在bean定义中有别名，则返回这些别名
     *
     * @param name
     * @return
     * @throws NoSuchBeanDefinitionException
     *
     */
    public static String[] getAliases(String name) throws NoSuchBeanDefinitionException
    {
        return beanFactory.getAliases(name);
    }

    /**
     * 获取aop代理对象
     *
     * @param invoker
     * @return
     */
    @SuppressWarnings("unchecked")
    public static <T> T getAopProxy(T invoker)
    {
        return (T) AopContext.currentProxy();
    }

    /**
     * 获取当前的环境配置，无配置返回null
     *
     * @return 当前的环境配置
     */
    public static String[] getActiveProfiles()
    {
        return applicationContext.getEnvironment().getActiveProfiles();
    }

    /**
     * 获取当前的环境配置，当有多个环境配置时，只获取第一个
     *
     * @return 当前的环境配置
     */
    public static String getActiveProfile()
    {
        final String[] activeProfiles = getActiveProfiles();
        return StringUtils.isNotEmpty(activeProfiles) ? activeProfiles[0] : null;
    }

    /**
     * 获取配置文件中的值
     *
     * @param key 配置文件的key
     * @return 当前的配置文件的值
     *
     */
    public static String getRequiredProperty(String key)
    {
        return applicationContext.getEnvironment().getRequiredProperty(key);
    }
}

资源文章链接:JAVA三种拦截方式_java的拦截器-CSDN博客