Spring【DAO模块】就是这么简单

首先来看一下我们原生的JDBC：需要手动去数据库的驱动从而拿到对应的连接..

try {
String sql = "insert into t_dept(deptName) values('test');";
Connection con = null;
Statement stmt = null;
Class.forName("com.mysql.jdbc.Driver");
// 连接对象
con = DriverManager.getConnection("jdbc:mysql:///hib_demo", "root", "root");
// 执行命令对象
stmt =  con.createStatement();
// 执行
stmt.execute(sql);

// 关闭
stmt.close();
con.close();
} catch (Exception e) {
e.printStackTrace();
}

因为JDBC是面向接口编程的，因此数据库的驱动都是由数据库的厂商给做到好了，我们只要加载对应的数据库驱动，便可以获取对应的数据库连接....因此，我们写了一个工具类，专门来获取与数据库的连接(Connection),当然啦，为了更加灵活，我们的工具类是读取配置文件的方式来做的。

/*
* 连接数据库的driver，url，username，password通过配置文件来配置，可以增加灵活性
* 当我们需要切换数据库的时候，只需要在配置文件中改以上的信息即可
*
* */

private static String  driver = null;
private static String  url = null;
private static String  username = null;
private static String password = null;

static {
try {

//获取配置文件的读入流
InputStream inputStream = UtilsDemo.class.getClassLoader().getResourceAsStream("db.properties");

Properties properties = new Properties();
properties.load(inputStream);

//获取配置文件的信息
driver = properties.getProperty("driver");
url = properties.getProperty("url");
username = properties.getProperty("username");
password = properties.getProperty("password");

//加载驱动类
Class.forName(driver);

} catch (IOException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
}

}

