Java入坑之 数据库编程

r囧r小猫 2024-04-17 11:48 123阅读 0赞

一、基础概念

1.1JDBC 步骤

  1. 导入驱动jar包
  2. 注册驱动
  3. 获取数据库连接对象 Connection
  4. DataSource dSource;
  5. dSource.getConnection();
  6. 定义sql语句
  7. String sql = "update account set balance = 500 where id = 1";
  8. 获取执行sql语句的对象 Statement
  9. PreparedStatement stmt = conn. prepareStatement(sql)；
  10. 执行sql，接受返回结果
  11.  int count = stmt.executeUpdate(sql);
  12. 处理结果 System.out.println(count);
  13. 释放资源  stmt.close(); conn.close();

1c7382ce42f44bef818f648ff820fdc3.png

1.2相关类介绍

7c5b2229fdf64e5f90fa712214604738.png

1.3相关代码

022447da47b74c12824cfc17246ce2e7.png

在Maven中声明MySQL的JDBC实现依赖

0b78545b38854b838b9c52ffee35e572.png

1.3.1查询

  1. package org.example;
  3. import java.sql.Connection;
  4. import java.sql.DriverManager;
  5. import java.sql.ResultSet;
  6. import java.sql.SQLException;
  7. import java.sql.Statement;
  9. public class SelectTest {
  10.     public static void main(String[] args) {
  11.         // 注册 MySQL 驱动
  12.         try {
  13.             Class.forName("com.mysql.cj.jdbc.Driver");
  14.             System.out.println("注册驱动成功!");
  15.         } catch (ClassNotFoundException e1) {
  16.             System.out.println("注册驱动失败!");
  17.             e1.printStackTrace();
  18.             return;
  19.         }
  21.         String url = "jdbc:mysql://localhost:3306/t_book?serverTimezone=UTC";
  22.         Connection conn = null;
  23.         try {
  24.             // 构建 Java 和数据库之间的桥梁：URL，用户名，密码
  25.             conn = DriverManager.getConnection(url, "root", "b123456");
  26.             System.out.println("连接数据库成功！");
  28.             // 构建数据库执行者
  29.             Statement stmt = conn.createStatement();
  30.             System.out.println("创建 Statement 成功！");
  32.             // 执行 SQL 语句并返回结果到 ResultSet
  33.             ResultSet rs = stmt.executeQuery("select bookid, bookname, price from book order by bookid");
  35.             // 开始遍历 ResultSet 数据
  36.             while (rs.next()) {
  37.                 System.out.println(rs.getInt(1) + "," + rs.getString(2) + "," + rs.getInt("price"));
  38.             }
  40.             rs.close();
  41.             stmt.close();
  42.         } catch (SQLException e) {
  43.             e.printStackTrace();
  44.         } finally {
  45.             try {
  46.                 if (conn != null) {
  47.                     conn.close();
  48.                     System.out.println("关闭数据库连接成功！");
  49.                 }
  50.             } catch (SQLException e) {
  51.                 e.printStackTrace();
  52.             }
  53.         }
  54.     }
  55. }

1.3.2增删改

  1. package org.example;
  3. import java.sql.*;
  5. public class UpdateTest {
  6.     public static void main(String[] args) {
  7.         executeUpdate("update book set price = 300 where bookid = 1");
  8.         executeUpdate("insert into book(bookid, bookname, price) values(4, '编译原理', 90)");
  9.         executeUpdate("delete from book where bookid = 4");
  10.     }
  12.     /**
  13.      * 执行数据更新操作
  14.      * @param sql 要执行的 SQL 语句
  15.      */
  16.     public static void executeUpdate(String sql) {
  17.         // 注册 MySQL 驱动
  18.         try {
  19.             Class.forName("com.mysql.cj.jdbc.Driver");
  20.             System.out.println("注册驱动成功!");
  21.         } catch (ClassNotFoundException e1) {
  22.             System.out.println("注册驱动失败!");
  23.             e1.printStackTrace();
  24.         }
  26.         String url = "jdbc:mysql://localhost:3306/t_book?serverTimezone=UTC";
  27.         Connection conn = null;
  28.         try {
  29.             // 构建 Java 和数据库之间的桥梁：URL，用户名，密码
  30.             conn = DriverManager.getConnection(url, "root", "b123456");
  31.             System.out.println("连接数据库成功！");
  33.             // 构建数据库执行者
  34.             Statement stmt = conn.createStatement();
  35.             System.out.println("创建 Statement 成功！");
  36.             int rs = stmt.executeUpdate(sql);
  37.             stmt.close();
  38.         } catch (SQLException e) {
  39.             e.printStackTrace();
  40.         } finally {
  41.             try {
  42.                 if (conn != null) {
  43.                     conn.close();
  44.                     System.out.println("关闭数据库连接成功！");
  45.                 }
  46.             } catch (SQLException e) {
  47.                 e.printStackTrace();
  48.             }
  49.         }
  50.     }
  51. }

