Spring【DAO模块】知识要点

Java3y Java3y 博客等级 墨衍会员 · AI 创作全网分发 墨衍智能分发 本文由作者通过墨衍一键同步至各平台 1分发平台 500+累计阅读 585平均单平台 已同步平台 优快云 微信公众号 微博 知乎 掘金 百家号 博客园 抖音 小红书 你的文章也可以这样分发 墨衍会员 ¥399起/年，写一次发全网 我也要 码龄9年
关注
原创 最新推荐文章于 2026-03-27 02:25:52 发布 585 阅读 AI 写同款· GEO 优化 ›
C语言实验——各位数字之和排序 C语言实验——各位数字之和排序Time Limit: 1000 ms Memory Limit: 65536 KiB Submit Statistic Discuss Problem Description给定n个正整数，根据各位数字之和从小到大进行排序。 Input输入数据有多组，每组数据占一行，每行的第一个数正整数n，表示整数个数，后面... 阅读详情 
前言
上一篇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.youkuaiyun.com/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


                

  
        

    

  






  




  

    
  




        

          

              版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
          

        

  


  
    
      【雕爷学编程】Arduino智能家居之DS18B20温度传感器
      1、温度和湿度控制：通过连接温度传感器和湿度传感器，Arduino可以实时监测室内环境的温度和湿度，并通过控制空调、加热器或加湿器等执行器，实现室内温湿度的自动调节。设计用户友好的界面和操作方式，提供简单直观的控制和反馈机制，以及考虑用户习惯和需求，能够提升系统的整体用户体验。这意味着用户可以根据自己的需求和创意，自定义和定制智能家居系统的功能和外观。5、能源管理：Arduino可以与电能监测模块和智能插座等设备结合使用，实时监测家庭能源的使用情况，并通过自动控制电器设备的开关，实现能源的有效管理和节约。
    
    阅读详情
  





    

      

        
相关推荐

        
      

      

          
            
SAP SD信贷管理实战：从配置到风险控制的完整指南（附后台路径）

              
本文详细解析了SAP SD信贷管理的完整配置流程与风险控制策略，涵盖信贷控制范围设置、风险分级机制及动态控制配置。通过实战案例和后台路径指引，帮助企业实现从客户信用评估到实时监控的全流程管理，有效降低坏账风险并优化资金安全。

            

                3a9bq4r8t2y的博客
                
                  
                    212
                
            

          
          
            
spring DAO 模块有什么作用？

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

            

                学亮编程手记
                
                  
                    691
                
            

          
          
            
TC264摄像头循迹进阶：八邻域与逐行遍历在复杂赛道边界提取中的实战对比

              
本文对比分析了TC264摄像头循迹中八邻域法与逐行遍历法在复杂赛道边界提取中的实战表现。八邻域法在边界连续性方面表现优异，适合处理环岛等复杂元素；逐行遍历法则在计算效率和岔路口识别上更具优势。文章提供了详细的代码实现和优化策略，帮助智能车竞赛选手根据赛道特点选择最佳算法方案。

            

                rainy的博客
                
                  
                    938
                
            

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

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

            

                H215919719的博客
                
                  
                    4056
                
            

          
          
            
解放双手：用KUKA示教器白键一键触发复杂工艺，自定义你的快捷指令

              
本文详细介绍了如何利用KUKA示教器的工艺白键功能，通过自定义快捷指令一键触发复杂工艺，显著提升自动化产线效率。文章涵盖UserTech技术栈解析、KRL脚本封装、人机交互视觉工程及工业实战策略，帮助工程师实现机械臂操作的高阶优化。

            

                weixin_30379531的博客
                
                  
                    432
                
            

          
          
            
AI产品经理面试宝典第94天：RAG知识库构建与预处理策略面试指南

              
本文深入解析RAG知识库构建的核心挑战与预处理策略，涵盖文档格式转换、问答对生成及自动化测试全流程，为AI产品经理提供面试必备的实战方法论与避坑指南，助你精准应对技术深度类问题。

            

                打造全国最全的AI Agent开发知识领域的博客
                
                  
                    312
                
            

          
          
            
