spring|spring event|Spring内置事件驱动编程模型|类型泛化

package com.jysemel.spring.boot.study.event;


import lombok.Getter;
import lombok.Setter;

// 定义一个泛型事件
@Getter
@Setter
public class EntityCreatedEvent<T> {

    private T entity;
}

package com.jysemel.spring.boot.study.event;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import org.springframework.core.ResolvableType;
import org.springframework.core.ResolvableTypeProvider;

@Data
@NoArgsConstructor
@AllArgsConstructor
public class GenericEvent<T> implements ResolvableTypeProvider {

    private T data;
    private String operation;

    @Override
    public ResolvableType getResolvableType() {
        if (this.data != null) {
            return ResolvableType.forClassWithGenerics(
                    getClass(),
                    ResolvableType.forInstance(this.data)
            );
        }
        return ResolvableType.forClass(getClass());
    }
}

package com.jysemel.spring.boot.study.event;


import lombok.AllArgsConstructor;
import lombok.Getter;
import lombok.Setter;

@Getter
@Setter
@AllArgsConstructor
public class Order {

    private String orderId;
    private Double amount;

}

package com.jysemel.spring.boot.study.event;


import lombok.AllArgsConstructor;
import lombok.Getter;
import lombok.Setter;

@Getter
@Setter
@AllArgsConstructor
public class Person {
    private String name;
    private Integer age;
}

package com.jysemel.spring.boot.study.listener;


import com.jysemel.spring.boot.study.event.GenericEvent;
import com.jysemel.spring.boot.study.event.Order;
import com.jysemel.spring.boot.study.event.Person;
import jakarta.annotation.PostConstruct;
import lombok.extern.slf4j.Slf4j;
import org.springframework.context.event.EventListener;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Component;

@Slf4j
@Component
public class GenericEventListener {

    @PostConstruct
    public void init() {
        System.out.println("✅✅✅ GenericEventListener 已被 Spring 加载！");
    }
    /**
     * 监听 Person 类型的泛型事件
     * Spring 会根据泛型参数自动路由
     */
    @Async
    @EventListener
    public void handlePersonEvent(GenericEvent<Person> event) {
        Person person = event.getData();
        log.info("【Person监听器】操作: {}, 数据: name={}, age={}", event.getOperation(), person.getName(), person.getAge());
    }

    /**
     * 监听 Order 类型的泛型事件
     */
    @Async
    @EventListener
    public void handleOrderEvent(GenericEvent<Order> event) {
        Order order = event.getData();
        log.info("【Order监听器】操作: {}, 数据: orderId={}, amount={}", event.getOperation(), order.getOrderId(), order.getAmount());
    }

    /**
     * 监听所有类型的泛型事件（兜底）
     * 注意：SpEL 表达式可以精确控制
     */
    @Async
    @EventListener(condition = "#event.operation == 'DELETE'")
    public void handleAllDeleteEvent(GenericEvent<?> event) {
        log.info("【通用删除监听器】操作: DELETE, 数据: {}", event.getData());
    }

    @EventListener
    @Async
    public void handleRawEvent(GenericEvent event) {
        System.out.println("🔥🔥🔥【兜底原始类型】成功捕获事件，数据为: " + event.getData());
    }
}

package com.jysemel.spring.boot.study.service;


import com.jysemel.spring.boot.study.event.GenericEvent;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationEventPublisher;
import org.springframework.stereotype.Component;

@Component
public class EventPublisher {

    @Autowired
    private  ApplicationEventPublisher publisher;

    /**
     * 发布泛型事件
     * @param data      业务数据（任意类型）
     * @param operation 操作类型
     * @param <T>       数据类型
     */
    public <T> void publish(T data, String operation) {
        GenericEvent<T> event = new GenericEvent<>(data, operation);
        publisher.publishEvent(event);
        System.out.println("事件已发布: " + event);
    }
}