网络编程之Socket通信（Java）进阶版

最新推荐文章于 2023-02-12 13:33:54 发布
最新推荐文章于 2023-02-12 13:33:54 发布
阅读量621 收藏 3
点赞数 1
分类专栏： socket网络编程 文章标签： 网络编程 socket 通信 服务器

之前在前面已经介绍了Socket通信的一些基本原理，以及如何让客户端与服务器端建立通信，和实现通信的一些基本步骤（包括首先使得服务器端与客户端建立连接，建立连接之后，服务器端开始侦听客户端的请求，侦听到客户端的请求之后，通过输入输出流处理相关信息实现通信，最后通信完毕结束通信等一系列流程）。

但是之前只是单个客户端与服务器进行通信，而我们实际应用中单个客户端的情况几乎不存在，都是多个客户端同时与服务器进行交互（这里同时交互就会出现并发性的问题，对于并发性的问题暂时还不是很懂，只知道有这个概念），那就需要服务器端不停的侦听客户端的请求（写在while循环中，并且条件始终为true，死循环），每当侦听到一个客户端的请求时，都需要创建一个Socket与之建立通信（通过线程实现，每当侦听到一个客户端的请求，服务端都要单独开辟一条线程与之进行通信）。


下面直接贴代码吧：


1、服务端Socket，（这里面通过死循环让服务器端一直循环侦听来自客户端的请求）

需要注意的是，服务端必须要先于客户端启动，因为要启动之后才能侦听客户端的请求


[java] view plain copy
print ?
  1. package com.socket;  
  2.   
  3. import java.io.IOException;  
  4. import java.net.ServerSocket;  
  5. import java.net.Socket;  
  6.   
  7. /** 
  8.  * 服务器端Socket 
  9.  * @author feizi 
  10.  * @time 2014-11-14下午5:08:16 
  11.  */  
  12. public class ServerSocketMany {  
  13.       
  14.     /** 
  15.      * main测试方法 
  16.      * @param args 
  17.      * @throws IOException 
  18.      */  
  19.     public static void main(String[] args) throws IOException{  
  20.           
  21.         System.out.println("服务器已经启动，等待客户端的连接....");  
  22.           
  23.         //创建服务器端Socket，即ServerSOcket，等待客户端的请求  
  24.         ServerSocket server = new ServerSocket(5555);  
  25.           
  26.         int count = 0;//侦听到的客户端的数量  
  27.           
  28.         Socket socket = null;//服务器端Socket  
  29.           
  30.         //死循环，让服务端循环侦听  
  31.         while(true){  
  32.               
  33.             //服务端开始侦听客户端的连接  
  34.             socket = server.accept();  
  35.               
  36.             //启动线程，与客户端进行通信  
  37.             Thread serverThread = new ServerThread(socket);  
  38.             serverThread.start();  
  39.               
  40.             //计数，统计客户端连接数  
  41.             count++;  
  42.               
  43.             System.out.println("当前链接的客户端的数量为："+count+"个....");  
  44.         }  
  45.     }  
  46. }  
package com.socket;

import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;

/**
 * 服务器端Socket
 * @author feizi
 * @time 2014-11-14下午5:08:16
 */
public class ServerSocketMany {
	
	/**
	 * main测试方法
	 * @param args
	 * @throws IOException
	 */
	public static void main(String[] args) throws IOException{
		
		System.out.println("服务器已经启动，等待客户端的连接....");
		
		//创建服务器端Socket，即ServerSOcket，等待客户端的请求
		ServerSocket server = new ServerSocket(5555);
		
		int count = 0;//侦听到的客户端的数量
		
		Socket socket = null;//服务器端Socket
		
		//死循环，让服务端循环侦听
		while(true){
			
			//服务端开始侦听客户端的连接
			socket = server.accept();
			
			//启动线程，与客户端进行通信
			Thread serverThread = new ServerThread(socket);
			serverThread.start();
			
			//计数，统计客户端连接数
			count++;
			
			System.out.println("当前链接的客户端的数量为："+count+"个....");
		}
	}
}


2、服务器端的线程实现类，线程中主要是实现与客户端的通信（通过输入输出流接收并响应数据信息）


