websocket 与 jmx和jms 协作工作来管理web项目

最新推荐文章于 2022-06-07 16:11:31 发布
最新推荐文章于 2022-06-07 16:11:31 发布
阅读量2.7k 收藏
点赞数 1
文章标签： websocket jms jmx
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xy18930914/article/details/51210967
版权

MX4J是一个开源JMX管理框架，支持JSR3 (JMX) 和JSR160 (JMX Remote API)。通过spring将MX4J集成到我们的应用系统中，可以通过HTTP协议适配，能够基于Web的方式来实现对应用系统的监控和管理。这里，使用的版本分别为：

  • Spring 2.5

  • MX4J 3.0.2

MX4J对应的几个JAR文件，加入到CLASSPATH：

  • mx4j.jar
  • mx4j-impl.jar
  • mx4j-jmx.jar
  • mx4j-remote.jar
  • mx4j-rimpl.jar
  • mx4j-rjmx.jar
  • mx4j-tools.jar

首先，给出Spring的完整配置，server.xml 配置文件如下所示：

<?xml version="1.0" encoding="UTF-8" ?>

<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:util="http://www.springframework.org/schema/util"
	xsi:schemaLocation="http://www.springframework.org/schema/beans
  http://www.springframework.org/schema/beans/spring-beans.xsd
  http://www.springframework.org/schema/util
  http://www.springframework.org/schema/util/spring-util-2.5.xsd">


<bean id="carrierConfig" class="entity.Carrier" />

 <bean id="exporter" class="org.springframework.jmx.export.MBeanExporter">
	<property name="assembler" ref="assembler" />
	<property name="beans">
		<map>
			<entry key="mx4jServer:name=HttpAdaptor" value-ref="httpAdaptor"/>
			<entry key="beanEntity:name=carrierMBeanManager" value-ref="carrierConfig"/>
		</map>
	</property>
	<property name="server" ref="mbeanServer" />
</bean>

<bean id="jmxAttributeSource" class="org.springframework.jmx.export.annotation.AnnotationJmxAttributeSource" />

<bean id="assembler" class="org.springframework.jmx.export.assembler.MetadataMBeanInfoAssembler">
	<property name="attributeSource" ref="jmxAttributeSource" />
</bean>

<!--  <bean id="assembler"  class="org.springframework.jmx.export.assembler.InterfaceBasedMBeanInfoAssembler">   -->
<!--         <property name="managedInterfaces">   -->
<!--             <list>   -->
<!--                 <value>entity.SelectedMethodsInterface</value>   -->
<!--             </list>   -->
<!--        </property>   -->
<!--  </bean>   -->

<bean id="mbeanServer" class="org.springframework.jmx.support.MBeanServerFactoryBean"/>

<bean id="httpAdaptor" class="mx4j.tools.adaptor.http.HttpAdaptor">
	<property name="processor">
		<bean id="xsltProcessor" class="mx4j.tools.adaptor.http.XSLTProcessor" />
	</property>
	<property name="port" value="8089"/> 
	<property name="host" value="localhost"/> 
</bean>

</beans>


上面配置中，比较核心的是MX4J的HTTP适配器类：mx4j.tools.adaptor.http.HttpAdaptor，它有一个processor属性，使用MX4J已经实现的mx4j.tools.adaptor.http.XSLTProcessor来对其注入。XSLTProcessor实现了MX4J定义的XML转换成为浏览器可以解析的格式的文档，就Web网页。

Spring配置中通过实例化一个HttpAdaptor，注册到MBean Server中，实现基于HTTP协议远程访问管理和监控。org.shirdrn.jmx.mx4j.MyConfiguration我们定义的一个MBean，也注册到MBean Server中，实现JMX的管理与监控，代码如下所示： 

package entity;

import java.io.IOException;
import java.io.Serializable;
import java.nio.CharBuffer;
import java.util.HashMap;
import java.util.Map;

import org.springframework.jmx.export.annotation.ManagedOperation;
import org.springframework.jmx.export.annotation.ManagedOperationParameter;
import org.springframework.jmx.export.annotation.ManagedOperationParameters;
import org.springframework.jmx.export.annotation.ManagedResource;

import utils.StartServerService;
import webSocket.MyWebSocketBound;



@ManagedResource(objectName = "bean:name=CarrierMBean")
public class Carrier implements Serializable{
	
