java socket 长期通信 java socket closed

转载

编程小匠人之魂 2024-07-05 09:56:32

文章标签 java socket 长期通信 java socket 网络客户端 文章分类 Java 后端开发

网络基础介绍

java socket 长期通信 java socket closed_客户端

TCP/IP协议

TCP/IP是目前世界上应用最为广泛的协议

也是TCP和IP为基础的不同层次上多个人协议的集合
也称：TCP/IP协议族或TCP/IP协议栈

TCP：Transmission Control Protocol 传输控制协议
IP：Internet Protocol 互联网协议

java socket 长期通信 java socket closed_客户端_02

IP地址

为实现网路不同计算机之间的通信，每台机器都必须有一个唯一的标识----IP地址

java socket 长期通信 java socket closed_java socket 长期通信_03

IP地址格式：数字型，如：192.168.0.1 （常见IPv4）

端口

用于区分不同应用程序
端口号范围为0_{65535，其中0}1023为系统所保留
IP地址和端口号组成了所谓的Socket，Socket是网络上运行的程序之间双向通信链路的终结点，是TCP和UDP的基础
HTTP : 80 FTP : 21 telnet : 23

java socket 长期通信 java socket closed_java socket 长期通信_04

java中的网络支持

针对网络通信的不同层次，java提供的网络功能有四大类：

InetAddress：用于表示网络上的硬件资源。
URL：同一资源定位符，通过URL可以直接读取或写入网络上的数据。
Sockets：使用TCP协议实现网络通信的Socket相关的类。
Datagram：使用UPD协议，将数据保存在数据报中，通过网络进行通信

Java中网络相关API的应用

InetAddress 的应用

InetAddress类用于标识网络上的硬件资源，表示互联网协议（IP）地址。

实例：

public class InetAddressTest {
    public static void main(String[] args) throws UnknownHostException {
        InetAddress address = InetAddress.getLocalHost();
        System.out.println("计算名"+address.getHostName());
        System.out.println("IP地址"+address.getHostAddress());
        byte[] bytes = address.getAddress(); //获取字节数组形式的IP地址
        System.out.println("字节数组形式的IP"+ Arrays.toString(bytes));

        //直接输出InetAddress对象
        System.out.println(address);

        //根据机器名获取InetAddress实例
        InetAddress address2 = InetAddress.getByName("DESKTOP-0BBS5QP");
        System.out.println("IP地址"+address2.getHostAddress());

        //根据ip获取InetAddress实例
        InetAddress address3 = InetAddress.getByName("192.168.111.1");
        System.out.println("计算机名"+address3.getHostName());
    }
}

输出结果：

java socket 长期通信 java socket closed_网络_05

URL的应用

1、统一资源定位符URL（Uniform Resource Locator）是对可以从互联网上得到的资源的位置和访问方法的一种简洁的表示，是互联网上标准资源的地址。

2、URL由两部分组成：协议名称和资源名称，中间用冒号隔开。

java socket 长期通信 java socket closed_java socket 长期通信_06

3、在java.net包中，提供了URL类来表示

常用方法

public class URLTest {
    public static void main(String[] args) {
        try {
            //创建一个URL实例
            URL imooc=new URL("http://www.imooc.com");
            //?后面为参数，#后面表示锚点
            URL url = new URL(imooc, "/index.html?username=tom#test");
            System.out.println("协议"+url.getProtocol());
            System.out.println("主机"+url.getHost());
            //如果未指定端口号，则使用默认的端口号，此时getPort()方法返回值为-1
            System.out.println("端口"+url.getPort());
            System.out.println("文件路径"+url.getPath());
            System.out.println("文件名"+url.getFile());
            System.out.println("相对路径"+url.getRef());
            System.out.println("查询字符串"+url.getQuery());
        } catch (MalformedURLException e) {
            e.printStackTrace();
        }
    }
}

java socket 长期通信 java socket closed_网络_07

使用URL读取网页内容

通过URL对象的openStream()方法可以得到质的资源的输入流。
通过输入流可以读取、访问网络上的数据。

