JAVA WEB从入门到精通 day17 JDBC学习（二）

JDBC学习第二天

事务

简介

    事务(Transaction)是访问并可能更新数据库中各种数据项的一个程序执行单元(unit)。是一系列操作，这些操作作为整体向系统提交，要么都执行，要么都不执行，事务是一个不可分割的工作逻辑单元。

    例如银行转账：张三给李四转账500块钱，需要完成两个操作，张三减500，李四加500，当张三出现异常时，没有减成功，而李四却加了500，这时候银行就会亏损。

事务的特性

    事务应该具有4个属性：原子性、一致性、隔离性、持久性。这四个属性通常称为ACID特性。

    原子性（atomicity）。一个事务是一个不可分割的工作单位，事务中包括的诸操作要么都做，要么都不做。

    一致性（consistency）。事务必须是使数据库从一个一致性状态变到另一个一致性状态。一致性与原子性是密切相关的。

    隔离性（isolation）。一个事务的执行不能被其他事务干扰。即一个事务内部的操作及使用的数据对并发的其他事务是隔离的，并发执行的各个事务之间不能互相干扰。

    持久性（durability）。持久性也称永久性（permanence），指一个事务一旦提交，它对数据库中数据的改变就应该是永久性的。接下来的其他操作或故障不应该对其有任何影响。

mysql中事务的使用

        开始事务：START TRANSACTION
        提交事务：COMMIT
        回滚事务（撤销事务）：ROLLBACK

        案例：
            （1）我们创建一个银行表 

            CREATE TABLE BANK(
                NAME VARCHAR(50),
                MONEY INT
            );
            （2）插入两行数据 

            INSERT INTO BANK VALUES('ZHANGSAN',1000);
            INSERT INTO BANK VALUES('LISI',1000);

            （3）开始事务
            START TRANSACTION;

            (4)执行转账操作
            UPDATE BANK SET MONEY=MONEY-100 WHERE NAME='ZHANGSAN';
            UPDATE BANK SET MONEY=MONEY+100 WHERE NAME='LISI';

            (5)提交或者回滚事务
            COMMIT （提交事务）
            ROLLBACK（回滚事务）：刚才做的所有操作都取消  

JDBC操作事务

Connection中有三个方法和事务相关
            -setAutoCommit(boolean):设置是否自动提交事务，默认为true，每条语句都是一个单独的事务。设置false，那么就相当于开始事务，不自动提交，需要我们提交。 

            -commit():提交事务 

            -rollback():回滚事务

        案例：

            public class Demo4 {

                public static void main(String[] args) throws SQLException {
                    Connection conn=null;
                    try {
                        conn=JdbcUtils.getConnection();       //获取连接

                        String sql1="UPDATE BANK SET MONEY=MONEY-100 WHERE NAME='zhangsan'";
                        String sql2="UPDATE BANK SET MONEY=MONEY+100 WHERE NAME='lisi'";
                        Statement st=conn.createStatement();
                        conn.setAutoCommit(false);               //开启事务
                        st.executeUpdate(sql1);                  //执行语句
                        st.executeUpdate(sql2);
                        conn.commit();                           //提交事务    


                    } catch (Exception e) {
                        conn.rollback();                //如果出现异常则回滚事务
                    }

                }

            }

事务并发引起的问题

    -脏读，某个事务读取的数据是另一个事务正在处理的数据，而另一个事务可能会回滚，造成第一个事务读取的数据是错误的。

    -不可重复读：当一个事务读取某一数据后，另一事务对该数据执行了更新操作，使得第一个事务无法再次读取和前一次一样的数据。

    -幻读：例如第一个事务对一个表中的所有行进行修改，第二个事务是向表中插入一行数据，这时操作第一个事务的用户就会发现还有没修改的行，像发生了幻觉。

