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还给我们提供了很多这种实现类，我们可以在查询使用。我写的并不全面，可以参考网上的文章进行深入学习
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
