JDBC
通过Java操作数据库。
接口与实现的关系
一、JDBC规范
掌握四个核心对象：
1、DriverManager:用于注册驱动
2、Connection: 表示与数据库创建的连接
3、Statement: 操作数据库sql语句的对象
4、ResultSet: 结果集或一张虚拟表
JDBC规范在JDK的java.sql.*、javax.sql.*中（接口）
数据库厂商提供的驱动：jar文件（实现类）
二、开发JDBC程序
1、创建数据库表，并向表中添加测试数据
2、创建java project项目，添加数据库驱动（*.jar）
3、实现JDBC操作
（1）加载驱动
DriverManager. registerDriver(Driver driver) ;
Class.forName("com.mysql.jdbc.Driver");
（2）创建连接Connection
（3）得到执行sql语句的Statement对象
（4）执行sql语句，并返回结果
（5）处理结果
（6）关闭资源
1 public void test1() throws Exception {
2 // 加载驱动,反射
3 Class.forName("com.mysql.jdbc.Driver");
4
5 // 获取连接Connection,用java.sql.Connection sun的接口，多态，能用接口就不用类，导java.sql包
6 Connection connection = DriverManager.getConnection("jdbc:mysql://localhost:3306/db1", "root", "GUOJIE123");
7
8 // 得到执行sql语句的对象Statement，全是接口，实现在jar包中
9 Statement createStatement = connection.createStatement();
10
11 // 执行sql语句返回结果
12 ResultSet executeQuery = createStatement.executeQuery("select * from emp");
13
14 // 处理结果
15 while(executeQuery.next()) { // 开始指向表头，一次移动一行
16 System.out.println(executeQuery.getObject(1)); // 数据库都是从1开始,每次取一列
17 System.out.println(executeQuery.getObject(2));
18 System.out.println(executeQuery.getObject(3));
19 }
20
21 // 关闭资源
22 executeQuery.close();
23 createStatement.close();
24 connection.close();
25 }
26 }
三、JDBC常用的类和接口
1、java.sql.Drivermanager类
创建连接
（1）注册驱动
不建议使用
原因有2个：导致驱动被注册2次，强烈依赖数据库的驱动jar。
解决办法：Class.forName("com.mysql.jdbc.Driver"); // 反射加载，解耦，不需要编译路径
（2）与数据库建立连接
（常用）
getConnection(String url, String user, String password) // 试图建立到给定数据库 URL 的连接
getConnection("jdbc:mysql://localhost:3306/day06", "root", "123");
URL:SUN公司与数据库厂商之间的一种协议。
jdbc:mysql://localhost:3306/db1
协议 子协议 IP : 端口号 数据库
mysql: jdbc:mysql://localhost:3306/day14 或者 jdbc:mysql:///day14（默认本机连接）
oracle: jdbc:oracle:thin:@localhost:1521:sid // thin瘦的，
方式二：
getConnection(String url, Properties info)；
1 Properties info = new Properties();//要参考数据库文档
2 info.setProperty("user", "root");
3 info.setProperty("password","root");
方式三：
getConnection(String url);
DriverManager.getConnection("jdbc:mysql://localhost:3306/day14?user=root&password=root");
JUnit测试类
import org.junit.Test;
注意：测试方法不能有返回值和参数
Assert.assertEquals(); // 断言
2、java.sql.Connection接口
一个连接
接口的实现在数据库驱动中，所有与数据库交互都是基于连接对象的。
Statement createStatement(); //创建操作sql语句的对象
3、java.sql.Statement接口
操作sql语句，并返回相应结果的对象（车）
接口的实现在数据库驱动中，用于执行静态 SQL 语句并返回它所生成结果的对象。
ResultSet executeQuery(String sql) //根据查询语句返回结果集，只能执行select语句。
int executeUpdate(String sql) // 根据执行的DML（insert update delete）语句，返回受影响的行数。
boolean execute(String sql) // 此方法可以执行任意sql语句。返回boolean值，表示是否返回ResultSet结果集，仅当执行select语句，且有返回结果集时返回true, 其它语句都返回false
CRUD：客户端的增删改查，对应数据库的
数据库语句在数据库的图形界面里面写，SQL语句在客户端不用加；
4、java.sql.ResultSet接口
结果集（客户端存表数据的对象）
（1）封装结果集
提供一个游标，默认游标指向结果集第一行之前。
调用一次next()，游标向下移动一行。
提供一些get方法
封装数据的方法
Object getObject(int columnIndex); 根据序号取值，索引从1开始
Object getObject(String ColomnName); 根据列名取值。
将结果集中的数据封装到javaBean中
java的数据类型与数据库中的类型的关系
1 byte tityint
2 short smallint
3 int int
4 long bigint
5 float float
6 double double
7 String char varchar
8 Date date
Clob 数据库中大文本
1 boolean next() // 将光标从当前位置向下移动一行
2 int getInt(int colIndex) // 以int形式获取ResultSet结果集当前行指定列号值
3 int getInt(String colLabel) // 以int形式获取ResultSet结果集当前行指定列名值
4 float getFloat(int colIndex) // 以float形式获取ResultSet结果集当前行指定列号值
5 float getFloat(String colLabel) // 以float形式获取ResultSet结果集当前行指定列名值
6 String getString(int colIndex) // 以String 形式获取ResultSet结果集当前行指定列号值
7 String getString(String colLabel) // 以String形式获取ResultSet结果集当前行指定列名值
8 Date getDate(int columnIndex);
9 Date getDate(String columnName);
10 void close() // 关闭ResultSet 对象
使用JDBC实现CRUD操作
1 // 实体类，对应数据库的每一行
2 public class Emp {
3 private int id;
4 private String name;
5 private String gender;
6
7 public int getId() {
8 return id;
9 }
10 public void setId(int id) {
11 this.id = id;
12 }
13 public String getName() {
14 return name;
15 }
16
17 public void setName(String name) {
18 this.name = name;
19 }
20 public String getGender() {
21 return gender;
22 }
23 public void setGender(String gender) {
24 this.gender = gender;
25 }
26
27 @Override
28 public String toString() {
29 return "Emp [id=" + id + ", name=" + name + ", gender=" + gender + "]";
30 }
31 }
1 public class TestCRUD {
2
3 @Test
4 public void test() throws Exception {
5 // 加载驱动,反射
6 Class.forName("com.mysql.jdbc.Driver");
7
8 // 获取连接Connection,用java.sql.Connection sun的接口，多态，能用接口就不用类，导java.sql包
9 Connection connection = DriverManager.getConnection("jdbc:mysql://localhost:3306/db1", "root", "GUOJIE123");
10
11 // 得到执行sql语句的对象Statement，全是接口，实现在jar包中
12 Statement createStatement = connection.createStatement();
13
14 // 执行sql语句返回结果
15 ResultSet executeQuery = createStatement.executeQuery("select * from emp");
16 List<Emp> list = new ArrayList<Emp>();
17
18 // 处理结果
19 while(executeQuery.next()) { // 开始指向表头，一次移动一行
20 Emp emp = new Emp(); // 要是放在外面的话，会造成覆盖显示最后一行数据，因list中存放的是emp的引用，内存地址都一样，以最后修改的一次为结果
21 emp.setId(executeQuery.getInt("id"));
22 emp.setName(executeQuery.getString("name"));
23 emp.setGender(executeQuery.getString("gender"));
24 list.add(emp);
25 }
26
27 // 关闭资源
28 executeQuery.close();
29 createStatement.close();
30 connection.close();
31
32 for (Emp emp : list) {
33 System.out.println(emp);
34 }
35 }
36 }
5、释放资源
资源有限，要正确关闭
1 @Test
2 public void test2() throws Exception {
3 // 获取连接Connection
4 Connection connection = null;
5 // 得到执行sql语句的对象Statement
6 Statement createStatement = null;
7 // 执行sql语句返回结果
8 ResultSet executeQuery = null;
9 try {
10 // 加载驱动,反射
11 Class.forName("com.mysql.jdbc.Driver");
12
13 connection = DriverManager.getConnection(
14 "jdbc:mysql://localhost:3306/db1", "root", "GUOJIE123");
15
16 createStatement = connection.createStatement();
17
18 executeQuery = createStatement.executeQuery("select * from emp");
19
20 // 处理结果
21 while (executeQuery.next()) { // 开始指向表头，一次移动一行
22 System.out.println(executeQuery.getObject(1)); // 数据库都是从1开始,每次取一列
23 System.out.println(executeQuery.getObject(2));
24 System.out.println(executeQuery.getObject(3));
25 }
26 } catch (Exception e) {
27 // TODO Auto-generated catch block
28 e.printStackTrace();
29 } finally {
30 // 关闭资源
31 if (executeQuery != null) {
32 try {
33 executeQuery.close(); // executeQuery中还可能出错，继续try-catch
34 } catch (Exception e) {
35 e.printStackTrace();
36 }
37 executeQuery = null; // 让资源回收器回收
38 }
39
40 if (createStatement != null) {
41 try {
42 createStatement.close();
43 } catch (Exception e) {
44 e.printStackTrace();
45 }
46 createStatement = null; // 让资源回收器回收
47 }
48
49 if (connection != null) {
50 try {
51 connection.close();
52 } catch (Exception e) {
53 e.printStackTrace();
54 }
55 connection = null; // 让资源回收器回收
56 }
57 }
58
59 }
SQL注入：
由于没有对用户输入进行充分检查，而SQL又是拼接而成，在用户输入参数时，在参数中添加一些SQL 关键字，达到改变SQL运行结果的目的，也可以完成恶意攻击
原理：
1.在输入时连接一个永远为真的一个值
2.使用mysql 中的 – 注释
解决SQL注入：使用PreparedStatement 取代 Statement，对sql语句进行预编译
PreparedStatement pst=con.prepareStatement(String sql);
PreparedStatement 解决SQL注入原理：运行在SQL中参数以?占位符的方式表示select * from user where username = ? and password = ? ;将带有?的SQL 发送给数据库完成编译 （不能执行的SQL 带有?的SQL 进行编译 叫做预编译），在SQL编译后发现缺少两个参数PreparedStatement 可以将? 代替参数 发送给数据库服务器，因为SQL已经编译过，参数中特殊字符不会当做特殊字符编译，无法达到SQL注入的目的
四、事务
事务指逻辑上的一组操作，组成这组操作的各个单元，要不全部成功，要不全部不成功
1、开启事务命令
1 start transaction // 开启事务
2 Rollback // 回滚事务，将数据恢复到事务开始时状态
3 Commit // 提交事务，对事务中进行操作，进行确认操作，事务在提交后，数据就不可恢复
2、mysql管理事务
方式一 ：同时事务管理SQL 语句
同上开始事务命令
方式二：数据库中存在一个自动提交变量 ，通过 show variables like '%commit%'; ---- autocommint 值是 on，说明开启自动提交
关闭自动提交 set autocommit = off / set autocommit = 0
如果设置autocommit 为 off，意味着以后每条SQL 都会处于一个事务中，相当于每条SQL执行前 都执行 start transaction
注意：Oracle中 autocommit 默认就是 off
3、JDBC使用事务
当Jdbc程序向数据库获得一个Connection对象时，默认情况下这个Connection对象会自动向数据库提交在它上面发送的SQL语句。若想关闭这种默认提交方式，让多条SQL在一个事务中执行，可使用下列语句：
1 Connection.setAutoCommit(false); // 相当于start transaction
2 Connection.rollback(); rollback
3 Connection.commit(); commit
4、事物特性 ACID
原子性是指事务是一个不可分割的工作单位，事务中的操作要么都发生，要么都不发生。 (2)一致性（Consistency）事务前后数据的完整性必须保持一致。(3)隔离性（Isolation）事务的隔离性是指多个用户并发访问数据库时，一个用户的事务不能被其它用户的事务所干扰，多个并发事务之间数据要相互隔离。(4)持久性（Durability）持久性是指一个事务一旦被提交，它对数据库中数据的改变就是永久性的，接下来即使数据库发生故障也不应该对其有任何影响
5、事务隔离级别
多个线程开启各自事务操作数据库中数据时，数据库系统要负责隔离操作，以保证各个线程在获取数据时的准确性。
如果不考虑隔离性，可能会引发如下问题：
(1)脏读 ：指一个事务读取另一个事务未提交的数据
(2)不可重复读：在一个事务先后两次读取发生数据不一致情况，第二次读取到另一个事务已经提交数据 （强调数据更新 update）
(3)虚读(幻读) ：在一个事务中，第二次读取发生数据记录数的不同 ，读取到另一个事务已经提交数据 （强调数据记录变化 insert ）
(4)丢失更新 ：两个事务对同一条记录进行操作，后提交的事务，将先提交的事务的修改覆盖了
解决：数据库内部定义了四种隔离级别，用于解决三种隔离问题
1 Serializable：可避免脏读、不可重复读、虚读情况的发生。（串行化）2 Repeatable read：可避免脏读、不可重复读情况的发生。（可重复读）不可以避免虚读3 Read committed：可避免脏读情况发生（读已提交）4 Read uncommitted：最低级别，以上情况均无法保证。(读未提交)
mysql中默认的事务隔离级别是 Repeatable read.oracle 中默认的事务隔离级别是 Read committed
操作数据库内部隔离级别set session transaction isolation level 设置事务隔离级别select @@tx_isolation 查询当前事务隔离级别
JDBC中指定事务的隔离级别 Connection接口中定义事务隔离级别四个常量：（1）static int TRANSACTION_READ_COMMITTED 指示不可以发生脏读的常量；不可重复读和虚读可以发生。 （2）static int TRANSACTION_READ_UNCOMMITTED 指示可以发生脏读 (dirty read)、不可重复读和虚读 (phantom read) 的常量。 （3）static int TRANSACTION_REPEATABLE_READ 指示不可以发生脏读和不可重复读的常量；虚读可以发生。 （4）static int TRANSACTION_SERIALIZABLE 指示不可以发生脏读、不可重复读和虚读的常量。
通过 void setTransactionIsolation(int level) 设置数据库隔离级别
6、事务隔离级别总结 read uncommitted 什么问题也解决不了. read committed 可以解决脏读，其它解决不了. Repeatable read 可以解决脏读，可以解决不可重复读,不能解决虚读. Serializable 它会锁表，可以解决所有问题. 安全性：serializable > repeatable read > read committed > read uncommitted 性能 ：serializable < repeatable read < read committed < read uncommitted
不会选择 serializable 和 read uncommitted mysql默认隔离级别 repeatable read ，oracle默认隔离级别 read committed
7、TheadLocal
Service层和Dao层保证共用一个Connection，通过方法传参的方式实现
要是实现接口时无参，用TheadLocal实现保证共用一个Connection
ThreadLocal可以理解成是一个Map集合 Map<Thread,Object> set方法是向ThreadLocal中存储数据，那么当前的key值就是当前线程对象. get方法是从ThreadLocal中获取数据，它是根据当前线程对象来获取值。 如果我们是在同一个线程中，只要在任意的一个位置存储了数据，在其它位置上，就可以获取到这个数据
关于JdbcUtils中使用ThreadLocal 1.声明一个ThreadLocal
private static final ThreadLocal<Connection> tl = new ThreadLocal<Connection>();
2.在getConnection()方法中操作
1 Connection con = tl.get(); 直接从ThreadLocal中获取，第一次返回的是null.
2 if (con == null) {
3 // 2.获取连接
4 con = DriverManager.getConnection(URL, USERNAME, PASSWORD);
5 tl.set(con); //将con装入到ThreadLocal中。
6 }
8、丢失更新
多个事务对同一条记录进行了操作，后提交的事务将先提交的事务操作覆盖了
解决丢失更新可以采用两种方式：
1.悲观锁 悲观锁 （假设丢失更新一定会发生 ）
利用数据库内部锁机制，管理事务 提供的锁机制(1)共享锁
select * from table lock in share mode（读锁、共享锁）
(2)排它锁
select * from table for update （写锁、排它锁）
update语句默认添加排它锁
2.乐观锁 乐观锁 （假设丢失更新不会发生）
采用程序中添加版本字段解决丢失更新问题
create table product (
id int,
name varchar(20),
updatetime timestamp
);
insert into product values(1,'冰箱',null);
update product set name='洗衣机' where id = 1;
解决丢失更新：在数据表添加版本字段，每次修改过记录后，版本字段都会更新，如果读取是版本字段id， 与修改时版本字段不一致，说明别人进行修改过数据 （重改）
五、连接池
就是创建一个容器，用于装入多个Connection对象，在使用连接对象时，从容器中获取一个Connection， 使用完成后，在将这个Connection重新装入到容器中。这个容器就是连接池。(DataSource)，也叫做数据源.
我们可以通过连接池获取连接对象. 优点：节省创建连接与释放连接 性能消耗（连接池中连接起到复用的作用 ，提高程序性能）
1、自定义连接池 （1）创建一个MyDataSource类，在这个类中创建一个LinkedList<Connection> （2）在其构造方法中初始化List集合，并向其中装入5个Connection对象。 （3）创建一个public Connection getConnection();从List集合中获取一个连接对象返回. （4）创建一个 public void readd(Connection) 这个方法是将使用完成后的Connection对象重新装入到List集合中.
代码问题: 1.连接池的创建是有标准的. 在javax.sql包下定义了一个接口 DataSource 简单说，所有的连接池必须实现javax.sql.DataSource接口，我们的自定义连接池必须实现DataSource接口。 2.我们操作时，要使用标准，怎样可以让 con.close()它不是销毁，而是将其重新装入到连接池. 要解决这个问题，其本质就是将Connection中的close()方法的行为改变。 怎样可以改变一个方法的行为(对方法功能进行增强) 1.继承 2.装饰模式 1.装饰类与被装饰类要实现同一个接口或继承同一个父类 2.在装饰类中持有一个被装饰类引用 3.对方法进行功能增强。 3.动态代理 可以对行为增强 Proxy.newProxyInstance(ClassLoacer ,Class[],InvocationHandler);
结论:
Connection对象如果是从连接池中获取到的，那么它的close方法的行为已经改变了，不在是销毁，而是重新装入到连接池。
1.连接池必须实现javax.sql.DataSource接口。 2.要通过连接池获取连接对象 DataSource接口中有一个 getConnection方法. 3.将Connection重新装入到连接池 使用Connection的close()方法。
2、开源连接池
（1） DBCP(了解)
DBCP是apache的一个开源连接池。 要想使用DBCP连接池，要下载jar包 导入时要导入两个 commons-dbcp-1.4.jar commons-pool-1.5.6.jar 关于dbcp连接池使用 1.手动配置(手动编码)
BasicDataSource bds = new BasicDataSource();
// 需要设置连接数据库最基本四个条件
bds.setDriverClassName("com.mysql.jdbc.Driver");
bds.setUrl("jdbc:mysql:///day18");
bds.setUsername("root");
bds.setPassword("abc");
// 得到一个Connection
Connection con = bds.getConnection();
2.自动配置(使用配置文件)
1 Properties props = new Properties();
2 FileInputStream fis = new FileInputStream("D:\\java1110\\workspace\\day18_2\\src\\dbcp.properties");
3 props.load(fis);
4
5 DataSource ds = BasicDataSourceFactory.createDataSource(props);
（2）C3P0(必会) C3P0是一个开源的JDBC连接池，它实现了数据源和JNDI绑定，支持JDBC3规范和JDBC2的标准扩展。 目前使用它的开源项目有Hibernate，Spring等。 c3p0与dbcp区别:
c3p0有自动回收空闲连接功能，DBCP没有 c3p0连接池使用 1.导包 c3p0-0.9.1.2.jar 使用 1.手动
1 ComboPooledDataSource cpds = new ComboPooledDataSource();
2 cpds.setDriverClass("com.mysql.jdbc.Driver");
3 cpds.setJdbcUrl("jdbc:mysql:///day18");
4 cpds.setUser("root");
5 cpds.setPassword("abc");
2.自动(使用配置文件) c3p0的配置文件可以是properties也可以是xml. c3p0的配置文件如果名称叫做 c3p0.properties or c3p0-config.xml 并且放置在classpath路径下(对于web应用就是classes目录) 那么c3p0会自动查找。 注意：我们其时只需要将配置文件放置在src下就可以。 使用：
ComboPooledDataSource cpds = new ComboPooledDataSource(); // 它会在指定的目录下查找指定名称的配置文件，并将其中内容加载。
（3）Tomcat内置连接池
Tomcat管理连接池
要想将一个dbcp连接池让 tomcat管理，只需要创建一个context.xml配置文件,在配置文件中
<Context>
<Resource name="jdbc/EmployeeDB" auth="Container"
type="javax.sql.DataSource" username="root" password="abc"
driverClassName="com.mysql.jdbc.Driver" url="jdbc:mysql:///day18"
maxActive="8" maxIdle="4"/>
</Context>
context.xml文件位置
1.在Tomcat/conf/context.xml 这时这个连接池是给整个服务器使用的。 2.在Tomcat/conf/Catalina/localhost 这时这个连接池只给localhost虚拟主机使用。 3.将context.xml文件放置在web应用的META-INF下，只给本项目使用注意：如果是全局设置，那么我们需要将数据库驱动放置在tomcat/lib目录下
从tomcat中获取连接池
我们在servlet中获取连接池对象，用JNDI技术实现
1 Context context = new InitialContext();
2 Context envCtx = (Context)context.lookup("java:comp/env"); // 固定路径
3 DataSource datasource = (DataSource) envCtx.lookup("jdbc/EmployeeDB");
JNDI(Java Naming and Directory Interface,Java命名和目录接口)是SUN公司提供的一种标准的Java命名系统接口， JNDI提供统一的客户端API，通过不同的访问提供者接口JNDI SPI的实现，由管理者将JNDI API映射为特定的命名服务 和目录系统，使得Java应用程序可以和这些命名服务和目录服务之间进行交互。目录服务是一种命名服务， 在这种服务里，对象不但有名称，还有属性。
六、元数据
元数据(metaData) 指数据库中库、表、列的定义信息
1. DataBaseMetaData 数据库元数据（ 了解）
（1）通过DataBaseMetaData获得 数据库连接的基本参数
获取DataBaseMetaData：Connection接口中定义了一个方法 getMetaData();
1 getURL() // 返回一个String类对象，代表数据库的URL。
2 getUserName() // 返回连接当前数据库管理系统的用户名。
3 getDriverName() // 返回驱动驱动程序的名称。
4 getPrimaryKeys(String catalog, String schema, String table) // 返回指定表主键的相关描述 结果集
每个主键列描述都有以下列： TABLE_CAT String => 表类别（可为 null） TABLE_SCHEM String => 表模式（可为 null） TABLE_NAME String => 表名称 COLUMN_NAME String => 列名称 KEY_SEQ short => 主键中的序列号（值 1 表示主键中的第一列，值 2 表示主键中的第二列）。 PK_NAME String => 主键的名称（可为 null）
（2）获得数据库、表、列、主键、外键 定义信息
1 getTables
2 getColumns
3 getPrimaryKeys
2、 ParameterMetaData 参数元数据
参数元数据主要用于获取:sql语句中占位符的相关信息.
PreparedStatement . getParameterMetaData() // 获得代表PreparedStatement元数据的ParameterMetaData对象
Select * from user where name=? And password=?
ParameterMetaData对象
1 getParameterCount() // 获得指定参数的个数
2 getParameterTypeName(int param) // 获得指定参数的sql类型
在获取参数类型时会产生异常 java.sql.SQLException: Parameter metadata not available for the given statement
解决方案: 在url后添加参数 jdbc:mysql:///day18?generateSimpleParameterMetadata=true 添加这个参数后，我们在获取，它的结果也是varchar,
原因:是mysql驱动的支持问题，Oracle可以
3、 ResultSetMetaData 结果集元数据( 重点)
ResultSet. getMetaData() // 获得代表ResultSet对象元数据的ResultSetMetaData对象
ResultSetMetaData对象
1 getColumnCount() // 返回resultset对象的列数
2 getColumnName(int column) // 获得指定列的名称
3 getColumnTypeName(int column) // 获得指定列的类型
七、DbUtils
commons-dbutils 是 Apache 组织提供的一个开源 JDBC工具类库，它是对JDBC的简单封装，学习成本极低，并且使用dbutils能极大简化jdbc编码的工作量，同时也不会影响程序的性能。因此dbutils成为很多不喜欢hibernate的公司的首选
1、DbUtils核心
1.QueryRunner类 它是用于执行sql语句的类。 （1）query 用于执行select （2）update 用于执行update delete insert （3）batch 批处理 2.ResultSetHandler接口 用于定义结果集的封装 它提供九个实现类，可以进行不同的封装。 3.DbUtils类 它提供关于关闭资源以及事务rollback,commit操作
2、QueryRunner
单化了SQL查询，它与ResultSetHandler组合在一起使用可以完成大部分的数据库操作，能够大大减少编码量。
（1）获取QueryRunner
new QueryRunner() // 如果是使用这种构造创建的QueryRunner,它的事务是手动控制.
new QueryRunner(DataSource ds); // 如果是使用这种构造，它的事务是自动事务，简单说，一条sql一个事务。
（2）QueryRunner中的三个核心方法
query update batch 对于上述三个方法，它们提供很多重载。 如果QueryRunner在创建时，没有传递DataSource参数，那么在使用 query,update,batch方法时，要传递Connection参数 如果QueryRunner在创建时，传递了Dataource参数，好么在使用 query,update,batch方法时，不需要传递Connection参数。
总结：
1 QueryRunner runner=new QueryRunner();
2 runner.query(Connection,sql,ResultSetHandler,Object... param);
3 runner.update(Connection,sql,Object...param);
4 runner.batch(Connection con,sql,Object[][] objs);
5
6 QueryRunner runner=new QueryRunner(DataSource ds);
7 runner.query(sql,ResultSetHandler,Object... param);
8 runner.update(sql,Object...param);
9 runner.batch(sql,Object[][] objs);
3、DbUtils类
提供如关闭连接、装载JDBC驱动程序等常规工作的工具类，里面的所有方法都是静态的
public static void close(…) throws java.sql.SQLException // DbUtils类提供了三个重载的关闭方法。这些方法检查所提供的参数是不是NULL，如果不是的话，它们就关闭Connection、Statement和ResultSet。
public static void closeQuietly(…) // 这一类方法不仅能在Connection、Statement和ResultSet为NULL情况下避免关闭，还能隐藏一些在程序中抛出的SQLException。
public static void commitAndCloseQuietly(Connection conn) // 用来提交连接，然后关闭连接，并且在关闭连接时不抛出SQL异常。
public static boolean loadDriver(java.lang.String driverClassName) //这一方装载并注册JDBC驱动程序，如果成功就返回true。使用该方法，你不需要捕捉这个异常ClassNotFoundException。
模仿QueryRunner
1 1.query方法模仿
2 public <T> T query(Connection con, String sql, MyResultSetHandler<T> mrs,Object... params) throws SQLException {
3
4 PreparedStatement pst = con.prepareStatement(sql); // 得到一个预处理的Statement.
5 // 问题:sql语句中可能存在参数，需要对参数赋值。
6
7 ParameterMetaData pmd = pst.getParameterMetaData();
8 // 可以得到有几个参数
9 int count = pmd.getParameterCount();
10 for (int i = 1; i <= count; i++) {
11 pst.setObject(i, params[i - 1]);
12 }
13
14 ResultSet rs = pst.executeQuery(); // 得到了结果集，要将结果集封装成用户想要的对象，但是，工具不可能知道用户需求。
15
16 return mrs.handle(rs);
17 }
18 2.update方法模仿
19 public int update(Connection con, String sql, Object... params) throws SQLException {
20
21 PreparedStatement pst = con.prepareStatement(sql); // 得到一个预处理的Statement.
22 // 问题:sql语句中可能存在参数，需要对参数赋值。
23
24 ParameterMetaData pmd = pst.getParameterMetaData();
25 // 可以得到有几个参数
26 int count = pmd.getParameterCount();
27 for (int i = 1; i <= count; i++) {
28 pst.setObject(i, params[i - 1]);
29 }
30
31 int row = pst.executeUpdate();
32 // 关闭资源
33 pst.close();
34 return row;
35 }
4、ResultSetHandler接口
用于封装结果集
ResulsetHandler九个实现类（完成常规操作，而不需要自定义结果集封装）
（1）ArrayHandler：将结果集中第一条记录封装到Object[],数组中的每一个元素就是记录中的字段值。
（2）ArrayListHandler：将结果集中每一条记录封装到Object[],数组中的每一个元素就是记录中的字段值。再将这些数组装入到List集合。
重点）：将结果集中第一条记录封装到一个javaBean中。
重点)：将结果集中每一条记录封装到javaBean中，再将javaBean封装到List集合.
（5）ColumnListHandler：将结果集中指定列的值封装到List集合.
（6）MapHandler： 将结果集中第一条记录封装到Map集合中，集合的 key就是字段名称，value就是字段值
（7）MapListHandler： 将结果集中每一条记录封装到Map集合中，集合的 key就是字段名称，value就是字段值，再将这些Map封装到List集合
（8）KeyedHandler：在使用指定的列的值做为一个Map集合的key，值为每一条记录的Map集合封装
（9）ScalarHandler：进行单值查询 select count(*) from account;
1 // 使用BeanUtils实现
2 Object obj = null;
3
4 Map<String, String[]> map = new HashMap<String, String[]>();
5
6 ResultSetMetaData md = rs.getMetaData();
7 int count = md.getColumnCount();
8
9 if (rs.next()) {
10 try {
11 obj = clazz.newInstance();
12 for (int i = 1; i <= count; i++) {
13 map.put(md.getColumnName(i),
14 new String[] { rs.getString(md.getColumnName(i)) });
15 }
16 BeanUtils.populate(obj, map);
17 } catch (InstantiationException e) {
18 e.printStackTrace();
19 } catch (IllegalAccessException e) {
20 e.printStackTrace();
21 } catch (InvocationTargetException e) {
22 e.printStackTrace();
23 }
24
25 }
26
27 return obj;
客户信息的CURD操作
web 表现层、service 业务层、dao 持久层、utils 工具包、domain 实体类（javaBean）
// 查询所有客户信息
1 // 1.在success.jsp页面添加连接
2 <a href="${pageContext.request.contextPath}/findAll">查看所有客户信息</a>
3 // 2.在CustomerFindAllServlet中调用service,在service中调用dao,最后得到一个List<Customer>
4 // 3.在showCustomer.jsp页面展示客户信息
5 <c:forEach items="${cs}" var="c">
6 <tr>
7 <td><input type="checkbox">
8 </td>
9 <td>${c.id }</td>
10 <td>${c.name}</td>
11 <td>${c.gender }</td>
12 <td>${c.birthday }</td>
13 <td>${c.cellphone }</td>
14 <td>${c.email }</td>
15 <td>${c.preference }</td>
16 <td>${c.type }</td>
17 <td>${c.description }</td>
18 <td><a>编辑</a> <a>删除</a></td>
19 </tr>
20 </c:forEach>
1 // 删除操作
2 // 1.在showCustomer.jsp页面的删除连接上添加参数 客户的id
<a href="${pageContext.request.contextPath}/delByid?id=${c.id}">删除</a>
3 // 2.创建一个CustomerDelByIdServlet,获取请求参数,调用service中删除方法.
删除完成后，需要重新跳转到查询所有的servlet中，再重新查询数据
response.sendRedirect(request.getContextPath()+"/findAll");
1 // 编辑
2 // 1.查询，做回显示
3 <a href="${pageContext.request.contextPath}/findById?id=${c.id}">编辑</a>
4 // 1.创建CustomerFindByIdServlet,得到要查询的id,调用service，得到Custonmer对象。
5 // 2.将customer对象存储到request域，请求转发到customerInfo.jsp页面。
6 // 3.在customerInfo.jsp页面展示客户信息
7 // 注意:客户的id不能修改，所以使用<input type="hidden">
8
9 // 2.修改
10 // 1.注意使用BeanUtils时的类型转换问题
11 // 2.注意编码问题
12 // post:request.setCharacterEncoding("utf-8");
13 // get:手动转换 new String(request.getParameter(name).getBytes("iso8859-1"),"utf-8");
14
15 // 3.进行修改操作
16 String sql = "update customer set name=?,gender=?,birthday=?,cellphone=?,email=?,preference=?,type=?,description=? where id=?";
17 // 修改完成后，在重新查询一次
18 response.sendRedirect(request.getContextPath() + "/findAll");
解决关于回显示时的问题
性别 应该使用radio
1 // 使用自定义标签
2 // 1.定义标签类 extends SimpleTagSupport
3 // 2.定义tld文件
4 <tag>
5 <name>sex</name><!-- 标签名称 -->
6 <tag-class>cn.itcast.customer.tag.GenderTag</tag-class><!-- 标签类 -->
7 <body-content>empty</body-content><!-- 标签体中内容 -->
8
9 <attribute>
10 <name>gender</name> <!-- 属性名称 -->
11 <required>true</required> <!-- 属性必须有 -->
12 <rtexprvalue>true</rtexprvalue><!-- 属性值可以接收el表达式 -->
13 </attribute>
14 </tag>
15 // 3.在页面上使用
16 // 1.使用taglib导入
17 // 2.使用
18 <my:sex gender="${c.gender}" />
使用虚拟主机可以将项目部署成顶级域名
1.在service.xml文件
1.端口修改为80
2. 配置主机
1 <Host name="www.customer.com" appBase="D:\java1110\workspace\day19_2"
2 unpackWARs="true" autoDeploy="true">
3 <Valve className="org.apache.catalina.valves.AccessLogValve" directory="logs"
4 prefix="localhost_access_log." suffix=".txt"
5 pattern="%h %l %u %t "%r" %s %b" />
6 <Context path="" docBase="D:\java1110\workspace\day19_2\WebRoot" />
7 </Host>
3.在hosts文件中配置
127.0.0.1 www.customer.com
