Spring【DAO模块】知识要点

最新推荐文章于 2023-12-21 00:37:04 发布
最新推荐文章于 2023-12-21 00:37:04 发布
阅读量467 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Java_3y/article/details/98867271
版权 
 
 
前言
 
 
上一篇Spring博文主要讲解了如何使用Spring来实现AOP编程，本博文主要讲解Spring的DAO模块对JDBC的支持，以及Spring对事务的控制…
 
 
对于JDBC而言，我们肯定不会陌生，我们在初学的时候肯定写过非常非常多的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();        }
            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();
        }
 
 
    /*    * 连接数据库的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();            }        }    }

    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();
            }
        }
    }
 
 
 
 
使用Spring的JDBC
 
 
上面已经回顾了一下以前我们的JDBC开发了，那么看看Spring对JDBC又是怎么优化的
 
 
首先，想要使用Spring的JDBC模块，就必须引入两个jar文件：
 
 
    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();        }    }
        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();
        }
    }
 
 
    <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>
        <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();        }    }
    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();
        }
    }
 
 
<?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>
<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>
 
 
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. */@Componentpublic 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);    }}

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();    }
    public void test33() {
        ApplicationContext ac = new ClassPathXmlApplicationContext("bb/bean.xml");

        UserDao userDao = (UserDao) ac.getBean("userDao");
        userDao.save();
    }
 
 
 
  640?wx_fmt=png 
  

    这里写图片描述 
  
 
 
 
 
 
 
JdbcTemplate查询
 
 
我们要是使用JdbcTemplate查询会发现有很多重载了query()方法
 
 
 
  640?wx_fmt=png 
  

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

    这里写图片描述 
  
 
 
 
 
我们可以实现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);    }
        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);
    }
 
 
 
  640?wx_fmt=png 
  

    这里写图片描述 
  
 
 
 
 
 
 
当然了，一般我们都是将每行记录封装成一个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;        }    }

        // 如何封装一行记录
        @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来对程序进行事务控制….
 
 
一般地，我们事务控制都是在service层做的。。为什么是在service层而不是在dao层呢？？有没有这样的疑问…
 
 
service层是业务逻辑层，service的方法一旦执行成功，那么说明该功能没有出错。
 
 
一个service方法可能要调用dao层的多个方法…如果在dao层做事务控制的话，一个dao方法出错了，仅仅把事务回滚到当前dao的功能，这样是不合适的[因为我们的业务由多个dao方法组成]。如果没有出错，调用完dao方法就commit了事务，这也是不合适的[导致太多的commit操作]。
 
 
事务控制分为两种：
 
 
编程式事务控制
 
 
自己手动控制事务，就叫做编程式事务控制。
 
 
声明式事务控制
 
 
Spring提供对事务的控制管理就叫做声明式事务控制
 
 
Spring提供了对事务控制的实现。
 
 
Spring给我们提供了事务的管理器类，事务管理器类又分为两种，因为JDBC的事务和Hibernate的事务是不一样的。
 
 
 
 
声明式事务控制
 
 
我们基于Spring的JDBC来做例子吧
 
 
引入相关jar包
 
 
 
 
搭建配置环境
 
 
public interface IUser {    void save();}interface IUser {
    void save();
}
 
 
@Repositorypublic 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);    }}
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);
    }

}
 
 
@Servicepublic class UserService {    @Autowired    private UserDao userDao;    public void save() {        userDao.save();    }}
public class UserService {

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

        userDao.save();
    }
}
 
 
<?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>
<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()，即时在中途中有异常抛出，还是可以在数据库插入一条记录的。
 
 
@Servicepublic class UserService {    @Autowired    private UserDao userDao;    public void save() {        userDao.save();        int i = 1 / 0;        userDao.save();    }}
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();    }}class Test2 {

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

        UserService userService = (UserService) ac.getBean("userService");
        userService.save();
    }
}
 
 
 
  640?wx_fmt=png 
  

    这里写图片描述 
  
 
 
 
 
 
 
