[网络协议]11.网络编程

1.TCP通信

1.1 Socket原理

Socket简介
Socket通常称作套接字用于描述IP地址和端口，是一个通信连接的句柄。
在Internet上的主机一般运行了多个服务软件，同时提供集中服务。
每种服务都打开一个Soket，并绑定一个端口上，不同的端口对应于不同的服务。
应用程序通常通过“套接字”向网络发出请求或者应答网络请求。Socket和ServerSocket类位于java.net包中。ServerSocket用于服务端，Socket是建立网络连接时使用的。在连接成功时，应用程序两端都会生成一个Socket实例，操作这个实例，完成所需要的会话。

1.2 获取本地地址和端口号

Java.net.Socket为套接字类，其提供了很多方法， 其中我们可以通过Socket获取本地的地址以及端口号。
Int getLocalPort();
该方法用于获取本地使用的端口号
InetAddress getLocalAddresss();
该方法用于获取套接字绑定的本地地址
使用InetAddress获取本地的地址方法：
String getCanonicalHostName();
获取此IP地址的完全限定域名。
String getHostAddress()
返回IP地址字符串（以文本表现形式）

public static void testSocket() throws Exception {
	Socket socket =  new Socket("127.0.0.1",8088);
	InetAddress add = socket.getLocalAddress();
	System.out.println(add.getCanonicalHostName());
	System.out.println(add.getHostAddress());
	System.out.println(socket.getLocalPort());
}

1.3 获取远端地址和端口号

通过Socket获取远端的地址以及端口号。
Int getPort();
该方法用于获取远端使用的端口号
InetAddress.getInetAddress();
该方法用于获取套接字绑定的远端地址

public static void testSocket() throws Exception {
	Socket socket =  new Socket("localhost",8088);
	InetAddress inetAdd = socket.getLocalAddress();
	System.out.println(inetAdd.getCanonicalHostName());
	System.out.println(inetAdd.getHostAddress());
	System.out.println(socket.getPort());
}

1.4.获取网络输入流和网络输出流

通过Socket获取输入流于输出流，这两个方法是使用Socket通讯的关键方法。

inputStream getInputStream()
该方法用于返回此套接字的输入流。
OutputStream.getOutputStream()
该方法用于返回此套接字的输出流。

public static void testSocket() throws Exception {
	Socket socket =  new Socket("localhost",8088);
	InputStream  in = socket.getInputStream();
	OutputStream out = socket.getOutputStream();
}

1.5 close方法

当使用Socket进行通讯完毕后，要关闭Socket已释放系统资源。
Void close();
关闭此套接字。当关闭了该套接字后也会同时关闭由此获取的输入流与输出流。

1.6 Server端ServerScoket监听

Java.net.ServerSocket是运行于服务端应用程序中。通常创建ServerSocket需要指定服务端口，之后监听Socket的连接：

//创建ServerSocket并申请服务端口8088
ServerSocket server = new ServerSocket(8088);
/*
 * 方法会产生阻塞，直到某个Socket连接，并返回请求连接的Socket
 */
Socket socket = server.accept();

1.7 Client端Socket连接

当服务端创建ServerSocket并通过accept()方法侦听后，我们就可以通过客户端应用程序中创建Socket来向服务端发起连接。
需要注意的是，创建Socket的同时就发起连接，若连接异常会抛出异常。

//参数1：服务端的IP地址，参数2：服务端的服务端口
ServerSocket server = new ServerSocket(8088);

1.8 C-S端通信模型

1.9. 聊天室案例

使用Socket于ServerSocket建立客户端于服务端的连接并使用客户端向服务端发送一条消息

改善代码，使用户可以重复通过在控制台输入内容，并将内容发送给服务端。

Server.java

package day05.ZHONG;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.Scanner;
public class Server {
	private static BufferedReader br=null;
	private static PrintWriter pw=null;
	private static ServerSocket ss;
	private static Socket s;
	static Scanner scanner=new Scanner(System.in);
	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		try {
			ss=new ServerSocket(5500);
			System.out.println("服务器正常启动。。。。");
		    s=ss.accept();//阻塞方法
		    System.out.println("连接成功"+s.getRemoteSocketAddress());
		    br=new BufferedReader(new InputStreamReader(s.getInputStream()));
			pw=new PrintWriter(new OutputStreamWriter(s.getOutputStream()));
			while(true){
				String string=br.readLine();
				System.out.println("Server读到："+string);
				System.out.println("Server端请输入：");
				String str=scanner.next();
				pw.println(str);
				pw.flush();
				if(str.equals("exit")){
					break;
				}
			}
		} catch (Exception e1) {
				// TODO Auto-generated catch block
				e1.printStackTrace();
		}
		try {
			pw.close();
			br.close();
		} catch (IOException e1) {
				// TODO Auto-generated catch block
			e1.printStackTrace();
		}
	}

}

