GUI+SQLServer考试系统

文章目录

1、概述
- 1.1、目的与要求
- 1.2、设计环境
2、需求分析
3、概念模型设计
4、逻辑和物理结构设计
5、数据库的实施与维护
5.2、部分操作截图
6、源码获取地址

1、概述

1.1、目的与要求

随着科技的发展，基本上所有的具有一定数量数据的机构都开始使用计算机数据库来做管理。几乎现在每个人在学习中，都会做大量的题。该课程设计要求设计一个做题的数据管理系统，数据库中包含了用户的基本信息，题库基本信息，以及用户错题集。要方便用户进行做题整理与归纳，通过该课程设计，应该达到把数据库理论知识更加的巩固加深，加强动手能力与实践能力，学以致用，与现实生活中的应用充分结合起来。

1.2、设计环境

Microsoft SQL Server 2019
JDK 1.8
IntelliJ IDEA 2021

2、需求分析

2.1、系统功能要求设计

此系统实现如下功能：
1. 使得用户练习题，整理错题、条理化、自动化。
2. 通过账号和密码登录系统，管理员增删改查提供以及用户。
3. 设计人机交换界面，功能安排合理，操作使用方便，并且进一步考虑系统在安全性，完整性，并发控制等方面的功能要求。

2.2、系统模块设计

习题练习系统大体可以分成两大模块如，一是管理员模块，里面包含题库和用户的基本信息；再者便是用户模块，在该模块中应该包含查询题库，与错题集的添加。
可以得到系统流程图：

2.3、数据字典

数据项是数据库的关系中不可再分的数据单位，下表分别列出了数据的名称、数据类型、长度、取值能否为空。利用SQL Server 2019 建立“exam”数据库，其基本表清单及表结构描述如下：
数据库中用到的表：
Usertable 数据表，结构如下：
Title 数据表，结构如下：
Error 数据表结构如下：

3、概念模型设计

由需求分析的结果可知，本系统设计的实体包括：
1. 用户：账号，密码，姓名，权限
2. 题库：题目编号，题目，选项A，选项B，选项C，选项D，选项E，题目类型，答案
3. 错题集：errorid，写错时间
4. 管理员可以添加多个题，用户可以答多个题。由上述分析可得到系统的E—R图：

4、逻辑和物理结构设计

4.1、由系统E—R图转化而得到的关系模式如下

用户（userid，姓名，密码，权限）
题库（topicid，题目，选项A，选项B，选项C，选项D，选项E，题目类型，答案，userid）
错题集（errorid，写错时间，userid，topicid）

4.2、确定关系模型的存取方法

在将概念模型转换成物理模型之后，我们可以对物理模型进行设计，双击物理模型的关系，可以对该关系的名称、注释等信息进行查询。可对该关系的屆性列进行设计，可分别设置其名称、码、数据类型以及主码、是否为空等。在实际设计中最常用的存取方法是紫引发，使用紫引可以大大减少数据的查询时间，在建立紫引时应遊福：在经常需要搜紫的列上建立紫引：在主关键字上建立紫升；在经常用于连接的列上建立索引，即在外键上建立索引：在经常需要根据范围进行搜索的列上创建索列，因为索引己经排序，其指定的范围是连续的等规则。才能充分利用索引的作用避免因索引引起的负面
作用。

4.3、确定数据库的存储结构

创建用户表：

CREATE TABLE [dbo].[usertable](
	[userid] [varchar](10) NOT NULL,
	[password] [varchar](16) NOT NULL,
	[name] [varchar](10) NOT NULL,
	[power] [int] NOT NULL,
 CONSTRAINT [PK_user] PRIMARY KEY CLUSTERED 
(
	[userid] ASC
)WITH (PAD_INDEX = OFF, STATISTICS_NORECOMPUTE = OFF, IGNORE_DUP_KEY = OFF, ALLOW_ROW_LOCKS = ON, ALLOW_PAGE_LOCKS = ON, OPTIMIZE_FOR_SEQUENTIAL_KEY = OFF) ON [PRIMARY]
) ON [PRIMARY]
GO
ALTER TABLE [dbo].[usertable]  WITH CHECK ADD  CONSTRAINT [CK_usertable] CHECK  (([power]=(1) OR [power]=(0)))
GO
ALTER TABLE [dbo].[usertable] CHECK CONSTRAINT [CK_usertable]
GO
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

