JAVA事件监听机制和 Spring 事件机制

最新推荐文章于 2024-05-19 18:20:33 发布

huang__2

最新推荐文章于 2024-05-19 18:20:33 发布

阅读量349

点赞数

分类专栏： spring Java 文章标签： java Spring

本文链接：https://blog.csdn.net/huang__2/article/details/105868559

版权

Java 同时被 2 个专栏收录

27 篇文章 0 订阅

订阅专栏

spring

11 篇文章 0 订阅

订阅专栏

JAVA事件监听机制和 Spring 事件机制

JAVA事件监听机制

在这里插入图片描述

Java 事件处理采用的是面向对象方法，所有的事件都是由 java.util包中的EventObject类扩展而来的（公共超类不是 Event , 它是旧事件模型中的事件类名。尽管现在不赞成使用旧的事件模型，但这些类仍然保留在Java 库中 )。

事件对象封装了事件源与监听器彼此通信的事件信息。 在必要的时候，可以对传递给监听器对象的事件对象进行分析。在按钮例子中，是借助 getSource和getActionCommand方法实现对象分析的。

事件源有一些向其注册事件监听器的方法。 当某个事件源产生事件时，事件源会向为事件注册的所有事件监听器对象发送一个通告。

事件监听模型：

监听者（扩展 java.util.EventListener）
- 监听器对象是一个实现了特定监听器接口（ listener interface ) 的类的实例。
- 监听器对象将利用事件对象中的信息决定如何对事件做出响应。
- 方法参数类型
  - java.util.EventObject 对象（子类）
  - 事件源
- 监听方法访问限定符 public
- 监听方法是没有返回值（void）
  - 例外：Spring @EventListener
- 监听方法不会 throws Throwable
事件（扩展java.util.EventObject）
- 每个事件对象都有事件源。
事件源（Object）
- 事件源是一个能够注册监听器对象并发送事件对象的对象。

总结：当事件发生时，事件源将事件对象传递给所有注册的监听器。

多事件监听器接口

限制：Java 8 之前，接口没有 default method，当出现多个监听方法时，需要 Adapter 抽象类提供空实现。

适配器类。

注意：事件/监听者器，尤其在扩展时，注意事件（语法）时态。

public interface WindowListener extends EventListener { 
    public void windowOpened(WindowEvent e);
    public void windowClosing(WindowEvent e);   
    public void windowClosed(WindowEvent e);   
    public void windowIconified(WindowEvent e);  
    public void windowDeiconified(WindowEvent e);  
    public void windowActivated(WindowEvent e);
    public void windowDeactivated(WindowEvent e);
}

实现接口，书写 6 个没有任何操作的方法代码显然是一种乏味的工作。鉴于简化的目的，每个含有多个方法的 AWT 监听器接口都配有一个适配器（ adapter ) 类，这个类实现了接口中的所有方法，但每个方法没有做任何事情。这意味着适配器类自动地满足了Java 实现相关监听器接口的技术需求。可以通过扩展适配器类来指定对某些事件的响应动作，而不必实现接口中的每个方法（ ActionListener 这样的接口只有一个方法，因此没必要提供适配器类 ) 。

class Terminator extends WindowAdapter{
    public void windowCIosing( WindowEvent e ){      
        System.exit(O) ;
    }
}

awt button 事件实例

public class ButtonFrame  extends JFrame{
    
    private JPanel buttonPanel;
    private static final int DEFAULT_WIDTH = 300 ;
    private static final int DEFAULT_HEIGHT = 300 ;
    public ButtonFrame(){
        // 设置大小
        setSize(DEFAULT_WIDTH, DEFAULT_HEIGHT);

        // 事件源
        JButton yellowButton = new JButton("Yellow");
        JButton blueButton = new JButton("Blue");
        JButton redButton = new JButton("Red");

        //buttonPanel 面板
        buttonPanel = new JPanel();

        buttonPanel.add(yellowButton);
        buttonPanel.add(blueButton);
        buttonPanel.add(redButton);

        add(buttonPanel);
        // 监听器
        ColorAction yellowAction = new ColorAction(Color.YELLOW);
        ColorAction blueAction = new ColorAction(Color.BLUE);
        ColorAction redAction = new ColorAction(Color.RED);

        //事件源能够添加监听器
        yellowButton.addActionListener(yellowAction);
        blueButton.addActionListener(blueAction);
        redButton.addActionListener(redAction);
    }

    private class ColorAction implements ActionListener {
        private Color backgroundColor;

