JDBC 1

Java 中的数据存储技术

　　在Java中，数据库存取技术可分为如下几类：

　　　　JDBC直接访问数据库

　　　　JDO技术

　　　　第三方O/R工具，如Hibernate, ibatis 等

　　JDBC是java访问数据库的基石，JDO, Hibernate等只是更好的封装了JDBC。

JDBC基础

　　JDBC(Java Database Connectivity)是一个独立于特定数据库管理系统、通用的SQL数据库存取和操作的公共接口（一组API），定义了用来访问数据库的标准Java类库，使用这个类库可以以一种标准的方法、方便地访问数据库资源

JDBC体系结构

JDBC接口（API）包括两个层次：

　　面向应用的API：Java API，抽象接口，供应用程序开发人员使用（连接数据库，执行SQL语句，获得结果）。

　　面向数据库的API：Java Driver API，供开发商开发数据库驱动程序用。

JDBC驱动程序分类

　　JDBC驱动程序：各个数据库厂商根据JDBC的规范制作的 JDBC 实现类的类库

　　JDBC驱动程序总共有四种类型：

　　　　第一类：JDBC-ODBC桥。

　　　　第二类：部分本地API部分Java的驱动程序。

　　　　第三类：JDBC网络纯Java驱动程序。

　　　　第四类：本地协议的纯 Java 驱动程序。

　　第三、四两类都是纯Java的驱动程序，因此，对于Java开发者来说，它们在性能、可移植性、功能等方面都有优势。

Driver 接口

　　Java.sql.Driver 接口是所有 JDBC 驱动程序需要实现的接口。这个接口是提供给数据库厂商使用的，不同数据库厂商提供不同的实现

　　在程序中不需要直接去访问实现了 Driver 接口的类，而是由驱动程序管理器类(java.sql.DriverManager)去调用这些Driver实现

加载与注册 JDBC 驱动

　　加载 JDBC 驱动需调用 Class 类的静态方法 forName()，向其传递要加载的 JDBC 驱动的类名

　　DriverManager 类是驱动程序管理器类，负责管理驱动程序

　　通常不用显式调用 DriverManager 类的 registerDriver() 方法来注册驱动程序类的实例，因为 Driver 接口的驱动程序类都包含了静态代码块，在这个静态代码块中，会调用 DriverManager.registerDriver() 方法来注册自身的一个实例

建立连接

　　可以调用 DriverManager 类的 getConnection() 方法建立到数据库的连接

　　JDBC URL 用于标识一个被注册的驱动程序，驱动程序管理器通过这个 URL 选择正确的驱动程序，从而建立到数据库的连接。

　　JDBC URL的标准由三部分组成，各部分间用冒号分隔。

　　　　jdbc:<子协议>:<子名称>
　　　　协议：JDBC URL中的协议总是jdbc
　　　　子协议：子协议用于标识一个数据库驱动程序
　　　　子名称：一种标识数据库的方法。子名称可以依不同的子协议而变化，用子名称的目的是为了定位数据库提供足够的信息

几种常用数据库的JDBC URL

　　对于 Oracle 数据库连接，采用如下形式： jdbc:oracle:thin:@localhost:1521:sid

　　对于 SQLServer 数据库连接，采用如下形式： jdbc:microsoft:sqlserver//localhost:1433; DatabaseName=sid

　　对于 MYSQL 数据库连接，采用如下形式：   jdbc:mysql://localhost:3306/sid

	public static Connection getConnection() throws Exception {
		// 1. 准备连接数据库的 4 个字符串.
		// 1). 创建 Properties 对象
		Properties properties = new Properties();

		// 2). 获取 jdbc.properties 对应的输入流
		InputStream in = JDBCTools.class.getClassLoader().getResourceAsStream(
				"jdbc.properties");

		// 3). 加载 2） 对应的输入流
		properties.load(in);

		// 4). 具体决定 user, password 等4 个字符串.
		String user = properties.getProperty("user");
		String password = properties.getProperty("password");
		String jdbcUrl = properties.getProperty("jdbcUrl");
		String driver = properties.getProperty("driver");

		// 2. 加载数据库驱动程序(对应的 Driver 实现类中有注册驱动的静态代码块.)
		Class.forName(driver);

		// 3. 通过 DriverManager 的 getConnection() 方法获取数据库连接.
		return DriverManager.getConnection(jdbcUrl, user, password);
	}

访问数据库

Statement

　　该对象用于执行静态的 SQL 语句，并且返回执行结果

　　Statement 接口中定义了下列方法用于执行 SQL 语句：

　　　　ResultSet excuteQuery(String sql)

