AI 助理
文档备案控制台
开发者社区 数据库 文章 正文

[Java Web]JDBC综合实践-＞Java操作MySQL数据库（二）

2023-08-07 197
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
本文涉及的产品
RDS MySQL DuckDB 分析主实例，集群系列 4核8GB
RDS AI 助手，专业版
RDS MySQL DuckDB 分析主实例，基础系列 4核8GB
简介： [Java Web]JDBC综合实践-＞Java操作MySQL数据库（二）

4.2、com.sql

4.2.1、information

编写src下的com.sql.information实体类，该实体类为一个标准JavaBeen格式。

总共六个参数，分别对应数据库中information表中六列数据。

1. package com.sql;
2. 
3. public class information {
4. private int id;
5. private String brand;
6. private String company;
7. private int sort;
8. private String description;
9. private int status;
10. 
11. public information() { }
12. 
13. public information(int id, String brand, String company, int sort, String description, int status) {
14. this.id = id;
15. this.brand = brand;
16. this.company = company;
17. this.sort = sort;
18. this.description = description;
19. this.status = status;
20.     }
21. 
22. @Override
23. public String toString() {
24. return "information{" +
25. "id=" + id +
26. ", brand='" + brand + '\'' +
27. ", company='" + company + '\'' +
28. ", sort=" + sort +
29. ", description='" + description + '\'' +
30. ", status=" + status +
31. '}';
32.     }
33. 
34. public int getId() {
35. return id;
36.     }
37. 
38. public void setId(int id) {
39. this.id = id;
40.     }
41. 
42. public String getBrand() {
43. return brand;
44.     }
45. 
46. public void setBrand(String brand) {
47. this.brand = brand;
48.     }
49. 
50. public String getCompany() {
51. return company;
52.     }
53. 
54. public void setCompany(String company) {
55. this.company = company;
56.     }
57. 
58. public int getSort() {
59. return sort;
60.     }
61. 
62. public void setSort(int sort) {
63. this.sort = sort;
64.     }
65. 
66. public String getDescription() {
67. return description;
68.     }
69. 
70. public void setDescription(String description) {
71. this.description = description;
72.     }
73. 
74. public int getStatus() {
75. return status;
76.     }
77. 
78. public void setStatus(int status) {
79. this.status = status;
80.     }
81. }

4.2.2、sqlInitialForMySQL

sqlInitialForMySQL即是在本文目录中的2.2部分提到过的，将JDBC的实现步骤中一些相同的步骤提取出来单独成类来实现，以达到简化代码量的效果。

sqlInitialForMySQL类实现的是，在本文目录中3.5.2部分提到的"改进后的JDBC步骤"中的第三步到第五步-->加载配置文件、获取连接池对象、获取连接：

1. package com.sql;
2. 
3. import com.alibaba.druid.pool.DruidDataSourceFactory;
4. 
5. import javax.sql.DataSource;
6. import java.io.FileInputStream;
7. import java.sql.Connection;
8. import java.util.Properties;
9. 
10. public class sqlInitialForMySQL {
11. public Connection InitialOfOperation() throws Exception {
12. //注册驱动
13. //MySQL 5之后的驱动包，可以省略注册驱动的步骤，
14. //自动加载jar包中META-INF/services/java.sql.Driver文件中的驱动类
15. //获取Connection,加载配置文件(MySQL的url，username，password均在其中)
16. Properties properties = new Properties();
17.         properties.load(new FileInputStream("src/druid.properties"));
18. //获取连接池对象
19. DataSource dataSource = DruidDataSourceFactory.createDataSource(properties);
20. //获取数据库连接
21.         Connection connection;
22.         connection = dataSource.getConnection();
23. return connection;
24.     }
25. 
26. }

最终这个类返回的是Connection对象，方便接着调用或者作参传入。

4.3、com.operation

4.3.1、encapsulationTool

此工具类主要作用是将传进来的六种参数封装成一个information实例对象，方便添加进list集合，使用于selectAll()方法中。

