网络编程--TCP相关

/*
演示tcp传输。
1.tcp分为客户端和服务端。
2.客户端对应的对象是Socket.
	服务端对应的对象是ServerSocket。

*/

/*
客户端：
通过查阅Socket对象，发现在该对象建立时，就可以去连接指定主机。
因为tcp是面向连接的。所以在建立socket服务时，就要有服务端存在，并连接成功。
	形成通路后，在该通道进行数据的传输。

需求：给服务端发送一个文本数据。

步骤：
	1.创建Socket服务。并指定要连接的主机和端口。
	2.获取socket流中的输出流。将数据写入该流中，通过网络发送给服务端。
*/
import java.io.*;
import java.net.*;

class TcpClient{
	public static void main(String[] args) {
		//创建客户端的socket服务。指定目的主机和端口
		Socket s = null;
		try{
			s = new Socket("192.168.1.254",102);
		}catch (Exception e){
			throw new RuntimeException("异常！");
		}
		
		//为了发送数据，应该获取socket流中的输出流。
		OutputStream out = s.getOutputStream();

		out.write("tcp ge men lai le".getBytes());

		s.close();
	}
}
/*
服务端：
需求：定义端点接收数据并打印在控制台上。

步骤：
	1.建立服务端的socket服务。ServerSocket();并监听一个接口。
	2.获取连接过来的客户端对象。通过ServerSocket的accept方法。没有连接就会等，所以这个方法是阻塞式的
	3.客户端如果发过来数据，那么服务端就要使用对应的客户端对象，并获取到该客户端对象的读取流来读取发过来的数据。
	4.关闭服务端。(可选)
*/
class TcpServer{
	public static void main(String[] args) {
		//建立服务端socket服务，并监听一个端口。
		ServerSocket ss = new ServerSocket(102);

		//通过accept方法获取连接过来的客户端对象。
		Socket s = ss.accept();
		String ip = s.getInetAddress().getHostAddress();

		//获取客户端发送过来的数据，那么要使用客户端对象的读取流来读取数据。
		InputStream in = s.getInputStream();
		byte[] buffer = new byte[1024];
		int len = in.read(buffer);
		String content = new String(buffer,0,len)
		
		System.out.println(content);

		//关闭客户端--服务端可以不关闭自己，关客户端
		s.close();
		ss.close();//可选
	}
}

/*----------------------------------------------------------------------*/
/*
演示tcp的传输的客户端和服务端的互访。

需求：客户端给服务端发送数据，服务端收到后，给客户端反馈信息。
*/

/*
客户端：
	1.建立socket服务，指定要连接的主机和端口。
	2.获取socket流中的输出流。将数据写入该流中，通过网络发送给服务端。
	3.获取socket流中的输入流，将服务端反馈的数据获取到，并打印。
	4.关闭客户端资源。
*/
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.Socket;
import java.net.UnknownHostException;