        public ColorAction(Color c) {
            this.backgroundColor = c;
        }
        @Override
        public void actionPerformed(ActionEvent e) {
            buttonPanel.setBackground(backgroundColor);
        }
    }
    public static void main(String[] args) {
        ButtonFrame buttonFrame = new ButtonFrame();
        buttonFrame.setVisible(true);
        // 当关闭窗体时，退出程序。
        buttonFrame.addWindowListener(new WindowAdapter() {
            @Override
            public void windowClosing(WindowEvent e) {
                super.windowClosing(e);
                System.exit(0);
            }
        });
    }
}

事件机制在Spring的运用

Spring 事件发布的核心类 `AbstractApplicationContext`

事件最终还是由组播（`ApplicationEventMulticaster`）发布。

Spring 事件基类 ApplicationEvent

相对于 java.util.EventObject 增加事件发生时间戳 timestamp

Spring 事件监听器 ApplicationListener

事件监听器接口,事件的业务逻辑封装在监听器里面。

ApplicationEventPublisherAware 事件发送器,通过实现这个接口,来触发事件。

ApplicationEventPublisherAware 带有Aware 标记接口，在spring中调用 referesh()方法中的prepareBeanFactory(beanFactory); 中ApplicationEventPublisher 等组件会被自动装配在spring容器中。在通过IOC容器使用ApplicationEventPublisherAware 实现类可以通过成员属性获取实例。

@Component
public class TestPublish implements ApplicationEventPublisherAware {
    
    private static ApplicationEventPublisher applicationEventPublisher;
    // 这个方法可以从IOC容器中拿到ApplicationEventPublisher实例。
    @Override
    public void setApplicationEventPublisher(ApplicationEventPublisher applicationEventPublisher) {
        TestPublish.applicationEventPublisher = applicationEventPublisher;
    }
    // 发布事件
    public static void  publishEvent(ApplicationEvent communityArticleEvent) {
        applicationEventPublisher.publishEvent(communityArticleEvent);
    }
}

ApplicationEventMulticaster 事件广播器

public class ApplicationEventMulticasterDemo {

    public static void main(String[] args) {
        ApplicationEventMulticaster multicaster = new SimpleApplicationEventMulticaster();

        // 添加监听器
        multicaster.addApplicationListener(event -> {
            if (event instanceof PayloadApplicationEvent) {
                System.out.println("接受到 PayloadApplicationEvent :"
                        + PayloadApplicationEvent.class.cast(event).getPayload());
            }else {
                System.out.println("接收到事件：" + event);
            }
        });
        // 发布/广播事件
        multicaster.multicastEvent(new MyEvent("Hello,World"));
        multicaster.multicastEvent(new PayloadApplicationEvent<Object>("2", "Hello,World"));
    }
    private static class MyEvent extends ApplicationEvent {
        public MyEvent(Object source) {
            super(source);
        }
    }
}

GenericApplicationContext 通过IOC容器事件发布

context.publishEvent(Object event) 注意参数（可以任意一个对象）。析源码可知。

public class SpringEventListenerDemo {

    public static void main(String[] args) {
        GenericApplicationContext context = new GenericApplicationContext();

        // 添加事件监听器
//        context.addApplicationListener(new ApplicationListener<ApplicationEvent>() {
//            @Override
//            public void onApplicationEvent(ApplicationEvent event) {
//                System.err.println("监听事件:" + event);
//
//            }
//        });

        // 添加自义定监听器 --》监听容器启动过程
        context.addApplicationListener(new ClosedListener());
        context.addApplicationListener(new RefreshedListener());
        // 启动 Spring 应用上下文
        context.refresh();

        // 一个是 ContextRefreshedEvent
        // 一个是 PayloadApplicationEvent
        // Spring 应用上下文发布事件
        context.publishEvent("HelloWorld"); // 发布一个 HelloWorld 内容的事件
        // 一个是 MyEvent
        context.publishEvent(new MyEvent("HelloWorld 2018"));

        // 一个是 ContextClosedEvent
        // 关闭应用上下文
        context.close();
    }

    private static class RefreshedListener implements ApplicationListener<ContextRefreshedEvent> {

        @Override
        public void onApplicationEvent(ContextRefreshedEvent event) {
            System.out.println("上下文启动：" + event);
        }
    }

    private static class ClosedListener implements ApplicationListener<ContextClosedEvent> {
        @Override
        public void onApplicationEvent(ContextClosedEvent event) {
            System.out.println("关闭上下文：" + event);
        }
    }

    private static class MyEvent extends ApplicationEvent {
        public MyEvent(Object source) {
            super(source);
        }
    }
}