	private static final long serialVersionUID = -1490071251860434130L;
	
	
	private Long carrierId;
 	private String carrierName;
 	private String serialNumber;
 	private String status;
 	private static Map<Integer,Carrier> map = new HashMap<Integer,Carrier>();
 	
 	
 	public Carrier(){
 		super();
 	}
 	
 	 public Carrier(long carrierId,String carrierName,String serialNumber,String status){
 		 this.carrierId = carrierId;
 		 this.carrierName = carrierName;
 		 this.serialNumber = serialNumber;
 		 this.status = status;
 	 }
 	
 	
 	/**
	 * 
	 * @param carrierName
	 * @param serialNumber
	 * @param status
	 */
     @ManagedOperation(description = "To set carrierInfor ")
 	 @ManagedOperationParameters({
 	 @ManagedOperationParameter(name = "carrierId", description = "The carrier carrierId"),
 	 @ManagedOperationParameter(name = "carrierName", description = "The carrier carrierName"),
 	 @ManagedOperationParameter(name = "serialNumber", description = "The carrier serialNumber"),
 	 @ManagedOperationParameter(name = "status", description = "The carrier status")})
    	public void setCarrierInfor(long carrierId,String carrierName,String serialNumber,String status) {
    		this.carrierId = carrierId;
    		this.carrierName = carrierName;
    		this.serialNumber = serialNumber;
    		this.status = status;
    	}
 	 
 	 /**
 	  * 显示信息
 	  * @return
 	  */
    @ManagedOperation(description = "To show carrier ")
	public String show() {
	 StringBuffer sb = new StringBuffer().append("carrierId=").append(carrierId).append(  
                ", carrierName=").append(carrierName).append(",serialNumber=").append(serialNumber)
                .append(",status=").append(status);  
        return sb.toString();  
	}
    
    
    /**
  	  * 发送信息，通过webSocket中间件
  	  */
  	 @ManagedOperation(description = "To send carrierInfor ")
	 @ManagedOperationParameters({
	 @ManagedOperationParameter(name = "carrierId", description = "The carrier carrierId"),
	 @ManagedOperationParameter(name = "carrierName", description = "The carrier carrierName"),
	 @ManagedOperationParameter(name = "serialNumber", description = "The carrier serialNumber"),
	 @ManagedOperationParameter(name = "status", description = "The carrier status")})
  	 public void sendMessage(long carrierId,String carrierName,String serialNumber,String status){
//  	String str = URLDecoder.decode(serialNumber, "UTF-8");
  		 
  		StringBuffer sb = new StringBuffer();
  		MyWebSocketBound test = new MyWebSocketBound();
  		map =  StartServerService.getCarrierMap();
  		for(int i = 1;i<= map.size();i++){
  			Carrier entity = map.get(i);
  			if(entity.getCarrierId() == carrierId){
  				entity.setCarrierId(carrierId);
  				if(!"".equals(carrierName) && null != carrierName){
  					entity.setCarrierName(carrierName);
  				}
  				if(!"".equals(serialNumber) && null != serialNumber){
  					entity.setSerialNumber(serialNumber);
  				}
  				if(!"".equals(status) && null != status){
  					entity.setStatus(status);
  				}
  				System.out.println("服务端修改信息"+carrierId+"的信息为："+entity);
   			}
  			sb.append(entity.toString());
  		}
  		 String sbTest = sb.toString().substring(0, sb.toString().length() - 1);
  	     CharBuffer buffer = CharBuffer.wrap(sbTest); 
  		try {
  			test.onTextMessage(buffer);
		} catch (IOException e) {
			e.printStackTrace();
		}
  	 }
  	 
  	 /**
  	  * 构造实体
  	  * @return
  	  */
	public Map<Integer, Carrier> createEntity() {
		for(int i=1;i<=10;i++){
			Carrier entity = new Carrier(i, "车牌号"+i, "00"+i, "在线"+i);
			map.put(i, entity);
		}
		return map;
	}
 	/**
 	 * 按要求显示
 	 */
	@Override
   	public String toString() {
   		 String test = carrierId + "," + carrierName + "," + serialNumber + "," + status + ";";
   		return test;
   }
	