1.3.3事务逻辑

74a026cfebac44ddb47a4586925c010d.png

" class="reference-link">052bab90a74f4355b4960b52fae15997.png

  1. package org.example;
  3. import java.sql.*;
  5. public class TransactionTest {
  6.     public static void main(String[] args) throws Exception {
  7.         // 构建Java和数据库之间的桥梁介质
  8.         try {
  9.             Class.forName("com.mysql.cj.jdbc.Driver");
  10.             System.out.println("注册驱动成功!");
  11.         } catch (ClassNotFoundException e1) {
  12.             System.out.println("注册驱动失败!");
  13.             e1.printStackTrace();
  14.         }
  15.         String url = "jdbc:mysql://localhost:3306/t_book?serverTimezone=UTC";
  16.         Connection conn = null;
  17.         try {
  18.             // 构建Java和数据库之间的桥梁：URL，用户名，密码
  19.             conn = DriverManager.getConnection(url, "root", "b123456");
  20.             conn.setAutoCommit(false);
  22.             insertBook(conn, "insert into book values(101, 'aaaa', 10)");
  23.             insertBook(conn, "insert into book values(102, 'bbbb', 10)");
  24.             insertBook(conn, "insert into book values(103, 'cccc', 10)");
  26.             Savepoint phase1 = conn.setSavepoint(); // 设置一个保存点
  28.             insertBook(conn, "insert into book values(104, 'cccc', 10)");
  29.             insertBook(conn, "insert into book values(105, 'cccc', 10)");
  31.             conn.rollback(phase1); // 回滚到phase1保存点，即上面2行无效
  32.             conn.commit();
  34.             System.out.println("操作成功");
  35.         } catch (SQLException e) {
  36.             e.printStackTrace();
  37.             conn.rollback();
  38.         } finally {
  39.             if (null != conn) {
  40.                 conn.close();
  41.             }
  42.         }
  43.     }
  45.     public static void insertBook(Connection conn, String sql) {
  46.         try {
  47.             // 构建数据库执行者
  48.             Statement stmt = conn.createStatement();
  49.             // 执行SQL语句
  50.             int result = stmt.executeUpdate(sql);
  51.             stmt.close();
  52.         } catch (SQLException e) {
  53.             e.printStackTrace();
  54.         }
  55.     }
  56. }

1.3.4拼接字符串

297d3f7d78a74646b8c2fd67e9b8c985.png

