网络编程——JavaEE

于 2022-07-06 15:39:35 发布
阅读量457 收藏 3
点赞数 7
分类专栏： JavaEE 文章标签： 网络 java-ee udp socket websocket
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sjp151/article/details/125628329
版权

网络编程

网络编程套接字

网络编程套接字：是操作系统给应用程序提供的一组 API （socket API）。socket API 可以视为是 应用层 和 传输层 之间的通信桥梁。传输层的核心协议有两种，TCP UDP，socket API 也有对应的两组。由于 TCP 和 UDP 协议，差别很大，所以这两组 API 差别也挺大

  1. TCP：有连接，可靠传输，面向字节流，全双工。
  2. UDP：无连接，不可靠传输，面向数据报，全双工。
  3. 有链接：相当于打电话，得先接通，才能交互数据。
  4. 无连接：像发微信，不需要接通，直接就能发数据。
  5. 可靠传输：传输过程中，发送方知道接收方有没有收到数据。打电话就是可靠传输。已读也是可靠传输。
  6. 不可靠传输：传输过程中，发送方不知道接收方有没有收到数据。发微信就是不可靠传输。
  7. 面向字节流：以字节为单位进行传输（非常类似于 文件操作 中的字节流）。
  8. 面向数据报：以数据报为单位进行传输（一个数据报都会明确大小）。一次发生/接收必须是一个完整的数据报，不能是半个，也不能是一个半。
  9. 全双工：一条链路双向通信。
  10. 半双工：一条链路单向通信。

UDP

UDP socket 比 TCP 更简单，主要涉及到两个类：

  1. DatagramSocket，这个 DatagramSocket 对象对应到操作系统当中的一个 socket 文件。平时说的文件，只是指普通文件（硬盘上的数据）。实际上，操作系统中的文件还可能表示了一些硬件设备/软件资源。socket 文件，就对应着 ”网卡“ 这种硬件设备，从 socket 文件读数据，本质上就是读网卡。往 socket 文件写数据，本质上就是写网卡。可以认为 socket 文件就是一个遥控器，通过遥控器来操作网卡。核心方法：receive 接收数据 send 发送数据 close 释放资源。
  2. DatagramPacket，代表了一个 UDP 数据报，使用 UDP 传输数据的基本单位。每次发送/接收数据，都是在传输一个 DatagramPacket 对象。

回显服务

回想服务就是请求内容是啥，响应就是啥。我们把整个回显服务分为两部分：

  1. UdpEchoServer 服务器部分。
  2. UdpEchoClient 客户端部分。

服务器部分

  1. 网络编程的时候，先准备好 socket 实例。socket 实例是进行网络编程的大前提。构造 socket 对象失败的原因：
    a、端口号已经被占用。
    b、每个进程能够打开的文件数是有上限的，如果进程之前就已经打开了很多很多的文件，就可能导致此处的 socket 文件就不能顺利打开了。
private DatagramSocket socket = null;
  1. 绑定端口号，可以在运行程序的时候来指定。
public UdpEchoServer(int port) throws SocketException {
    socket = new DatagramSocket(port);
}
  1. 多个进程不能绑定同一个端口。一个进程可以绑定多个端口，就是创建多个 socket 对象，然后绑定多个端口。

启动服务器：

  1. 因为 UDP 不需要建立连接，所以直接接收从客户端发来的数据即可。通过 DatagramPacket 来构造一个对象，然后通过 socket.receive() 来填充数据就好。receive 可能会引起阻塞。
  2. 根据请求计算相应。因为这里是回显服务，所以直接返回数据就可以了。
  3. 把响应写回到客户端。通过 sent 方法就可以写回。返回的时候再构造一个 DatagramPacket 对象返回就好。
  4. 在发送数据的时候，必须指定这个数据要发给谁，就是指定 IP 和 端口。
  5. 一个服务器 可以有很多个客户端。产生多少客户端，要通过性能测试来看。

服务器代码如下：

public class UdpEchoServer {