Client

package day05.ZHONG;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.net.InetAddress;
import java.net.Socket;
import java.net.UnknownHostException;
import java.util.Scanner;
public class Client {
	private static PrintWriter pw=null;
	private static BufferedReader br=null;
	private static Socket s;
	static Scanner scanner=new Scanner(System.in);
	/**
	 * @param args
	 */
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		try {
			Socket s=new Socket(InetAddress.getLocalHost(),5500);
			pw=new PrintWriter(new OutputStreamWriter(s.getOutputStream()));
			br=new BufferedReader(new InputStreamReader(s.getInputStream()));
			while(true){
				System.out.println("Client端请输入：");
				String str = scanner.next();
				pw.println(str);
				pw.flush();
				String string=br.readLine();
				System.out.println("Client读到："+string);
				if(str.equals("exit")){
					break;
				}
			} 
		}catch (Exception e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
		}
		try {
			br.close();
			pw.close();
		} catch (IOException e1) {
				// TODO Auto-generated catch block
				e1.printStackTrace();
		}
	}
}

1.10 Server端多线程模型

如果向是一个服务端可以支持多客户端连接，我们需要了解以下问题：
循环调用accept方法侦听客户端的连接
使用线程来处理单一客户端的数据交互

因为需要处理多客户端，所以服务端要周期性循环调用accept方法，但该方法会产生阻塞，所以与某个客户端的交互就需要使用线程来并发处理。

重构聊天室案例，使用线程来实现一个客户端可以同时接受多个客户端的信息。

1.10.1 Server.java

package day05.ZHONG.duo;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;
import java.text.SimpleDateFormat;
import java.util.Date;

public class Server {

	public static void main(String[] args) throws IOException, InterruptedException {
		// TODO Auto-generated method stub
		ServerSocket ss = new ServerSocket(10086);
		System.out.println("服务器正常启动。。。");
		while(true){
			Socket socket = ss.accept();
			System.out.println("用户接入成功。。。");
			/*
			 * 每次连接成功一个客户端，则启动一个线程为其服务
			 */
			new ServerThread(socket).start();
		}		
	}
}

1.10.2 Client.java

package day05.ZHONG.duo;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.net.Socket;
import java.net.UnknownHostException;
import java.util.Scanner;
public class Client {
	public static void main(String[] args) throws UnknownHostException, IOException, InterruptedException {

		Socket socket = new Socket("127.0.0.1",10086);
		PrintWriter pw = new PrintWriter(new OutputStreamWriter(socket.getOutputStream()));
		BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
		Scanner scanner = new Scanner(System.in);
		while(true){
			String arg = scanner.nextLine();
			if("exit".equals(arg.trim())){
				pw.println("exit");
				pw.flush();
				break;
			}
			pw.println(arg);
			pw.flush();
			String str = br.readLine();
			System.out.println("Client read = "+str);
		}
//		Thread.sleep(300);
		pw.close();
		br.close();
	}
}

1.10.3 ServerThread.java

package day05.ZHONG.duo;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.net.InetAddress;
import java.net.Socket;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Scanner;

public class ServerThread extends Thread {

	private Socket socket;
	private InetAddress ip;
	public ServerThread(Socket socket) {
		ip =socket.getInetAddress();
		this.socket = socket;
	}

