13. Java网络编程

最新推荐文章于 2023-01-12 11:37:12 发布
最新推荐文章于 2023-01-12 11:37:12 发布
阅读量1k 收藏 1
点赞数
分类专栏： # JavaSE 文章标签： java 网络 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Buluchacha/article/details/121971678
版权

Java网络编程

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

1. 网络通信三要素

1.1 概述

在这里插入图片描述
在这里插入图片描述

1.2 要素一：IP地址

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

1.3 IP地址操作类-InetAddress

在这里插入图片描述

public class Test {
    public static void main(String[] args) throws Exception {
        // 1.获取本机地址对象。
        InetAddress ip1 = InetAddress.getLocalHost();
        System.out.println(ip1.getHostName()); // LAPTOP-CBBQD180
        System.out.println(ip1.getHostAddress()); // 192.168.164.1

        // 2.获取域名ip对象
        InetAddress ip2 = InetAddress.getByName("www.baidu.com");
        System.out.println(ip2.getHostName()); // www.baidu.com
        System.out.println(ip2.getHostAddress()); // 45.113.192.101

        // 3.获取公网IP对象。
        InetAddress ip3 = InetAddress.getByName("112.80.248.76");
        System.out.println(ip3.getHostName()); // 112.80.248.76
        System.out.println(ip3.getHostAddress()); // 112.80.248.76

        // 4.判断是否能通： ping  5s之前测试是否可通
        System.out.println(ip3.isReachable(5000)); // true
    }
}

1.4 要素二：端口号

在这里插入图片描述

1.5 要素三：协议

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

2. UDP通信

2.1 快速入门

在这里插入图片描述
在这里插入图片描述

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

//先启动服务端，再启动客户端
/**
 发送端  一发 一收
 */
public class ClientDemo {
    public static void main(String[] args) throws Exception {
        System.out.println("=====客户端启动======");

        // 1、创建发送端对象：发送端自带默认的端口号（人）
        DatagramSocket socket = new DatagramSocket(6666);

        // 2、创建一个数据包对象封装数据（韭菜盘子）
        /**
         public DatagramPacket(byte buf[], int length,
         InetAddress address, int port)
         参数一：封装要发送的数据（韭菜）
         参数二：发送数据的大小
         参数三：服务端的主机IP地址
         参数四：服务端的端口
         */
        byte[] buffer = "我是一颗快乐的韭菜，你愿意吃吗？".getBytes();
        DatagramPacket packet = new DatagramPacket( buffer, buffer.length,
                InetAddress.getLocalHost() , 8888);

        // 3、发送数据出去
        socket.send(packet);

        socket.close();
    }
}

/**
 接收端
 */
public class ServerDemo {
    public static void main(String[] args) throws Exception {
        System.out.println("=====服务端启动======");
        // 1、创建接收端对象：注册端口（人）
        DatagramSocket socket = new DatagramSocket(8888);

        // 2、创建一个数据包对象接收数据（韭菜盘子）
        byte[] buffer = new byte[1024 * 64];
        DatagramPacket packet = new DatagramPacket(buffer, buffer.length);

        // 3、等待接收数据。
        socket.receive(packet);

        // 4、取出数据即可
        // 读取多少倒出多少
        int len = packet.getLength();
        String rs = new String(buffer,0, len);
        System.out.println("收到了：" + rs);

        // 获取发送端的ip和端口
        String ip = packet.getSocketAddress().toString();
        System.out.println("对方地址：" + ip);

        int port  = packet.getPort();
        System.out.println("对方端口：" + port);

        socket.close();
    }
}

/**
 =====服务端启动======
 =====客户端启动======
 收到了：我是一颗快乐的韭菜，你愿意吃吗？
 对方地址：/192.168.164.1:6666
 对方端口：6666
 */

2.2 多发多收

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

/**
 发送端  多发 多收
 */
public class ClientDemo {
    public static void main(String[] args) throws Exception {
        System.out.println("=====客户端启动======");

        // 1、创建发送端对象：发送端自带默认的端口号（人）
        DatagramSocket socket = new DatagramSocket(7777);

        Scanner sc = new Scanner(System.in);
        while (true) {
            System.out.println("请说：");
            String msg = sc.nextLine();

            if("exit".equals(msg)){
                System.out.println("离线成功！");
                socket.close();
                break;
            }

            // 2、创建一个数据包对象封装数据（韭菜盘子）
            byte[] buffer = msg.getBytes();
            DatagramPacket packet = new DatagramPacket( buffer, buffer.length,
                    InetAddress.getLocalHost() , 8888);

            // 3、发送数据出去
            socket.send(packet);
        }
    }
}

