背景
最近公司的客户要求，分配给员工的任务除了有微信通知外，还希望pc端的网页也能实时收到通知。管理员分配任务是在我们的系统a,而员工接受任务是在系统b。两个系统都是现在已投入使用的系统。
技术选型
根据需求我们最终选用springaop+rabbitmq+websocket。
springaop可以让我们不修改原有代码，直接将原有service作为切点，加入切面。rabbitmq可以让a系统和b系统解耦。websocket则可以达到实时通知的要求。
springaop
aop称为面向切面编程，在程序开发中主要用来解决一些系统层面上的问题，比如日志，事务，权限等待。是spring的核心模块，底层是通过动态代理来实现（动态代理将在之后的文章重点介绍）。
基本概念
aspect(切面)：通常是一个类，里面可以定义切入点和通知。
jointpoint(连接点)：程序执行过程中明确的点，一般是方法的调用。
advice(通知)：aop在特定的切入点上执行的增强处理，有before,after,afterreturning,afterthrowing,around。
pointcut(切入点)：就是带有通知的连接点，在程序中主要体现为书写切入点表达式。
通知类型
before：在目标方法被调用之前做增强处理。
@before只需要指定切入点表达式即可
afterreturning：在目标方法正常完成后做增强。
@afterreturning除了指定切入点表达式后，还可以指定一个返回值形参名returning,代表目标方法的返回值
afterthrowing：主要用来处理程序中未处理的异常。
@afterthrowing除了指定切入点表达式后，还可以指定一个throwing的返回值形参名,可以通过该形参名
来访问目标方法中所抛出的异常对象
after：在目标方法完成之后做增强，无论目标方法时候成功完成。
@after可以指定一个切入点表达式
around：环绕通知,在目标方法完成前后做增强处理,环绕通知是最重要的通知类型,像事务,日志等都是环绕通知,注意编程中核心是一个proceedingjoinpoint。
rabbitmq
从图中我们可以看到rabbitmq主要的结构有：routing、binding、exchange、queue。
queue
queue（队列）rabbitmq的作用是存储消息，队列的特性是先进先出。
exchange
生产者产生的消息并不是直接发送给消息队列queue的，而是要经过exchange（交换器），由exchange再将消息路由到一个或多个queue，还会将不符合路由规则的消息丢弃。
routing
用于标记或生产者寻找exchange。
binding
用于exchange和queue做关联。
exchange type fanout
fanout类型的exchange路由规则非常简单，它会把所有发送到该exchange的消息路由到所有与它绑定的queue中。
direct
direct会把消息路由到那些binding key与routing key完全匹配的queue中。
topic
direct规则是严格意义上的匹配，换言之routing key必须与binding key相匹配的时候才将消息传送给queue，那么topic这个规则就是模糊匹配，可以通过通配符满足一部分规则就可以传送。
headers
headers类型的exchange不依赖于routing key与binding key的匹配规则来路由消息，而是根据发送的消息内容中的headers属性进行匹配。
websocket
了解websocket必须先知道几个常用的web通信技术及其区别。
短轮询
短轮询的基本思路就是浏览器每隔一段时间向浏览器发送http请求，服务器端在收到请求后，不论是否有数据更新，都直接进行响应。这种方式实现的即时通信，本质上还是浏览器发送请求，服务器接受请求的一个过程，通过让客户端不断的进行请求，使得客户端能够模拟实时地收到服务器端的数据的变化。
这种方式的优点是比较简单，易于理解，实现起来也没有什么技术难点。缺点是显而易见的，这种方式由于需要不断的建立http连接，严重浪费了服务器端和客户端的资源。尤其是在客户端，距离来说，如果有数量级想对比较大的人同时位于基于短轮询的应用中，那么每一个用户的客户端都会疯狂的向服务器端发送http请求，而且不会间断。人数越多，服务器端压力越大，这是很不合理的。
因此短轮询不适用于那些同时在线用户数量比较大，并且很注重性能的web应用。
长轮询/ comet
comet指的是，当服务器收到客户端发来的请求后，不会直接进行响应，而是先将这个请求挂起，然后判断服务器端数据是否有更新。如果有更新，则进行响应，如果一直没有数据，则到达一定的时间限制(服务器端设置)后关闭连接。
长轮询和短轮询比起来，明显减少了很多不必要的http请求次数，相比之下节约了资源。长轮询的缺点在于，连接挂起也会导致资源的浪费。
sse
sse是html5新增的功能，全称为server-sent events。它可以允许服务推送数据到客户端。sse在本质上就与之前的长轮询、短轮询不同，虽然都是基于http协议的，但是轮询需要客户端先发送请求。而sse最大的特点就是不需要客户端发送请求，可以实现只要服务器端数据有更新，就可以马上发送到客户端。
sse的优势很明显，它不需要建立或保持大量的客户端发往服务器端的请求，节约了很多资源，提升应用性能。并且sse的实现非常简单，不需要依赖其他插件。
websocket
websocket是html5定义的一个新协议，与传统的http协议不同，该协议可以实现服务器与客户端之间全双工通信。简单来说，首先需要在客户端和服务器端建立起一个连接，这部分需要http。连接一旦建立，客户端和服务器端就处于平等的地位，可以相互发送数据，不存在请求和响应的区别。
websocket的优点是实现了双向通信，缺点是服务器端的逻辑非常复杂。现在针对不同的后台语言有不同的插件可以使用。
四种web即时通信技术比较
从兼容性角度考虑，短轮询>长轮询>长连接sse>websocket；
从性能方面考虑，websocket>长连接sse>长轮询>短轮询。
实战
项目使用springboot搭建。rabbitmq的安装这里不讲述。
rabbitmq配置
两个系统a、b都需要操作rabbitmq，其中a生产消息，b消费消息。故都需要配置。
1、首先引入rabbitmq的dependency：
|
1
2
3
4
|
<dependency> <groupid>org.springframework.boot</groupid> <artifactid>spring-boot-starter-amqp</artifactid></dependency> |
这个dependency中包含了rabbitmq相关dependency。
2、在项目的配置文件里配置为使用rabbitmq及其参数。
application-pro.yml
|
1
2
3
4
5
6
7
8
|
#消息队列message.queue.type: rabbitmq## rabbit mq propertiesrabbitmq: host: localhost port: 5672 username: guest password: guest |
application.properties
|
1
2
|
#将要使用的队列名rabbitmq.websocket.msg.queue=websocket_msg_queue |
3、创建配置文件。队列的创建交给spring。
rabbitmqconfig.java
|
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
|
@configuration@enablerabbitpublic class rabbitmqconfig { @value("${rabbitmq.host}") private string host; @value("${rabbitmq.port}") private string port; @value("${rabbitmq.username}") private string username; @value("${rabbitmq.password}") private string password; @value("${rabbitmq.websocket.msg.queue}") private string websocketmsgqueue; @bean public connectionfactory connectionfactory() throws ioexception { cachingconnectionfactory factory = new cachingconnectionfactory(); factory.setusername(username); factory.setpassword(password);// factory.setvirtualhost("test"); factory.sethost(host); factory.setport(integer.valueof(port)); factory.setpublisherconfirms(true); //设置队列参数，是否持久化、队列ttl、队列消息ttl等 factory.createconnection().createchannel(false).queuedeclare(websocketmsgqueue, true, false, false, null); return factory; } @bean public messageconverter messageconverter() { return new jackson2jsonmessageconverter(); } @bean @scope(configurablebeanfactory.scope_prototype) // 必须是prototype类型 public rabbittemplate rabbittemplate() throws ioexception { return new rabbittemplate(connectionfactory()); } @bean public simplerabbitlistenercontainerfactory rabbitlistenercontainerfactory() throws ioexception { simplerabbitlistenercontainerfactory factory = new simplerabbitlistenercontainerfactory(); factory.setconnectionfactory(connectionfactory()); factory.setconcurrentconsumers(3); factory.setmaxconcurrentconsumers(10); factory.setacknowledgemode(acknowledgemode.manual); return factory; }} |
4、系统b中创建队列监听，当队列有消息时，发送websocket通知。
rabbitmqlistener.java
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
|
@componentpublic class rabbitmqlistener { @autowired private rabbitmqservice mqservice; /** * websocket推送监听器 * @param socketentity * @param deliverytag * @param channel */ @rabbitlistener(queues = "websocket_msg_queue") public void websocketmsglistener(@payload websocketmsgentity socketmsgentity, @header(amqpheaders.delivery_tag) long deliverytag, channel channel) throws ioexception { mqservice.handlewebsocketmsg(socketmsgentity, deliverytag, channel); }} |
rabbitmqservice.java
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
|
public class rabbitmqservice { @autowired private messagewebsockethandler messagewebsockethandler; /** * @param socketmsgentity * @param deliverytag * @param channel * @throws ioexception */ void handlewebsocketmsg(websocketmsgentity socketmsgentity, long deliverytag, channel channel) throws ioexception { try { messagewebsockethandler.sendmessagetousers(socketmsgentity.tojsonstring(), socketmsgentity.gettouserids()); channel.basicack(deliverytag, false); } catch (exception e) { channel.basicnack(deliverytag, false, false); } }} |
websocketmsgentity为mq中传送的实体。
|
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
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
|
public class websocketmsgentity implements serializable { public enum ordertype{ repair("维修"), maintain("保养"), measure("计量"); ordertype(string value){ this.value = value; } string value; public string getvalue() { return value; } } //设备名称 private string equname; //设备编号 private string equid; //工单类型 private ordertype ordertype; //工单单号 private string orderid; //工单状态 private string orderstatus; //创建时间 private date createtime; //消息接收人id private list<string> touserids; public string getequname() { return equname; } public void setequname(string equname) { equname = equname; } public string getorderid() { return orderid; } public void setorderid(string orderid) { this.orderid = orderid; } public string getequid() { return equid; } public void setequid(string equid) { equid = equid; } public string getorderstatus() { return orderstatus; } public void setorderstatus(string orderstatus) { this.orderstatus = orderstatus; } public ordertype getordertype() { return ordertype; } public void setordertype(ordertype ordertype) { this.ordertype = ordertype; } public date getcreatetime() { return createtime; } public void setcreatetime(date createtime) { this.createtime = createtime; } public list<string> gettouserids() { return touserids; } public void settouserids(list<string> touserids) { this.touserids = touserids; } public string tojsonstring(){ return json.tojsonstring(this); }} |
springaop
1、系统a中创建一个切面类datainterceptor.java
|
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
|
@aspect@componentpublic class datainterceptor { @autowired private messagequeueservice queueservice; //维修工单切点 @pointcut("execution(* com.zhishang.hes.common.service.impl.repairserviceimpl.executeflow(..))") private void repairmsg() { } /** * 返回通知，方法执行正常返回时触发 * * @param joinpoint * @param result */ @afterreturning(value = "repairmsg()", returning = "result") public void afterreturning(joinpoint joinpoint, object result) { //此处可以获得切点方法名 //string methodname = joinpoint.getsignature().getname(); equipmentrepair equipmentrepair = (equipmentrepair) result; websocketmsgentity websocketmsgentity = this.generaterepairmsgentity(equipmentrepair); if (websocketmsgentity == null) { return; } queueservice.send(websocketmsgentity); } /** * 生成发送到mq的维修消息 * * @param equipmentrepair * @return */ private websocketmsgentity generaterepairmsgentity(equipmentrepair equipmentrepair) { websocketmsgentity websocketmsgentity = generaterepairmsgfromtasks(equipmentrepair); return websocketmsgentity; } /** * 从任务中生成消息 * * @param equipmentrepair * @return */ private websocketmsgentity generaterepairmsgfromtasks(equipmentrepair equipmentrepair) { //业务代码略 }} |
2、发送消息到mq。这里只贴了发送的核心代码
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
public class rabbitmessagequeue extends abstractmessagequeue { @value("${rabbitmq.websocket.msg.queue}") private string websocketmsgqueue; @autowired private rabbittemplate rabbittemplate; @override public void send(websocketmsgentity entity) { //没有指定exchange，则使用默认名为“”的exchange，binding名与queue名相同 rabbittemplate.convertandsend(websocketmsgqueue, entity); }} |
websocket
1、 系统b中引入websocket服务端dependency
|
1
2
3
4
5
|
<dependency> <groupid>org.springframework</groupid> <artifactid>spring-websocket</artifactid> <version>4.3.10.release</version></dependency> |
2、 配置websocket，添加处理类
websocketconfigurer.java
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
|
@configuration@enablewebsocketpublic class websocketconfig extends webmvcconfigureradapter implements websocketconfigurer { private static logger logger = loggerfactory.getlogger(websocketconfig.class); @override public void registerwebsockethandlers(websockethandlerregistry registry) { //配置websocket路径 registry.addhandler(messagewebsockethandler(),"/msg-websocket").addinterceptors(new myhandshakeinterceptor()).setallowedorigins("*"); //配置websocket路径 支持前端使用socketjs registry.addhandler(messagewebsockethandler(), "/sockjs/msg-websocket").setallowedorigins("*").addinterceptors(new myhandshakeinterceptor()).withsockjs(); } @bean public messagewebsockethandler messagewebsockethandler() { logger.info("......创建messagewebsockethandler......"); return new messagewebsockethandler(); }} |
messagewebsockethandler.java 主要用于websocket连接及消息发送处理。配置中还使用了连接握手时的处理，主要是取用户登陆信息，这里不多讲述。
|
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
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
|
public class messagewebsockethandler extends textwebsockethandler { private static logger logger = loggerfactory.getlogger(systemwebsockethandler.class); private static concurrenthashmap<string, copyonwritearrayset<websocketsession>> users = new concurrenthashmap<>(); @override public void afterconnectionestablished(websocketsession session) throws exception { string userid = session.getattributes().get("websocket_userid").tostring(); logger.info("......afterconnectionestablished......"); logger.info("session.getid:" + session.getid()); logger.info("session.getlocaladdress:" + session.getlocaladdress().tostring()); logger.info("userid:" + userid); //websocket连接后记录连接信息 if (users.keyset().contains(userid)) { copyonwritearrayset<websocketsession> websocketsessions = users.get(userid); websocketsessions.add(session); } else { copyonwritearrayset<websocketsession> websocketsessions = new copyonwritearrayset<>(); websocketsessions.add(session); users.put(userid, websocketsessions); } } @override public void handletransporterror(websocketsession session, throwable throwable) throws exception { removeusersession(session); if (session.isopen()) { session.close(); } logger.info("异常出现handletransporterror" + throwable.getmessage()); } @override public void afterconnectionclosed(websocketsession session, closestatus closestatus) throws exception { removeusersession(session); logger.info("关闭afterconnectionclosed" + closestatus.getreason()); } @override public boolean supportspartialmessages() { return false; } /** * 给符合要求的在线用户发送消息 * * @param message */ public void sendmessagetousers(string message, list<string> userids) throws ioexception{ if (stringutils.isempty(message) || collectionutils.isempty(userids)) { return; } if (users.isempty()) { return; } for (string userid : userids) { if (!users.keyset().contains(userid)) { continue; } copyonwritearrayset<websocketsession> websocketsessions = users.get(userid); if (websocketsessions == null) { continue; } for (websocketsession websocketsession : websocketsessions) { if (websocketsession.isopen()) { try { websocketsession.sendmessage(new textmessage(message)); } catch (ioexception e) { logger.error(" websocket server send message error " + e.getmessage()); try { throw e; } catch (ioexception e1) { e1.printstacktrace(); } } } } } } /** * websocket清除连接信息 * * @param session */ private void removeusersession(websocketsession session) { string userid = session.getattributes().get("websocket_userid").tostring(); if (users.keyset().contains(userid)) { copyonwritearrayset<websocketsession> websocketsessions = users.get(userid); websocketsessions.remove(session); if (websocketsessions.isempty()) { users.remove(userid); } } }} |
整个功能完成后，a系统分配任务时，系统b登陆用户收到的消息如图：
总体流程：
1、对于系统b，每个登陆的用户都会和服务器建立websocket长连接。
2、系统a生成任务，aop做出响应，将封装的消息发送给mq。
3、系统b中的mq监听发现队列有消息到达，消费消息。
4、系统b通过websocket长连接将消息发给指定的登陆用户。
以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持服务器之家。
原文链接：http://www.cnblogs.com/little-sheep/p/9934887.html
