Java Socket编程基础实战

最新推荐文章于 2024-08-18 09:14:28 发布

菜根檀

最新推荐文章于 2024-08-18 09:14:28 发布

阅读量774

点赞数 1

分类专栏： Java 文章标签： java socket

本文链接：https://blog.csdn.net/cangafuture/article/details/109907454

版权

Java 专栏收录该内容

25 篇文章 1 订阅

订阅专栏

JavaSocket编程基础

- 利用Socket进行本地端口通信
- 线程及Socket编程

Socket是java网络编程的重要组成部分，包括我们所使用的网络通信或网络游戏，一般都是基于Socket进行编程的。

所谓套接字(Socket)，就是对网络中不同主机上的应用进程之间进行双向通信的端点的抽象。一个套接字就是网络上进程通信的一端，提供了应用层进程利用网络协议交换数据的机制。从所处的地位来讲，套接字上联应用进程，下联网络协议栈，是应用程序通过网络协议进行通信的接口，是应用程序与网络协议根进行交互的接口-----百度百科

接下来我将根据几个具体的小例子来对Java中的Socket方法进行一个简要介绍，方便大家对Socket编程有一个简单认识。

利用Socket进行本地端口通信

两个类：SimpleServerProgram.java和SimpleClientProgram.java 分别表示服务器端与客户端程序
SimpleServerProgram.java

package com.caigentan.java.net.socket;  
import java.io.*; 
import java.net.ServerSocket; 
import java.net.Socket;  
public class SimpleServerProgram {     
	public static void main(String[] args){         
	ServerSocket listener = null;         
	String line;         
	BufferedReader is;         
	BufferedWriter os;         
	Socket socketOfServer = null;          

	try {             
		listener = new ServerSocket(9999);         
	} catch (IOException e) {             
		e.printStackTrace();             
		System.exit(1);         
	}          

	try {             
		System.out.println("Server is waiting to accept user...");             
		socketOfServer = listener.accept();             
		System.out.println("accept client");              
		is = new BufferedReader(new InputStreamReader(socketOfServer.getInputStream()));             
		os = new BufferedWriter(new OutputStreamWriter(socketOfServer.getOutputStream()));              

		while (true){                 
			line = is.readLine();                 
			os.write(">>" + line);                 
			os.newLine();                 
			os.flush();                  
			if(line.equals("out")){                     
				os.write(">>ok");                     
				os.newLine();                     
				os.flush();                     
				break;                 
			}             
		}         
	} catch (IOException e) {             
		e.printStackTrace();         
	}         
	System.out.println("Server Stopped");     
	} 
}

对上面出现的一些函数进行简要解释：
BufferedReader is：用于从控制台获取信息
BufferedWriter os：用于向控制台写信息
Socket socketOfServer：初始化一个套接字
listener = new ServerSocket(9999)：用于向系统申请端口用于监听
socketOfServer = listener.accept()：监听，如果有客户端进行连接则相应
line = is.readLine()：从控制台逐行获取信息（控制台的信息来自客户端的os）
os.newLine()：类似回车操作
os.flush():写入内存保存
os.write(String str):发送信息 str 给对方

impleClientProgram.java

package com.caigentan.java.net.socket;  
import java.io.*; import java.net.Socket; 
import java.net.UnknownHostException;  
public class SimpleClientProgram {     
	public static void main(String[] args) {         
		final String serverHost = "localhost";         
		Socket socketOfClient = null;         
		BufferedReader is = null;         
		BufferedWriter os = null;          

		try {             
			socketOfClient = new Socket(serverHost,9999);             
			os = new BufferedWriter(new OutputStreamWriter(socketOfClient.getOutputStream()));             
			is = new BufferedReader(new InputStreamReader(socketOfClient.getInputStream()));          
		} catch (UnknownHostException e) {             
			System.out.println("Don't know Host");             
			e.printStackTrace();         
		} catch (IOException e) {             
			System.err.println("Couldn't get I/O for the connection to " + serverHost);             
			e.printStackTrace();         
		}          

		try {             
			os.write("hello");             
			os.newLine();             
			os.flush();             
			os.write("I'am caigentan");             
			os.newLine();             
			os.flush();             
			os.write("out");             
			os.newLine();             
			os.flush();              
			String responseLine;            
			while((responseLine = is.readLine()) != null){                 
				System.out.println("Server:" + responseLine);                 
				if (responseLine.indexOf("ok") != -1){                     
					break;                 
				}             
			}              

			os.close();             
			is.close();             
			socketOfClient.close();         
		} catch (IOException e) {             
			e.printStackTrace();         
		}     
	}  
}