事务隔离级别

    -SERIALIZABLE(串行化)：不会出现任何并发问题，因为对数据的访问是串行化，而不是并发访问。能解决上面三个问题，但性能最差，没人用。 

    -REPEATABLE READ（可重复读）:可以防止脏读和不可重复读的问题 

    -READ COMMITTED（读已提交数据）：可以防止脏读问题，性能比REPEATABLE READ好 

    -READ UNCOMMITTED:不能解决任何问题。性能最好。没人用


    Mysql默认隔离级别为REPEATABLE READ 。 
    可以通过 SELECT @@tx_isolation 来查看隔离级别。
    可以通过 set transaction isolationlevel[四个选一个]来设置隔离级别

    JDBC设置隔离级别
        connection.setTransactionisolation(int level)
        参数：
        -Connection.TRANSACTION_READ_UNCOMMITTED
        -Connection.TRANSACTION_READ_COMMITTED
        -Connection.TRANSACTION_REPEATABLE_READ
        -Connection.TRANSACTION_SERIALIZABLE

数据库连接池

概念

数据库连接池负责分配，管理和释放数据库连接，允许应用程序重复使用一个现有的数据库连接。
而不是再重新建立一个连接，能明显提高对数据库操作的性能。

当我们每次需要操作数据库时，如果我们每次调用方法都要新建一个连接，那样会大大影响程序的性能。
而我们只需要将创建好的连接对象放在连接池中，用时取出来，不用就再归还。这样能明显提高性能。

原理

    连接池基本的思想是在系统初始化的时候，将数据库连接作为对象存储在内存中，当用户需要访问数据库时，并非建立一个新的连接，而是从连接池中取出一个已建立的空闲连接对象。
    使用完毕后，用户也并非将连接关闭，而是将连接放回连接池中，以供下一个请求访问使用。而连接的建立、断开都由连接池自身来管理。 

    同时，还可以通过设置连接池的参数来控制连接池中的初始连接数、连接的上下限数以及每个连接的最大使用次数、最大空闲时间等等。也可以通过其自身的管理机制来监视数据库连接的数量、使用情况等。 

连接池基本参数

    初始大小：初始拥有的连接对象个数 

    最小空闲连接数：当我们的连接对象都被使用时，剩余的连接对象到达最小空闲连接数时，就要再创建一些连接对象。 

    最大连接数：如果数据库连接请求超过此数，后面的数据库请求将被加入等待队列中。

    还有很多的连接池参数，我们可以百度进行查询设置。

连接池特性

连接池的close（）方法不是销毁连接，而是把当前连接归还给连接池。

java使用数据库连接池

数据库连接池必须实现DataSource接口。 
数据库连接池有很多开源的项目，不用我们来实现。
我们来学习几个常用的连接池。

dbcp连接池。

由apache提供。使用时需要导入commons-dbcp.jar,commons-pool.jar和 commons-logging.jar 三个jar包。

操作步骤：
        1.导入jar包
        2.创建连接池对象
        3.设置连接的四大参数 （驱动名字，url，数据库名字，数据库密码），我们也可以设置一些连接池的参数
        4。调用方法获取连接

    public class Demo5 {

            public static void main(String[] args) throws SQLException { 

                BasicDataSource datasource=new BasicDataSource();         //创建连接池对象 

                datasource.setDriverClassName("com.mysql.jdbc.Driver");    //设置四大参数 
                datasource.setUrl("jdbc:mysql://localhost:3306/mysql1");
                datasource.setUsername("root");
                datasource.setPassword("123456");

                Connection conn=datasource.getConnection();               //获取连接
            }

        }   

c3p0连接池

C3P0是一个开源的JDBC连接池，它实现了数据源和JNDI绑定，支持JDBC3规范和JDBC2的标准扩展。

