jdbc入门（二）

一、事务

    1.事务概述

        事务（Transaction），一般是指要做的或所做的事情。在计算机术语中是指访问并可能更新数据库中各种数据项的一个程序执行单元(unit)。事务通常由高级数据库操纵语言或编程语言（如SQL，C++或Java）书写的用户程序的执行所引起，并用形如begin transaction和end transaction语句（或函数调用）来界定。事务由事务开始(begin transaction)和事务结束(end transaction)之间执行的全体操作组成。

        银行转账！张三转10000块到李四的账户，这其实需要两条SQL语句：

            给张三的账户减去10000元；

            给李四的账户加上10000元。

        如果在第一条SQL语句执行成功后，在执行第二条SQL语句之前，程序被中断了（可能是抛出了某个异常，也可能是其他什么原因），那么李四的账户没有加上10000元，而张三却减去了10000元。这肯定是不行的！

        事务中的多个操作，要么完全成功，要么完全失败！

    2.事务的四大特性（ACID）

        原子性（Atomicity）：事务中所有操作是不可再分割的原子单位。事务中所有操作要么全部执行成功，要么全部执行失败。

        一致性（Consistency）：事务执行后，数据库状态与其它业务规则保持一致。如转账业务，无论事务执行成功与否，参与转账的两个账号余额之和应该是不变的。

        隔离性（Isolation）：隔离性是指在并发操作中，不同事务之间应该隔离开来，使每个并发中的事务不会相互干扰。

        持久性（Durability）：一旦事务提交成功，事务中所有的数据操作都必须被持久化到数据库中，即使提交事务后，数据库马上崩溃，在数据库重启时，也必须能保证通过某种机制恢复数据。

    3.MySQL中的事务

        在默认情况下，MySQL每执行一条SQL语句，都是一个单独的事务。如果需要在一个事务中包含多条SQL语句，那么需要开启事务和结束事务。

                开启事务：start transaction；

                结束事务：commit或rollback。

        在执行SQL语句之前，先执行strat transaction，这就开启了一个事务（事务的起点），然后可以去执行多条SQL语句，最后要结束事务，commit表示提交，即事务中的多条SQL语句所做出的影响会持久化到数据库中。或者rollback，表示回滚，即回滚到事务的起点，之前做的所有操作都被撤消了！

    4.JDBC事务

        同一事务中所有的操作，都在使用同一个Connection对象！

        Connection的三个方法与事务相关：

        setAutoCommit(boolean)：设置是否为自动提交事务，如果true（默认值就是true）表示自动提交，也就是每条执行的SQL语句都是一个单独的事务，如果设置false，那么就相当于开启了事务了；con.setAutoCommit(false)表示开启事务！！！

        commit()：提交结束事务；con.commit();表示提交事务

        rollback()：回滚结束事务。con.rollback();表示回滚事务
 

        jdbc处理事务的代码格式：

                try {
                  con.setAutoCommit(false);//开启事务…
                  ….
                  …
                  con.commit();//try的最后提交事务
                } catch() {
                  con.rollback();//回滚事务

                }

代码演示：

AccountDao.java

public class AccountDao {
	public void updateBalance(Connection con, String name, double balance) {
		try {
			String sql = "update account set balance=balance+? where name=?";
			PreparedStatement psmt = con.prepareStatement(sql);
			psmt.setDouble(1, balance);
			psmt.setString(2, name);
			psmt.executeUpdate();
		} catch (SQLException e) {
			e.printStackTrace();
		}
	}
}

jdbcUtils.java

public class jdbcUtils {
	private static Properties props = null;

	// 只在JdbcUtils类被加载时执行一次！
	static {
		// 给props进行初始化，即加载dbconfig.properties文件到props对象中
		try {
			InputStream in = jdbcUtils.class.getClassLoader()
					.getResourceAsStream("dbconfig.properties");
			props = new Properties();
			props.load(in);
		} catch (IOException e) {
			throw new RuntimeException(e);
		}

		// 加载驱动类
		try {
			Class.forName(props.getProperty("driverClassName"));
		} catch (ClassNotFoundException e) {
			throw new RuntimeException(e);
		}
	}

	// 获取连接!
	public static Connection getConnection() throws SQLException {
		// 得到Connection
		return DriverManager.getConnection(props.getProperty("url"),
				props.getProperty("username"), props.getProperty("password"));
	}
}

