传统tcp网络编程入门示例

1.demo

 

public class Server {
	public static void main(String[] args) throws IOException {
		// 创建一个ServerSocket，用于监听客户端Socket的连接请求
		ServerSocket ss = new ServerSocket(30000);
		// 采用循环不断接受来自客户端的请求
		while (true) {
			// 每当接受到客户端Socket的请求，服务器端也对应产生一个Socket
			Socket s = ss.accept();
			// 方式一
			PrintStream ps = new PrintStream(s.getOutputStream());
			ps.println("hello，您收到了服务器的问候！");// 进行普通IO操作
			ps.close();
			s.close();
			// 方式二
			BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));
			bw.write("hello，您收到了服务器的问候！\n");// 必须同时加上\n和flush,客户端用readLine才能输出
			bw.flush();
			// 方式三
			BufferedReader br = new BufferedReader(new InputStreamReader(s.getInputStream()));
			System.out.println("来自客户端的数据：" + br.readLine());
		}
	}
}

public class Client {
	public static void main(String[] args) throws IOException {
		Socket socket = new Socket("127.0.0.1", 30000);
		// 方式一、二
		BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
		String line = br.readLine();
		System.out.println("来自服务器的数据：" + line);
		br.close();
		socket.close();
		// 方式三
		BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
		bw.write("hello，您收到了客户端的问候！");// 只需要加flush,服务器端用readLine就能输出
		bw.flush();
	}
}

2.半关闭的Socket

 

 

public class Server {
	public static void main(String[] args) throws Exception {
		ServerSocket ss = new ServerSocket(30000);
		Socket socket = ss.accept();
		PrintStream ps = new PrintStream(socket.getOutputStream());
		ps.println("服务器的第一行数据");
		ps.println("服务器的第二行数据");
		// 关闭socket的输出流，表明输出数据已经结束
		socket.shutdownOutput();
		// 下面语句将输出false，表明socket还未关闭。
		System.out.println(socket.isClosed());
		Scanner scan = new Scanner(socket.getInputStream());
		while (scan.hasNextLine()) {
			System.out.println(scan.nextLine());
		}
		scan.close();
		socket.close();
		ss.close();
	}
}

public class Client {
	public static void main(String[] args) throws Exception {
		Socket s = new Socket("localhost", 30000);
		Scanner scan = new Scanner(s.getInputStream());
		while (scan.hasNextLine()) {
			System.out.println(scan.nextLine());
		}
		PrintStream ps = new PrintStream(s.getOutputStream());
		ps.println("客户端的第一行数据");
		ps.println("客户端的第二行数据");
		ps.close();
		scan.close();
		s.close();
	}
}

3.ByteArrayOutputStream

PrintStream的write方法是可以用的，只不过要在后面加上输出\n，否则就用它的println,否则因为接收端用的是nextLine()会因为没有末尾的换行
而读取不到数据；但用字节的方式接收的话就不必关心末尾有没有\n了

 

public class Server {
	public static void main(String[] args) throws Exception {
		ServerSocket server = new ServerSocket(30000);
		while (true) {
			Socket socket = server.accept();
			PrintStream ps = new PrintStream(socket.getOutputStream());
			ps.write("这是测试么？".getBytes());
			ps.println("这是测试么？？");
			ps.print("这是测试么？？");
			socket.shutdownOutput();// 必须关闭，否则客户端会阻塞在read方法上
		}
	}

}

public class Client {
	public static void main(String[] args) throws Exception {
		Socket socket = new Socket("127.0.0.1", 30000);
		InputStream is = socket.getInputStream();
		byte[] bytes = new byte[1024];
		ByteArrayOutputStream bout = new ByteArrayOutputStream();
		int len;
		while (true) {
			len = is.read(bytes);
			System.out.println("len = " + len);
			if (len < 0) {
				break;
			}
			bout.write(bytes, 0, len);
		}
		System.out.println(bout.size());
		System.out.println(bout.toString());
	}
}

 

4.多线程

public class MyServer {
	// 定义保存所有Socket的ArrayList，并将其包装为线程安全的
	public static List<Socket> socketList = Collections.synchronizedList(new ArrayList<Socket>());

	public static void main(String[] args) throws IOException {
		ServerSocket ss = new ServerSocket(30000);
		while (true) {
			// 此行代码会阻塞，将一直等待别人的连接
			Socket s = ss.accept();
			socketList.add(s);
			// 每当客户端连接后启动一条ServerThread线程为该客户端服务
			new Thread(new ServerThread(s)).start();
		}
	}
}

// 负责处理每个线程通信的线程类
public class ServerThread implements Runnable {
	// 定义当前线程所处理的Socket
	Socket s = null;
	// 该线程所处理的Socket所对应的输入流
	BufferedReader br = null;

	public ServerThread(Socket s) throws IOException {
		this.s = s;
		// 初始化该Socket对应的输入流
		br = new BufferedReader(new InputStreamReader(s.getInputStream()));
	}

	public void run() {
		try {
			String content = null;
			// 采用循环不断从Socket中读取客户端发送过来的数据
			while ((content = readFromClient()) != null) {
				// 遍历socketList中的每个Socket，
				// 将读到的内容向每个Socket发送一次
				for (Socket s : MyServer.socketList) {
					PrintStream ps = new PrintStream(s.getOutputStream());
					ps.println(content);
				}
			}
		} catch (IOException e) {
			e.printStackTrace();
		}
	}

	// 定义读取客户端数据的方法
	private String readFromClient() {
		try {
			return br.readLine();
		}
		// 如果捕捉到异常，表明该Socket对应的客户端已经关闭
		catch (IOException e) {
			// 删除该Socket。
			MyServer.socketList.remove(s); // ①
		}
		return null;
	}
}

public class MyClient {
	public static void main(String[] args) throws Exception {
		Socket s = new Socket("127.0.0.1", 30000);
		// 客户端启动ClientThread线程不断读取来自服务器的数据
		new Thread(new ClientThread(s)).start(); // ①
		// 获取该Socket对应的输出流
		PrintStream ps = new PrintStream(s.getOutputStream());
		String line = null;
		// 不断读取键盘输入
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		while ((line = br.readLine()) != null) {
			// 将用户的键盘输入内容写入Socket对应的输出流
			ps.println(line);
		}
	}
}

public class ClientThread implements Runnable {
	// 该线程负责处理的Socket
	private Socket s;
	// 该线程所处理的Socket所对应的输入流
	BufferedReader br = null;

	public ClientThread(Socket s) throws IOException {
		this.s = s;
		br = new BufferedReader(new InputStreamReader(s.getInputStream()));
	}

	public void run() {
		try {
			String content = null;
			// 不断读取Socket输入流中的内容，并将这些内容打印输出
			while ((content = br.readLine()) != null) {
				System.out.println(content);
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
}

参考：

 

疯狂java讲义