XML方式实现声明式事务控制
 
 
首先，我们要配置事务的管理器类：因为JDBC和Hibernate的事务控制是不同的。
 
 
    <!--1.配置事务的管理器类:JDBC-->    <bean id="txManage" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">        <!--引用数据库连接池-->        <property name="dataSource" ref="dataSource"/>    </bean>
    <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>
    <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>
    <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();    }
    public void test33() {
        ApplicationContext ac = new ClassPathXmlApplicationContext("bb/bean.xml");

        UserService userService = (UserService) ac.getBean("userService");
        userService.save();
    }
 
 
 
  640?wx_fmt=png 
  

    这里写图片描述 
  
 
 
 
 
 
 
使用注解的方法实现事务控制
 
 
当然了，有的人可能觉得到XML文件上配置太多东西了。Spring也提供了使用注解的方式来实现对事务控制
 
 
第一步和XML的是一样的，必须配置事务管理器类：
 
 
    <!--1.配置事务的管理器类:JDBC-->    <bean id="txManage" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">        <!--引用数据库连接池-->        <property name="dataSource" ref="dataSource"/>    </bean>
    <bean id="txManage" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">

        <!--引用数据库连接池-->
        <property name="dataSource" ref="dataSource"/>
    </bean>
 
 
第二步：开启以注解的方式来实现事务控制
 
 
    <!--开启以注解的方式实现事务控制-->    <tx:annotation-driven transaction-manager="txManage"/>
    <tx:annotation-driven transaction-manager="txManage"/>
 
 
最后，想要控制哪个方法事务，在其前面添加@Transactional这个注解就行了！如果想要控制整个类的事务，那么在类上面添加就行了。
 
 
    @Transactional    public void save() {        userDao.save();        int i = 1 / 0;        userDao.save();    }
    public void save() {

        userDao.save();

        int i = 1 / 0;
        userDao.save();
    }
 
 
 
  640?wx_fmt=png 
  

    这里写图片描述 
  
 
 
 
 
 
 
事务属性
 
 
其实我们在XML配置管理器类如何管理事务，就是在指定事务的属性！我们来看一下事务的属性有什么：
 
 
 
  640?wx_fmt=png 
  

    这里写图片描述 
  
 
 
 
 
对于事务的隔离级别，不清楚的朋友可参考我之前的博文：http://blog.csdn.net/hon_3y/article/details/53760782
 
 
事务传播行为:
 
 
看了上面的事务属性，没有接触过的其实就这么一个：propagation = Propagation.REQUIRED事务的传播行为。
 
 
事务传播行为的属性有以下这么多个，常用的就只有两个：
 
 
 
  640?wx_fmt=png 
  

    这里写图片描述 
  
 
 
 
 
当事务传播行为是Propagation.REQUIRED 
 
 
    Class Log{            Propagation.REQUIRED              insertLog();      }REQUIRED  
            insertLog();  
    }
 
 
    Propagation.REQUIRED    Void  saveDept(){        insertLog();           saveDept();    }
        insertLog();   
        saveDept();
    }
 
 
saveDept()本身就存在着一个事务，当调用insertLog()的时候，insertLog()的事务会加入到saveDept()事务中
 
 
也就是说，saveDept()方法内始终是一个事务，如果在途中出现了异常，那么insertLog()的数据是会被回滚的【因为在同一事务内】
 
 
    Void  saveDept(){        insertLog();    // 加入当前事务        .. 异常, 会回滚        saveDept();    }
        insertLog();    // 加入当前事务
        .. 异常, 会回滚
        saveDept();
    }
 
 
 
 
当事务传播行为是Propagation.REQUIRED_NEW 
 
 
    Class Log{            Propagation.REQUIRED              insertLog();      }REQUIRED  
            insertLog();  
    }
 
 
    Propagation.REQUIRED    Void  saveDept(){        insertLog();           saveDept();    }
        insertLog();   
        saveDept();
    }
 
 
当执行到saveDept()中的insertLog()方法时，insertLog()方法发现 saveDept()已经存在事务了，insertLog()会独自新开一个事务，直到事务关闭之后，再执行下面的方法
 
 
如果在中途中抛出了异常，insertLog()是不会回滚的，因为它的事务是自己的，已经提交了
 
 
    Void  saveDept(){        insertLog();    // 始终开启事务        .. 异常, 日志不会回滚        saveDept();    }
        insertLog();    // 始终开启事务
        .. 异常, 日志不会回滚
        saveDept();
    }
 
 
 
 
 
  