	public Long getCarrierId() {
		return carrierId;
	}
	public void setCarrierId(Long carrierId) {
		this.carrierId = carrierId;
	}
	public String getCarrierName() {
		return carrierName;
	}
	public void setCarrierName(String carrierName) {
		this.carrierName = carrierName;
	}
	public String getSerialNumber() {
		return serialNumber;
	}
	public void setSerialNumber(String serialNumber) {
		this.serialNumber = serialNumber;
	}
	public String getStatus() {
		return status;
	}
	public void setStatus(String status) {
		this.status = status;
	}

	public static Map<Integer, Carrier> getMap() {
		return map;
	}

	public static void setMap(Map<Integer, Carrier> map) {
		Carrier.map = map;
	}

	
	
}
 
但是，Spring配置中的org.springframework.jmx.export.assembler.InterfaceBasedMBeanInfoAssembler对MBean暴露的操作进行了限制，主要是通过我们定义的接口org.shirdrn.jmx.mx4j.SelectedMethodsInterface来指定需要将MBean的哪些内容暴露给JMX管理，接口如下所示：（必须配置文件中  对接口有相应的配置  ） 

package entity;

import org.springframework.jmx.export.annotation.ManagedOperation;
import org.springframework.jmx.export.annotation.ManagedOperationParameter;
import org.springframework.jmx.export.annotation.ManagedOperationParameters;


public interface SelectedMethodsInterface {
	    public long getId();    
	    public void setName(String name);  
	    public String getName();  
	    public void show();    
}

最后，我们可以初始化Spring的IOC容器，启动MX4J的HttpAdaptor服务，实现通过Web控制台的JMX管理。


/*******************************************websock协作工作建立长连接实时改变对象信息*****************************************************/

websocket  页面的调用test.jsp  代码如下：

<%@ page language="java" import="java.util.*" pageEncoding="utf-8"%>
<%
String path = request.getContextPath();
String basePath = request.getScheme()+"://"+request.getServerName()+":"+request.getServerPort()+path+"/";
%>

<!DOCTYPE html>
<html>
<head>
 <base href="<%=basePath%>">
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<title>WebSocket Test</title>

<script type="text/javascript" src="js/jquery-1.8.3.min.js"></script>  
<script type="text/javascript">
var ws = null;
function initWebSocket() {
	if ('WebSocket' in window){
		ws = new WebSocket("ws://127.0.0.1:8080/webSocket/mywebsocket.do");
	}else{
		alert("not support");
	}
	
	ws.onmessage = function(evt) {
		var mess = "";
		var mss = "";
		var ms = [];
		var message = [];
 		var msg = evt.data;
		message = msg.split(";");
		for(var mege in message){
			 mss = message[mege];
			 ms = mss.split(",");
			var result ="carrierId"+mege+":"+ "<input type='text' id=carrierId"+mege+" value='"+ms[0]+"' readonly='readonly'/>"
			+ "carrierName"+mege+":"+ "<input type='text' id=carrierName"+mege+" value='"+ms[1]+"' readonly='readonly'/>"
			+ "serialNumber"+mege+":"+ "<input type='text' id=serialNumber"+mege+" value='"+ms[2]+"' readonly='readonly'/>"
			+ "status"+mege+":"+ "<input type='text' id=status"+mege+" value='"+ms[3]+"' readonly='readonly'/>";
				
	 		$("#receiveMessage").html(result +"</br>"+ mess);
	 		mess = $("#receiveMessage").html();
		}
	};
	
	ws.onclose = function(evt) {
		alert("close");
	};
	
	ws.onopen = function(evt) {
		alert("open");
	};
}

function sendMsg() {
	var carrierId = document.getElementById('carrierId').value;
	var carrierName = document.getElementById('carrierName').value;
	var serialNumber = document.getElementById('serialNumber').value;
	var status = document.getElementById('status').value;
	var sendmsg = carrierId +"," + carrierName +"," + serialNumber +"," + status;
	ws.send(sendmsg);
};
</script>
</head>
<body οnlοad="initWebSocket();">
	carrierId:<input type="text" id="carrierId"/>
	carrierName:<input type="text" id="carrierName"/>
	serialNumber:<input type="text" id="serialNumber"/>
	status:<input type="text" id="status"/>
<input type="button" value="send" οnclick="sendMsg()"></input>

