引言
最近在看tomcat源码,源码中出现了大量事件消息,可以说整个tomcat的启动流程都可以通过事件派发机制串起来,研究透了tomcat的各种事件消息,基本上对tomcat的启动流程也就有了一个整体的认识。在这一基础上,联想到之前在看spring源码过程中也存在不少事件相关知识,于是想对这两个框架中的事件派发机制做一个简单的总结,加深理解。
事件机制原理其实比较简单,抽象来看的话,设计模式中的观察者模式可以说是最经典的事件驱动机制的体现了,观察者和被观察者就体现了事件监听和事件派发的角色。还有各种mq,其实也是事件机制的一种体现。
理解tomcat和spring中的事件机制之前,让我们先从最基本的jdk中提供的事件机制开始说起。
jdk中的事件机制
jdk中对事件机制的各个角色提供了完善的抽象,主要包括3个角色:
eventobject(事件关注内容):事件发布时需要关注的内容。jdk中提供了eventobject接口。
eventlistener(事件监听者):事件监听对象,也就是对eventobject感兴趣的对象。jdk中提供了eventlistener接口。
eventsource(事件源):发布事件的对象,可以在该对象中组册eventlistener,然后在特定的条件下发布eventobject给已经注册的eventlistener。
事件的注册与发布,需要这三个对象协同工作,可以通过下面的例子来说明各个对象的作用:
首先是事件关注内容对象myeventobject,实现了eventobject接口。eventname参数为具体的事件关注内容
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
|
public class myeventobject extends eventobject { private string eventname ; public myeventobject (object source, string eventname) { super (source); this .seteventname(eventname); } public string geteventname() { return eventname; } public void seteventname(string eventname) { this .eventname = eventname; } private static final long serialversionuid = 8374250957018011175l; } |
其次是事件监听接口myeventlistener,继承了eventlistener,定义了一个myevent接口用来发布事件,任何感兴趣的监听对象都可以实现该接口来监听。
对myeventobject感兴趣的监听者myeventlistenerimpl,实现了myeventlistener接口,当事件发布时会触发myevent事件并收到myeventobject对象。
1
2
3
4
5
6
7
8
9
10
11
12
13
|
public interface myeventlistener extends eventlistener { public void myevent(myeventobject eventobject); } public class myeventlistenerimpl implements myeventlistener { @override public void myevent(myeventobject eventobject) { system.out.println( "myeventlistenerimpl --- " + eventobject.geteventname()); } } |
最后是事件发布源对象myeventsource,它可以注册多个事件监听对象,任何实现了myeventlistener接口的监听对象都可以注册,内部通过一个set来存储感兴趣的监听对象,并在合适的时机会发布消息并通知所有监听对象。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
|
public class myeventsource { private set<myeventlistener> myeventlisteners = new hashset<>(); public void addlistener(myeventlistener listener){ this .myeventlisteners.add(listener); } public void removelistener(myeventlistener listener){ this .myeventlisteners.remove(listener); } public void pushevent(){ //dosomething //发布push event消息 notifylistener( new myeventobject( this , "push event" )); } private void notifylistener(myeventobject eventobject){ for (myeventlistener myeventlistener : myeventlisteners) { myeventlistener.myevent(eventobject); } } } |
之后可以通过一个启动类来注册并触发事件:
1
2
3
4
5
6
7
8
9
10
|
public static void main(string[] args) { myeventsource myeventsource = new myeventsource(); myeventlistenerimpl myeventlistenerimpl = new myeventlistenerimpl(); myeventsource.addlistener(myeventlistenerimpl); myeventsource.pushevent(); } |
myeventobject定义了感兴趣的内容,myeventlistenerimpl是对myeventobject感兴趣的监听者,myeventsource会发布myeventobject给所有组册的监听者,最后通过一个main来启动整个流程。
明白了jdk中对事件机制的定义,再来看看tomcat和spring中的事件机制。
tomcat的事件机制
tomcat的事件机制也离不开eventobject、eventlistener以及eventsource三个对象,只不过在此基础上提供了更加抽象和便捷的操作。这里我挑选tomcat的生命周期接口对象lifecycle来讲解整个事件发布流程:
首先还是eventobject对象lifecycleevent,这里只列出了核心代码。它的主要参数是lifecycle,lifecycle中定义了tomcat各个阶段的名称:before_init、after_init、start等等,是事件监听者感兴趣的对象。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
|
public final class lifecycleevent extends eventobject { //...... public lifecycleevent(lifecycle lifecycle, string type, object data) { super (lifecycle); this .type = type; this .data = data; } //...... } public interface lifecycle { /** * the lifecycleevent type for the "component after init" event. */ public static final string before_init_event = "before_init" ; /** * the lifecycleevent type for the "component after init" event. */ public static final string after_init_event = "after_init" ; /** * the lifecycleevent type for the "component start" event. */ public static final string start_event = "start" ; //...... } |
事件监听接口lifecyclelistener,定义了lifecycleevent方法用来传递监听者感兴趣的lifecycleevent对象,监听者使用lifecycleevent参数用来在tomcat的各个阶段处理进行相应处理。这些感兴趣的对象包括下面这些类:
这里使用contextconfig类为例,可以看到它实现了lifecyclelistener接口。这个类在解析server.xml的时候用来监听standardcontext的各个阶段的事件,并做出相应处理:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
|
public interface lifecyclelistener { public void lifecycleevent(lifecycleevent event); } public class contextconfig implements lifecyclelistener { //...... @override public void lifecycleevent(lifecycleevent event) { // identify the context we are associated with try { context = (context) event.getlifecycle(); } catch (classcastexception e) { log.error(sm.getstring( "contextconfig.cce" , event.getlifecycle()), e); return ; } // process the event that has occurred if (event.gettype().equals(lifecycle.configure_start_event)) { configurestart(); } else if (event.gettype().equals(lifecycle.before_start_event)) { beforestart(); } else if (event.gettype().equals(lifecycle.after_start_event)) { // restore docbase for management tools if (originaldocbase != null ) { context.setdocbase(originaldocbase); } } else if (event.gettype().equals(lifecycle.configure_stop_event)) { configurestop(); } else if (event.gettype().equals(lifecycle.after_init_event)) { init(); } else if (event.gettype().equals(lifecycle.after_destroy_event)) { destroy(); } } //...... } |
lifecyclesupport是我们需要了解的主要对象,它是监听对象的一个管理类,原理其实和上面的例子差不多,对应了myeventsource类的部分功能,方便eventsource类来管理监听对象。它把对监听对象的添加移除以及发布事件几个操作进行了统一管理,避免eventsource类中出现太多管理监听对象的逻辑。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
|
public final class lifecyclesupport { //...... //监听对象集合 private lifecyclelistener listeners[] = new lifecyclelistener[ 0 ]; private final object listenerslock = new object(); // lock object for changes to listeners //添加监听对象 public void addlifecyclelistener(lifecyclelistener listener) { synchronized (listenerslock) { lifecyclelistener results[] = new lifecyclelistener[listeners.length + 1 ]; for ( int i = 0 ; i < listeners.length; i++) results[i] = listeners[i]; results[listeners.length] = listener; listeners = results; } } //发布监听对象 public void firelifecycleevent(string type, object data) { lifecycleevent event = new lifecycleevent(lifecycle, type, data); lifecyclelistener interested[] = listeners; for ( int i = 0 ; i < interested.length; i++) interested[i].lifecycleevent(event); } //移除监听对象 public void removelifecyclelistener(lifecyclelistener listener) { synchronized (listenerslock) { int n = - 1 ; for ( int i = 0 ; i < listeners.length; i++) { if (listeners[i] == listener) { n = i; break ; } } if (n < 0 ) return ; lifecyclelistener results[] = new lifecyclelistener[listeners.length - 1 ]; int j = 0 ; for ( int i = 0 ; i < listeners.length; i++) { if (i != n) results[j++] = listeners[i]; } listeners = results; } } } |
使用了lifecyclesupport之后,操作lifecyclelistener就简单多了,只需要调用lifecyclesupport的各个方法就可以了:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
|
public abstract class lifecyclebase implements lifecycle{ //...... private lifecyclesupport lifecycle = new lifecyclesupport( this ); @override public void addlifecyclelistener(lifecyclelistener listener) { lifecycle.addlifecyclelistener(listener); } @override public void removelifecyclelistener(lifecyclelistener listener) { lifecycle.removelifecyclelistener(listener); } protected void firelifecycleevent(string type, object data) { lifecycle.firelifecycleevent(type, data); } //...... } |
在需要发布事件时调用firelifecycleevent方法就可以发布事件:
1
|
firelifecycleevent(lifecycle.configure_stop_event, null ); |
tomcat事件机制就是在之前的例子上抽出了一个lifecyclesupport类来方便管理监听对象的各种操作,这是一个可以借鉴的地方,其他差别并不大。再来看看spring中对事件机制的处理。
spring的事件机制
spring中的事件机制原理也是一样的,只是相对来说实现上稍微复杂一点。还是通过相同的角度来看这个问题。
首先是eventobject,spring里面的主要实现是applicationevent:
这里通过contextstartedevent类来查看eventobject,它关注的对象是applicationcontext,是spring容器在启动时触发的事件对象:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
|
public abstract class applicationevent extends eventobject { //...... public applicationevent(object source) { super (source); this .timestamp = system.currenttimemillis(); } //...... } public abstract class applicationcontextevent extends applicationevent { public applicationcontextevent(applicationcontext source) { super (source); } public final applicationcontext getapplicationcontext() { return (applicationcontext) this .getsource(); } } public class contextstartedevent extends applicationcontextevent { public contextstartedevent(applicationcontext source) { super (source); } } |
事件监听接口applicationlistener,定义了onapplicationevent方法用来传递监听者感兴趣的applicationevent对象,监听者使用applicationevent参数用来在context的各个阶段处理进行相应处理。
如果我们需要在容器启动后进行相应处理,那么我们可以在业务类中实现applicationlistener接口,在事件发生时就会发起通知:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
|
public interface applicationlistener<e extends applicationevent> extends eventlistener { void onapplicationevent(e event); } public class myapplicationlistener implements applicationlistener<applicationevent> { @override public void onapplicationevent(applicationevent applicationevent) { if (applicationevent instanceof contextrefreshedevent){ system.out.println( "context refresh!" ); } } } |
那么在spring框架中是怎么发布这些事件的呢?是不是也有一个类似tomcat中lifecyclesupport一样的类呢?通过查看源码可以发现发现,applicationcontext容器在初始化阶段会调用refresh()方法,这其中又调用了
finishrefresh()方法,这其中调用了publishevent(new contextrefreshedevent(this))方法,发布了contextrefreshedevent这一对象。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
|
protected void finishrefresh() { //...... // publish the final event. publishevent( new contextrefreshedevent( this )); } protected void publishevent(object event, @nullable resolvabletype eventtype) { //...... getapplicationeventmulticaster().multicastevent(applicationevent, eventtype); //...... } publishevent方法通过调用一个默认的多播器simpleapplicationeventmulticaster的multicastevent方法来发布各种事件: simpleapplicationeventmulticaster public void multicastevent( final applicationevent event, @nullable resolvabletype eventtype) { resolvabletype type = (eventtype != null ? eventtype : resolvedefaulteventtype(event)); //通过getapplicationlisteners获取了所有监听器,然后通过invokelistener方法循环发布事件 for ( final applicationlistener<?> listener : getapplicationlisteners(event, type)) { executor executor = gettaskexecutor(); if (executor != null ) { executor.execute(() -> invokelistener(listener, event)); } else { invokelistener(listener, event); } } } protected void invokelistener(applicationlistener<?> listener, applicationevent event) { //...... doinvokelistener(listener, event); } private void doinvokelistener(applicationlistener listener, applicationevent event) { //...... listener.onapplicationevent(event); } |
也就是说在spring容器中发布applicationlistener所关注的对象是通过simpleapplicationeventmulticaster这个类来管理的,和tomcat中lifecyclesupport的功能类似,只是在实现上有略微差别。
最后提一句,在spring中你也可以自己发布各种事件,调用applicationcontext的publishevent方法即可。
1
|
applicationcontext.publishevent( new applicationevent( new string( "事件发布" )) { }); |
总结
这篇文章对java的事件机制在tomcat以及spring框架中的实现做了一个简单总结和对比,你需要知道以下几点:
- jdk中定义了eventobject和eventlistener两个接口,奠定了事件机制的基础。
- tomcat额外提供了一个support类来对监听器的添加删除以及发布进行管理。
- spring容器内部通过simpleapplicationeventmulticaster来发布各个事件,用户可以通过实现applicationlistener接口来监听自己感兴趣的容器事件。
希望你通过这篇文章的学习可以对java的事件机制有一个更深刻的认识,在实现自己的事件机制时有可以借鉴以及改进的地方。
好了,以上就是这篇文章的全部内容了,希望本文的内容对大家的学习或者工作具有一定的参考学习价值,如果有疑问大家可以留言交流,谢谢大家对服务器之家的支持。
原文链接:http://www.cnblogs.com/konck/p/10134541.html