    //准备好 socket 实例。
    private DatagramSocket socket = null;
    //绑定端口号。
    public UdpEchoServer(int port) throws SocketException {
        socket = new DatagramSocket(port);
    }
    //启动服务器
    public void start() throws IOException {
        System.out.println("启动服务器");
        while (true) {
            //1、读取客户发来的请求
            //为了接收数据，需要准备好一个空的 DatagramPacket 对象。
            DatagramPacket requestPacket = new DatagramPacket(new byte[1024],1024);
            socket.receive(requestPacket);
            String request = new String(requestPacket.getData(),0,requestPacket.getLength(),"UTF-8");
            //2、根据请求计算响应（由于这是一个回显服务，所以这一步就可以省略）
            String response = process(request);
            //3、把响应写回到客户端。
            DatagramPacket responsePacket = new DatagramPacket(response.getBytes(),response.getBytes().length,
                    requestPacket.getSocketAddress());
            // 在当前的情景当中，就是谁发来的请求，就再返还给谁。
            socket.send(responsePacket);
            System.out.printf("[%s:%d] req: %s, resp: %s\n",
                    requestPacket.getAddress().toString(),requestPacket.getPort(),request,response);
        }
    }
    //由于是回显服务，响应就和请求一样了
    public String process(String request) {
        return request;
    }
    public static void main(String[] args) throws IOException {
        UdpEchoServer server = new UdpEchoServer(9090);
        server.start();
    }
}

客户端部分

在客户端的端口号，就不用自己手动指定了。让操作系统自己分配一个空闲的端口号就可以了。

  1. 客户端也要构造 UDP 请求。
  2. 客户端要有 IP。
  3. 客户端要有端口号。

客户端的主要作用：

  1. 从控制台读取用户输入的字符串。

  2. 把用户输入的内容，构造成一个 UDP 请求，并发送。构造的信息包含两部分信息：
    a、数据的内容 request 字符串。
    b、数据要发给谁 服务器的 IP + 端口。

  3. 从服务器响应数据，并解析。

  4. 把响应结果显示到控制台上。

客户端代码：

public class UdpEchoClient {
    private DatagramSocket socket = null;
    private String serverIP;
    private int serverPort;
    public UdpEchoClient(String serverIP, int serverPort) throws SocketException {
        //此处的 port 是服务器的端口
        //客户端启动的的时候，不需要给 socket 指定端口，客户端自己的端口是系统自己分配的
        socket = new DatagramSocket();
        this.serverIP = serverIP;
        this.serverPort = serverPort;
    }
    public UdpEchoClient() throws SocketException {
        socket = new DatagramSocket();
    }
    public void start() throws IOException {
        System.out.println("启动客户端");
        Scanner scanner = new Scanner(System.in);
        while (true) {
            //1、从控制台读取用户输入的字符串
            String request = scanner.next();
            //2、把用户输入的内容，构造成一个 UDP 请求并发送
            //构造的信息包含两部分信息：1、数据的内容 request 字符串    2、数据要发给谁 服务器的 IP + 端口
            DatagramPacket requestPacket = new DatagramPacket(request.getBytes(),request.getBytes().length,
                    InetAddress.getByName(serverIP),serverPort);
            socket.send(requestPacket);
            //3、从服务器响应数据，并解析
            DatagramPacket responsePacket = new DatagramPacket(new byte[1024],1024);
            socket.receive(responsePacket);
            String response = new String(responsePacket.getData(),0,responsePacket.getLength(),"UTF-8");
            //4、把响应结果显示到控制台上
            System.out.printf("req: %s, resp: %s\n", request,response);
        }
    }
    public static void main(String[] args) throws IOException {
        //因为客户端和服务器在同一个端口上，使用的 Ip 仍然是 127.0.0.1 如果在不同的机器上面，就要修改 IP 了
        UdpEchoClient client = new UdpEchoClient("127.0.0.1",9090);
        client.start();
    }
}

效果展示

先启动服务器：
在这里插入图片描述
再启动客户端：
在这里插入图片描述
测试效果：
在这里插入图片描述
在这里插入图片描述

加一些业务逻辑

通过在回显服务的基础上，加一些业务逻辑，就可以模拟实际开发当中的使用。 这里用一个翻译字典来展示：

  1. 客户端代码不变。
  2. 主要调整 process 方法。
  3. 读取请求并解析，把响应写回给客户端，这俩步骤都一样。