class TcpClient{
	public static void main(String[] args){
		Socket s = null;
		try {
			s = new Socket("192.168.1.254",1022);
		} catch (UnknownHostException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}

		OutputStream out = null;
		try {
			out = s.getOutputStream();
		} catch (IOException e) {
			e.printStackTrace();
		}

		try {
			out.write("服务端，你好".getBytes());
		} catch (IOException e) {
			e.printStackTrace();
		}

		InputStream in = null;
		try {
			in = s.getInputStream();
		} catch (IOException e) {
			e.printStackTrace();
		}

		byte[] buffer = new byte[1024];

		int len = 0;
		try {
			len = in.read(buffer);
		} catch (IOException e) {
			e.printStackTrace();
		}

		System.out.println(new String(buffer,0,len));

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

/*
服务端：
	1.建立服务端的socket服务。ServerSocket();并监听一个接口。
	2.获取连接过来的客户端对象。
	3.获取socket流中的输入流，并读取数据。
	4.获取socket流中的输出流，并反馈数据。
	5.关闭socket流。ServerSocket流不一定关。
*/
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;

class TcpServer{
	public static void main(String[] args){
		ServerSocket ss = null;
		try {
			ss = new ServerSocket(1022);
		} catch (IOException e) {
			e.printStackTrace();
		}

		Socket s = null;
		try {
			s = ss.accept();
		} catch (IOException e) {
			e.printStackTrace();
		}

		String ip = s.getInetAddress().getHostAddress();
		
		InputStream in = null;
		try {
			in = s.getInputStream();
		} catch (IOException e) {
			e.printStackTrace();
		}

		byte[] buffer = new byte[1024];

		int len = 0;
		try {
			len = in.read(buffer);
		} catch (IOException e) {
			e.printStackTrace();
		}

		System.out.println(ip+"::"+new String(buffer,0,len));

		OutputStream out = null;
		try {
			out = s.getOutputStream();
		} catch (IOException e) {
			e.printStackTrace();
		}

		try {
			out.write("哥们收到，你也好".getBytes());
		} catch (IOException e) {
			e.printStackTrace();
		}

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

		try {
			ss.close();
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
}

/*------------------------------------------------------------------------*/
/*
需求：建立一个文本转换服务器。
客户端给服务端发送文本，服务端会将文本转成大写再返回给客户端。
而且客户端可以不断的进行文本转换。当客户端输入over时，转换结束。

该例子出现的问题；
现象：客户端和服务端都在莫名的等待。
为什么呢？
因为客户端和服务端都有阻塞式方法。这些方法没有读到结束标记，那么就会一直等。
而导致两端都在等。


分析：
客户端：
既然是操作设备上的数据，那么就可以使用io技术，并按照io的操作规律来思考。
源：键盘录入。
目的：网络设备，网络输出流。
而且操作的是文本数据，可以选择字符流。

步骤：
	1.建立服务。
	2.获取键盘录入。
	3.将数据发给服务端。
	4.获取服务端返回的大写数据。
	5.结束，关资源。

都是文本数据，可以使用字符流进行操作，同时提高效率，加入缓冲。
*/
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.net.UnknownHostException;

class TransClient{
	public static void main(String[] args) {
		Socket s = null;
		try {
			s  = new Socket("192.168.1.254",10005);
		} catch (UnknownHostException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}
		
		//定义读取键盘数据的流对象
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		
		
		/*//定义目的，将数据写入到socket输出流。发送给服务端。
		BufferedWriter bwOut = null;
		try {
			bwOut = new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));
		} catch (IOException e) {
			e.printStackTrace();
		}
		*/
		//定义目的，将数据写入到socket输出流。发送给服务端。
		PrintWriter pwOut = null;
		try{
			out = new PrintWriter(s.getOutputStream(),true);
		}catch (IOException e){
			e.printStackTrace();
		} 
		
		//定义一个socket读取流，读取服务端返回的大写信息。
		BufferedReader brIn = null;
		try {
			brIn = new BufferedReader(new InputStreamReader(s.getInputStream()));
		} catch (IOException e1) {
			e1.printStackTrace();
		}
		
		
		String line = null;
		try {
			while((line = br.readLine())!=null){
				if("over".equals(line))
					break;
				
				//bwOut.write(line);//加入回车结束标记
				//bwOut.newLine();
				pwOut.println(line);
				
				String str = brIn.readLine();
				System.out.println("server:"+str);
			}
		} catch (IOException e) {
			e.printStackTrace();
		}
		try {
			br.close();
		} catch (IOException e) {
			e.printStackTrace();
		}
		try {
			s.close();
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
}
/*
服务端：
源：socket读取流。
目的：socket输出流。
都是文本，装饰。
*/
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.net.ServerSocket;
import java.net.Socket;

class TransServer{
	public static void main(String[] args) {
		ServerSocket ss = null;
		try {
			ss = new ServerSocket(10005);
		} catch (IOException e) {
			e.printStackTrace();
		}
		
		Socket s = null;
		try {
			s = ss.accept();
		} catch (IOException e) {
			e.printStackTrace();
		}
		
		String ip = s.getInetAddress().getHostAddress();
		System.out.println("ip:"+ip+"connected");
		
		//读取socket读取流中的数据。
		BufferedReader brIn = null;
		try {
			brIn = new BufferedReader(new InputStreamReader(s.getInputStream()));
		} catch (IOException e1) {
			e1.printStackTrace();
		}
		
		
		/*//目的，socket输出流，将大写数据写入到socket输出流并返回给客户端。
		BufferedWriter brOut = null;
		try {
			brOut = new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));
		} catch (IOException e1) {
			e1.printStackTrace();
		}
		*/

		//目的，socket输出流，将大写数据写入到socket输出流并返回给客户端。
		PrintWriter pwOut = null;
		try{
			out = new PrintWriter(s.getOutputStream(),true);
		}catch (IOException e){
			e.printStackTrace();
		} 
		
		
		String line = null;
		try {
			while((line = brIn.readLine())!=null){//readLine()读到回车标记
				//brOut.write(line.toUpperCase());
				//brOut.newLine();
				pwOut.println(line.toUpperCase());
			}
		} catch (IOException e) {
			e.printStackTrace();
		}
		
		try {
			s.close();
		} catch (IOException e) {
			e.printStackTrace();
		}
		try {
			ss.close();
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
}