Java Socket实现基于TCP和UDP多线程通信
2016-11-12 19:11
399 查看
一.通过Socket实现TCP编程
1.1 TCP编程
TCP协议是面向连接,可靠的,有序的,以字节流的方式发送数据。基于TCP协议实现网络通信的类有客户端的Socket类和服务器端的ServerSocket类。
1.2 服务器端套路
1.创建ServerSocket对象,绑定监听端口。
2.通过accept()方法监听客户端请求。
3.连接建立后,通过输入流读取客户端发送的请求信息。
4.通过输出流向客户端发送响应信息。
5.关闭响应的资源。
1.3 客户端套路
1.创建Socket对象,指明需要连接的服务器的地址和端口号。
2.连接建立后,通过输出流向服务器发送请求信息。
3.通过输入流获取服务器响应的信息。
4.关闭相应资源。
1.4 多线程实现服务器与多客户端之间通信步骤
1.服务器端创建ServerSocket,循环调用accept()等待客户端连接。
2. 客户端创建一个socket并请求和服务器端连接。
3.服务器端接受客户端请求,创建socket与该客户建立专线连接。
4.建立连接的两个socket在一个单独的线程上对话。
5.服务器端继续等待新的连接。
1.5 创建处理线程类ServerThread
这里选择实现runnable接口而不是继承Thread是因为一个类只能继承一个父类,当我需要继承其他类的时,父类就就不好处理了。
1.6 创建服务器端类
使用while以达到可以循环侦听不同客户端的连接请求。因为这是一个死循环,所以不用关闭也没有机会去关闭serverSocket。设置count值,用于记录服务器端被连接过的次数并显示客户端所在ip值。如果线程处理类是继承Thread类,那么创建新线程代码可以改为ServerThread serverThread = new ServerThread(socket);serverThread.start();
1.7 创建客户端类
在后面的关闭资源中,我把输入输出相关的流关闭注释了,是因为对于同一个Socket,关闭socket的时候也会把输入输出流关闭,直接关闭socket就行,当然保留也是可以的。
1.8 先运行服务器端,在运行客户端
![](https://images2015.cnblogs.com/blog/917807/201611/917807-20161112153930139-1748550364.png)
![](https://images2015.cnblogs.com/blog/917807/201611/917807-20161112154108842-886277533.png)
此时在看服务器控制台:服务器端一直在循环侦听客户端的连接
![](https://images2015.cnblogs.com/blog/917807/201611/917807-20161112154345483-1074594776.png)
1.9 进行第二个客户端的连接
修改相应信息将用户名zzh改为admin。运行客户端,打开服务端控制台
![](https://images2015.cnblogs.com/blog/917807/201611/917807-20161112154811702-229865403.png)
输出客户端的ip都为127.0.0.1,是因为服务器和客户端都是本机,在真实的环境中会显示客户端的ip地址信息。
二. 通过Socket实现UDP编程
2.1 UDP编程
UDP协议又叫用户数据报协议,是无连接,不可靠的,无序的。特点是传输速度相对要快,UDP协议以数据报作为数据传输的载体。当进行数据传输时,首先需要将要传输的数据定义成数据报(Datagram),在数据报中指明数据所要达到的Socket(主机地址和端口号),然后再将数据报发送出去。相关操作类有:DatagramPacket数据报包,DatagramSocket进行端到端通信的类。
2.2 服务器端实现套路
1.创建DatagramSocket,指定端口号。2.创建DatagramPacket。3.接收客户端发送的数据信息。4.读取数据。
2.3 客户端实现套路
1.定义发送信息,比如发送地址,端口号和内容。2. 创建DatagramPacket,包含将要发送的信息。3.创建DatagramSocket。4.发送数据。
2.4 多线程实现服务器与多客户端之间通信步骤
1.服务器端创建DatagramSocket的实例socket,循环调用receive()方法,此方法在接收到数据报之前会一直阻塞。
2.客户端创建DatagramSocket,将含有地址,端口号和内容的数据报包发送出去。
3. 服务器端收到数据报包packet,通过DatagramSocket和packet与客户端建立一个线程
4. 服务器端继续等待新的数据报包。
5. 发送方的DatagramPacket构造方法传递四个参数包含数据内容,数据大小,地址和端口号。接收方的DatagramPacket构造方法有两个参数接收数据和数据大小。
2.5 创建服务器线程处理类UDPThread
注意,DatagramSocket的实例socket不能关闭,会出现SocketException。读取数据用到的new String(packet.getData(), 0, packet.getLength()),参数表示数据报中的字节数组,位置和长度。
2.6 创建服务器端类
之前我将new DatagramSocket放入了while循环中,报了java.net.BindException: Address already in use: Cannot bind,才知道不能在while中连续创建新的DatagramSocket对象。
2.7 创建客户端类
2.8 先运行服务器端,在运行客户端
![](https://images2015.cnblogs.com/blog/917807/201611/917807-20161112172119889-617837312.png)
![](https://images2015.cnblogs.com/blog/917807/201611/917807-20161112172139889-1739719789.png)
![](https://images2015.cnblogs.com/blog/917807/201611/917807-20161112172151280-627091748.png)
2.9 修改客户端信息,再次运行客户端
![](https://images2015.cnblogs.com/blog/917807/201611/917807-20161112172326342-1254553483.png)
服务器控制台:服务器端一直在循环等待接收客户端的数据。
三. 总结
这两个例子只是简单的实现了基于TCP和UDP的socket编程,其中像多线程的优先级等都暂且没做考虑,不过依然要强调一下,服务器与多个客户端进行通信,因为是死循环,不设置多线程优先级,可能会导致运行时速度非常慢,优先级的范围1-10,默认为5,我们可以适当降低线程的优先级,比如thread.setPriority(4);
对于同一个socket,如果关闭了输出流比如(pw.close()),则与该输出流关联的socket也会关闭,所以一般不需要关闭输出流,当关闭socket的时候,输出流也会关闭,直接关闭socket就行。
在使用TCP通信传输信息时,更多是使用对象的形式来传输,可以使用ObjectOutputStream对象序列化流来传递对象,比如ObjectOutputStream os = new ObjectOutputStream(socket.getOutputStream());User user = new User("admin","123"); os.writeObject(user);
希望这篇文章能让你有所获,麻烦点赞或关注我,谢谢观看!
1.1 TCP编程
TCP协议是面向连接,可靠的,有序的,以字节流的方式发送数据。基于TCP协议实现网络通信的类有客户端的Socket类和服务器端的ServerSocket类。
1.2 服务器端套路
1.创建ServerSocket对象,绑定监听端口。
2.通过accept()方法监听客户端请求。
3.连接建立后,通过输入流读取客户端发送的请求信息。
4.通过输出流向客户端发送响应信息。
5.关闭响应的资源。
1.3 客户端套路
1.创建Socket对象,指明需要连接的服务器的地址和端口号。
2.连接建立后,通过输出流向服务器发送请求信息。
3.通过输入流获取服务器响应的信息。
4.关闭相应资源。
1.4 多线程实现服务器与多客户端之间通信步骤
1.服务器端创建ServerSocket,循环调用accept()等待客户端连接。
2. 客户端创建一个socket并请求和服务器端连接。
3.服务器端接受客户端请求,创建socket与该客户建立专线连接。
4.建立连接的两个socket在一个单独的线程上对话。
5.服务器端继续等待新的连接。
1.5 创建处理线程类ServerThread
这里选择实现runnable接口而不是继承Thread是因为一个类只能继承一个父类,当我需要继承其他类的时,父类就就不好处理了。
package com.tzzh; import java.io.BufferedReader; import java.io.IOException; import java.io.InputStream; import java.io.InputStreamReader; import java.io.OutputStream; import java.io.PrintWriter; import java.net.Socket; public class ServerThread implements Runnable{ Socket socket = null;//和本线程相关的Socket public ServerThread(Socket socket) { this.socket = socket; } @Override public void run() { InputStream is = null; InputStreamReader isr = null; BufferedReader br = null; OutputStream os = null; PrintWriter pw = null; try { //与客户端建立通信,获取输入流,读取取客户端提供的信息 is = socket.getInputStream(); isr = new InputStreamReader(is,"GBK"); br = new BufferedReader(isr); String data = null; while((data=br.readLine()) != null){//循环读取客户端的信息 System.out.println("我是服务器,客户端提交信息为:"+data); } socket.shutdownInput();//关闭输入流 //获取输出流,响应客户端的请求 os = socket.getOutputStream(); pw = new PrintWriter(os); pw.write("服务器端响应成功!"); pw.flush(); } catch (IOException e) { e.printStackTrace(); }finally { //关闭资源即相关socket try { if(pw!=null) pw.close(); if(os!=null) os.close(); if(br!=null) br.close(); if(isr!=null) isr.close(); if(is!=null) is.close(); if(socket!=null) socket.close(); } catch (IOException e) { e.printStackTrace(); } } } }
1.6 创建服务器端类
使用while以达到可以循环侦听不同客户端的连接请求。因为这是一个死循环,所以不用关闭也没有机会去关闭serverSocket。设置count值,用于记录服务器端被连接过的次数并显示客户端所在ip值。如果线程处理类是继承Thread类,那么创建新线程代码可以改为ServerThread serverThread = new ServerThread(socket);serverThread.start();
package com.tzzh; import java.io.IOException; import java.net.InetAddress; import java.net.ServerSocket; import java.net.Socket; public class Server { public static void main(String[] args) { try { //创建一个服务器端的Socket,即ServerSocket,绑定需要监听的端口 ServerSocket serverSocket = new ServerSocket(8888); Socket socket = null; //记录连接过服务器的客户端数量 int count = 0; System.out.println("***服务器即将启动,等待客户端的连接***"); while(true){//循环侦听新的客户端的连接 //调用accept()方法侦听,等待客户端的连接以获取Socket实例 socket = serverSocket.accept(); //创建新线程 Thread thread = new Thread(new ServerThread(socket)); thread.start(); count++; System.out.println("服务器端被连接过的次数:"+count); InetAddress address = socket.getInetAddress(); System.out.println("当前客户端的IP为:"+address.getHostAddress()); } //serverSocket.close();一直循环监听,不用关闭连接 } catch (IOException e) { e.printStackTrace(); } } }
1.7 创建客户端类
在后面的关闭资源中,我把输入输出相关的流关闭注释了,是因为对于同一个Socket,关闭socket的时候也会把输入输出流关闭,直接关闭socket就行,当然保留也是可以的。
package com.tzzh; import java.io.BufferedReader; import java.io.IOException; import java.io.InputStream; import java.io.InputStreamReader; import java.io.OutputStream; import java.io.PrintWriter; import java.net.Socket; import java.net.UnknownHostException; public class Client { public static void main(String[] args) { try { //创建客户端Socket,指定服务器地址和端口 Socket socket = new Socket("localhost", 8888); //建立连接后,获取输出流,向服务器端发送信息 OutputStream os = socket.getOutputStream(); //输出流包装为打印流 PrintWriter pw = new PrintWriter(os); //向服务器端发送信息 pw.write("用户名:zzh;密码:123");//写入内存缓冲区 pw.flush();//刷新缓存,向服务器端输出信息 socket.shutdownOutput();//关闭输出流 //获取输入流,接收服务器端响应信息 InputStream is = socket.getInputStream(); BufferedReader br = new BufferedReader(new InputStreamReader(is, "GBK")); String data = null; while((data=br.readLine())!= null){ System.out.println("我是客户端,服务器端提交信息为:"+data); } //关闭其他资源 // br.close(); // is.close(); // pw.close(); // os.close(); socket.close(); } catch (UnknownHostException e) { e.printStackTrace(); } catch (IOException e) { e.printStackTrace(); } } }
1.8 先运行服务器端,在运行客户端
![](https://images2015.cnblogs.com/blog/917807/201611/917807-20161112153930139-1748550364.png)
![](https://images2015.cnblogs.com/blog/917807/201611/917807-20161112154108842-886277533.png)
此时在看服务器控制台:服务器端一直在循环侦听客户端的连接
![](https://images2015.cnblogs.com/blog/917807/201611/917807-20161112154345483-1074594776.png)
1.9 进行第二个客户端的连接
修改相应信息将用户名zzh改为admin。运行客户端,打开服务端控制台
![](https://images2015.cnblogs.com/blog/917807/201611/917807-20161112154811702-229865403.png)
输出客户端的ip都为127.0.0.1,是因为服务器和客户端都是本机,在真实的环境中会显示客户端的ip地址信息。
二. 通过Socket实现UDP编程
2.1 UDP编程
UDP协议又叫用户数据报协议,是无连接,不可靠的,无序的。特点是传输速度相对要快,UDP协议以数据报作为数据传输的载体。当进行数据传输时,首先需要将要传输的数据定义成数据报(Datagram),在数据报中指明数据所要达到的Socket(主机地址和端口号),然后再将数据报发送出去。相关操作类有:DatagramPacket数据报包,DatagramSocket进行端到端通信的类。
2.2 服务器端实现套路
1.创建DatagramSocket,指定端口号。2.创建DatagramPacket。3.接收客户端发送的数据信息。4.读取数据。
2.3 客户端实现套路
1.定义发送信息,比如发送地址,端口号和内容。2. 创建DatagramPacket,包含将要发送的信息。3.创建DatagramSocket。4.发送数据。
2.4 多线程实现服务器与多客户端之间通信步骤
1.服务器端创建DatagramSocket的实例socket,循环调用receive()方法,此方法在接收到数据报之前会一直阻塞。
2.客户端创建DatagramSocket,将含有地址,端口号和内容的数据报包发送出去。
3. 服务器端收到数据报包packet,通过DatagramSocket和packet与客户端建立一个线程
4. 服务器端继续等待新的数据报包。
5. 发送方的DatagramPacket构造方法传递四个参数包含数据内容,数据大小,地址和端口号。接收方的DatagramPacket构造方法有两个参数接收数据和数据大小。
2.5 创建服务器线程处理类UDPThread
注意,DatagramSocket的实例socket不能关闭,会出现SocketException。读取数据用到的new String(packet.getData(), 0, packet.getLength()),参数表示数据报中的字节数组,位置和长度。
package com.uzzh; import java.io.IOException; import java.net.DatagramPacket; import java.net.DatagramSocket; import java.net.InetAddress; public class UDPThread implements Runnable{ DatagramSocket socket = null; DatagramPacket packet = null; public UDPThread(DatagramSocket socket,DatagramPacket packet) { this.socket = socket; this.packet = packet; } @Override public void run() { String info = null; InetAddress address = null; int port = 8800; byte[] data2 = null; DatagramPacket packet2 = null; try { info = new String(packet.getData(), 0, packet.getLength()); System.out.println("我是服务器,客户端说:"+info); address = packet.getAddress(); port = packet.getPort(); data2 = "我在响应你!".getBytes(); packet2 = new DatagramPacket(data2, data2.length, address, port); socket.send(packet2); } catch (IOException e) { e.printStackTrace(); } //socket.close();不能关闭 } }
2.6 创建服务器端类
package com.uzzh; import java.io.IOException; import java.net.DatagramPacket; import java.net.DatagramSocket; import java.net.InetAddress; public class UDPServer { public static void main(String[] args) throws IOException { DatagramSocket socket = new DatagramSocket(8800); DatagramPacket packet = null; byte[] data = null; int count = 0; System.out.println("***服务器端启动,等待发送数据***"); while(true){ data = new byte[1024];//创建字节数组,指定接收的数据包的大小 packet = new DatagramPacket(data, data.length); socket.receive(packet);//此方法在接收到数据报之前会一直阻塞 Thread thread = new Thread(new UDPThread(socket, packet)); thread.start(); count++; System.out.println("服务器端被连接过的次数:"+count); InetAddress address = packet.getAddress(); System.out.println("当前客户端的IP为:"+address.getHostAddress()); } } }
之前我将new DatagramSocket放入了while循环中,报了java.net.BindException: Address already in use: Cannot bind,才知道不能在while中连续创建新的DatagramSocket对象。
2.7 创建客户端类
package com.uzzh; import java.io.IOException; import java.net.DatagramPacket; import java.net.DatagramSocket; import java.net.InetAddress; public class UDPClient { public static void main(String[] args) throws IOException { //定义服务器的地址,端口号,数据 InetAddress address = InetAddress.getByName("localhost"); int port = 8800; byte[] data = "用户名:admin;密码:123".getBytes();//将字符串转换为字节数组 //创建数据报 DatagramPacket packet = new DatagramPacket(data, data.length, address, port); //创建DatagramSocket,实现数据发送和接收 DatagramSocket socket = new DatagramSocket(); //向服务器端发送数据报 socket.send(packet); //接收服务器响应数据 byte[] data2 = new byte[1024]; DatagramPacket packet2 = new DatagramPacket(data2, data2.length); socket.receive(packet2); String info = new String(data2, 0, packet2.getLength()); System.out.println("我是客户端,服务器说:"+info); socket.close(); } }
2.8 先运行服务器端,在运行客户端
![](https://images2015.cnblogs.com/blog/917807/201611/917807-20161112172119889-617837312.png)
![](https://images2015.cnblogs.com/blog/917807/201611/917807-20161112172139889-1739719789.png)
![](https://images2015.cnblogs.com/blog/917807/201611/917807-20161112172151280-627091748.png)
2.9 修改客户端信息,再次运行客户端
![](https://images2015.cnblogs.com/blog/917807/201611/917807-20161112172326342-1254553483.png)
服务器控制台:服务器端一直在循环等待接收客户端的数据。
三. 总结
这两个例子只是简单的实现了基于TCP和UDP的socket编程,其中像多线程的优先级等都暂且没做考虑,不过依然要强调一下,服务器与多个客户端进行通信,因为是死循环,不设置多线程优先级,可能会导致运行时速度非常慢,优先级的范围1-10,默认为5,我们可以适当降低线程的优先级,比如thread.setPriority(4);
对于同一个socket,如果关闭了输出流比如(pw.close()),则与该输出流关联的socket也会关闭,所以一般不需要关闭输出流,当关闭socket的时候,输出流也会关闭,直接关闭socket就行。
在使用TCP通信传输信息时,更多是使用对象的形式来传输,可以使用ObjectOutputStream对象序列化流来传递对象,比如ObjectOutputStream os = new ObjectOutputStream(socket.getOutputStream());User user = new User("admin","123"); os.writeObject(user);
希望这篇文章能让你有所获,麻烦点赞或关注我,谢谢观看!
相关文章推荐
- Java Socket实现基于TCP和UDP多线程通信
- Java Socket实现基于TCP和UDP多线程通信
- Java Socket实现基于TCP和UDP多线程通信
- Java Socket实现基于TCP和UDP多线程通信
- Java Socket实现基于TCP和UDP多线程通信
- Java Socket实现基于TCP和UDP多线程通信
- JAVA socket实现TCP/UDP的多线程通信
- Android实现基于TCP和UDP协议的即时通讯,含android端和服务器端
- 基于混合TCP-UDP的HTTP协议实现方法
- 基于TCP和UDP的Socket实现(JAVA)
- Java Socket应用(五)——编程实现基于 TCP 的 Socket 通信
- 利用TCP和UDP协议,实现基于Socket的小聊天程序(初级版)
- 简单实现基于UDP的Socket多线程通信
- 基于TCP和UDP的聊天功能的实现
- (TCP-over-UDP library):基于UDP协议之上实现通用、可靠、高效的TCP协议 ---------- 转
- 简单实现基于TCP的Socket多线程通信
- JAVA Socket 底层是怎样基于TCP/IP实现的???
- (TCP-over-UDP library):基于UDP协议之上实现通用、可靠、高效的TCP协议
- TDP(TCP-over-UDP library):基于UDP协议之上实现
- 基于混合TCP-UDP的HTTP协议实现方法