如何使用静态编程语言在Spring Boot中处理自定义注释？

Question

上下文：我想在Spring Boot中创建一个自定义注释，并为处理添加额外的逻辑。我举了一个注释非常简单的例子，但我希望有几个这样的注释具有更细粒度的控制。

解决这个问题有几种方法：

• 创建过滤器
• 创建拦截器
• 使用自定义处理创建注释

我必须使用最新的一个，因为上面两个不适用于我的用例。

问题：

我在静态编程语言中有一个自定义注释，我希望它被注册并在运行时被检查。

@Retention(AnnotationRetention.RUNTIME)
@Target(AnnotationTarget.FUNCTION)
annotation class OfflineProcessing(val allow: Bool)

REST控制器如下：

@RestController
class ApiController {

    @GetMapping("/api/version")
    @OfflineProcessing(true)
    fun apiVersion(): String {
        return "0.1.0"
    }
}

其思想是每个方法都有注释，并根据线性处理的允许与否，生成条件逻辑。

我已经尝试过创建基本的PostBean处理机：

@Component
class OfflineProcessingAnnotationProcessor @Autowired constructor(
        val configurableBeanFactory: ConfigurableListableBeanFactory
) : BeanPostProcessor {

    @Throws(BeansException::class)
    override fun postProcessBeforeInitialization(bean: Any, beanName: String): Any? {
        println("Before processor. Bean name: $beanName, Bean: $bean. Bean factory: $configurableBeanFactory.")
        return super.postProcessBeforeInitialization(bean, beanName)
    }

    @Throws(BeansException::class)
    override fun postProcessAfterInitialization(bean: Any, beanName: String): Any? {
        println("After processor. Bean name: $beanName, Bean: $bean. Bean factory: $configurableBeanFactory.")
        return super.postProcessAfterInitialization(bean, beanName)
    }

}

很明显，注释不会在BeanPost处理机的其他注释中被记录，我混淆了如何访问它，到目前为止，我没有找到任何其他没有BeanPost处理机的好例子。

依赖性：

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-configuration-processor</artifactId>
</dependency>

我做错什么了吗？还是我试图用错误的方法来完成任务？




Answer 1

这是一个一般性的问题，不是科特林特有的。

我认为，你试图解决这个问题的误解是，你在使用BeanPostProcessor。bean是在早期阶段创建的，它可能是一个单例，因此在执行rest请求时不会调用它。这意味着您需要检查一个包含注释的bean，然后在其上创建一个代理bean，并将您的逻辑嵌入到该代理中。

这与AOP的做法非常相似，@eol的方法是匹配复活节。

我想建议使用拦截器，但不是bean创建拦截器。

我的答案是受Spring Boot添加Http请求拦截器的启发

定义注释

@Retention(AnnotationRetention.RUNTIME)
@Target(AnnotationTarget.FUNCTION)
annotation class OfflineProcessing(val allow: Boolean)

定义拦截器

@Component
class CustomRestAnnotationInterceptor:HandlerInterceptor {
    private val logger: Logger = LoggerFactory.getLogger(this.javaClass)

    override fun preHandle(request: HttpServletRequest, response: HttpServletResponse, handler: Any): Boolean {
        if (handler is HandlerMethod) {
            var isOffline: OfflineProcessing? = handler.getMethodAnnotation(OfflineProcessing::class.java)
            if (null == isOffline) {
                isOffline = handler.method.declaringClass
                    .getAnnotation(OfflineProcessing::class.java)
            }
            if (null != isOffline) {
                logger.info("method called has OfflineProcessing annotation with allow=${isOffline.allow}" )
            }
        }
        return true
    }
}

将拦截器添加到路径

@Configuration
class WebConfig : WebMvcConfigurer {
    @Autowired
    lateinit var customRestAnnotationInterceptor: CustomRestAnnotationInterceptor

    override fun addInterceptors(registry: InterceptorRegistry) {
        // Custom interceptor, add intercept path and exclude intercept path
        registry.addInterceptor(customRestAnnotationInterceptor).addPathPatterns("/**")
    }
}

使用控制器上的注释

日志会显示

2022-04-14 08:48:58.785  INFO 32595 --- [nio-8080-exec-1] .h.s.k.q.CustomRestAnnotationInterceptor : method called has OfflineProcessing annotation with allow=true

Answer 2

这不是对你的问题的直接回答，但是在这种情况下，我只是简单地使用Spring AOP，而不是实现BeanPost处理机。要做到这一点，您可以定义以下注释和相应的方面，例如：

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
annotation class OfflineProcessing(val allowed: Boolean = true)

@Aspect
@Component
class OfflineProcessingAspect {
    @Pointcut("@annotation(<path.to.annotation.package>.OfflineProcessing)")
    fun offlineProcessingPointcut(offlineProcessing: OfflineProcessing?) {
    }

    @Around("offlineProcessingPointcut(offlineProcessing)")
    @Throws(Throwable::class)
    fun around(pjp: ProceedingJoinPoint, offlineProcessing: OfflineProcessing): Object {
        if (offlineProcessing.allowed()) {               
           // your pre-processing logic here
           val result = pjp.proceed()
           // post-processing logic here
           return result
        }
        // do the same for non-allowed offline-processing ...
    }
}

最后，添加以下依赖项：

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-aop</artifactId>
</dependency>