关键的就是：根据请求处理响应。只需要重写 process 方法就可以了，所以通过继承来写。

通过哈希表来构造一个词典。

代码如下：

public class TranslateServer extends UdpEchoServer{
    private HashMap<String, String> translate = new HashMap<>();
    public TranslateServer(int port) throws SocketException {
        super(port);
        translate.put("cat","小猫");
        translate.put("dog","小狗");
        translate.put("pig","小猪");
    }
    @Override
    public String process(String request) {
        return translate.getOrDefault(request,"没有该词的翻译");
    }
    public static void main(String[] args) throws IOException {
        TranslateServer server = new TranslateServer(9090);
        server.start();
    }
}

运行效果：
在这里插入图片描述

TCP

TCP 是以字节流为单位的。TCP 的 API 当中主要涉及到两个类：

  1. ServerSocket API（专门给 TCP 服务器使用）
  2. Socket API（既要给服务器用，又要给客户端用）

回显服务

服务器部分

建立连接

因为 TCP 是有链接的，不能一上来就读数据，而要先建立连接（接电话）。通过 Socket 里面的 accept 来建立链接：

public void start() throws IOException {
    System.out.println("服务器启动");
    while (true) {
    	//“接电话” 建立连接。
        Socket clientSocket = serverSocket.accept();
        processConnection(clientSocket);
    }
}
处理请求

处理请求的时候，先获得 IP 和端口号。 针对 TCP socket 的读写就和文件读写是一模一样的。
处理请求代码部分：

