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來解決,這也是業界...