98355f83e87f4b89a3c67d4d33b1d491.png

  1. package org.example;
  3. import java.sql.Connection;
  4. import java.sql.DriverManager;
  5. import java.sql.SQLException;
  6. import java.sql.Statement;
  8. public class InsertTest {
  9.     public static void main(String[] a) {
  10.         //concatInsertBook();
  11.         unsafeConcatInsertBook();
  12.     }
  14.     public static void concatInsertBook() {
  15.         // 构建Java和数据库之间的桥梁介质
  16.         try {
  17.             Class.forName("com.mysql.cj.jdbc.Driver");
  18.             System.out.println("注册驱动成功!");
  19.         } catch (ClassNotFoundException e1) {
  20.             System.out.println("注册驱动失败!");
  21.             e1.printStackTrace();
  22.         }
  24.         String url = "jdbc:mysql://localhost:3306/t_book?serverTimezone=UTC";
  25.         Connection conn = null;
  26.         try {
  27.             // 构建Java和数据库之间的桥梁：URL，用户名，密码
  28.             conn = DriverManager.getConnection(url, "root", "b123456");
  29.             // 构建数据库执行者
  30.             Statement stmt = conn.createStatement();
  31.             System.out.println("创建Statement成功！");
  32.             // 执行SQL语句
  33.             int bookid = 11;
  34.             String bookName = "Effective Java";
  35.             int price = 50;
  36.             String sql = "insert into book(bookid,bookname,price) values("
  37.                     + bookid + ", '" + bookName + "', " + price + ")";
  38.             int result = stmt.executeUpdate(sql);
  39.             stmt.close();
  40.             System.out.println("操作成功");
  41.         } catch (SQLException e) {
  42.             e.printStackTrace();
  43.         } finally {
  44.             try {
  45.                 if (conn != null) {
  46.                     conn.close();
  47.                 }
  48.             } catch (SQLException e) {
  49.                 e.printStackTrace();
  50.             }
  51.         }
  52.     }
  54.     public static void unsafeConcatInsertBook() {
  55.         // 构建Java和数据库之间的桥梁介质
  56.         try {
  57.             Class.forName("com.mysql.cj.jdbc.Driver");
  58.             System.out.println("注册驱动成功!");
  59.         } catch (ClassNotFoundException e1) {
  60.             System.out.println("注册驱动失败!");
  61.             e1.printStackTrace();
  62.         }
  64.         String url = "jdbc:mysql://localhost:3306/t_book?serverTimezone=UTC";
  65.         Connection conn = null;
  66.         try {
  67.             // 构建Java和数据库之间的桥梁：URL，用户名，密码
  68.             conn = DriverManager.getConnection(url, "root", "b123456");
  69.             // 构建数据库执行者
  70.             Statement stmt = conn.createStatement();
  71.             System.out.println("创建Statement成功！");
  72.             // 执行SQL语句
  73.             int bookid = 13;
  74.             String bookName = "Effective Java',50);delete from t_book;insert into t_book values(101, 'faked book";
  75.             int price = 50;
  76.             String sql = "insert into book(bookid,bookname,price) values("
  77.                     + bookid + ", '" + bookName + "', " + price + ");";
  78.             System.out.println(sql);
  79.             int result = stmt.executeUpdate(sql);
  80.             stmt.close();
  81.             System.out.println("操作成功");
  82.         } catch (SQLException e) {
  83.             e.printStackTrace();
  84.         } finally {
  85.             try {
  86.                 if (conn != null) {
  87.                     conn.close();
  88.                 }
  89.             } catch (SQLException e) {
  90.                 e.printStackTrace();
  91.             }
  92.         }
  93.     }
  94. }

1.3.5batch函数

  1. package org.example;
  3. import java.sql.*;
  5. public class InsertTest1 {
  6.     public static void main(String[] a) {
  7.         safeInsertBook();
  8.         batchInsertBook();
  9.     }
  11.     public static void safeInsertBook() {
  12.         Connection conn = null;
  13.         try {
  14.             // 注册 MySQL 驱动
  15.             Class.forName("com.mysql.jdbc.Driver");
  16.             System.out.println("注册驱动成功!");
  17.         } catch (ClassNotFoundException e1) {
  18.             System.out.println("注册驱动失败!");
  19.             e1.printStackTrace();
  20.         }
  22.         String url = "jdbc:mysql://localhost:3306/t_book?serverTimezone=UTC";
  23.         try {
  24.             // 构建Java和数据库之间的桥梁：URL，用户名，密码
  25.             conn = DriverManager.getConnection(url, "root", "b123456");
  26.             String sql = "insert into book(bookid,bookname,price) values (?, ?, ?)";
  27.             // 构建数据库执行者
  28.             PreparedStatement pstmt = conn.prepareStatement(sql);
  30.             // 设置参数
  31.             int bookid = 15;
  32.             String bookName = "Effective Java',50);delete from t_book;insert into t_book values(101, 'faked book";
  33.             int price = 50;
  34.             pstmt.setInt(1, bookid);
  35.             pstmt.setString(2, bookName);
  36.             pstmt.setInt(3, price);
  38.             // 执行SQL语句
  39.             int result = pstmt.executeUpdate();
  40.             pstmt.close();
  41.             System.out.println("操作成功");
  42.         } catch (SQLException e) {
  43.             e.printStackTrace();
  44.         } finally {
  45.             try {
  46.                 if (conn != null) {
  47.                     conn.close();
  48.                     System.out.println("关闭数据库连接成功！");
  49.                 }
  50.             } catch (SQLException e) {
  51.                 e.printStackTrace();
  52.             }
  53.         }
  54.     }
  56.     public static void batchInsertBook() {
  57.         Connection conn = null;
  58.         try {
  59.             // 注册 MySQL 驱动
  60.             Class.forName("com.mysql.jdbc.Driver");
  61.             System.out.println("注册驱动成功!");
  62.         } catch (ClassNotFoundException e1) {
  63.             System.out.println("注册驱动失败!");
  64.             e1.printStackTrace();
  65.         }
  67.         String url = "jdbc:mysql://localhost:3306/t_book?serverTimezone=UTC";
  68.         try {
  69.             // 构建Java和数据库之间的桥梁：URL，用户名，密码
  70.             conn = DriverManager.getConnection(url, "root", "b123456");
  71.             String sql = "insert into book(bookid,bookname,price) values (?,?,?)";
  72.             // 构建数据库执行者
  73.             PreparedStatement pstmt = conn.prepareStatement(sql);
  75.             // 设置参数
  76.             String bookName = "aaaaaaaaaaaaaaaa";
  77.             int price;
  79.             // 执行批量插入操作
  80.             for (int i = 210; i < 202; i++) {
  81.                 price = 50;
  82.                 pstmt.setInt(1, i);
  83.                 pstmt.setString(2, bookName);
  84.                 pstmt.setInt(3, price);
  85.                 pstmt.addBatch();
  86.             }
  87.             pstmt.executeBatch();
  88.             pstmt.close();
  89.             System.out.println("操作成功");
  90.         } catch (SQLException e) {
  91.             e.printStackTrace();
  92.         } finally {
  93.             try {
  94.                 if (conn != null) {
  95.                     conn.close();
  96.                     System.out.println("关闭数据库连接成功！");
  97.                 }
  98.             } catch (SQLException e) {
  99.                 e.printStackTrace();
  100.             }
  101.         }
  102.     }
  103. }