1. package com.operation;
2. 
3. import com.sql.information;
4. 
5. public class encapsulationTool {
6. public information tool(information ifm, int id,String brand,
7.                      String company, int sort, String description,int status){
8.         ifm.setId(id);
9.         ifm.setBrand(brand);
10.         ifm.setCompany(company);
11.         ifm.setSort(sort);
12.         ifm.setDescription(description);
13.         ifm.setStatus(status);
14. return ifm;
15.     }
16. }

4.3.2、🔺operations完整源码

operations操作类中是实现了本次需求的增删改查操作。

在这个类里边使用到了com.sql.sqlInitialForMySQL和com.sql.information两个自己编写的类。

下面是operations的全部实现代码。

1. package com.operation;
2. 
3. import com.sql.sqlInitialForMySQL;
4. import com.sql.information;
5. 
6. import org.junit.Test;
7. 
8. import java.sql.Connection;
9. import java.sql.PreparedStatement;
10. import java.sql.ResultSet;
11. import java.util.ArrayList;
12. import java.util.List;
13. 
14. /**
15.  * JDBC各种操作
16.  */
17. public class operations {
18. public static Connection connection;
19. /**
20.      * 重点
21.      */
22. public encapsulationTool TOOL = new encapsulationTool();
23. 
24. static {//导入写好的类
25. try {
26.             connection = new sqlInitialForMySQL().InitialOfOperation();
27.         } catch (Exception e) {
28.             e.printStackTrace();
29.         }
30.     }
31. 
32. /**
33.      * 查询所有
34.      * 1. SQL：select * from information;
35.      * 2. 参数：不需要
36.      * 3. 结果：List<Brand>
37.      */
38. @Test
39. public void selectAll() throws Exception {
40. //定义SQL
41. String sql = "select * from information";
42. //获取preparedStatement
43. PreparedStatement preparedStatement = connection.prepareStatement(sql);
44. //执行SQL
45. ResultSet resultSet = preparedStatement.executeQuery();
46. //处理结果
47. information information = new information();
48. 
49.         List<information> list = new ArrayList<>();
50. 
51. while (resultSet.next()) {
52. int id = resultSet.getInt("id");
53. String brand = resultSet.getString("brand");
54. String company = resultSet.getString("company");
55. int sort = resultSet.getInt("sort");
56. String description = resultSet.getString("description");
57. int status = resultSet.getInt("status");
58. //封装information对象
59.             information = TOOL.tool(information, id, brand, company, sort, description, status);
60.             list.add(information);
61.             System.out.println(list);
62.         }
63.         resultSet.close();
64.         preparedStatement.close();
65.         connection.close();
66.     }
67. 
68. /**
69.      * 添加数据
70.      * 1. SQL：insert into information(brand_name,company_name,
71.      * ordered, description, status) values(?,?,?,?,?);
72.      * 2. 参数：需要，除了id之外的所有参数信息
73.      * 3. 结果：boolean
74.      */
75. @Test
76. public void insert() throws Exception {
77. String brand = "香飘飘";
78. String company = "香飘飘公司";
79. int sort = 1;
80. String description = "香飘飘是香飘飘食品股份有限公司旗下杯装奶茶品牌，成立于2005年";
81. int status = 1;
82. 
83. String sql = "insert into information(brand,company,sort,description,status) " +
84. "values (?,?,?,?,?)";
85. PreparedStatement preparedStatement = connection.prepareStatement(sql);
86. try (preparedStatement) {
87.             preparedStatement.setString(1, brand);
88.             preparedStatement.setString(2, company);
89.             preparedStatement.setInt(3, sort);
90.             preparedStatement.setString(4, description);
91.             preparedStatement.setInt(5, status);
92.             connection.setAutoCommit(false);
93.             preparedStatement.executeUpdate();
94.             connection.commit();
95.             selectAll();
96.         } catch (Exception e) {
97.             connection.rollback();
98.             e.printStackTrace();
99.         } finally {
100.             connection.close();
101.         }
102. 
103.     }
104. 
105. /**
106.      * 修改数据
107.      * 1. SQL：update information set
108.      * brand_name = ?,company_name= ?,
109.      * ordered  = ?,description = ?,status  = ?
110.      * where id = ?
111.      * 2. 参数：需要，所有数据
112.      * 3. 结果：boolean
113.      */
114. @Test
115. public void update() throws Exception {
116. int id = 4;
117. String brand = "香飘飘";
118. String company = "香飘飘";//作出修改
119. int sort = 1000;//做出修改
120. String description = "绕地球三圈";
121. int status = 1;
122. 
123. String sql = "update information set brand=?,company=?,sort=?,description=?,status=?" +
124. " where id=? ";
125. PreparedStatement preparedStatement = connection.prepareStatement(sql);
126. try (preparedStatement) {
127.             preparedStatement.setString(1, brand);
128.             preparedStatement.setString(2, company);
129.             preparedStatement.setInt(3, sort);
130.             preparedStatement.setString(4, description);
131.             preparedStatement.setInt(5, status);
132.             preparedStatement.setInt(6, id);
133.             connection.setAutoCommit(false);
134.             preparedStatement.executeUpdate();
135.             connection.commit();
136.             selectAll();
137.         } catch (Exception e) {
138.             connection.rollback();
139.             e.printStackTrace();
140.         } finally {
141.             connection.close();
142.         }
143.     }
144. 
145. /**
146.      * 删除数据
147.      * 1. SQL：delete from information where id = ?
148.      * 2. 参数：需要，id
149.      * 3. 结果：boolean
150.      */
151. @Test
152. public void delete() throws Exception {
153. //删除第四条数据"香飘飘"
154. int id = 4;
155. String sql = "delete from information where id = ?";
156. PreparedStatement preparedStatement = connection.prepareStatement(sql);
157. try (preparedStatement) {
158.             preparedStatement.setInt(1, id);
159.             connection.setAutoCommit(false);
160.             preparedStatement.executeUpdate();
161.             connection.commit();
162.             selectAll();
163.         } catch (Exception e) {
164.             connection.rollback();
165.             e.printStackTrace();
166.         } finally {
167.             connection.close();
168.         }
169. 
170. 
171.     }
172. }