操作步骤：
        1.导入jar包(c3p0.jar 和 mchange-commons-java.jar)
        2.创建连接池对象
        3.设置连接的四大参数参数（驱动名字，url，数据库名字，数据库密码），我们也可以设置连接池参数
        4.调用方法获取连接

            public class Demo6 {

                public static void main(String[] args) throws PropertyVetoException, SQLException {
                    ComboPooledDataSource datasource=new ComboPooledDataSource();    //创建连接池对象 

                    datasource.setDriverClass("com.mysql.jdbc.Driver");               //设置四大参数
                    datasource.setJdbcUrl("jdbc:mysql://localhost:3306/mysql1");
                    datasource.setUser("root");
                    datasource.setPassword("123456");

                    Connection conn=datasource.getConnection();                        //获取连接
                    System.out.println(conn);
                    conn.close();                                     //归还连接
                }
            }

使用c3p0配置文件设置数据库连接四大参数，和连接池参数

首先，必须在本类所在路径创建一个 c3p0-config.xml 文件

<?xml version="1.0" encoding="UTF-8"?>
            <c3p0-config>
              <default-config>    //默认配置
                <property name="user">root</property>                             //数据库名字
                <property name="password">123456</property>                        //数据库密码
                <property name="driverClass">com.mysql.jdbc.Driver</property>      //驱动名字
                <property name="jdbcUrl">jdbc:mysql://localhost:3306/mysql1</property> //url

                <property name="initialPoolSize">10</property>                    //连接池参数
                <property name="maxIdleTime">30</property>
                <property name="maxPoolSize">100</property>
                <property name="minPoolSize">10</property>
              </default-config>

              <named-config name="myconfig">                 //不同的数据库参数。使用时需要用到name这个参数  
                <property name="user">root</property>
                <property name="password">java</property>
                <property name="driverClass">com.mysql.jdbc.Driver</property>
                <property name="jdbcUrl">jdbc:mysql://localhost:3306/jdbc</property>

                <property name="initialPoolSize">10</property>
                <property name="maxIdleTime">30</property>
                <property name="maxPoolSize">100</property>
                <property name="minPoolSize">10</property>
              </named-config>
            </c3p0-config>

案例：使用配置文件获取连接

public class Demo7 {
                public static void main(String[] args) throws SQLException {
                    ComboPooledDataSource datasource=new ComboPooledDataSource();//创建连接池对象
                    Connection conn=datasource.getConnection();                //获取连接，配置都在配置文件中       

                    System.out.println(conn);
                }
            }

        配置文件里可以写多个不同的数据库配置，使用时需要传入name参数。
            例如：使用上面配置文件中name=myconfig的配置
            public class Demo7 {
                public static void main(String[] args) throws SQLException {
                    ComboPooledDataSource datasource=new ComboPooledDataSource("myconfig");  //参数传入使用的配置的名字
                    Connection conn=datasource.getConnection();

                    System.out.println(conn);
                }
            }

ThreadLocal 类

简介

        泛型类。
        ThreadLocal翻译过来是“本地线程”，其实ThreadLocal并不是线程，而是线程的局部变量。相当于一个容器。用来存取变量。

        使用ThreadLocal操作变量时，ThreadLocal会为使用该变量的线程提供独立的副本，而不会影响其他线程对应的副本。

        ThreadLocal 不是用来解决共享对象的多线程访问问题的。
        一般情况下，通过ThreadLocal.set() 到线程中的对象是该线程自己使用的对象，其他线程是不需要访问的，也访问不到的。
        各个线程中访问的是不同的对象。 

        简单的说，A和B共享一个桌子，是不能通过ThreadLocal解决的，因为ThreadLocal为A和B一人给了个桌子。
        ThreadLocal解决的只是为了结构上需要而共享资源，其实根本没必要共享资源的情况。

原理

ThreadLocal是如何做到为每一个线程维护变量的副本？ 

        在Threadlocal类中有一个Map集合，Map中元素键为当前线程对象，值则对应副本的值。 

        1.每个线程中都有一个自己的ThreadLocalMap类对象，可以将线程自己的对象保持到其中，各管各的，线程可以正确的访问到自己的对象。  

        2。将一个共用的ThreadLocal静态实例作为key，将不同对象的引用保存到不同线程的ThreadLocalMap中，然后在线程执行的各处通过这个静态ThreadLocal实例的get()方法取得自己线程保存的那个对象，避免了将这个对象作为参数传递的麻烦。 

