Java 网络编程

package org.lovian.network.ip;

import java.net.InetAddress;
import java.net.UnknownHostException;

/*
 * InetAddress 成员方法：
 * public static InetAddress getByName(String host): 根据主机名或 IP 地址的字符串表示来得到 IP 地址对象（静态方法返回）
 * public String getHostName() : 获取主机名（host）
 * public String getHostAddress(): 获取 IP 地址
 *
 */
public class InetAddressDemo {
	public static void main(String[] args) throws UnknownHostException {

		// 通过 host name 获取 InetAddress 实例对象
		InetAddress address = InetAddress.getByName("www.google.fr");
		// 获取 host
		String hostName = address.getHostName();
		String ip = address.getHostAddress();
		System.out.println("Host: " + hostName + " IP: " + ip);

		// 通过 ip 获取 InetAddress 实例对象
		InetAddress address2 = InetAddress.getByName("216.58.208.195");
		// 获取 host
		String hostName2 = address2.getHostName();
		String ip2 = address2.getHostAddress();
		System.out.println("Host2: " + hostName2 + " IP2: " + ip2);
	}
}

package org.lovian.network.udp;

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;

/*
 * UDP发送端发送数据：
 * A: 创建发送端Socket对象
 * B: 创建数据，并把数据打包
 * C: 调用 Socket 对象的发送方法发送数据包
 * D: 释放资源（底层是 IO 流）
 */
public class UDPSender {
	public static void main(String[] args) throws IOException {
		// Create UDP Socket Object
		DatagramSocket ds = new DatagramSocket();

		// Create data and data package
		// Includes: data, length, ip address, port
		// public DatagramPacket(byte[] buf, int length, InetAddress address, int port): 用于发送数据包
		byte[] bys = "hello, this is udp sender!".getBytes();
		int length = bys.length;
		InetAddress address = InetAddress.getByName("localhost");
		int port = 10086;
		DatagramPacket dp = new DatagramPacket(bys, length, address, port);

		// Send package
		ds.send(dp);
		// Close
		ds.close();
	}
}

package org.lovian.network.udp;

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;

/*
 * UDP接收端接受数据：
 * A: 创建发送端Socket对象
 * B: 创建一个数据包（接收容器）
 * C: 调用Socket对象的接收方法接收数据
 * D: 解析数据并处理
 * D: 释放资源（底层是 IO 流）
 */
public class UDPReceiver {
	public static void main(String[] args) throws IOException {
		// Create Socket Object, port is 10086
		DatagramSocket ds = new DatagramSocket(10086);

		// Create a data package
		// public DatagramPacket(byte[] buf, int length) : 用于接收数据包
		byte[] bys = new byte[1024]; // 1k
		int length = bys.length;
		DatagramPacket dp = new DatagramPacket(bys, length);

		// Receive data
		ds.receive(dp);

		// Parse data package (DatagramPacket)
		// public InetAddress getAddress(): 获取发送方 ip 地址
		// public byte[] getData(): 获取数据缓冲区
		// public int getLength(): 获取数据实际长度
		InetAddress address = dp.getAddress();
		byte[] data = dp.getData();
		int dataLength = dp.getLength();
		String s = new String(data, 0, dataLength);
		System.out.println(
				"Received: " + s + "; From host: " + address.getHostName() + " IP: " + address.getHostAddress());

		// Close
		ds.close();
	}
}

package org.lovian.network.udp;

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.util.Date;

public class BroadcastReceiver {
	public static void main(String[] args) throws IOException {
		// 创建接收端 socket 对象
		DatagramSocket ds = new DatagramSocket(10086);

		// 接收数据
		while (true) {
			byte[] buf = new byte[1024];
			DatagramPacket dp = new DatagramPacket(buf, buf.length);
			ds.receive(dp);
			// 处理翻译数据
			String s = new String(dp.getData(), 0, dp.getLength());
			System.out.println("Recieved From: " + dp.getAddress().getHostAddress() + " Time: " + new Date() + " Data: " + s);
			// 结束
			if(s.equals("bye")){
				System.out.println("Terminated");
				break;
			}
		}
		ds.close();
	}
}

package org.lovian.network.udp;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.util.Date;

public class BroadcastSender {
	public static void main(String[] args) throws IOException{
		//创建 socket 对象
		DatagramSocket ds = new DatagramSocket();

		// 创建键盘输入对象
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		String line = null;
		// 读取键盘数据
		while((line = br.readLine()) != null){
			System.out.println("Send From: " + InetAddress.getByName("localhost") + " Time: " + new Date());
			byte[] buf = line.getBytes();
			// 发送到广播地址： x.x.x.255, port: 10086
			DatagramPacket dp = new DatagramPacket(buf, buf.length, InetAddress.getByName("10.30.167.255"), 10086);
			// 发送数据
			ds.send(dp);
			//如果字符为 bye， 结束
			if(line.equals("bye")){
				System.out.println("Terminated");
				break;
			}
		}
		ds.close();
	}
}

package org.lovian.network.tcp;

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

/*
 * TCP协议发送数据：
 * A: 创建发送端的socket对象
 *        这一步成功，就说明连接已经建立成功了
 * B：获取输出流，写数据
 * C: 释放资源
 */
public class Client {
	public static void main(String[] args) throws IOException{
		// 创建客户端的 Socket 对象, 两种主要构造方法
		// Socket(InetAddress address, int port);
		// Socket(String host, int port);
		Socket socket =  new Socket("localhost", 10086);

		// 获取输出流
		OutputStream os = socket.getOutputStream();
		// 写数据
		os.write("hello, this is TCP client".getBytes());

		// 释放资源
		socket.close();
	}
}