public static Connection getConnection() throws SQLException {
return DriverManager.getConnection(url,username,password);
}
public static void release(Connection connection, Statement statement, ResultSet resultSet) {

if (resultSet != null) {
try {
resultSet.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
if (statement != null) {
try {
statement.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
if (connection != null) {
try {
connection.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
}

经过上面一层的封装，我们可以在使用的地方直接使用工具类来得到与数据库的连接...那么比原来就方便很多了！但是呢，每次还是需要使用Connection去创建一个Statement对象。并且无论是什么方法，其实就是SQL语句和传递进来的参数不同！
于是，我们就自定义了一个JDBC的工具类，详情可以看http://blog.csdn.net/hon_3y/article/details/53760782#t6
我们自定义的工具类其实就是以DbUtils组件为模板来写的，因此我们在开发的时候就一直使用DbUtils组件了。

使用Spring的JDBC

上面已经回顾了一下以前我们的JDBC开发了，那么看看Spring对JDBC又是怎么优化的首先，想要使用Spring的JDBC模块，就必须引入两个jar文件：引入jar文件spring-jdbc-3.2.5.RELEASE.jar
spring-tx-3.2.5.RELEASE.jar

首先还是看一下我们原生的JDBC代码：获取Connection是可以抽取出来的，直接使用dataSource来得到Connection就行了。

public void save() {try {
String sql = "insert into t_dept(deptName) values('test');";
Connection con = null;
Statement stmt = null;
Class.forName("com.mysql.jdbc.Driver");
// 连接对象
con = DriverManager.getConnection("jdbc:mysql:///hib_demo", "root", "root");
// 执行命令对象
stmt =  con.createStatement();
// 执行
stmt.execute(sql);

// 关闭
stmt.close();
con.close();
} catch (Exception e) {
e.printStackTrace();
}
}

值得注意的是，JDBC对C3P0数据库连接池是有很好的支持的。因此我们直接可以使用Spring的依赖注入，在配置文件中配置dataSource就行了！

<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
<property name="driverClass" value="com.mysql.jdbc.Driver"></property>
<property name="jdbcUrl" value="jdbc:mysql:///hib_demo"></property>
<property name="user" value="root"></property>
<property name="password" value="root"></property>
<property name="initialPoolSize" value="3"></property>
<property name="maxPoolSize" value="10"></property>
<property name="maxStatements" value="100"></property>
<property name="acquireIncrement" value="2"></property>
</bean>

// IOC容器注入
private DataSource dataSource;
public void setDataSource(DataSource dataSource) {
this.dataSource = dataSource;
}

public void save() {
try {
String sql = "insert into t_dept(deptName) values('test');";
Connection con = null;
Statement stmt = null;
// 连接对象
con = dataSource.getConnection();
// 执行命令对象
stmt =  con.createStatement();
// 执行
stmt.execute(sql);

// 关闭
stmt.close();
con.close();
} catch (Exception e) {
e.printStackTrace();
}
}

Spring来提供了JdbcTemplate这么一个类给我们使用！它封装了DataSource，也就是说我们可以在Dao中使用JdbcTemplate就行了。
创建dataSource，创建jdbcTemplate对象

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:c="http://www.springframework.org/schema/c"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd"> 
<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
<property name="driverClass" value="com.mysql.jdbc.Driver"></property>
<property name="jdbcUrl" value="jdbc:mysql:///zhongfucheng"></property>
<property name="user" value="root"></property>
<property name="password" value="root"></property>
<property name="initialPoolSize" value="3"></property>
<property name="maxPoolSize" value="10"></property>
<property name="maxStatements" value="100"></property>
<property name="acquireIncrement" value="2"></property>
</bean>

<!--扫描注解-->
<context:component-scan base-package="bb"/>

<!-- 2. 创建JdbcTemplate对象 -->
<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
<property name="dataSource" ref="dataSource"></property>
</bean>

</beans>

userDao

package bb;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Component;

/**
* Created by ozc on 2017/5/10.
*/

@Component
public class UserDao implements IUser {

//使用Spring的自动装配
@Autowired
private JdbcTemplate template;

@Override
public void save() {
String sql = "insert into user(name,password) values('zhoggucheng','123')";
template.update(sql);
}

}

测试：

@Test
public void test33() {
ApplicationContext ac = new ClassPathXmlApplicationContext("bb/bean.xml");

UserDao userDao = (UserDao) ac.getBean("userDao");
userDao.save();
}

JdbcTemplate查询

我们要是使用JdbcTemplate查询会发现有很多重载了query()方法

一般地，如果我们使用queryForMap()，那么只能封装一行的数据，如果封装多行的数据、那么就会报错！并且，Spring是不知道我们想把一行数据封装成是什么样的，因此返回值是Map集合...我们得到Map集合的话还需要我们自己去转换成自己需要的类型。我们一般使用下面这个方法：

我们可以实现RowMapper，告诉Spriing我们将每行记录封装成怎么样的。

public void query(String id) {
String sql = "select * from USER where password=?";

List<User> query = template.query(sql, new RowMapper<User>() {

//将每行记录封装成User对象
@Override
public User mapRow(ResultSet resultSet, int i) throws SQLException {
User user = new User();
user.setName(resultSet.getString("name"));
user.setPassword(resultSet.getString("password"));

return user;
}

},id);

System.out.println(query);
}

当然了，一般我们都是将每行记录封装成一个JavaBean对象的，因此直接实现RowMapper，在使用的时候创建就好了。

class MyResult implements RowMapper<Dept>{

// 如何封装一行记录
@Override
public Dept mapRow(ResultSet rs, int index) throws SQLException {
Dept dept = new Dept();
dept.setDeptId(rs.getInt("deptId"));
dept.setDeptName(rs.getString("deptName"));
return dept;
}

}

事务控制概述

下面主要讲解Spring的事务控制，如何使用Spring来对程序进行事务控制....Spring的事务控制是属于Spring Dao模块的。
一般地，我们事务控制都是在service层做的。。为什么是在service层而不是在dao层呢？？有没有这样的疑问...service层是业务逻辑层，service的方法一旦执行成功，那么说明该功能没有出错。一个service方法可能要调用dao层的多个方法...如果在dao层做事务控制的话，一个dao方法出错了，仅仅把事务回滚到当前dao的功能，这样是不合适的[因为我们的业务由多个dao方法组成]。如果没有出错，调用完dao方法就commit了事务，这也是不合适的[导致太多的commit操作]。事务控制分为两种：编程式事务控制
声明式事务控制

编程式事务控制

自己手动控制事务，就叫做编程式事务控制。Jdbc代码：

Conn.setAutoCommite(false);  // 设置手动控制事务

Hibernate代码：

Session.beginTransaction();    // 开启一个事务

【细粒度的事务控制： 可以对指定的方法、指定的方法的某几行添加事务控制】
(比较灵活，但开发起来比较繁琐： 每次都要开启、提交、回滚.)

声明式事务控制

Spring提供对事务的控制管理就叫做声明式事务控制Spring提供了对事务控制的实现。如果用户想要使用Spring的事务控制，只需要配置就行了。
当不用Spring事务的时候，直接移除就行了。
Spring的事务控制是基于AOP实现的。因此它的耦合度是非常低的。
【粗粒度的事务控制： 只能给整个方法应用事务，不可以对方法的某几行应用事务。】(因为aop拦截的是方法。)

Spring给我们提供了事务的管理器类，事务管理器类又分为两种，因为JDBC的事务和Hibernate的事务是不一样的。Spring声明式事务管理器类：

Jdbc技术：DataSourceTransactionManager

Hibernate技术：HibernateTransactionManager

声明式事务控制

我们基于Spring的JDBC来做例子吧引入相关jar包AOP相关的jar包【因为Spring的声明式事务控制是基于AOP的，那么就需要引入AOP的jar包。】
引入tx名称空间
引入AOP名称空间
引入jdbcjar包【jdbc.jar包和tx.jar包】

搭建配置环境

编写一个接口

public interface IUser {
void save();
}

UserDao实现类，使用JdbcTemplate对数据库进行操作！

@Repository
public class UserDao implements IUser {

//使用Spring的自动装配
@Autowired
private JdbcTemplate template;

@Override
public void save() {
String sql = "insert into user(name,password) values('zhong','222')";
template.update(sql);
}

}

userService

@Service
public class UserService {

@Autowired
private UserDao userDao;
public void save() {

userDao.save();
}
}

bean.xml配置：配置数据库连接池、jdbcTemplate对象、扫描注解

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:c="http://www.springframework.org/schema/c"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd"> 
<!--数据连接池配置-->
<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
<property name="driverClass" value="com.mysql.jdbc.Driver"></property>
<property name="jdbcUrl" value="jdbc:mysql:///zhongfucheng"></property>
<property name="user" value="root"></property>
<property name="password" value="root"></property>
<property name="initialPoolSize" value="3"></property>
<property name="maxPoolSize" value="10"></property>
<property name="maxStatements" value="100"></property>
<property name="acquireIncrement" value="2"></property>
</bean>

<!--扫描注解-->
<context:component-scan base-package="bb"/>

<!-- 2. 创建JdbcTemplate对象 -->
<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
<property name="dataSource" ref="dataSource"></property>
</bean>

</beans>

前面搭建环境的的时候，是没有任何的事务控制的。也就是说，当我在service中调用两次userDao.save()，即时在中途中有异常抛出，还是可以在数据库插入一条记录的。Service代码：

@Service
public class UserService {

@Autowired
private UserDao userDao;
public void save() {

userDao.save();

int i = 1 / 0;
userDao.save();
}
}

测试代码：

public class Test2 {

@Test
public void test33() {
ApplicationContext ac = new ClassPathXmlApplicationContext("bb/bean.xml");

UserService userService = (UserService) ac.getBean("userService");
userService.save();
}
}

XML方式实现声明式事务控制

首先，我们要配置事务的管理器类：因为JDBC和Hibernate的事务控制是不同的。

<!--1.配置事务的管理器类:JDBC-->
<bean id="txManage" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">

<!--引用数据库连接池-->
<property name="dataSource" ref="dataSource"/>
</bean>

再而，配置事务管理器类如何管理事务

<!--2.配置如何管理事务-->
<tx:advice id="txAdvice" transaction-manager="txManage">

<!--配置事务的属性-->
<tx:attributes>
<!--所有的方法，并不是只读-->
<tx:method name="*" read-only="false"/>
</tx:attributes>
</tx:advice>

最后，配置拦截哪些方法，

<!--3.配置拦截哪些方法+事务的属性-->
<aop:config>
<aop:pointcut id="pt" expression="execution(* bb.UserService.*(..) )"/>
<aop:advisor advice-ref="txAdvice" pointcut-ref="pt"></aop:advisor>
</aop:config>

配置完成之后，service中的方法都应该被Spring的声明式事务控制了。因此我们再次测试一下：

@Test
public void test33() {
ApplicationContext ac = new ClassPathXmlApplicationContext("bb/bean.xml");

UserService userService = (UserService) ac.getBean("userService");
userService.save();
}

使用注解的方法实现事务控制

当然了，有的人可能觉得到XML文件上配置太多东西了。Spring也提供了使用注解的方式来实现对事务控制第一步和XML的是一样的，必须配置事务管理器类：

<!--1.配置事务的管理器类:JDBC-->
<bean id="txManage" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">

<!--引用数据库连接池-->
<property name="dataSource" ref="dataSource"/>
</bean>

第二步：开启以注解的方式来实现事务控制

<!--开启以注解的方式实现事务控制-->
<tx:annotation-driven transaction-manager="txManage"/>

最后，想要控制哪个方法事务，在其前面添加@Transactional这个注解就行了！如果想要控制整个类的事务，那么在类上面添加就行了。

@Transactional
public void save() {

userDao.save();

int i = 1 / 0;
userDao.save();
}

事务属性

其实我们在XML配置管理器类如何管理事务，就是在指定事务的属性！我们来看一下事务的属性有什么：

对于事务的隔离级别，不清楚的朋友可参考我之前的博文：http://blog.csdn.net/hon_3y/article/details/53760782

事务传播行为:

看了上面的事务属性，没有接触过的其实就这么一个：

propagation = Propagation.REQUIRED

事务的传播行为。事务传播行为的属性有以下这么多个，常用的就只有两个：Propagation.REQUIRED【如果当前方法已经有事务了，加入当前方法事务】
Propagation.REQUIRED_NEW【如果当前方法有事务了，当前方法事务会挂起。始终开启一个新的事务，直到新的事务执行完、当前方法的事务才开始】

当事务传播行为是Propagation.REQUIRED

现在有一个日志类，它的事务传播行为是Propagation.REQUIRED

Class Log{
Propagation.REQUIRED
insertLog();
}

现在，我要在保存之前记录日志

Propagation.REQUIRED
Void  saveDept(){
insertLog();
saveDept();
}

saveDept()本身就存在着一个事务，当调用insertLog()的时候，insertLog()的事务会加入到saveDept()事务中也就是说，saveDept()方法内始终是一个事务，如果在途中出现了异常，那么insertLog()的数据是会被回滚的【因为在同一事务内】

Void  saveDept(){
insertLog();    // 加入当前事务
.. 异常, 会回滚
saveDept();
}

当事务传播行为是Propagation.REQUIRED_NEW

现在有一个日志类，它的事务传播行为是Propagation.REQUIRED_NEW

Class Log{
Propagation.REQUIRED
insertLog();
}

现在，我要在保存之前记录日志

Propagation.REQUIRED
Void  saveDept(){
insertLog();
saveDept();
}

当执行到saveDept()中的insertLog()方法时，insertLog()方法发现 saveDept()已经存在事务了，insertLog()会独自新开一个事务，直到事务关闭之后，再执行下面的方法如果在中途中抛出了异常，insertLog()是不会回滚的，因为它的事务是自己的，已经提交了

Void  saveDept(){
insertLog();    // 始终开启事务
.. 异常, 日志不会回滚
saveDept();
}

http://www.gxq9182.cn/ http://www.wbd0565.cn/ http://www.evl5793.cn/ http://www.tuq2170.cn/ http://www.cwt3115.cn/ http://www.lia3012.cn/ http://www.qfc6292.cn/ http://www.vjp6092.cn/ http://www.okr2737.cn/ http://www.vwl4798.cn/ http://www.bfn6408.cn/ http://www.jvu4337.cn/ http://www.fgm2878.cn/ http://www.bdu1500.cn/ http://www.tdy5267.cn/ http://www.nyh2569.cn/ http://www.ncs7961.cn/ http://www.zth2084.cn/ http://www.zur3790.cn/ http://www.wkj3723.cn/ http://www.wac3757.cn/ http://www.xlc5825.cn/ http://www.jyf8675.cn/ http://www.mxv9381.cn/ http://www.uwy6316.cn/ http://www.dww9805.cn/ http://www.blw0160.cn/ http://www.fbw5398.cn/ http://www.mcp2369.cn/ http://www.pzq1104.cn/ http://www.sky3484.cn/ http://www.sfo7099.cn/ http://www.xbx8533.cn/ http://www.ncn6620.cn/ http://www.llu9392.cn/ http://www.eqs1683.cn/ http://www.slg6006.cn/ http://www.url9735.cn/ http://www.ney3099.cn/ http://www.vab8501.cn/ http://www.vkp1919.cn/ http://www.awt9604.cn/ http://www.igq3204.cn/ http://www.ayp2545.cn/ http://www.pgn4393.cn/ http://www.npd9270.cn/ http://www.sfi6002.cn/ http://www.nne5492.cn/ http://www.yai2320.cn/ http://www.ics4171.cn/ http://www.sfv9051.cn/ http://www.ccg1407.cn/ http://www.hjn1455.cn/ http://www.ygf6271.cn/ http://www.vfm1218.cn/ http://www.aaa4131.cn/