结果：
启动Server
$Gt"E: \env variable\jdk-1108+10\bin\java. exe" Server is waiting to accept user$
启动Client
$t"E: \env variable\jdk-1108+10\bin\java.exe ↓ Server:>> hello Server: >>f am caigentan Server: >>out Server: >>0k$
此时的Server
$T"E: \env variable\jdk-1108+10\bin\java.exe" N Server is waiting to accept user accept client 数进 Server stopped$

线程及Socket编程

通常，我们在实际使用时，服务器与客户端进行通信往往是在线程上进行的（每次新线程建立时创建连接）
此处我们仍然具有两个类：ThreadServerProgram.java 和 ThreadClientProgram.java
ThreadServerProgram.java

package com.caigentan.java.net.socket;  
import java.io.*; 
import java.net.ServerSocket; 
import java.net.Socket;  
public class ThreadServerProgram {     
	public static void main(String[] args) throws IOException {         
		ServerSocket listener = null;         
		System.out.println("Server is waiting for accept...");         
		int clientNumber = 0;          
		try {             
			listener = new ServerSocket(7777);         
		} catch (IOException e) {             
			e.printStackTrace();             
			System.exit(1);         
		}          
		
		try {             
			while (true) {                 
				Socket socketOfServer = listener.accept();                 
				new ServiceThread(socketOfServer, clientNumber++).start();             
			}         
		} catch (IOException e) {             
			e.printStackTrace();         
		} finally {             
			listener.close();         
		}     
	}      

	private static void log(String message) {         
		System.out.println(message);     
	}      

	private static class ServiceThread extends Thread {         
		private Socket socketOfServer;         
		private int clientNumber;          
		public ServiceThread(Socket socketOfServer, int clientNumber) {             
			this.socketOfServer = socketOfServer;             
			this.clientNumber = clientNumber;              
			log("new connection of client #" + this.clientNumber + " at " + this.socketOfServer);         
		}          

		@Override         
		public void run() {             
			try {                 
				BufferedReader is = new BufferedReader(new InputStreamReader(socketOfServer.getInputStream()));
				BufferedWriter os = new BufferedWriter(new OutputStreamWriter(socketOfServer.getOutputStream()));                  
				while (true) {                     
					String line = is.readLine();                     
					os.write("from server >>" + line);                     
					os.newLine();                     
					os.flush();                      
					
					if (line.equals("exit")) {                         
						os.write("from server >>" + "ok");                         
						os.newLine();                         
						os.flush();                         
						break;                     
					}                 
				}             
			} catch (IOException e) {                 
				e.printStackTrace();             
			}         
		}     
	} 
}

ThreadClientProgram.java

package com.caigentan.java.net.socket;  
import javax.xml.crypto.Data; 
import java.io.*; 
import java.net.Socket; 
import java.net.UnknownHostException; 
import java.util.Date;  

public class ThreadClientProgram {     
	public static void main(String[] args) {         
		final String serverHost = "localhost";          
		Socket socketOfClient = null;         
		BufferedReader is = null;         
		BufferedWriter os = null;          

		try {             
			socketOfClient = new Socket(serverHost, 7777);             
			is = new BufferedReader(new InputStreamReader(socketOfClient.getInputStream()));             
			os = new BufferedWriter(new OutputStreamWriter(socketOfClient.getOutputStream()));         
		} catch (UnknownHostException e) {             
			e.printStackTrace();         
		} catch (IOException e) {             
			e.printStackTrace();         
		}          

		try {             
			os.write("Hello! now is " + new Date());             
			os.newLine();             
			os.flush();             
			os.write("I'm caigentan");             
			os.newLine();             
			os.flush();             
			os.write("exit");             
			os.newLine();             
			os.flush();              

			String responseLine;             
			while ((responseLine = is.readLine()) != null) {                 
				System.out.println(responseLine);                 
				if (responseLine.indexOf("ok") != -1) {                     
					break;                 
				}             
			}             

			os.close();             
			is.close();             
			socketOfClient.close();         
		} catch (IOException e) {             
			e.printStackTrace();         
		}     
	} 
}