程序员经验分享-hwhale

Java---TCP通信

2023-10-26

目录

1.TCP通信-快速入门

编写客户端代码

步骤：客户端发送消息

总结：

需求：服务端实现步骤

总结：

2.TCP通信-多发多收消息

案例：使用TCP通信实现：多发多收消息

总结：

*3.TCP通信-同时接受多个客户端消息[重点]

总结：

4.TCP通信-使用线程池优化

总结：

5.TCP通信实战案例-即时通信

总结：

6.TCP通信实战案例-模拟BS系统[了解]

总结：

1.TCP通信-快速入门

编写客户端代码

TCP协议：

TCP是一种面向连接，安全、可靠的传输数据的协议

传输前，采用“三次握手”方式，点对点通信，是可靠的

在连接中可进行大数据量的传输

TCP通信模式演示：

Socket类

Socket类成员方法

步骤：客户端发送消息

需求：客户端实现步骤

1.创建客户端的Socket对象，请求与服务端的连接。

2.使用socket对象调用getOutputStream()方法得到字节输出流。

3.使用字节输出流完成数据的发送。

4.释放资源：关闭socket管道。

import java.io.IOException;
import java.io.OutputStream;
import java.io.PrintStream;
import java.net.Socket;

/**
   目标：完成Socket网络编程入门案例的客户端开发，实现1发1收。
 */
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", 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();
        }
    }

总结：

1.TCP通信的客户端的代表类是谁？

Socket类

public Socket(String host , int port)

2.TCP通信如何使用Socket管道发送、接收数据。

OutputStream getOutputStream()：获得字节输出流对象（发）

InputStream getInputStream()：获得字节输入流对象（收）

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

步骤：服务端实现接收消息

ServerSocket(服务端)

ServerSocket类成员方法

 

需求：服务端实现步骤

创建ServerSocket对象，注册服务端端口。

调用ServerSocket对象的accept()方法，等待客户端的连接，并得到Socket管道对象。

通过Socket对象调用getInputStream()方法得到字节输入流、完成数据的接收。

释放资源：关闭socket管道

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.ServerSocket;
import java.net.Socket;

/**
   目标：开发Socket网络编程入门代码的服务端，实现接收消息
 */
public class ServerDemo2 {
    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();
        }
    }
}

总结：

1.TCP通信服务端用的代表类？

ServerSocket类,注册端口。

调用accept()方法阻塞等待接收客户端连接。得到Socket对象。

2.TCP通信的基本原理？

客户端怎么发，服务端就应该怎么收。

客户端如果没有消息，服务端会进入阻塞等待。

Socket一方关闭或者出现异常、对方Socket也会失效或者出错。

2.TCP通信-多发多收消息

案例：使用TCP通信实现：多发多收消息

需求：使用TCP通信方式实现：多发多收消息。

具体要求：

可以使用死循环控制服务端收完消息继续等待接收下一个消息。

客户端也可以使用死循环等待用户不断输入消息。

客户端一旦输入了exit，则关闭客户端程序，并释放资源。

import java.io.OutputStream;
import java.io.PrintStream;
import java.net.Socket;
import java.util.Scanner;

/**
   目标：实现多发和多收
 */
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", 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();
        }
    }
}

import java.io.BufferedReader;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.ServerSocket;
import java.net.Socket;

/**
   目标：开发Socket网络编程入门代码的服务端，实现接收消息
 */
public class ServerDemo2 {
    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();
        }
    }
}

本案例实现了多发多收，那么是否可以同时接收多个客户端的消息？

不可以的。

因为服务端现在只有一个线程，只能与一个客户端进行通信。

总结：

1.本次多发多收是如何实现的？

客户端使用循环反复地发送消息。

服务端使用循环反复地接收消息。

2.现在服务端为什么不可以同时接收多个客户端的消息？

目前服务端是单线程的，每次只能处理一个客户端的消息。

*3.TCP通信-同时接受多个客户端消息[重点]

之前我们的通信是否可以同时与多个客户端通信，为什么？

不可以的

单线程每次只能处理一个客户端的Socket通信

如何才可以让服务端可以处理多个客户端的通信需求？

引入多线程。

同时处理多个客户端消息

 

import java.io.OutputStream;
import java.io.PrintStream;
import java.net.Socket;
import java.util.Scanner;