我们大概实现一下ThreadMap
            public class ThreadLocalTest<T> {
                private Map<Thread,T> map=new HashMap<Thread,T>();  //内部有一个map对象

                public void set(T data)
                {
                    map.put(Thread.currentThread(), data);           //将当前线程对象作为键，我们传入的参数设为值
                }
                public T get()
                {
                    return map.get(Thread.currentThread());           //获取当前线程的值
                }
                public void remove()
                {
                    map.remove(Thread.currentThread());               //移除当前线程
                }

            }

ThreadLocal案例

public class ThreadLocal1 {

                public static void main(String[] args) {
                    final ThreadLocal <String>tl=new ThreadLocal<String>();    //创建ThreadLocal
                    tl.set("hello");                                           //设置值
                    new Thread(){                                              //开启一个新线程
                        public void run(){
                            System.out.println(tl.get());                      //获取不到设置的值，输出为null
                        }       
                    }.start();
                    System.out.println(tl.get());                               //输出hello
                }
            }

DBUtils学习

简介

Commons DbUtils是Apache组织提供的一个对JDBC进行简单封装的开源工具类库。
使用它能够简化JDBC应用程序的开发，同时也不会影响程序的性能。

为什么使用DBUtils？

        在之前，我们对数据库的操作都是通过JDBC来实现的，我们需要获取连接，设置sql模板，给sql模板设置值，然后再执行语句。
        这样我们会写大量重复的代码，操作复杂，效率低。

自己简化一下JDBC繁琐的操作

（1）我们首先创建一个数据表

四列，分别是id，名字，性别，年龄
create table stu(
    id char(10),
    name varchar(50),
    gender varchar(10),
    age int
)

（2）创建一个Stu类，是一个Javabean，用来对stu进行封装

    stu类。javabean。对应数据库里stu表的 id，name，gender，age。
    用来对stu进行封装。  

    public class stu {
                private String Id;
                private String Name;
                private String Gender;
                private int Age;
                public stu()
                {

                }
                public stu(String id, String name, String gender, int age) {
                    super();
                    Id = id;
                    Name = name;
                    Gender = gender;
                    Age = age;
                }
                public String getId() {
                    return Id;
                }
                public void setId(String id) {
                    Id = id;
                }
                public String getName() {
                    return Name;
                }
                public void setName(String name) {
                    Name = name;
                }
                public String getGender() {
                    return Gender;
                }
                public void setGender(String gender) {
                    Gender = gender;
                }
                public int getAge() {
                    return Age;
                }
                public void setAge(int age) {
                    Age = age;
                }

            }

（3）我们写一个接口，用来对结果集进行操作。具体要怎么操作由调用者自己实现。

    interface RsHandler<T> {
                    public T handle(ResultSet rs)throws SQLException;
            }

（4）我们写一个工具类对JDBC的操作进行简化

    public class MyDbutils<T> {
                private DataSource datasource;

                public MyDbutils(){                                 //无参构造方法
                } 

                public MyDbutils(DataSource datasource)         //我们在构造方法中传入一个连接池对象
                {
                    super();
                    this.datasource=datasource;
                } 

                public int update(String sql,Object... params)               //对数据库进行增删改操作，参数为sql模板和操作数据库需要的参数
                {
                    Connection conn=null;                                    
                    PreparedStatement ps=null;
                    try {
                        conn=datasource.getConnection();        //通过传入的连接池获取连接                 
                        ps=conn.prepareStatement(sql);
                        initParams(ps,params);                                //调用给sql模板赋值的方法

                        return ps.executeUpdate();                            //执行操作并返回影响的行数

                    } catch (Exception e) {
                        throw new RuntimeException(e);
                    }finally {
                        try{
                        if(ps!=null) ps.close();
                        if(conn!=null) conn.close();
                        }catch (Exception e) {

                        }
                    }
                } 

                public void initParams(PreparedStatement pst,Object...params) throws SQLException      //给sql模板赋值的方法，传入PraparedStatement对象和一个参数数组
                {
                    for(int i=0;i<params.length;i++)
                    {
                        pst.setObject(i+1, params[i]);  //进行遍历赋值
                    }
                }

                public T query(String sql,RsHandler rh,Object...params)          //对数据库进行查询操作，参数为 sql模板，对结果集进行操作的接口，sql语句需要的参数
                {

                    Connection conn=null;
                    PreparedStatement ps=null;
                    ResultSet rs=null;
                    try {
                        conn=datasource.getConnection();
                        ps=conn.prepareStatement(sql);
                        initParams(ps,params); 
                        rs=ps.executeQuery();                                       //执行查询语句，得到结果集

                        return (T) rh.handle(rs);                                   //将结果集交给接口的处理方法，方法我们不写，由调用者处理

                    } catch (Exception e) {
                        throw new RuntimeException(e);
                    }finally {
                        try{
                        if(rs!=null) rs.close();    
                        if(ps!=null) ps.close();
                        if(conn!=null) conn.close();
                        }catch (Exception e) {

                        }
                    }
                }

            }

