java 网络协议（一）Tcp

1，简化的服务器端程序

package tcp;

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

//简单化的服务器端程序，用到ServerSocket类，不做任何事，只是在碰到有连接的时候停顿3秒
public class Techo {
	public static void main(String[] args) {
		
		try {
			ServerSocket server = new ServerSocket(8123); //如果端口已占用会出现异常，例如运行两次此程序第二个会有异常
			while(true){
				System.out.println("Listening....");
				Socket socket = server.accept(); //监听到了的连接，这个调用会阻塞，因此程序会挂起，直到一台客户端计算机连接到它
				InetAddress addr = socket.getInetAddress(); //得到客户端的ip地址
				System.out.println("connection made to "+addr.getHostName()+"("+addr.getHostAddress()+")");
				
				pause(3000);
				socket.close();
			}
		} catch (IOException e) {
			e.printStackTrace();
		}
	}

	private static void pause(int i) {

		try {
			Thread.sleep(i);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}

}

先运行此程序，控制台显示Listening....，再在命令行中运行  telnet localhost 8123，显示
Listening....
connection made to bupt(0:0:0:0:0:0:0:1)
Listening....
说明服务器一直在监听，直到有客户端连接为止

2，单连接，只连接一次就关闭服务器

package tcp;

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

//允许单连接的

public class BeerServer {
	public static void main(String[] args) {
		
		try {
			ServerSocket server = new ServerSocket(1234); //如果端口已占用会出现异常，例如运行两次此程序第二个会有异常
		
				System.out.println("Listening....");
				Socket socket = server.accept(); //监听到了的连接，这个调用会阻塞，因此程序会挂起，直到一台客户端计算机连接到它
				InetAddress addr = socket.getInetAddress(); //得到客户端的ip地址
				System.out.println("connection made to "+addr.getHostName()+"("+addr.getHostAddress()+")");
				
				server.close();//no more connect,只要建立一个连接后就关闭
//				PrintStream不做什么，必须和流联系在一起
				PrintStream psstream = new PrintStream(socket.getOutputStream());
				for(int i =10;i>=0;i--){
					psstream.println(i+" bottles of beer on the wall");
				}
				psstream.close();
				socket.close();
		
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
}

先运行此程序，再在命令行中运行  telnet localhost 1234
如下图所示


2，客户端输入控制服务器端输出

package tcp;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintStream;
import java.net.InetAddress;
import java.net.ServerSocket;
import java.net.Socket;

//客户端指定信息来控制服务器输出

public class BeerServer1 {
	public static void main(String[] args) {
		
		try {
			ServerSocket server = new ServerSocket(1234); //如果端口已占用会出现异常，例如运行两次此程序第二个会有异常
		
				System.out.println("Listening....");
				Socket socket = server.accept(); //监听到了的连接，这个调用会阻塞，因此程序会挂起，直到一台客户端计算机连接到它
				InetAddress addr = socket.getInetAddress(); //得到客户端的ip地址
				System.out.println("connection made to "+addr.getHostName()+"("+addr.getHostAddress()+")");
				
				server.close();//no more connect,只向单个客户端显示消息
				
				
//				PrintStream不做什么，必须和流联系在一起
				PrintStream psstream = new PrintStream(socket.getOutputStream());
				
//		==========	与上一个不同之处 =============
				//ask for count
				psstream.print("count? ");
				BufferedReader input = new BufferedReader(new InputStreamReader(socket.getInputStream()));
				
//				read and parse it
				String line = input.readLine();
				psstream.println(" ");
				int count = Integer.parseInt(line);
//		==========	与上一个不同之处 =============				
				for(int i =count;i>=0;i--){
					psstream.println(i+" bottles of beer on the wall");
				}
				psstream.close();
				socket.close();
		
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
}

先运行此程序，再在命令行中运行  telnet localhost 1234,输入count后




3，tcp连接传递数据
客户端

package tcp.data;

import java.io.DataInputStream;
import java.io.IOException;
import java.net.Socket;
import java.net.UnknownHostException;
//客户端取出浮点型数据pi值
public class DataClient {
	public static void main(String[] args) {

		try {
			Socket socket = new Socket(args[0],1234);
			
			DataInputStream dis = new DataInputStream(socket.getInputStream());
			float f = dis.readFloat();
			System.out.println("PI="+f);
			dis.close();
			socket.close();
			
		} catch (UnknownHostException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
}

服务器端

package tcp.data;

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

//一个特定的java服务器端程序能用专门的流传送输入的数据或者对象
public class DataServer {
	public static void main(String[] args) {
		
		try {
			ServerSocket server = new ServerSocket(1234); //如果端口已占用会出现异常，例如运行两次此程序第二个会有异常
		
				System.out.println("Listening....");
				Socket socket = server.accept(); //监听到了的连接，这个调用会阻塞，因此程序会挂起，直到一台客户端计算机连接到它
				
				DataOutputStream dsstream = new DataOutputStream(socket.getOutputStream());
				dsstream.writeFloat(3.14159265f);
				dsstream.close();
				socket.close(); 
		
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
}

执行结果：




4，tcp传递对象
客户端

package tcp.obj;

import java.io.IOException;
import java.io.ObjectInputStream;
import java.net.Socket;
import java.net.UnknownHostException;
import java.util.List;

//一个特定的java客户端程序，从服务器端读对象
public class ObjClient {

	public static void main(String[] args) throws ClassNotFoundException {
		try {

			Socket socket = new Socket(args[0], 1234);

			ObjectInputStream ois = new ObjectInputStream(socket
					.getInputStream());
			List hash = (List) ois.readObject();

			System.out.println(hash);
			ois.close();
			socket.close();

		} catch (UnknownHostException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
}

服务器端

package tcp.obj;

import java.io.IOException;
import java.io.ObjectOutputStream;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.ArrayList;
import java.util.List;

//服务器端，对象传递数据
public class ObjServer {
	public static void main(String[] args) {
		try {
			ServerSocket server = new ServerSocket(1234); //如果端口已占用会出现异常，例如运行两次此程序第二个会有异常
		
             List<String> list = new ArrayList<String>();		
             list.add("first");
             list.add("second");
			while(true){ //一直在监听
			    System.out.println("Listening....");
				Socket socket = server.accept(); //监听到了的连接，这个调用会阻塞，因此程序会挂起，直到一台客户端计算机连接到它
				
				ObjectOutputStream oos = new ObjectOutputStream(socket.getOutputStream());
				oos.writeObject(list);
				oos.close();
				socket.close();
			}
		} catch (IOException e) {
			e.printStackTrace();
		}	
	}
}

5，以上均是单客户端，以下是用多线程实现的多个客户端同时响应的服务器端程序

package tcp.multiclient;
import java.io.IOException;
import java.io.PrintStream;
import java.net.ServerSocket;
import java.net.Socket;
//使用线程，允许服务器一次处理多个客户端的请求

public class MTServer extends Thread {  //或implements Runnable
	Socket client;
	public static void main(String[] args) throws IOException {
		ServerSocket server = new ServerSocket(1234);
		System.out.println("Listening....");

		while (true) { // 一直监听，每监听到一个连接，启动一个线程  ，可以考虑用线程池？？？？
		Socket socket = server.accept();
		System.out.println("Connected....");	
		new MTServer(socket).start(); // 执行run方法
//			new Thread(new MTServer(socket)).start(); 如果是实现runnable接口
		}
	}
	public MTServer(Socket client) {
		super();
		this.client = client;
	}
	public void run() {
		try {
			PrintStream psstream = new PrintStream(client.getOutputStream());
			for (int i = 10; i >= 0; i--) {
				psstream.println(i + " bottles of beer on the wall");
			}
			psstream.close();
			client.close();
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
}

6，用java中的zip减少发送数据量
服务器端

package tcp.zipUnzip;

import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.zip.GZIPInputStream;
//使用java的压缩类减少数据量，服务器端
public class CompRcv {
	public static void main(String[] args) throws NumberFormatException, IOException {
		
		ServerSocket server = new ServerSocket(Integer.parseInt(args[0]));
		System.out.println("Listening....");
		Socket socket = server.accept();
		[color=red]GZIPInputStream zip = new GZIPInputStream(socket.getInputStream());[/color] 
		while(true){
			int c;
			c = zip.read();
			if(c==-1)break;
			System.out.println((char)c); //中文读不出来
		}
	}
}

客户端

package tcp.zipUnzip;

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.net.Socket;
import java.net.UnknownHostException;
import java.util.zip.GZIPOutputStream;

//客户端发送压缩文件到服务器，参数为主机名，端口号，发送的文件
public class CompSend {

	public static void main(String[] args) throws NumberFormatException, UnknownHostException, IOException {
		Socket socket = new Socket(args[0],Integer.parseInt(args[1]));	
		[color=red]GZIPOutputStream zip = new GZIPOutputStream(socket.getOutputStream());[/color]
		String line;
		BufferedReader reader = new BufferedReader(new FileReader(args[2]));
		while(true){
			line = reader.readLine();
			if(line==null)break;
			line = line+"\n";
			zip.write(line.getBytes(),0,line.length());
		}
		zip.finish();
		zip.close();
		socket.close();
	}
}

执行结果和上面无两样