java:socket通信

基于tcp协议,建立稳定连接的点对点的通信。

  实时，快速，安全性高，占用系统资源高，效率低

请求-响应模式(request, response)

  客户端: 在网络通讯中,第一次主动发起通讯的程序叫做客户端程序。

  服务器:第一次通讯中等待连接的程序被称作服务器端程序。

 

tcp有点像两个人打电话,必须电话线接通，两个人才可以通话。

 

Socket:发送TCP消息

ServerSocket:创建服务器

 

package com.test;

import java.io.BufferedReader;
import java.io.DataInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.Socket;

// 客户端
public class SocketClient {
	public static void main(String[] args) throws IOException{
		Socket client = new Socket("localhost", 8888);
		client.getOutputStream();
		
//		// 输入
//		BufferedReader br = new BufferedReader(new InputStreamReader(client.getInputStream()));
//		String msg = br.readLine(); // 阻塞式方法
//		System.out.println(msg);
		
		DataInputStream dis = new DataInputStream(client.getInputStream());
		String msg = dis.readUTF();
		System.out.println(msg);
	}
}

package com.test;

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

// 服务端
public class SocketServer {
	public static void main(String[] args) throws IOException{
		// 创建服务器,指定端口
		ServerSocket server = new ServerSocket(8888);
		
		// 接受客户端连接, 阻塞式
		Socket socket = server.accept();
		
		System.out.println("一个客户端建立连接");
		
		// 发送数据
		String msg = "tcp编程";
		// 输出流
//		BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
//		bw.write(msg);
//		bw.newLine();
//		bw.flush();
	
		DataOutputStream dos = new DataOutputStream(socket.getOutputStream());
		dos.writeUTF(msg);
		dos.flush();
	}
}

 

 

 基于Socket,ServerSocket实现类似聊天室的功能

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

// 服务器
public class Server {
	private List<Channel> channels = new ArrayList<Channel>();
	
	public static void main(String[] args) throws IOException{
		Server s = new Server();
		s.start();
	}
	
	public void start() throws IOException{
		ServerSocket server = new ServerSocket(8888);

		while(true){
			Socket client = server.accept();
			Channel n = new Channel(client);
			channels.add(n);
			new Thread(n).start();
		}
	}
	
	private class Channel implements Runnable{

		private DataInputStream dis;
		private DataOutputStream dos;
		private boolean isRunning = true;
		
		public Channel(Socket client){
			try {
				dis = new DataInputStream(client.getInputStream());
				dos = new DataOutputStream(client.getOutputStream());
			} catch (IOException e) {
				CloseUtil.close(dis,dos);
				isRunning = false;
			}

		}
		
		private String recevieMsg(){
			String msg = "";
			try {
				//System.out.println("server..等待读...");
				 return dis.readUTF();
			} catch (IOException e) {
				CloseUtil.close(dis,dos);
				isRunning = false;
			}
			
			return msg;
		}
		
		private void sendMsg(String msg){
			// 输出流
			try {
				dos.writeUTF("服务器-->"+msg);
				dos.flush();
			} catch (IOException e) {
				CloseUtil.close(dis,dos);
				isRunning = false;
			}
		}
		
		private void sendMsgToOthers(){
			// 输出流
			try {
				System.out.println("channels.size() "+channels.size());
				String msg = recevieMsg();
				
				for(Channel n : channels){
					if(n == this){
						continue;
					}
					System.out.println("recevieMsg() "+msg);
					n.sendMsg(msg);
				}
			} catch (Exception e) {
				CloseUtil.close(dis,dos);
				isRunning = false;
			}
		}
		
		@Override
		public void run() {
			while(isRunning){
				sendMsgToOthers();
			}
		}
	}
}

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

// 客户端
public class Client {
	public static void main(String[] args) throws IOException{
		Socket socket = new Socket("localhost", 8888);
		
		new Thread(new Send(socket)).start(); // 一条路径
		new Thread(new Receive(socket)).start(); // 一条路径
	}
}

import java.io.BufferedReader;
import java.io.DataOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.Socket;

// 发送
public class Send implements Runnable{

	// 管道流
	private BufferedReader br = null;
	// 输出流
	private DataOutputStream dos = null;
	private boolean isRunning = true;
	
	public Send(){
		br = new BufferedReader(new InputStreamReader(System.in));
	}
	
	public Send(Socket client){
		this();
		try {
			dos = new DataOutputStream(client.getOutputStream());
		} catch (IOException e) {
			isRunning = false;
			CloseUtil.close(dos,br);
		}
	}
	
	private String getMsgFromConsole(){
		try {
			return br.readLine();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		return "";
	}
	
	private void sendMsg(){
		String msg = getMsgFromConsole();
		try {
			dos.writeUTF(msg);
			dos.flush(); // 强制刷新
		} catch (IOException e) {
			isRunning = false;
			CloseUtil.close(dos,br);
		}
	}
	
	@Override
	public void run() {
		while(isRunning){
			sendMsg();
		}
	}
}

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

// 接收
public class Receive implements Runnable{
	
	// 输出流
	private DataInputStream dis = null;
	private boolean isRunning = true;
	
	public Receive(){
	}
	
	public Receive(Socket client){
		
		try {
			dis = new DataInputStream(client.getInputStream());
		} catch (IOException e) {
			isRunning = false;
			CloseUtil.close(dis);
		}
	}
	
	public String readMsg(){
		String msg = "";
		try {
			//System.out.println("readUTF()之前..."+System.currentTimeMillis());
			msg = dis.readUTF();
			//System.out.println("readUTF()之后..."+System.currentTimeMillis());
			return msg;
		} catch (IOException e) {
			isRunning = false;
			CloseUtil.close(dis);
		}
		return msg;
	}
	
	@Override
	public void run() {
		while(isRunning){
			System.out.println(readMsg());
		}
	}
}

import java.io.Closeable;
import java.io.IOException;

public class CloseUtil {
	public static void close(Closeable...cios){
		for(Closeable cio : cios){
			try {
				if(null != cio){					
					cio.close();
				}
			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
	}
}