[java] view plain copy
print ?
  1. package com.socket;  
  2.   
  3. import java.io.BufferedReader;  
  4. import java.io.IOException;  
  5. import java.io.InputStream;  
  6. import java.io.InputStreamReader;  
  7. import java.io.OutputStream;  
  8. import java.io.PrintWriter;  
  9. import java.net.Socket;  
  10.   
  11. /** 
  12.  * 创建一个服务端线程，循环侦听客户端的请求，多个客户端 
  13.  * @author feizi 
  14.  * @time 2014-11-14下午5:36:45 
  15.  */  
  16. public class ServerThread extends Thread{  
  17.   
  18.     //每当侦听到一个新的客户端的时，服务端这边都要有一个Socket与之进行通信  
  19.     public Socket socket = null;  
  20.       
  21.     //默认的构造方法，保留  
  22.     public ServerThread(){}  
  23.       
  24.     //带参构造方法  
  25.     public ServerThread(Socket socket){  
  26.         this.socket = socket;  
  27.     }  
  28.       
  29.     //覆写run方法  
  30.     public void run(){  
  31.         //获取输入字节流  
  32.         InputStream in = null;  
  33.           
  34.         //将输入字节流包装成输入字符流  
  35.         InputStreamReader isr = null;  
  36.           
  37.         //为字符输入流添加缓冲  
  38.         BufferedReader br = null;  
  39.           
  40.         //收到信息之后，向客户端响应信息,获取输出字节流  
  41.         OutputStream out = null;  
  42.           
  43.         //将字节输出流包装成字符打印输出流  
  44.         PrintWriter pw = null;  
  45.           
  46.         try {  
  47.               
  48.             in = socket.getInputStream();  
  49.             isr = new InputStreamReader(in);  
  50.             br = new BufferedReader(isr);  
  51.               
  52.             //读取字符输入流中的数据  
  53.             String data = null;  
  54.             while((data = br.readLine()) != null){  
  55.                 System.out.println("我是服务器，客户端说："+data);  
  56.             }  
  57.               
  58.             //调用shutDown方法关闭Socket输入流  
  59.             socket.shutdownInput();  
  60.               
  61.             out = socket.getOutputStream();  
  62.             pw = new PrintWriter(out);  
  63.             pw.write("用户名和密码正确");  
  64.             pw.flush();  
  65.               
  66.             //调用shutDown方法关闭Socket输出流  
  67.             socket.shutdownOutput();  
  68.               
  69.         } catch (IOException e) {  
  70.             e.printStackTrace();  
  71.         }finally{  
  72.               
  73.             //关闭资源  
  74.             try {  
  75.                 if(null != pw)  
  76.                     pw.close();  
  77.                 if(null != out)  
  78.                     out.close();  
  79.                 if(null != br)  
  80.                     br.close();  
  81.                 if(null != isr)  
  82.                     isr.close();  
  83.                 if(null != in)  
  84.                     in.close();  
  85.                 if(null != socket)  
  86.                     socket.close();  
  87.             } catch (IOException e) {  
  88.                 e.printStackTrace();  
  89.             }  
  90.         }  
  91.     }  
  92. }  
package com.socket;

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;

/**
 * 创建一个服务端线程，循环侦听客户端的请求，多个客户端
 * @author feizi
 * @time 2014-11-14下午5:36:45
 */
public class ServerThread extends Thread{

	//每当侦听到一个新的客户端的时，服务端这边都要有一个Socket与之进行通信
	public Socket socket = null;
	
	//默认的构造方法，保留
	public ServerThread(){}
	
	//带参构造方法
	public ServerThread(Socket socket){
		this.socket = socket;
	}
	