（5）我们来测试一下我们写的工具类

public class Test {

            public static void main(String[] args) {
                    /*stu s=new stu();
                    s.setId("0004");
                    s.setName("蓝猫");
                    s.setGender("man");
                    s.setAge(56);
                    addStu(s);*/               //调用addStu方法，将stu对象插入数据库
                    stu s=load("0002")；       //调用查询方法，并返回stu对象
                    System.out.println(s.getAge());

            } 

            public static void addStu(Stu stu)            //我们向数据库插入一个stu对象
            {

                    DataSource datasource=JdbcUtils.getDataSource();  //获取连接池
                    MyDbutils md=new MyDbutils(datasource);            //实例化我们自己写的工具类，传入连接池 

                    //调用update方法，传入sql模板，参数数组
                    md.update("insert into stu values(?,?,?,?)", new Object[]{stu.getId(),stu.getName(),stu.getGender(),stu.getAge()});
            }  

            public static stu load(String id)              //我们通过ID查询数据库，返回一个stu对象
            {
                    DataSource datasource=JdbcUtils.getDataSource();
                    MyDbutils md=new MyDbutils(datasource); 

                    RsHandler <stu>rh=new RsHandler<stu>(){              //写一个实现接口的内部类，用来对结果集进行操作
                        public stu handle(ResultSet rs) throws SQLException {

                            if(!rs.next()) return null;                  //将结果集封装成一个对象返回
                            stu s=new stu();
                            s.setId(rs.getString("ID"));
                            s.setName(rs.getString("NAME"));
                            s.setGender(rs.getString("GENDER"));
                            s.setAge(rs.getInt("AGE"));
                            return s;
                        }
                    } ; 

                    return (stu) md.query("select * from stu where id=?", rh,new Object[]{id}); //调用query方法，传入sql模板，具体的实现类，参数数组
                }

            }

我们可以看到我们对数据库的操作已经简化了很多，省去了很多重复的代码，比如设置参数值，关闭资源等。
其实Apache提供的DBUtils类和我们做的差不多，我们相当于自己实现了一个简易的DBUtils。
但是DBUtils提供了很多对结果集进行操作的实体类。不需要我们再自己来实现。

DBUtils的使用

DButils主要类
        QueryRunner类
            -update方法
                *int update（String sql，Object... params）:可以执行增删改操作，用实例化QueryRunner时传入的连接池获取连接。
                *int update(Connection con,String sql,Object... params):不用连接池的连接，自己提供连接。这样可以保证使用的是同一个连接。我们用到事务的操作时，一般用这个。、

            -query方法
                *T query(String sql,ResultSetHandler rsh,Object... params):可以执行查询操作。
                会先查询得到结果集，然后调用ResultSetHandler的handle（）方法 把结果集转换成需要的类型。

                *T query(Connection con,String sql,ResultSetHandler rsh,Object... params):自己传入connection。需要进行事务操作时使用。

            ResultSetHandler接口
                用于把结果集进行转换的接口。
                我们可以实现该接口自己来实现对结果集的操作。但apache提供了很多这个接口的实现类。