dbcconfig.properties

driverClassName=com.mysql.jdbc.Driver
url=jdbc\:mysql\://localhost\:3306/mydbc?rewriteBatchedStatements\=true
username=root
password=root

Service.java

	public void zhuanZhang(String from, String to, double money) {
		Connection con = null;
		try {
			con = jdbcUtils.getConnection();
			con.setAutoCommit(false);
			AccountDao dao = new AccountDao();
			dao.updateBalance(con, from, -money);
			dao.updateBalance(con, to, money);
			con.commit();
			con.close();
		} catch (Exception e) {
			try {
				con.rollback();
				con.close();
			} catch (SQLException e1) {
				e1.printStackTrace();
			}

		}
	}

Test类

	@Test
	public void fun1() {
		zhuanZhang("zs", "ls", 100);
	}

    5.事务隔离级别

    （1）事务的并发读问题

        脏读：读取到另一个事务未提交数据；

        不可重复读：两次读取不一致；

        幻读（虚读）：读到另一事务已提交的数据。

        不可重复读和幻读的区别：

                不可重复读是读取到了另一事务的更新；

                幻读是读取到了另一事务的插入（MySQL中无法测试到幻读）；

    （2）四大隔离级别

        4个等级的事务隔离级别，在相同数据环境下，使用相同的输入，执行相同的工作，根据不同的隔离级别，可以导致不同的结果。不同事务隔离级别能够解决的数据并发问题的能力是不同的。

        1.SERIALIZABLE（串行化）

                不会出现任何并发问题，因为它是对同一数据的访问是串行的，非并发访问的；

                性能最差；

        2.REPEATABLE READ（可重复读）（MySQL）

                防止脏读和不可重复读，不能处理幻读问题

                性能比SERIALIZABLE好

        3.READ COMMITTED（读已提交数据）（Oracle）

                防止脏读，没有处理不可重复读，也没有处理幻读；

                性能比REPEATABLE READ好

        4.READ UNCOMMITTED（读未提交数据）

                可能出现任何事务并发问题

                性能最好

    （3）MySQL隔离级别

        MySQL的默认隔离级别为REPEATABLE READ，可以通过以下语句查看：

select @@tx_isolation

        也可以通过下面语句来设置当前连接的隔离级别：

set transaction isolationlevel [4选1]

    （4）JDBC设置隔离级别

        con. setTransactionIsolation(int level)

            参数可选值如下：

                Connection.TRANSACTION_READ_UNCOMMITTED；

                Connection.TRANSACTION_READ_COMMITTED；

                Connection.TRANSACTION_REPEATABLE_READ；

                Connection.TRANSACTION_SERIALIZABLE。