<div id="receiveMessage">
	carrierId:<input type="text" id="carrierIds" readonly="readonly"/>
	carrierName:<input type="text" id="carrierNames" readonly="readonly"/>
	serialNumber:<input type="text" id="serialNumbers" readonly="readonly"/>
	status:<input type="text" id="statuss" readonly="readonly"/>
</div>
</body>
</html>

以下是websock工作所需要的类：

ApplicationContextListener.java  具体代码  如下：

package webSocket;

import javax.servlet.ServletContext;
import javax.servlet.ServletContextEvent;
import javax.servlet.ServletContextListener;

import utils.SpringBeanHolder;
import utils.StartServerService;

public class ApplicationContextListener implements ServletContextListener {

	@Override
	public void contextDestroyed(ServletContextEvent sce) {
	}

	@Override
	public void contextInitialized(ServletContextEvent event) {

		ServletContext servlet = event.getServletContext();
		SpringBeanHolder.setContextOfWeb(servlet);
		StartServerService.startHttpAdaptor();
		StartServerService.getCarriers();
	}

}
InitServlet.java  具体代码  如下： 


package webSocket;

import java.util.ArrayList;
import java.util.List;

import javax.servlet.ServletConfig;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;

import org.apache.catalina.websocket.MessageInbound;



public class InitServlet extends HttpServlet {

	private static final long serialVersionUID = -2895964351950418467L;

	private static List<MessageInbound> socketList;

	public void init(ServletConfig config) throws ServletException {
		InitServlet.socketList = new ArrayList<MessageInbound>();
		super.init(config);
		System.out.println("socket init success..");
	}
  
	public static synchronized List<MessageInbound> getSocketList() {
		return InitServlet.socketList;
	}

}

MyWebSocket.java  具体代码  如下：



package webSocket;

import javax.servlet.http.HttpServletRequest;

import org.apache.catalina.websocket.StreamInbound;
import org.apache.catalina.websocket.WebSocketServlet;

public class MyWebSocket extends WebSocketServlet {

	private static final long serialVersionUID = 7780410787770617234L;

	/**
	 * 在这里初始化自定义的WebSocket连接对象
	 */
	@Override
	protected StreamInbound createWebSocketInbound(String subProtocol, HttpServletRequest request) {
		return new MyWebSocketBound();
	}

}

<pre name="code" class="java">MyWebSocketBound .java  具体代码  如下:

 

package webSocket;

import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.CharBuffer;
import java.util.HashMap;
import java.util.Map;

import org.apache.catalina.websocket.MessageInbound;
import org.apache.catalina.websocket.WsOutbound;

import utils.StartServerService;
import entity.Carrier;

public class MyWebSocketBound extends MessageInbound {

	private StringBuffer buf = new StringBuffer();
	private static Map<Integer, Carrier> entityMap = new HashMap<Integer, Carrier>();

	public MyWebSocketBound() {
		super();
	}

	/**
	 * 打开连接
	 */
	@Override
	public void onOpen(WsOutbound outbound) {
		System.out.println("连接已打开");
		super.onOpen(outbound);
		InitServlet.getSocketList().add(this);
		try {
			entityMap = StartServerService.getCarrierMap();
			for (int i = 1; i <= entityMap.size(); i++) {
				Carrier entity = entityMap.get(i);
				buf.append(entity.toString());
			}
			String buff = buf.toString().substring(0, buf.toString().length() - 1);
			CharBuffer buffer = CharBuffer.wrap(buff);
			this.getWsOutbound().writeTextMessage(buffer);

		} catch (IOException e) {
			System.out.println("连接异常");
		}
	}

	/**
	 * 关闭连接
	 */
	@Override
	public void onClose(int status) {
		System.out.println("连接已关闭");
		InitServlet.getSocketList().remove(this);
		super.onClose(status);
	}

	/**
	 * 发送信息（发送字符串类型的信息）
	 */
	@Override
	public void onTextMessage(CharBuffer msg) throws IOException {
		String receiveMessage = msg.toString();
		for (MessageInbound messageInbound : InitServlet.getSocketList()) {
			CharBuffer buffer = CharBuffer.wrap(receiveMessage);
			WsOutbound outbound = messageInbound.getWsOutbound();
			outbound.writeTextMessage(buffer);
			outbound.flush();
		}
	}

