Java 基于TCP协议的Socket编程和通信
在网络通讯中，第一次主动发起通讯的程序被称作客户端(Client)程序，简称客户端，而在第一次通讯中等待连接的程序被称作服务器端(Server)程序，简称服务器。一旦通讯建立，则客户端和服务器端完全一样，没有本质的区别。
请求-响应”模式：
1. Socket类：发送TCP消息。
2. ServerSocket类：创建服务器。
套接字是一种进程间的数据交换机制。这些进程既可以在同一机器上，也可以在通过网络连接的不同机器上。换句话说，套接字起到通信端点的作用。单个套接字是一个端点，而一对套接字则构成一个双向通信信道，使非关联进程可以在本地或通过网络进行数据交换。一旦建立套接字连接，数据即可在相同或不同的系统中双向或单向发送，直到其中一个端点关闭连接。套接字与主机地址和端口地址相关联。主机地址就是客户端或服务器程序所在的主机的IP地址。端口地址是指客户端或服务器程序使用的主机的通信端口。
在客户端和服务器中，分别创建独立的Socket，并通过Socket的属性，将两个Socket进行连接，这样，客户端和服务器通过套接字所建立的连接使用输入输出流进行通信。
TCP/IP套接字是最可靠的双向流协议，使用TCP/IP可以发送任意数量的数据。
实际上，套接字只是计算机上已编号的端口。如果发送方和接收方计算机确定好端口，他们就可以通信了。
TCP/IP通信连接的简单过程：
位于A计算机上的TCP/IP软件向B计算机发送包含端口号的消息，B计算机的TCP/IP软件接收该消息，并进行检查，查看是否有它知道的程序正在该端口上接收消息。如果有，他就将该消息交给这个程序。
要使程序有效地运行，就必须有一个客户端和一个服务器。
通过Socket的编程顺序：
1. 创建服务器ServerSocket，在创建时，定义ServerSocket的监听端口(在这个端口接收客户端发来的消息)。
2. ServerSocket调用accept()方法，使之处于阻塞状态。
3. 创建客户端Socket，并设置服务器的IP及端口。
4. 客户端发出连接请求，建立连接。
5. 分别取得服务器和客户端Socket的InputStream和OutputStream。
6. 利用Socket和ServerSocket进行数据传输。
7. 关闭流及Socket。
单向通信
服务器端
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.OutputStreamWriter;
import java.net.ServerSocket;
import java.net.Socket;
/**
* 最简单的服务器端代码
* @author Administrator
*/
public class BasicSocketServer {
public static void main(String[] args) {
Socket socket = null;
BufferedWriter bw = null;
try {
// 建立服务器端套接字：指定监听的接口
ServerSocket serverSocket = new ServerSocket(8888);
System.out.println("服务端建立监听");
// 监听，等待客户端请求，并愿意接收连接
socket = serverSocket.accept();
// 获取socket的输出流，并使用缓冲流进行包装
bw = new BufferedWriter(new
OutputStreamWriter(socket.getOutputStream()));
// 向客户端发送反馈信息
bw.write("hhhh");
} catch (IOException e) {
e.printStackTrace();
} finally {
// 关闭流及socket连接
if (bw != null) {
try {
bw.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if (socket != null) {
try {
socket.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}客户端
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.InetAddress;
import java.net.Socket;
/**
* 最简单的Socket客户端
* @author Administrator
*/
public class BasicSocketClient {
public static void main(String[] args) {
Socket socket = null;
BufferedReader br = null;
try {
/*
* 创建Scoket对象：指定要连接的服务器的IP和端口而不是自己机器的
* 端口。发送端口是随机的。
*/
socket = new Socket(InetAddress.getLocalHost(), 8888);
//获取scoket的输入流，并使用缓冲流进行包装
br = new BufferedReader(new
InputStreamReader(socket.getInputStream()));
//接收服务器端发送的信息
System.out.println(br.readLine());
} catch (Exception e) {
e.printStackTrace();
} finally {
// 关闭流及socket连接
if (br != null) {
try {
br.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if (socket != null) {
try {
socket.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}双向通信
服务器端
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;
public class Server {
public static void main(String[] args){
Socket socket = null;
BufferedReader in = null;
BufferedWriter out = null;
BufferedReader br = null;
try {
//创建服务器端套接字：指定监听端口
ServerSocket server = new ServerSocket(8888);
//监听客户端的连接
socket = server.accept();
//获取socket的输入输出流接收和发送信息
in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
out = new BufferedWriter(new
OutputStreamWriter(socket.getOutputStream()));
br = new BufferedReader(new InputStreamReader(System.in));
while (true) {
//接收客户端发送的信息
String str = in.readLine();
System.out.println("客户端说：" + str);
String str2 = "";
//如果客户端发送的是“end”则终止连接
if (str.equals("end")){
break;
}
//否则，发送反馈信息
str2 = br.readLine(); // 读到\n为止，因此一定要输入换行符！
out.write(str2 + "\n");
out.flush();
}
} catch (IOException e) {
e.printStackTrace();
} finally {
//关闭资源
if(in != null){
try {
in.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if(out != null){
try {
out.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if(br != null){
try {
br.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if(socket != null){
try {
socket.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}客户端
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.net.InetAddress;
import java.net.Socket;
import java.net.UnknownHostException;
public class Client {
public static void main(String[] args) {
Socket socket = null;
BufferedReader in = null;
BufferedWriter out = null;
BufferedReader wt = null;
try {
//创建Socket对象，指定服务器端的IP与端口
socket = new Socket(InetAddress.getLocalHost(), 8888);
//获取scoket的输入输出流接收和发送信息
in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
out = new BufferedWriter(new
OutputStreamWriter(socket.getOutputStream()));
wt = new BufferedReader(new InputStreamReader(System.in));
while (true) {
//发送信息
String str = wt.readLine();
out.write(str + "\n");
out.flush();
//如果输入的信息为“end”则终止连接
if (str.equals("end")) {
break;
}
//否则，接收并输出服务器端信息
System.out.println("服务器端说：" + in.readLine());
}
} catch (UnknownHostException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} finally {
// 关闭资源
if (out != null) {
try {
out.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if (in != null) {
try {
in.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if (wt != null) {
try {
wt.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if (socket != null) {
try {
socket.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}聊天室
服务器端
package cn.menglangpoem.chat;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.List;
import java.util.concurrent.CopyOnWriteArrayList;
/**
* 聊天室服务器
*/
public class Server {
//准备容器，存储客户端
private static List list = new CopyOnWriteArrayList<>();
//主函数
public static void main(String[] args) throws IOException {
int num = 0;
//创建服务器
ServerSocket server = null;
try {
server = new ServerSocket(8888);
System.out.println("服务器已启动，端口号---->8888");
} catch (IOException e) {
e.printStackTrace();
}
while(true)
{
//接收客户端
Socket client = server.accept();
num++;
System.out.println(num+"个服务器已连接");
//存储到容器
Chanel chanel = new Chanel(client);
list.add(chanel);
//开启线程
new Thread(chanel).start();
}
}
//信号通道
static class Chanel implements Runnable{
private Socket clinet = null;//客户端
private boolean flag = true;//控制运行
private DataInputStream clientR = null; //读信息
private DataOutputStream clientW = null;//写信息
private String name; //客户端姓名
public Chanel(Socket clinet) {
this.clinet = clinet;
//初始化
try {
this.clientR = new DataInputStream(clinet.getInputStream());
this.clientW = new DataOutputStream(clinet.getOutputStream());
this.name = clientR.readUTF();
this.send("欢迎来到聊天室！");
} catch (IOException e) {
//e.printStackTrace();
System.out.println("初始化失败！");
flag = false;
}
}
@Override
public void run() {
while(flag)
{
sendOthers();
}
}
//发送
private void send(String msg)
{
//判断是否为空
try {
//System.out.println("send ---- "+msg);
clientW.writeUTF(msg);
clientW.flush();
} catch (IOException e) {
//e.printStackTrace();
System.out.println("发送失败！");
flag = false;
}
}
//接收
private String receive()
{
String msg = null;
try {
msg = clientR.readUTF();
} catch (IOException e) {
//e.printStackTrace();
System.out.println("接收失败！");
flag = false;
}
return msg;
}
//发送群消息
private void sendOthers()
{
String msg = receive();
for(Chanel other: list)
{
if(other == this)
continue;
else
{
other.send(this.name+"说"+msg);
}
}
}
}
}
客户端
package cn.menglangpoem.chat;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.net.Socket;
import java.util.Scanner;
/**
* 聊天客户端
*/
public class Client {
public static void main(String[] args) throws IOException {
//连接服务器
Socket server = new Socket("localhost",8888);
//启动线程
new Thread(new Send(server)).start();
new Thread(new Receive(server)).start();
System.out.println("请输入昵称");
}
//接收信息
static class Receive implements Runnable{
private Socket server = null;
private boolean flag = true;
DataInputStream serverR = null;
//构造函数
public Receive(Socket server) {
//初始化
this.server = server;
try {
this.serverR = new DataInputStream(server.getInputStream());
} catch (IOException e) {
e.printStackTrace();
flag = false;
}
}
@Override
public void run() {
while (flag)
{
System.out.println(receive());
}
}
private String receive()
{
String msg = null;
try {
msg = serverR.readUTF();
} catch (IOException e) {
//e.printStackTrace();
System.out.println("接收信息失败！");
flag = false;
}
return msg;
}
}
//发送信息
static class Send implements Runnable{
private Socket server = null;
private DataOutputStream serverW = null;
private boolean flag = true;
public Send(Socket server) {
this.server = server;
try {
serverW = new DataOutputStream(server.getOutputStream());
} catch (IOException e) {
e.printStackTrace();
}
}
//线程体
@Override
public void run() {
while (flag)
send();
}
//发送函数
private void send()
{
Scanner scanner = new Scanner(System.in);
String msg = scanner.next();
try {
serverW.writeUTF(msg);
serverW.flush();
} catch (IOException e) {
e.printStackTrace();
System.out.println("发送信息失败！");
flag = false;
}
}
}
}