如何在Vaadin中用Spring AOP的@Around拦截Button点击事件并日志记录？

可行性说明 #

完全可行，但你的当前实现存在核心问题：Spring AOP仅能代理Spring容器管理的Bean，而你代码中创建的ComponentEventListener匿名内部类并非Spring Bean，因此切面无法拦截到这些类的方法调用。

问题原因分析 #

Spring AOP基于动态代理机制，只会对由Spring容器实例化和管理的Bean生成代理对象。你在MainView的initUI方法中直接new出来的匿名ComponentEventListener实例，完全脱离Spring的管理范畴，所以切面的@Around通知无法生效。

解决方案 #

下面提供几种实用的实现方案，你可以根据项目需求选择：

方案1：将事件处理器定义为Spring Bean

把点击事件的处理器封装成独立的Spring Bean，再注入到视图中使用，这样Spring AOP就能正常拦截。

1. 创建独立的事件处理器Bean：

package com.example.aspectdemo.listener;

import com.vaadin.flow.component.ClickEvent;
import com.vaadin.flow.component.ComponentEventListener;
import com.vaadin.flow.component.button.Button;
import org.springframework.stereotype.Component;

@Component
public class Test1ClickListener implements ComponentEventListener<ClickEvent<Button>> {
    @Override
    public void onComponentEvent(ClickEvent<Button> buttonClickEvent) {
        System.out.println("Button Test1 clicked");
    }
}

@Component
public class Test2ClickListener implements ComponentEventListener<ClickEvent<Button>> {
    @Override
    public void onComponentEvent(ClickEvent<Button> buttonClickEvent) {
        System.out.println("Button Test2 clicked");
    }
}

2. 在MainView中注入并使用这些Bean：

package com.example.aspectdemo.ui;

import com.example.aspectdemo.listener.Test1ClickListener;
import com.example.aspectdemo.listener.Test2ClickListener;
import com.vaadin.flow.component.button.Button;
import com.vaadin.flow.component.orderedlayout.VerticalLayout;
import com.vaadin.flow.router.Route;

@Route("")
public class MainView extends VerticalLayout {

    public MainView(Test1ClickListener test1ClickListener, Test2ClickListener test2ClickListener) {
        initUI(test1ClickListener, test2ClickListener);
    }

    public void initUI(Test1ClickListener test1Listener, Test2ClickListener test2Listener) {
        Button btnTest1 = new Button("Test1");
        Button btnTest2 = new Button("Test2");

        btnTest1.addClickListener(test1Listener);
        btnTest2.addClickListener(test2Listener);

        this.add(btnTest1, btnTest2);
    }
}

此时你的原有切面ClickInformation无需修改，就能正常拦截到onComponentEvent方法的调用。

方案2：将点击逻辑抽为视图Bean的方法

如果不想创建过多独立的处理器类，可以把点击逻辑直接写在MainView（它本身是Spring Bean，因为@Route注解会被Vaadin Spring自动注册到容器）的方法中，然后修改切面切点拦截这些方法。

1. 修改MainView的实现：

package com.example.aspectdemo.ui;

import com.vaadin.flow.component.ClickEvent;
import com.vaadin.flow.component.button.Button;
import com.vaadin.flow.component.orderedlayout.VerticalLayout;
import com.vaadin.flow.router.Route;

@Route("")
public class MainView extends VerticalLayout {

    public MainView() {
        initUI();
    }

    public void initUI() {
        Button btnTest1 = new Button("Test1", this::onTest1Click);
        Button btnTest2 = new Button("Test2", this::onTest2Click);

        this.add(btnTest1, btnTest2);
    }

    public void onTest1Click(ClickEvent<Button> event) {
        System.out.println("Button Test1 clicked");
    }

    public void onTest2Click(ClickEvent<Button> event) {
        System.out.println("Button Test2 clicked");
    }
}

2. 修改切面的切点和逻辑：

package com.example.aspectdemo.config;

import com.vaadin.flow.component.ClickEvent;
import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.springframework.stereotype.Component;

@Aspect
@Component
@Slf4j
public class ClickInformation {

    @Around("execution(* com.example.aspectdemo.ui.MainView.on*(..)) && args(event)")
    public Object logClickInformation(ProceedingJoinPoint pjp, ClickEvent<?> event) throws Throwable {
        String method = pjp.getSignature().getName();
        String targetClass = pjp.getTarget().getClass().getName();
        String buttonText = event.getSource().getText();
        
        String msg = """
                      target: %s
                      method: %s
                      button text: %s
                    """.formatted(targetClass, method, buttonText);
        log.info(msg);
        
        return pjp.proceed();
    }
}

这种方案更简洁，适合点击逻辑较为简单的场景。

方案3：使用AspectJ字节码织入（进阶）

如果必须拦截匿名内部类或非Spring Bean的方法，可以改用AspectJ的编译时/加载时织入（CTW/LTW），它直接修改字节码，不受Spring Bean的限制。

1. 添加AspectJ依赖（Maven示例）：

<dependencies>
    <dependency>
        <groupId>org.aspectj</groupId>
        <artifactId>aspectjrt</artifactId>
        <version>1.9.20.1</version>
    </dependency>
</dependencies>

<build>
    <plugins>
        <plugin>
            <groupId>org.codehaus.mojo</groupId>
            <artifactId>aspectj-maven-plugin</artifactId>
            <version>1.14.0</version>
            <executions>
                <execution>
                    <goals>
                        <goal>compile</goal>
                    </goals>
                </execution>
            </executions>
            <configuration>
                <complianceLevel>17</complianceLevel> <!-- 对应你的JDK版本 -->
                <aspectLibraries>
                    <aspectLibrary>
                        <groupId>org.springframework</groupId>
                        <artifactId>spring-aspects</artifactId>
                    </aspectLibrary>
                </aspectLibraries>
            </configuration>
        </plugin>
    </plugins>
</build>

2. 启用AspectJ加载时织入（可选，若用编译时织入则无需此步）：
   在application.properties中添加：

spring.aop.mode=aspectj

此时你的原有切面代码无需修改，就能拦截到匿名内部类的onComponentEvent方法。

总结 #

• 优先选择方案1或方案2，它们基于Spring AOP的原生机制，配置简单、维护成本低；
• 若有特殊需求必须拦截非Spring Bean的方法，再考虑方案3的AspectJ织入方式。

内容的提问来源于stack exchange，提问作者Lukas