	/**
	 * 发送信息（发送二进制类型的文件）
	 */
	@Override
	public void onBinaryMessage(ByteBuffer message) throws IOException {
	}

	public StringBuffer getBuf() {
		return buf;
	}

	public void setBuf(StringBuffer buf) {
		this.buf = buf;
	}

	public static Map<Integer, Carrier> getEntityMap() {
		return entityMap;
	}

	public static void setEntityMap(Map<Integer, Carrier> entityMap) {
		MyWebSocketBound.entityMap = entityMap;
	}

}

 

 以下是工具类，Spring获得bean的工具类 SpringBeanHolder .java 具体代码如下： 

 

 

package utils;

import javax.servlet.ServletContext;

import org.springframework.context.ApplicationContext;
import org.springframework.web.context.support.WebApplicationContextUtils;

public class SpringBeanHolder {

	private static ApplicationContext context;
 	
	public static void setContextOfWeb(ServletContext servlet) {
		context = WebApplicationContextUtils
				.getRequiredWebApplicationContext(servlet);
	}
	
	

	public static Object getBean(String beanName) {
		return context.getBean(beanName);
	}
	
}
 

 以下是工具类，Spring获得bean的工具类StartServerService .java 具体代码如下： 

 

 

package utils;

import java.io.IOException;
import java.util.HashMap;
import java.util.Map;

import mx4j.tools.adaptor.http.HttpAdaptor;
import entity.Carrier;

public class StartServerService {

	private static Map<Integer,Carrier> carrierMap = new HashMap<Integer,Carrier>();
	
	private static StartServerService serverService = new StartServerService();
	/**
	 * 单例模式
	 */
	public StartServerService(){
	}
	
	public static StartServerService getStartServerService(){
		return serverService;
	}
	
	/**
	 * 开启MX4j服务
	 */
	public static void startHttpAdaptor() {
		HttpAdaptor httpAdaptor = (HttpAdaptor)SpringBeanHolder.getBean("httpAdaptor");  
		try {
        	httpAdaptor.start();
        	System.out.println("后台   mx4j Server 启动成功");
		} catch (IOException e) {
			e.printStackTrace();
		}
		
	}
	/**
	 * 得到对象列表信息，放入application全局资源中
	 */
	public static void getCarriers() {
		Carrier carrier = (Carrier)SpringBeanHolder.getBean("carrierConfig");  
		carrierMap = carrier.createEntity();
	}

	public static Map<Integer, Carrier> getCarrierMap() {
		return carrierMap;
	}

	public static void setCarrierMap(Map<Integer, Carrier> carrierMap) {
		StartServerService.carrierMap = carrierMap;
	}
}

 

 

注意：要使用websocket  服务器可用
 
 

jetty 7.0.1 包含了一个初步的实现
 


  resin 包含有websocket 实现 

 


  pywebsocket, apache http server 扩展 

 


  apache tomcat 7.0.27 版本 

 


  Nginx 1.3.13 版本 

 


  jWebSocket java实现版 
 
 
 
 现在开启服务，以下是效果图 
 
 
  
 
 

 

 

 


 
 

 

用浏览器打开  两个分开页面  websocket 建立长连接  实时改变 对象的属性信息：
 


 

                

        

        

    

  


    

      

        

            

              
                
                  andy xin
                
              
            

            

                关注
              
            

        

        

          
      

      









                



	

		

			

				
					
红队系列-网络安全知识锦囊(持续更新)

				
			

			

				

					aming小老弟
				

				

					11-09
					
					1219
					
				

			

		

		

			
				
AJP13是定向包协议。因为性能原因，使用二进制格式来传输可读性文本。AJP协议：WEB服务器通过TCP连接和SERVLET容器连接。为了减少进程生成socket的花费，WEB服务器和SERVLET容器之间尝试保持持久性的TCP连接，对多个请求/回复循环重用一个连接。一旦连接分配给一个特定的请求，在请求处理循环结束之前不会在分配。换句话说，在连接上，请求不是多元的。这个是连接两端的编码变得容易，虽然这导致在一时刻会有很多连接。

			
		

	



                

              
                



	

		

			

				
					
《Spring 5 官方文档》1. Spring入门指南

				
			

			

				

					ifeves的博客
				

				

					05-21
					
					2088
					
				

			

		

		

			
				
