**Java套接字编程-由浅入深**
套接字编程TCP/UDP：
在java里面有专门的类负责客户端和服务端通信的任务，而通信的种类有两种：TCP和UDP，TCP是典型的服务端/客户端模型，他通过客户端和服务端的连接，使用java IO流来达到效果。而在UDP中，我们用到的是数据报来进行通信。tcp通信需要建立专门的连接通道，通过这个通道进行通信，udp则是以数据报的接收发送达到通信效果。二者的区别在于是否需要建立通信通道。举个简单的例子：TCP通信就相当于是打电话，你给别人打电话，你需要知道别人的电话号码，就相当于IP地址。电话打通后，拨打电话的双方之间就是有信号通道，互相之间能听到对方说的话，一旦电话挂断，通信通道销毁，这个时候你就什么也听不到了。这个时候你就会想能不能发短信呢，当然能，UDP就相当于发送短信，我只需要知道对方的电话号码，直接编辑短信发给他就是了，不再需要建立专门的通道哦，但是UDP有一个明显的缺点就是消息不及时，手机收到短信几天甚至十几天过后才看到是常有的事，所以UDP的缺点就在于不能及时让对方知道，甚至对方可能接收不了。但是两种通信方式在实际编程中互相结合使用，互相弥补优缺点。
TCP：
tcp中涉及到的主要有两个类：Socket 和ServerSocket,Socket用于客户端，ServerSocket用于服务端。
Socket的用法：Socket socket = new Socket(ip,port);最常用的构造方法之一，含义是连接到地址为ip的服务器上，端口为port.一般socket通信使用IO流来进行写入和读取，客户端向流里面写东西，socket通过调用getInputStream()和getOutputStream()方法来获取输出输入流，服务端从流里面把数据读取出来过后又向流里面写入东西，客户端再从流里面读取信息，完成一次对话：
BufferedWriter bw = new BufferedWriter(new InputStreamWriter(socket.getOutpouStream()));
bw.write("hello world");
//一定要加这句话，将缓冲区的内容全部排出
bw.fllush();
`ServerSocket`用法：`ServerSocket serversocket = new ServerSocket(port)`;建立监听窗口，等待连接：
//发方法在没有接收到客户端的连接请求时一直处于阻塞状态，返回值是Socket
Socket socket = serversocket.accept();
//建立输入流，读取客户端发来的信息
`BufferedReader br = new BufferedReader(new`
InputStreamReader(socket.getInputStream()))；
byte[] buf = new byte[2048];
//调用read方法，将流里面的内容读取到byte数组中，并返回其长度
int len = in.read(buf);
//将byte数组转换为字符串
System.out.println(new String(buf,0,len) );
再向客户端写东西：
BufferedReader bo= new BufferedWriter(new InputStreamWriter(socket.getOutputStream()))；
String s = "客户你好，我已收到消息";
bo.write(s);
在客户端里再用BufferedReader将信息读取出来即可.
下面用具体例子给大家讲解：
客户端：
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.net.Socket;
import java.net.UnknownHostException;
import java.util.Scanner;
public class Client {
private int port;
private String address;
private Socket socket;
private BufferedWriter out;
private BufferedReader in;
public Client(int port,String address){
this.port = port;
this.address = address;
}
public void start() throws UnknownHostException, IOException{
//发送连接请求
socket = new Socket(address,port);
//输入流
in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
out = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
//向流里面输入内容
out.write("快来和我聊天吧");
out.flush();
System.out.println("向服务端发送数据：");
try{
//while的作用是能一直从键盘读入
while(true){
//不要用readLine()该方法容易引起阻塞
char[] cbuf = new char[2048];
int len = in.read(cbuf);
System.out.println("收到服务端回话："+new String(cbuf,0,len));
Scanner scan = new Scanner(System.in);
String s = scan.next();
if(!s.equals("再见")){
out.write(s);
out.flush();
}else{
socket.close();
in.close();
out.close();
socket.close();
}
}
}catch(Exception e){
e.printStackTrace();
}finally{
try{
System.out.println("所有连接已关闭");
}catch(Exception e){
e.printStackTrace();
}
}
}
public static void main(String[] args) throws UnknownHostException, IOException{
Client client = new Client(9994,"127.0.0.1");
client.start()；
}
}
服务端：
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;
import java.util.Scanner;
public class Service {
private BufferedReader in;
private BufferedWriter out;
private ServerSocket serversocket;
private Socket socket;
private int port;
public Service(int port){
this.port = port;
}
public void response() throws IOException, InterruptedException{
try {
//建立监听端口
serversocket = new ServerSocket(this.port);
System.out.println("准备接收客户端发来的数据:");
//阻塞，等待客户端发请求
socket = serversocket.accept();
in = new BufferedReader(new InputStreamReader(socket.getInputStream()));
out = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
System.out.println("连接成功，客户端信息："+socket);
//为客户端开一个新线程
try{
while(true){
char[] cbuf = new char[2048];
int len = in.read(cbuf);
System.out.println("收到客户端消息:"+new String(cbuf,0,len));
//out.write("我已经给你连接上了，开始聊天吧");
//必须要用上out.flush，不然数据在缓冲区中，不能被读取
//out.flush();
Scanner scan = new Scanner(System.in);
String s = scan.next();
if(!s.equals("再见")){
out.write(s);
out.flush();
}else{
serversocket.close();
in.close();
out.close();
socket.close();
}
}
}catch(Exception e){
e.printStackTrace();
}
//向客户端发送内容
//建议不要用nextLine，因为该方法读取的是行，如果没读取到换行符，则会一直读下去，造成阻塞
} catch (IOException e) {
e.printStackTrace();
}
}
/*public class LogicThread extends Thread{
private BufferedReader in;
private BufferedWriter out;
private ServerSocket serversocket;
private Socket socket;
public LogicThread(BufferedReader in,BufferedWriter out,Socket socket,ServerSocket serversocket){
this.in = in;
this.out = out;
this.socket = socket;
this.serversocket = serversocket;
}
public void run(){
while(true){
}
}
}*/
public static void main(String[] args) throws IOException, InterruptedException{
Service service = new Service(9994);
service.response();
//service.serversocket.close();
}
}
UDP编程：
客户端：
DatagramSocket:套接字，相当于电话，使用方法：
DatagramSocket ds = new DatagramSocket();可以不需要绑定任何地址，因为你发送短信给别人的时候，任何手机都可以用，你只需要在发送短信的时候记住电话号码就行了
DatagramPacket:数据报，相当于短信，使用方法：
String s = "heelo world";
byte[] buf = s.getBytes();
DatagramPacket dp = new DatagramPacket(buf,buf.length,Ip,port);
上面的IP就相当于电话号码，长度就是短信大小。
然后用电话把短信发出去：ds.send(dp);
服务端：
服务端需要建立监听端口，如果你手机关机别人是接收不到的，所以开机监听：
DatagramSocket ds = new DatagramSocket(port);
接收：
byte[] buf = new btye[2048]
//构造数据报
DatagramPacket dp = new DatagramPacket(buf,buf.length);
将收到的内容放到dp中
ds.receive(dp);
读取：
byte[] buf1 = dp.getData()；
System.out.println(new String(buf1,0,buf1.length()));
返回结果给客户端：
String s = "收到"；
byte[] buf2 = s.getBytes();
//通过接收到的数据报获得客户端的ip和port,并向他返回信息
ds.send(buf2,buf2.length,dp.getAddress(),dp.getPort());
客户端再通过receive()方法收到服务端返回的消息即可完成一次通信。
实例：
客户端：
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.net.UnknownHostException;
import java.util.Scanner;
public class Client {
private int port;
private InetAddress address;
//发送报文给服务端
private DatagramPacket send;
//接收服务端发送过来的报文
private DatagramPacket recieve;
private DatagramSocket socket;
public Client(int port,InetAddress address){
this.port = port;
this.address = address;
}
public void send() {
//不需要绑定具体的发送地点，类似于邮局，你不需要在固定的邮局寄东西，所以这不绑定ip都可以，信封上有就行了
try{
socket = new DatagramSocket();
//发送
Scanner scan = new Scanner(System.in);
while(true){
String s = scan.next();
//将字符串转换到byte类型的buf数组里面
byte[] buf = s.getBytes();
send = new DatagramPacket(buf,buf.length,address,port);
socket.send(send);
System.out.println("发送成功，等待服务端响应");
//接收
byte[] rbuf = new byte[2048];
recieve = new DatagramPacket(rbuf,rbuf.length);
//未收到服务端消息时阻塞
socket.receive(recieve);
//用于接收
byte[] rbuf1 = recieve.getData();
int len = rbuf1.length;
System.out.println("服务端说："+new String(rbuf1,0,len));
}
}catch(Exception e){
e.printStackTrace();
}
}
public static void main(String[] args) throws UnknownHostException{
Client client = new Client(9998,InetAddress.getByName("127.0.0.1"));
client.send();
}
}
服务端：
import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.util.Scanner;
public class Service {
private int port;
private DatagramPacket send;
private DatagramPacket recieve;
private DatagramSocket socket;
public Service(int port){
this.port = port;
}
public void recieve() throws IOException{
//建立监听窗口
socket = new DatagramSocket(port);
System.out.println("服务器已经启动");
//开启新线程为客户端处理事务
new LogicThread(recieve,socket);
//System.out.println("发送成功");
}
public class LogicThread extends Thread{
public DatagramPacket recieve;
public DatagramSocket socket;
public LogicThread(DatagramPacket recieve,DatagramSocket socket){
this.recieve = recieve;
this.socket = socket;
start();
}
public void run(){
try{
//while的作用是一直接接收数据包
while(true){
byte[] rbuf = new byte[2048];
//封装数据报，用于接收数据
recieve = new DatagramPacket(rbuf,rbuf.length);
//等待客户端发来数据，不然阻塞
socket.receive(recieve);
byte[] buf = recieve.getData();
int len = buf.length;
System.out.println("客户端发来数据："+new String(buf,0,len));
//向客户端发送数据
Scanner scan = new Scanner(System.in);
String s = scan.next();
byte[] sbuf = s.getBytes();
send = new DatagramPacket(sbuf,sbuf.length,recieve.getAddress(),recieve.getPort());
socket.send(send);
}
}catch(Exception e){
e.printStackTrace();
}
}
}
public static void main(String[] args) throws IOException{
Service service = new Service(9998);
service.recieve();
}
}
简单的TCP/UDP通信介绍到此，如果有什么不对的大家尽量指出，这样才能共同进步，对吗。