`
haoningabc
  • 浏览: 1478317 次
  • 性别: Icon_minigender_1
  • 来自: 北京
社区版块
存档分类
最新评论

websocket,使用tomcat7转发

websocket 
阅读更多
前篇：
http://haoningabc.iteye.com/blog/2011985
代码的git地址
https://github.com/killinux/mysocket/tree/master/websocket/project/tomcat7servlet


如果是使用tomcat7的模式
1.html是客户端
2.tomcat7的servlet对websocket协议进行了封装，里面转发给普通的socket服务端
3.普通的socket 作为服务端


html ----->tomcat7,servlet----->socket server



这里纯js的客户端： 
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">  
<html>  
<head>  
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">  
<title>Insert title here</title>  
</head>  
<script type="text/javascript">  
    var ws = null;  
    function startServer() {  
        var url = "ws://192.168.0.102:5000";  
        if ('WebSocket' in window) {  
            ws = new WebSocket(url);  
        } else if ('MozWebSocket' in window) {  
            ws = new MozWebSocket(url);  
        } else {  
            alert('浏览器不支持');  
            return;
        }  
        ws.onopen = function() {  
            alert('Opened!');  
        };  
        // 收到服务器发送的文本消息, event.data表示文本内容  
        ws.onmessage = function(event) {  
            alert('Receive message: ' + event.data);  
        };  
        ws.onclose = function() {  
          alert('Closed!');  
        }  
}  
    //发送信息  
    function sendMessage(){  
        var textMessage=document.getElementById("textMessage").value;  
          
        if(ws!=null&&textMessage!=""){  
            ws.send(textMessage);  
              
        }  
    }  
</script>  
<body onload="startServer()">  
        <input type="text" id="textMessage" size="20" />  
        <input type="button" onclick="sendMessage()" value="Send">  
    </body>  
</html>


如果是用java-websocket，

git为 https://github.com/killinux/Java-WebSocket
代码如下：
socket server端： 
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.net.ServerSocket;
import java.net.Socket;
public class Server {
	public static final int PORT = 5000;
	public static void main(String[] args) {
		System.out.println("服务器...\n");
		Server ser = new Server();
		ser.sock();
	}
	public void sock() {
		try {
			ServerSocket server = new ServerSocket(PORT);
			while (true) {
				// 一旦有堵塞, 则表示服务器与客户端获得了连接
				Socket client = server.accept();
				// 处理这次连接
				new PServer(client);
			}
		} catch (Exception e) {
			System.out.println("服务器异常: " + e.getMessage());
		}
	}

	private class PServer implements Runnable {
		private Socket socket;
		public PServer(Socket sock) {
			socket = sock;
			new Thread(this).start();
		}
		public void run() {
			System.out.println("一个客户端连接ip:" + socket.getInetAddress());
			try {
				// 读取客户端数据
				DataInputStream input = new DataInputStream(
						socket.getInputStream());
				// 向客户端发送数据
				DataOutputStream out = new DataOutputStream(
						socket.getOutputStream());
				// 读取客户端数据
				//System.out.println("客户端发过来的内容: " + input.readUTF());
				byte[] bt = new byte[1024];
				int leng = input.read(bt);
				System.out.println(new String(bt, 0, leng));
				// 发送键盘输入的一行
				// String s = new BufferedReader(new
				// InputStreamReader(System.in)).readLine();
				String s = "server d shu ru";
				out.write(s.getBytes());
				out.flush();
				input.close();
				out.close();
				socket.close();
			} catch (Exception e) {
				System.out.println("服务器 run 异常: " + e.getMessage());
			}
		}

	}

}

----------------------------------------------------------------------
----------------------------------------------------------------------
如果server是用tomcat转发
参考
http://blog.csdn.net/a79412906/article/details/9393515
servlet: 
package com.hao;

import java.io.DataInputStream;
import java.io.IOException;
import java.io.PrintWriter;
import java.net.Socket;
import java.net.UnknownHostException;
import java.nio.ByteBuffer;
import java.nio.CharBuffer;

import javax.servlet.http.HttpServletRequest;

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

public class HelloWorldWebSocketServlet extends WebSocketServlet {

	protected StreamInbound createWebSocketInbound(String subProtocol,HttpServletRequest arg1) {

		return new MessageInbound() {

			@Override
			protected void onBinaryMessage(ByteBuffer arg0) throws IOException {
				// TODO Auto-generated method stub

			}

			@Override
			protected void onTextMessage(CharBuffer message) throws IOException {
				// TODO Auto-generated method stub
				System.out.println("onText--->" + message.toString());
				Socket socket;
				String msg = "";
				try {
					// 向服务器利用Socket发送信息
					socket = new Socket("192.168.1.102", 5000);
					//socket = new Socket("127.0.0.1",5000);
					PrintWriter output = new PrintWriter(
							socket.getOutputStream());

					output.write(message.toString());
					output.flush();

					// 这里是接收到Server的信息
					DataInputStream input = new DataInputStream(
							socket.getInputStream());
					byte[] b = new byte[1024];
					input.read(b);
					// Server返回的信息
					msg = new String(b).trim();

					output.close();
					input.close();
					socket.close();
				} catch (UnknownHostException e) {
					e.printStackTrace();
				} catch (IOException e) {
					e.printStackTrace();
				}
				// 往浏览器发送信息
				CharBuffer cb = CharBuffer.wrap(new StringBuilder(msg));
				getWsOutbound().writeTextMessage(cb);
			}
		};
	}

	public static void main(String[] args) {
		Socket socket;
		String message ="haoning";
		String msg = "";
		try {
			// 向服务器利用Socket发送信息
			socket = new Socket("192.168.0.102", 5000);
			// socket = new Socket("127.0.0.1",5000);
			PrintWriter output = new PrintWriter(
					socket.getOutputStream());

			output.write(message.toString());
			output.flush();

			// 这里是接收到Server的信息
			DataInputStream input = new DataInputStream(
					socket.getInputStream());
			byte[] b = new byte[1024];
			input.read(b);
			// Server返回的信息
			msg = new String(b).trim();

			output.close();
			input.close();
			socket.close();
		} catch (UnknownHostException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
}

web.xml配置： 
<servlet>
      <servlet-name>wsSnake</servlet-name>
      <servlet-class>com.hao.HelloWorldWebSocketServlet</servlet-class>
    </servlet>
    <servlet-mapping>
      <servlet-name>wsSnake</servlet-name>
      <url-pattern>/websocket/test</url-pattern>
    </servlet-mapping>

tomcat7的
配置 
<?xml version='1.0' encoding='utf-8'?>
<Context crossContext="true" docBase="D:/workspace/work1/Test/webapp" path="/webs" reloadable="true">
</Context>

中心server代码： 
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.net.ServerSocket;
import java.net.Socket;
public class Server {
	public static final int PORT = 5000;
	public static void main(String[] args) {
		System.out.println("服务器...\n");
		Server ser = new Server();
		ser.sock();
	}
	public void sock() {
		try {
			ServerSocket server = new ServerSocket(PORT);
			while (true) {
				// 一旦有堵塞, 则表示服务器与客户端获得了连接
				Socket client = server.accept();
				System.out.println("server accept");
				// 处理这次连接
				new PServer(client);
			}
		} catch (Exception e) {
			System.out.println("服务器异常: " + e.getMessage());
		}
	}

	private class PServer implements Runnable {
		private Socket socket;
		public PServer(Socket sock) {
			socket = sock;
			new Thread(this).start();
		}
		public void run() {
			System.out.println("一个客户端连接ip:" + socket.getInetAddress());
			try {
				// 读取客户端数据
				DataInputStream input = new DataInputStream(
						socket.getInputStream());
				// 向客户端发送数据
				DataOutputStream out = new DataOutputStream(
						socket.getOutputStream());
				// 读取客户端数据
				//System.out.println("客户端发过来的内容: " + input.readUTF());
				byte[] bt = new byte[1024];
				int leng = input.read(bt);
				System.out.println(new String(bt, 0, leng));
				// 发送键盘输入的一行
				// String s = new BufferedReader(new
				// InputStreamReader(System.in)).readLine();
				String s = "server d shu ru";
				out.write(s.getBytes());
				out.flush();
				input.close();
				out.close();
				socket.close();
			} catch (Exception e) {
				System.out.println("服务器 run 异常: " + e.getMessage());
			}
		}

	}

}


客户端改进如下： 
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">  
<html>  
<head>  
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">  
<title>Insert title here</title>  
</head>  
<script type="text/javascript">  
    var ws = null;
    function log(text) {
       document.getElementById("log").innerHTML = (new Date).getTime() + ": " + text +"<br>"+  document.getElementById("log").innerHTML;
    }  
    function startServer() {  
        var url = document.getElementById("serverip").value;// "ws://192.168.0.102:8887";  
        if ('WebSocket' in window) {  
            ws = new WebSocket(url);  
        } else if ('MozWebSocket' in window) {  
            ws = new MozWebSocket(url);  
        } else {  
            alert('浏览器不支持');  
            return;
        }  
        ws.onopen = function() {  
            alert('Opened!');  
        };  
        // 收到服务器发送的文本消息, event.data表示文本内容  
        ws.onmessage = function(event) {  
            //alert('Receive message: ' + event.data); 
            log('Receive message: ' + event.data); 
        };  
        ws.onclose = function() {  
          alert('Closed!');  
        }  
        document.getElementById("conbtn").disabled="true";
        document.getElementById("stopbtn").removeAttribute('disabled');
	}  
    //发送信息  
    function sendMessage(){  
        var textMessage=document.getElementById("textMessage").value;  
          
        if(ws!=null&&textMessage!=""){  
            ws.send(textMessage);  
              
        }  
    }  
    function stopconn(){
		ws.close();
    	document.getElementById("conbtn").removeAttribute('disabled');
    	document.getElementById("stopbtn").disabled="true";
    }
</script>  
<body onload="">  
		<input id="serverip" type="text"  size="20" value="ws://192.168.0.102:8887"/> 
		<input id="conbtn" type="button" onclick="startServer()" value="open" />
		<input id="stopbtn" type="button" onclick="stopconn()" value="stop" disabled="disabled"/>
		</br>
        <input id="textMessage" type="text"  size="20" />  
        <input type="button" onclick="sendMessage()" value="Send">  
        <div id="log"></div>
    </body>  
</html>



servlet中发现，不能广播，只能单纯的返回，如果想每个浏览器都受到消息，则修改如下 
package com.hao;

import java.io.DataInputStream;
import java.io.IOException;
import java.io.PrintWriter;
import java.net.Socket;
import java.net.UnknownHostException;
import java.nio.ByteBuffer;
import java.nio.CharBuffer;
import java.util.ArrayList;

import javax.servlet.http.HttpServletRequest;

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

public class HelloWorldWebSocketServlet extends WebSocketServlet {
	private static ArrayList mmiList  = new ArrayList();

	protected StreamInbound createWebSocketInbound(String subProtocol,
			HttpServletRequest arg1) {
		return new MyMessageInbound();
	}

	private class MyMessageInbound extends MessageInbound {
		WsOutbound myoutbound;

		@Override
		public void onOpen(WsOutbound outbound) {
			try {
				System.out.println("Open Client.");
				this.myoutbound = outbound;
				mmiList .add(this);
				outbound.writeTextMessage(CharBuffer.wrap("Hello!"));
			} catch (IOException e) {
				e.printStackTrace();
			}
		}

		@Override
		public void onClose(int status) {
			System.out.println("Close Client.");
			mmiList .remove(this);
		}

		@Override
		protected void onBinaryMessage(ByteBuffer arg0) throws IOException {
			// TODO Auto-generated method stub

		}

		@Override
		protected void onTextMessage(CharBuffer message) throws IOException {
			// TODO Auto-generated method stub
			System.out.println("onText--->" + message.toString());
			for (int i=0;i< mmiList.size();i++ ) {
				MyMessageInbound mmib = (MyMessageInbound) mmiList.get(i);
                CharBuffer buffer = CharBuffer.wrap(message);
                mmib.myoutbound.writeTextMessage(buffer);
                mmib.myoutbound.flush();
            }
			
			/*Socket socket;
			String msg = "";
			try {
				// 向服务器利用Socket发送信息
				socket = new Socket("192.168.0.102", 5000);
				// socket = new Socket("127.0.0.1",5000);
				PrintWriter output = new PrintWriter(socket.getOutputStream());

				output.write(message.toString());
				output.flush();

				// 这里是接收到Server的信息
				DataInputStream input = new DataInputStream(
						socket.getInputStream());
				byte[] b = new byte[1024];
				input.read(b);
				// Server返回的信息
				msg = new String(b).trim();

				output.close();
				input.close();
				socket.close();
			} catch (UnknownHostException e) {
				e.printStackTrace();
			} catch (IOException e) {
				e.printStackTrace();
			}
			// 往浏览器发送信息
			CharBuffer cb = CharBuffer.wrap(new StringBuilder(msg));
			getWsOutbound().writeTextMessage(cb);*/
		}
	}

	public static void main(String[] args) {
		Socket socket;
		String message = "haoning";
		String msg = "";
		try {
			// 向服务器利用Socket发送信息
			socket = new Socket("192.168.0.102", 5000);
			// socket = new Socket("127.0.0.1",5000);
			PrintWriter output = new PrintWriter(socket.getOutputStream());

			output.write(message.toString());
			output.flush();

			// 这里是接收到Server的信息
			DataInputStream input = new DataInputStream(socket.getInputStream());
			byte[] b = new byte[1024];
			input.read(b);
			// Server返回的信息
			msg = new String(b).trim();

			output.close();
			input.close();
			socket.close();
		} catch (UnknownHostException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
}

这段参考
http://blog.fens.me/java-websocket-intro/
分享到：
| tcp/ip sockets 编程 java和c的对比
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    Nginx + Websocket 实现推送

    Nginx + Websocket 实现推送 , 实现思路 : http://blog.csdn.net/shangmingtao/article/details/76639821 . 代码可以直接线上运行.

    容器网页终端（websocket-webshell）

    在WebSocket-WebShell的场景中，Tomcat8可能作为WebSocket服务器运行，处理来自客户端的WebSocket连接，并将这些连接转发到Docker容器中的SSH服务。 在项目"websocket-tail-demo-master"中，我们可以预见到一些关键...

    websocket私聊点对点通讯

    在Java环境下，我们可以使用Tomcat 7及以上版本，因为Tomcat从7.0.27版本开始内置了对WebSocket的支持，无需额外配置web.xml。我们可以创建一个继承自`javax.websocket.Endpoint`的类，并重写其`onOpen`、`onClose`...

    html5 支持的websocket小案例源代码

    Tomcat 7是第一个正式支持WebSocket的版本，因此，这两个jar包——catalina.jar和tomcat-coyote.jar，很可能是Tomcat服务器的核心组件，它们负责处理HTTP和HTTPS请求，以及WebSocket协议的解析和管理。 catalina....

    websocket服务器

    Tomcat7是一个广泛使用的开源Java Servlet容器，支持包括WebSocket在内的多种Web技术。在Java中实现WebSocket，我们需要遵循JSR 356规范，该规范定义了`javax.websocket`包下的API。 创建WebSocket服务器端点类...

    Springboot+Websocket示例

    在本文中，我们将深入探讨如何使用Spring Boot和WebSocket技术创建一个简单的实时通信示例。Spring Boot简化了Java Web应用程序的开发过程，而WebSocket则提供了一种双向通信协议，允许服务器和客户端之间进行低延迟...

    WebSocket 实现聊天室

    在这个项目中，服务器端通常会使用Java的WebSocket API，例如`javax.websocket`包，创建一个WebSocket端点（Endpoint）。这个端点类会处理客户端的连接请求、消息接收和发送。例如，你可以看到一个名为`...

    java仿QQ聊天室（websocket）

    为了部署这个项目，首先需要确保服务器环境支持WebSocket，如Tomcat 7及以上版本或者Jetty等支持WebSocket的Servlet容器。然后，将项目打包成WAR文件，将其部署到服务器的webapps目录下，最后配置好数据库连接参数，...

    基于eclipse，websocket的聊天界面

    1. **服务器端**：通常使用Java的WebSocket API（如Jetty或Tomcat的WebSocket支持）来创建WebSocket服务端，处理客户端的连接、断开、消息接收和发送。 2. **客户端**：在HTML页面中，使用JavaScript（结合jQuery和...

    WebRtc.rar_WEBSOCKET 视频_webRTC服务器_webrtc与websocket_websocket_web

    在这个项目中，服务器端使用Java编程语言实现，这可能利用了Java的WebSocket库，如Jetty或Tomcat的WebSocket API。 3. **客户端实现**: 客户端基于Chrome浏览器，这是因为Chrome浏览器对WebRTC的支持最为完善。在...

    websocket实现“支持客户聊天”功能

    同时，你可能还需要配置服务器环境（例如Tomcat或Jetty），以便部署和运行WebSocket应用。 "websocket客户聊天"这个压缩包文件可能包含了实现上述功能的相关代码和配置文件。解压后，你可以查看其中的Java类和...

    apache-tomcat-8.5.47-windows-x64.zip

    Tomcat 8.5.x系列是Tomcat的稳定版本，提供了对Java Servlet 3.1、JavaServer Pages (JSP) 2.3以及WebSocket 1.1规范的支持。版本8.5.47修复了若干安全漏洞和性能问题，增强了服务器的安全性和稳定性。用户应该定期...

    最新版windows apache-tomcat-8.5.69-windows-x64.zip

    这种组合被称为"Apache+Tomcat"或"Apache+mod_jk"，其中mod_jk是Apache的模块，负责在Apache和Tomcat之间转发请求。 对于开发者来说，Tomcat 8.5.69提供了丰富的API和工具，如JMX（Java Management Extensions）...

    apache-tomcat-8.5.15

    7. **热部署**：Tomcat允许在不重启服务器的情况下更新Web应用，只需将新的WAR文件放入`webapps`目录，Tomcat会自动检测并部署。 8. **线程池**：Tomcat 8.5引入了更高效的线程池模型，提高了并发处理能力。 9. **...

    Tomcat是什么.docx

    通过配置规则，它们可以将静态资源请求直接转发给 Nginx 或 Apache 自身处理，而将动态请求转发给后端的 Tomcat 服务器。 2. **动静分离** - 这种架构模式称为“动静分离”，即静态资源和动态内容由不同的服务器...

    websocket构建实时web应用

    `等选项来确保正确转发Websocket连接。 - **Tomcat配置**：Tomcat也需要进行相应的配置以支持Websocket，例如启用Websocket支持、调整最大连接数等。 #### 七、Websocket的编程接口 - **客户端API**：现代浏览器...

    基于tomcat7利用webrtc API实现一对一视频通话

    而`RTCApp`可能是服务器端的Java应用程序，使用WebSocket API实现信令服务。它需要监听客户端的连接，接收并广播信令消息，同时处理其他服务器端任务，如认证、会话管理等。 为了实现一对一视频通话，你需要执行...

    java实现websocket聊天室

    在实际部署时，我们需要一个支持WebSocket的服务器，如Tomcat或Jetty。部署完成后，用户可以通过浏览器访问聊天室页面，然后使用WebSocket API与服务器进行交互，实现聊天功能。 总的来说，这个Java实现的WebSocket...

    tomcat-v7.0.109.zip

    3. **WebSocket支持**：从Tomcat 7开始，它包含了WebSocket API的支持，这是一种在客户端和服务器之间建立长时间连接的协议，用于实现实时通信。 **Apache Tomcat 7.0.109中的主要改进和特性：** 1. **安全性增强**...

    apache-tomcat-8.0.15

    Apache Tomcat 8.0.15 是一个广泛使用的开源软件，它是一个实现了Java Servlet、JavaServer Pages（JSP）和Java EE的Web应用程序容器。这个版本是Tomcat服务器的一个重要分支，它提供了对Java EE 7规范的支持，使得...

Magicbox
Global site tag (gtag.js) - Google Analytics