JDBC学习笔记——JDBC概述

Posted 2020-09-04

转自：http://www.cnblogs.com/ysw-go/

 

JDBC

JDBC API是一个Java API，可以访问任何类型表列数据，特别是存储在关系数据库中的数据。JDBC代表Java数据库连接。

JDBC库中所包含的API任务通常与数据库使用：

• 连接到数据库

• 创建SQL或mysql语句

• 在数据库中执行SQL或MySQL查询

• 查看和修改记录

JDBC架构

　　　　　   　　　

JDBC API支持两层和三层的处理模式对数据库的访问，但一般JDBC体系结构由两层组成：

1. JDBC API: 这提供了应用程序到JDBC管理器连接。

2. JDBC Driver API: 这支持JDBC管理器 - 驱动器连接。

JDBC API使用一个驱动程序管理器和数据库特定的驱动程序提供透明的异构数据库的连接。

确保使用正确的驱动程序来访问每个数据源的JDBC驱动程序管理器。驱动程序管理器能够支持多个并发连接到多个异构数据库的驱动程序。

上面的这些内容网上都可以找到，我只记录一下连接数据库的具体步骤;

通过Driver接口获取数据库连接

第一步：创建一个Driver实现类的对象

其中：

/**
     * Driver是一个接口，数据库厂商必须提供实现的接口
     * 能从其中获取数据库连接，可以通过Driver的实现类的对象获取连接
     * 1.加入mysql驱动
     * 1).解压mysql-connector-java-5.1.18.zip
     * 2).在当前目录下新建lib目录
     * 3).把mysql-connector-java-5.1.18-bin.jar复制到lib目录
     * 4).右键->build-path->add build path加载到类路径下
     * @throws SQLException 
     * 
     */

执行上面的步骤，加入mysql的驱动

1 Driver driver=new com.mysql.jdbc.Driver();

其中：

com.mysql.jdbc.Driver()

这是驱动的类型。
jdbc中需要配置不同的驱动类型来连接不同类型的数据库，这种是连接mysql用的数据库驱动类型。
用法举例：class.forName("com.mysql.jdbc.Driver")
注意，Driver的D要大写。

---

 

第二步：准备连接数据库的基本信息，url，user,password

JDBC URL的标准由三部分组成

jdbc:<子协议>:<子名称>
1).协议：JDBC URL中的协议总是JDBC
2).子协议：子协议用于标识一个数据库驱动程序
3).子名称：一种标识数据库的方法。子名称可以依据不同的
    子协议而变化，用子名称的目的是为了定位数据库提供足够的信息
例如：jdbc:mysql://127.0.0.1:3306/test【这是我的主机上的,你的不一定】
【记忆】如何查看自己安装的mysql数据库绑定的端口号：进入mysql->mysql后面输入show global variables like ‘port‘;别写错了，切记别忘记写英文状态下的分号;

1     String url="jdbc:mysql://localhost:3306/test";
2         Properties info=new Properties();
3         info.put("user", "root");
4         info.put("password", "123456");

---

第三步：调用Driver接口实现类对象的connect(url,info)方法获取数据库的连接

1 Connection connection=driver.connect(url, info);
2         System.out.println(connection);

【注意】：Connection是一个接口，java.sql包下的接口，eclipse的自动补全功能总是出错，不注意的话会导成别的包里的Connection

此时在开启你的mysql服务的情况下运行程序，运行结果：

[email protected]

上面的步骤的完整代码(main函数中)

 1     public static void main(String[] args) throws SQLException {
 2         //1.创建一个Driver实现类的对象
 3         Driver driver=new com.mysql.jdbc.Driver();
 4         /*
 5          * JDBC URL的标准由三部分组成
 6          * jdbc:<子协议>:<子名称>
 7          * 1).协议：JDBC URL中的协议总是JDBC
 8          * 2).子协议：子协议用于标识一个数据库驱动程序
 9          * 3).紫明成：一种标识数据库的方法。子名称可以一句不同的
10          * 子协议而变化，用子名称的目的是为了定位数据库提供足够的信息
11          * 例如：jdbc:mysql://127.0.0.1:3306/test【这是我的主机上的,你的不一定】
12          * 查看端口号：在mysql后面输入show global variables like ‘port‘;别写错了，切记别忘记写英文状态下的分号
13          */
14         //2.准备连接数据库的基本信息，url，user,password
15         String url="jdbc:mysql://localhost:3306/test";
16         Properties info=new Properties();
17         info.put("user", "root");
18         info.put("password", "123456");
19         //3.调用Driver接口实现类对象的connect(url,info)方法获取数据库的连接
20         //此处Connection是一个接口，java.sql包下的接口
21         Connection connection=driver.connect(url, info);
22         System.out.println(connection);
23     }