二、数据库连接池

    1.数据库连接池的概念

        用池来管理Connection，这可以重复使用Connection。有了池，所以我们就不用自己来创建Connection，而是通过池来获取Connection对象。当使用完Connection后，调用Connection的close()方法也不会真的关闭Connection，而是把Connection“归还”给池。池就可以再利用这个Connection对象了。

    

    2.JDBC数据连接池接口（DataSource）

        Java为数据库连接池提供了公共的接口：javax.sql.DataSource，各个厂商可以让自己的连接池实现这个接口。这样应用程序可以方便的切换不同厂商的连接池！

    3.DBCP连接池

        （1）什么是DBCP连接池？

                DBCP是Apache提供的一款开源免费的数据库连接池！

        （2）DBCP的使用

	public void fun1() throws SQLException {
		BasicDataSource ds = new BasicDataSource();
		ds.setUsername("root");
		ds.setPassword("123");
		ds.setUrl("jdbc:mysql://localhost:3306/mydb1");
		ds.setDriverClassName("com.mysql.jdbc.Driver");
	
		ds.setMaxActive(20);//最大连接数
		ds.setMaxIdle(10);//最大空闲连接数
		ds.setInitialSize(10);//初始化连接数
		ds.setMinIdle(2);//最小空闲连接数
		ds.setMaxWait(1000);//最大等待毫秒数
		
		Connection con = ds.getConnection();
		System.out.println(con.getClass().getName());
		con.close();//关闭连接只是把连接归还给池！

        （3）DBCP的配置信息

#基本配置
driverClassName=com.mysql.jdbc.Driver
url=jdbc:mysql://localhost:3306/mydb1
username=root
password=123

#初始化池大小，即一开始池中就会有10个连接对象
默认值为0
initialSize=0

#最大连接数，如果设置maxActive=50时，池中最多可以有50个连接，当然这50个连接中包含被使用的和没被使用的（空闲）
#你是一个包工头，你一共有50个工人，但这50个工人有的当前正在工作，有的正在空闲
#默认值为8，如果设置为非正数，表示没有限制！即无限大
maxActive=8

#最大空闲连接
#当设置maxIdle=30时，你是包工头，你允许最多有20个工人空闲，如果现在有30个空闲工人，那么要开除10个
#默认值为8，如果设置为负数，表示没有限制！即无限大
maxIdle=8

#最小空闲连接
#如果设置minIdel=5时，如果你的工人只有3个空闲，那么你需要再去招2个回来，保证有5个空闲工人
#默认值为0
minIdle=0

#最大等待时间
#当设置maxWait=5000时，现在你的工作都出去工作了，又来了一个工作，需要一个工人。
#这时就要等待有工人回来，如果等待5000毫秒还没回来，那就抛出异常
#没有工人的原因：最多工人数为50，已经有50个工人了，不能再招了，但50人都出去工作了。
#默认值为-1，表示无限期等待，不会抛出异常。
maxWait=-1

#连接属性
#就是原来放在url后面的参数，可以使用connectionProperties来指定
#如果已经在url后面指定了，那么就不用在这里指定了。
#useServerPrepStmts=true，MySQL开启预编译功能
#cachePrepStmts=true，MySQL开启缓存PreparedStatement功能，
#prepStmtCacheSize=50，缓存PreparedStatement的上限
#prepStmtCacheSqlLimit=300，当SQL模板长度大于300时，就不再缓存它
connectionProperties=useUnicode=true;characterEncoding=UTF8;useServerPrepStmts=true;cachePrepStmts=true;prepStmtCacheSize=50;prepStmtCacheSqlLimit=300

#连接的默认提交方式
#默认值为true
defaultAutoCommit=true

#连接是否为只读连接
#Connection有一对方法：setReadOnly(boolean)和isReadOnly()
#如果是只读连接，那么你只能用这个连接来做查询
#指定连接为只读是为了优化！这个优化与并发事务相关！
#如果两个并发事务，对同一行记录做增、删、改操作，是不是一定要隔离它们啊？
#如果两个并发事务，对同一行记录只做查询操作，那么是不是就不用隔离它们了？
#如果没有指定这个属性值，那么是否为只读连接，这就由驱动自己来决定了。即Connection的实现类自己来决定！
defaultReadOnly=false

#指定事务的事务隔离级别
#可选值：NONE,READ_UNCOMMITTED, READ_COMMITTED, REPEATABLE_READ, SERIALIZABLE
#如果没有指定，那么由驱动中的Connection实现类自己来决定
defaultTransactionIsolation=REPEATABLE_READ

    4.C3P0连接池

        （1）什么是C3P0连接池？

        C3P0是一个开源的JDBC连接池，它实现了数据源和JNDI绑定，支持JDBC3规范和JDBC2的标准扩展。目前使用它的开源项目有Hibernate，Spring等。

        （2）C3P0的使用

                C3P0中池类是：ComboPooledDataSource。

	public void fun1() throws PropertyVetoException, SQLException {
		ComboPooledDataSource ds = new ComboPooledDataSource();
		ds.setJdbcUrl("jdbc:mysql://localhost:3306/mydb1");
		ds.setUser("root");
		ds.setPassword("123");
		ds.setDriverClass("com.mysql.jdbc.Driver");
	
		ds.setAcquireIncrement(5);//每次的增量为5
		ds.setInitialPoolSize(20);//初始化连接数
		ds.setMinPoolSize(2);//最少连接数
		ds.setMaxPoolSize(50);//最多连接数
		
		Connection con = ds.getConnection();
		System.out.println(con);
		con.close();
	}

配置文件要求：

 

        文件名称：必须叫c3p0-config.xml

        文件位置：必须在src下

<?xml version="1.0" encoding="UTF-8"?>
<c3p0-config>
	<default-config>
		<property name="jdbcUrl">jdbc:mysql://localhost:3306/mydb1</property>
		<property name="driverClass">com.mysql.jdbc.Driver</property>
		<property name="user">root</property>
		<property name="password">123</property>
		<property name="acquireIncrement">3</property>
		<property name="initialPoolSize">10</property>
		<property name="minPoolSize">2</property>
		<property name="maxPoolSize">10</property>
	</default-config>
	<named-config name="oracle-config">
		<property name="jdbcUrl">jdbc:mysql://localhost:3306/mydb1</property>
		<property name="driverClass">com.mysql.jdbc.Driver</property>
		<property name="user">root</property>
		<property name="password">123</property>
		<property name="acquireIncrement">3</property>
		<property name="initialPoolSize">10</property>
		<property name="minPoolSize">2</property>
		<property name="maxPoolSize">10</property>
	</named-config>
</c3p0-config>

        c3p0的配置文件中可以配置多个连接信息，可以给每个配置起个名字，这样可以方便的通过配置名称来切换配置信息。上面文件中默认配置为mysql的配置，名为oracle-config的配置也是mysql的配置。

使用默认的配置信息

	public void fun2() throws PropertyVetoException, SQLException {
		ComboPooledDataSource ds = new ComboPooledDataSource();
		Connection con = ds.getConnection();
		System.out.println(con);
		con.close();
	}

使用名为oracle-config的配置信息

	public void fun2() throws PropertyVetoException, SQLException {
		ComboPooledDataSource ds = new ComboPooledDataSource("orcale-config");
		Connection con = ds.getConnection();
		System.out.println(con);
		con.close();
	}

三、Tomcat配置连接池

    1.Tomcat配置JNDI资源

 

        JNDI（Java Naming and Directory Interface），Java命名和目录接口。JNDI的作用就是：在服务器上配置资源，然后通过统一的方式来获取配置的资源。

        我们这里要配置的资源当然是连接池了，这样项目中就可以通过统一的方式来获取连接池对象了。

        下图是Tomcat文档提供的：

 

 

配置JNDI资源需要到<Context>元素中配置<Resource>子元素：

        name：指定资源的名称，这个名称可以随便给，在获取资源时需要这个名称；

        factory：用来创建资源的工厂，这个值基本上是固定的，不用修改；

        type：资源的类型，我们要给出的类型当然是我们连接池的类型了

        bar：表示资源的属性，如果资源存在名为bar的属性，那么就配置bar的值。对于DBCP连接池而言，你需要配置的不是bar，因为它没有bar这个属性，而是应该去配置url、username等属性。

<Context>  
  <Resource name="mydbcp" 
			type="org.apache.tomcat.dbcp.dbcp.BasicDataSource"
			factory="org.apache.naming.factory.BeanFactory"
			username="root" 
			password="123" 
			driverClassName="com.mysql.jdbc.Driver"    
			url="jdbc:mysql://127.0.0.1/mydb1"
			maxIdle="3"
			maxWait="5000"
			maxActive="5"
			initialSize="3"/>
</Context>  

    2.获取资源

 

        配置资源的目的当然是为了获取资源了。只要你启动了Tomcat，那么就可以在项目中任何类中通过JNDI获取资源的方式来获取资源了。

        下图是Tomcat文档提供的，与上面Tomcat文档提供的配置资源是对应的。

 

        获取资源：

 

                Context：javax.naming.Context；

                InitialContext：javax.naming.InitialContext；

                lookup(String)：获取资源的方法，其中”java:comp/env”是资源的入口（这是固定的名称），获取过来的还是一个Context，这说明需要在获取到的Context上进一步进行获取。”bean/MyBeanFactory”对应<Resource>中配置的name值，这回获取的就是资源对象了。

	        Context cxt = new InitialContext(); 
	        DataSource ds = (DataSource)cxt.lookup("java:/comp/env/mydbcp");
	        Connection con = ds.getConnection();
	        System.out.println(con);
	        con.close();

	        Context cxt = new InitialContext(); 
            Context envCxt = (Context)cxt.lookup("java:/comp/env");
	        DataSource ds = (DataSource)env.lookup("mydbcp");
	        Connection con = ds.getConnection();
	        System.out.println(con);
	        con.close();

上面两种方式是相同的效果。