spring 中的DAO是什么

              
在 Spring 中，DAO 是数据访问层的核心设计模式，通过解耦、模板化和标准化，显著提升代码的可维护性和可扩展性。是一种设计模式，它的核心目标是将数据访问逻辑与业务逻辑解耦，提供一种标准化的方式操作数据源（如数据库、文件、外部 API）。Spring 对 DAO 模式提供了强大的支持，通过依赖注入、模板设计模式、统一的异常体系等特性，简化了数据访问层的开发。：将数据访问逻辑（如 SQL 查询、事务管理）封装在 DAO 层，业务层（Service 层）只需调用 DAO 方法，无需关心底层数据源细节。

            

                LCY133的博客
                
                  
                    1220
                
            

          
          
            
【系统分析师】2025年上半年真题：案例分析-答案及详解（回忆版）

              
摘要： 试题一考查面向对象分析，涉及用例模型构建的四个阶段（识别参与者、合并需求、细化描述、调整模型），分析CRM系统的参与者与用例，并说明用例间的包含、扩展和泛化关系。 试题二探讨嵌入式Docker，包括容器的轻量性、可移植性及隔离性含义，10项措施与7个规范方面的对应关系，以及优化容器切换时间的三种方法（如无状态连接优化）。 试题三聚焦数据库设计，分析订单表的函数依赖与范式分解（BCNF），讨论分解后是否保持函数依赖及无损性，并针对触发器的性能缺陷提出优化方案。 试题四解析Web开发中的MVC架构与SS

            

                数据知道的博客
                
                  
                    6605
                
            

          
          
            
spring的spring-dao的配置

            

                qq_59787564的博客
                
                  
                    140
                
            

          
          
            
基于 51 单片机的智能手势控制小车设计与实现

              
智能手势控制小车以STC89C52RC 单片机为控制核心，通过手势识别模块采集用户手势指令，经单片机处理后驱动电机执行前进、后退、左转、右转等动作。该项目融合了传感器技术、单片机编程和电机驱动技术，具有成本低、易实现、互动性强的特点，适合作为嵌入式系统入门实践案例。本项目成功实现了基于 51 单片机的智能手势控制小车，通过 APDS-9960 模块采集手势信号，经单片机处理后驱动电机完成基本动作，验证了 “传感器 + 单片机 + 执行器” 的嵌入式系统设计思路。

            

                weixin_42300449的博客
                
                  
                    178
                
            

          
          
            
2026软考中级-软件设计师笔记（送最新视频教程）

              
核心口诀：运控存输输（运算器、控制器、存储器、输入、输出）例题（2019年上半年）：核心公式：数字签名流程：数字证书作用：死锁4个必要条件：死锁判断公式：处理策略：程序设计语言的四大核心成分：顺序表操作（时间复杂度）：链表操作（时间复杂度）：核心思想：频率高的字符用短编码，频率低的用长编码 → 最小化总编码长度构造步骤（贪心算法）：前提：有序表（升序/降序）
步骤：时间复杂度：O(log₂n)
例：查找中核心思想：用哈希函数将关键字映射到存储位置
哈希冲突：不同关键字映射到同一位置 → 用链地址法或开放定址

            

                
                  
                    36万+
                
            

          
          
            
解释JDBC抽象和DAO模块

              
JDBC提供了一种标准化的方式来连接、查询和操作数据库，而JDBC抽象和DAO(Data Access Object)模块是在Java应用程序中使用JDBC时常见的设计模式和概念。JDBC抽象是指将数据库访问的具体细节(如数据库驱动程序和连接管理)与应用程序逻辑分离的过程。它的主要目标是将数据库操作从应用程序的业务逻辑中分离出来，提供了一种对象化的方式来访问和操作数据库。它允许应用程序迭代检索的数据行。代表数据库中的实体或表，通常是Java类，其中包含了属性和方法，用于与数据库表的字段相对应。

            

                Blue92120的博客
                
                  
                    293
                
            

          
          
            
