本文主要是介绍Socket编程，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！

文章目录

• 一、Socketbc编程
• • 1.IP和端口号（组成网络）
  • 2.Tcp与UDP概念
  • 3.Socket编程原理
  • 4.代码
  • 5.UDP程序的原理
  • 6.主要类的方法
  • 7、代码具体实现
  • 8、UDP对聊
• 总结

一、Socketbc编程

public class ServerSocket
extends Object
implements Closeable
这个类实现了服务器套接字。 服务器套接字等待通过网络进入的请求。 它根据该请求执行一些操作，然后可能将结果返回给请求者。
服务器套接字的实际工作由SocketImpl类的实例执行。 应用程序可以更改创建套接字实现的套接字工厂，以配置自己创建适合本地防火墙的套接字。

1.IP和端口号（组成网络）

IP（internet Protocol），网络之间的互联协议，IP（加子网掩码）是区分不同计算机的唯一标识
端口号是计算机的逻辑通信接口，不同的应用程序用不同的端口号，网络应用程序的区分标识

端口号一般是两个字节（16给bit 65536）

1、公认端口
第一类:公认端口（Well Known Ports）：从0到1023，它们紧密绑定（binding）于一些服务。通常这些端口的通讯明确表明了某种服务的协议，例如：80端口实际上总是HTTP通讯。 21 ftp 22 ssh（security shell） 443 https …
2、注册端口 （1024-49151）
第一类:公认端口（Well Known Ports）：从0到1023，它们紧密绑定（binding）于一些服务。通常这些端口的通讯明确表明了某种服务的协议，例如：80端口实际上总是HTTP通讯。 21 ftp 22 ssh（security shell） 443 https …
3、动态和、私有端口
第三类:动态和/或私有端口（Dynamic and/or Private Ports）：从49152到65535。理论上，不应为服务分配这些端口。实际上，机器通常从1024起分配动态端口

2.Tcp与UDP概念

网络七层协议： 网络层，数据链路层，网络层ip，传输层，会话层，表示层，应用层
传输层两个重要协议

TCP（Transmission Control Protocol）连通性
传输控制协议，提供可靠无差错的数据传输，保证数据正确性,速度慢，占用系统资源高，TCP面向连接。每条TCP传输连接只能有两个端点，只能进行点对点的数据传输，不支持多播和广播传输方式。
UDP（User Datagram Protocol）（）
用户数据报协议，不可靠的数据传输，可能丢包,速度快,占用资源较少，UDP面向无连接。UDP支持一对一，一对多，多对一和多对多的交互通信。

3.Socket编程原理

服务器端

(1) 创建ServerSocket对象，绑定监听端口；
(2) 通过accept()方法监听客户端请求(产生阻塞)；
(3) 连接建立后，通过输入流读取客户端发送的请求信息；
(4) 通过输出流向客户端发送相应信息；
(5) 关闭相应资源。

客户端

（1）创建Socket对象，指明需要连接的服务器地址和端口；
（2）连接建立后，通过输出流向服务器端发送请求信息；
（3）通过输入流获取服务器端返回的响应信息；
（4）关闭相应资源；

4.代码

/**
 * @author zhangyifan
 * @version 8.0
 * @description:服务器
 * @date 2021/12/7 9:56
 */
public class Server {
    public static void main(String[] args) {
        ServerSocket serverSocket= null;
        Socket socket=null;
        BufferedReader bufferedReader=null;
        PrintWriter printWriter=null;
        try {
            // (1) 创建ServerSocket对象，绑定监听端口；
            serverSocket = new ServerSocket(16666);
            System.out.println("服务器以准备就绪,等待连接");
            // (2) 通过accept()方法监听客户端请求(产生阻塞)；
            socket= serverSocket.accept();//监听
            //按行读取提高效率 需要把字节流转换成字符流
            bufferedReader=//BufferedReader在字符流套接缓存，提高读写效率
                    new BufferedReader( //InputStreamReader吧字节流转字符流
                            new InputStreamReader( socket.getInputStream()) ) ;
            //按行读取客户端信息
            String s = bufferedReader.readLine();
            //打印
            System.out.println("客户端说"+s);
            //    (4) 通过输出流向客户端发送相应信息；
            printWriter =new PrintWriter(socket.getOutputStream());
            //写入信息
            printWriter.println("你好客户端 收到了信息"+s+"，给你回复");
            //清空管道
            printWriter.flush();
        } catch (IOException e) {
            e.printStackTrace();

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

        }

    }
}
/**
 * @author zhangyifan
 * @version 8.0
 * @description:客户端
 * @date 2021/12/7 10:35
 */
