基于TCP协议的网络编程
TCP/IP协议是一种可靠的网络协议，它的通信的两端各自建立一个Socket,从而在通信的两端之间形成网络虚拟链路。
Java使用Socket对象来代表两端的通信端口，并通过Socket产生IO流来进行网络通信。
1、ServerSocket
java中能接收其他通信实体连接请求的类是ServerSocket,他会监听来自客户端Socket连接，如果没有连接，它将一直处于等待状态。
ServerSocket常用方法:
Socket accept():如果接收到客户端Socket的连接请求，返回一个与客户端Socket对应的Socket(每个TCP连接有两个Socket),否则一直处于等待状态，线程被阻塞。
ServerSocket构造器:
ServerSocket(int port):指定端口创建ServerSocket.
ServerSocket(int port ,int backlog):增加一个用来改变连接队列长度的参数backlog.
ServerSocket(int port ,int backlog ,InetAddress localAddr):机器有多IP时候，可以指定IP创建ServerSocket.
2、使用Socket进行通信
客户端可以使用Socket的构造器连接到指定服务器，Socket有两个构造器：
Socket(InetAddress/String remoteAddress,int port):创建连接到指定远程主机、远程端口的Socket,该构造器没有指定本地地址、本地端口，默认使用本机默认ip,默认使用系统动态分配的端口。
Socket(InetAddress/String remoteAddress,int port,InetAddress localAddr,int localPort):穿件Socket带有本地IP和port
package net;
import java.io.DataInputStream;
import java.io.IOException;
import java.io.PrintStream;
import java.net.ServerSocket;
import java.net.Socket; public class SocketServer { public static void main(String[] args) throws IOException {
//定义服务端口号
int port = 7000;
//获取ServerSocket对象
ServerSocket serverSocket = new ServerSocket(port);
while(true) {
//监听来自客户端的连接
Socket socket =serverSocket.accept();
PrintStream pis = new PrintStream(socket.getOutputStream());
pis.print("Hi:来自服务端的问候");
pis.close();
socket.close();
} }
} package net;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintStream;
import java.net.Socket;
import java.net.UnknownHostException;
public class SocketClient { public static void main(String[] args) { //定义客户端端口
int port = 7000;
//获取Socket
Socket socket = null;
BufferedReader br = null;
try {
socket = new Socket("localhost",port);
//设置10s超时
socket.setSoTimeout(10000);
br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
//获取数据
System.out.println(br.readLine());
} catch (Exception e) {
e.printStackTrace();
}finally {
try {
br.close();
socket.close();
} catch (IOException e) {
e.printStackTrace();
}
} }
}
3、加入多线程
上面程序只是简单的实现了Server和Client的简单通信：服务器接收到客户端的连接后想客户端发送了一个字符串，客户端读取字符串后就退出了。
实际应用中客户端可能需要跟服务器保持长时间通信，在使用传统的BufferReader的readLine方法读取数据时，在该方法返回成功之前，线程被阻塞，考虑到此点，所以服务器端应该为每个Socket单独启动一个线程，负责与客户端通信。
下面程序实现了命令行聊天大厅功能（参考疯狂java讲义）
服务端：
package chatServer; /**
* 协议字符
* @author rdb
*
*/
public interface ChatProtocol { //协议字符串长度
int PROTOCOL_LEN = 2;
//公发前后端字符
String MSG_ROUND = "☾△";
//用户前后字符
String USER_ROUND = "△▽";
//登录成功表示
String LOGIN_SUCCESS = "1";
//用户重复标识
String NAME_REP = "-1" ;
//私发用户标识
String PRIVATE_ROUND = "◆◆" ; String SPLIT_SIGN = "◆" ;
} package chatServer;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;
/**
*
* ChaMap:保存用户和对应的输出流，一一对应，不允许出现value重复
* @author rdb
* @param <K>
* @param <V>
*/
public class ChatMap<K,V> { //创建一个线程安全的HashMap
public Map<K,V> map = Collections.synchronizedMap(new HashMap<>()); //获取value的set集合
public synchronized Set<V> valueSet(){
Set<V> set = new HashSet<>();
map.forEach((key,value) -> set.add(value));
return set ;
} //实现put方法，不允许出现重复value
public synchronized V put(K key,V value) {
for(V v : valueSet()) {
if(v.equals(value) && v.hashCode() == value.hashCode()) {
throw new RuntimeException("ChatMap中不允许有重复value");
}
}
return map.put(key, value);
} //根据value查找key
public synchronized K getKeyByValue(V value) {
for(K k : map.keySet()) {
if(map.get(k) == value && map.get(k).equals(value)) {
return k;
}
}
return null;
} //根据value删除
public synchronized void removeByValue(V value){
for(K k : map.keySet()) {
if(map.get(k) == value) {
map.remove(k);
break;
}
}
}
} package chatServer;
import java.io.PrintStream;
import java.net.ServerSocket;
import java.net.Socket;
public class ChatServer { private static final int SERVER_PORT = 30000 ;
//用户保存客户端用户和对应socket输出流
public static ChatMap<String, PrintStream> chatMap = new ChatMap<>(); public void init() {
try {
ServerSocket serverSocket = new ServerSocket(SERVER_PORT);
while(true) {
Socket socket = serverSocket.accept();
System.out.println("******");
//启动对应的线程处理对应的客户端
new Thread(new ServerThread(socket)).start();
}
} catch (Exception e) {
e.printStackTrace();
}
} public static void main(String[] args) {
ChatServer chatServer = new ChatServer();
chatServer.init();
}
} package chatServer;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintStream;
import java.net.Socket;
public class ServerThread implements Runnable { private Socket socket = null;
private BufferedReader br = null;
private PrintStream ps = null; public ServerThread(Socket socket) {
this.socket = socket;
} @Override
public void run() {
try {
// 获取socket对应的输入流
br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
// 获取socket对应的输出流
ps = new PrintStream(socket.getOutputStream());
// 获取客户端的消息
String line = null;
while ((line = br.readLine()) != null) {
// 判断信息类型
// 用户登录
if (line.startsWith(ChatProtocol.USER_ROUND) &&
line.endsWith(ChatProtocol.USER_ROUND)) {
String userName = getRealMsg(line);
// 如果包含该用户，返回重复登录
if (ChatServer.chatMap.map.containsKey(userName)) {
System.out.println("重复");
ps.println(ChatProtocol.NAME_REP);
} else {
System.out.println("成功");
ps.println(ChatProtocol.LOGIN_SUCCESS);
ChatServer.chatMap.put(userName, ps);
}
}
// 私聊
else if (line.startsWith(ChatProtocol.PRIVATE_ROUND) &&
line.endsWith(ChatProtocol.PRIVATE_ROUND)) {
String userAndMsg = getRealMsg(line);
// 私聊时 SPLIT_SIGN前是私聊对象，后面是私聊信息
String user = userAndMsg.split(ChatProtocol.SPLIT_SIGN)[0];
String msg = userAndMsg.split(ChatProtocol.SPLIT_SIGN)[1];
// 向对应的客户端发送消息
ChatServer.chatMap.map.get(user).
println(ChatServer.chatMap.getKeyByValue(ps) + "悄悄的对你说：" + msg);
}
// 公聊
else {
String msg = getRealMsg(line);
// 向每个用户发送消息
ChatServer.chatMap.map.forEach((key, value) ->
value.println(ChatServer.chatMap.getKeyByValue(ps) + "说：" + msg));
}
}
}
// 捕获到异常表示对应的Socket的客户端出现问题，在map中移除该客户端信息
catch (IOException e) {
ChatServer.chatMap.removeByValue(ps);
System.out.println(ChatServer.chatMap.map.size());
// 关闭相关资源
try {
if (br != null) {
br.close();
}
if (ps != null) {
ps.close();
}
if (socket != null) {
socket.close();
}
} catch (IOException e1) {
e1.printStackTrace();
}
}
} private String getRealMsg(String msg) {
return msg.substring(ChatProtocol.PROTOCOL_LEN, msg.length() - ChatProtocol.PROTOCOL_LEN);
} }
客户端：
package charClient; import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintStream;
import java.net.Socket; import javax.swing.JOptionPane; /**
* 客户端
* @author rdb
*
*/
public class ChatClient { private static final int SERVER_PORT = 30000;
private static final String SERVER_IP = "127.0.0.1";
private Socket socket = null ;
private BufferedReader br = null;
private PrintStream ps = null ;
//键盘输入
private BufferedReader keyIn = null ; public void init() {
try {
socket = new Socket(SERVER_IP,SERVER_PORT);
br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
ps = new PrintStream(socket.getOutputStream());
keyIn = new BufferedReader(new InputStreamReader(System.in)); String tip = "";
//要求输入用户名登录
while(true) {
String userName =JOptionPane.showInputDialog(tip + "输入用户名");
//将用户名发送到服务器
ps.println(ChatProtocol.USER_ROUND + userName + ChatProtocol.USER_ROUND);
//获取服务器返回的消息
String result = br.readLine();
if(result.equals(ChatProtocol.NAME_REP)) {
System.out.println("用户名重复，请重试");
continue;
}
if(result.equals(ChatProtocol.LOGIN_SUCCESS)) {
break ;
}
}
} catch (IOException e) {
System.out.println("网络异常，请重新登录");
closeRs();
System.exit(1);
}
//启动对应socket的读取服务器消息的线程
new Thread(new ClientThread(br)).start(); String line = null;
try {
while((line = keyIn.readLine()) != null) {
//如果发送信息中有:号，且以//开头，则认为是发送私聊信息://张三:你最近怎么样
if(line.indexOf(":") >0 && line.startsWith("||")) {
line = line.substring(2);
System.out.println(ChatProtocol.PRIVATE_ROUND+line.split(":")[0]
+ChatProtocol.SPLIT_SIGN+line.split(":")[1]+ChatProtocol.PRIVATE_ROUND);
ps.println(ChatProtocol.PRIVATE_ROUND+line.split(":")[0]
+ChatProtocol.SPLIT_SIGN+line.split(":")[1]+ChatProtocol.PRIVATE_ROUND);
}else {
ps.println(ChatProtocol.MSG_ROUND + line + ChatProtocol.MSG_ROUND);
} }
} catch (IOException e) {
System.out.println("网络异常，请重新登录");
closeRs();
System.exit(1);
} } private void closeRs() {
try {
if(br != null) {
br.close();
}
if(ps != null) {
ps.close();
}
if(socket != null) {
socket.close();
}
if(keyIn != null) {
keyIn.close();
}
} catch (IOException e) {
e.printStackTrace();
}
} public static void main(String[] args) {
ChatClient chatClient = new ChatClient();
chatClient.init();
}
} package charClient; import java.io.BufferedReader;
import java.io.IOException; public class ClientThread implements Runnable{
private BufferedReader br = null;
public ClientThread(BufferedReader br) {
this.br = br ;
}
@Override
public void run() {
String line = null;
try {
while((line = br.readLine()) != null){
System.out.println(line);
}
} catch (IOException e) {
e.printStackTrace();
}finally {
try {
if(br != null) {
br.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
} package charClient; /**
* 协议字符
* @author rdb
*
*/
public interface ChatProtocol { //协议字符串长度
int PROTOCOL_LEN = 2;
//公发前后端字符
String MSG_ROUND = "☾△";
//用户前后字符
String USER_ROUND = "△▽";
//登录成功表示
String LOGIN_SUCCESS = "1";
//用户重复标识
String NAME_REP = "-1" ;
//私发用户标识
String PRIVATE_ROUND = "◆◆" ; String SPLIT_SIGN = "◆" ;
}