/**
 接收端
 */
public class ServerDemo {
    public static void main(String[] args) throws Exception {
        System.out.println("=====服务端启动======");
        // 1、创建接收端对象：注册端口（人）
        DatagramSocket socket = new DatagramSocket(8888);

        // 2、创建一个数据包对象接收数据（韭菜盘子）
        byte[] buffer = new byte[1024 * 64];
        DatagramPacket packet = new DatagramPacket(buffer, buffer.length);

        while (true) {
            // 3、等待接收数据。
            socket.receive(packet);
            // 4、取出数据即可
            // 读取多少倒出多少
            int len = packet.getLength();
            String rs = new String(buffer,0, len);
            System.out.println("收到了来自：" + packet.getAddress() +", 对方端口是" + packet.getPort() +"的消息：" + rs);
        }
    }
}

/**
 客户端控制台：
     =====客户端启动======
     请说：
     你好
     请说：
     再见
     请说：
     exit
     离线成功！
 服务端控制台：
     =====服务端启动======
     收到了来自：/192.168.164.1, 对方端口是7777的消息：你好
     收到了来自：/192.168.164.1, 对方端口是7777的消息：再见
 */

2.3 广播、组播

在这里插入图片描述
在这里插入图片描述

/**
 发送端  多发 多收
 */
public class ClientDemo {
    public static void main(String[] args) throws Exception {
        System.out.println("=====客户端启动======");

        // 1、创建发送端对象：发送端自带默认的端口号（人）
        DatagramSocket socket = new DatagramSocket();

        Scanner sc = new Scanner(System.in);
        while (true) {
            System.out.println("请说：");
            String msg = sc.nextLine();

            if("exit".equals(msg)){
                System.out.println("离线成功！");
                socket.close();
                break;
            }

            // 2、创建一个数据包对象封装数据（韭菜盘子）
            byte[] buffer = msg.getBytes();
            // 注意：只要目的地IP是 255.255.255.255 这个消息将以广播的形式对外发送
            DatagramPacket packet = new DatagramPacket( buffer, buffer.length,
                    InetAddress.getByName("255.255.255.255") , 8888);

            // 3、发送数据出去
            socket.send(packet);
        }
    }
}

/**
 接收端
 */
public class ServerDemo {
    public static void main(String[] args) throws Exception {
        System.out.println("=====服务端启动======");
        // 1、创建接收端对象：注册端口（人）
        DatagramSocket socket = new DatagramSocket(8888);

        // 2、创建一个数据包对象接收数据（韭菜盘子）
        byte[] buffer = new byte[1024 * 64];
        DatagramPacket packet = new DatagramPacket(buffer, buffer.length);

        while (true) {
            // 3、等待接收数据。
            socket.receive(packet);
            // 4、取出数据即可
            // 读取多少倒出多少
            int len = packet.getLength();
            String rs = new String(buffer,0, len);
            System.out.println("收到了来自：" + packet.getAddress() +", 对方端口是" + packet.getPort() +"的消息：" + rs);
        }
    }
}

/**
 客户端控制台：
     =====客户端启动======
     请说：
     你好 我是广播消息
     请说：
     exit
     离线成功！

 服务端控制台：
     =====服务端启动======
     收到了来自：/192.168.145.1, 对方端口是60445的消息：你好 我是广播消息
 */

在这里插入图片描述

/**
 发送端  多发 多收
 */
public class ClientDemo {
    public static void main(String[] args) throws Exception {
        System.out.println("=====客户端启动======");

        // 1、创建发送端对象：发送端自带默认的端口号（人）
        DatagramSocket socket = new DatagramSocket();

        Scanner sc = new Scanner(System.in);
        while (true) {
            System.out.println("请说：");
            String msg = sc.nextLine();

            if("exit".equals(msg)){
                System.out.println("离线成功！");
                socket.close();
                break;
            }

            // 2、创建一个数据包对象封装数据（韭菜盘子）
            byte[] buffer = msg.getBytes();
            // 这个消息将以组播的形式对外发送
            DatagramPacket packet = new DatagramPacket( buffer, buffer.length,
                    InetAddress.getByName("224.0.1.1") , 9898);

            // 3、发送数据出去
            socket.send(packet);
        }
    }
}