	@Override
	public void run() {
		BufferedReader br = null;
		PrintWriter pw = null;
		try {
			br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
			pw = new PrintWriter(new OutputStreamWriter(socket.getOutputStream()));
			while (true) {
				String string = br.readLine();
				System.out.println("Server read  = 服务端"+ip+"说：" + string);
				System.out.println("Server端请输入： ");
				Scanner scanner = new Scanner(System.in);
				String str = scanner.nextLine();//服务端说
				
				pw.println( "【"+ new SimpleDateFormat("yyyy-MM-dd hh:mm:ss").format(new Date()) 
						+ "】服务端说："+str);
				pw.flush();
				if ("exit".equals(str)) {
					break;
				}
			}

			// Thread.sleep(300);
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} finally{
			try {
				br.close();
			} catch (Exception e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
			try {
				pw.close();
			} catch (Exception e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
	}
}

1.11聊天室群发

重构聊天室案例，使服务器可以将用户的信息转发给所有客户端。并在每个客户端控制台上显示。

Server.java

package day05;

import java.io.BufferedReader;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.net.InetAddress;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.ArrayList;
import java.util.List;

/**
 * 聊天室服务端
 * @author Administrator
 */
public class Server {
	/*
	 * 运行在服务端的ServerSocket
	 * 用于监听服务端口，并接收客户端的链接
	 */
	private ServerSocket server;
	/*
	 * 该集合用来保存所有客户端的输出流，便于广播
	 */
	private List<PrintWriter> allOut;
	/**
	 * 构造方法，用来初始化属性
	 */
	public Server(){
		try {
			allOut = new ArrayList<PrintWriter>();
			/*
			 * 创建ServerSocket的同时需要指定
			 * 开启的服务端口。
			 * 端口:每种通讯协议都会有端口。
			 * 作用:当客户端通过ip地址链接到当前计算机
			 * 后，就是通过端口找到我们的应用程序的。
			 * 因为在计算机中有很多程序都要使用网络，
			 * 都会用到TCP这样的协议，那么远程计算机
			 * 发送过来的数据交给那个程序就是靠端口。
			 * 
			 */
			server = new ServerSocket(8088);
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
	/**
	 * 向共享集合中添加一个输出流
	 * @param out
	 */
	private synchronized void addOut(PrintWriter out){
		allOut.add(out);
	}
	/**
	 * 将给定的输出流从共享集合中删除
	 * @param out
	 */
	private synchronized void removeOut(PrintWriter out){
		allOut.remove(out);
	}
	/**
	 * 将给定的消息发送给所有客户端
	 * @param message
	 */
	private synchronized void sendMessageToAllClient(String message){
		for(PrintWriter out : allOut){
			out.println(message);
		}
	}
	
	/**
	 * 服务端开始工作的方法
	 */
	public void start(){
		try {
			/*
			 * Socket accept()
			 * 该方法是一个阻塞方法，用于监听8088端口
			 * 直到一个客户端进行了链接，才会将于该客户端
			 * 交互的Socket返回。
			 */
			System.out.println("等待客户端链接...");
			Socket socket = server.accept();
			System.out.println("一个客户端链接了!");
			/*
			 * 启动一个线程，用来与当前客户端进行交互。
			 */			
			ClientHandler handler
				= new ClientHandler(socket);
			Thread t = new Thread(handler);
			t.start();
			
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
	
	public static void main(String[] args) {
		Server server = new Server();
		server.start();
	}
	
	/**
	 * 这是一个线程要执行的任务，用于使得服务端可以
	 * 处理与某个客户端的交互工作。
	 * @author Administrator
	 *
	 */
	private class ClientHandler implements Runnable{
		/*
		 * 当前线程需要与这个客户端进行交互
		 */
		private Socket socket;
		
		//当前客户端的地址
		private String host;
		/**
		 * 创建用于与给定客户端进行交互的线程任务
		 * @param socket 当前线程需要交互的客户端Socket
		 */
		public ClientHandler(Socket socket){
			this.socket = socket;
			/*
			 * 通过socket可以获取远程计算机信息
			 */
			//获取远程计算机地址信息
			InetAddress address
				= socket.getInetAddress();
			//获取ip
			host = address.getHostAddress();
			System.out.println("["+host+"]上线了!");
			
		}
		
		public void run(){
			PrintWriter pw = null;
			try {
				/*
				 * 通过客户端的Socket获取输出流，用来将消息
				 * 发送给当前客户端
				 */
				OutputStream out 
					= socket.getOutputStream();
				
				OutputStreamWriter osw
					= new OutputStreamWriter(out,"UTF-8");
				
				pw = new PrintWriter(osw,true);
				//将这个客户端的输出流存入共享集合
				addOut(pw);
				
				
				/*
				 * InputStream getInputStream()
				 * Socket的该方法用来获取一个可以读取远端
				 * 计算机发送过来数据的输入流
				 */
				InputStream in = socket.getInputStream();
				InputStreamReader isr
					= new InputStreamReader(in,"UTF-8");
				BufferedReader br
					= new BufferedReader(isr);
				
				String message = null;
				/*
				 * 我们通过br.readLine()读取客户端发送过来的
				 * 一行字符串。这里该方法的执行由于客户端的操作
				 * 系统不同，这里的结果会有差异。
				 * 
				 * windows的客户端与服务端断开连接后:
				 * 这里的readLine方法会直接抛出异常，告知我们客户端
				 * 与我们断开了连接。
				 * 
				 * linux的客户端与服务端断开连接后:
				 * 这里的readLine方法会返回null。
				 */
				while((message = br.readLine())!=null){
					System.out.println("["+host+"]说:"+message);
//					pw.println(message);
					/*
					 * 当读取到该客户端发送过来的一句话后，转发
					 * 给所有客户端
					 */
					sendMessageToAllClient(
						"["+host+"]说:"+message);
				}
				
			} catch (Exception e) {
				
			} finally{
				//将该客户端的输出流从共享集合中删除
				removeOut(pw);
				/*
				 * 无论是什么操作系统的客户端与服务端断开
				 * 连接，这里都应当将该客户端的Socket关闭
				 * 以释放资源
				 */
				try {
					socket.close();
					System.out.println("["+host+"]下线了!");
				} catch (Exception e2) {
					
				}
			}
		}
	}
}

Client.java

package day05;

import java.io.BufferedReader;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.net.Socket;
import java.util.Scanner;

/**
 * 聊天室客户端
 * @author Administrator
 *
 */
public class Client {
	/*
	 * 客户端的Socket，用于链接服务端的ServerSocket
	 * 并与服务端通讯
	 */
	private Socket socket;
	/**
	 * 构造方法，用来初始化客户端
	 */
	public Client(){
		try {
			/*
			 * 初始化Socket常使用带两个参数的构造方法
			 * 参数1:服务端的地址
			 * 参数2:服务端开启的服务端口
			 * 需要注意的是:创建的过程就是链接的过程，
			 * 若链接失败这里会抛出异常。
			 */
			socket = new Socket("localhost",8088);
			
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
	/**
	 * 客户端开始工作的方法
	 */
	public void start(){
		try {
			/*
			 * 启动用来读取服务端发送过来的消息的
			 * 线程
			 */
			GetServerMessageHandler handler = new GetServerMessageHandler();
			Thread t = new Thread(handler);
			t.start();
			/*
			 * 若想将消息发送至服务端，我们需要通过
			 * socket获取输出流。
			 * 
			 * OutputStream getOutputStream()
			 * Socket提供了该方法用来获取一个字节输出流
			 * 便于我们将数据发送至远端计算机。
			 */
			OutputStream out = socket.getOutputStream();
			OutputStreamWriter osw = new OutputStreamWriter(out,"UTF-8");
			PrintWriter pw= new PrintWriter(osw,true);
			
			//获取用户输入
			Scanner scanner = new Scanner(System.in);
			//循环将键盘输入的内容发送给服务端
			while(true){
				pw.println(scanner.nextLine());
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
	
	public static void main(String[] args) {
		Client client = new Client();
		client.start();
	}
	/**
	 * 该线程用来接收服务端发送过来的消息，并输出到
	 * 客户端的控制台
	 * @author Administrator
	 *
	 */
	private class GetServerMessageHandler 
						implements Runnable{
		public void run(){
			try {
				InputStream in= socket.getInputStream();
				InputStreamReader isr = new InputStreamReader(in,"UTF-8");
				BufferedReader br = new BufferedReader(isr);
				String message = null;
				while((message = br.readLine())!=null){
					System.out.println(message);
				}
			} catch (Exception e) {
				
			}
		}
	}	
}

2.UDP通信

2.1构建接收包

DatagramPacket：UDP数据包基于IP建立的，每台主机有65535个端口可以使用。
构建接收包
DatatgramPacket(byte[] buf,int length)
将数据包中length长度的数据装进buf数组。

DatagramPacket(byte[] buf, int offset, int length)
将数据包中从offset开始、length长度的数据装进buf数组。

2.2 构建接收包

构造发送包
DatagramPacket(byte[] buf , int length , InetAddress clientAdress,int clientPort)
从buf数组中取出length长度的数据创建数据包对象，目标是clientAddress地址，clientPort端口，通常用来发送数据给客户端。