DBUtils使用小案例

public class DbutilsTest {

                public static void main(String[] args) throws SQLException {

                        //update();      //调用对数据库增删改操作的方法
                        //query();       //调用对数据库进行查询的方法
                } 

                public static void  update() throws SQLException                //对数据库进行增删改等操作
                {
                    QueryRunner qr=new QueryRunner(new JdbcUtils().getDataSource()); //获取DBUtils提供的工具类对象

                    String sql="insert into stu values(?,?,?,?)";                    //设置sql模板
                    Object[] params={"1008","康熙","man","1000"};                 //设置参数数组
                    qr.update(sql, params);                                         //调用update方法，传入sql模板和参数数组
                } 


                public static stu query() throws SQLException                   //对数据库进行查询操作，并返回一个对象
                {
                    QueryRunner qr=new QueryRunner(new JdbcUtils().getDataSource());

                    String sql="select * from stu where id=?";
                    Object[] params={"1003"};
                    ResultSetHandler<stu> rsh=new ResultSetHandler<stu>(){       //我们需要实现这个接口来对查询出来的结果集进行操作，和我们自己写的几乎一样

                        public stu handle(ResultSet arg0) throws SQLException {
                            // TODO Auto-generated method stub
                            return null;
                        }
                    };
                    return qr.query(sql, params, rsh);                          //调用query方法，传入sql模板，对结果集操作的实现类，参数数组
                }
            }

Apache提供的ResultSetHandler接口的实现类

    DBUtils提供了很多的ResultSetHandler接口的实现类，供我们对结果集进行操作，不用我们再自己写实现类。

（1）BeanHandler类

需要一个javabean的class文件，会将结果集中的数据封装到该javabean对象中，然后返回该javabean对象
需要注意的是javabean中的成员变量必须和数据库中的列名称一样。 

public class DbutilsTest {

                public static void main(String[] args) throws SQLException {
                    QueryRunner qr=new QueryRunner(new JdbcUtils().getDataSource());

                    String sql="select * from stu where id=?";  //sql模板
                    Object[] params={"0003"};                   //参数数组  

                    stu s=qr.query(sql, new BeanHandler<stu>(stu.class), params);  //提供stu类的class，返回一个stu对象
                    System.out.println(s.getName());
                }

            }

（2）BeanListHandler类

    多行。需要一个指定的class类型的参数，用来把结果集转换成list对象，list集合里是每一行的javabean对象。

    public class DbutilsTest {

                public static void main(String[] args) throws SQLException {
                    QueryRunner qr=new QueryRunner(new JdbcUtils().getDataSource());

                    String sql="select * from stu ";  //sql模板，对所有行进行查询

                    List<stu> l=qr.query(sql, new BeanListHandler<stu>(stu.class));//返回list集合
                    System.out.println(l);
                }
            }

（3）MapHandler类

        单行。把一行结果转换成map对象。 

        public class DbutilsTest {

                    public static void main(String[] args) throws SQLException {
                        QueryRunner qr=new QueryRunner(new JdbcUtils().getDataSource());

                        String sql="select * from stu where id=?";
                        Object[] params={"0001"};

                        Map l= qr.query(sql, new MapHandler(),params);//返回一个Map对象
                        System.out.println(l);
                    }
                }

（4）MapListHandler类

多行。把多行记录转换成多个Map。即list<Map>。

public class DbutilsTest {

                    public static void main(String[] args) throws SQLException {
                        QueryRunner qr=new QueryRunner(new JdbcUtils().getDataSource());

                        String sql="select * from stu ";


                        List<Map<String, Object>> l= qr.query(sql, new MapListHandler());   //返回一个list<Map>集合对象
                        System.out.println(l);
                    }
                }

Apache还给我们提供了很多这种实现类，我们可以在查询使用。我写的并不全面，可以参考网上的文章进行深入学习