创建题库表：

CREATE TABLE [dbo].[title](
		[topicid] [int] IDENTITY(1,1) NOT NULL,
		[topic] [varchar](800) NOT NULL,
		[A] [varchar](800) NOT NULL,
		[B] [varchar](800) NOT NULL,
		[C] [varchar](800) NOT NULL,
		[D] [varchar](800) NOT NULL,
		[E] [varchar](800) NULL,
		[type] [char](6) NOT NULL,
		[value] [varchar](5) NOT NULL,
		[userid] [varchar](10) NULL,
 CONSTRAINT [PK_title] PRIMARY KEY CLUSTERED 
(
		[topicid] ASC
)WITH (PAD_INDEX = OFF, STATISTICS_NORECOMPUTE = OFF, IGNORE_DUP_KEY = OFF, ALLOW_ROW_LOCKS = ON, ALLOW_PAGE_LOCKS = ON, OPTIMIZE_FOR_SEQUENTIAL_KEY = OFF) ON [PRIMARY]
) ON [PRIMARY]
GO
ALTER TABLE [dbo].[title]  WITH CHECK ADD  CONSTRAINT [FK_title_title] FOREIGN KEY([topicid])
REFERENCES [dbo].[title] ([topicid])
GO
ALTER TABLE [dbo].[title] CHECK CONSTRAINT [FK_title_title]
GO
ALTER TABLE [dbo].[title]  WITH CHECK ADD  CONSTRAINT [FK_title_title1] FOREIGN KEY([topicid])
REFERENCES [dbo].[title] ([topicid])
GO
ALTER TABLE [dbo].[title] CHECK CONSTRAINT [FK_title_title1]
GO

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

创建错题表：

CREATE TABLE [dbo].[error](
	[errorid] [int] IDENTITY(1,1) NOT NULL,
	[userid] [varchar](10) NOT NULL,
	[topicid] [int] NOT NULL,
	[errortime] [date] NOT NULL,
 CONSTRAINT [PK_error] PRIMARY KEY CLUSTERED 
(
	[errorid] ASC
)WITH (PAD_INDEX = OFF, STATISTICS_NORECOMPUTE = OFF, IGNORE_DUP_KEY = OFF, ALLOW_ROW_LOCKS = ON, ALLOW_PAGE_LOCKS = ON, OPTIMIZE_FOR_SEQUENTIAL_KEY = OFF) ON [PRIMARY]
) ON [PRIMARY]
GO
ALTER TABLE [dbo].[error]  WITH CHECK ADD  CONSTRAINT [FK_error_title] FOREIGN KEY([topicid])
REFERENCES [dbo].[title] ([topicid])
GO
ALTER TABLE [dbo].[error] CHECK CONSTRAINT [FK_error_title]
GO

ALTER TABLE [dbo].[error]  WITH CHECK ADD  CONSTRAINT [FK_error_usertable] FOREIGN KEY([userid])
REFERENCES [dbo].[usertable] ([userid])
GO
ALTER TABLE [dbo].[error] CHECK CONSTRAINT [FK_error_usertable]
GO

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

5、数据库的实施与维护

