-
JDBC 连接数据库的四种方式
JDBC 连接数据库的四种方式
每博一文案
师傅说，人这一辈子总有许多遗憾，许多无可奈何。 其实有些事情不用太过执着，放下牵绊你的生活无畏执念，你会收获一个更为广阔的天地。 想开，看开，放开这六个字，就是人生最好的活法。 你给人生设立了很多目标，用没日没夜的加班，工作，不断透支着自己的身体换取成功的筹码， 但是健康的身体一旦失去，就很难再重新回来。你总是强迫自己变成别人喜欢的模样，却忘了问问，自己内心 真正的想法，你总是很在乎别人的看法，因为别人的一句话就胡思乱想，明明自己受了委屈，怕得罪人，而什么 都不敢说。其实你不必太过与计较得失，学会坦然面对，怡然自得，别在做不到的事情为难自己，学会追求 自己真正想要的东西。 人生的道路走得慢一点，稳一点，才能收获沿途更多的风景。学会想开，看开，放开，那些不值得的人与事，你 的人生才能拥有更加珍贵的东西。 —————— 一禅心灵庙语- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
1. JDBC 六步编写步骤
JDBC编程六步骤 ,这是一个十分重要的一个点 ⭐⭐⭐⭐⭐
- 注册驱动 作用：告诉Java程序，即将要连接的是哪个品牌的数据库。就是说明你 要连接的是什么品牌(MySQL,Oracle,SQL Server)的数据库
- 连接数据库 作用：连接上你上一步注册驱动的数据库。表示 JVM 的进程和数据库进程之间的通道打开，这是属于进程之间的通信，注意：使用完之后一定要关闭
- 获取操作数据库操作对象 专门执行SQL语句的对象，注意使用完之后，一定要关闭资源
- 第三步获得的对象，执行SQL语句(DQL,DML…) ,注意在Java中执行SQL语句不要加上分号
;，不然可能报错 - 处理查询结果集 (只有当第四步，执行的是 select 查询结果集的时候，才有这第五步，处理查询结果集)
- 关闭、释放资源：使用完资源之后，一定 要关闭资源（如果连接的资源过多，没有关闭的话，当连接的资源数量达到一定的数量，可能就无法再连接资源了，所以使用完资源，一定要及时关闭，这是一个好习惯）
补充：ODBC(Open Database Connectivity，开放式数据库连接)，是微软在Windows平台下推出的。使用者在程序中只需要调用ODBC API，由 ODBC 驱动程序将调用转换成为对特定的数据库的调用请求。
2. 部署对应驱动
什么是驱动
这里的驱动指的是：不同数据库厂家对 JDBC 接口的实现类的，打包封装成一个以
.jar包。所有的数据库驱动都是以jar包的形式存在的，在 jar 包当中有很多，.class文件，这些class文件就是对 JDBC 接口的实现。注意: 驱动不是 SUN公司提供的，而是各个不同的数据库厂商负责提供的，用于Java程序员连接上他们的数据库，下载驱动的 jar 包需要去数据库官网下载。这里以 MySQL 数据库为例：
2.1 下载驱动
我们需要下载好驱动的 jar 包
- 我们先进入到 MySQL官网：https://dev.mysql.com/downloads/
-
再选择: Platform Independent
-
选择下载对应的zip压缩文件即可。
- 下载好之后，解压就好了。
- 打开该文件夹，其中会有一个名为
mysql-connector-j-8.0.31.jar的驱动文件。就是它了。
提醒一点： 新版本的 JDBC 驱动类的包有所改动，将以前的
com.mysql.jdbc.Driver改为com.mysql.cj.jdbc.Driver。但是该这篇文章使用的是
mysql-connector-java-5.1.7版本的为例的，没有做改动，如有需要的，我提供了Github，以及 Gitee 链接大家可以自行获取，
Gitee: JDBCmysql · 彩虹海/软件和配置 - 码云 - 开源中国 (gitee.com)
2.2 将驱动加载到项目中这里以 IDEA 为例
- 第一步在 IDEA 中 (右)击项目名，New——>一个目录(Directory) ，名为
libs的目录(文件夹),用于存放我们刚刚下载好的 jar 驱动包 ，这里说明一下，新建一个目录，存放是为了，方便管理项目中的文件。规范化
- 我们将我们下载好的 jar 驱动 复制，粘贴到该目录中去就可以了，
- 添加好以后，我们在右击 mysql-connector-java-5.1.7-bin.jar 将该 jdr 驱动部署到项目中去，选择 (Add as Library)
这样我们就把 jar 驱动部署到我们的项目中去了。
3. 连接数据库的四种方式:
对应连接数据库有许多的方法，不仅仅只是七种而已，方法虽然有很多，但是真正在实际开发中使用到的也就只有一两种而已， 这里我们的四种方式，都是一次一次的优化迭代的出来的，其中在开发中常用的 也就是这里的倒数 两种而已。其他的大家了解就可以了。
为了，是我们更加清晰了解Java程序连接数据库这里我们自己编写一个简单版的 JDBC 模拟连接数据库
- 模拟 SUN公司制定的 JDBC 接口
package day01; /** * 模拟 SUN公司制定的 JDBC 接口 */ public interface JdbcInterface { // 抽象方法，连接数据库 public Object getConnection(); // crud 增删改 public void crud(); // 关闭资源 public void close(); }- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 模拟 Mysql 数据库厂家实现 JDBC 接口的实现类
package day01; /** * 模拟 Mysql 数据库厂家实现 JDBC 接口的实现类 */ public class MysqlJdbc implements JdbcInterface{ @Override public Object getConnection() { System.out.println("连接上 MySQL数据库"); return null; } @Override public void crud() { System.out.println("对MySQL数据库进行增删改操作"); } @Override public void close() { System.out.println("关闭MySQL资源"); } }- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 模拟 Oracle 数据库厂家实现 JDBC 接口的实现类
package day01; /** * 模拟 Oracle 数据库厂家实现 JDBC 接口的实现类 */ public class OracleJdbc implements JdbcInterface { @Override public Object getConnection() { System.out.println("连接上Oracle数据库"); return null; } @Override public void crud() { System.out.println("对Oracle数据库进行增删改操作"); } @Override public void close() { System.out.println("关闭Oracle资源"); } }- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 模拟Java程序面向JDBC接口连接数据库
package day01; /** * 模拟Java程序面向JDBC接口连接数据库 */ public class TestJdbc { public static void main(String[] args){ JdbcInterface mysqlJdbc = new MysqlJdbc(); // 多态,接口引用实现类,(动态绑定) mysqlJdbc.getConnection(); // 连接Mysql数据库 mysqlJdbc.crud(); // 对Mysql数据库进行增删改操作 mysqlJdbc.close(); // 关闭Mysql 的资源 System.out.println("==============下面是Oracle的连接操作============"); JdbcInterface oracleJdbc = new OracleJdbc(); oracleJdbc.getConnection(); oracleJdbc.crud(); oracleJdbc.close(); } }- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
运行结果:
3.1 方式一:
通过上述模拟的连接数据库操作，让我们进一步了解的，Java程序连接数据库，这里我们就来真正的连接我们的数据库：
实例代码实现:
package Blogs; import java.sql.Connection; import java.sql.SQLException; import java.util.Properties; public class blogs01 { /** * 方式一: * @param args */ public static void main(String[] args) throws SQLException { // 1. 注册驱动(说明你要连接的数据库是什么品牌的) // java.sql.Driver 是接口, com.mysql.jdbc.Drivers是该接口的实现类 java.sql.Driver driver = new com.mysql.jdbc.Driver(); // 路径new 类 // 或者我们导入 java.sql.Driver 可以省略其中的java.sql.Driver String url = "jdbc:mysql:localhost:3306/test?useUnicode=true&characterEncoding=utf8"; /*?useUnicode=true&characterEncoding=utf8 设置字符编码,如果JDBC程序与服务器端的字符集不一致， 会导致乱码，那么可以通过参数指定服务器端的字符集 url 赋值上，你所要连接的数据库网络上的地址(位置) */ // url 统一资源定位符 // 将连接数据库的用户名和密码封装到 Properties 中,让其自动获取 Properties properties = new Properties(); properties.setProperty("user","root"); // 用户名 properties.setProperty("password","abc123"); // 密码 // 2.连接上(注册驱动时的)数据库 // Connection 是一个接口 Connection connection = driver.connect(url,properties); System.out.println("方式一:"+connection); // 打印连接上的数据库的地址 // 3. 获取操作数据库对象...这里省略,我们只是连接数据库 // 4. 通过获取的对象操作数据库，执行SQL语句 // 5. 如果第四步是 select 查询结果集,处理查询的结果集 // 6. 关闭资源,一般放在 finally 一定会被执行(无论是否存在异常) } }- 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
上述代码的解析:
3.1.1要素一：Driver接口,Driver类
大家看到这里可能会有疑惑吧，就是为什么 Driver又是接口，又是类的。是不是写错了，其中没有写错，这两虽然是同名的但是去一样的，它们分别在各自不同的包下，只是命名相同，既然命名相同，它们之间一定有什么紧密的联系，Driver类是对 Driver接口的实现，默认情况下:
Driver是一个接口在 java.sql.Driver包下，打开 JDK文档查看：如下：
java.sql.Driver接口是所有 JDBC 驱动程序需要实现的接口。这个接口是提供给各个数据库厂商使用的，不同数据库厂商对其实现接口。我们知道接口里面只是一些抽象方法，具体的使用我们还是要使用其中实现了该
java.sql.Driver接口的类的，其中的com.mysql.jdbc.Driver包下的 Driver 就是注册驱动的实现类。非常有意思的是该类和它的接口的命名是一样的 都是 Driver ,所以容易让大家混淆。其实也是十分简单：我们需要记住
对应的包就好了，如 java.sql.Driver包下的Driver 是接口, 而 com.mysql.jdbc.Driver 包下的是实现类
注意: 命名相同的 类名 或者是 接口名 ，Java调用时，不知道该调用哪一个，从而报错，所以必须指明绝对路径 new 的类
有关com.mysql.jdbc.Driver 包下的类，我们可以通过查看 我们下载到 Mysql 实现驱动的源代码上查看到如下：
Mysql中的Driver.java实现类的源代码如下:
/* Copyright 2002-2004 MySQL AB, 2008 Sun Microsystems This program is free software; you can redistribute it and/or modify it under the terms of version 2 of the GNU General Public License as published by the Free Software Foundation. There are special exceptions to the terms and conditions of the GPL as it is applied to this software. View the full text of the exception in file EXCEPTIONS-CONNECTOR-J in the directory of this software distribution. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ package com.mysql.jdbc; // 对应的包 import java.sql.SQLException; /** * The Java SQL framework allows for multiple database drivers. Each driver * should supply a class that implements the Driver interface * ** The DriverManager will try to load as many drivers as it can find and then * for any given connection request, it will ask each driver in turn to try to * connect to the target URL. * *
* It is strongly recommended that each Driver class should be small and * standalone so that the Driver class can be loaded and queried without * bringing in vast quantities of supporting code. * *
* When a Driver class is loaded, it should create an instance of itself and * register it with the DriverManager. This means that a user can load and * register a driver by doing Class.forName("foo.bah.Driver") * * @see org.gjt.mm.mysql.Connection * @see java.sql.Driver * @author Mark Matthews * @version $Id$ */
public class Driver extends NonRegisteringDriver implements java.sql.Driver { // ~ Static fields/initializers // --------------------------------------------- // // Register ourselves with the DriverManager // static { try { java.sql.DriverManager.registerDriver(new Driver()); } catch (SQLException E) { throw new RuntimeException("Can't register driver!"); } } // ~ Constructors // ----------------------------------------------------------- /** * Construct a new driver and register it with DriverManager * * @throws SQLException * if a database error occurs. */ public Driver() throws SQLException { // Required for Class.forName().newInstance() } }- 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
3.1.2 要素二：URL 统一资源定位符
URL统一资源定位符( 网络中某个资源的绝对路径 )。URL 包括: 协议，域名(ip地址)，端口号，资源名
例如:
http://110.242.68.3/index.html/这是一个百度的网页地址，大家可以复制到地址栏上访问看看， https 表示通信协议，110.242.68.3 ip地址，https默认端口是80,index.html资源名什么是通信协议，有什么用 ?
通信协议是通信之前就提前定好的，作用是规定好数据是以什么样的格式传送的，格式是提交定好的，不然不同的格式浏览器是无法识别到的。就比如：一个中国人说广东话，给外国人听，而那个外国人，也说它们自己的方言，
两个人，谁也听不懂，它们各自在说什么 ？？？，同样的协议不同(导致数据格式不同)，有怎么可以识别通信呢
同理我们这里的 URL：表示的是我们所要连接的数据库的地址 ，你要连接数据库总要告诉人家你在网络上的什么位置吧，不然，怎么连接上呢。是吧，总不至于让，人家在这个庞大的网络上，大海捞针吧。
String url = "jdbc:mysql:localhost:3306/test?useUnicode=true&characterEncoding=utf8"; 数据库所在的网络上的位置 jdbc:mysql 表示协议 localhost 表示本地ip地址和 127.0.0.1是一样的表示本地ip地址 3306 表示Mysql默认的端口号 test 表示实际具体的数据库名(资源名) useUnicode=true&characterEncoding=utf8 表示设置有关的字符编码集:如果JDBC驱动和服务器的字符编码不一致的话，会出现乱码，报错的现象，我们需要指定服务器端的字符集- 1
- 2
- 3
- 4
- 5
- 6
- 7
3.1.3 要素三：用户名和密码
user表示连接上数据库的用户名password表示连接上数据库的密码 ，这两个变量名，不要修改它们，统一使用默认的。其值根据实际情况赋值就好了。
Properties properties = new Properties();实例化类，将我们的用户名和封装到对象中，让其自动获取对应的值
Connection connection = driver.connect(url,properties);
其中的 Connection 是一个接口是 driver.connect 方法的返回值，
driver.connect作用：根据我们的用户名和密码，尝试连接我们指定的url上的数据库，注意是尝试所以可能会失败，需要进行异常处理操作。
3.2 方式二:使用 DriverManager 代替driver.connect(url,properties);统一管理数据库
我们通过
DriverManager类来代替Driver实现来统一管理(注册驱动，连接数据库)数据库
- 在DriverManager类下有一个名为
registerDriver的 静态 方法，作用：注册驱动。注意它的参数是Driver接口，接口时不可以 new 的，所以我们需要传入的是该Driver的实现类，该实例类在com.mysql.jdbc.Driver包下。因为接口名和实现的类名是一样的我们，需要通过导入绝对路径的方式new 对象，防止歧义冲突，报错。具体如下：
- 在DriverManager类下有一个名为
DriverManager.getConnection的 静态 方法，作用: 通过信息尝试连接上 给定url的数据库,注意和方式一，一样是尝试，所以可能失败，需要异常处理。具体信息如下文档:
具体代码实现:
public static void main(String[] args) throws SQLException { // 1. 注册驱动(说明你要连接的是什么品牌的数据库) // registerDriver 的参数是 Driver类类型, 而Driver 在默认包下是接口,接口是不可以new的,所以我们需要传入其实现类 DriverManager.registerDriver(new com.mysql.jdbc.Driver()); // 或者分两步 // java.sal.Driver 是接口, com.mysql.jdbc.Driver() 是实现类 java.sql.Driver driver = new com.mysql.jdbc.Driver(); DriverManager.registerDriver(driver); String url = "jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=utf8"; // 所连数据库在网络上的位置 String user = "root"; // 用户名 String password="abc123"; // 密码 // 2.连接根据信息连接上(注册驱动)上的数据库 DriverManager.getConnection Connection connection = DriverManager.getConnection(url,user,password); System.out.println("方式二:"+connection); // 打印连接上数据库的地址 // 3.获取操作数据库的对象 // 4.通过对象执行SQL语句 // 5.如果第4步是select 查询结果集的操作,处理结果集 // 6.关闭资源,一般放在finally 中. }- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
3.3 方式三: 通过反射加载 Driver类,执行其中的静态代码块，这是常用的方式 ⭐⭐⭐
加载驱动：加载 JDBC 驱动需调用 Class 类的静态方法 forName()，向其传递要加载的 JDBC 驱动的类名
- Class.forName(“com.mysql.jdbc.Driver”);
使用反射加载com.mysql.jdbc.Driver包下的类，动态加载，更加的灵活，减少依赖性。
我们这里通过反射加载了其中
com.mysql.jdbc.Driver的类，让其执行其中的 静态代码块(加载类就会被执行一次)，该静态代码块的作用就是注册驱动 ，如下是该 com.mysql.jdbc.Driver下的静态代码块:
具体代码实现:
public static void main(String[] args) throws ClassNotFoundException, SQLException { // 1.注册驱动(说明你要连接的是什么品牌的数据库),这里通过反射加载Driver类,执行Driver类中的 注册驱动的静态方法 Class.forName("com.mysql.jdbc.Driver"); // 因为我们只是想要执行其中Driver的静态方法,所以我们并不需要接受返回值 String url = "jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=utf8"; String user = "root"; String password = "adc123"; // 2. 连接驱动 Connection connection = DriverManager.getConnection(url,user,password); System.out.println("方式三:"+connection); // 打印其连接上数据库的地址 // 3. 获取操作数据库的对象 // 4. 通过对象操作数据库，执行SQL语句 // 5. 如果第四步是 select 是查询结果集,需要处理结果集 // 6.关闭资源,一般放在 finally 中(一定会被执行,无论是否异常) }- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
补充:
其实我们也可以将其中的反射加载类，也就是这段代码
Class.forName("com.mysql.jdbc.Driver")省略掉，也是没有问题的。实验如下:
是因为：从
JDK1.5以后使用 jdbc，不再需要显示调用Class.forName()注册驱动，而是自动调用驱动 jar 包下的 META-INF\services\java.sql.Driver 文本中的类名称去注册。但是还是建议写上
Class.forName()，可以更加直观的知道你连接的是什么品牌的数据库，提高代码的可读性3.4 方式四: 将信息写入到配置文件中，通过读取配置文件中的信息连接数据库，常用的方式 ⭐⭐⭐
我们可以将相关的信息(url(数据库所在位置)、用户名、密码)写入到
.properties文件中去，方便操作使用，提高安全性，这么做的好处:
- 实现了数据与代码的分离，实现了解耦
- 如果需要修改配置信息，直接修改配置文件中的信息就可以了，可以避免重新打包。
- 提高安全性
具体代码实现如下:
- 首先我先创建一个文件用于存放其连接数据库的配置信息，名为
jdbc.properties的文件
该文件内容如下：# 表示注释，注意所赋值的内容上不要含有空格和 ; 分号，防止无法识别到。
user=root # 用户名 password=adc123 # 密码 url=jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=utf8 # url driverClass=com.mysql.jdbc.Driver # 注册的Driver 驱动的包路径 # 注意不要所赋予的值在内容上不要加空格和;分号,- 1
- 2
- 3
- 4
- 5
public static void main(String[] args) throws ClassNotFoundException, SQLException { // 使用资源绑定器,绑定属性的配置文件.properties 这个配置文件 ResourceBundle bundle = ResourceBundle.getBundle("jdbc"); String driver = bundle.getString("driverClass"); // Driver类包 String url = bundle.getString("url"); // url 数据库在网络上的地址 String user = bundle.getString("user"); // user 用户名 String password = bundle.getString("password"); // password 密码 // 1. 注册驱动(说明你想要连接的是哪个数据库) Class.forName(driver); // 2. 连接数据库 Connection connection = DriverManager.getConnection(url,user,password); System.out.println("方式四:"+connection); // 打印连接上数据库的地址 // 3. 获取操作数据库的对象 // 4. 通过对象执行SQL语句 // 5. 如果第四步是 select 查询结果集的话,需要处理结果集 // 6. 关闭资源,一般放在 finally 中(一定会被执行的,无论是否异常) }- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
或者
public static void main(String[] args) throws IOException, ClassNotFoundException, SQLException { // 通过Properties对象获取配置文件(jdbc.properties)的信息 Properties properties = new Properties(); properties.load(new FileInputStream("src\\jdbc.properties")); String driver = properties.getProperty("driverClass"); String url = properties.getProperty("url"); String user = properties.getProperty("user"); String password = properties.getProperty("password"); // 1. 注册驱动(说明你要连接的什么品牌的数据库) Class.forName(driver); // 2. 连接(注册驱动上的)数据库 Connection connection = DriverManager.getConnection(url,user,password); System.out.println("方式四:"+connection); // 3. 获取操作数据库的对象 // 4. 通过对象执行SQL语句 // 5. 如果第四步是 select 查询结果集,则需要处理结果集,不是就不用 // 6. 关闭资源,一般放在 finally中(一定会被执行) }- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
4. 实测:连接数据库进行增删改操作
既然我们已经可以连接上数据库了，那我们就简单的按照 JDBC六步骤初步操作数据库
首先我们先了解一下，我们操作实验的对象，我们连接的是MySQL 数据库中的名为dbtest7数据库 下的 admin 表,如下所示
补充:
获取连接数据库的对象是
Statement statement = connection.createStatement();这段代码：其中 Statement 是一个接口，具体如下
connection.createStatement() 方法，作用是获取连接操作数据的对象
statement.executeUpdate()该方法是执行SQL语句，返回影响数据库的行数
- 通过连接数据库(insert)增加一条记录
public static void main(String[] args) throws ClassNotFoundException, SQLException { // 1. 注册驱动(说明连接的什么品牌的数据库) Class.forName("com.mysql.jdbc.Driver"); String url = "jdbc:mysql://localhost:3306/dbtest7?useUnicode=true&characterEncoding=utf8"; String user = "root"; String password = "adc123"; // 2. 连接(驱动上的)数据库 Connection connection = DriverManager.getConnection(url,user,password); // 3. 获取操作数据库的对象 // Statement 是一个接口, Statement statement = connection.createStatement(); // 设置执行的sqL语句插入语句,注意在java中执行sql语句不要加;分号不然报错 String sql = "insert admin(id,user_name,pwd) values(3,'王五','qq123')"; // 4. 通过对象中的方法执行SQL语句 int count = statement.executeUpdate(sql); // 该方法返回影响数据库的行数 System.out.println(count == 1 ? "插入成功":"插入失败"); // 因为我们只是插入一行数据,所以只会有一行数据受影响 // 5.第四步不是 select 查询结果集,不需要处理结果集，省略 // 6. 关闭资源，从小到大 statement.close(); // 关闭操作数据库的连接 connection.close(); // 关闭数据库连接 }- 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
或者: 我们使用另外一种处理 异常的方式: 使用
try{}catch{}finally{}public static void main(String[] args){ Connection connection = null; // 扩大作用域,利用关闭资源 Statement statement = null; // try { // 1. 注册驱动(说明连接什么品牌的数据库),通过反射加载Driver类,执行Driver类中的静态代码块(注册驱动) Class.forName("com.mysql.jdbc.Driver"); String url = "jdbc:mysql://localhost:3306/dbtest7?useUnicode=true&characterEncoding=utf8"; String user = "root"; String password = "abc123"; // 2. 连接(驱动上)的数据库 connection = DriverManager.getConnection(url,user,password); // 3.获取操作数据库的对象 statement = connection.createStatement(); // 4. 通过对象的方法执行SQL语句，操作数据库 String sql = "insert admin(id,user_name,pwd) values(4,'小王','QQ996')"; int count = statement.executeUpdate(sql); System.out.println( count == 1 ? "插入成功" : "插入失败"); // 5. 如果第四步是select 查询结果集,则需要处理结果集,这里不是，所以不用 } catch (ClassNotFoundException e) { e.printStackTrace(); } catch (SQLException e) { e.printStackTrace(); } finally { // 6.关闭资源,从小到大,一定会被执行,(无论是否异常) if( statement != null) { // 不为空在需要关闭资源,为空不需要 try { statement.close(); // 关闭 statement 操作数据库连接 } catch (SQLException e) { e.printStackTrace(); } } if( connection != null){ try { connection.close(); // 关闭 connection 连接上的数据库的资源 } catch (SQLException e) { e.printStackTrace(); } } } }- 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
- 通过连接数据库进行(update)修改操作
public static void main(String[] args) throws ClassNotFoundException, SQLException { // 1. 注册驱动(说明连接的什么品牌的数据库)通过反射加载Driver类,执行Driver类中的静态代码块(注册驱动) Class.forName("com.mysql.jdbc.Driver"); String url = "jdbc:mysql://localhost:3306/dbtest7?useUnicode=true&characterEncoding=utf8"; String user = "root"; String password = "adb123"; // 2. 连接(驱动上的)数据库 Connection connection = DriverManager.getConnection(url,user,password); // 3. 获取操作数据库的对象 // Statement 是一个接口, Statement statement = connection.createStatement(); // 设置执行的sqL语句插入语句,注意在java中执行sql语句不要加;分号不然报错 String sql = "update admin set user_name = '老王' where id = 4"; // 4. 通过对象中的方法执行SQL语句，操作数据库 int count = statement.executeUpdate(sql); // 该方法返回影响数据库的行数 System.out.println(count == 1 ? "修改成功":"修改失败"); // 因为我们只是修改了一行数据,所以只会有一行数据受影响 // 5.第四步不是 select 查询结果集,不需要处理结果集，省略 // 6. 关闭资源，从小到大 statement.close(); // 关闭操作数据库的连接 connection.close(); // 关闭数据库连接 }- 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
或者:
public static void main(String[] args){ Connection connection = null; // 扩大作用域,利用关闭资源 Statement statement = null; // try { // 1. 注册驱动(说明连接什么品牌的数据库),通过反射加载Driver类,执行Driver类中的静态代码块(注册驱动) Class.forName("com.mysql.jdbc.Driver"); String url = "jdbc:mysql://localhost:3306/dbtest7?useUnicode=true&characterEncoding=utf8"; String user = "root"; String password = "adb123"; // 2. 连接(驱动上)的数据库 connection = DriverManager.getConnection(url,user,password); // 3.获取操作数据库的对象 statement = connection.createStatement(); // 4. 通过对象的方法执行SQL语句，操作数据库 String sql = "update admin set user_name = '小五' where id = 3"; int count = statement.executeUpdate(sql); System.out.println( count == 1 ? "修改成功" : "修改失败"); // 5. 如果第四步是select 查询结果集,则需要处理结果集,这里不是，所以不用 } catch (ClassNotFoundException e) { e.printStackTrace(); } catch (SQLException e) { e.printStackTrace(); } finally { // 6.关闭资源,从小到大,一定会被执行,(无论是否异常) if( statement != null) { // 不为空在需要关闭资源,为空不需要 try { statement.close(); // 关闭 statement 操作数据库连接 } catch (SQLException e) { e.printStackTrace(); } } if( connection != null){ try { connection.close(); // 关闭 connection 连接上的数据库的资源 } catch (SQLException e) { e.printStackTrace(); } } } }- 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
- 通过连接数据库进行 (delete) 删除操作
public static void main(String[] args) throws ClassNotFoundException, SQLException { // 1. 注册驱动(说明连接的什么品牌的数据库)通过反射加载Driver类,执行Driver类中的静态代码块(注册驱动) Class.forName("com.mysql.jdbc.Driver"); String url = "jdbc:mysql://localhost:3306/dbtest7?useUnicode=true&characterEncoding=utf8"; String user = "root"; String password = "adb123"; // 2. 连接(驱动上的)数据库 Connection connection = DriverManager.getConnection(url,user,password); // 3. 获取操作数据库的对象 // Statement 是一个接口, Statement statement = connection.createStatement(); // 设置执行的sqL语句插入语句,注意在java中执行sql语句不要加;分号不然报错 String sql = "delete from admin where id = 4"; // 4. 通过对象中的方法执行SQL语句，操作数据库 int count = statement.executeUpdate(sql); // 该方法返回影响数据库的行数 System.out.println(count == 1 ? "删除成功":"删除失败"); // 因为我们只是删除了一行数据,所以只会有一行数据受影响 // 5.第四步不是 select 查询结果集,不需要处理结果集，省略 // 6. 关闭资源，从小到大 statement.close(); // 关闭操作数据库的连接 connection.close(); // 关闭数据库连接 }- 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
或者
public static void main(String[] args){ Connection connection = null; // 扩大作用域,利用关闭资源 Statement statement = null; // try { // 1. 注册驱动(说明连接什么品牌的数据库),通过反射加载Driver类,执行Driver类中的静态代码块(注册驱动) Class.forName("com.mysql.jdbc.Driver"); String url = "jdbc:mysql://localhost:3306/dbtest7?useUnicode=true&characterEncoding=utf8"; String user = "root"; String password = "adb123"; // 2. 连接(驱动上)的数据库 connection = DriverManager.getConnection(url,user,password); // 3.获取操作数据库的对象 statement = connection.createStatement(); // 4. 通过对象的方法执行SQL语句，操作数据库 String sql = "delete from admin where id = 3"; int count = statement.executeUpdate(sql); System.out.println( count == 1 ? "删除成功" : "删除失败"); // 5. 如果第四步是select 查询结果集,则需要处理结果集,这里不是，所以不用 } catch (ClassNotFoundException e) { e.printStackTrace(); } catch (SQLException e) { e.printStackTrace(); } finally { // 6.关闭资源,从小到大,一定会被执行,(无论是否异常) if( statement != null) { // 不为空在需要关闭资源,为空不需要 try { statement.close(); // 关闭 statement 操作数据库连接 } catch (SQLException e) { e.printStackTrace(); } } if( connection != null){ try { connection.close(); // 关闭 connection 连接上的数据库的资源 } catch (SQLException e) { e.printStackTrace(); } } } }- 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
5. 总结:
JDBC 连接的六个步骤：
- 注册驱动(说明你要连接的是什么品牌的数据库)，常用的方式是：通过反射加载com.mysql.jdbc.Driver类，执行该类中的静态代码块，注册驱动，注意不同包下Driver 是接口还是类
- 连接(注册驱动)上的数据库，常用的方式是使用 DriverManager.getConnection 统一替代 Driver 管理数据库，一般将其中的 url (所连接的数据库在网络上的位置)，用户名和密码，Driver 包路径，写入到配置文件中，注意 url 中存在一个 JDBC驱动与服务器字符集编码不一致的问题，通过设置配置参数解决
- 获取操作数据库的对象, statement = connection.createStatement();
- 通过对象执行 SQL语句操作数据库，注意Java执行 SQL语句不要加 ;分号，不然报错
- 处理第四步中的 select 查询结果集，没有就不用
- 关闭资源，从小到大关闭资源，一般将其放在 finally 中一定会被执行
连接数据库的方式有许多，记住最后后面两种常用的方式就可以了，通过反射加载类，将参数信息写入到配置文件中去。
6. 最后:
限于自身水平，其中存在的错误，希望大家给予指教，韩信点兵——多多益善，谢谢大家，后会有期，江湖再见 ！！！
-
相关阅读:
Xpath注入学习记录
docker启动tomcat容器实例，浏览器访问失败
Text2SQL中不同数据库SQL之间转换的实战代码
android app开发环境搭建
C++ 同构字符串/ 单词规律
关于激光雷达传感器分类及简介
excel如何调整日期格式的方法
美术作品的著作权
Network（三）动态路由与ACL配置
分享一下怎么做陪诊小程序
- 原文地址：https://blog.csdn.net/weixin_61635597/article/details/127445157