　　　　int excuteUpdate(String sql)

	/**
	 * 通过 JDBC 向指定的数据表中插入一条记录.
	 * 1. Statement: 用于执行 SQL 语句的对象
	 * 1). 通过 Connection 的 createStatement() 方法来获取
	 * 2). 通过 executeUpdate(sql) 可以执行 SQL 语句.
	 * 3). 传入的 SQL 可以是 INSRET, UPDATE 或 DELETE. 但不能是 SELECT
	 *
	 * 2. Connection、Statement 都是应用程序和数据库服务器的连接资源. 使用后一定要关闭.
	 * 需要在 finally 中关闭 Connection 和 Statement 对象.
	 *
	 * 3. 关闭的顺序是: 先关闭后获取的. 即先关闭 Statement 后关闭 Connection
	 */
	@Test
	public void testStatement() throws Exception{
		//1. 获取数据库连接
		Connection conn = null;
		Statement statement = null;
		try {
			conn = getConnection2();

			//3. 准备插入的 SQL 语句
			String sql = null;
//			sql = "INSERT INTO customers (NAME, EMAIL, BIRTH) " +
//					"VALUES('XYZ', 'xyz@atguigu.com', '1990-12-12')";
//			sql = "DELETE FROM customers WHERE id = 1";
			sql = "UPDATE customers SET name = 'TOM' " +
					"WHERE id = 4";

			//4. 执行插入.
			//1). 获取操作 SQL 语句的 Statement 对象:
			//调用 Connection 的 createStatement() 方法来获取
			statement = conn.createStatement();

			//2). 调用 Statement 对象的 executeUpdate(sql) 执行 SQL 语句进行插入
			statement.executeUpdate(sql);
		} catch (Exception e) {
			e.printStackTrace();
		} finally{
			try {
				//5. 关闭 Statement 对象.
				if(statement != null)
					statement.close();
			} catch (Exception e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			} finally{
				//2. 关闭连接
				if(conn != null)
					conn.close();
			}
		}

	}

ResultSet

	/**
	 * ResultSet: 结果集. 封装了使用 JDBC 进行查询的结果.
	 * 1. 调用 Statement 对象的 executeQuery(sql) 可以得到结果集.
	 * 2. ResultSet 返回的实际上就是一张数据表. 有一个指针指向数据表的第一样的前面.
	 * 可以调用 next() 方法检测下一行是否有效. 若有效该方法返回 true, 且指针下移. 相当于
	 * Iterator 对象的 hasNext() 和 next() 方法的结合体
	 * 3. 当指针对位到一行时, 可以通过调用 getXxx(index) 或 getXxx(columnName)
	 * 获取每一列的值. 例如: getInt(1), getString("name")
	 * 4. ResultSet 当然也需要进行关闭.
	 */
	@Test
	public void testResultSet(){
		//获取 id=4 的 customers 数据表的记录, 并打印

		Connection conn = null;
		Statement statement = null;
		ResultSet rs = null;
		try {
			//1. 获取 Connection
			conn = JDBCTools.getConnection();
			System.out.println(conn);

			//2. 获取 Statement
			statement = conn.createStatement();
			System.out.println(statement);

			//3. 准备 SQL
			String sql = "SELECT id, name, email, birth " +
					"FROM customers";

			//4. 执行查询, 得到 ResultSet
			rs = statement.executeQuery(sql);
			System.out.println(rs);

			//5. 处理 ResultSet
			while(rs.next()){
				int id = rs.getInt(1);
				String name = rs.getString("name");
				String email = rs.getString(3);
				Date birth = rs.getDate(4);

				System.out.println(id);
				System.out.println(name);
				System.out.println(email);
				System.out.println(birth);
			}
		} catch (Exception e) {
			e.printStackTrace();
		} finally{
			//6. 关闭数据库资源.
			JDBCTools.release(rs, statement, conn);
		}
	}

数据类型转换表

aaarticlea/png;base64,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" alt="" width="551" height="299" />

JDBC API 小结1

　　java.sql.DriverManager用来装载驱动程序，获取数据库连接。

　　java.sql.Connection完成对某一指定数据库的联接

　　java.sql.Statement在一个给定的连接中作为SQL执行声明的容器，他包含了两个重要的子类型。

　　　　Java.sql.PreparedSatement 用于执行预编译的sql声明

　　　　Java.sql.CallableStatement用于执行数据库中存储过程的调用

　　java.sql.ResultSet对于给定声明取得结果的途径

PreparedStatement

　　可以通过调用 Connection 对象的 preparedStatement() 方法获取 PreparedStatement 对象

　　PreparedStatement 接口是 Statement 的子接口，它表示一条预编译过的 SQL 语句

　　PreparedStatement 对象所代表的 SQL 语句中的参数用问号(?)来表示，调用 PreparedStatement 对象的 setXXX() 方法来设置这些参数. setXXX() 方法有两个参数，第一个参数要设置的 SQL 语句中的参数的索引(从 1 开始)，第二个是设置的 SQL 语句中的参数的值

public void testPreparedStatement(){
		Connection con = null;
		PreparedStatement ps = null;
		try {
			con = JDBCTools.getConnection();
			String sql = "INSERT INTO customers(name,email,birth) VALUES(?,?,?)";
			ps = con.prepareStatement(sql);
			ps.setString(1, "ZhangSan");
			ps.setString(2, "zhangsan@163.com");
			ps.setDate(3, new Date(new java.util.Date().getTime()));

			ps.executeUpdate();
		} catch (Exception e) {
			e.printStackTrace();
		}finally{
			JDBCTools.release(null, ps, con);
		}
}

PreparedStatement vs Statement

　　代码的可读性和可维护性.

　　PreparedStatement 能最大可能提高性能

　　PreparedStatement 可以防止 SQL 注入