在operations中的各个方法，使用了事务管理机制。使用try-with-resource，自动释放资源，在try中设置事务管理，在catch中设置事务回滚，在finally中设置资源释放，避免出现死锁占用资源

在operations类中的开头部分，使用静态代码块加载connection连接，跟随本类一起加载，自始至终只有一个对象，节约了性能

4.3.3、⭐selectAll()

该方法是获取commodity数据库中information表中的信息。

1. /**
2.  * 查询所有
3.  * 1. SQL：select * from information;
4.  * 2. 参数：不需要
5.  * 3. 结果：List<Brand>
6.  */
7. @Test
8. public void selectAll() throws Exception {
9. //定义SQL
10. String sql = "select * from information";
11. //获取preparedStatement
12. PreparedStatement preparedStatement = connection.prepareStatement(sql);
13. //执行SQL
14. ResultSet resultSet = preparedStatement.executeQuery();
15. //处理结果
16. information information = new information();
17. 
18.     List<information> list = new ArrayList<>();
19. 
20. while (resultSet.next()) {
21. int id = resultSet.getInt("id");
22. String brand = resultSet.getString("brand");
23. String company = resultSet.getString("company");
24. int sort = resultSet.getInt("sort");
25. String description = resultSet.getString("description");
26. int status = resultSet.getInt("status");
27. //封装information对象
28.         information = TOOL.tool(information, id, brand, company, sort, description, status);
29.         list.add(information);
30.         System.out.println(list);
31.     }
32.     resultSet.close();
33.     preparedStatement.close();
34.     connection.close();
35. }

4.3.4、insert()

该方法是往commodity数据库中information表中添加信息，可批量添加也可依次添加。