private void processConnection(Socket clientSocket) {
    System.out.printf("[%s:%d] 客户端建立连接\n",clientSocket.getInetAddress().toString(),clientSocket.getPort());
    //处理请求和响应
    try (InputStream inputStream = clientSocket.getInputStream()) {
        try (OutputStream outputStream = clientSocket.getOutputStream()) {
            //循环的处理每个请求，然后分别返回响应
            Scanner scanner = new Scanner(inputStream);
            while (true) {
                //1、读取请求
                if (!scanner.hasNext()) {
                    System.out.printf("[%s:%d] 客户端断开连接",clientSocket.getInetAddress().toString(),clientSocket.getPort());
                    break;
                }
                String request = scanner.next();
                //2、根据请求，计算响应
                String response = process(request);
                //3、把响应返回客户端，为了方便，可以使用 PrintWriter 把 OutputStream 包裹一下
                PrintWriter printWriter = new PrintWriter(outputStream);
                printWriter.println(response);
                //刷新缓冲区，如果不刷新的话，可能客户端就不能第一时间看到响应结果
                printWriter.flush();
                System.out.printf("[%s:%d] req: %s, resp: %s\n",clientSocket.getInetAddress().toString(),
                        clientSocket.getPort(),request,response);
            }
        }
    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        try {
            //关闭资源
            clientSocket.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
服务器端代码
public class TcpEchoServer {
    private ServerSocket serverSocket = null;
    public TcpEchoServer(int port) throws IOException {
        serverSocket = new ServerSocket(port);
    }
    public void start() throws IOException {
        System.out.println("服务器启动");
        while (true) {
        	//建立连接
            Socket clientSocket = serverSocket.accept();
            processConnection(clientSocket);
        }
    }
    private void processConnection(Socket clientSocket) {
        System.out.printf("[%s:%d] 客户端建立连接\n",clientSocket.getInetAddress().toString(),clientSocket.getPort());
        //处理请求和响应
        try (InputStream inputStream = clientSocket.getInputStream()) {
            try (OutputStream outputStream = clientSocket.getOutputStream()) {
                //循环的处理每个请求，然后分别返回响应
                Scanner scanner = new Scanner(inputStream);
                while (true) {
                    //1、读取请求
                    if (!scanner.hasNext()) {
                        System.out.printf("[%s:%d] 客户端断开连接",clientSocket.getInetAddress().toString(),clientSocket.getPort());
                        break;
                    }
                    String request = scanner.next();
                    //2、根据请求，计算响应
                    String response = process(request);
                    //3、把响应返回客户端，为了方便，可以使用 PrintWriter 把 OutputStream 包裹一下
                    PrintWriter printWriter = new PrintWriter(outputStream);
                    printWriter.println(response);
                    //刷新缓冲区，如果不刷新，可能客户端就不能第一时间看到响应结果
                    printWriter.flush();
                    System.out.printf("[%s:%d] req: %s, resp: %s\n",clientSocket.getInetAddress().toString(),
                            clientSocket.getPort(),request,response);
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                //关闭资源
                clientSocket.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
    private String process(String request) {
        return request;
    }
    public static void main(String[] args) throws IOException {
        TcpEchoServer server = new TcpEchoServer(9090);
        server.start();
    }
}

客户端部分

也用普通的 socket 即可。不用手动给客户端绑定端口，系统会自动分配。

  1. 对于 TCP 的 ServerSocket 来说，构造方法指定的端口，也表示自己绑定哪个端口。
  2. 对于 TCP 的 Socket 来说，构造方法指定的端口。表示要链接的服务器的端口。

流程和 UDP 一样，不过因为是字节流，所以是用文件来操作的。代码如下：

public class TcpEchoClient {
    private Socket socket = null;
    public TcpEchoClient(String serverIP, int serverPort) throws IOException {
    	//获得 IP 和端口
        socket = new Socket(serverIP,serverPort);
    }
    public void start() {
        System.out.println("和服务器连接成功");
        Scanner scanner = new Scanner(System.in);
        try (InputStream inputStream = socket.getInputStream()) {
            try (OutputStream outputStream = socket.getOutputStream()) {
                while (true) {
                    // 1、从控制台读取字符串
                    String request = scanner.next();
                    // 2、根据读取的字符串，构造请求，把请求发给服务器
                    PrintWriter printWriter = new PrintWriter(outputStream);
                    printWriter.println(request);
                    printWriter.flush();
                    // 3、从服务器读取响应，并解析
                    Scanner respScanner = new Scanner(inputStream);
                    String response = respScanner.next();
                    // 4、把结果显示到控制台上
                    System.out.printf("res: %s, resp: %s\n",request, response);
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    public static void main(String[] args) throws IOException {
        TcpEchoClient client = new TcpEchoClient("127.0.0.1",9090);
        client.start();
    }
}

效果展示

客户端：
在这里插入图片描述
服务器端：
在这里插入图片描述

多客户端回显服务多线程版本

因为上面的版本，一次只能接通一个会话，也就是一次只能连接一个客户端，所以实现一个多客户端的。通过多线程就可以实现多客户端了。其他地方都不要修改。只需要修改接通链接的地方就好了。修改后的代码如下：

public class TcpThreadEchoServer {
    private ServerSocket serverSocket = null;
    public TcpThreadEchoServer(int port) throws IOException {
        serverSocket = new ServerSocket(port);
    }
    public void start() throws IOException {
        System.out.println("服务器启动");
        //建立连接
        while (true) {
            Socket clientSocket = serverSocket.accept();
            //每次 accept 成功，都创建一个新的线程，由新线程去执行这个 processConnection
            Thread t = new Thread(() -> {
                processConnection(clientSocket);
            });
            t.start();
        }
    }
    private void processConnection(Socket clientSocket) {
        System.out.printf("[%s:%d] 客户端建立连接\n",clientSocket.getInetAddress().toString(),clientSocket.getPort());
        //处理请求和响应
        try (InputStream inputStream = clientSocket.getInputStream()) {
            try (OutputStream outputStream = clientSocket.getOutputStream()) {
                //循环的处理每个请求，然后分别返回响应
                Scanner scanner = new Scanner(inputStream);
                while (true) {
                    //1、读取请求
                    if (!scanner.hasNext()) {
                        System.out.printf("[%s:%d] 客户端断开连接",clientSocket.getInetAddress().toString(),clientSocket.getPort());
                        break;
                    }
                    String request = scanner.next();
                    //2、根据请求，计算响应
                    String response = process(request);
                    //3、把响应返回客户端，为了方便，可以使用 PrintWriter 把 OutputStream 包裹一下
                    PrintWriter printWriter = new PrintWriter(outputStream);
                    printWriter.println(response);
                    //刷新缓冲区，如果不刷新，可能客户端就不能第一时间看到响应结果
                    printWriter.flush();
                    System.out.printf("[%s:%d] req: %s, resp: %s\n",clientSocket.getInetAddress().toString(),
                            clientSocket.getPort(),request,response);
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                //关闭资源
                clientSocket.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
    private String process(String request) {
        return request;
    }
    public static void main(String[] args) throws IOException {
        TcpEchoServer server = new TcpEchoServer(9090);
        server.start();
    }
}

运行结果：

我们创建三个客户端来测试：

客户端1：
在这里插入图片描述
客户端2：
在这里插入图片描述
客户端3：
在这里插入图片描述
服务器端：
在这里插入图片描述
通过多线程就可以完成多客户端访问了。在客户端 new Socket 成功的时候，其实操作系统层面已经建立好了连接（TCP 三次握手），但是应用程序并没有接通这个连接。

多客户端回显服务线程池版本

既然可以通过多线程来实现多客户端，那么也可以实现线程池版本。只要把 new 线程的对方，改成线程池就好了。

public class TcpThreadPoolEchoServer {
    private ServerSocket serverSocket = null;
    public TcpThreadPoolEchoServer (int port) throws IOException {
        serverSocket = new ServerSocket(port);
    }
    public void start() throws IOException {
        System.out.println("服务器启动");
        ExecutorService pool = Executors.newCachedThreadPool();
        while (true) {
            Socket clientSocket = serverSocket.accept();
            //通过线程池来实现
            pool.submit(new Runnable() {
                @Override
                public void run() {
                    processConnection(clientSocket);
                }
            });
        }
    }
    private void processConnection(Socket clientSocket) {
        System.out.printf("[%s:%d] 客户端建立连接\n",clientSocket.getInetAddress().toString(),clientSocket.getPort());
        //处理请求和响应
        try (InputStream inputStream = clientSocket.getInputStream()) {
            try (OutputStream outputStream = clientSocket.getOutputStream()) {
                //循环的处理每个请求，然后分别返回响应
                Scanner scanner = new Scanner(inputStream);
                while (true) {
                    //1、读取请求
                    if (!scanner.hasNext()) {
                        System.out.printf("[%s:%d] 客户端断开连接",clientSocket.getInetAddress().toString(),clientSocket.getPort());
                        break;
                    }
                    String request = scanner.next();
                    //2、根据请求，计算响应
                    String response = process(request);
                    //3、把响应返回客户端，为了方便，可以使用 PrintWriter 把 OutputStream 包裹一下
                    PrintWriter printWriter = new PrintWriter(outputStream);
                    printWriter.println(response);
                    //刷新缓冲区，如果不刷新，可能客户端就不能第一时间看到响应结果
                    printWriter.flush();
                    System.out.printf("[%s:%d] req: %s, resp: %s\n",clientSocket.getInetAddress().toString(),
                            clientSocket.getPort(),request,response);
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                //关闭资源
                clientSocket.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
    private String process(String request) {
        return request;
    }
    public static void main(String[] args) throws IOException {
        TcpEchoServer server = new TcpEchoServer(9090);
        server.start();
    }
}

运行结果如下：
客户端1：
在这里插入图片描述
客户端2：
在这里插入图片描述
客户端3：
在这里插入图片描述
服务器端：
在这里插入图片描述

实现翻译服务

和 UDP 版本的实现方法一样，不过是变成了 TCP 的模式。还是继承自线程池，代码如下：

public class TcpDictServer extends TcpThreadPoolEchoServer {
    private HashMap<String, String> dict = new HashMap<>();
    public TcpDictServer(int port) throws IOException {
        super(port);

        dict.put("cat", "小猫");
        dict.put("dog", "小狗");
        dict.put("pig", "小猪");
    }

    @Override
    public String process(String request) {
        return  dict.getOrDefault(request,"没有此翻译");
    }

    public static void main(String[] args) throws IOException {
        TcpDictServer server = new TcpDictServer(9090);
        server.start();
    }
}

运行结果如下：
在这里插入图片描述

Lockey-s
关注
  • 7
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 9
    评论
专栏目录
小汤学编程之JavaEE学习day02——Servlet使用步骤、生命周期、接收与返回数据、GET与POST、转发与重定向
SoupTC的博客
12-29 199
一、Servlet使用步骤 二、Servlet生命周期 三、Servlet接收与返回数据 四、GET请求与POST请求的区别 五、转发与重定向 一、Servlet使用步骤 servlet是运行在服务器上的应用程序。 Servlet是单实例多线程的。 创建web项目，在web.xml中配置Servlet信息。 编写Servlet.java ... @WebServlet("/LoginServlet") public class LoginServlet extends HttpServlet { .
JavaEE编程技术(JSP/Servlet)
Xiongchao99的博客
04-24 2366
1、DOS，命令窗口下编译运行java文件 （1）编译.java文件：若没有配置环境变量，可以直接到开始搜索cmd打开命令窗口，进入java文件所在的磁盘文件地址，（如：进入Server.java所在的D：\MyEclipse\test1\Server.java可用命令：D：——>cd MyEclipse——>cd test1；注：进入一个文件夹后可以用dir命令获取该文件夹中含有哪些子文件)，
Java EE编程技术（第2版）教材例子代码
05-13
Java EE编程技术（第2版）教材例子代码，包含完整的代码及项目文件，以及运行截图。
JavaEE编程技术第二版源码--郝玉龙
10-23
JavaEE编程技术第二版源码--郝玉龙。有第二章到第九章的源码。清华大学出版社出版的高等学校计算机科学与技术教材源代码。
Java EE编程技术学习笔记(1)-Java EE概述
sinat_26841049的博客
07-23 712
Java EE概述 企业级应用程序特点：分布式，高速反应性，安全性，可扩展性，集成化。 三层体系结构应用程序：表示逻辑（瘦客户层），业务逻辑，业务数据   Java EE技术框架 1. 组件技术：客户端组件（Web浏览器，Applet，应用程序），Web组件（Servlet，JSP），业务组件（EJB，Entity）。 2. 服务技术：JDNI，JDBC，JTA，JAAS，JCA，WS
求精要诀——JavaEE编程开发案例精讲 源代码
04-02
求精要诀——JavaEE编程开发案例精讲 文件过大无法全部上传该部分是 1-7章实践部分 源代码
求精要诀——JavaEE编程开发案例精讲 源代码（8-12）
04-02
求精要诀——JavaEE编程开发案例精讲 源代码（8-12章）
求精要诀：JavaEE编程开发案例精讲
07-22
资源名称：求精要诀：Java EE编程开发案例精讲内容简介：Java EE是当前最流行的Web应用主流框架，在企业级应用开发中占主导地位。本书系统地介绍Java EE的体系结构、JSP与Servlet在体系结构中的地位、应用服务器和...
JavaEE编程技术
09-26
Java EE编程技术——源代码和课件下载
Java EE编程技术学习笔记(3)-JSP&JavaBean&JSF
sinat_26841049的博客
07-23 474
JSP 嵌入JSP页面的成分：HTML、脚本元素、指令、动作。JSP还定义了可以直接使用的内置对象，新的JSP规范使用了表达式语言（EL）。   1.脚本 输出表达式 表达式 %> 注释（输出到客户端） （不输出到客户端） 声明变量、方法和类 声明代码 %>   2.指令 page指令：”java” %> 用来定义JSP页面的全局属性：import、content
java ee编程技术温立辉_java ee编程技术
weixin_33955307的博客
03-04 253
《高等学校计算机科学与技术教材：JaEE编程技术(第2版)》对JaEE6编程技术进行了系统介绍。首先对JaEE体系结构进行概述，介绍JaEE的定义、设计思想、技术框架等，然后详细指导读者如何基于NetBeans+MySQL来搭建JaEE开发环境，随后以JaEE企业应用的表现层、业务逻辑层和数据持久化层的编程任务为主线，由浅入深地讲解各个应用层次开发相关的组件技术、服务技术、通信技术和架构技术等，重...
怎么用java ee编程_Java EE应用程序入门 - 编程入门网
weixin_28704675的博客
02-17 168
Java EE应用程序入门时间:2011-07-06 netbeans.org本文将详细介绍使用 EJB 3.0 技术开发企业应用程序的基础知识，而 EJB 3.0 是 Java EE 5 平台的组成部分。本文还将阐述如何通过 EJB 3.0 技术简化开发企业应用程序的流程。本文使用的是 NetBeans IDE 6.0 发行版。先决条件本文假定您在以下方面拥有基本知识和编程经验：Java 编程N...
Java网络编程详解
weixin_30354675的博客
02-27 707
1.网络编程 　　1.1计算机网络概述 　　网络编程的实质就是两个(或多个)设备(例如计算机)之间的数据传输。 　　按照计算机网络的定义，通过一定的物理设备将处于不同位置的计算机连接起来组成的网络，这个网络中包含的设备有：计算机、路由器、交换机等等。 　　其实从软件编程的角度来说，对于物理设备的理解不需要很深刻，就像你打电话时不需要很熟悉通信网络的底层实现...
JavaEE实现WebSocket（一）入门
技术之道，其路之久远，需淡然与仔细
08-11 2467
基于JavaEE的WebSocket技术的最简单实现实例--聊天室
端口号 & 一个端口号是否可以被多个进程绑定？& 一个进程是否可以bind多个端口号？
热门推荐
dangzhangjing97的博客
07-08 1万+
1.端口号的作用 端口号可以用来标识同一个主机上通信的不同应用程序，端口号+IP地址就可以组成一个套接字，用来标识一个进程 2.端口号的应用场景 在TCP/IP协议中，用“源IP地址”，“目的IP地址”，“源端口号”，“目的端口号”,协议号（IP协议的协议号为4，TCP的协议号为6）这样的一个五元组来标识一个通信，通信的双方在发送消息时，消息的头部会带着这样的五元组 3.端...
单个进程监听多个端口及多个进程监听同一个端口
mtAsnow
08-27 3939
单个进程监听多个端口 单个进程创建多个 socket 绑定不同的端口，TCP, UDP 都行 多个进程监听同一个端口(multiple processes listen on same port) 方式1：通过 fork 创建子进程的方式可以实现，其他情况下不行。 当连接到来时，子进程、父进程都可以 accept, 这就是著名的“惊群”问题(thundering herd problem)。 NG...
一个socket可以绑定多个端口吗_udp绑定端口信息
weixin_39834406的博客
11-29 2419
1. udp网络程序-端口问题会变的端口号重新运行多次脚本，然后在“网络调试助手”中，看到的现象如下：说明：每重新运行一次网络程序，上图中红圈中的数字，不一样的原因在于，这个数字标识这个网络程序，当重新运行时，如果没有确定到底用哪个，系统默认会随机分配记住一点：这个网络程序在运行的过程中，这个就唯一标识这个程序，所以如果其他电脑上的网络程序如果想要向此程序发送数据，那么就需要向这个数字(即端口)标...
一个socket可以绑定多个端口吗_开始Socket编程，在Unity里搭一个最简单的Echo程序...
weixin_39531229的博客
11-29 1129
网络游戏分为客户端和服务端两部分，顾名思义客户端就是运行在用户的电脑或者手机上，服务端程序运行在游戏运营商的服务器上。多个客户端通过网络与服务端进行通信。大多数的网络游戏因为要同时处理与很多很多玩家的通信，游戏服务器通常采用分布式架构，不同的服务端负责不同区的玩家。服务端与客户端通常使用TCP网络进行通讯。于是就要提到网络编程的基础：Socket。网络上的两个程序要进行数据交换，是通过一个双向的通...
基于javaEE的网络营销系统设计
最新发布
09-10
### 回答1： Java EE（Java Enterprise Edition）...总之，基于JavaEE的网络营销系统设计，需要考虑用户需求、系统性能和数据安全等方面，通过合理的架构和技术选型，为企业提供一个功能强大、稳定可靠的网络营销平台。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Lockey-s

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值