如果文章有错的地方欢迎指正，大家互相交流。习惯在微信看技术文章，想要获取更多的Java资源的同学，可以关注微信公众号:Java3y
 
 
 
 

 


                

        

        

    




    

      

        

            

              
                
                  Java3y
                
              
            

            

                关注
              
            

        

        

          
    
            
  • 
              
                
                
                
                
                      0
                
              
              
    点赞
    
            
    • 
            
  • 
              
                
                
                
              
              
    踩
    
            
    • 
            
  • 
              
                
                
                
                
                    0
                
              
              
    
                
    
                  
                    收藏
                  
                
    
              
    
              
    
                
    
                  觉得还不错?
                  
                    一键收藏
                  
                 
                
    
              
    
            
    • 
          
  • 
            
    
              
              
            
    
              
              
              
                    0
              
            
            
    评论
    
          
    • 
          
  • 
          
    • 
          
  • 
            
              
            
              
    
            
              
                
            
    
          
    • 
        

      

      










                



	

		

			

				
					
Spring之DAO模块

				
			

			

				

					冰河
				

				

					03-10
					
					3924
					
				

			

		

		

			
				
Spring的DAO模块提供了对JDBC、Hibernate、JDO等DAO层支持

DAO模块依赖于commons-pool.jar、commons-collections.jar

Spring完全抛弃了JDBC API，开发者只需要使用封装好的JdbcTemplate执行SQL语句，然后得到需要的结果

DAO层业务逻辑




public interface IpersonDao{
...

			
		

	



                

              
                



	

		

			

				
					
邹波spring

				
			

			

				

					05-10
				

			

		

		

			
				
通过邹波老师的Spring视频教程和笔记，我们可以系统地学习到Spring框架的核心知识和技术要点。无论是初学者还是有一定经验的开发者，都能够从中获益匪浅。Spring框架作为目前最流行的Java企业级开发框架之一，掌握其...

			
		

	



                


  
              

                


	

		

			

				
					
spring DAO 模块有什么作用？

				
			

			

				

					学亮编程手记
				

				

					11-22
					
					410
					
				

			

		

		

			
				
DAO的主要作用是封装对数据存储的访问细节，使业务逻辑层与具体的数据存储技术（如关系型数据库、NoSQL数据库等）解耦，提供了一种更加灵活和可维护的数据访问方式。使用DAO的好处在于，它将数据访问相关的代码与业务逻辑代码进行分离，提供了一种清晰的层次结构，使代码更加模块化和可维护。这些技术与DAO的概念结合使用，可以更好地支持数据访问层的开发。通过使用JDBC抽象和DAO模块，保证数据库代码的简洁，并能避免数据库资源错误关闭导致的问题，它在各种不同的数据库的错误信息之上，提供了一个统一的异常访问层。

			
		

	





	

		

			

				
					
一篇带你走进程序设计的准则——DAO和MVC设计模式

				
			

			

				

					H215919719的博客
				

				

					10-21
					
					3356
					
				

			

		

		

			
				
DAO（Data Access Object，数据访问对象）的主要功能就是操作数据库，也就是数据的增删改查。接下来分别介绍每一层的功能。（1）客户层：目前采用B/S开发架构居多，客户使用浏览器访问，当然也可以使用别的工具访问。（2）显示层：使用JSP/Servlet进行页面显示。（3）业务层：负责将DAO层的操作进行组合，形成一个完整的业务逻辑。（4）数据层：提供原子性操作，比如增加、删除、修改、查询。那么Model、View、Controller分别在应用程序中代表什么呢？

			
		

	



		

			
		



	

		

			

				
					
Spring七大模块之DAO（上）

				
			

			

				

					qq_21954477的博客
				

				

					09-14
					