1. /**
2.  * 添加数据
3.  * 1. SQL：insert into information(brand_name,company_name,
4.  * ordered, description, status) values(?,?,?,?,?);
5.  * 2. 参数：需要，除了id之外的所有参数信息
6.  * 3. 结果：boolean
7.  */
8. @Test
9. public void insert() throws Exception {
10. String brand = "香飘飘";
11. String company = "香飘飘公司";
12. int sort = 1;
13. String description = "香飘飘是香飘飘食品股份有限公司旗下杯装奶茶品牌，成立于2005年";
14. int status = 1;
15. 
16. String sql = "insert into information(brand,company,sort,description,status) " +
17. "values (?,?,?,?,?)";
18. PreparedStatement preparedStatement = connection.prepareStatement(sql);
19. try (preparedStatement) {
20.         preparedStatement.setString(1, brand);
21.         preparedStatement.setString(2, company);
22.         preparedStatement.setInt(3, sort);
23.         preparedStatement.setString(4, description);
24.         preparedStatement.setInt(5, status);
25.         connection.setAutoCommit(false);
26.         preparedStatement.executeUpdate();
27.         connection.commit();
28.         selectAll();
29.     } catch (Exception e) {
30.         connection.rollback();
31.         e.printStackTrace();
32.     } finally {
33.         connection.close();
34.     }
35. }

4.3.5、update()

该方法是修改commodity数据库中information表中的信息，以唯一标识id号为限制条件

1. /**
2.  * 修改数据
3.  * 1. SQL：update information set
4.  * brand_name = ?,company_name= ?,
5.  * ordered  = ?,description = ?,status  = ?
6.  * where id = ?
7.  * 2. 参数：需要，所有数据
8.  * 3. 结果：boolean
9.  */
10. @Test
11. public void update() throws Exception {
12. int id = 4;
13. String brand = "香飘飘";
14. String company = "香飘飘";//作出修改
15. int sort = 1000;//做出修改
16. String description = "绕地球三圈";
17. int status = 1;
18. 
19. String sql = "update information set brand=?,company=?,sort=?,description=?,status=?" +
20. " where id=? ";
21. PreparedStatement preparedStatement = connection.prepareStatement(sql);
22. try (preparedStatement) {
23.         preparedStatement.setString(1, brand);
24.         preparedStatement.setString(2, company);
25.         preparedStatement.setInt(3, sort);
26.         preparedStatement.setString(4, description);
27.         preparedStatement.setInt(5, status);
28.         preparedStatement.setInt(6, id);
29.         connection.setAutoCommit(false);
30.         preparedStatement.executeUpdate();
31.         connection.commit();
32.         selectAll();
33.     } catch (Exception e) {
34.         connection.rollback();
35.         e.printStackTrace();
36.     } finally {
37.         connection.close();
38.     }
39. }

4.3.6、delete()

该方法是删除commodity数据库中information表中的信息，以唯一标识id号为限制条件

1. /**
2.  * 删除数据
3.  * 1. SQL：delete from information where id = ?
4.  * 2. 参数：需要，id
5.  * 3. 结果：boolean
6.  */
7. @Test
8. public void delete() throws Exception {
9. //删除第四条数据"香飘飘"
10. int id = 4;
11. String sql = "delete from information where id = ?";
12. PreparedStatement preparedStatement = connection.prepareStatement(sql);
13. try (preparedStatement) {
14.         preparedStatement.setInt(1, id);
15.         connection.setAutoCommit(false);
16.         preparedStatement.executeUpdate();
17.         connection.commit();
18.         selectAll();
19.     } catch (Exception e) {
20.         connection.rollback();
21.         e.printStackTrace();
22.     } finally {
23.         connection.close();
24.     }
25. }

5、注意事项

5.1、空指针

关于自己编写的封装工具类TOOL的使用，一开始写的是：

public encapsulationTool TOOL;

即只声明了对象，但是没有初始化，此时调用Tool.tool会报空指针异常，初始化Tool对象后则解决：

5.2、🔺🔺包名格式异常

在创建包的时候，出现了如下的现象：

