自定义事件学习使用

已于 2024-02-18 11:05:31 修改
阅读量385 收藏 6
点赞数 8
分类专栏： 项目 文章标签： 学习 java
于 2024-01-19 11:41:31 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44877172/article/details/135693711
版权

请求接口

@RestController
@RequestMapping(value = "/caching")
public class TestController {

    @RequestMapping(value = "/testFilter",method = RequestMethod.GET)
    public String testCachingFilter(HttpServletRequest request, HttpServletResponse response,String content){
    //定义事件
        DefaultDomainEvent de = new DefaultDomainEvent();
        de.addEventData("key1","value1");
        //发布事件
DomainEventPublisherFactory.getRegisteredPublisher().publishEvent(de);
        return "SUCCESS";
    }
    
}

自定义事件

public interface DomainEvent {
    /**
     * 获得事件ID
     * @return
     */
    String getEventId();
    /**
     * 获得事件事件
     * @return
     */
    Date obtainEventTime(); 
    /**
     * 获取操作信息
     * @return
     */
    OperateInfo getOperateInfo();
    /**
     * 获得事件的触发人身份
     * @return
     */
    AccessTokenUser getOperator();
    /**
     * 事件需要传递的业务数据
     * @return
     */
    <T> T getEventData();
    /**
     * 定义事件监听器的执行顺序逻辑
     * @return
     */
    ExecutePoint obtainExecutePoint();
    /**
     * 事件类型
     * @return
     */
    String getEventType();
    /**
     * 排序号  相同的排序号  按发布事件的顺序
     * @return
     */
    default int orderNo() {
        return 0;
    }
    /**
     * 异常是否抛出
     * @return
     */
    default boolean throwException() {
        return true;
    }
}

public class DefaultDomainEvent implements DomainEvent {

    //传递的数据
    private Map<String,Object> eventData;
    //TODO 也可以定义其他数据

    public DefaultDomainEvent() {
    }

    public DefaultDomainEvent(Map<String, Object> eventData) {
        this.eventData = eventData;
    }

    @Override
    public String getEventId() {
        return null;
    }

    //当前系统时间
    @Override
    public Date obtainEventTime() {
        return null;
    }

    //当前用户信息
    @Override
    public OperateInfo getOperateInfo() {
        return null;
    }
    //当前用户信息
    @Override
    public AccessTokenUser getOperator() {
        return null;
    }
    //当前事件中包含的数据
    @Override
    public <T> T getEventData() {
        return (T)this.eventData;
    }

    //事件执行时机
    @Override
    public ExecutePoint obtainExecutePoint() {
        return ExecutePoint.CURR_THREAD;
    }

    //事件类型
    @Override
    public String getEventType() {
        return DefaultDomainEvent.class.getSimpleName();
    }

    public void addEventData(String key,Object value){
        if (this.eventData == null) this.eventData = new HashMap<>();
        if (StringUtils.isBlank(key)) return;
        if (value == null){
            this.eventData.remove(key);
            return;
        }
        this.eventData.put(key, value);
    }

    public void addEventData(Map<String,Object> eventData){
        if (this.eventData == null) this.eventData = new HashMap<>();
        if (eventData == null) return;
        this.eventData.putAll(eventData);
    }
}

自定义事件监听器

@Service
public class DefaultDomainEventListener implements IDomainEventListener {

    private static Logger logger = LoggerFactory.getLogger(DefaultDomainEventListener.class);

    @Override
    public void onEvent(DomainEvent event) {
    //执行我们的业务逻辑
        Map<String,Object> eventData = event.getEventData();
        logger.info("DefaultDomainEventListener.onEvent():params:{}", JsonConverter.toJsonStr(eventData));
    }

    @Override
    public boolean listenOn(String eventType) {
        return DefaultDomainEvent.class.getName().equals(eventType);
    }
}

事件发布器

public class DomainEventPublisherFactory {
	