此阶段主要任务包括创建数据库，加载初始数据，数据库试运行，数据库的安全性和完整性控制数据库的备份与恢复，数据库性能的监督分析和改仅，数据库的重组和重构等。首先在数据库中建立一个学生成绩管理系统数据库,然后新建一个数据源。主要代码如下:

	import java.sql.*;
	import java.util.ArrayList;
	import java.util.List;
	import java.util.Vector;
	import java.util.concurrent.CopyOnWriteArrayList;
	
	public class ConnectSQLserver {
	    public ConnectSQLserver( ) {
	        String url = "jdbc:sqlserver://127.0.0.1:1433;databaseName=exam;user=sa;password=123";//sa身份连接
	        Connection con = null;  //会话连接
	        try {
	            //1-注册驱动器,驱动管理器类加载SQLServerDriver类的静态方法，如果没有添加这个驱动，则创建这个驱动
	            Class.forName("com.microsoft.sqlserver.jdbc.SQLServerDriver");
	            System.out.println("驱动加载成功！");
	            //2-与数据源获得连接
	            con = DriverManager.getConnection(url);
	            System.out.println("数据库连接成功！");
	        } catch (Exception e) {
	            e.printStackTrace();
	        } finally {
	            try {
	                con.close();
	            } catch (SQLException throwables) {
	                throwables.printStackTrace();
	            }
	
	        }
	    }
	
	    public User login( String userid, String password ) {
	        User user = new User();
	        String url = "jdbc:sqlserver://127.0.0.1:1433;databaseName=exam;user=sa;password=123";//sa身份连接
	        Connection con = null;  //会话连接
	        Statement stmt = null;  //用于执行静态SQL语句并返回其生成的结果的对象。
	        ResultSet rs = null;  //数据库结果集的数据表
	        try {
	            //1-注册驱动器,驱动管理器类加载SQLServerDriver类的静态方法，如果没有添加这个驱动，则创建这个驱动
	            Class.forName("com.microsoft.sqlserver.jdbc.SQLServerDriver");
	            System.out.println("驱动加载成功！");
	            //2-与数据源获得连接
	            con = DriverManager.getConnection(url);
	            System.out.println("数据库连接成功！");
	            //3-创建一个Statement对象，用于将SQL语句发送到数据库
	            stmt = con.createStatement();
	            //4- SQL语句
	            String SQL = "SELECT  name,power FROM usertable where userid="
	                    + "'" + userid + "'and password=" + "'" + password + "'";
	            //5-执行SQL,返回数据
	            rs = stmt.executeQuery(SQL);
	            //6-遍历
	            if (rs.next()) {
	                user.setUserid(rs.getString("name"));
	                user.setPower(rs.getString("power"));
	            }
	        } catch (Exception e) {
	            e.printStackTrace();
	        } finally {
	            if (rs != null)
	                try {
	                    rs.close();
	                } catch (Exception e) {
	                }
	            if (stmt != null)
	                try {
	                    stmt.close();
	                } catch (Exception e) {
	                }
	            if (con != null)
	                try {
	                    con.close();
	                } catch (Exception e) {
	                }
	            return user;
	        }
	    }
	
	    public int addexam( String topic, String A, String B, String C, String D, String E, String type, String value ,String userid) {
	        User user = new User();
	        String url = "jdbc:sqlserver://127.0.0.1:1433;databaseName=exam;user=sa;password=123";//sa身份连接
	        Connection con = null;  //会话连接
	        Statement stmt = null;  //用于执行静态SQL语句并返回其生成的结果的对象。
	        int rs = 0;  //数据执行结果
	        try {
	            //1-注册驱动器,驱动管理器类加载SQLServerDriver类的静态方法，如果没有添加这个驱动，则创建这个驱动
	            Class.forName("com.microsoft.sqlserver.jdbc.SQLServerDriver");
	            System.out.println("驱动加载成功！");
	            //2-与数据源获得连接
	            con = DriverManager.getConnection(url);
	            System.out.println("数据库连接成功！");
	            //3-创建一个Statement对象，用于将SQL语句发送到数据库
	            stmt = con.createStatement();
	            //4- SQL语句
	            String SQL = "insert into title values('" + topic + "','" + A + "','" + B + "','" +
	                    C + "','" + D + "','" + E + "','" + type + "','" + value + "','" +userid+"')";
	            //5-执行SQL,返回数据
	            System.out.println(SQL);
	            rs = stmt.executeUpdate(SQL);
	        } catch (Exception e) {
	            e.printStackTrace();
	        } finally {
	            if (stmt != null)
	                try {
	                    stmt.close();
	                } catch (Exception e) {
	                }
	            if (con != null)
	                try {
	                    con.close();
	                } catch (Exception e) {
	                }
	            return rs;
	        }
	    }
	
	    public Vector[] delExam( ) {
	        String url = "jdbc:sqlserver://127.0.0.1:1433;databaseName=exam;user=sa;password=123";//sa身份连接
	        Connection con = null;  //会话连接
	        Statement stmt = null;  //用于执行静态SQL语句并返回其生成的结果的对象。
	        ResultSet rs = null;  //数据执行结果
	        Vector rowData, columnNames;
	        columnNames = new Vector();
	        columnNames.add("题目编号");
	        columnNames.add("题目");
	        rowData = new Vector();
	        try {
	            //1-注册驱动器,驱动管理器类加载SQLServerDriver类的静态方法，如果没有添加这个驱动，则创建这个驱动
	            Class.forName("com.microsoft.sqlserver.jdbc.SQLServerDriver");
	            System.out.println("驱动加载成功！");
	            //2-与数据源获得连接
	            con = DriverManager.getConnection(url);
	            System.out.println("数据库连接成功！");
	            //3-创建一个Statement对象，用于将SQL语句发送到数据库
	            stmt = con.createStatement();
	            //4- SQL语句
	            String SQL = "select topicid,topic from title";
	            //5-执行SQL,返回数据
	            rs = stmt.executeQuery(SQL);
	            while (rs.next()) {
	                Vector hang = new Vector();
	                hang.add(rs.getString(1));
	                hang.add(rs.getString(2));
	                rowData.add(hang.clone());
	            }
	        } catch (Exception e) {
	            e.printStackTrace();
	        } finally {
	            if (rs != null)
	                try {
	                    rs.close();
	                } catch (Exception e) {
	                }
	            if (stmt != null)
	                try {
	                    stmt.close();
	                } catch (Exception e) {
	                }
	            if (con != null)
	                try {
	                    con.close();
	                } catch (Exception e) {
	                }
	            Vector[] vectors = {rowData, columnNames};
	            return vectors;
	        }
	    }
	
	    public int bDelExam( int i ) {
	        String url = "jdbc:sqlserver://127.0.0.1:1433;databaseName=exam;user=sa;password=123";//sa身份连接
	        Connection con = null;  //会话连接
	        Statement stmt = null;  //用于执行静态SQL语句并返回其生成的结果的对象。
	        int rs = 0;  //数据执行结果
	        try {
	            //1-注册驱动器,驱动管理器类加载SQLServerDriver类的静态方法，如果没有添加这个驱动，则创建这个驱动
	            Class.forName("com.microsoft.sqlserver.jdbc.SQLServerDriver");
	            System.out.println("驱动加载成功！");
	            //2-与数据源获得连接
	            con = DriverManager.getConnection(url);
	            System.out.println("数据库连接成功！");
	            //3-创建一个Statement对象，用于将SQL语句发送到数据库
	            stmt = con.createStatement();
	            //4- SQL语句
	            String SQL0 = "delete from title where topicid=" + i;
	            String SQL1 = "delete from error where topicid=" + i;
	            //5-执行SQL,返回数据
	            System.out.println(SQL1);
	            stmt.executeUpdate(SQL1);
	            rs = stmt.executeUpdate(SQL0);
	        } catch (Exception e) {
	            e.printStackTrace();
	        } finally {
	            if (stmt != null)
	                try {
	                    stmt.close();
	                } catch (Exception e) {
	                }
	            if (con != null)
	                try {
	                    con.close();
	                } catch (Exception e) {
	                }
	            return rs;
	        }
	    }
	
	    public int bAltExam( int i ) {
	        String url = "jdbc:sqlserver://127.0.0.1:1433;databaseName=exam;user=sa;password=123";//sa身份连接
	        Connection con = null;  //会话连接
	        Statement stmt = null;  //用于执行静态SQL语句并返回其生成的结果的对象。
	        ResultSet rs = null;  //数据执行结果
	        int rs1 = 0;
	        try {
	            //1-注册驱动器,驱动管理器类加载SQLServerDriver类的静态方法，如果没有添加这个驱动，则创建这个驱动
	            Class.forName("com.microsoft.sqlserver.jdbc.SQLServerDriver");
	            System.out.println("驱动加载成功！");
	            //2-与数据源获得连接
	            con = DriverManager.getConnection(url);
	            System.out.println("数据库连接成功！");
	            //3-创建一个Statement对象，用于将SQL语句发送到数据库
	            stmt = con.createStatement();
	            //4- SQL语句
	            String SQL = "select topicid from title where topicid=" + i;
	            //5-执行SQL,返回数据
	            rs = stmt.executeQuery(SQL);
	            while (rs.next()) {
	                rs1 = new Integer(rs.getInt(1));
	            }
	        } catch (Exception e) {
	            e.printStackTrace();
	        } finally {
	            if (rs != null) {
	                try {
	                    rs.close();
	                } catch (Exception e) {
	                }
	            }
	            if (stmt != null)
	                try {
	                    stmt.close();
	                } catch (Exception e) {
	                }
	            if (con != null)
	                try {
	                    con.close();
	                } catch (Exception e) {
	                }
	            return rs1;
	        }
	    }
	
	    public int setExam( int topicid, String topic, String A, String B, String C, String D, String E, String type, String value ) {
	        User user = new User();
	        String url = "jdbc:sqlserver://127.0.0.1:1433;databaseName=exam;user=sa;password=123";//sa身份连接
	        Connection con = null;  //会话连接
	        Statement stmt = null;  //用于执行静态SQL语句并返回其生成的结果的对象。
	        int rs = 0;  //数据执行结果
	        try {
	            //1-注册驱动器,驱动管理器类加载SQLServerDriver类的静态方法，如果没有添加这个驱动，则创建这个驱动
	            Class.forName("com.microsoft.sqlserver.jdbc.SQLServerDriver");
	            System.out.println("驱动加载成功！");
	            //2-与数据源获得连接
	            con = DriverManager.getConnection(url);
	            System.out.println("数据库连接成功！");
	            //3-创建一个Statement对象，用于将SQL语句发送到数据库
	            stmt = con.createStatement();
	            //4- SQL语句
	            String SQL = "update title set topic='" + topic + "',A='" + A + "',B='" + B + "',C='" +
	                    C + "',D='" + D + "',E='" + E + "',type='" + type + "',value='" + value + "'" + "where topicid=" + topicid;
	            //5-执行SQL,返回数据
	            System.out.println(SQL);
	            rs = stmt.executeUpdate(SQL);
	        } catch (Exception e) {
	            e.printStackTrace();
	        } finally {
	            if (stmt != null)
	                try {
	                    stmt.close();
	                } catch (Exception e) {
	                }
	            if (con != null)
	                try {
	                    con.close();
	                } catch (Exception e) {
	                }
	            return rs;
	        }
	    }
	
	    public int addUser( String userid, String password, String name, int power ) {
	        String url = "jdbc:sqlserver://127.0.0.1:1433;databaseName=exam;user=sa;password=123";//sa身份连接
	        Connection con = null;  //会话连接
	        Statement stmt = null;  //用于执行静态SQL语句并返回其生成的结果的对象。
	        int rs = 0;  //数据执行结果
	        try {
	            //1-注册驱动器,驱动管理器类加载SQLServerDriver类的静态方法，如果没有添加这个驱动，则创建这个驱动
	            Class.forName("com.microsoft.sqlserver.jdbc.SQLServerDriver");
	            System.out.println("驱动加载成功！");
	            //2-与数据源获得连接
	            con = DriverManager.getConnection(url);
	            System.out.println("数据库连接成功！");
	            //3-创建一个Statement对象，用于将SQL语句发送到数据库
	            stmt = con.createStatement();
	            //4- SQL语句
	            String SQL = "insert into usertable(userid,password,name,power) " +
	                    "values('" + userid + "','" + password + "','" + name + "'," +
	                    power  + ")";
	            //5-执行SQL,返回数据
	            System.out.println(SQL);
	            rs = stmt.executeUpdate(SQL);
	        } catch (Exception e) {
	            e.printStackTrace();
	        } finally {
	            if (stmt != null)
	                try {
	                    stmt.close();
	                } catch (Exception e) {
	                }
	            if (con != null)
	                try {
	                    con.close();
	                } catch (Exception e) {
	                }
	            return rs;
	        }
	    }
	
	    public Vector[] delUser( ) {
	        String url = "jdbc:sqlserver://127.0.0.1:1433;databaseName=exam;user=sa;password=123";//sa身份连接
	        Connection con = null;  //会话连接
	        Statement stmt = null;  //用于执行静态SQL语句并返回其生成的结果的对象。
	        ResultSet rs = null;  //数据执行结果
	        Vector rowData, columnNames;
	        columnNames = new Vector();
	        columnNames.add("用户账户");
	        columnNames.add("用户姓名");
	        columnNames.add("权限");
	        rowData = new Vector();
	        try {
	            //1-注册驱动器,驱动管理器类加载SQLServerDriver类的静态方法，如果没有添加这个驱动，则创建这个驱动
	            Class.forName("com.microsoft.sqlserver.jdbc.SQLServerDriver");
	            System.out.println("驱动加载成功！");
	            //2-与数据源获得连接
	            con = DriverManager.getConnection(url);
	            System.out.println("数据库连接成功！");
	            //3-创建一个Statement对象，用于将SQL语句发送到数据库
	            stmt = con.createStatement();
	            //4- SQL语句
	            String SQL = "select userid,name,power from usertable";
	            //5-执行SQL,返回数据
	            rs = stmt.executeQuery(SQL);
	            while (rs.next()) {
	                Vector hang = new Vector();
	                hang.add(rs.getString(1));
	                hang.add(rs.getString(2));
	                hang.add(rs.getString(3));
	                rowData.add(hang.clone());
	            }
	        } catch (Exception e) {
	            e.printStackTrace();
	        } finally {
	            if (rs != null)
	                try {
	                    rs.close();
	                } catch (Exception e) {
	                }
	            if (stmt != null)
	                try {
	                    stmt.close();
	                } catch (Exception e) {
	                }
	            if (con != null)
	                try {
	                    con.close();
	                } catch (Exception e) {
	                }
	            Vector[] vectors = {rowData, columnNames};
	            return vectors;
	        }
	    }
	

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380

5.2、部分操作截图

下面显示了登录系统进行查询的临时界面：
下面显示了添加题库插入临时界面：
下面显示了添加用户临时插入界面：
下面显示了删除题库界面：
下面显示了做题，查询界面：

6、源码获取地址

考试系统源码

相关阅读:
0110闭区间上连续函数的性质-函数与极限-高等数学
 基于CNTK/C#实现逻辑回归【附源码】
二叉树 | 递归遍历 | leecode刷题笔记
 SpringMVC-拦截器概念及入门案例
 其实 Gradle Transform 就是个纸老虎 —— Gradle 系列(4)
QT+OSG/osgEarth编译之五十：osgTerrain+Qt编译（一套代码、一套框架，跨平台编译，版本：OSG-3.6.5工具库osgTerrain）
序列化进阶2-常见序列化框架
 MySQL：事务1（锁与隔离级别）
Java设计模式（二）创建型设计模式
 Antv/G2 自定义tooltip鼠标悬浮提示信息
原文地址：https://blog.csdn.net/qq_45042462/article/details/125466275