即：com.operation.selectAll本来应该创建的是一个在二级包下的Java类selectAll，但是这个地方却出现了三级包名，并未创建Java类。

解决方法：

       将此处的Compact Middle Packages取消勾选，即可解决。



文章标签：
云数据库 RDS MySQL 版
Java
关系型数据库
MySQL
数据库
数据库连接
关键词：
Java Web
web数据库
实践数据库
Java MYSQL
Java实践
相关实践学习
每个IT人都想学的“Web应用上云经典架构”实战
本实验从Web应用上云这个最基本的、最普遍的需求出发，帮助IT从业者们通过“阿里云Web应用上云解决方案”，了解一个企业级Web应用上云的常见架构，了解如何构建一个高可用、可扩展的企业级应用架构。
MySQL数据库入门学习
本课程通过最流行的开源数据库MySQL带你了解数据库的世界。 &nbsp; 相关的阿里云产品：云数据库RDS MySQL 版 阿里云关系型数据库RDS（Relational Database Service）是一种稳定可靠、可弹性伸缩的在线数据库服务，提供容灾、备份、恢复、迁移等方面的全套解决方案，彻底解决数据库运维的烦恼。 了解产品详情:&nbsp;https://www.aliyun.com/product/rds/mysql&nbsp;
aly逐梦苍穹
目录
相关文章
霍格沃兹测试开发学社
|
4月前
|
存储 人工智能 NoSQL
AI大模型应用实践 八：如何通过RAG数据库实现大模型的私有化定制与优化
RAG技术通过融合外部知识库与大模型，实现知识动态更新与私有化定制，解决大模型知识固化、幻觉及数据安全难题。本文详解RAG原理、数据库选型（向量库、图库、知识图谱、混合架构）及应用场景，助力企业高效构建安全、可解释的智能系统。
霍格沃兹测试开发学社
1029 2
7u23muuk6qtpg
|
5月前
|
存储 弹性计算 Cloud Native
云原生数据库的演进与应用实践
随着企业业务扩展，传统数据库难以应对高并发与弹性需求。云原生数据库应运而生，具备计算存储分离、弹性伸缩、高可用等核心特性，广泛应用于电商、金融、物联网等场景。阿里云PolarDB、Lindorm等产品已形成完善生态，助力企业高效处理数据。未来，AI驱动、Serverless与多云兼容将推动其进一步发展。
7u23muuk6qtpg
271 8
DatabaseEvangelist
|
7月前
|
人工智能 运维 数据挖掘
瑶池数据库Data+AI驱动的全栈智能实践开放日回顾
阿里云瑶池数据库重磅推出“Data+AI能力家族”，包括DTS AI数据准备、Data Agent系列智能体及DMS MCP统一数据访问服务，重构数据与AI协同边界。通过智能化工具链，覆盖数据全生命周期，提升企业数据开发、分析、治理与运维效率，降低技术门槛，激活数据资产价值，助力企业迈向全栈智能新时代。
DatabaseEvangelist
315 4
阿里云瑶池数据库_
|
8月前
|
人工智能 运维 数据挖掘
瑶池数据库开放日：全新发布Data+AI能力家族，赋能企业全栈智能实践
近日，阿里云瑶池数据库生态工具产品重磅升级，推出“Data+AI能力家族”，并举办了为期3天的全栈智能实践开放日活动。发布会上首次公开了 “Data Agent for Analytics、Data Agent for Meta、DAS Agent”等瑶池数据库Data Agent系列能力，以工具智能化 × 智能化工具的双引擎重构数据与AI的协同边界，揭秘AI时代数据价值释放的全新路径。
阿里云瑶池数据库_
519 0
青云交（Java大数据AI云原生Python）
|
9月前
|
负载均衡 算法 关系型数据库
大数据大厂之MySQL数据库课程设计：揭秘MySQL集群架构负载均衡核心算法：从理论到Java代码实战，让你的数据库性能飙升！
本文聚焦 MySQL 集群架构中的负载均衡算法，阐述其重要性。详细介绍轮询、加权轮询、最少连接、加权最少连接、随机、源地址哈希等常用算法，分析各自优缺点及适用场景。并提供 Java 语言代码实现示例，助力直观理解。文章结构清晰，语言通俗易懂，对理解和应用负载均衡算法具有实用价值和参考价值。
青云交（Java大数据AI云原生Python）
503 14
大数据大厂之MySQL数据库课程设计：揭秘MySQL集群架构负载均衡核心算法：从理论到Java代码实战，让你的数据库性能飙升！
哈你真皮
|
10月前
|
Java 关系型数据库 MySQL
Java汽车租赁系统源码(含数据库脚本)
Java汽车租赁系统源码(含数据库脚本)
哈你真皮
301 4
蓝易云
|
10月前
|
NoSQL Java API
在Java环境下如何进行Redis数据库的操作
总的来说，使用Jedis在Java环境下进行Redis数据库的操作，是一种简单而高效的方法。只需要几行代码，就可以实现复杂的数据操作。同时，Jedis的API设计得非常直观，即使是初学者，也可以快速上手。
蓝易云
422 94
阿里云云原生
|
11月前
|
人工智能 前端开发 JavaScript
代码采纳率从 22% 到 33%，通义灵码辅助数据库智能编码实践
通义灵码本质上是一个AI agent，它已经进行了大量的优化。然而，为了更完美或有效地调用模型的潜在能力，我们在使用时仍需掌握一些技巧。通常，大多数人在使用通义灵码时会直接上手，这是 AI agent 的一个优势，即 zero shot 使用，无需任何上下文即可直接使用通义灵码的能力。
阿里云云原生
400 2
游客kufrkwrbkmpsa
|
11月前
|
数据库
【YashanDB数据库】Yashandb表闪回业务表实践
Yashandb表闪回业务表实践
游客kufrkwrbkmpsa
159 0

