Java 网络编程

• TCP ：TCP（英语：Transmission Control Protocol，传输控制协议） 是一种面向连接的、可靠的、基于字节流的传输层通信协议，TCP 层是位于 IP 层之上，应用层之下的中间层。TCP 保障了两个应用程序之间的可靠通信。通常用于互联网协议，被称 TCP / IP。

• **UDP ** ： UDP （英语：User Datagram Protocol，用户数据报协议），位于 OSI 模型的传输层。一个无连接的协议。提供了应用程序之间要发送数据的数据报。由于UDP缺乏可靠性且属于无连接协议，所以应用程序通常必须容许一些丢失、错误或重复的数据包，不可靠的协议

• *并发（Concurrent），在操作系统中，是指一个时间段中有几个程序都处于已启动运行到运行完毕之间，且这几个程序都是在同一个处理机上运行。

• 并行（Parallel），当系统有一个以上CPU时，当一个CPU执行一个进程时，另一个CPU可以执行另一个进程，两个进程互不抢占CPU资源，可以同时进行，这种方式我们称之为并行(Parallel)。

  并发：其实决定并行的因素不是CPU的数量，而是CPU的核心数量，比如一个CPU多个核也可以并行。

  同步是指：发送方发出数据后，等接收方发回响应以后才发下一个数据包的通讯方式。
  异步是指：发送方发出数据后，不等接收方发回响应，接着发送下个数据包的通讯方式。

​ 套接字使用TCP提供了两台计算机之间的通信机制， 客户端程序创建一个套接字，并尝试连接服务器的套接字。当连接建立时，服务器会创建一个 Socket 对象。客户端和服务器现在可以通过对 Socket 对象的写入和读取来进行通信。java.net.Socket 类代表一个套接字，并且 java.net.ServerSocket 类为服务器程序提供了一种来监听客户端，并与他们建立连接的机制。

Socket:定义客户端

 		SercerSocket:定义服务端
* 		服务1端口号 0-65535 端口号就是给计算机的特定进程提供服务。
* 		服务2     0-1023
* 		服务3
* 		MySql 端口号 3306 ftp 21/20 http 80 SMTP 25 DNS 53 ssh22 TFTP 69
* 		Oracle 	  1521
* 		Tomcat     8080
* 		
* 		想系统申请端口号 端口号是系统中所有程序没有使用过的端口，才能申请成功
* 		端口号的范围：0 -65535 之间 0 -1023之间是系统端口
		连接本机可以用localhost/127.0.0.1
		阻塞方法accept():等待客户端的连接 阻塞方法，监听客户端的连接
 聊天室案例代码：
    package www.git.exer1;
//服务端
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class ServerExer {

	HashMap map = new HashMap<>();
	ArrayList allPw = new ArrayList<>();

	public static void main(String[] args) throws Exception {
		try {
			ServerSocket server = new ServerSocket(8086);
			System.out.println("服务端开启成功！");
			ExecutorService pool = Executors.newCachedThreadPool();
			ServerExer server1 = new ServerExer();

			while (true) {
				System.out.println("等待客户端的连接");
				Socket socket = server.accept();
				System.out.println("和客户端连接成功！");

				// Thread thread = new Thread(server1.new
				// ClientHandler(socket));
				// thread.start();
				pool.execute(server1.new ClientHandler(socket));
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

	class ClientHandler implements Runnable {
		private Socket socket;

		public ClientHandler(Socket socket) {
			this.socket = socket;
		}

		@Override
		public void run() {
			try {
				InputStream is = socket.getInputStream();
				InputStreamReader isr = new InputStreamReader(is, "GBK");
				BufferedReader br = new BufferedReader(isr);

				OutputStream os = socket.getOutputStream();
				OutputStreamWriter osw = new OutputStreamWriter(os, "GBK");
				PrintWriter pw = new PrintWriter(osw, true);

				synchronized (allPw) {
					allPw.add(pw);
				}

				String line = null;
				String name = br.readLine();

				synchronized (map) {
					map.put(name, pw);
				}
				while ((line = br.readLine()) != null) {
					if (line.equals("1")) {
						// 需要私聊的对象
						line = br.readLine();
						// 私聊的对象的输出流
						synchronized (map) {
							PrintWriter p = map.get(line);
							line = br.readLine();
							p.println(line);
						}
					} else {// 群发
						synchronized (allPw) {
							line = br.readLine();
							for (PrintWriter p : allPw) {
								if (p == pw) {
									continue;
								}
								p.println(line);
							}
						}
					}
				}
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}
}
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.net.Socket;
import java.util.Scanner;
import java.io.PrintWriter;


public class ClientExer {
	public static void main(String[] args) throws Exception {
		System.out.println("开始连接服务端！");
		Socket socket = new Socket("localhost", 8086);
		System.out.println("连接服务端成功！");

		Thread writeUser = new Thread(new writeUser(socket));
		Thread read = new Thread(new readData(socket));

		writeUser.start();
		read.start();
	}
}

// 输入用户名
class writeUser implements Runnable {
	Scanner scanner = new Scanner(System.in);
	private Socket socket;

	public writeUser(Socket socket) {
		this.socket = socket;
	}

	@Override
	public void run() {
		try {
			OutputStream os = socket.getOutputStream();
			OutputStreamWriter osw = new OutputStreamWriter(os, "GBK");
			PrintWriter pw = new PrintWriter(osw, true);

			System.out.println("请输入你的用户昵称（昵称）：");
			pw.println(scanner.next());

			while (true) {
				System.out.println("请选择私聊或者群发：1：表示私聊/t2：表示群发，否者退出发送信息");
				int number = scanner.nextInt();
				pw.println(number);
				switch (number) {
				case 1:
					System.out.println("请输入你要私聊的用户：");
					String username = scanner.next();
					pw.println(username);
					System.out.println("请输入私聊的信息：");
					pw.println(scanner.next());
					break;
				case 2:
					System.out.println("请输入群发消息：");
					pw.println(scanner.next());
					break;
				default:
					System.out.println("退出消息发送");
					System.exit(0);

				}
			}
		} catch (IOException e) {
			e.printStackTrace();
		}
		scanner.close();
	}
}

class readData implements Runnable {
	private Socket socket;

	public readData(Socket socket) {
		this.socket = socket;
	}

	@Override
	public void run() {
		try {
			InputStream is = socket.getInputStream();
			InputStreamReader isr = new InputStreamReader(is, "GBK");
			BufferedReader br = new BufferedReader(isr);
			String line = null;
			while ((line = br.readLine()) != null) {
				System.out.println("对方发回来的信息：");
				System.out.println(line);
			}
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
}