/**
    目标：实现服务端可以同时处理多个客户端的消息。
 */
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", 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();
        }
    }
}

import java.io.BufferedReader;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.ServerSocket;
import java.net.Socket;

/**
   目标：实现服务端可以同时处理多个客户端的消息。
 */
public class ServerDemo2 {
    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();
        }
    }
}

import java.io.BufferedReader;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.Socket;

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() + "下线了！！！");
        }
    }
}

总结：

本次是如何实现服务端接收多个客户端的消息的。

主线程定义了循环负责接收客户端Socket管道连接

每接收到一个Socket通信管道后分配一个独立的线程负责处理它。

4.TCP通信-使用线程池优化

目前的通信架构存在什么问题？

客户端与服务端的线程模型是： N-N的关系。

客户端并发越多，系统瘫痪的越快。

引入线程池处理多个客户端消息

 

import java.io.OutputStream;
import java.io.PrintStream;
import java.net.Socket;
import java.util.Scanner;

/**
    拓展：使用线程池优化：实现通信。
 */
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", 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();
        }
    }
}

import java.net.ServerSocket;
import java.net.Socket;
import java.util.concurrent.*;

/**
   目标：实现服务端可以同时处理多个客户端的消息。
 */
public class ServerDemo2 {

    // 使用静态变量记住一个线程池对象
    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();
        }
    }
}

import java.io.BufferedReader;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.Socket;

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() + "下线了！！！");
        }
    }
}

总结：

本次使用线程池的优势在哪里？

服务端可以复用线程处理多个客户端，可以避免系统瘫痪。

适合客户端通信时长较短的场景。

5.TCP通信实战案例-即时通信

即时通信是什么含义，要实现怎么样的设计？

即时通信，是指一个客户端的消息发出去，其他客户端可以接收到。

之前我们的消息都是发给服务端的。

即时通信需要进行端口转发的设计思想。

即时通信-端口转发

 

import java.io.OutputStream;
import java.io.PrintStream;
import java.net.Socket;
import java.util.Scanner;

/**
    拓展：即时通信

    客户端：发消息的同时，随时有人发消息过来。
    服务端：接收消息后，推送给其他所有的在线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", 9999);

            // 马上为客户端分配一个独立的线程负责读取它收到的消息
            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();
        }
    }
}

import java.io.BufferedReader;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintStream;
import java.net.Socket;

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("服务端把你踢出去了~~");
        }
    }

}

import java.net.ServerSocket;
import java.net.Socket;
import java.util.ArrayList;
import java.util.List;

/**
   目标: 即时通信
 */
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(9999);
            // 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();
        }
    }
}

import java.io.*;
import java.net.Socket;

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();
        }
    }
}

总结：

即时通信是什么含义，要实现怎么样的设计？

即时通信，是指一个客户端的消息发出去，其他客户端可以接收到

即时通信需要进行端口转发的设计思想。

服务端需要把在线的Socket管道存储起来

一旦收到一个消息要推送给其他管道

6.TCP通信实战案例-模拟BS系统[了解]

之前的客户端都是什么样的

其实就是CS架构，客户端实需要我们自己开发实现的。

BS结构是什么样的，需要开发客户端吗？

浏览器访问服务端，不需要开发客户端。

HTTP响应数据的协议格式：就是给浏览器显示的网页信息

 

import java.io.PrintStream;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.concurrent.*;

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

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

    客户端：浏览器。（无需开发）
    服务端：自己开发。
    需求：在浏览器中请求本程序，响应一个网页文字给浏览器显示


 */
public class BSserverDemo {
    // 使用静态变量记住一个线程池对象
    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();
        }
    }
}
import java.io.BufferedReader;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintStream;
import java.net.Socket;

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'>《最牛的149期》 </span>");
            ps.close();
        } catch (Exception e) {
            System.out.println(socket.getRemoteSocketAddress() + "下线了！！！");
        }
    }
}

总结：

1.TCP通信如何实现BS请求网页信息回来呢？

客户端使用浏览器发起请求（不需要开发客户端）

服务端必须按照浏览器的协议规则响应数据。

2.浏览器使用什么协议规则呢？

HTTP协议（简单了解下）

本文内容由网友自发贡献，版权归原作者所有，本站不承担相应法律责任。如您发现有涉嫌抄袭侵权的内容，请联系:hwhale#tublm.com(使用前将#替换为@)