如果有大量的sq语句，它们结构相同，仅仅差别在具体数值上，那么可以通过addBatch
方法进行批量操作。这样会提高性能，减少数据库负担。

1.3.6ResultSetMetaData类

b4461c8313a0439cba88cccd6a907f47.png

  1. package org.example;
  3. import java.sql.*;
  5. public class ResultSetMetaDataTest {
  6.     public static void main(String[] args) {
  7.         // 构建Java和数据库之间的桥梁介质
  8.         try {
  9.             Class.forName("com.mysql.cj.jdbc.Driver");
  10.             System.out.println("注册驱动成功!");
  11.         } catch (ClassNotFoundException e1) {
  12.             System.out.println("注册驱动失败!");
  13.             e1.printStackTrace();
  14.             return;
  15.         }
  17.         String url = "jdbc:mysql://localhost:3306/t_book?serverTimezone=UTC";
  18.         Connection conn = null;
  19.         try {
  20.             // 构建Java和数据库之间的桥梁：URL，用户名，密码
  21.             conn = DriverManager.getConnection(url, "root", "b123456");
  22.             // 构建数据库执行者
  23.             Statement stmt = conn.createStatement();
  24.             System.out.println("创建Statement成功！");
  25.             // 执行SQL语句并返回结果到ResultSet
  26.             ResultSet rs = stmt.executeQuery("select bookid, bookname, price from book order by bookid");
  27.             // 获取结果集的元数据
  28.             ResultSetMetaData meta = rs.getMetaData();
  29.             int cols = meta.getColumnCount();
  30.             for (int i = 1; i <= cols; i++) {
  31.                 System.out.println(meta.getColumnName(i) + "," + meta.getColumnTypeName(i));
  32.             }
  33.             rs.close();
  34.             stmt.close();
  35.         } catch (SQLException e) {
  36.             e.printStackTrace();
  37.         } finally {
  38.             try {
  39.                 if (conn != null) {
  40.                     conn.close();
  41.                 }
  42.             } catch (SQLException e) {
  43.                 e.printStackTrace();
  44.             }
  45.         }
  46.     }
  47. }

二、数据库连接池

2.1流程重述

f704166ab8ee4052bfc6f062dfdebe73.png

2.2亨元模式

52e9cad2b8a04842be8bcc3ab5e47f46.png