AUTOSAR进阶图解==＞AUTOSAR_SWS_ADCDriver

              
本文深入解析了AUTOSAR ADC Driver的架构设计和技术实现。主要内容包括：1）ADC Driver在AUTOSAR分层架构中的定位及核心功能；2）详细的模块架构设计，涵盖初始化管理、组转换管理、优先级处理等核心子组件；3）全面的配置模型说明，包括主配置类、通用配置、通道配置等关键数据结构；4）状态机机制和操作序列分析。通过分层设计和标准化接口，ADC Driver实现了硬件抽象和软件解耦，提供了良好的可移植性和可维护性。

            

                一名留德华的，康德的信徒的，专注于汽车电子领域的博客
                
                  
                    786
                
            

          
          
            
Spring的DAO模块数据库操作实例

              
Spring的DAO模块提供了对了JDBC、Hibernate、JDO等DAO层支持。DAO模块依赖于 
，MyEclipse自带的Spring DAO类库没有这两个类库，需要自己添加。 
下面以保存实体Person为例作介绍： 
      传统的JDBC编程，总免不了与Connection、Statement、PreparedStatement、ResultSet、SQLException等打交

            

                wuruiaoxue的专栏
                
                  
                    4837
                
            

          
          
            
WINCC7.3破解文件

              
WINCC7.3硬件够破解文件，有需要的下载！WINCC7.3硬件够破解文件，有需要的下载！

            

            

          
          
            
VB摄像头监控

              
该VB模块可对摄像头捕获的画面进行录像等，可在创建的窗口进行控制

            

            

          
          
            
Spring之DAO模块

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

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

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





[java] view
 plainc

            

                jerrying0203的专栏
                
                  
                    743
                
            

          
          
            
lwip-2.0.3

              
lwip是瑞典计算机科学院(SICS)的Adam Dunkels 开发的一个小型开源的TCP/IP协议栈。实现的重点是在保持TCP协议主要功能的基础上减少对RAM 的占用。

            

            

          
          
            
Spring：组成的七大模块

              
Spring 由七大模块组成，分别是Spring 核心容器（Spring Core）、应用上下文（Spring Context）、Spring面向切面编程（Spring AOP）、JDBC和DAO模块（Spring DAO）、对象实体映射（Spring ORM）、Web模块（Spring Web）以及MVC模块（SpringWebMVC）。 ...

            

                weixin_39885962的博客
                
                  
                    1万+
                
            

          
          
            
jdk-8u144-linux-x64.tar.gz.

              
该资源为搭建Linux系统Java环境用，资源的后缀为tar.gz格式的压缩包

            

            

          
          
            
Spring Dao 模块学习笔记

              
第一节：Spring的数据访问哲学Spring的目标之一就是允许开发人员进行程序开发时可以遵循面向对象中的 的原则–“针对接口编程”1Spring数据访问异常体系1.1传统的JDBC 异常: 
只有类似于SQLException这种很笼统的异常，很是鸡肋，基本上没啥用 
1.2Spring Dao层的访问异常体系： 
首先 SpringDao层的异常体系是平台无关的，也就是说不管你用hibernat

            

                JustinMJC的博客
                
                  
                    1558
                
            

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

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

            

                LoveSummer
                
                  
                    3774
                
            

          
          
            
spring-DAO

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

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

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

            

                demon7552003的小本本
                
                  
                    2967
                
            

          
          
            
spring dao层注解_Spring– DAO和服务层

              
spring dao层注解
 欢迎来到Spring教程的第三部分。 在这一部分中，我们将继续编写Timesheet应用程序，这次我们将实现DAO层，业务服务并编写一些测试。  在上一部分中，我们定义了GenericDao接口，该接口告诉我们需要对实体执行哪些操作。 现在我们需要提供实现。 我们将使用Hibernate的工具（使用SessionFactory）编写一个类来执行这些操作。 因此，任何...

            

                最佳 Java 编程
                
                  
                    9492
                
            

          
          
            
spring相关知识要点

              
1. 什么是spring?

 

Spring 是个java企业级应用的开源开发框架。Spring主要用来开发Java应用，但是有些扩展是针对构建J2EE平台的web应用。Spring 框架目标是简化Java企业级应用开发，并通过POJO为基础的编程模型促进良好的编程习惯。

 