做上面的步骤的时候有一个小插曲，连接上数据库进行登录(具体登录步骤)：

/*
         * MySQL附带了一个空密码有的root用户。成功后安装了数据库和客户端，需要进行如下设置root密码：
    
    D:\\software\\mysql-5.6.25-winx64\\bin> mysqladmin -u root password "123456";
    注：
    
    1. 关闭正在运行的MySQL服务。 
    2. 打开DOS窗口，转到 D:\\software\\mysql-5.6.25-winx64\\bin 目录。 
    3. 输入mysqld --skip-grant-tables 回车。--skip-grant-tables 的意思是启动MySQL服务的时候跳过权限表认证。 
    4. 再开一个DOS窗口(因为刚才那个DOS窗口已经不能动了)，转到mysql\\bin目录。 
    5. 输入mysql回车，如果成功，将出现MySQL提示符 >。 
    6. 连接权限数据库： use mysql; 。 
    6. 改密码：update user set password=password("123456") where user="root";(别忘了最后加分号) 。 
    7. 刷新权限(必须步骤)：flush privileges;　
    8. 退出 quit。 
    9. 注销系统，再进入，使用用户名root和刚才设置的新密码 123456 登录。
    现在使MySQL服务器的连接，那么使用下面的命令：
     */

上面的步骤可以完成我们连接mysql的需求，但是我们想连接Orcle或者Sqlserver等其他数据库了呢，我们需要更改我们的程序，改变驱动器的类型，这样不是很好。

我们可以这样：

编写一个通用的方法，在不修改源程序的情况下，可以获取任何数据库的连接
     * 解决方案：把数据库驱动Driver实现类的全类名、url、user、password
     * 放入一个配置文件中，通过修改配置文件的方法实现和具体的数据库解耦

首先，我们新建一个配置文件名字叫做jdbc.Properties,里面添加我们连接数据库需要的信息

driver=com.mysql.jdbc.Driver
jdbcUrl=jdbc:mysql://localhost:3306/test
user=root
password=123456

具体的代码实现：

测试方法一：

 1 public Connection getConnection() throws Exception{
 2         String driverClass=null;
 3         String jdbcUrl=null;
 4         String user=null;
 5         String password=null;
 6         //读取类路径下的jdbc.properties文件
 7         InputStream in=getClass().getClassLoader()
 8                 .getResourceAsStream("jdbc.properties");
 9         Properties properties=new Properties();
10         properties.load(in);
11         driverClass=properties.getProperty("driver");
12         jdbcUrl=properties.getProperty("jdbcUrl");
13         user=properties.getProperty("user");
14         password=properties.getProperty("password");
15         //通过反射创建Driver对象
16         Driver driver=(Driver) Class.forName(driverClass).newInstance();
17         Properties info=new Properties();
18         info.put("user", user);
19         info.put("password", password);
20         Connection connection=driver.connect(jdbcUrl, info);
21         return connection;
22     }

测试方法二：

 1 public Connection testGetConnection2() throws Exception{
 2         //1.准备连接数据库的四个字符串
 3         //1).创建Properties对象
 4         Properties properties=new Properties();
 5         //2).获取jdbc.properties对应的输入流
 6         InputStream in=this.getClass().
 7                 getClassLoader().getResourceAsStream("jdbc.properties");
 8         //3).加载2)对应的输入流
 9         properties.load(in);
10         //4).具体决定user,password等四个字符串
11         String user=properties.getProperty("user");
12         String jdbcUrl=properties.getProperty("jdbcUrl");
13         String password=properties.getProperty("password");
14         String driver=properties.getProperty("driver");
15         //2.加载数据库驱动程序(对应的Driver实现类中注册驱动的静态代码块)
16         Class.forName(driver);
17         //3.通过DriverManager的getConnection()方法获取数据库连接
18         return DriverManager.getConnection(jdbcUrl,user,password);
19     }

---