热门文章

最新文章

  • 1
    阿里云DTS踩坑经验分享系列｜如何使用DTS进行MySQL->ClickHouse同步
  • 2
    MySQL · 引擎特性 · InnoDB 大字段压缩
  • 3
    MySQL表连接（内连接、交叉连接、外连接、联合查询）
  • 4
    大数据 | （五）通过Sqoop实现从MySQL导入数据到HDFS
  • 5
    浅析MySQL优化器统计信息
  • 6
    断电了，MySQL也不会丢失数据
  • 7
    一分钟安装mysql
  • 8
    mysql用户授权与权限撤销
  • 9
    MySQL之备份和还原
  • 10
    安装MySQL5.1.24
  • 1
    Java 核心知识与技术全景解析
    160
  • 2
    Java 17 及以上版本核心特性在现代开发实践中的深度应用与高效实践方法 Java 开发实践
    334
  • 3
    Java 核心知识点与实战应用解析
    141
  • 4
    Java 基础知识点全面梳理包含核心要点及难点解析 Java 基础知识点
    300
  • 5
    Java泛型类型擦除以及类型擦除带来的问题
    230
  • 6
    Java 17 新特性与微服务开发的实操指南
    357
  • 7
    从基础语法到实战应用的 Java 入门必备知识全解析
    176
  • 8
    解决java.lang.IllegalArgumentException: Invalid uri由无效查询引起的问题
    888
  • 9
    Java 基础篇完整学习攻略
    135
  • 10
    Java int和Integer的区别
    258

    • 相关课程

    更多
  • 数据库的前世今生
  • 数据库核心概念
  • 从传统数据库到云数据库演进
  • 数据库常见问题排查
  • 数据库及SQL/MySQL基础
  • 高校精品课-西安交通大学 -数据库理论与技术

    • 相关电子书

    更多
  • 开源数据库工作室推广计划
  • 国产数据库研制人才培养实践
  • 阿里云&信通院《Serverless数据库技术研究报告》

    • 推荐镜像

    更多
  • mysql
    • 下一篇
    第五届伏魔挑战赛如约来袭，诚邀各路高手来战！