2. 使用Spring框架的好处是什么？


	轻量：Spring 是轻量的，基本的版本大约2MB
	
	
	控制...

            

                SlagSea
                
                  
                    7014
                
            

          
          
            
解释 JDBC 抽象和 DAO 模块

              
是 Java 中最常用的数据库访问 API，它提供了一种与关系型数据库交互的标准方法。然而，原生 JDBC 的使用中存在许多缺点，例如需要手动处理数据库连接、SQL 语句和异常处理，这些操作容易导致代码冗长且难以维护。为了解决这些问题，Spring 提供了JDBC 抽象模块，以简化与数据库的交互。Spring JDBC 抽象和 DAO 模块是 Spring 数据访问层的核心组成部分，旨在简化数据库交互过程并提高代码的可维护性和可复用性。JDBC 抽象通过等工具，帮助开发者减少样板代码，专注于业务逻辑；

            

                lssffy的博客
                
                  
                    841
                
            

          
          
            
ajax关键知识点之Spring整合Hibernate的DAO层开发解析

              
本文解析了Spring整合Hibernate实现DAO层开发的关键技术。DAO层作为"数据库翻译官"，隔离业务逻辑与数据访问，提升系统可维护性。Spring通过HibernateDaoSupport简化操作，LocalSessionFactoryBean管理SessionFactory配置。文章详细介绍了DAO接口与实现类的设计模式，以及N-1和1-N关联中延迟加载的优化策略，强调通过合理配置lazy属性平衡性能。整个方案采用面向接口编程，使数据持久层具有更好的移植性，适用于轻量级Jav

            

                2301_78506709的博客
                
                  
                    698
                
            

          
          
            
(spring)Dao

              
DAO
学习dao前有数据库基础，java与数据库连接使用的是jdbc，在此前我已学习过jdbc也不再介绍jdbc，直接使用Spring的DAO模块，而在使用Spring的DAO，最基础的DAO模块对JDBC的支持。依赖于commons-dbcp.jar和commons-pool.jar。在pox中新添依赖。
<!--    jdbc-->
 ...

            

                谭宇
                
                  
                    654
                
            

          
          
            
spring-dao.xml配置

              
拿去直接用吧，用来配置spring-dao的配置文件


<?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:con...

            

                wb785074651的博客
                
                  
                    4082
                
            

          
          
            
Spring DAO

              
Spring的DAO模块提供了对JDBC、Hibernate、JDO等DAO层的支持。本节先介绍DAO模块对JDBC技术的支持
实例：保存Person实体：
1.实体类Person代码：
package com.spring.bean;

import java.util.Date;

public class Person {
	private Integer id;
	private S

            

                一直在追逐，一直在妥协
                
                  
                    758
                
            

          
      

    


  

    

      上一篇：
      
        Spring【依赖注入】就是这么简单
      
    

    

      下一篇：
      
        阅读SSM项目之scm
      
    

  



            
  



          

          


  

    
    
    
    

      点赞
      
      
            0
      
    

    
    
      评论
      
            0
      
    
    
    

      书签
      书签
      
          0
      
    

    
    
    
    
    
    
  


            

            

              

              

            

            


  

    

      
          Java3y
      
      

        

          Java3y
            
                  
                    领域专家: 后端开发技术领域
                      领域专家: 后端开发技术领域
                  
            
        

        

            
              博客等级
            
            码龄9年
          1万+粉丝
          509原创
        

      

    

    

          + 关注
    

  



        

        
      

      

        
      

      





	

		评论	
	

  

    

      

      

      

        
        

          
          

            

              成就一亿技术人!
            

            

              拼手气红包6.0元
            

          

        

        

          

            还能输入1000个字符
          

          

             
          

          

            

              表情包
              插入表情
              

                

              

            

            

              表情包
              代码片
              

                
              

            

            

              
              
              
              
              
              
              
            

          

        

      

    

		

			

			

			

					 条评论被折叠 查看
			

			

				
			

		

	

	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

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

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

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

              

            

          

      

      余额充值