通过DriverManager获取数据库连接

 1 public void testDriverManager() throws Exception{
 2         //1.准备连接数据库的四个字符串
 3         //驱动的全类名
 4         String driverClass="com.mysql.jdbc.Driver";
 5         //url
 6         String jdbcUrl="dbc:mysql://localhost:3306/test";
 7         //user
 8         String user="root";
 9         //password
10         String password="123456";
11         //读取类路径下的jdbc.properties文件
12         InputStream in=getClass().getClassLoader()
13                 .getResourceAsStream("jdbc.properties");
14         Properties properties=new Properties();
15         properties.load(in);
16         driverClass=properties.getProperty("driver");
17         jdbcUrl=properties.getProperty("jdbcUrl");
18         user=properties.getProperty("user");
19         //2.加载数据库驱动程序(对应的Driver实现类中注册驱动的静态代码块)
20         /*
21          *使用Drivermanager的好处:可以加载多个驱动
22         DriverManager
23         .registerDriver(Class.forName(driverClass).newInstance());
24          * 
25          */
26         Class.forName(driverClass);
27         password=properties.getProperty("password");
28         //3.通过DriverManager的getConnection()方法获取数据库连接
29         Connection connection=DriverManager
30                 .getConnection(jdbcUrl, user, password);
31         System.out.println(connection);
32     }