	private static final DomainEventPublisherFactory INSTANCE = new DomainEventPublisherFactory();
	private DomainEventPublisher domainEventPublisher = null;
	private DomainEventPublisherFactory(){
		
	}
	public static final DomainEventPublisherFactory instance(){
		return INSTANCE;
	}
	public static final DomainEventPublisher registerPublisher(DomainEventPublisher domainEventPublisher){
		instance().domainEventPublisher = domainEventPublisher;
		return domainEventPublisher;
	}
	
	public static final DomainEventPublisher getRegisteredPublisher(){
		if(instance().domainEventPublisher==null){
			throw new RuntimeException("事件发布器未注册到DomainEventPublisherFactory!");
		}
		return instance().domainEventPublisher;
	}
}

public interface DomainEventPublisher {
	void publishEvent(DomainEvent event);
}
//执行发布的事件逻辑
@Component
public class DefaultDomainEventPublisher implements DomainEventPublisher,ApplicationContextAware {
    private final Logger logger=LogManager.getLogger(this.getClass());
    
    private ApplicationContext context;
    @Override
    public void setApplicationContext(ApplicationContext context)
            throws BeansException {
        this.context = context;
        DomainEventPublisherFactory.registerPublisher(this);
    }
    @Autowired
    private AsyncTaskComponent asyncTaskComponent;
    
    
    private List<IDomainEventListener> listeners=null;
    private List<IDomainEventListener> getDomainEventListeners(){
        if(listeners!=null) return listeners;
        
        synchronized(DefaultDomainEventPublisher.class) {
            if(listeners!=null) return listeners;
            
            Map<String, IDomainEventListener> beans = context.getBeansOfType(IDomainEventListener.class);
            if(beans==null) return listeners;
            List<IDomainEventListener> listeners1=new ArrayList<>();
            Map<IDomainEventListener,Integer> los=new HashMap<>();
            int i=1;
            for (IDomainEventListener listener : beans.values()) {
                los.put(listener, i);
                listeners1.add(listener);
                i++;
            }
            Collections.sort(listeners1, (l1,l2)->{
                int rt=l1.getOrderNo()-l2.getOrderNo();
                if(rt==0) rt=los.get(l1)-los.get(l2);
                return rt;
            });
            listeners = Collections.unmodifiableList(listeners1);
        }
        
        return listeners;
    }
    @Override
    public void publishEvent(DomainEvent event) {
        //如果是事务提交后的事件  判断以经加入的事件 不再加入
        if(!ExecutePoint.CURR_THREAD.equals(event.obtainExecutePoint())
                &&!ExecutePoint.NEW_THREAD_NOW.equals(event.obtainExecutePoint())
                &&this.eventAdded(event)
                ) {
            return;
        }
        List<IDomainEventListener> listeners = this.getDomainEventListeners();
        for(IDomainEventListener listener:listeners){
            if(StringUtils.isBlank(event.getEventType())
                    ||!listener.listenOn(event.getEventType())
                    ) {
                continue;
            }
            if(ExecutePoint.CURR_THREAD.equals(event.obtainExecutePoint())){//当前线程
                try {
                    listener.onEvent(event);
                } catch (Exception e) {
                    logger.error(e);
                    if(event.throwException()) throw new RuntimeException(e);
                }
            }else if(ExecutePoint.CURR_THREAD_AFTER_COMMITTED.equals(event.obtainExecutePoint())){//事务提交后  当前线程执行
                List<WaitExecuteDomainEvent> waits=ThreadLocalCache.getCacheObject(ExecutePoint.CURR_THREAD_AFTER_COMMITTED.toString());
                if(waits==null) {
                    waits=new ArrayList<WaitExecuteDomainEvent>();
                    ThreadLocalCache.addCache(ExecutePoint.CURR_THREAD_AFTER_COMMITTED.toString(), waits);
                    //事务提交后 在线程中执行事件  避免  事务问题
                    TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronization() {
                        @Override
                        public void afterCommit() {
                            run_CURR_THREAD_AFTER_COMMITTED_Events();
                        }
                        @Override
                        public int getOrder() {
                            return 0;
                        }
                    });
                }
                waits.add(new WaitExecuteDomainEvent(listener,event));
            }else if(ExecutePoint.NEW_THREAD_NOW.equals(event.obtainExecutePoint())){//立即 启动一个线程
                asyncTaskComponent.runTaskInThreadPool(new AsyncTaskComponent.IAsyncTask<String>() {
                    @Override
                    public String execute(Map<String, Object> data) {
                        IDomainEventListener listener=(IDomainEventListener) data.get("listener");
                        DomainEvent event=(DomainEvent) data.get("event");
                        try {
                            listener.onEvent(event);
                        } catch (Exception e) {
                            logger.error(e);
                        }
                        return null;
                    }
                }, Utils.buildMap("listener",listener,"event",event));
            }else if(ExecutePoint.NEW_THREAD_AFTER_COMMITTED.equals(event.obtainExecutePoint())){//事务提交后 启动一个线程
                TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronization() {
                    @Override
                    public void afterCommit() {
                        asyncTaskComponent.runTaskInThreadPool(new AsyncTaskComponent.IAsyncTask<String>() {
                            @Override
                            public String execute(Map<String, Object> data) {
                                IDomainEventListener listener=(IDomainEventListener) data.get("listener");
                                DomainEvent event=(DomainEvent) data.get("event");
                                try {
                                    listener.onEvent(event);
                                } catch (Exception e) {
                                    logger.error(e);
                                }
                                return null;
                            }
                        }, Utils.buildMap("listener",listener,"event",event));
                    }
                    @Override
                    public int getOrder() {
                        return listener.getOrderNo()+1;
                    }
                });
            }else if(ExecutePoint.NEW_THREAD_AFTER_COMPLETIONED.equals(event.obtainExecutePoint())){//事务完成(提交/回滚)后 启动一个线程
                TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronization() {
                    @Override
                    public void afterCompletion(int status) {//status 见TransactionSynchronization.STATUS_
                        asyncTaskComponent.runTaskInThreadPool(new AsyncTaskComponent.IAsyncTask<String>() {
                            @Override
                            public String execute(Map<String, Object> data) {
                                IDomainEventListener listener=(IDomainEventListener) data.get("listener");
                                DomainEvent event=(DomainEvent) data.get("event");
                                try {
                                    listener.onEvent(event);
                                } catch (Exception e) {
                                    logger.error(e);
                                }
                                return null;
                            }
                        }, Utils.buildMap("listener",listener,"event",event));
                    }
                    @Override
                    public int getOrder() {
                        return listener.getOrderNo()+1;
                    }
                });
            }
        }
    }
    //运行事务提交后事件
    public void run_CURR_THREAD_AFTER_COMMITTED_Events() {
        List<WaitExecuteDomainEvent> waits=ThreadLocalCache.removeCache(ExecutePoint.CURR_THREAD_AFTER_COMMITTED.toString());
        if(CollectionUtils.isEmpty(waits)) return;
        Map<WaitExecuteDomainEvent,Integer> waitToIndex=new HashMap<WaitExecuteDomainEvent,Integer>();
        int i=0;
        for (WaitExecuteDomainEvent wait : waits) {
            waitToIndex.put(wait, i);
            i++;
        }
        waits.sort(Comparator.comparingInt(WaitExecuteDomainEvent::getOrderNo).thenComparingInt(waitToIndex::get));
        Future<String> f=asyncTaskComponent.runTaskInThreadPool(data -> {
            for (WaitExecuteDomainEvent wait : waits) {
                wait.execute();
            }
            return null;
        }, null);
        //Boolean isyc = Boolean.valueOf(BaseConstants.getProperty("prefetchingRecordNo", "false"));
        //if(isyc) return;
        //等待10s
        String name=waits.toString();
        try {
            f.get(10,TimeUnit.SECONDS);
        } catch (Exception e) {
            e.printStackTrace();
            logger.error(name+".run_CURR_THREAD_AFTER_COMMITTED_Events 运行超时10s");
        }
        for (WaitExecuteDomainEvent wait : waits) {
            if(wait.getError()!=null) {
                logger.error(name+".run_CURR_THREAD_AFTER_COMMITTED_Events."+wait.getListenerClassName()+"运行出错:",wait.getError());
            }
            if(wait.isExecuted()) {
                logger.info(name+".run_CURR_THREAD_AFTER_COMMITTED_Events."+wait.getListenerClassName()+"运行耗时:"+wait.getCost()+"ms");
                continue;
            }
            if(wait.isExecuting()) {
                logger.warn(name+".run_CURR_THREAD_AFTER_COMMITTED_Events."+wait.getListenerClassName()+"正在运行,参数"+JsonConverter.toJsonStr(wait.getEvent())+",已耗时:"+wait.getCost()+"ms");
            }
            else {
                logger.warn(name+".run_CURR_THREAD_AFTER_COMMITTED_Events."+wait.getListenerClassName()+"还未运行,参数"+JsonConverter.toJsonStr(wait.getEvent()));
            }
        }
    }
    //判断事件是否已经 加入到 队列中
    private boolean eventAdded(DomainEvent event) {
        if(ThreadLocalCache.getCacheObject(ThreadLocalCache.REQUEST_ID)==null) {
            return false;
        }
        synchronized (ThreadLocalCache.getCacheObject(ThreadLocalCache.REQUEST_ID)) {
            Map<String,Boolean> addedKeys=ThreadLocalCache.getCacheObject("addedEventKeys");
            if(addedKeys==null) {
                addedKeys=new HashMap<String,Boolean>();
            }
            String eventKey=event.getEventType()+event.getEventId();
            if(addedKeys.containsKey(eventKey)) {
                return true;
            }
            addedKeys.put(eventKey, true);
        }
        return false;
    }
}