源码分析 context.publishEvent 发布事件

public abstract class AbstractApplicationContext extends DefaultResourceLoader
		implements ConfigurableApplicationContext {
		
		....
// 核心方法		
protected void publishEvent(Object event, @Nullable ResolvableType eventType) {
		Assert.notNull(event, "Event must not be null");
		if (logger.isTraceEnabled()) {
			logger.trace("Publishing event in " + getDisplayName() + ": " + event);
		}

		// 如有必要，将事件装饰为ApplicationEvent
		ApplicationEvent applicationEvent;
		if (event instanceof ApplicationEvent) {
			applicationEvent = (ApplicationEvent) event;
		}
		// 如果不是ApplicationEvent 默认为PayloadApplicationEvent事件发布。
		else {
			applicationEvent = new PayloadApplicationEvent<>(this, event);
			if (eventType == null) {
				eventType = ((PayloadApplicationEvent) applicationEvent).getResolvableType();
			}
		}

		// 将时间事件加入earlyApplicationEvents 容器
		if (this.earlyApplicationEvents != null) {
			this.earlyApplicationEvents.add(applicationEvent);
		}
		// 通过ApplicationEventMulticaster 开始组播。事件最终还是由组播发送。
		else {
			getApplicationEventMulticaster().multicastEvent(applicationEvent, eventType);
		}

		// 通过父类上下文发布事件。
		if (this.parent != null) {
			if (this.parent instanceof AbstractApplicationContext) {
				((AbstractApplicationContext) this.parent).publishEvent(event, eventType);
			}
			else {
				this.parent.publishEvent(event);
			}
		}
	}
	
	.....
}

源码分析ApplicationEventMulticaster#multicastEvent(ApplicationEvent, ResolvableType)

// 该类是ApplicationEventMulticaster 一个实现，说明事件不一定是单线程执行。
public class SimpleApplicationEventMulticaster extends AbstractApplicationEventMulticaster {

	@Nullable
	private Executor taskExecutor;
    ...
    
    @Override
	public void multicastEvent(final ApplicationEvent event, @Nullable ResolvableType eventType) {
		ResolvableType type = (eventType != null ? 
                               eventType : resolveDefaultEventType(event));
        // 判断是否能够获取 Executor
		 Executor executor = getTaskExecutor();
		for (ApplicationListener<?> listener : getApplicationListeners(event, type)) {
            // 如果执行器不为空，就使用多线程执行
			if (executor != null) {
				executor.execute(() -> invokeListener(listener, event));
			}
			else {
                // 否则使用单线程执行
				invokeListener(listener, event);
			}
		}
	}
    
    ...    
        
}

上下文容器监听事件

// springboot 内容
@EnableAutoConfiguration
public class SpringBootEventDemo {

    public static void main(String[] args) {
        new SpringApplicationBuilder(SpringBootEventDemo.class)
                .listeners(event -> { // 增加监听器
                    System.err.println("监听到事件 ： " + event.getClass().getSimpleName());
                })
                .run(args)
                .close();
        ; // 运行
    }
}

ssm 框架整合中在web.xml 中通过Tomcat在启动时触发ContextLoaderListener 启动容器。

<!-- Spring监听器 -->
    <listener>
        <listener-class>
              org.springframework.web.context.ContextLoaderListener
        </listener-class>
    </listener>

public void contextInitialized(ServletContextEvent event) {
   this.initWebApplicationContext(event.getServletContext()); // 启动容器
}

容器调用事件流程

refresh() -> finishRefresh() -> publishEvent(new ContextRefreshedEvent(this));
发送 Spring 事件通过

ApplicationEventMulticaster#multicastEvent(ApplicationEvent, ResolvableType)
Spring 事件的类型 ApplicationEvent

Spring 事件监听器 ApplicationListener

Spring 事件广播器 ApplicationEventMulticaster
- 实现类：SimpleApplicationEventMulticaster
自定义事件都是PayloadApplicationEvent
事件不一定是单线程执行。

关注我，一起学习Java.
在这里插入图片描述

huang__2

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
JAVA事件监听机制和 Spring 事件机制

JAVA事件监听机制和 Spring 事件机制JAVA事件监听机制 Java 事件处理采用的是面向对象方法，所有的事件都是由 java.util包中的EventObject类扩展而来的（公共超类不是 Event , 它是旧事件模型中的事件类名。尽管现在不赞成使用旧的事件模型，但这些类仍然保留在Java 库中 )。事件对象封装了事件源与监听器彼...
复制链接

扫一扫