package org.lovian.network.tcp;

import java.io.IOException;
import java.io.InputStream;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.Date;

/*
 * TCP协议接收数据
 * A: 创建接收端的 ServerSocket 对象
 * B: 监听客户端，返回一个对象的 Socket 对象
 * C: 获取输入流读取数据，并处理显式
 * D: 释放资源
 */
public class Server {
	public static void main(String[] args) throws IOException{
		//创建接收端的 ServerSocket 对象
		// ServerSocket(int port);
		ServerSocket ss = new ServerSocket(10086);

		// 监听客户端，返回一个对象的 Socket 对象
		// public Socket accept()： 阻塞式方法
		Socket socket = ss.accept();

		// 获取输入流，读取数据并显示在控制台
		InputStream is = socket.getInputStream();

		byte[] buf = new byte[1024];
		int length = 0;
		while((length = is.read(buf)) != -1){
			String str = new String(buf, 0, length);
			System.out.println("From: " + socket.getInetAddress().getHostAddress() + " Time: " + new Date());
			System.out.println("Data: " + str);
		}
		// 释放资源 (关闭客户端的)
		socket.close();
		ss.close(); // 服务器端应该一直处于监听状态，不应该关闭
	}
}

package org.lovian.network.tcp;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.net.Socket;
import java.util.Date;

public class TcpClient {
	public static void main(String[] args) throws IOException {
		Socket socket = new Socket("localhost", 10086);

		// 键盘录入数据
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		// 包装 TCP 通道内的字节流 --> 字符流 --> 高效字符流
		BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));

		String line = null;
		while ((line = br.readLine()) != null) {
			bw.write(line);
			bw.newLine();
			bw.flush();
			System.out.println("From: " + socket.getInetAddress().getHostAddress() + " Time: " + new Date());
			if ("bye".equals(line)) {
				// 键盘录入数据要自定义结束标记
				System.out.println("Termiated");
				break;
			}
		}
		socket.close();
	}
}

package org.lovian.network.tcp;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.Date;

public class TcpServer {
	public static void main(String[] args) throws IOException{
		ServerSocket ss = new ServerSocket(10086);
		// 监听客户端
		Socket socket = ss.accept();

		// 包装通道内的输入字节流 --> 输入字符流 --> 高效字符流
		BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
		String line = null;
		while((line = br.readLine()) != null){
			System.out.println("From: " + socket.getInetAddress().getHostAddress() + " Time: " + new Date());
			System.out.println("Data: " + line);
			if("bye".equals(line)){
				System.out.println("Termiated");
				break;
			}
		}

		socket.close();
		ss.close();
	}
}

package org.lovian.network.tcp;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.net.Socket;

public class UploadClient {
	public static void main(String[] args) throws IOException {
		// 创建客户端socket对象，指定服务器的 host 和端口
		Socket s = new Socket("localhost", 10086);

		// 封装要上传的文本文件
		BufferedReader br = new BufferedReader(new FileReader("text.txt"));

		// 封装通道内的客户端的输出流
		BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));

		// 读取文件内容
		String line = null;
		while ((line = br.readLine()) != null) {
			// 通过通道输出流传送文件内容
			bw.write(line);
			bw.newLine();
			bw.flush();
		}

		// 发送传输结束标志，发送结束之前的所有内容
		s.shutdownOutput();

		// 通过客户端输入流获取服务器的反馈信息
		BufferedReader brClient = new BufferedReader(new InputStreamReader(s.getInputStream()));
		String serverFeedBack = brClient.readLine(); // 阻塞方法，有反馈就执行，没有反馈就阻塞
		System.out.println(serverFeedBack);

		br.close();
		s.close();
	}
}

package org.lovian.network.tcp;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.net.Socket;

public class processThread implements Runnable {

	private Socket s;

	// 通过构造方法传入每一个客户端线程的 socket 对象
	public processThread(Socket s) {
		this.s = s;
	}

	@Override
	public void run() {
		BufferedWriter bw = null;
		try {
			// 上传文件，相当于读取文件-->发送数据到服务器-->服务器把数据写入服务器中的文件
			// 为了防止名称冲突，使用时间作为存储文件名（小规模并发）
			bw = new BufferedWriter(new FileWriter(System.currentTimeMillis() + "_text.txt"));
			// 封装通道输入流用来读取客户端发来的数据
			BufferedReader br = new BufferedReader(new InputStreamReader(s.getInputStream()));

			// 读取数据
			String line = null;
			while ((line = br.readLine()) != null) { // 阻塞方法
				// 将读取到的数据写入服务器
				bw.write(line);
				bw.newLine();
				bw.flush();
			}
			// 当服务器收到客户端发来的结束信号，读取操作停止

			// 给出上传成功反馈
			BufferedWriter bwServer = new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));
			bwServer.write("File uploaded successfully");
			bwServer.newLine();
			bwServer.flush();

		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			try {
				bw.close();
				s.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}
}

package org.lovian.network.tcp;

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

public class UploadServer {
	public static void main(String[] args) throws IOException{
		// 创建TCP服务器 Socket 对象，指定监听端口
		ServerSocket ss = new ServerSocket(10086);

		while(true){
			// 监听客户端连接
			Socket s = ss.accept(); // 阻塞方法，成功则建立通道
			// 执行每一个客户端的线程
			new Thread(new processThread(s)).start();
		}
	}
}