1.Spring入门指南本参考指南提供了有关Spring Framework的详细信息。它全面的介绍了Spring的所有的功能，以及Spring涉及的基础概念（如“依赖注...

			
		

	



                


  
              

                


	

		

			

				
					
JMX与JMS的概念

				
			

			

				

					07-13
				

			

		

		

			
				
JMX与JMS的概念

			
		

	





	

		

			

				
					
socket 简单实现jms（消费者生产者模型）

				
			

			

				

					Ant_Shen的专栏
				

				

					04-20
					
					1365
					
				

			

		

		

			
				
本文基于socket通讯，以及lock锁机制来初步实现jms的异步队列。 
设计分成三个部分，分别是信息队列管理类，服务端类和客户端类。Buffer(信息队列管理类)import java.util.LinkedList;
import java.util.Queue;
import java.util.concurrent.locks.Condition;
import java.util.con

			
		

	



		

			
		



	

		

			

				
					
Java成神之路（十四）JMX与JMS

				
			

			

				

					love Simple的博客
				

				

					03-27
					
					1393
					
				

			

		

		

			
				
一：JMS

Java消息服务
两个应用程序之间进行异步通信的API-JMS,中间间
异步，可靠：服务器只推送一次：
两种模型：点对点（一对一），发布订阅（一对多）
JMS模型
点对点，P2P:
消息队列（queue）、发布者（Sender）、接受者（Receiver）:
每一个消息只有一个消费者（一旦消费，就不再消息队列）
时间无依赖（发了就不用管，登陆后就接收）
接受成功后，需要向队列提交接收...

			
		

	





	

		

			

				
					
Websocket通讯简析

				
			

			

				

					weixin_33979203的博客
				

				

					01-22
					
					81
					
				

			

		

		

			
				
什么是Websocket Websocket是一种全新的协议，不属于HTTP无状态协议，协议名为"ws"，这意味着一个Websocket连接地址会是这样的写法：ws://**。Websocket协议本质上是一个基于TCP的协议。建立连接需要握手，客户端（浏览器）首先向服务器（web server）发起一条特殊的HTTP请求，web server解析后生成应答到浏览器，这样子一个Websocke...

			
		

	





	

		

			

				
					
websocket客服系统

				
			

			

				

					07-20
				

			

		

		

			
				
项目采用springmvc+websocket+maven环境，实现web及时聊天客服系统！readme.txt文件包含了项目运行的入口地址。

			
		

	





	

		

			

				
					
基于Spring4MVC的测试Demo

				
			

			

				

					05-31
				

			

		

		

			
				
首先，Spring4是Spring框架的一个主要版本，引入了许多增强和改进，如支持Java 8的新特性、对WebSocket的支持以及对JMS和JMX的改进。在Spring4MVC中，我们可以通过注解驱动的配置来简化Web应用的开发，例如使用@...

			
		

	





	

		

			

				
					
企业内部通讯软件

				
			

			

				

					07-03
				

			

		

		

			
				
企业内部通讯软件是现代企业信息化建设中的重要组成部分，它能够高效地促进员工之间的沟通与协作，提高工作效率。在Java开发领域，这样的软件通常基于强大的Java技术栈构建，为开发者提供了丰富的学习和实践机会。本...

			
		

	





	

		

			

				
					
Spring框架概述及其工厂模式

				
			

			

				

					rincoo_的博客
				

				

					06-07
					
					766
					
				

			

		

		

			
				
Spring 框架是一个轻量级的解决方案，并且是构建企业就绪应用程序的一站式潜在 Store。但是Spring 是模块化的，允许您仅使用所需的那些 Component，而不必引入其他 Component。您可以将 IoC 容器与顶部的任何 Web 框架一起使用，但也可以仅使用Hibernate 集成代码或JDBC 抽象层。 Spring 框架支持声明式事务 Management，通过 RMI 或 Web 服务对逻辑的远程访问以及用于持久化数据的各种选项。它提供了功能齐全的MVC framework，并使您能

			
		

	





	

		

			

				
					
Spring整合JMS

				
			

			

				

					02-25
				

			

		

		

			
				
对JMS做了一个简要介绍，讲一下Spring整合JMS的具体过程。JMS只是一个标准，真正在使用它的时候我们需要有它的具体实现，这里我们就使用Apache的activeMQ来作为它的实现

			
		

	





	

		

			

				
					