异步执行发布的事件

@Component
public class AsyncTaskComponent {
    /**
     * 启动监听线程
     * @param <T>
     * @param task
     * @param data
     */
    @Async("taskExecutor")//使用线程池 启动
    public <T> Future<T> runTaskInThreadPool(IAsyncTask<T> task, Map<String,Object> data){
        return new AsyncResult<T>(task.execute(data));
    }
    
    //异步任务接口
    public interface IAsyncTask<T> {
        T execute(Map<String,Object> data);
    }
    
}

定义事件执行的时机

public enum ExecutePoint {
    NEW_THREAD_NOW,//立即启动一个新线程执行
    NEW_THREAD_AFTER_COMMITTED, //在事务提交后启动一个新线程执行
    NEW_THREAD_AFTER_COMPLETIONED, //在事务完成(提交/回滚)后启动一个新线程执行
    CURR_THREAD, //在当前线程执行
    CURR_THREAD_AFTER_COMMITTED, //在事务提交后的当前线程执行
}

Spring事件的学习使用

@Component
public class CustomApplicationListener implements ApplicationListener<ApplicationContextEvent>{

	@Override
	public void onApplicationEvent(ApplicationContextEvent event) {
		SpringUtil.setApplicationContext(event.getApplicationContext());
	}

}