享元模式, Flyweight Pattern
- 经典23个设计模式的一种，属于结构型模式。
- 一个系统中存在大量的相同的对象，由于这类对象的大量使用，会造成系统内存的耗费，可以使用享元模式来减少系统中对象的数量。

2.3 数据库连接池概念

ec18a43628f74f438052c89cbbc92dfc.png

2.4C3P0连接池

2.4.1配置文件

  1. <!-- https://mvnrepository.com/artifact/com.mchange/c3pθ -->
  2.         <dependency>
  3.             <groupId>com.mchange</groupId>
  4.             <artifactId>c3p0</artifactId>
  5.             <version>0.9.5.2</version>
  6.         </dependency>
  7.         <!-- https://mvnrepository.com/artifact/com.alibaba/druid -->
  8.         <dependency>
  9.             <groupId>com.alibaba</groupId>
  10.             <artifactId>druid</artifactId>
  11.             <version>1.1.10</version>
  12.         </dependency>

2.4.2相关代码

  1. package org.example;
  3. import java.sql.Connection;
  4. import java.sql.ResultSet;
  5. import java.sql.SQLException;
  6. import java.sql.Statement;
  8. public class SelectTest1 {
  9.     public static void main(String[] args) {
  10.         Connection conn = null;
  11.         try {
  12.             // 从c3p0获取数据库连接
  13.             conn = C3p0Factory1.getConnection();
  14.             //conn = C3p0Factory2.getConnection();
  15.             从Druid获取
  16.             conn = DruidFactory1.getConnection();
  17.             //conn = DruidFactory2.getConnection();
  18.             // 构建数据库执行者
  19.             Statement stmt = conn.createStatement();
  20.             System.out.println("创建Statement成功！");
  22.             // 执行SQL语句并返回结果到ResultSet
  23.             ResultSet rs = stmt.executeQuery("select bookid, bookname, price from book order by bookid");
  25.             // 开始遍历ResultSet数据
  26.             while (rs.next()) {
  27.                 System.out.println(rs.getInt(1) + "," + rs.getString(2) + "," + rs.getInt("price"));
  28.             }
  30.             rs.close();
  31.             stmt.close();
  32.         } catch (Exception e) {
  33.             e.printStackTrace();
  34.         } finally {
  35.             try {
  36.                 if (conn != null) {
  37.                     conn.close();
  38.                 }
  39.             } catch (SQLException e) {
  40.                 e.printStackTrace();
  41.             }
  42.         }
  43.     }
  44. }

2.4.3相关配置

" class="reference-link">e7996c92fd55410784f86c44da99efc9.png

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <c3p0-config>
  3.     <default-config>    <!--  默认配答 -->
  4.         <property name="driverClass">com.mysql.jdbc.Driver</property>
  5.         <property name="jdbcUrl">jdbc:mysql://localhost:3306/test</property>
  6.         <property name="user">root</property>
  7.         <property name="password">123456</property>
  8.         <property name="initialPoolSize">5</property>
  9.         <property name="maxPoolSize">20</property>
  10.     </default-config>
  11. </c3p0-config>

4b1277d540134701935dc749f58c73ad.jpeg

  1. package org.example;
  3. import com.mchange.v2.c3p0.ComboPooledDataSource;
  4. import java.sql.Connection;
  6. public class C3p0Factory2 {
  7.     private static ComboPooledDataSource dataSource = null;
  9.     public static void init() throws Exception {
  10.         // 创建 ComboPooledDataSource 实例，会自动加载 c3p0-config.xml 文件的配置
  11.         dataSource = new ComboPooledDataSource();
  12.         // 此时 dataSource 是一个完全配置好的可用连接池 DataSource
  13.     }
  15.     public static Connection getConnection() throws Exception {
  16.         if (null == dataSource) {
  17.             init();
  18.         }
  19.         // 返回从连接池获取的数据库连接
  20.         return dataSource.getConnection();
  21.     }
  22. }