JavaSE

Java

开发语言

网络

tcpip

Java---TCP通信 的相关文章

  • Android Canvas.DrawBitmap 没有模糊/抗锯齿？

    我正在尝试使用精灵 或非常像素化的角色 背景等 制作一个Android游戏 我把它们画在画布上 就像这样 matrix preScale xrat yrat canvas drawBitmap img matrix null 其中 img

  • 按钮和窗口之间的空间

    我这里有这段代码 其想法是在主窗口中在文本区域旁边有两个按钮 但我尚未添加 在尝试使用 GridBagLayout 并在此过程中扯掉我的头发后 我决定不使用布局并在不可调整大小的窗口内手动放置按钮 import java awt impor

  • API 级别 15 的印地语字体（又名 Android 4.0.2）

    我有一个基于印地语内容的 Android 应用程序 并使用了 Android API 16 SDK 中的 devangiri 字体 并重命名为印地语 ttf 文本在 API 级别 16 和 17 上渲染良好 但在 Android API 级

  • 使用 System.loadLibrary() 时出现不满意的链接错误？

    由于某种原因 我在我的 java 应用程序中遇到了令人讨厌的不满意链接错误 这是所涉犯罪者 System loadLibrary psjw 尽管库 psjw dll 显然与此类位于同一源包中 请帮忙 确保 psjw dll 位于您的 PAT

  • 我需要帮助理解 java 中 Timer 类的 ScheduleAtFixedRate 方法

    作为一个粉丝番茄工作法 http www pomodorotechnique com 我正在为自己制作一个倒计时器 以保证我完成作业 然而 这个特定的项目不是家庭作业 Stack 有很多关于使用计时器来控制用户输入之前的延迟等问题 但关于独

  • “赠送”应用内购买 Android

    有没有办法将 Google Billing 中的应用内购买 赠送 给特定帐户 我把这个问题放在这里是因为如果有一种方法可以以编程方式完成它 那很好 但不是必须的 在官方文档中找不到任何相关内容 我想要这个的原因是因为我的一个应用程序目前处于

  • TarsosDSP 音高分析傻瓜式教程

    我正在开发一个分析声音文件音调的程序 我遇到了一个非常好的 API 称为 TarsosDSP 它提供了各种音高分析 然而 我在设置它时遇到了很多麻烦 有人可以向我展示一些有关如何使用此 API 特别是 PitchProcessor 类 的快

  • 如何将 JTextField 添加到 JFrame 的菜单栏？

    我一直在尝试重载 JMenu 并放入一些自定义代码来支持 JTextField 但进展并不顺利 我在这里的主要目的是在菜单项的右侧添加一个搜索字段 因此 我在左侧有 文件 编辑 帮助 之类的东西 然后在右侧是搜索栏 几乎就像某些浏览器中的谷

  • 将两个表视图绑定在一起，以便它们同步滚动

    我想将两个表视图绑定在一起 以便它们同步滚动 我怎么做 我无法找到如何访问表格视图的滚动条 我做了一个CSS hack来将Tableview与外部滚动条绑定 一个滚动条控制两个表格视图 我的想法的概述 创建两个表视图 制作一个垂直滚动条 在

  • 无法在 Vaadin Maven 项目上运行 mvn vaadin:compile

    当我运行命令 mvn vaadin compile 时出现此错误 INFO BUILD FAILURE INFO INFO Total time 1 039s INFO Finished at Thu Mar 20 11 35 00 CET

  • 根据条件更改 JSlider 的最小值和最大值

    我正在 Netbeans 中创建 Swing GUI 此 GUI 的目的是打开一个 缓冲 图像 在 JLabel 中作为图标 并对其应用仿射变换 现在我正在做 4 个转换 如下所示 现在 每个变换都需要两个滑块来更改 X 和 Y 值 但旋转

  • 无法初始化类 io.confluence.kafka.schemaregistry.client.rest.RestService

    我正在尝试使用 KafkaAvroSerialzer 设置一个卡夫卡生产者以获得价值 当 rit 尝试创建生产者时 我遇到了这个错误 我正在使用 confluence 5 2 1 中提供的所有罐子 java lang NoClassDefF

  • 在 Android 应用程序中读取 CSV 文件

    我正在开发一个概念验证应用程序 以便我可以在我正在制作的更大的应用程序中实现该功能 我对 Java 和 Android 开发有点陌生 但希望这个问题不会太简单或太复杂 基本上 我试图从 CSV 文件中读取字符串列表 并使其可用于在应用程序的

  • 为什么文件传输完成后我的列表视图条目的内容没有更新？

    为什么将文件复制到目录后listview没有更新驻留在该目录中的较新内容 仅当我退出时listview重新进入视图会刷新吗 有人可以告诉我如何解决这个问题吗 文件功能java文件的复制 您应该将新复制的文件 VideoInfo对象 添加到您

  • java：如何仅选择jtable中的一个单元格而不是整行

    在 jTable 中 我希望当用户单击单元格时 这句话会打印在屏幕上 I am cell in row X and column Y 其中 x 和 Y 是单击单元格的行和列 但我得到的是 例如 当我单击第 1 行和第 4 列中的单元格时 我

  • 使用 lambda 或 Stream API 合并流以生成交替序列

    我有一些按预期返回 Stream 的代码 但也许可以用某种类型的 lambda 或 stream 操作替换它 而不是耗尽 a 中的迭代器while loop 它只是一种交替流中元素的方法first and second当其中一个元素耗尽时停

  • Java HashMap 与 ArrayList 相比的内存开销

    我想知道java HashMap与ArrayList相比的内存开销是多少 Update 我想提高搜索一大包 600 万以上 相同对象的特定值的速度 因此 我正在考虑使用一个或多个HashMap来代替ArrayList 但我想知道 HashM

  • 使用 HttpClient 在 java 中进行连接池 [关闭]

    Closed 这个问题需要多问focused help closed questions 目前不接受答案 如何使用 HttpClient 创建连接池 我必须频繁连接到同一台服务器 值得创建这样一个池吗 是否可以保持 HTTP 连接处于活动状

  • 如何使用 Maven 创建新的 Eclipse RCP 项目？

    如何使用 Maven 创建新的 Eclipse RCP 项目 最好是m2eclipse http maven apache org eclipse plugin html 我读到有一个关于 Eclipse 的 Maven 插件 Maven

  • 为什么浮点数有符号零？

    为什么双打有 0也 0 其背景和意义是什么 0 通常 被视为0 当一个negative浮点数非常接近零 可以考虑0 要明确的是 我指的是算术下溢 http en wikipedia org wiki Arithmetic underflow