public class SpringUtil {
	private static ApplicationContext applicationContext = null ;
	private static Environment  environment = null ;
	public static void setApplicationContext(ApplicationContext applicationContext){
		if(SpringUtil.applicationContext==null){
			SpringUtil.applicationContext=applicationContext;
			SpringUtil.environment=applicationContext.getEnvironment();
		}
	}
	public static ApplicationContext getApplicationContext() {
		return applicationContext;
	}
	public static Environment getEnvironment() {
		return environment;
	}
	
	public static Object getBean(String name){
		return getApplicationContext().getBean(name);
	}
	public static <T> T getBean(Class<T> clazz){
		return getApplicationContext().getBean(clazz);
	}
	public static <T> T getBean(String name,Class<T> clazz){
		return getApplicationContext().getBean(name,clazz);
	}
	
	public static String getString(String key){
		return getEnvironment().getProperty(key);
	}
	public static int getInt(String key){
		return NumberUtil.parseInt(getEnvironment().getProperty(key));
	}
	public static long getLong(String key){
		return NumberUtil.parseLong(getEnvironment().getProperty(key));
	}
	public static boolean getBoolean(String key){
		return BooleanUtil.toBoolean(getEnvironment().getProperty(key));
	}
}
weixin_44877172
关注
  • 8
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
vue学习之组件传值、自定义事件
yoghurt&girl的博客
10-19 734
子组件传父组件
VB.NET学习笔记：事件处理及自定义事件
zyjq52uys的博客
01-03 2396
测试环境：windows 7和Microsoft Visual Studio 2015 编程必然要知道事件，比如单击按钮事件，然后编写当事件发生时的处理代码，VB.NET是怎样进行事件处理的呢？可否自定义事件呢？因扩展控件，使其列头增加全选全不选复选框并具备分页功能需要用到自定义事件，详见博文《VB.NET学习笔记：WinForm自定义DataGridView分页组合控件》、《VB.NET学习笔记...
QT自定义事件
qq_38491692的博客
08-05 1312
自定义事件主要用于用户实现自己所需要的变化
vue3学习（自定义事件）
weixin_48221105的博客
11-13 1132
vue3学习
DOM深入学习 --- 创建自定义事件（四）
秋天，黄叶坠地，凉风有信。
03-10 855
创建自定义事件 我们不仅可以分配事件处理程序，还可以从 JavaScript 生成事件。 自定义事件可用于创建“图形组件”。例如，我们自己的基于 JavaScript 的菜单的根元素可能会触发 open（打开菜单），select（有一项被选中）等事件来告诉菜单发生了什么。另一个代码可能会监听事件，并观察菜单发生了什么。 我们不仅可以生成出于自身目的而创建的全新事件，还可以生成例如 click 和 mousedown 等内建事件。这可能会有助于自动化测试。 事件构造器 内建事件类形成一个层次结构（hierar
vue-组件的自定义事件
m0_64081601的博客
03-22 1055
假如子组件是Demo，父组件是app，子组件已经在父组件中被引用了,例如要给demo绑定一个hello自定义事件,在A中事件的回调是updatethis.$off('绑定的事件名’）在父组件使用组件实例对象身上的$off进行解绑若解绑多个事件，则使用数组包裹，如果不传参数，所有的自定义事件都解绑若想让自定义事件只能触发一次，可以使用once修饰符，或者$.once方法。
Vue自定义事件
小可桢的博客
12-08 674
1. 什么是自定义事件 在封装组件时，为了让组件的使用者可以监听到组件内状态的变化，此时需要用到组件的自定义事件。 2. 自定义事件的 3 个使用步骤 在封装组件时： ① 声明自定义事件 ② 触发自定义事件 在使用组件时： ③ 监听自定义事件 3. 自定义事件传参 在调用 this.$emit() 方法触发自定义事件时，可以通过第 2 个参数为自定义事件传参 ...
学习笔记（13）自定义指令和事件
dugujiuding的博客
02-08 389
vue自定义指令、自定义事件
Qt自定义事件
sinat_38183777的博客
06-16 2775
1.使用Qt自定义事件的意义 我们都知道使用Qt信号槽很方便，只要把信号的发送方和接收方连接起来就可以了，但前提是在同一个文件能同时访问这两个对象，这不是任何情况都能保证的。另外信号槽是一对一的，当要在多个地方响应同一个信号的时候，使用信号槽会显得臃肿。而使用Qt自定义事件可以很好的解决这些问题，所以就算考虑不到其他情况，单是这两种情况也是值得我们关注一下Qt自定义事件的了。 2.简单理解Qt自定...
wxWidGets学习（自定义事件）
q893332169的博客
10-10 826
1. 前言 废话不多说，先看效果图： 从图中可以看出当点击第一个按钮的时候，第二个按钮的字会变。我写的是第一个按钮点击之后执行点击事件，在点击事件里面发送自定义的事件给第二个按钮，第二个按钮接受到自定义事件后，改变自己的label。 2. 正文 2.1 创建自定义事件类 MyPlotEvent.h #ifndef MYPLOTEVENT_H #define MYPLOTEV...
C#自定义事件及用法实例
12-25
本文实例讲述了C#自定义事件及用法。分享给大家供大家参考。具体分析如下： 事件是C#中一个重要的内容，MSDN上有一个自定义事件的演示示例。我看了半天有点晕，所以新建了一个winform工程添加了一个按钮，然后找出...
微信小程序自定义事件
03-29
什么是自定义事件呢,你可以简单的理解为:在触发子组件的一些事件的时候,同时也能触发父组件对应的事件并对父组件中的某些数据进行修改的事件就是自定义事件. 有翻阅学习过小程序官方给出的自定义组件教程的小伙们...
VB6用户自定义事件EVENT实例.zip
08-26
VB用户自定义事件绕来绕去的，翻了半天书也不好弄清楚，最后还是仔细翻看MSDN的事例弄有了。我把它贴成了VB可运行工程，试运行一下就很有体验感了，学起来省时省力。取之于MSDN用之于需要的学习，不需要消耗积分。
js自定义事件及事件交互原理概述(一)
10-27
在JS中事件是JS与浏览器交互的主要途径,本文主要介绍下最简单的自定义事件，不过还有很多缺陷，感兴趣的朋友可以了解下，或许对你学习自定义事件有所帮助
c#在程序中定义和使用自定义事件方法总结
08-26
在本篇文章中小编给大家整理了关于c#在程序中定义和使用自定义事件方法总结相关知识点，需要的朋友们学习下。
FME学习之旅---day27
最新发布
summer_corner的博客
05-17 201
我们付出一些成本，时间的或者其他，最终总能收获一些什么。
使用多实例学习进行乳腺癌组织病理学图像分类和定位
qq_47896523的博客
05-16 1105
乳腺癌是女性最主要的死亡原因，病理学家根据病理切片中观察到的各种视觉特征（例如细胞核的形态特征、细胞核的微观和宏观结构等）做出决定。计算机辅助诊断（CAD）系统可以帮助病理学家自动做出决策。卷积神经网络是最广泛使用的深度学习框架，用于学习图像类别之间的复杂判别特征。多年来，VGG16 [3] 和 ResNet18 [4] 等各种 CNN 架构在海量 ImageNet 数据集上产生了出色的结果。CNN 被用于医学图像以产生最先进的结果。为图像中存在的所有类别提供了定位信息。
WEB转Flutter基础学习笔记（内含vue和flutter对比）
小易不止于搬砖的博客
05-17 682
笔者是一名web前端，记录在转栈flutter时的学习笔记，内涵和vue的对比，能够辅助前端同学更容易理解flutter
Page对象的学习
2301_77523055的博客
05-14 1007
ASP.NET允许开发者创建自定义控件和用户控件来扩展页面的功能。自定义控件是从现有的ASP.NET控件派生出来的新控件，而用户控件则是将多个控件组合成一个可重用的单元。这些控件可以像其他ASP.NET控件一样在页面上使用，并通过Page对象进行交互。Page_Init主要用于在控件加载之前进行初始化设置和添加事件处理程序。Page_Load主要用于处理页面回发和加载数据，以及执行其他需要在页面加载时完成的逻辑。由于Page_Init在Page_Load之前触发，因此在Page_Init。
学习掌握自定义事件的实现方法。
05-29
在 React 中，可以通过在组件中使用 componentDidMount 和 componentWillUnmount 方法来监听和取消监听自定义事件。例如： ```javascript class MyComponent extends React.Component { componentDidMount() { ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值