/**
 接收端
 */
public class ServerDemo {
    public static void main(String[] args) throws Exception {
        System.out.println("=====服务端启动======");
        // 1、创建接收端对象：注册端口（人）
        MulticastSocket socket = new MulticastSocket(9898);

        // 注意：绑定组播地址（加群）
        socket.joinGroup(new InetSocketAddress(InetAddress.getByName("224.0.1.1") , 9898),
                NetworkInterface.getByInetAddress(InetAddress.getLocalHost()));

        // 2、创建一个数据包对象接收数据（韭菜盘子）
        byte[] buffer = new byte[1024 * 64];
        DatagramPacket packet = new DatagramPacket(buffer, buffer.length);


        while (true) {
            // 3、等待接收数据。
            socket.receive(packet);
            // 4、取出数据即可
            // 读取多少倒出多少
            int len = packet.getLength();
            String rs = new String(buffer,0, len);
            System.out.println("收到了来自：" + packet.getAddress() +", 对方端口是" + packet.getPort() +"的消息：" + rs);
        }
    }
}

/**
 客户端控制台：
     =====客户端启动======
     请说：
     你好 我是组播消息
     请说：
     exit
     离线成功！

 服务端控制台：
     =====服务端启动======
    收到了来自：/192.168.164.1, 对方端口是50227的消息：你好 我是组播消息
 */

3. TCP通信

3.1 快速入门

3.1.1 编写客户端代码

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

在这里插入图片描述
在这里插入图片描述

/**
 目标：完成Socket网络编程入门案例的客户端开发，实现1发1收。
 */