	//覆写run方法
	public void run(){
		//获取输入字节流
		InputStream in = null;
		
		//将输入字节流包装成输入字符流
		InputStreamReader isr = null;
		
		//为字符输入流添加缓冲
		BufferedReader br = null;
		
		//收到信息之后，向客户端响应信息,获取输出字节流
		OutputStream out = null;
		
		//将字节输出流包装成字符打印输出流
		PrintWriter pw = null;
		
		try {
			
			in = socket.getInputStream();
			isr = new InputStreamReader(in);
			br = new BufferedReader(isr);
			
			//读取字符输入流中的数据
			String data = null;
			while((data = br.readLine()) != null){
				System.out.println("我是服务器，客户端说："+data);
			}
			
			//调用shutDown方法关闭Socket输入流
			socket.shutdownInput();
			
			out = socket.getOutputStream();
			pw = new PrintWriter(out);
			pw.write("用户名和密码正确");
			pw.flush();
			
			//调用shutDown方法关闭Socket输出流
			socket.shutdownOutput();
			
		} catch (IOException e) {
			e.printStackTrace();
		}finally{
			
			//关闭资源
			try {
				if(null != pw)
					pw.close();
				if(null != out)
					out.close();
				if(null != br)
					br.close();
				if(null != isr)
					isr.close();
				if(null != in)
					in.close();
				if(null != socket)
					socket.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}
}



3、客户端Socket，这个和单客户端的情况一样，在第一篇中有详细介绍


[java] view plain copy
print ?
  1. package com.socket;  
  2.   
  3. import java.io.BufferedReader;  
  4. import java.io.IOException;  
  5. import java.io.InputStream;  
  6. import java.io.InputStreamReader;  
  7. import java.io.OutputStream;  
  8. import java.io.PrintWriter;  
  9. import java.net.Socket;  
  10. import java.net.UnknownHostException;  
  11.   
  12. /** 
  13.  * 客户端Socket 
  14.  * @author feizi 
  15.  * @time 2014-11-14下午5:18:06 
  16.  */  
  17. public class ClientSocketDemo {  
  18.       
  19.     /** 
  20.      * main测试方法 
  21.      * @param args 
  22.      * @throws UnknownHostException 
  23.      * @throws IOException 
  24.      */  
  25.     public static void main(String[] args) throws UnknownHostException, IOException{  
  26.           
  27.         //创建客户端Socket，向服务器发起请求  
  28. //      String address = "127.0.0.1";  
  29.         String address = "localhost";//服务器地址  
  30.           
  31.         int port = 5555;//端口号  
  32.         Socket socket = new Socket(address, port);  
  33.           
  34.         //获取Socket的字节输出流  
  35.         OutputStream out = socket.getOutputStream();  
  36.           
  37.         //将字节输出流包装成字符打印输出流  
  38.         PrintWriter pw = new PrintWriter(out);  
  39.           
  40. //      pw.print("用户名：admin,密码：123");  
  41. //      pw.print("用户名：tom,密码：456");  
  42. //      pw.print("用户名：dark,密码：789");  
  43. //      pw.print("用户名：white,密码：111");  
  44.         pw.print("用户名：green,密码：222");  
  45.           
  46.         //刷新输出流  
  47.         pw.flush();  
  48.           
  49.         //调用shutDown方法关闭Socket的输出流  
  50.         socket.shutdownOutput();  
  51.           
  52.         //接收服务器端发来的响应信息，获取字节输入流  
  53.         InputStream in = socket.getInputStream();  
  54.           
  55.         //将字节输入流包装成字符输入流  
  56.         InputStreamReader isr = new InputStreamReader(in);  
  57.           
  58.         //为字符输入流添加缓冲  
  59.         BufferedReader br = new BufferedReader(isr);  
  60.           
  61.         //读取字符输入流中的数据信息  
  62.         String data = null;  
  63.         while((data = br.readLine()) != null){  
  64.             System.out.println("我是客户端，服务器说："+data);  
  65.         }  
  66.           
  67.         //调用shutDown方法关闭Socket的输入流  
  68.         socket.shutdownInput();  
  69.           
  70.         br.close();  
  71.         isr.close();  
  72.         in.close();  
  73.         pw.close();  
  74.         out.close();  
  75.         socket.close();  
  76.     }  
  77. }  
package com.socket;

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;

/**
 * 客户端Socket
 * @author feizi
 * @time 2014-11-14下午5:18:06
 */
public class ClientSocketDemo {
	
	/**
	 * main测试方法
	 * @param args
	 * @throws UnknownHostException
	 * @throws IOException
	 */
	public static void main(String[] args) throws UnknownHostException, IOException{
		
		//创建客户端Socket，向服务器发起请求
//		String address = "127.0.0.1";
		String address = "localhost";//服务器地址
		
		int port = 5555;//端口号
		Socket socket = new Socket(address, port);
		
		//获取Socket的字节输出流
		OutputStream out = socket.getOutputStream();
		
		//将字节输出流包装成字符打印输出流
		PrintWriter pw = new PrintWriter(out);
		
//		pw.print("用户名：admin,密码：123");
//		pw.print("用户名：tom,密码：456");
//		pw.print("用户名：dark,密码：789");
//		pw.print("用户名：white,密码：111");
		pw.print("用户名：green,密码：222");
		
		//刷新输出流
		pw.flush();
		
		//调用shutDown方法关闭Socket的输出流
		socket.shutdownOutput();
		
		//接收服务器端发来的响应信息，获取字节输入流
		InputStream in = socket.getInputStream();
		
		//将字节输入流包装成字符输入流
		InputStreamReader isr = new InputStreamReader(in);
		
		//为字符输入流添加缓冲
		BufferedReader br = new BufferedReader(isr);
		
		//读取字符输入流中的数据信息
		String data = null;
		while((data = br.readLine()) != null){
			System.out.println("我是客户端，服务器说："+data);
		}
		
		//调用shutDown方法关闭Socket的输入流
		socket.shutdownInput();
		
		br.close();
		isr.close();
		in.close();
		pw.close();
		out.close();
		socket.close();
	}
}


下面是程序运行结果截图：


客户端：




服务器端：




大家可以点此链接查看单客户端与服务器端交互的情况：

Java网络编程之Socket通信（一）


每天成长一点点，始终坚信：天道酬勤，努力了，奋斗了，一切切有可能！奋斗奋斗奋斗

魅影骑士0050
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java网络编程socket非阻塞通信
06-14
通过java网络编程深入理解socket阻塞通信和非阻塞通信的在网络中的应用 源码包每一行都有注释，在代码里面每一个类都有详细的注释来解释这个类的功能这个方法的功能，调用哪一个类的哪一个功能等等。 压缩包包含实验...
Java网络编程基础教程之Socket入门实例
09-04
Java网络编程是构建分布式应用程序的关键技术之一，而Socket是其核心组件。Socket允许两个网络应用程序之间建立通信链路，通常用于客户端和服务器之间的交互。本教程将带你了解Java中Socket的基本使用，包括创建...
Java网络编程实现本地通信(一)
算法、原理、设计模式、非线性控制、深度强化学习
04-29 1936
目录 前言 计算机网络简介 网络编程的目的 网络通信的要素 地址： 规则： URL IP IP地址分类 1、公网IP、私网IP 2、ipv4/ipv6 3、本机IP地址 域名 JavaIP地址类：InetAddress Port 端口号 端口号分类 公有端口：0~1023 程序注册端口：1024~29151 动态私有端口：48152~65535 Windows查看本机端口命令 Java端口地址类：InetSocketAddress TCP-UDP协议 简介 .
opencv3 feature2d 的探索
slzlincent的博客
09-08 1049
想研究一下 feature.cpp中的detect() virtual void cv::Feature2D::detect ( InputArray image, std::vector< KeyPoint > & keypoints, ...
【网络编程】Java中的Socket
墨辰JC的博客
02-12 2645
包含实现网络上传文件。所谓Socket（套接字），就是对网络中不同主机上的应用进程之间进行双向通信的端点的抽象。一个套接字就是网络上进程通信的一端，提供了应用层进程利用网络协议交换数据的机制。从所处的地位来讲，套接字上联应用进程，下联网络协议栈，是应用程序通过网络协议进行通信的接口，是应用程序与网络协议栈进行交互的接口。套接字是通信的基石，是支持TCP/IP协议的路通信的基本操作单元。可以将套接字看作不同主机间的进程进行双间通信的端点，它构成了单个主机内及整个网络间的编程界面。
java socket报文通信（一）socket的建立
weixin_34163553的博客
12-26 491
java socket报文通信（一） socket的建立 今天来和大家分享一下java中如何使用socket进行通信。先来啰嗦两句，看看Tcp/ip和udp: TCP是Transfer Control Protocol的 简称，是一种面向连接的保证可靠传输的协议。通过TCP协议传输，得到的是一个顺序的无差错的数据流。发送方和接收方的成对的两个socket之间必须建 立连接，以便在TCP协议的...
JAVA TCP-IP Socket网络通信编程研究.pdf
04-05
JAVA TCP-IP Socket 网络通信编程研究 JAVA TCP-IP Socket 网络通信编程研究是关于使用 Java 语言实现基于 TCP/IP 协议的网络通信编程的研究。该研究主要关注于使用 Java Socket 实现 TCP/IP 网络程序框架及网络...
Java进阶学习网络服务器编程.rar
最新发布
07-10
在Java中，我们可以使用Socket编程来实现这一过程，Socket是网络通信的基本单位，它提供了两台机器间双向通信的端点。 接着，我们关注Java中的网络API，包括java.net包中的类，如Socket、ServerSocket、URL、...
java网络编程 socket的TCP应用编程
01-09
- Java Socket类和ServerSocket类是进行TCP网络编程的核心API。 - ServerSocket用于创建服务器端的套接字，监听特定端口的连接请求。 - Socket用于创建客户端的套接字，与服务器建立连接。 3. **服务端编程**： ...
java socket 点对点通信
01-03
程序功能为： （1） 服务器可以接受任何客户的连接 （2） 客户程序使用命令行参数指定服务器地址 （3） 客户端输入的文本都发送给服务器 （4） 客户使用输入end时停止发送，关闭连接 （5）服务器能同时连接多个客户端
java程序设计进阶版
08-24
java程序设计进阶版 原书第10版 清晰度较高、章节完整 pdf版本
java网络编程——网络版题库程序
08-25
java网络编程——网络版题库程序（主要技术java+socket+多线程+mysql），程序是C/S 版本的，由于服务器端是java写的，所有客户端使用android也是很容易与服务器对接的
Socket编程笔记
迷茫的小菜鸟丶的专栏
04-03 538
学习基于TCP/IP的Socket编程时整理的一些笔记。
自学JAVA基础 进阶版
weixin_45497576的博客
11-30 285
自学JAVA，笔记已上传
JAVA Socket编程——基于ServerSocket建立聊天服务器
热门推荐
浅然的专栏
02-27 2万+
该篇博客写一下关于Socket编程，java实现基于ServerSocket的聊天服务器。可实现客户端与客户端之间的群聊（win下cmd命令行模拟客户端） 该篇博客目录 1、Socket介绍 2、Socket编程在客户端与服务端的使用注意 3、java实现基于ServerSocket的聊天服务器 一、Socket介绍 Socket类实现客户端套接字（也...
java socket 进阶话题一： socket 客户端连接管理
撒哈拉的海马
01-23 2126
主控和代理端的消息通讯使用java socket，网上关于java socket 基础编程已经存在很多，本文主要探讨 java socket 中的一些延伸性的话题：多代理端同步消息通讯、 socket的分包和粘包，socket 客户端连接管理。
Java网络编程总结
wenzhi的博客
09-22 2万+
本文主要对java网络编程Socket类的使用做总结，其中Socket对象可以进行数据的读取和写入是必须要知道的！
java通讯教程_Java实现简单的socket通信教程
weixin_42220853的博客
02-12 295
今天学习了一下java如何实现socket通信，感觉难点反而是在io上，因为java对socket封装已经很完善了。今天代码花了整个晚上调试，主要原因是io的flush问题和命令行下如何运行具有package的类，不过最后问题基本都解决了，把代码贴出来供大家参考serverpublic class TcpServer {public static void main(String[] args) ...
Java网络编程（概念+实例）
06-17
Java语言中的网络编程主要依赖于`java.net`包提供的API，特别是Socket和ServerSocket类，这两个核心组件在实现客户端-服务器模型时起着至关重要的作用。 Socket编程是Java网络编程的基础，它是基于TCP（传输控制...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值