java网络编程

基于TCP协议网络服务器端编程步骤：

1）创建服务器端Socket，并绑定在某一端口上

ServerSocket ss = new ServerSocket(port);

2）接收客户请求，返回客户端Socket

Socket s = ss.accept();

3）获取客户端的输入、输出流

s.getInputStream();

s.getOutputStream();

4）封装输入、输出流

5）执行读、写操作

6）释放资源

close();

import java.net.*;
import java.util.Date;
import java.io.*;

/*
 * 服务器端，先启动
 */
public class TimeTcpServer {
	public static void main(String[] args) {
		//端口号从外部传入
		//6666
		int port = Integer.parseInt(args[0]);
		ServerSocket ss = null;
		Socket s = null;
		BufferedWriter bw = null;
		try {
			//1.创建服务器端Socket，绑定在一个端口上
			ss = new ServerSocket(port);
			//2.获取客户端Socket，等待接受客户请求，会使线程阻塞(客户请求没有到达就等待)
			s = ss.accept();
			//3.获取基本流，给客户端发数据，用输出流
			//4.封装流对象
			bw = new BufferedWriter(new OutputStreamWriter(s.getOutputStream(),"UTF8"));
			//5.读写操作
			String time = new Date().toString();
			bw.write(time);
			bw.flush();
		}catch(IOException e){
			e.printStackTrace();
		}finally {
			//6.释放资源
			try {
				if(bw != null)
					bw.close();
				if(s != null)
					s.close();
				if(ss != null)
					ss.close();
			}catch(IOException e) {
				e.printStackTrace();
			}
		}
	}
}

基于TCP协议网络客户端编程步骤：

1）创建Socket，并指定服务器的IP和端口信息

Socket s = new Socket(serverAddress,serverPort);

2）获取服务器端的输入、输出流

s.getInputStream();

s.getOutputStream();

3）封装输入、输出流

4）执行读、写操作

5）释放资源

close();

 

import java.io.*;
import java.net.Socket;

/*
 * 客户端，后启动 
 */
public class TimeTcpClient {

	public static void main(String[] args) {
		//端口号和服务器端的端口号保持一致
		//指定服务器的ip地址和端口信息，从外部将参数传入
		//127.0.0.1 6666
		String ip = args[0];
		int port = Integer.parseInt(args[1]);
		Socket s = null;
		BufferedReader br = null;
		try {
			//1.创建Socket，与服务器连接，返回服务器的Socket
			s = new Socket(ip,port);
			//2.获取基本流，客户端从服务器上读取，使用输入流
			//3.封装流对象
			br = new BufferedReader(new InputStreamReader(s.getInputStream(),"UTF8"));
			//4.读写操作
			String time = br.readLine();
			System.out.println(time);
		}catch(IOException e) {
			e.printStackTrace();
		}finally {
			//5.释放资源
			try {
				if(br != null)
					br.close();
				if(s != null)
					s.close();
			}catch(IOException e){
				e.printStackTrace();
			}
		}
	}

}

 多线程的服务器端：服务器端既可以处理多个客户请求，还可以支持并发

客户端可以反复输入

服务器一直在运行

import java.net.*;
import java.util.Date;
import java.io.*;

/*
 * 服务器端，先启动
 */
class TimeThread extends Thread{
	private Socket s;
	public TimeThread(){}
	public TimeThread(Socket s) {
		this.s = s;
	}
	public void run() {
		BufferedWriter bw = null;
		try {
		//3.获取基本流，给客户端发数据，用输出流
			//s.getOutputStream()使用客户端的Socket
		//4.封装流对象
		bw = new BufferedWriter(new OutputStreamWriter(s.getOutputStream(),"UTF8"));
		//5.读写操作
		String time = new Date().toString();
		bw.write(time);
		bw.flush();
		}catch(IOException e) {
			e.printStackTrace();
		}finally {
			//6.释放资源
			try {
				if(bw != null)
					bw.close();
				//每一个线程为一个客户请求提供服务
				//每一个客户都有自己的Socket
				//客户请求完了，要关闭客户的Socket
				if(s != null)
					s.close();
			}catch(IOException e) {
				e.printStackTrace();
			}
		}
	}
}
public class TimeTcpThreadServer {
	public static void main(String[] args) {
		//端口号从外部传入
		//6666
		int port = Integer.parseInt(args[0]);
		ServerSocket ss = null;
		Socket s = null;
		//BufferedWriter bw = null;
		try {
			//1.创建服务器端Socket，绑定在一个端口上
			ss = new ServerSocket(port);
			//2.获取客户端Socket，等待接受客户请求，会使线程阻塞(客户请求没有到达就等待)
			//不同的客户端Socket不一样
			//服务器端启动起来一般是不宕机的，一直在工作，等待客户端发请求
			//ss一直在死循环
			while(true) {//接受客户端的一个请求，交给线程处理
				s = ss.accept();
				new TimeThread(s).start();
			}
			/*
			//3.获取基本流，给客户端发数据，用输出流
			//4.封装流对象
			bw = new BufferedWriter(new OutputStreamWriter(s.getOutputStream(),"UTF8"));
			//5.读写操作
			String time = new Date().toString();
			bw.write(time);
			bw.flush();
			*/
			
		}catch(IOException e){
			e.printStackTrace();
		}finally {
			//6.释放资源
			try {
				/*
				if(bw != null)
					bw.close();
				if(s != null)
					s.close();
				*/
				if(ss != null)
					ss.close();
			}catch(IOException e) {
				e.printStackTrace();
			}
		}
	}
}