public class ClientDemo {
    public static void main(String[] args) {
        try {
            System.out.println("====客户端启动===");
            // 1、创建Socket通信管道请求有服务端的连接
            // public Socket(String host, int port)
            // 参数一：服务端的IP地址
            // 参数二：服务端的端口
            Socket socket = new Socket("127.0.0.1", 7777);
            // 2、从socket通信管道中得到一个字节输出流 负责发送数据
            OutputStream os = socket.getOutputStream();
            // 3、把低级的字节流包装成打印流
            PrintStream ps = new PrintStream(os);
            // 4、发送消息
            ps.println("我是TCP的客户端，我已经与你对接，并发出邀请：约吗？");
            ps.flush();

            // 关闭资源。
            // socket.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

3.1.2 编写服务端代码、原理分析

在这里插入图片描述
在这里插入图片描述

/**
 目标：开发Socket网络编程入门代码的服务端，实现接收消息
 */
public class ServerDemo {
    public static void main(String[] args) {
        try {
            System.out.println("===服务端启动成功===");
            // 1、注册端口
            ServerSocket serverSocket = new ServerSocket(7777);
            // 2、必须调用accept方法：等待接收客户端的Socket连接请求，建立Socket通信管道
            Socket socket = serverSocket.accept();
            // 3、从socket通信管道中得到一个字节输入流
            InputStream is = socket.getInputStream();
            // 4、把字节输入流包装成缓冲字符输入流进行消息的接收
            BufferedReader br = new BufferedReader(new InputStreamReader(is));
            // 5、按照行读取消息
            String msg;
            if ((msg = br.readLine()) != null){
                System.out.println(socket.getRemoteSocketAddress() + "说了：: " + msg);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

/**
 客户端控制台：
     =====客户端启动======

 服务端控制台：
     =====服务端启动======
    /127.0.0.1:51934说了：: 我是TCP的客户端，我已经与你对接，并发出邀请：约吗？
 */

3.2 多发多收信息

在这里插入图片描述

/**
 目标：实现多发和多收
 */
public class ClientDemo {
    public static void main(String[] args) {
        try {
            System.out.println("====客户端启动===");
            // 1、创建Socket通信管道请求有服务端的连接
            // public Socket(String host, int port)
            // 参数一：服务端的IP地址
            // 参数二：服务端的端口
            Socket socket = new Socket("127.0.0.1", 7777);

            // 2、从socket通信管道中得到一个字节输出流 负责发送数据
            OutputStream os = socket.getOutputStream();

            // 3、把低级的字节流包装成打印流
            PrintStream ps = new PrintStream(os);

            Scanner sc =  new Scanner(System.in);
            while (true) {
                System.out.println("请说：");
                String msg = sc.nextLine();
                // 4、发送消息
                ps.println(msg);
                ps.flush();
            }

            // 关闭资源。
            // socket.close();

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

/**
 目标：开发Socket网络编程入门代码的服务端，实现接收消息
 */
public class ServerDemo {
    public static void main(String[] args) {
        try {
            System.out.println("===服务端启动成功===");
            // 1、注册端口
            ServerSocket serverSocket = new ServerSocket(7777);
            while (true) {
                // 2、必须调用accept方法：等待接收客户端的Socket连接请求，建立Socket通信管道
                Socket socket = serverSocket.accept();
                // 3、从socket通信管道中得到一个字节输入流
                InputStream is = socket.getInputStream();
                // 4、把字节输入流包装成缓冲字符输入流进行消息的接收
                BufferedReader br = new BufferedReader(new InputStreamReader(is));
                // 5、按照行读取消息
                String msg;
                while ((msg = br.readLine()) != null){
                    System.out.println(socket.getRemoteSocketAddress() + "说了：: " + msg);
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

在这里插入图片描述

3.3 同时接收多个客户端消息（重点）

在这里插入图片描述
在这里插入图片描述

/**
 目标：实现服务端可以同时处理多个客户端的消息。
 */
public class ClientDemo {
    public static void main(String[] args) {
        try {
            System.out.println("====客户端启动===");
            // 1、创建Socket通信管道请求有服务端的连接
            // public Socket(String host, int port)
            // 参数一：服务端的IP地址
            // 参数二：服务端的端口
            Socket socket = new Socket("127.0.0.1", 7777);

            // 2、从socket通信管道中得到一个字节输出流 负责发送数据
            OutputStream os = socket.getOutputStream();

            // 3、把低级的字节流包装成打印流
            PrintStream ps = new PrintStream(os);

            Scanner sc =  new Scanner(System.in);
            while (true) {
                System.out.println("请说：");
                String msg = sc.nextLine();
                // 4、发送消息
                ps.println(msg);
                ps.flush();
            }

            // 关闭资源。
            // socket.close();

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

/**
 目标：实现服务端可以同时处理多个客户端的消息。
 */
public class ServerDemo {
    public static void main(String[] args) {
        try {
            System.out.println("===服务端启动成功===");
            // 1、注册端口
            ServerSocket serverSocket = new ServerSocket(7777);
            // a.定义一个死循环由主线程负责不断的接收客户端的Socket管道连接。
            while (true) {
                // 2、每接收到一个客户端的Socket管道，交给一个独立的子线程负责读取消息
                Socket socket = serverSocket.accept();
                System.out.println(socket.getRemoteSocketAddress()+ "它来了，上线了！");
                // 3、开始创建独立线程处理socket
                new ServerReaderThread(socket).start();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

/**
 客户端控制台：
     =====客户端启动======
     请说：
     hi
 服务端控制台：
     ===服务端启动成功===(可以多个服务端)
     /127.0.0.1:52194它来了，上线了！
     /127.0.0.1:52194说了：: hi
     /127.0.0.1:52194下线了！！！
 */

public class ServerReaderThread extends Thread{
    private Socket socket;
    public ServerReaderThread(Socket socket){
        this.socket = socket;
    }
    @Override
    public void run() {
        try {
            // 3、从socket通信管道中得到一个字节输入流
            InputStream is = socket.getInputStream();
            // 4、把字节输入流包装成缓冲字符输入流进行消息的接收
            BufferedReader br = new BufferedReader(new InputStreamReader(is));
            // 5、按照行读取消息
            String msg;
            while ((msg = br.readLine()) != null){
                System.out.println(socket.getRemoteSocketAddress() + "说了：: " + msg);
            }
        } catch (Exception e) {
            System.out.println(socket.getRemoteSocketAddress() + "下线了！！！");
        }
    }
}

3.4 使用线程池优化

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

/**
 拓展：使用线程池优化：实现通信。
 */
public class ClientDemo {
    public static void main(String[] args) {
        try {
            System.out.println("====客户端启动===");
            // 1、创建Socket通信管道请求有服务端的连接
            // public Socket(String host, int port)
            // 参数一：服务端的IP地址
            // 参数二：服务端的端口
            Socket socket = new Socket("127.0.0.1", 6666);

            // 2、从socket通信管道中得到一个字节输出流 负责发送数据
            OutputStream os = socket.getOutputStream();

            // 3、把低级的字节流包装成打印流
            PrintStream ps = new PrintStream(os);

            Scanner sc =  new Scanner(System.in);
            while (true) {
                System.out.println("请说：");
                String msg = sc.nextLine();
                // 4、发送消息
                ps.println(msg);
                ps.flush();
            }
            // 关闭资源。
            // socket.close();

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

/**
 目标：实现服务端可以同时处理多个客户端的消息。
 */
public class ServerDemo {
    // 使用静态变量记住一个线程池对象
    private static ExecutorService pool = new ThreadPoolExecutor(300,
            1500, 6, TimeUnit.SECONDS,
            new ArrayBlockingQueue<>(2)
            , Executors.defaultThreadFactory(), new ThreadPoolExecutor.AbortPolicy());

    public static void main(String[] args) {
        try {
            System.out.println("===服务端启动成功===");
            // 1、注册端口
            ServerSocket serverSocket = new ServerSocket(6666);
            // a.定义一个死循环由主线程负责不断的接收客户端的Socket管道连接。
            while (true) {
                // 2、每接收到一个客户端的Socket管道，
                Socket socket = serverSocket.accept();
                System.out.println(socket.getRemoteSocketAddress()+ "它来了，上线了！");

                // 任务对象负责读取消息。
                Runnable target = new ServerReaderRunnable(socket);
                pool.execute(target);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

public class ServerReaderRunnable implements Runnable{
    private Socket socket;
    public ServerReaderRunnable(Socket socket){
        this.socket = socket;
    }
    @Override
    public void run() {
        try {
            // 3、从socket通信管道中得到一个字节输入流
            InputStream is = socket.getInputStream();
            // 4、把字节输入流包装成缓冲字符输入流进行消息的接收
            BufferedReader br = new BufferedReader(new InputStreamReader(is));
            // 5、按照行读取消息
            String msg;
            while ((msg = br.readLine()) != null){
                System.out.println(socket.getRemoteSocketAddress() + "说了：: " + msg);
            }
        } catch (Exception e) {
            System.out.println(socket.getRemoteSocketAddress() + "下线了！！！");
        }
    }
}

3.5 实战案例 - 即时通信

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

/**
    拓展：即时通信

    客户端：发消息的同时，随时有人发消息过来。
    服务端：接收消息后，推送给其他所有的在线socket
 */
public class ClientDemo1 {
    public static void main(String[] args) {
        try {
            System.out.println("====客户端启动===");
            // 1、创建Socket通信管道请求有服务端的连接
            // public Socket(String host, int port)
            // 参数一：服务端的IP地址
            // 参数二：服务端的端口
            Socket socket = new Socket("127.0.0.1", 6868);

            // 马上为客户端分配一个独立的线程负责读取它收到的消息
            new ClientReaderThread(socket).start();

            // 2、从socket通信管道中得到一个字节输出流 负责发送数据
            OutputStream os = socket.getOutputStream();

            // 3、把低级的字节流包装成打印流
            PrintStream ps = new PrintStream(os);

            Scanner sc =  new Scanner(System.in);
            while (true) {
                System.out.println("请说：");
                String msg = sc.nextLine();
                // 4、发送消息
                ps.println(msg);
                ps.flush();
            }
            // 关闭资源。
            // socket.close();

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

public class ClientReaderThread extends Thread{
    private Socket socket;
    public ClientReaderThread(Socket socket){
        this.socket = socket;
    }
    @Override
    public void run() {
        try {
            // 3、从socket通信管道中得到一个字节输入流
            InputStream is = socket.getInputStream();
            // 4、把字节输入流包装成缓冲字符输入流进行消息的接收
            BufferedReader br = new BufferedReader(new InputStreamReader(is));
            // 5、按照行读取消息
            String msg;
            while ((msg = br.readLine()) != null){
                System.out.println(socket.getRemoteSocketAddress() + "收到了: " + msg);
            }
        } catch (Exception e) {
            System.out.println("服务端把你踢出去了~~");
        }
    }
}

/**
   目标: 即时通信
 */
public class ServerDemo2 {

    public static List<Socket> onLineSockets = new ArrayList<>();

    public static void main(String[] args) {
        try {
            System.out.println("===服务端启动成功===");
            // 1、注册端口
            ServerSocket serverSocket = new ServerSocket(6868);
            // a.定义一个死循环由主线程负责不断的接收客户端的Socket管道连接。
            while (true) {
                // 2、每接收到一个客户端的Socket管道，交给一个独立的子线程负责读取消息
                Socket socket = serverSocket.accept();
                System.out.println(socket.getRemoteSocketAddress()+ "它来了，上线了！");
                // 把当前客户端管道Socket加入到在线集合中去
                onLineSockets.add(socket);

                // 3、开始创建独立线程处理socket
                new ServerReaderThread(socket).start();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

public class ServerReaderThread extends Thread{
    private Socket socket;
    public ServerReaderThread(Socket socket){
        this.socket = socket;
    }
    @Override
    public void run() {
        try {
            // 3、从socket通信管道中得到一个字节输入流
            InputStream is = socket.getInputStream();
            // 4、把字节输入流包装成缓冲字符输入流进行消息的接收
            BufferedReader br = new BufferedReader(new InputStreamReader(is));
            // 5、按照行读取消息
            String msg;
            while ((msg = br.readLine()) != null){
                System.out.println(socket.getRemoteSocketAddress() + "说了：: " + msg);
                // 把这个消息发给当前所有在线socket
                sendMsgToAll(msg);
            }
        } catch (Exception e) {
            System.out.println(socket.getRemoteSocketAddress() + "下线了！！！");
            // 从在线集合中抹掉本客户端socket
            ServerDemo2.onLineSockets.remove(socket);
        }
    }

    private void sendMsgToAll(String msg) {
        try {
            // 遍历全部的在线 socket给他们发消息
            for (Socket onLineSocket : ServerDemo2.onLineSockets) {
                // 除了自己的socket，其他socket我都发！！
                if(onLineSocket != socket){
                    PrintStream ps = new PrintStream(socket.getOutputStream());
                    ps.println(msg);
                    ps.flush();
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

3.6 实战案例 - 模拟BS系统

在这里插入图片描述
在这里插入图片描述

在这里插入图片描述

/**
 了解：BS-浏览器-服务器基本了解。

 引入：
 之前客户端和服务端都需要自己开发。也就是CS架构。
 接下来模拟一下BS架构。

 客户端：浏览器。（无需开发）
 服务端：自己开发。
 需求：在浏览器中请求本程序，响应一个网页文字给浏览器显示
 */
public class ServerDemo {
    // 使用静态变量记住一个线程池对象
    private static ExecutorService pool = new ThreadPoolExecutor(3,
            5, 6, TimeUnit.SECONDS,
            new ArrayBlockingQueue<>(2)
            , Executors.defaultThreadFactory(), new ThreadPoolExecutor.AbortPolicy());

    public static void main(String[] args) {
        try {
            // 1.注册端口
            ServerSocket ss = new ServerSocket(8080);
            // 2.创建一个循环接收多个客户端的请求。
            while(true){
                Socket socket = ss.accept();
                // 3.交给一个独立的线程来处理！
                pool.execute(new ServerReaderRunnable(socket));
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

public class ServerReaderRunnable implements Runnable{
    private Socket socket;
    public ServerReaderRunnable(Socket socket){
        this.socket = socket;
    }
    @Override
    public void run() {
        try {
            // 浏览器 已经与本线程建立了Socket管道
            // 响应消息给浏览器显示
            PrintStream ps = new PrintStream(socket.getOutputStream());
            // 必须响应HTTP协议格式数据，否则浏览器不认识消息
            ps.println("HTTP/1.1 200 OK"); // 协议类型和版本 响应成功的消息！
            ps.println("Content-Type:text/html;charset=UTF-8"); // 响应的数据类型：文本/网页

            ps.println(); // 必须发送一个空行

            // 才可以响应数据回去给浏览器
            ps.println("<span style='color:red;font-size:90px'>《最牛的Java》 </span>");
            ps.close();
        } catch (Exception e) {
            System.out.println(socket.getRemoteSocketAddress() + "下线了！！！");
        }
    }
}
孤岛使者
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java中的网络编程
m0_70990872的博客
07-13 455
Java中的网络编程
Java网络编程
明天请叫我早点起床的博客
09-01 256
1. 网络通信协议 2. 网络编程中两个主要的问题 如何准确地定位网络上一台或多台主机；定位主机上特定的应用：IP地址（InetAddress）和端口号 找到主机后如何可靠高效的进行数据传播：网络通信协议 3. TCP UDP 协议 细节 TCP 使用TCP协议前，须先建立TCP连接，形成传输数据通道 传输器，采用三次握手方式，点对点通信，是可靠的TCP协议进行通信的两个应用...
jdk6的配置方法(用于网络开发)
11-10
jdk6的配置方法 希望可以帮助不会配置jdk的人
JAVA16版本.JDK16关于TCP和UDP的优化
张晨光老师的播客
02-13 546
性能加倍：虚拟线程（光纤）和JDK15/16！ 如果您使用UDP作为传输，并希望将性能提高一倍：请继续阅读！ 如果使用TCP，性能不会有太大变化。您可能仍然对最近的jdk和虚拟线程（以前称为“fibers”）将带来什么感兴趣。 虚拟线程 虚拟线程是轻量级线程，在概念上类似于旧的绿色线程，由JVM而不是内核来管理。许多虚拟线程可以映射到同一个操作系统本机（运营商）线程（当然，一次只能映射一个），因此我们可以拥有数百万个虚拟线程。 虚拟线程是用continuations实现的，但这只是一个细节。重要的是JDK中
Java网络编程二（Java原生网络编程）
l18320786461的博客
04-20 914
一些常见术语： 说到Java原生网络编程，肯定离不开Socket。Socket是应用层与TCP/IP协议族通信的中间软件抽象层，它是一组接口，Socket其实就是一个门面模式，它把复杂的TCP/IP协议族隐藏在Socket接口后面，对用户来说，一组简单的接口就是全部，让Socket去组织数据，以符合指定的协议。 短连接： 连接->数据传输->关闭连接 传统http是无状态的，浏览器和服务器每次进行一次http请求，就奖励一次连接，但是任务结束后就中断。...
基于BIO模式下即时通信（三）
名字好难想
02-01 163
基于BIO模式下的即时通信，我们需要解决客户端到客户端的通信，也就是需要实现客户端与客户端的端口消息转发逻辑。 项目功能演示 #### 功能清单简单说明： 1.客户端登陆功能 可以启动客户端进行登录，客户端登陆只需要输入用户名和服务端ip地址即可。 2.在线人数实时更新。 客户端用户户登陆以后，需要同步更新所有客户端的联系人信息栏。 3.离线人数更新 检测到有客户端下线后，需要同步更新所有客户端的联系人信息栏。 4.群聊 任意一个客户端的消息，可以推送给当前所有客户端接收。 5.私聊
java进阶开发-----socket编程或TCP通信模型
weixin_65489884的博客
01-12 229
socket编程的进阶
Java：网络编程
qq_52749760的博客
05-16 619
网络编程 什么是网络编程？ 网络编程可以让程序与网络上的其他设备中的程序进行数据交互。 网络通信基本模式 常见的通信模式有如下2种形式：Client-Server(CS) 、 Browser/Server(BS) 网络通信三要素 三要素概述、要素一：IP地址 ####实现网络编程关键的三要素 IP地址：设备在网络中的地址，是唯一的标识。 端口：应用程序在设备中唯一的标识。 协议: 数据在网络中传输的规则，常见的协议有UDP协议和TCP协议。 IP地址 IP（Internet Protoco
Netty框架-java基础网络-2 -原生jdk之AIO,BIO,NIO,Buffer
qq_36949403的博客
01-08 148
服务端提供IP和监听端口，客户端通过连接操作想服务端监听的地址发起连接请求，通过三次握手连接，如果连接成功建立，双方就可以通过套接字进行通信。 传统的同步阻塞模型开发中，ServerSocket负责绑定IP地址，启动监听端口；Socket负责发起连接操作。连接成功后，双方通过输入和输出流进行同步阻塞式通信。
JDK发送接收TCP/UDP数据
iteye_878的博客
04-12 236
本文的理论和代码摘录于《疯狂Java讲义》[url]http://book.51cto.com/art/201203/322540.htm[/url]，测试部分的截图是本人增加的。 1.UDP协议和TCP协议简单对比如下。 TCP协议：可靠，传输大小无限制，但是需要连接建立时间，差错控制开销大。 UDP协议：不可靠，差错控制开销较小，传输大小限制在64KB以下，不需要建立连接。 2...
原生JDK网络编程之NIO篇
wangguodong1993的博客
05-09 520
原生JDK网络编程之NIO篇 一、NIO是什么     NIO库是在JDK1.4中引入的。NIO弥补了原来的I/O的不足，它在标准Java代码中提供了高速的、面向块的I/O。     NIO可以称为 no-blocking io 或者 new io都可以。 二、NIO和BIO的主要区别 1、面向流和面向缓冲     BIO是面向流的，NIO是面向缓冲区的。   &nbs
Java期末考试试题及参考答案(13)
谷哥的小弟
12-19 2932
在TCP连接中必须要明确客户端与服务器端，由客户端向服务器端发出连接请求，每次连接的创建都需要经过“三次握手”。第一次握手，客户端向服务器端发出连接请求，等待服务器确认；第二次握手，服务器端向客户端回送一个响应，通知客户端收到了连接请求；第三次握手，客户端再次向服务器端发送确认信息，确认连接。
Java网络编程.pdf
最新发布
05-21
java
Java网络编程.ppt
06-02
网络上计算机通过TCP/IP协议进行通信，而套接字（socket）则将这些通信协议进行了封装，如数据服务器，需要数据的客户端机器向数据服务器提出请求，而服务器则处理客户端的请求并向其发送所需的数据；
java网络编程
03-11
java网络编程包括socket tcp/udp io/nio讲解 http协议 jdbc rmi java的安全框架等知识
java网络编程.pdf
09-30
java网络编程.pdf
JDK7 AIO (非阻塞IO)实现大并发TCPServer和TCPClient
热门推荐
分布式应用与服务器架构专栏
10-18 2万+
JDK7 虽然已经发布了一段时间了，但是无奈，AIO相关介绍，尤其是靠谱儿的介绍实在是太少了。兄弟花了些时间，整理成册，希望对learner有些帮助。   epoll成为Linux下开发大并发web 服务器的首选已经好多年了，java世界里，直到JDK 7的AIO出现才用上了这个feature。哎！不过亡羊补牢，为时未晚，下面就看下用AIO开发一个简单的TCP Server和TCP C
警惕 JDK8 UDP 和 Thread.interrupt 的 Bug
m0_46163918的博客
12-24 270
在DatagramChannelImpl.send 方法中会拿到两把锁，注意其中一把为 stateLock，即线程中的 - locked (a java.lang.Object)。1. 在 Thread.interrupt 方法中会调用 b.interrupt，注意这里会拿到 blokcerLock，即线程栈中的 - locked (a java.lang.Object)。所以，要么升级 JDK 到 13，要么死！
从前慢-BIO、NIO、AIO
unique_perfect的博客
03-23 1万+
1 BIO、NIO、AIO课程介绍 在Java的软件设计开发中，通信架构是不可避免的，我们在进行不同系统或者不同进程之间的数据交互，或者在高并发下的通信场景下都需要用到网络通信相关的技术，对于一些经验丰富的程序员来说，Java早期的网络通信架构存在一些缺陷，**其中最令人恼火的是基于性能低下的同步阻塞式的I/O通信（BIO）**，随着互联网开发下通信性能的高要求，Java在2002年开始支持了非阻塞式的I/O通信技术(NIO)。大多数读者在学习网络通信相关技术的时候，都只是接触到零碎的通信技术点，没有完整的
java 网络编程技术
10-13
Java 网络编程技术是指使用 Java 语言进行网络编程的技术。Java 提供了丰富的网络编程 API，包括 Socket、ServerSocket、DatagramSocket、InetAddress 等类，可以方便地实现网络通信功能。Java 网络编程技术可以用于...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值