public class URLOpenText {
    public static void main(String[] args) {
        try {
            URL url= new URL("http://www.baidu.com");
            //通过URL的openStream方法获取URL对象表示的资源的字节输入流
            InputStream is = url.openStream();
            //将字节输入流转化为字符输入流
            InputStreamReader isr = new InputStreamReader(is);
            //为字符输入流添加缓冲
            BufferedReader br = new BufferedReader(isr);
            String data = br.readLine();    // 读取数据
            while (data!=null){
                System.out.println(data);
                data=br.readLine();
            }
            br.close();
            isr.close();
            is.close();
        }  catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Sccket实现TCP编程

Socket通信

TCP协议是面向连接、可靠的、有序的，以字节流的方式发送数据基于TCP协议实现网络通信的类

客户端的Socket类
服务器端的ServerSocket类

Sokoet通信模型

java socket 长期通信 java socket closed_java_08

Socket通信实现步骤

1、创建ServerSocket和Soket

2、打开连接到Socket的输入/输出流

3、按照协议对Socket进行读/写操作

4、关闭输入输出流、关闭Socket

案例：用户登录

服务器端：

创建ServerSocket对象，绑定监听端口
通过accept()方法监听客户端请求
连接请求后，通过输入流读取客户端发送的请求信息
通过输出流向客户端发送响应信息
关闭相关资源

public class Server {
    public static void main(String[] args) {
        try {
            //1、创建一个服务器端Socket，指定绑定的端口，并监听
            ServerSocket serverSocket = new ServerSocket(8888);
            //2、调用accept（）方法开始监听，等待的连接
            System.out.println("***服务器即将启动，等待客户端的连接***");
            Socket socket = serverSocket.accept();
            //3、获取输入流，并读取客户端信息
            InputStream is = socket.getInputStream();  //字节输入流
            InputStreamReader isr = new InputStreamReader(is);  //将字节流转化为字符流
            BufferedReader br = new BufferedReader(isr);
            String info =null;
            //循环读取客户端的信息
            while ((info=br.readLine())!=null){
                System.out.println("我是服务器，客户端说："+info);
            }
            socket.shutdownInput();//关闭输入流
            //4、获取输出流，响应客户端的请求
            OutputStream os = socket.getOutputStream();
            PrintWriter pw = new PrintWriter(os);
            pw.write("欢迎您！詹大帅哥");
            pw.flush();//调用flush()方法将缓冲输出
            //5、关闭资源
            pw.close();
            os.close();
            br.close();
            isr.close();
            is.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

客户端：

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

public class Client {
    public static void main(String[] args) {
        //1、创建客户端Socket，指定服务器地址和端口
        try {
            Socket socket = new Socket("localhost", 8888);
            //2、获取输出流，向服务器端发送信息
            OutputStream os = socket.getOutputStream();//字节输出流
            PrintWriter pw = new PrintWriter(os);//将输出流包装为打印流
            pw.write("用户名：admit；密码:123");
            pw.flush();
            socket.shutdownOutput();//关闭输出流
            //3、获取输入流
            InputStream is = socket.getInputStream();
            BufferedReader br = new BufferedReader(new InputStreamReader(is));
            String info=null;
            //循环读取服务端的信息
            while ((info=br.readLine())!=null){
                System.out.println("我是客户端，服务器说："+info);
            }
            is.close();
            br.close();
            pw.close();
            os.close();
            socket.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

多线程实现多客户的通信

多线程服务器

服务器端创建ServerSocket，循环调用accept()等待客户端连接
客户端创建一个Socket并请求和服务器连接
服务器端接受客户端请求，创建Socket与该客户建立专线连接
建立连接的两个Socket在一个单独的线程上对话
服务器端继续等待新的连接

public class SerberThread extends Thread {
    // 和本线程相关的Socket
    Socket socket=null;

    public SerberThread(Socket socket){
        this.socket=socket;
    }
    //线程执行的操作，响应客户端的请求

    public void run(){
        InputStream is = null;
        InputStreamReader isr = null;
        BufferedReader br=null;
        OutputStream os=null;
        PrintWriter pw=null;
        try {
            //字节输入流
            is = socket.getInputStream();
              //将字节流转化为字符流
            isr = new InputStreamReader(is);
            br = new BufferedReader(isr);
            String info =null;
            //循环读取客户端的信息
            while ((info=br.readLine())!=null){
                System.out.println("我是服务器，客户端说："+info);
            }
            socket.shutdownInput();//关闭输入流
            //4、获取输出流，响应客户端的请求
            os = socket.getOutputStream();
            pw = new PrintWriter(os);
            pw.write("欢迎您！詹大帅哥");
            pw.flush();//调用flush()方法将缓冲输出
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            //5、关闭资源
            try {
                if (pw !=null)
                pw.close();
                if (os !=null) {
                    os.close();
                if (br !=null)
                    br.close();
                if (isr !=null)
                    isr.close();
                if (is !=null)
                    is.close();
            }
        } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

修改Server类

public class Server {
    public static void main(String[] args) {
        try {
            int count=0; //记录客户端数量
            //1、创建一个服务器端Socket，指定绑定的端口，并监听
            ServerSocket serverSocket = new ServerSocket(8888);
            //2、调用accept（）方法开始监听，等待的连接
            System.out.println("***服务器即将启动，等待客户端的连接***");
            Socket socket =null;
            while (true){
                //调用accept（）方法开始监听，等待客户端的连接
                socket = serverSocket.accept();
                //创建一个新的线程
                SerberThread serberThread = new SerberThread(socket);
                //启动线程
                serberThread.start();
                count++;
                System.out.println("客户端的数量："+count);
                InetAddress address = socket.getInetAddress();
                System.out.println("IP地址："+address);
            }

        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

运行结果：

java socket 长期通信 java socket closed_java socket 长期通信_09

Sccket实现UDP编程

UDP协议（用户数据报协议）是无连接、不可靠的、无序的
UDP协议以数据报作为数据传输的载体
进行数据传输是，首先需要将传输的数据定义成数据报（Datagram），在数据报中指明数据所要达到的Socket（主机地址和端口号），然后再讲数据报发送出去

服务器端实现步骤

1、创建DategramSocket，指定端口号

2、创建DatagramPacket

3、接受客户端发送的数据信息

4、读取数据

public class UDPServer {
    public static void main(String[] args) {

        try {
            //1、创建服务器端DategramSocket，指定端口号
            DatagramSocket socket = new DatagramSocket(8800);
            //2、创建DatagramPacket数据报，接收数据
            byte[] data = new byte[1024];
            DatagramPacket packet = new DatagramPacket(data, data.length);
            //3、接受客户端发送的数据信息
            System.out.println("***服务器端已经启动，等待客户端发送数据***");
            socket.receive(packet);
            //4\读取数据
            String info = new String(data,0,packet.getLength());
            System.out.println("我是服务器，客户端所："+info);

            /*
            * 向客户端响应数据
            * */
            //1、定义客户端的地址、端口号、数据
            InetAddress address = packet.getAddress();
            int port=packet.getPort();
            byte[] data2="欢迎您！".getBytes();
            //2、创建数据报，包含响应的信息
            DatagramPacket packet2 = new DatagramPacket(data2, data2.length, address, port);
            //3、响应客户端
            socket.send(packet2);
            //4、关闭资源
            socket.close();
        } catch (SocketException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

客户端实现步骤

1、定义发送信息

2、创建DatagramPacket，包含将要发送的信息

3、创建DategramSocket

4、发送数据

public class UDPClient {
    public static void main(String[] args) throws IOException {
       // 1、定义发送信息
        InetAddress address = InetAddress.getByName("localhost");
        int prot=8800;
        byte[] data="用户名：shui；密码：123".getBytes();
        // 2、创建DatagramPacket，包含将要发送的信息
        DatagramPacket packet = new DatagramPacket(data, data.length, address, prot);
        // 3、创建DategramSocket
        DatagramSocket socket = new DatagramSocket();
        // 4、发送数据
        socket.send(packet);

        /*
        * 接收服务器响应的数据
        * */
        byte[] data2 = new byte[1024];
        DatagramPacket packet2 = new DatagramPacket(data2, data2.length);
        //2、接收服务器响应的数据
        socket.receive(packet2);
        //3、读取数据
        String reply = new String(data2, 0, packet2.getLength());
        System.out.println("我是客户端，服务器说："+reply);
        //4、关闭资源
        socket.close();

    }
}

本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。

上一篇：centos密码重试限制 centos 密码长度

下一篇：spring的分割字符 spring字符串

提问和评论都可以，用心的回复会被更多人看到评论

发布评论

相关文章

官方博客	全部文章	热门标签	班级博客
了解我们	网站地图	意见反馈

鸿蒙开发者社区	51CTO学堂
51CTO	软考资讯