weather-forecast-processor:使用 WebSockets 和 JMS 进行天气预报

				
			

			

				

					06-01
				

			

		

		

			
				
天气预报处理器
此应用程序必须演示Java EE 7设施，如WebSockets，JMS和EJB一起使用。 JMS 的作用是参与消息的生成、发送和接收。 EJB 处理消息消费 (MDB) 并使整个流程具有周期性（任务调度）。 WebSockets 负责并发客户端实时更新——所有客户端同时获取更新。
技术栈
JDK 8
 Apache Maven v.3.2
 Java EE 7.0（WebSockets，JMS，EJB）
 WildFly 应用服务器 v.8.2
构建说明
从应用程序根目录调用以下 maven 命令：
 mvn clean package
 检查构建日志，确保构建成功：
 [INFO] BUILD SUCCESS 
启动说明
组装好应用程序后，将weather-forecast-processor.war部署到WildFly服务器。
 该应用程序围绕两个调度程序设计：
 a

			
		

	





	

		

			

				
					
webservice和jms的区别

				
			

			

				

					xmh_sxh_1314的博客
				

				

					08-25
					
					573
					
				

			

		

		

			
				
Webservice专注于远程服务调用，jms专注于信息交换。
大多数情况下Webservice是两系统间的直接交互（Consumer <–> Producer），而大多数情况下jms是三方系统交互（Consumer <- Broker -> Producer）。当然，JMS也可以实现request-response模式的通信，只要Consumer或Producer其中一方兼任broker即可。
JMS可以做到异步调用完全隔离了客户端和服务提供者，能够抵御流量洪峰； WebServ.

			
		

	





	

		

			

				
					
webService和jms的区别

				
			

			

				

					weixin_34191845的博客
				

				

					03-12
					
					235
					
				

			

		

		

			
				
2019独角兽企业重金招聘Python工程师标准>>>   
                                        
         ...

			
		

	





	

		

			

				
					
JMS消息监听和转发实例

				
			

			

				

					shuishoujushi的专栏
				

				

					07-12
					
					1079
					
				

			

		

		

			
				
1. 新建web工程，在tomcat下注册queue
iJms.xml



        name="CONNECTON_FACTORY"
        auth="Container"
        type="org.apache.activemq.ActiveMQConnectionFactory"
        description="JMS Connectio

			
		

	





	

		

			

				
					
web JMS学习（activeMq）

				
			

			

				

					写博客只为学习
				

				

					04-11
					
					209
					
				

			

		

		

			
				
深入掌握JMS（一）：JSM基础

1. JMS基本概念
    JMS(Java Message Service) 即Java消息服务。它提供标准的产生、发送、接收消息的接口简化企业应用的开发。
   它支持两种消息通信模型：点到点（point-to-point）（P2P）模型和发布/订阅（Pub/Sub）模型。
  P2P 模型规定了一个消息只能有一个接收者;Pub/Sub 模型允许一个消息可

			
		

	





	

		

			

				
					
基于JMS消息中间件的分布式系统初探究(一) - 通过JMS实现Web服务器与服务框架的通讯

				
			

			

				

					王鸿飞的专栏
				

				

					03-24
					
					3080
					
				

			

		

		

			
				
在一个大型网站中，如果要把整个业务拆分成N个子业务，每个业务单独部署到一台服务器上，那么需要解决的问题有：
自身的部署。是部署到JavaEE容器中随容器启动，还是做为一个standalone程序单独启动？
子系统如何暴露服务接口(如何与其它系统进行通讯)。服务请求者直接通过Socket直连，还是通过Web Service, RMI等技术？
这里我们尝试通过standalone方式部署，通过JMS中间

			
		

	





	

		

			

				
					
WebSocket在容器管理中的双向实时应用与优势

				
			

			

				

					
				

			

		

		

			
				
2. 交互式管理：在Web界面操作容器时，WebSocket提供了即时的反馈机制。用户可以直接在前端进行容器的启动、停止、重启等操作，而无需频繁切换到后台进行命令行操作，极大地简化了管理员的工作流程。  WebSocket的...

			
		

	



              




          




        



    





    



      

      

        
      

      





	

		评论	
	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

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

              

            

          

      

      余额充值