TCP和UDP通信

socket：用于描述IP地址和端口，是一个通信链的句柄。

ServerSocket：用于服务端。

原理：应用程序通过“套接字”向网络发出请求或者应答网络请求。

构造方法：Socket(String url,int port)

常用方法：

int getLocalPort()

InetAddress getLocalAddress()

使用InetAddress获取本地的地址方法。

String getCanonicalHostNmae()

String getHostAddress()获取IP地址

int getPort()通过Socket获取服务器端的端口号

InetAddress getInetAddress()获取服务器端地址

通过Socket获取网络输入流和网络输出流：

InputStream getInputStream()

OutputStream getOutputStream()

close()

Server端：

ServerSocket server = new ServerSocket(8888);

Socket socket = server.accept()

public class Client {
//客户端Socket
private Socket socket;
/**
* 构造方法，用于初始化
*/
public Client(){
try {
socket = new Socket("localhost",8088);
} catch (Exception e) {
e.printStackTrace();
}
}
/**
* 客户端工作方法
*/
public void start(){
try {
OutputStream out = socket.getOutputStream();
OutputStreamWriter osw = new OutputStreamWriter(out,"UTF-8");
PrintWriter pw = new PrintWriter(osw,true);

//创建Scanner读取用户输入内容
Scanner scanner = new Scanner(System.in);
while(true){
pw.println(scanner.nextLine());
}
} catch (Exception e) {
e.printStackTrace();
} finally{
if(socket != null){
try {
socket.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}

public static void main(String[] args) {
Client client = new Client();
client.start();
}
}

/**
* 服务端应用程序
*/
public class Server {
//服务端Socket
private ServerSocket serverSocket;
/**
* 构造方法，用于初始化
*/
public Server(){
try {
serverSocket = new ServerSocket(8088);
} catch (Exception e) {
e.printStackTrace();
}
}
/**
* 服务端开启方法
*/
public void start(){
try {
System.out.println("等待客户端连接...");
//监听客户端的连接
Socket socket = serverSocket.accept();
System.out.println("客户端已连接!");
InputStream in = socket.getInputStream();
InputStreamReader isr = new InputStreamReader(in,"UTF-8");
BufferedReader br = new BufferedReader(isr);

//循环读取客户端发送的信息
while(true){
System.out.println("客户端说:"+br.readLine());
}
} catch (Exception e) {
e.printStackTrace();
}
}

public static void main(String[] args) {
Server server = new Server();
server.start();
}
}

多个客户端连接：
/**
* 服务端应用程序
*/
public class Server {
// 服务端Socket
private ServerSocket serverSocket;
// 所有客户端输出流
private List<PrintWriter> allOut;
// 线程池
private ExecutorService threadPool;
/**
* 构造方法，用于初始化
*/
public Server() {
try {
serverSocket = new ServerSocket(8088);

allOut = new ArrayList<PrintWriter>();

threadPool = Executors.newFixedThreadPool(40);
} catch (Exception e) {
e.printStackTrace();
}
}
/**
* 服务端开启方法
*/
public void start() {
try {
//循环监听客户端的连接
while(true){
System.out.println("等待客户端连接...");
// 监听客户端的连接
Socket socket = serverSocket.accept();
System.out.println("客户端已连接!");

//启动一个线程来完成针对该客户端的交互
ClientHandler handler = new ClientHandler(socket);
threadPool.execute(handler);
}
} catch (Exception e) {
e.printStackTrace();
}
}
/**
* 将输出流存入共享集合，与下面两个方法互斥，保证同步安全
* @param out
*/
private synchronized void addOut(PrintWriter out){
allOut.add(out);
}
/**
* 将给定输出流从共享集合删除
* @param out
*/
private synchronized void removeOut(PrintWriter out){
allOut.remove(out);
}
/**
* 将消息转发给所有客户端
* @param message
*/
private synchronized void sendMessage(String message){
for(PrintWriter o : allOut){
o.println(message);
}
}
public static void main(String[] args) {
Server server = new Server();
server.start();
}
/**
* 线程体，用于并发处理不同客户端的交互
*/
private class ClientHandler implements Runnable {
// 该线程用于处理的客户端
private Socket socket;
public ClientHandler(Socket socket) {
this.socket = socket;
}
@Override
public void run() {
PrintWriter pw = null;
try {
//将客户端的输出流存入共享集合，以便广播消息
OutputStream out = socket.getOutputStream();
OutputStreamWriter osw = new OutputStreamWriter(out,"UTF-8");
pw = new PrintWriter(osw,true);
/*
* 将用户信息存入共享集合
* 需要同步
*/
addOut(pw);

InputStream in = socket.getInputStream();
InputStreamReader isr = new InputStreamReader(in, "UTF-8");
BufferedReader br = new BufferedReader(isr);

String message = null;
// 循环读取客户端发送的信息
while ((message = br.readLine())!=null) {
/*
* 遍历所有输出流，将该客户端发送的信息转发给所有客户端
* 需要同步
*/
sendMessage(message);
}
} catch (Exception e) {
e.printStackTrace();
} finally {
/*
* 当客户端断线，要将输出流从共享集合中删除
* 需要同步
*/
removeOut(pw);

if (socket != null) {
try {
socket.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
}
}

UDP通信：

接收包：DatagramPacket（byte[] buf, int length）

               DatagramPacket(byte[] buf ,int offset, int length)

发送包：

              Datagrampacket(byte[] buf, int length, InetAddress clientAddress, int clientPort)

              Datagrampacket(byte[] buf,int offset, int length, InetAddress clientAddress, int clientPort)

客户端：

               DatagramSocket()

               send(DatagramPacket dp)

服务器端：

             DatagramSocket(int port)

              receive(DatagramPacket d)

例子：

public class Client {
private void start() {
try {
DatagramSocket client = new DatagramSocket();
String sendStr = "Hello! I'm Client";
byte[] sendBuf;
sendBuf = sendStr.getBytes();
InetAddress addr = InetAddress.getByName("127.0.0.1");
int port = 8088;
DatagramPacket sendPacket = new DatagramPacket(sendBuf,
sendBuf.length, addr, port);
client.send(sendPacket);
byte[] recvBuf = new byte[100];
DatagramPacket recvPacket = new DatagramPacket(recvBuf, recvBuf.length);
client.receive(recvPacket);
String recvStr = new String(recvPacket.getData(), 0,
recvPacket.getLength());
System.out.println("服务端说:" + recvStr);
client.close();
} catch (Exception e) {
e.printStackTrace();
}
}

public static void main(String[] args) {
Client client = new Client();
client.start();
}
}

public class Server {
public void start() {
try {
DatagramSocket server = new DatagramSocket(8088);
byte[] recvBuf = new byte[100];
DatagramPacket recvPacket = new DatagramPacket(recvBuf,
recvBuf.length);
server.receive(recvPacket);
String recvStr = new String(recvPacket.getData(), 0,
recvPacket.getLength());
System.out.println("客户端说:" + recvStr);
int port = recvPacket.getPort();
InetAddress addr = recvPacket.getAddress();
String sendStr = "Hello ! I'm Server";
byte[] sendBuf;
sendBuf = sendStr.getBytes();
DatagramPacket sendPacket = new DatagramPacket(sendBuf,
sendBuf.length, addr, port);
server.send(sendPacket);
server.close();
} catch (Exception e) {
e.printStackTrace();
}
}
public static void main(String[] args) {
Server server = new Server();
server.start();
}
}