随机推荐

  • UsbWebserver + MySQL + Apache的和环境配置问题（主要是连不上MySQL的问题）

    问题1 Apche感叹号 是因为软件路径中含有中文 可以把文件转移到没中文的路径下 问题2 mysqli connect Server sent charset 255 unknown to the client php集成环境 usbwe

  • 电子闹钟设计

    摘要 本设计是以89c51单片机作为控制核心的闹铃系统 本文大致可以分三个章节 第一章讲用单片机制作电子闹钟带来的优势 还有电子闹钟在未来的电子产品中的趋势以及本次设计所要实现的课题目标 第二章讲一些设计思路和硬件组成 第三讲程序代码 最后

  • CVE10大漏洞总结【网络安全】

    1 OpenSSL心脏出血漏洞 漏洞描述 这项严重缺陷 CVE 2014 0160 的产生是由于未能在memcpy 调用受害用户输入内容作为长度参数之前正确进行边界检查 攻击者可以追踪OpenSSL所分配的64KB缓存将超出必要范围的字节信

  • std::string::replace使用小计

    ctrl c ctrl v 真是害死人 看起来简单的东西 往往却又很容易出问题 究其原因 还在于只知其表不知其里 容易想当然 今天遇到的问题是简单调用string replace替换子串的问题 如 std string sTest1 12x

  • web服务器开发课程项目实训,Web前端开发实训案例教程（初级）

    目 录 第1章 实践概述 1 1 1 实践目标 1 1 2 实践知识地图 1 1 3 实施安排 6 1 3 1 实验部分 技术专题 6 1 3 2 综合实践部分 11 第2章 网页设计与制作 19 2 1 实验目标 19 2 2 实验任务

  • FTP命令详解

    FTP命令是Internet用户使用最频繁的命令之一 不论是在DOS还是UNIX操作系统下使用FTP 都会遇到大量的FTP内部命令 熟悉并灵活应用FTP的内部命令 可以大大方便使用者 并收到事半功倍之效 FTP的命令行格式为 ftp v d

  • bytebuffer 使用demo

    pom文件

  • 微信小程序路由

    wx reLaunch Object object 关闭所有页面 打开到应用内的某个页面 一般是跳转到首页使用 例 wx reLaunch url url wx navigateTo Object object 保留当前页面 跳转到应用内的

  • Java时间转换问题 [Failed to convert property value of type ‘java.lang.String‘ to required type ‘java.

    1 错误提示代码 default message Failed to convert property value of type java lang String to required type java 2 分析原因 遇到java接收

  • macOS 系统下安装Lua及lua-cjson

    macOS 系统下安装Lua及lua cjson lua安装及部署 具体操作步骤如下 curl R O http www lua org ftp lua 5 2 3 tar gz tar zxf lua 5 2 3 tar gz cd lu

  • 豆瓣读书top250数据爬取与可视化

    爬虫 scrapy 题目 根据豆瓣读书top250 根据出版社对书籍数量分类 绘制饼图 搭建环境 import scrapy import numpy as np import pandas as pd import matplotlib

  • UE5《Electric Dreams》项目PCG技术解析 之 PCGCustomNodes详解（三）SG_CopyPointsWithHierarchy

    继续解析 Electric Dreams 项目中的自定义节点和子图 SG CopyPointsWithHierarchy和PostCopyPoints OffsetIndices 文章目录 前导文章 标准组合拳 SG CopyPointsW

  • STM32开发中各库函数的主要作用和关系。

    STM32开发中各库函数的主要作用和关系 STM32各库函数关系的简单解析 您好 这是我第一次使用 CSDN来发布文章 如果有排版不合理 结构凌乱 欢迎私信我交流经验 文章内容如有错误 欢迎读者指正 首先我们了解一下什么是库函数 众所周知

  • 常见的几种开源协议

    在学习中经常能看到一些词 例如 GPL LGPL等等 自打上学那会就遇见过 对它们的具体含义却不了解 今天给它们总结一下 说到开源协议 不得不提GNU 课本上给的定义是 GNU is Not Unix 这是官方给出的递归定义 永远也找不到本

  • Linux基础服务3——samba

    文章目录 一 基本了解 1 1 服务安装 1 2 服务进程和端口 1 3 samba用户 1 4 配置文件 1 4 1 主配置文件 1 4 2 配置文件参数 1 5 安全级别 二 访问samba 2 1 参数测试 2 2 交互式访问 2 3

  • 多线程进阶学习10------AQS详解

    AbstractQueuedSynchronizer 来自于JDK1 5 位于JUC包 由并发编程大师Doug Lea编写 字面翻译就是 抽象队列同步器 简称为AQS AQS作为一个抽象类 是构建JUC包中的锁 比如ReentrantLoc

  • Netty工作原理最详细分析

    NIO通讯服务端步骤 1 创建ServerSocketChannel 为它配置非阻塞模式 2 绑定监听 配置TCP参数 录入backlog大小等 3 创建一个独立的IO线程 用于轮询多路复用器Selector 4 创建Selector 将之

  • 面试嵌入式工程师过程中的常见问题和回答

    1 请介绍一下你的嵌入式系统开发经验 an 首先 回答此类问题时应该尽可能地详细和具体 可以从以下方面介绍自己的嵌入式系统开发经验 1 开发环境和工具 介绍自己使用过哪些开发环境和工具 例如Keil IAR Eclipse等 可以说明自己对

  • Java之变量、标识符、保留字、变量

    文章目录 1 关键字与保留字 2 标识符 2 1 什么是标识符 Identifier 2 2 定义合法标识符规则 重要 2 3 Java 中的名称命名规范 3 变量 3 1 变量的声明与使用 3 2 基本数据类型 3 2 1 整数类型 by

  • Java---TCP通信

    目录 1 TCP通信 快速入门 编写客户端代码 步骤 客户端发送消息 总结 需求 服务端实现步骤 总结 2 TCP通信 多发多收消息 案例 使用TCP通信实现 多发多收消息 总结 3 TCP通信 同时接受多个客户端消息 重点 总结 4 TC

热门标签