（一）Socket概念：

socket时TCP/IP协议的抽象，是操作系统对外开放的接口
在这里插入图片描述
socket起源于unix，京客户端和服务端各自管理一个文件，是其能分别对文件进行读写操作
socket的通信流程：

(二)代码实现：

编写TCP和UDP实现服务端与客户端的通信：

TCP实现：

服务器端实现：

创建Socket，并将socket绑定端口
while循环使得socket一直在等待状态
监听端口
获取客户端请求信息后，执行相关业务逻辑

import java.net.ServerSocket;
import java.net.Socket;
        public class TCPServer{
             public static void main(String []agrs)throws Exception{
                  ServerSocket ss=new ServerSocket(65000);      //创建Socket，并将socket绑定端口
                  while(true){                                 //while循环使得socket一直在等待状态
                      Socket socket=ss.accept();               //监听端口
                      new LengthCalculator(socket).start();     //获取客户端请求信息后，执行相关业务逻辑
                      }
                 }
   }

线程运行持续获得客户端的请求后，回送信息：

获取socket输入流
获取socket输出流
buff读取输入内容
将接受流的byte数组转化为字符串
回送客户端字符串长度
关闭

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.Socket;
public class LengthCalculator extends Thread{
            private Socket socket;
            public LengthCalculator(Socket socket){
                   this.socket=socket;
                   }
             public void run(){
                     try{
                          //获取socket输入流
                          OutputStream os=socket.getOutputStream();   
                          //获取socket输出流
                          InputStream is=socket.getInputStream();
                          int ch=0;
                          //buff读取输入内容
                          byte[]buff=new byte[1024];
                          ch=is.read(buff);
                          //将接受流的byte数组转化为字符串
                          String content=new String(buff,0,ch);
                          //回送客户端字符串长度
                             os.write(String.valueOf(content.length()).getBytes());
                          //关闭
                          is.close();
                          os.close();
                          socket.close();
                  }catch(IOException e){
                  e.printStackTrace();
         }
      }
  }

客户端的实现：

创建socket，并指定连接端口
获取输出流
获取输入流
将要传递给server的字符串转换为byte数组
buff读取输入内容
ch获取读取长度
关闭输入流及socket

import java.io.OutputStream;
import java.io.InputStream;
import java.net.Socket;
import java.net.Socket;

    public class TCPClient{
         public static void main(String []args)throws Exception{
               //创建socket，并指定连接端口
                Socket socket=new Socket(new InetSocketAddress("127.0.0.1",65000);
                //获取输出流
                OutputStream os=socket.getOutputStream();
                //获取输入流
                InputStream is=socket.getInputStream();
                //将要传递给server的字符串转换为byte数组
                os.write(new String("hello world").getBytes());
                int ch=0;
                //buff读取输入内容
                byte[]buff=new byte[1024];
                //ch获取读取长度
                ch=is.read(buff);
                String connect=new String (buff,0,ch);
                System.out.println(connect);
                //关闭输入流及socket
                is.close();
                os.close();
                socket.close();
          }
     }

UDP实现：

服务器端：

服务器端接受客户端发送的数据报
- 监听端口号
- 存储从客户端接收的内容
- 将客户端发送的内容封装进入DatagramPacket中
- 将数据从二进制转化为字符串的形式
- 将要发送的信息转化为二进制
服务端发送数据报
- 从DatagramPacket对象中获取到数据的来源地址和端口号
- 发送数据给客户端

import java.net.DatagramPacket;
import java.net.DatagramSocket;

        public class UDPServer{
            public static void main(String []args)  throws Exception{
            //服务器端接受客户端发送的数据报
             //监听端口号
                DatagramSocket socket=new DatagramSocket(65001);
                //存储从客户端接收的内容
                byte[]buff=new byte[100];
                //将客户端发送的内容封装进入DatagramPacket中
                DatagramPacket packet=new DatagramPacket(buff,buff.length);
                socket.receive(packet);
                //将数据从二进制转化为字符串的形式
                byte[]data=packet.getData();
                String content=new String(data,0,packet.getLength());
                System.out.println(content);
               // 将要发送的信息转化为二进制
               byte[]sendedContent=String.valueOf(content.length()).getBytes();
            
            //服务端发送数据报
            //从DatagramPacket对象中获取到数据的来源地址和端口号
              DatagramPacket packetToClient=new DatagramPacket(sendedContent,sendedContent.length,packet.getAddress(),packet.getPort());
              //发送数据给客户端
              socket.send(packetToClient);
             }
        }

客户端实现：

客户端给服务器端发送数据
- 存储要发送的数据
- 将IP地址封装成InetAddres对象
- 将要发送给服务器端的数据封装为DatagramPacket对象，要写上ip与端口号
- 发送数据给服务器
客户端接收服务器的数据
- 创建DatagramPacket对象来存储服务器发送的数据
- 将服务器端发送的数据取出并打印到控制台

import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;

public class UDPClient{
      public static void main(String[]args)throws Exception{
                  //客户端给服务器端发送数据
                 DatagramSocket socket=new DatagramSocket();
                 //存储要发送的数据
                 byte[]buf="hello world".getBytes();
                 //将IP地址封装成InetAddres对象
                 InetAddress address=InetAddress.getByName("127.0.0.1");
                 //将要发送给服务器端的数据封装为DatagramPacket对象，要写上ip与端口号
                 DatagramPacket packet=new DatagramPacket(buf,buf.length,address,65001);
                 //发送数据给服务器
                 socket.send(packet);
                         
                    //客户端接收服务器的数据
                    byte[]data=new byte[100];
                    //创建DatagramPacket对象来存储服务器发送的数据
                    DatagramPacket receivedPacket=new DatagramPacket(buf,buf.length);
              
                 socket.receive(receivedPacket);
                 //将服务器端发送的数据取出并打印到控制台
                 String content=new String(receivedPacket.getData(),0,receivedPacket.getLength());
                 System.out.println(content);
        }
    }

（七）Socket简介及代码实现

（一）Socket概念：

(二)代码实现：

TCP实现：

UDP实现：