2.4.4 DruidData类

  1. package org.example;
  3. import com.alibaba.druid.pool.DruidDataSource;
  4. import java.sql.Connection;
  6. public class DruidFactory1 {
  7.     private static DruidDataSource dataSource = null;
  9.     public static void init() throws Exception {
  10.         dataSource = new DruidDataSource();
  11.         dataSource.setDriverClassName("com.mysql.jdbc.Driver");
  12.         dataSource.setUsername("root");
  13.         dataSource.setPassword("b123456");
  14.         dataSource.setUrl("jdbc:mysql://localhost:3306/t_book?serverTimezone=UTC");
  15.         dataSource.setInitialSize(5);
  16.         dataSource.setMinIdle(1);
  17.         dataSource.setMaxActive(10);
  18.         // 启用监控统计功能
  19.         dataSource.setFilters("stat");
  20.     }
  22.     public static Connection getConnection() throws Exception {
  23.         if (null == dataSource) {
  24.             init();
  25.         }
  26.         return dataSource.getConnection();
  27.     }
  28. }

2.4.6配置

  1. driverClassName=com.mysql.jdbc.Driver
  2. url=jdbc:mysql://localhost:3306/t_book?serverTimezone=UTC
  3. username=root
  4. password=b123456
  5. filters=stat
  6. initialSize=2
  7. maxActive=300
  8. maxWait=60000
  9. timeBetweenEvictionRunsMillis=60000
  10. minEvictableIdleTimeMillis=300000
  11. validationQuery=SELECT 1
  12. testWhileIdle=true
  13. testOnBorrow=false
  14. testOnReturn=false
  15. poolPreparedStatements=false
  16. maxPoolPreparedStatementPerConnectionSize=200
  18. package org.example;
  20. import com.alibaba.druid.pool.DruidDataSource;
  21. import com.alibaba.druid.pool.DruidDataSourceFactory;
  23. import java.io.InputStream;
  24. import java.sql.Connection;
  25. import java.util.Properties;
  27. public class DruidFactory2 {
  28.     private static DruidDataSource dataSource = null;
  30.     public static void init() throws Exception {
  31.         Properties properties = new Properties();
  32.         // 加载属性文件 druid.properties
  33.         InputStream in = DruidFactory2.class.getClassLoader().getResourceAsStream("druid.properties");
  34.         properties.load(in);
  35.         // 通过属性创建 Druid 数据源
  36.         dataSource = (DruidDataSource) DruidDataSourceFactory.createDataSource(properties);
  37.         in.close();
  38.     }
  40.     public static Connection getConnection() throws Exception {
  41.         if (null == dataSource) {
  42.             init();
  43.         }
  44.         return dataSource.getConnection();
  45.     }
  46. }

三、基于web的数据库开发

3.1配置DataSource

283414d5e47d4961a80c3dc746fe26e3.png

3.2相关类（driverClassName，驱动类）

" class="reference-link">d3f90959eb0e47258e422ab1572d58a8.png

3.3Connection接口" class="reference-link">6a7b47c7e4fb4eb2b21d9ce0cbbd1bba.png3.3Connection接口

java.sql.Connection接口表示与特定数据库的会话。在Connection的上下文中，执行SQL语句并返回结果。Connection接口对于连接到数据库和执行SQL语句至关重要。f2cb8de4f0f6479297a41c52deda6bbe.png

3.4Statement接口

Statement接口是Java执行数据库操作的一个重要接口，用于在已经建立数据库连接的基础上，向数据库发送要执行的SQL语句。Statement接口提供了执行语句和获取结果的基本方法。PreparedStatement接口添加了处理IN参数的方法；而CallableStatement添加了处理OUT参数的方法。

e828a48878724cc49ced7259b5b25dcc.png

3.5PreparedStatement接口

PreparedStatement接口是Java中的一个接口，它是用来执行预编译的SQL语句的。PreparedStatement是Statement的子接口，继承了Statement的所有功能。PreparedStatement接口提供了补充占位符变量的方法

c182b62fa5e04bf2ae82427252c250bc.png

发表评论

表情：
评论列表 （有 0 条评论，123人围观）

还没有评论，来说两句吧...

相关阅读

    相关 java入坑之泛型

    一、泛型入门 1.1基础概念 > Java泛型是JDK 5中引入的一个新特性，它提供了编译时类型安全检测机制，该机制允许程序员在编译时检测到非法的类型 ...

    墨蓝墨蓝/ 0 赞/ 126 阅读

    相关 JAVA入坑之GUI编程

    一、相关概述 > GUI编程是指通过图形化的方式来实现计算机程序的编写，它可以让用户通过鼠标、键盘等设备来操作计算机，而不是通过命令行来输入指令。在Java中，G...

    - 日理万妓- 日理万妓/ 0 赞/ 138 阅读