public class Client {
    public static void main(String[] args) {
        Socket socket= null;
        PrintWriter printWriter=null;
        BufferedReader bufferedReader=null;
        try {
            // (1) 创建Socket对象，指明需要连接的服务器地址和端口；
            socket = new Socket("192.168.41.26",16666);
            //   (2) 连接建立后，通过输出流向服务器端发送请求信息；
            printWriter=new PrintWriter(socket.getOutputStream());
            //写入消息
            printWriter.println("你好服务器");
            //写入消息
            printWriter.flush();
//        (3) 通过输入流获取服务器端返回的响应信息；
            bufferedReader=
                    new BufferedReader(new InputStreamReader(socket.getInputStream()));
            //按行读取信息
            String s = bufferedReader.readLine();
            //打印
            System.out.println("服务器说"+s);
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            //关闭资源
            if (bufferedReader!=null){
                try {
                    bufferedReader.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (printWriter!=null){
                printWriter.close();
            }
            if (socket!=null){
                try {
                    socket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

持续通话
有问题的代 码 发送消息有时会不及时

/**
 * @author zhangyifan
 * @version 8.0
 * @description:
 * @date 2021/12/7 14:19
 */
public class Server {
    public static void main(String[] args) {
        ServerSocket serverSocket=null;
        Socket socket=null;
        BufferedReader bufferedReader=null;
        PrintWriter printWriter=null;

      /*  (1) 创建ServerSocket对象，绑定监听端口；
        (2) 通过accept()方法监听客户端请求(产生阻塞)；
        (3) 连接建立后，通过输入流读取客户端发送的请求信息；
        (4) 通过输出流向客户端发送相应信息；
        (5) 关闭相应资源。*/
        try {
            // (1) 创建ServerSocket对象，绑定监听端口；
            serverSocket=new ServerSocket(16666);
            System.out.println("服务器准备就绪+等待客户端连接");
            //  (2) 通过accept()方法监听客户端请求(产生阻塞)；
            socket=serverSocket.accept();
            //   (3) 连接建立后，通过输入流读取客户端发送的请求信息；
            bufferedReader =
                    new BufferedReader(new InputStreamReader(socket.getInputStream()));
            //(4) 通过输出流向客户端发送相应信息；

            printWriter=new PrintWriter(socket.getOutputStream());

            Scanner scanner=new Scanner(System.in);
            while (true){
                //读取客户端·
                String clientMsg = bufferedReader.readLine();

                System.out.println("客户端说"+clientMsg);
                //包含
                if (clientMsg.contains("借钱")){
                    printWriter.println("你被啦黑了");//写出
                    printWriter.flush();//刷新
                    break;
                    }
                //提示
                System.out.println("请输入：");
                //阻塞并等待控制台输入
                String serverinputMsg = scanner.next();
                //写入信息
                printWriter.println(serverinputMsg);
                //刷新
                printWriter.flush();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }finally {

            //        (5) 关闭相应资源。
            if(printWriter!=null){
                printWriter.close();
            }
            try {
                if(bufferedReader!=null){
                    bufferedReader.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                if(socket!=null){
                    socket.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                if(serverSocket!=null){
                    serverSocket.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

/**
 * @author zhangyifan
 * @version 8.0
 * @description:
 * @date 2021/12/7 14:19
 */
public class Client {
    public static void main(String[] args) {
        Socket sOcket=null;
        PrintWriter printWriter=null;
        BufferedReader bufferedReader=null;
//        （1）创建Socket对象，指明需要连接的服务器地址和端口；
        try {
            sOcket=new Socket("192.168.41.26",16666);
            //（2）连接建立后，通过输出流向服务器端发送请求信息；
            printWriter =new PrintWriter(sOcket.getOutputStream());
            //（3）通过输入流获取服务器端返回的响应信息；
            bufferedReader=
                    new BufferedReader(new InputStreamReader(sOcket.getInputStream()));
            Scanner scanner=new Scanner(System.in);
            while (true){
                System.out.println("请输入：");
                String clientInputMsg = scanner.next();
                printWriter.println(clientInputMsg);
                printWriter.flush();

                String ServerMSG=bufferedReader.readLine();

                System.out.println("服务器说"+ServerMSG);

                if (ServerMSG.contains("拉黑")){
                    printWriter.println("别慌，拉黑前借钱");
                    printWriter.flush();//刷新
                    break;//退出
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            //        (4) 关闭相应资源。
            try {
                if(bufferedReader!=null){
                    bufferedReader.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
            if(printWriter!=null){
                printWriter.close();
            }
            try {
                if(sOcket!=null){
                    sOcket.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

多线程持续通话 可创建多个Client并 但是信息发送必须有去有回否则Server不知道下一个发给谁

/**
 * @author zhangyifan
 * @version 8.0
 * @description:
 * @date 2021/12/7 15:11
 */
public class Server {
    public static void main(String[] args) {
        ServerSocket serverSocket=null;
        try {
            serverSocket=new ServerSocket(16666);
            while (true){
                System.out.println("服务端已经准备就绪，等待客户端连接。。。。");
                //等待客户端连接
                Socket accept = serverSocket.accept();
                new Thread(new MTServer(accept)).start();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

/**
 * @author zhangyifan
 * @version 8.0
 * @description:
 * @date 2021/12/7 15:11
 */
public class MTServer implements Runnable{
    private Socket socket;
    //赋值
    public MTServer(Socket socket) {
        this.socket = socket;
    }
    @Override
    public void run() {
        //提示
        System.out.println("客户端"+Thread.currentThread().getName()+"已经连接，可以对话");
        BufferedReader bufferedReader=null;
        PrintWriter printWriter=null;

        try {//转换
            bufferedReader=
                    new BufferedReader(new InputStreamReader(socket.getInputStream()));
            //发送
            printWriter=new PrintWriter(socket.getOutputStream());
            Scanner scanner=new Scanner(System.in);
            while (true){
                String clientMsg = bufferedReader.readLine();
                //打印
                System.out.println("客户端"+clientMsg);
                //阻塞并等待控制台输入
                System.out.println("请求输入");

                String serverInputMsg = scanner.next();
                //写入信息
                printWriter.println(serverInputMsg);
                //刷新管道
                printWriter.flush();
                if (clientMsg.contains("借钱")){
                    printWriter.println("你被拉黑了");
                    printWriter.flush();//刷新
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            //        (5) 关闭相应资源。
            if (printWriter != null) {
                printWriter.close();
            }
            try {
                if (bufferedReader != null) {
                    bufferedReader.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                if (socket != null) {
                    socket.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }

        }
    }
}
/**
 * @author zhangyifan
 * @version 8.0
 * @description:
 * @date 2021/12/7 15:11
 */
public class Client {
    public static void main(String[] args) {
        Socket socket=null;
        PrintWriter printWriter=null;
        BufferedReader bufferedReader=null;
        try {
            socket=new Socket("192.168.41.26",16666);
            printWriter =new PrintWriter(socket.getOutputStream());
            bufferedReader=new BufferedReader(new InputStreamReader(socket.getInputStream()));
            /*printWriter.println(bufferedReader.readLine());*/
            Scanner scanner=new Scanner(System.in);
            while(true){
                System.out.println("请输入");
                //获取
                String next = scanner.next();
                //发出
                printWriter.println(next);
                //刷新
                printWriter.flush();
                //行读取
                String s = bufferedReader.readLine();
                System.out.println("服务器说"+s);
                if (s.contains("拉黑")){
                    printWriter.println("别慌，拉黑前借钱");
                    printWriter.flush();
                    break;
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            //        (4) 关闭相应资源。
            try {
                if(bufferedReader!=null){
                    bufferedReader.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
            if(printWriter!=null){
                printWriter.close();
            }
            try {
                if(socket!=null){
                    socket.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }

        }

    }
}

5.UDP程序的原理

服务器端

1. 创建服务端DatagramSocket类
2. 准备数据 以字节数组的形式
3. 打包 DatagramPacket+客户端的地址和端口
4. 发送
5. 释放资源

客户端

1. 创建客户端 DatagramSocket 类 + 指定的接收端口
2. 准备接收数据的容器 以字节数组的形式封装为DatagramPacket
3. 包 接收数据
4. 分析 （组装字节数组）
5. 释放资源

6.主要类的方法

DatagramSocket类 要用于实现信息的发送和接收

DatagramPacket类用于包装需要发送或接收的信息

7、代码具体实现

/**
 * @author zhangyifan
 * @version 8.0
 * @description:
 * @date 2021/12/7 11:36
 */
public class Client {
    public static void main(String[] args) {
        DatagramSocket datagramSocket=null;
        try {
            //1创建连接
              datagramSocket=new DatagramSocket(18888);
//  2准备接受容器 设置大小
              byte[] tempBytes=new byte[1024];
              DatagramPacket datagramPacket=new DatagramPacket(tempBytes,1024);
              //3、包接受信息
              System.out.println("客户端准备就绪，等待服务器");
              datagramSocket.receive(datagramPacket);
            //4 分析 组装字节数组
            String s = new String(tempBytes, 0, datagramPacket.getLength());
            System.out.println("收到信息"+s);
        } catch ( Exception e) {
            e.printStackTrace();
        }finally {
            if (datagramSocket!=null){
                datagramSocket.close();
            }
        }
    }
}

/**
 * @author zhangyifan
 * @version 8.0
 * @description:
 * @date 2021/12/7 11:36
 */
public class Server {
    public static void main(String[] args) {
        DatagramSocket datagramSocket=null;
        try {
            //创建服务端 DatagramSocket类
            datagramSocket=new DatagramSocket();
            //准备数据 字节
            String str="hello client";
            byte[] sendMsgBytes=str.getBytes();//装字节
            //1、 发送消息的字节数组  2.发送消息字节数组的长度  3.ip 4 端口号
            DatagramPacket datagramPacket=
                    new DatagramPacket(sendMsgBytes
                            , sendMsgBytes.length
                            , InetAddress.getByName("localhost")
                            ,18888);
            //发送
            datagramSocket.send(datagramPacket);
            System.out.println("消息发送完毕");
        } catch ( Exception e) {
            e.printStackTrace();
        }finally {
            //释放资源
            if (datagramSocket!=null){
                datagramSocket.close();
            }
        }
    }
}

注意事项：先启动客户端，receive方法在接收到数据报前一直阻塞。再运行服务器端。

8、UDP对聊

总结

这篇关于Socket编程的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！