1. 如何把superwebsocket加到web程序里运行
WebSocket是HTML5开始提供的一种浏览器与服务器间进行全双工通讯的网络技术。在WebSocket API中，浏览器和服务器只需要做一个握手的动作，然后，浏览器和服务器之间就形成了一条快速通道。两者之间就直接可以数据互相传送。 Cocos2d-x引擎集成li...
2. 怎样用java web和websocket实现网页即时通讯
java 后台做 websocket 服务端。 页面使用js的websocket客户端 连接上 服务端 就能实时通信了。
3. websocket的端口与web应用的端口可以共用一个吗
你好，不会起冲突的。
如果websocket使用wss,也会跟https共用443端口的，也是不会起冲突的。
另外楼主是自己开发的websocket服务吗？稳定性怎么样呢？
我们项目现在用的是【GoEasy】来实现websocket服务，目前使用还不错
4. HTML5 Web Socket和Web Worker的区别以及使用方法
一、WEB SOCKET
1、Web Socket是一种协议、本质上和http、tcp一样、协议是用来说明数据是如何传输的,写过一个小的在线聊天使用了socket.io、之后总结这个项目
2、Web Socket的前缀有两种：（1）ws:// 不是加密的、 (2)wss:// 是加密的
3、客户端和服务端进行Web Socket交互的方式也可以理解为“http握手 tcp数据传输”的方式
（1）浏览器（支持Websocket的浏览器）像HTTP一样、发起一个请求、然后等待服务端的响应
（2）服务器返回握手响应、告诉浏览器请将后续的数据按照websocket制定的数据格式传过来
（3）浏览器和服务器的socket连接不中断、此时这个连接和http不同的是它是双工的了
（4）浏览器和服务器有任何需要传递的数据的时候使用这个长连接进行数据传递
注
HTTP握手：是因为浏览器和服务器在建立长连接的握手过程是按照HTTP1.1的协议发送的、有Request、Request Header、 Response、 Response Header、但是不同的是Header里面的字段是有特定含义的
TCP传输: 主要体现在建立长连接后、浏览器是可以给服务器发送数据、服务器也可以给浏览器发送请求的、当然它的数据格式并不是自己定义的、是在要传输的数据外层有ws协议规定的外层包的
4、数据传输过程:websocket的数据传输形式是：frame、比如会将一条消息分为几个frame、按照先后顺序传输出去、这样做会有几个好处
（1）大数据的传输可以分片传输、不用考虑到数据大小导致的长度标志位不足够的情况
（2）和http的chunk一样、可以边生成数据边传递消息、即提高传输效率
5、客户端使用Web Socket的语法：JavaScript、服务端：多种web框架支持
二、WEB WORKER
1、当在 HTML 页面中执行脚本时、页面的状态是不可响应的、直到脚本已完成、而Web Worker 是运行在后台的 JavaScript、独立于其他脚本、不会影响页面的性能、您可以继续做任何愿意做的事情：点击、选取内容等等、而此时 Web Worker 在后台运行
除了DOM操作之外、理论上任何JS脚本任务都可放入worker中执行；语法上的限制、则是不能跨域访问JS、worker常用于需要消耗大量时间和CPU资源的复杂计算、以换来前台用户操作的友好型；换句话说、从用户体验上看、提高了服务性能
2、Web Worker使用：(当我们创建 Web Worker 对象后、它会继续监听消息（即使在外部脚本完成之后）直到其被终止为止）
（1）通过向 Web Worker 添加一个 "onmessage" 事件监听器来获取接受到的消息
（2）发送消息：postMessage()
（3）终止 Web Worker、并释放浏览器/计算机资源: terminate()
5. 如何使用WebSocket
WebSocket protocol 是HTML5一种新的协议(protocol)。它是实现了浏览器与服务器全双工通信(full-plex)。
现在，很多网站为了实现即时通讯(real-time)，所用的技术都是轮询(polling)。轮询是在特定的的时间间隔(time interval)（如每1秒），由浏览器对服务器发出HTTP request，然后由服务器返回最新的数据给客服端的浏览器。这种传统的HTTP request d的模式带来很明显的缺点 – 浏览器需要不断的向服务器发出请求(request)，然而HTTP request 的header是非常长的，里面包含的数据可能只是一个很小的值，这样会占用很多的带宽。
而最比较新的技术去做轮询的效果是Comet – 用了AJAX。但这种技术虽然可达到全双工通信，但依然需要发出请求(reuqest)。
在 WebSocket API，浏览器和服务器只需要要做一个握手的动作，然后，浏览器和服务器之间就形成了一条快速通道。两者之间就直接可以数据互相传送。在此WebSocket 协议中，为我们实现即使服务带来了两大好处：
1. Header
互相沟通的Header是很小的-大概只有 2 Bytes
2. Server Push
服务器可以主动传送数据给客户端
下面实现一个简单PUSH例子如下：
服务端代码：
public class InitServlet extends HttpServlet {
/**
*
*/
private static final long serialVersionUID = 1L;
private static List<MessageInbound> socketList;
public void init(ServletConfig config) throws ServletException {
InitServlet.socketList = new ArrayList<MessageInbound>();
super.init(config);
System.out.println("Server start============");
}
public static List<MessageInbound> getSocketList() {
return InitServlet.socketList;
}
}
public class TestWebSocketServlet extends WebSocketServlet{
private static final Logger log = Logger.getLogger(TestWebSocketServlet.class);
/**
*
*/
private static final long serialVersionUID = 1L;
//存储链接的容器
private static List<WebSocketMessageInbound> connsList = new ArrayList<WebSocketMessageInbound>();
@Override
protected StreamInbound createWebSocketInbound(String subProtocol,HttpServletRequest request) {
// TODO Auto-generated method stub
return new WebSocketMessageInbound();
}
public class WebSocketMessageInbound extends MessageInbound{
@Override
protected void onClose(int status) {
// InitServlet.getSocketList().remove(this);
super.onClose(status);
log.debug("onClose");
InitServlet.getSocketList().remove(this);
}
@Override
protected void onOpen(WsOutbound outbound) {
log.debug("onOpen");
super.onOpen(outbound);
InitServlet.getSocketList().add(this);
}
@Override
protected void onBinaryMessage(ByteBuffer message) throws IOException {
// TODO Auto-generated method stub
log.debug("onBinaryMessage");
}
@Override
protected void onTextMessage(CharBuffer message) throws IOException {
// TODO Auto-generated method stub
log.debug("onTextMessage="+message);
// this.getWsOutbound().writeTextMessage(CharBuffer.wrap("===="));
// this.getWsOutbound().writeTextMessage(message);
//发送给所有链接的
for (MessageInbound messageInbound : InitServlet.getSocketList()) {
CharBuffer buffer = CharBuffer.wrap(message);
WsOutbound outbound = messageInbound.getWsOutbound();
outbound.writeTextMessage(buffer);
outbound.flush();
}
}
}
}
web.xml配置
<!-- WebSocket -->
<servlet>
<servlet-name>initServlet</servlet-name>
<servlet-class>com.demo.websocket.InitServlet</servlet-class>
<load-on-startup>1</load-on-startup>
</servlet>
<servlet>
<servlet-name>websocket</servlet-name>
<servlet-class>com.demo.websocket.TestWebSocketServlet</servlet-class>
</servlet>
<servlet-mapping>
<servlet-name>websocket</servlet-name>
<url-pattern>/websocket</url-pattern>
</servlet-mapping>
前台代码：
<html>
<head>
<title>WebSoket Demo</title>
<script type="text/javascript">
//验证浏览器是否支持WebSocket协议
if (!window.WebSocket) {
alert("WebSocket not supported by this browser!");
}
var ws;
function display() {
//var valueLabel = document.getElementById("valueLabel");
//valueLabel.innerHTML = "";
ws=new WebSocket("ws://localhost:8082/springmvc/websocket");
//监听消息
ws.onmessage = function(event) {
//valueLabel.innerHTML+ = event.data;
log(event.data);
};
// 打开WebSocket
ws.onclose = function(event) {
//WebSocket Status:: Socket Closed
};
// 打开WebSocket
ws.onopen = function(event) {
//WebSocket Status:: Socket Open
//// 发送一个初始化消息
ws.send("Hello, Server!");
};
ws.onerror =function(event){
//WebSocket Status:: Error was reported
};
}
var log = function(s) {
if (document.readyState !== "complete") {
log.buffer.push(s);
} else {
document.getElementById("contentId").innerHTML += (s + "\n");
}
}
function sendMsg(){
var msg=document.getElementById("messageId");
//alert(msg.value);
ws.send(msg.value);
}
</script>
</head>
<body onload="display();">
<div id="valueLabel"></div>
<textarea rows="20" cols="30" id="contentId"></textarea>
<br/>
<input name="message" id="messageId"/>
<button id="sendButton" onClick="javascript:sendMsg()" >Send</button>
</body>
< /html>
6. 如何创建使用SuperWebSocket一个WebSocket的服务器
完全木有必要，应用服务器只运行web服务就行了，普通的socket直接开启就行，完全不要容器啊
7. websocket是前台完成还是后台完成
前台实现
1 connect:function() {
2 var webSocketIP = window.CRM_CONFIG.WebSocketIP;
3 var target = 'ws://'+webSocketIP+'/websocket';
4 if ('WebSocket' in window) {
5 ws = new WebSocket(target);
6 } else if ('MozWebSocket' in window) {
7 ws = new MozWebSocket(target);
8 } else {
9 return;
10 }
11 ws.onopen = function () {
12 console.log('Info: WebSocket connection opened.');
13 document.getElementById("wsMsg").style.display = "block";
14 };
15 var self = this;
16 ws.onmessage = function (event) {
17 if('您有如下工单需要及时处理：'!= event.data) {
18 self.setState({wsMessage: event.data})
19 document.getElementById("wsMsg").style.display = "block";
20 }else{
21 document.getElementById("wsMsg").style.display = "none";
22 }
23 };
24
25 <div id="wsMsg" className="msgDialog msgDiv">
26 <div className="msgContent" ><a onClick ={this.closeMsg}> X </a></div>
27 {this.state.wsMessage}
28 </div>
2、pom.xml依赖
1 <!--spring-websocket-->
2 <dependency>
3 <groupId>javax.servlet</groupId>
4 <artifactId>javax.servlet-api</artifactId>
5 <version>3.1.0</version>
6 </dependency>
7 <dependency>
8 <groupId>org.springframework</groupId>
9 <artifactId>spring-websocket</artifactId>
10 <version>${spring.version}</version>
11 </dependency>
3、spring.xml配置
<!--websocket 配置-->
<bean id="websocket" class="com.oasis.crm.controller.websocket.WebsocketEndPoint"/>
<websocket:handlers allowed-origins="*">
<websocket:mapping path="/websocket" handler="websocket"/>
<websocket:handshake-interceptors>
<bean class="com.oasis.crm.controller.websocket.HandshakeInterceptor"/>
</websocket:handshake-interceptors>
</websocket:handlers>
4、java代码
package com.oasis.crm.controller.websocket;
import com.oasis.crm..biz.user.UserDao;
import com.oasis.crm.model.biz.user.User;
import com.oasis.crm.service.biz.order.AcceptedWorkOrderService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.socket.CloseStatus;
import org.springframework.web.socket.TextMessage;
import org.springframework.web.socket.WebSocketSession;
import org.springframework.web.socket.handler.TextWebSocketHandler;
import java.util.Timer;
import java.util.TimerTask;
/**
* 推送即将要处理完成的受理单给处理人
*/
@RequestMapping("/websocket")
public class WebsocketEndPoint extends TextWebSocketHandler {
@Autowired
private AcceptedWorkOrderService acceptedWorkOrderService;
@Autowired
private UserDao userDao;
private Timer timer;
@Override
protected void handleTextMessage(WebSocketSession session,
TextMessage message) throws Exception {
if(!session.isOpen()){
timer.cancel();
return;
}
super.handleTextMessage(session, message);
session.sendMessage(message);
}
@Override
public void afterConnectionEstablished(WebSocketSession session) throws Exception {
String loginUserName = session.getPrincipal().getName();
User user = userDao.findUserByLoginName(loginUserName);
timer = new Timer(true);
long delay = 0;
OrderTimeTask orderTimeTask = new OrderTimeTask(user,session);
timer.schele(orderTimeTask,delay, 60000);// 设定指定的时间time,此处为1分钟
}
class OrderTimeTask extends TimerTask{
private User user;
private WebSocketSession session;
public OrderTimeTask(User user,WebSocketSession session){
this.user = user;
this.session = session;
}
@Override
public void run() {
try {
String reminder = acceptedWorkOrderService.getLastReminderOrder(user.getId());
TextMessage textMessage = new TextMessage(reminder);
handleMessage(session,textMessage);
} catch (Exception e){
e.printStackTrace();
}
}
}
@Override
public void afterConnectionClosed(WebSocketSession session, CloseStatus status) throws Exception {
System.out.println("Connection Closed！");
}
}
package com.oasis.crm.controller.websocket;
import org.springframework.http.server.ServerHttpRequest;
import org.springframework.http.server.ServerHttpResponse;
import org.springframework.web.socket.WebSocketHandler;
import org.springframework.web.socket成都软件开发公司http://www.yingtaow.com?server.support.;
import java.util.Map;
public class HandshakeInterceptor extends {
@Override
public boolean beforeHandshake(ServerHttpRequest request,
ServerHttpResponse response, WebSocketHandler wsHandler,
Map<String, Object> attributes) throws Exception {
return super.beforeHandshake(request, response, wsHandler, attributes);
}
@Override
public void afterHandshake(ServerHttpRequest request,
ServerHttpResponse response, WebSocketHandler wsHandler,
Exception ex) {
super.afterHandshake(request, response, wsHandler, ex);
}
}
================
或者前台拉定时取消息
setInterval(()=> {
this.getReminders();
}, 300000);
getReminders(){
$.getJSON(Remote.acceptedWorkOrder.reminderOrders,packVo=>{
this.setState({
wsMessage:packVo.vo
});
});
if('您有如下工单需要及时处理：'!= this.state.wsMessage&&''!=this.state.wsMessage){
document.getElementById("wsMsg").style.display = "block";
}else{
document.getElementById("wsMsg").style.display = "none";
}
}
8. 如何通过WebSocket连接服务器进行数据传输
客户端：
client.htm
<!DOCTYPEhtml>
<html>
<body>
<h1>WebSocket</h1>
<scriptsrc="client.js"></script>
</body>
</html>
client.js
varws=newWebSocket("ws://127.0.0.1:8080/");
ws.onopen=function(){
alert("Opened");
ws.send("I'mclient");
};
ws.onmessage=function(evt){
alert(evt.data);
};
ws.onclose=function(){
alert("Closed");
};
ws.onerror=function(err){
alert("Error:"+err);
};服务端可以用各种语言去实现，Java可以用Jetty，C#可以用SuperSocket，这里我举例用Node.js，创建server.js：
varWebSocketServer=require('ws').Server
,wss=newWebSocketServer({port:8080});
wss.on('connection',function(ws){
ws.on('message',function(message){
console.log('received:%s',message);
});
ws.send('something');
});运行方式：
npminstallws
nodeserver.js
9. 求个websocket和springmvc结合的例子啊，网上找的都不靠谱
最近一段时间因为需要，要做一个网页游戏。在某一段时间需要页面实时刷新。目前做网站普遍的思路都是js轮询的方式。由于是创新式的小项目，同组的好友提议了html5中提到的WebSocket，首先进行了技术调研。目前java方面支持的WebSocket的不算多。网上能搜到关于websocket实现框架的非常少。java EE7中加入WebSocket还没有看到。所以以来的包都来自于tomcat的支持。至少需要3个包tomcat-coyote，tomcat-catalina，tomcat-annotations-api，因为tomcat从7.027版本才开始比较好的支持websocket，在tomcat7.027之前的版本中，已经能使用websocket，但是会出现各式各样的问题。比如websocket连接后静置几秒钟就断开连接了等等。所以比较好的选择是使用7.027以上的版本。这3个jar包在相应tomcat的lib文件夹下都有。自从研究生期间接触maven后，慢慢了解到maven的强大，在这里不得不感叹一下。因为是个小型的敏捷团队，版本控制是必须的。在jar包控制这方面还是想通过maven来控制。就直接去maven中心库搜了搜。果真还是有的。小组讨论之后决定使用tomcat7.039(貌似40已经出了),到此解决了版本控制和jar包配置问题。pom关于tomcat3个jar包如下:
1 <dependency> 2 <groupId>org.apache.tomcat</groupId> 3 <artifactId>tomcat-coyote</artifactId> 4 <version>7.0.39</version> 5 </dependency> 6 <dependency> 7 <groupId>org.apache.tomcat</groupId> 8 <artifactId>tomcat-catalina</artifactId> 9 <version>7.0.39</version>10 </dependency>11 <dependency>12 <groupId>org.apache.tomcat</groupId>13 <artifactId>tomcat-annotations-api</artifactId>14 <version>7.0.39</version>15 </dependency>
接下来是解决架构问题。现在在网上能搜到关于websocket的实践很少，基本能搜到的都是websocket架构和非常简单的例子(tomcat自带就有websocket例子),怎么样能将websocket机制运用起来。首先基本框架准备使用hibernate+spring mvc结合websocket，但是在实际试验中spring mvc和websocket会有部分有冲突。因为到前一段时间Spring Framework 4.0发布的版本中才有了JDK 8的支持和WebSocket编程的支持。所以现阶段需要别的方式来实现spring mvc+websocket。简单的解决方案就是写一个工具类来手动获得bean。解决spring和websocket支持之后需要解决的websocket的交互方式。websocket最直接的两个方法就是onTextMessage和onBinaryMessage，也就是字节流传输和字符流传输。最优方式便是设计一套自己传输协议。通过字节流传输。前后台分别解析协议获取交互操作。其次便可在onTextMessage也就是字符流上做文章。引入json便可以很好支持了。
配置websocket的步骤：
1实现一个类继承ContextLoaderListener，并且在web.xml中配置
1 import javax.servlet.ServletContext; 2 import javax.servlet.ServletContextEvent; 3 4 import org.springframework.context.ApplicationContext; 5 import org.springframework.web.context.ContextLoaderListener; 6 import org.springframework.web.context.support.WebApplicationContextUtils; 7 8 public class SpringLoaderListener extends ContextLoaderListener{ 9 10 @Override11 public void contextInitialized(ServletContextEvent event) {12 super.contextInitialized(event);13 ServletContext context=event.getServletContext();14 ApplicationContext ctx=WebApplicationContextUtils.(context);15 SpringContextutil.setContext(ctx);16 17 }18 19 }
web.xml
1 <listener>2 <listener-class>3 XXXXXX.utils.SpringLoaderListener4 </listener-class>5 </listener>
获得spring bean工具类:
1 import org.springframework.beans.BeansException; 2 import org.springframework.beans.factory.NoSuchBeanDefinitionException; 3 import org.springframework.context.ApplicationContext; 4 5 public class SpringContextUtil { 6 private static ApplicationContext context; 7 8 public static ApplicationContext getContext() { 9 return context;10 }11 12 public static void setContext(ApplicationContext context) {13 SpringContextutil.context = context;14 }15 16 public static Object getBean(String name)throws BeansException{17 return context.getBean(name);18 }19 20 @SuppressWarnings("unchecked")21 public static Object getBean(String name, Class requiredType) throws BeansException { 22 return context.getBean(name, requiredType); 23 } 24 25 public static boolean containsBean(String name) { 26 return context.containsBean(name); 27 } 28 29 public static boolean isSingleton(String name) throws NoSuchBeanDefinitionException { 30 return context.isSingleton(name); 31 } 32 33 @SuppressWarnings("unchecked")34 public static Class getType(String name) throws NoSuchBeanDefinitionException { 35 return context.getType(name); 36 } 37 38 public static String[] getAliases(String name) throws NoSuchBeanDefinitionException { 39 return context.getAliases(name); 40 } 41 42 43 }
引入json所需jar包:
1 <dependency> 2 <groupId>com.google.code.gson</groupId> 3 <artifactId>gson</artifactId> 4 <version>2.2.3</version> 5 </dependency> 6 <dependency> 7 <groupId>net.sf.json-lib</groupId> 8 <artifactId>json-lib</artifactId> 9 <version>2.4</version>10 </dependency>11 <dependency>12 <groupId>net.sf.ezmorph</groupId>13 <artifactId>ezmorph</artifactId>14 <version>1.0.6</version>15 </dependency>
后台需要增加两个文件一个继承WebSocketServlet:
1 import javax.servlet.annotation.WebServlet; 2 import javax.servlet.http.HttpServletRequest; 3 4 import org.apache.catalina.websocket.StreamInbound; 5 import org.apache.catalina.websocket.WebSocketServlet; 6 9 @WebServlet("/room")10 public class RoomSocketServlet extends WebSocketServlet {11 12 private static final long serialVersionUID = -5853470534275847275L;13 14 @Override15 protected StreamInbound createWebSocketInbound(String arg0,HttpServletRequest request) {16 return new RoomMessageInbound();17 }18 19 }
一个继承MessageInbound：
1 public class RoomMessageInbound extends MessageInbound{ 2 private static RoomModel room ; 3 private UserModel user; 4 private CommandDispatcherUtils commandDispatcher; 5 6 public RoomMessageInbound() { 7 if (commandDispatcher == null) { 8 commandDispatcher = (CommandDispatcherUtils) SpringContextutil.getBean("commandDispatcher"); 9 room = RoomListModel.getInstance().getRoom(0);10 }11 }12 13 14 @Override15 protected void onOpen(WsOutbound outbound) 16 room.addUser(outbound.hashCode());17 super.onOpen(outbound);18 }19 20 @Override21 protected void onClose(int status) {22 room.remove(getWsOutbound().hashCode());23 super.onClose(status);24 }25 26 @Override27 protected void onBinaryMessage(ByteBuffer buffer) throws IOException {28 29 }30 31 @Override32 protected void onTextMessage(CharBuffer buffer) throws IOException {33 String msg = buffer.toString();34 JSONObject report = JSONObject.fromObject(msg);35 TemplateCommand command = commandDispatcher.getCommandByKey(report.getString("command"));36 command.execute(msg,user,room);37 }38 39 }
通过JSONObject report = JSONObject.fromObject(msg)就可以将字符串转换为json对象。也就等于通过websocket实现了实时对象信息的传递。
在前端页面中只需要页面载入时的js中加入
1 $(function() { 2 roomsocket = new WebSocket('ws://127.0.0.1:8080/XXXX/room);3 }
在前端向后台发送时将数据JSON.stringify(data)就能json化。
上述代码做了不少删减。所以代码不见得复制就能用。只是提供一种解决方案。况且不久java新的版本或者说Spring Framework 4.0就能很轻松的支持了websocket的实现。主要是还是给自己这段时间的websocket研究做一些总结。随着各种新的技术的诞生，实时web技术已经越来越成熟。websocket是html5的重要特色是值得去看看，研究一下
10. web前端可以使用websocket开启服务吗
1 通讯通道选择:这个很多前端高手已经回答了,基本就是两种方式:轮询和长连接,这种情况通常的解决方式是长连接,Web端可以用WebSocket来解决,这也是业界...