完整代码(先这样排版，有时间整理)：

  1 package com.atguigu.jdbc;
  2 
  3 import java.io.InputStream;
  4 import java.sql.Connection;
  5 import java.sql.DriverManager;
  6 import java.sql.SQLException;
  7 import java.util.Properties;
  8 
  9 import org.junit.Test;
 10 
 11 import com.mysql.jdbc.Driver;
 12 
 13 //JDBC学习
 14 public class JDBCTest {
 15 
 16     public Connection testGetConnection2() throws Exception{
 17         //1.准备连接数据库的四个字符串
 18         //1).创建Properties对象
 19         Properties properties=new Properties();
 20         //2).获取jdbc.properties对应的输入流
 21         InputStream in=this.getClass().
 22                 getClassLoader().getResourceAsStream("jdbc.properties");
 23         //3).加载2)对应的输入流
 24         properties.load(in);
 25         //4).具体决定user,password等四个字符串
 26         String user=properties.getProperty("user");
 27         String jdbcUrl=properties.getProperty("jdbcUrl");
 28         String password=properties.getProperty("password");
 29         String driver=properties.getProperty("driver");
 30         //2.加载数据库驱动程序(对应的Driver实现类中注册驱动的静态代码块)
 31         Class.forName(driver);
 32         //3.通过DriverManager的getConnection()方法获取数据库连接
 33         return DriverManager.getConnection(jdbcUrl,user,password);
 34     }
 35     /**
 36      * DriverManager是驱动的管理类
 37      * 1).可以通过重载的getConnection()方法获取数据库连接，较为方便
 38      * 2).可以同时管理多个驱动程序：若注册了多个数据库连接
 39      * ，则调用getConnection()方法时传入的参数不同，即返回不同的数据库连接
 40      * @throws Exception 
 41      */
 42     public void testDriverManager() throws Exception{
 43         //1.准备连接数据库的四个字符串
 44         //驱动的全类名
 45         String driverClass="com.mysql.jdbc.Driver";
 46         //url
 47         String jdbcUrl="dbc:mysql://localhost:3306/test";
 48         //user
 49         String user="root";
 50         //password
 51         String password="123456";
 52         //读取类路径下的jdbc.properties文件
 53         InputStream in=getClass().getClassLoader()
 54                 .getResourceAsStream("jdbc.properties");
 55         Properties properties=new Properties();
 56         properties.load(in);
 57         driverClass=properties.getProperty("driver");
 58         jdbcUrl=properties.getProperty("jdbcUrl");
 59         user=properties.getProperty("user");
 60         //2.加载数据库驱动程序(对应的Driver实现类中注册驱动的静态代码块)
 61         /*
 62          *使用Drivermanager的好处:可以加载多个驱动
 63         DriverManager
 64         .registerDriver(Class.forName(driverClass).newInstance());
 65          * 
 66          */
 67         Class.forName(driverClass);
 68         password=properties.getProperty("password");
 69         //3.通过DriverManager的getConnection()方法获取数据库连接
 70         Connection connection=DriverManager
 71                 .getConnection(jdbcUrl, user, password);
 72         System.out.println(connection);
 73     }
 74 
 75     /**
 76      * Driver是一个接口，数据库厂商必须提供实现的接口
 77      * 能从其中获取数据库连接，可以通过Driver的实现类的对象获取连接
 78      * 1.加入mysql驱动
 79      * 1).解压mysql-connector-java-5.1.18.zip
 80      * 2).在当前目录下新建lib目录
 81      * 3).把mysql-connector-java-5.1.18-bin.jar复制到lib目录
 82      * 4).右键->build-path->add build path加载到类路径下
 83      * @throws SQLException 
 84      * 
 85      */
 86         /*
 87          * MySQL附带了一个空密码有的root用户。成功后安装了数据库和客户端，需要进行如下设置root密码：
 88     
 89     D:\\software\\mysql-5.6.25-winx64\\bin> mysqladmin -u root password "123456";
 90     注：
 91     
 92     1. 关闭正在运行的MySQL服务。 
 93     2. 打开DOS窗口，转到 D:\\software\\mysql-5.6.25-winx64\\bin 目录。 
 94     3. 输入mysqld --skip-grant-tables 回车。--skip-grant-tables 的意思是启动MySQL服务的时候跳过权限表认证。 
 95     4. 再开一个DOS窗口(因为刚才那个DOS窗口已经不能动了)，转到mysql\\bin目录。 
 96     5. 输入mysql回车，如果成功，将出现MySQL提示符 >。 
 97     6. 连接权限数据库： use mysql; 。 
 98     6. 改密码：update user set password=password("123456") where user="root";(别忘了最后加分号) 。 
 99     7. 刷新权限(必须步骤)：flush privileges;　
100     8. 退出 quit。 
101     9. 注销系统，再进入，使用用户名root和刚才设置的新密码 123456 登录。
102     现在使MySQL服务器的连接，那么使用下面的命令：
103      */
104     public static void main(String[] args) throws SQLException {
105         //1.创建一个Driver实现类的对象
106         Driver driver=new com.mysql.jdbc.Driver();
107         /*
108          * JDBC URL的标准由三部分组成
109          * jdbc:<子协议>:<子名称>
110          * 1).协议：JDBC URL中的协议总是JDBC
111          * 2).子协议：子协议用于标识一个数据库驱动程序
112          * 3).紫明成：一种标识数据库的方法。子名称可以一句不同的
113          * 子协议而变化，用子名称的目的是为了定位数据库提供足够的信息
114          * 例如：jdbc:mysql://127.0.0.1:3306/test【这是我的主机上的,你的不一定】
115          * 查看端口号：在mysql后面输入show global variables like ‘port‘;别写错了，切记别忘记写英文状态下的分号
116          */
117         //2.准备连接数据库的基本信息，url，user,password
118         String url="jdbc:mysql://localhost:3306/test";
119         Properties info=new Properties();
120         info.put("user", "root");
121         info.put("password", "123456");
122         //3.调用Driver接口实现类对象的connect(url,info)方法获取数据库的连接
123         //此处Connection是一个接口，java.sql包下的接口
124         Connection connection=driver.connect(url, info);
125         System.out.println(connection);
126     }
127     /**
128      * 编写一个通用的方法，在不修改源程序的情况下，可以获取任何数据库的连接
129      * 解决方案：把数据库驱动Driver实现类的全类名、url、user、password
130      * 放入一个配置文件中，通过修改配置文件的方法实现和具体的数据库解耦
131      * @throws ClassNotFoundException 
132      * @throws IllegalAccessException 
133      * @throws InstantiationException 
134      */
135     public Connection getConnection() throws Exception{
136         String driverClass=null;
137         String jdbcUrl=null;
138         String user=null;
139         String password=null;
140         //读取类路径下的jdbc.properties文件
141         InputStream in=getClass().getClassLoader()
142                 .getResourceAsStream("jdbc.properties");
143         Properties properties=new Properties();
144         properties.load(in);
145         driverClass=properties.getProperty("driver");
146         jdbcUrl=properties.getProperty("jdbcUrl");
147         user=properties.getProperty("user");
148         password=properties.getProperty("password");
149         //通过反射创建Driver对象
150         Driver driver=(Driver) Class.forName(driverClass).newInstance();
151         Properties info=new Properties();
152         info.put("user", user);
153         info.put("password", password);
154         Connection connection=driver.connect(jdbcUrl, info);
155         return connection;
156     }
157     @Test
158     public void testGetConnection() throws Exception{
159         System.out.println(getConnection());
160     }
161 }