					2964
					
				

			

		

		

			
				
Spring的Dao模块式Spring框架中对应持久层的解决方式，提供了对JDBC、Hibernate、JDO等DAO层支持。 
Spring框架对JDBC进行了封装，完全抛弃了JDBC API。数据库连接、事务等也交给了Spring打点，开发者只需要使用封装好的JdbcTemplate执行SQL语句，然后得到需要的结果。 
需要的包： 
 
项目目录： 
 
User.javapublic cla

			
		

	





	

		

			

				
					
DAO简单介绍

				
			

			

				

					KyrieOH的博客
				

				

					03-17
					
					993
					
				

			

		

		

			
				
DAO简单介绍
DAO模式介绍
DAO代表数据访问对象（Data Access Object）,它描述了一个应用中DAO的角色。DAO的存在提供了读写数据库中数据的一种方法，把这个功能通过接口提供对外服务，程序中的其他模块通过这些接口来访问数据库

DAO的主要目的就是将持久性相关的问题与一般的业务规则和工作流程隔离开来，它为定义业务层可以访问的持久性操作引入了一个接口并隐藏了实现的具体细节。该接...

			
		

	





	

		

			

				
					
spring-DAO

				
			

			

				

					demon7552003的小本本
				

				

					08-24
					
					2660
					
				

			

		

		

			
				
使用DAO ( Data Access Object ，数据访问对象）设计模式，以便将低级别的数据访问逻辑与高级别的业务逻辑分离。

Spring中的DAO层能够以一致的方式轻松处理JDBC 、Hibernate或JPA等数据的访问技术，这使得可以相当容易地在上述持久化技术之间进行切换。

同时，Spring 的DAO层对各种技术的异常进行了封装，以便开发者能够使用统一的异常，而无须担心捕捉每种技...

			
		

	





	

		

			

				
					
Spring框架入门教程

				
			

			

				

					12-09
				

			

		

		

			
				
### Spring框架入门教程知识点详解  #### 一、Spring框架基础知识 ...通过上述步骤，不仅可以完成Spring框架的基础搭建，还可以理解Spring框架的核心概念和技术要点。这对于初学者来说是一个很好的实践起点。

			
		

	





	

		

			

				
					
SPRING面试宝典

				
			

			

				

					01-04
				

			

		

		

			
				
### SPRING面试宝典知识点详解  #### 一、Spring概述 ...以上就是从给定文件的标题、描述、标签和部分内容中提取出的相关知识点详解，希望能帮助读者更好地理解和掌握Spring框架的核心概念和技术要点。

			
		

	





	

		

			

				
					
[Spring 深度解析]第5章 Spring之DAO

				
			

			

				

					LoveSummer
				

				

					12-23
					
					3258
					
				

			

		

		

			
				
JDBC（Java DB Connection，Java数据库连接）是一种可用于执行SQL语句的Java API（Application Programming Interface，应用程序设计接口）。它由一些Java语言编写的类和界面组成。JDBC为数据库应用开发人员和数据库前台工具开发人员提供了一种标准的应用程序设计接口，使开发人员可以用纯Java语言编写完整的数据库应用程序。JDBC代表Java数据库连接。它是一个软件层，允许开发者在Java中编写客户端／服务器应用。

			
		

	





	

		

			

				
					
spring DAO

				
			

			

				

					LeZhi_126的博客
				

				

					09-10
					
					780
					
				

			

		

		

			
				
Spring 数据访问(DAO层) 总结

统一的异常体系

Spring本质上希望以统一的方式整合底层的持久化技术：以统一的方式进行调用及事务管理，避免让具体的实现侵入到业务层的代码中。由于每个持久化实现技术都有各自的异常体系，所以Spring提供了统一的异常体系，使不同异常体系的阻抗得以弥消，方便定义出和具体实现技术无关的DAO接口，以及整合到相同的事务管理体系中。

DAO（Data Acc...

			
		

	





	

		

			

				
					
Spring DAO

				
			

			

				

					李帅的博客
				

				

					04-15
					
					749
					
				

			

		

		

			
				
Spring DAO

阅读目录Spring DAO一  什么是DAO简介二  Spring DAO 中的核心类 JdbcTemplate1、如何获取到JdbcTemplate2、继承JdbcDaoSupport
一  什么是DAO
简介
DAO Data Access Object 数据访问对象 数据访问面向对象化
Spring 支持DAO 主要体现在下面三个方面：

对 JDBC 进行了简化和封装 可以更加方便的编写 DAO 组件
对JDBC 的 事务进行了封装 提供了AOP 模型的事务管理
对JDBC

			
		

	





	

		

			

				
					
Spring DAO模式

				
			

			

				

					m0_71001684的博客
				

				

					05-25
					
					199
					
				

			

		

		

			
				
/ 唯一性标识// 姓名// 年龄// 性别return id;return age;return sex;代码如下：// 添加用户信息的方法// 操作数据库的数据源对象，通过它创建一个数据库连接对象与数据库进行连接// 注入DataSource// 向数据表tb_user中添加数据// 获取姓名// 获取年龄// 获取性别// 定义Connection// 定义Statementtry {// 获取数据库连接。

			
		

	





	

		

			

				
					
Maven——分模块开发与设计（重点）

				
			

			

				

					weixin_51351637的博客
				

				

					11-26
					
					1419
					
				

			

		

		

			
				
目录一、模块拆分 1.1 模块拆分思想  1.2  pojo模块拆分 1.3  dao模块拆分 1.4 service模块拆分 1.5 controller模块拆分二、 聚合——模块聚合三、继承——模块继承左侧：我们从前的架构，一个人独立做的所有工作文件都在src目录下右侧：以后我们的工程都会按照模块化开发，通过多模块的合作，来完成我们的项目  按照下面的图示进行操作，真的非常简单 注意这个地方的parent我们先设置一个None，这个地方我们后面会说 如果进到这个页面发现下面的包没有颜色，不要着急，点击O

			
		

	





	

		

			

				
					
DAO相关基础

				
			

			

				

					m0_56557880的博客
				

				

					10-27
					
					1049
					
				

			

		

		

			
				
1.DAO定义：

DAO（DataAccessObjects 数据存取对象）是指代位于业务逻辑和持久化数据的访问，通俗就是对数据库操作的封装。

2.DAO的组成部分：

DAO接口：对数据库的所有操作定义成抽象方法

DAO实现类：对不同的数据库提供不同的实现方法

实体类：存放和实现数据的传递

数据库连接和关闭工具类：避免数据库的连接和关闭代码的重复使用，方便修改

3.servlet+dao+jsp的流程思路：

创建实体类用来传递数据库中的数据，所以属性和数据库中的字段要保持相同，

导入Bas

			
		

	





	

		

			

				
					
4、spring详解-spring DAO

					
最新发布

				
			

			

				

					qq_40119247的博客
				

				

					12-21
					
					357
					
				

			

		

		

			
				
把加载驱动、连接数据库与释放资源等重复操作提取出来，做成公共的独立模块，使用时只需调用即可，方便简洁，这便是jdbcTemplete。数据库有好多种，例如MySQL、Oracle等，需要注册不同的驱动来操作对应的数据库，所以首先要将驱动引入项目。数据库和应用程序是分隔开来的，数据库可能存放在远程其他服务中，所以注册驱动之后，我们要把应用程序跟数据库连接到一起。数据库执行完增、删、改、查操作结束之后，返回给程序一个结果，成功、失败或者查询的数据。最后，所有操作都执行完毕，需要关闭资源，以免造成资源的浪费。

			
		

	





	

		

			

				
					
Spring 对 DAO 的支持

				
			

			

				

					weixin_30783629的博客
				

				

					07-26
					
					215
					
				

			

		

		

			
				
一、Spring 的 DAO 理念
DAO（Data Access Object）是用于访问数据的对象，虽然在大多数情况下将数据保存在数据库中，但这并不是唯一的选择，也可以将数据存储到文件中或 LDAP 中。DAO 不但屏蔽了数据存储的最终介质的不同，也屏蔽了具体的实现技术的不同。
早期，JDBC 是访问数据库的主流选择。近几年，数据持久化技术获得了长足的发展，Hibernate、M...

			
		

	





	

		

			

				
					

				
			

			

				

					
				

			

		

		

			
				

			
		

	



              




          




        



    





    



      

      

        
      

      





	

		评论	
	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

                
 1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
 2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

              

            

          

      

      余额充值