Spring---学习第四天（jdbcTemplate+Spring的事务控制）

墨蓝 2023-02-20 08:25 6阅读 0赞

**JdbcTemplate**

JdbcTemplate是 spring 框架中提供的一个对象，它的作用和QueryRunning一样，是对原始 Jdbc API 对象的简单封装。 spring 框架提供了很多正对不同数据库类型的模板类。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTY4MDk2Mg_size_16_color_FFFFFF_t_70]  
操作关系型数据：

> JdbcTemplate  
> HibernateTemplate

操作 nosql 数据库

> RedisTemplate

操作消息队列

> JmsTemplate

**使用JdbcTemplate的两种方式**

**方法一  在dao中定义JdbcTemplate**  
**XML配置**

<?xml version="1.0" encoding="UTF-8"?>
    <beans xmlns="http://www.springframework.org/schema/beans"
           xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
           xsi:schemaLocation="http://www.springframework.org/schema/beans
           http://www.springframework.org/schema/beans/spring-beans.xsd">
        <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
            
            <property name="driverClassName" value="com.mysql.jdbc.Driver"></property>
            <property name="url" value="jdbc:mysql://localhost:3306/test02"></property>
            <property name="username" value="root"></property>
            <property name="password" value="123456"></property>
    
        </bean>
        
        <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
            <property name="dataSource" ref="dataSource"></property>
        </bean>
    </beans>

**DaoImpl代码**

@Repository
    public class AccountDaoImpl2 implements IAccountDao { 
    
        @Autowired
        private JdbcTemplate jdbcTemplate;
    
    
        @Override
        public Account findAccountById(Integer accountId) { 
            List<Account> accounts = jdbcTemplate.query("select * from account where id = ?",new BeanPropertyRowMapper<Account>(Account.class),accountId);
            return accounts.isEmpty()?null:accounts.get(0);
        }
    
        @Override
        public Account findAccountByName(String accountName) { 
            List<Account> accounts = jdbcTemplate.query("select * from account where name = ?",new BeanPropertyRowMapper<Account>(Account.class),accountName);
            if(accounts.isEmpty()){ 
                return null;
            }
            if(accounts.size()>1){ 
                throw new RuntimeException("结果集不唯一");
            }
            return accounts.get(0);
        }
    
        @Override
        public void updateAccount(Account account) { 
            jdbcTemplate.update("update account set name=?,money=? where id=?",account.getName(),account.getMoney(),account.getId());
        }
    }

**分析**

> 在正常的开发中，当 dao 有很多时，每个 dao 都有以下重复性的代码：  
> private JdbcTemplate jdbcTemplate;  
> public void setJdbcTemplate(JdbcTemplate jdbcTemplate) \{  
> this.jdbcTemplate = jdbcTemplate;  
> \}  
> 基于解决这个问题的出发点，有了第二个JdbcTemplate的使用方式

**方法二  让 dao 继承 JdbcDaoSupport**

**示例代码如下：**

/** * 账户的持久层实现类 */
    public class AccountDaoImpl extends JdbcDaoSupport implements IAccountDao { 
    
        @Override
        public Account findAccountById(Integer accountId) { 
            List<Account> accounts = super.getJdbcTemplate().query("select * from account where id = ?",new BeanPropertyRowMapper<Account>(Account.class),accountId);
            return accounts.isEmpty()?null:accounts.get(0);
        }
    
        @Override
        public Account findAccountByName(String accountName) { 
            List<Account> accounts = super.getJdbcTemplate().query("select * from account where name = ?",new BeanPropertyRowMapper<Account>(Account.class),accountName);
            if(accounts.isEmpty()){ 
                return null;
            }
            if(accounts.size()>1){ 
                throw new RuntimeException("结果集不唯一");
            }
            return accounts.get(0);
        }
    
        @Override
        public void updateAccount(Account account) { 
            super.getJdbcTemplate().update("update account set name=?,money=? where id=?",account.getName(),account.getMoney(),account.getId());
        }
    }

**Spring 中的事务控制**

**事务控制是为了保证我们在与数据库进行交互的时候能保持一致性。**

> 第一： JavaEE 体系进行分层开发，事务处理位于业务层， Spring 提供了分层设计业务层的事务处理解决方  
> 案。  
> 第二： spring 框架为我们提供了一组事务控制的接口。这组接口是在spring-tx-5.0.2.RELEASE.jar 中。  
> 第三： spring 的事务控制都是基于 AOP 的，它既可以使用编程的方式实现，也可以使用配置的方式实现。 我们学习的重点是使用配置的方式实现。

**Spring 中事务控制的 API 介绍**

**PlatformTransactionManager**

此接口是 spring 的事务管理器，它里面提供了我们常用的操作事务的方法,以下是3个主要的方法。

*  获取事务的状态信息
    
     *  TransactionStatus getTransaction(TransactionDefinition definition)
 *  提交事务
    
     *  void commit(TransactionStatus status)
 *  回滚事务
    
     *  void rollback(TransactionStatus status)

**TransactionDefinition**

*  获取事务对象名称
    
     *  String getName()
 *  获取事务隔离级别
    
     *  int getlsolationLevel()
 *  获取事务传播行为
    
     *  int getPropagationBehavior()
 *  获取事务超时时间
    
     *  int getTimeout()
 *  获取事务是否只读
    
     *  boolean isReadOnly()

**事务的传播行为**

*  REQUIRED:如果当前没有事务，就新建一个事务，如果已经存在一个事务中，加入到这个事务中。一般的选择（默认值）
 *  SUPPORTS:支持当前事务，如果当前没有事务，就以非事务方式执行（没有事务）
 *  MANDATORY：使用当前的事务，如果当前没有事务，就抛出异常
 *  REQUERS\_NEW:新建事务，如果当前在事务中，把当前事务挂起。
 *  NOT\_SUPPORTED:以非事务方式执行操作，如果当前存在事务，就把当前事务挂起
 *  NEVER:以非事务方式运行，如果当前存在事务，抛出异常
 *  NESTED:如果当前存在事务，则在嵌套事务内执行。如果当前没有事务，则执行 REQUIRED 类似的操作。

> Spring对事务的控制方式可以有两种，一种是**基于XML的声明事务的控制方式**，另一种是**基于注解的声明事务的控制方式**。

**是否只读事务**

> 建议查询时设置为只读。

**基于XML的声明事务的控制方式**

**bean.xml**

1、 配置事务管理器  
2、 配置事务的通知  
3、 配置AOP  
4、配置切入店方法  
5、建立切入点和事务的表达式

<?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:aop="http://www.springframework.org/schema/aop"
           xmlns:tx="http://www.springframework.org/schema/tx"
           xsi:schemaLocation="
            http://www.springframework.org/schema/beans
            http://www.springframework.org/schema/beans/spring-beans.xsd
            http://www.springframework.org/schema/tx
            http://www.springframework.org/schema/tx/spring-tx.xsd
            http://www.springframework.org/schema/aop
            http://www.springframework.org/schema/aop/spring-aop.xsd">
        
        <bean id="accountService" class="com.gzgs.service.impl.AccountServiceImpl">
            <property name="accountDao" ref="accountDao"></property>
        </bean>
        <bean id="accountDao" class="com.gzgs.dao.impl.AccountDaoImpl">
            <property name="dataSource" ref="dataSource"></property>
        </bean>
    
        
        <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
            <property name="driverClassName" value="com.mysql.jdbc.Driver"></property>
            <property name="url" value="jdbc:mysql://localhost:3306/test02"></property>
            <property name="username" value="root"></property>
            <property name="password" value="123456"></property>
        </bean>
        
    
        
        <bean id="txManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
            <property name="dataSource" ref="dataSource"></property>
        </bean>
        
       <tx:advice id="txAdvice">
           <tx:attributes>
               <tx:method name="*" read-only="false" propagation="REQUIRED"/>
               <tx:method name="find*" read-only="true" propagation="SUPPORTS"></tx:method>
           </tx:attributes>
       </tx:advice>
    
        
        <aop:config>
            
            <aop:pointcut id="pt1" expression="execution(* com.gzgs.service.impl.*.*(..))"></aop:pointcut>
            
            <aop:advisor advice-ref="txAdvice" pointcut-ref="pt1">
    
            </aop:advisor>
        </aop:config>
    </beans>

**基于注解的声明事务的控制方式**

**AccountDaoImpl代码**

package com.gzgs.dao.impl;
    
    import com.gzgs.bean.Account;
    import com.gzgs.dao.AccountDao;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.jdbc.core.BeanPropertyRowMapper;
    import org.springframework.jdbc.core.JdbcTemplate;
    import org.springframework.jdbc.core.support.JdbcDaoSupport;
    import org.springframework.stereotype.Repository;
    
    import java.util.List;
    
    @Repository("accountDao")
    public class AccountDaoImpl  implements AccountDao { 
    
        @Autowired
        private JdbcTemplate jdbcTemplate;
        public Account findAccountById(int accountId) { 
            List<Account> accounts = jdbcTemplate.query("select * from account where id = ?",new BeanPropertyRowMapper<Account>(Account.class),accountId);
            return accounts.isEmpty()?null:accounts.get(0);
        }
    
    
        public Account findAccountByName(String accountName) { 
            List<Account> accounts = jdbcTemplate.query("select * from account where name = ?",new BeanPropertyRowMapper<Account>(Account.class),accountName);
            if(accounts.isEmpty()){ 
                return null;
            }
            if(accounts.size()>1){ 
                throw new RuntimeException("结果集不唯一");
            }
            return accounts.get(0);
        }
    
    
        public void updateAccount(Account account) { 
             jdbcTemplate.update("update account set name=?,money=? where id=?",account.getName(),account.getMoney(),account.getId());
        }
    }

**AccountServiceImpl代码**

package com.gzgs.service.impl;
    
    import com.gzgs.bean.Account;
    import com.gzgs.dao.AccountDao;
    import com.gzgs.service.AccountService;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Service;
    import org.springframework.transaction.annotation.Propagation;
    import org.springframework.transaction.annotation.Transactional;
    
    
    /** * 账户的业务层实现类 * * 事务控制应该都是在业务层 */
    @Service("accountService")
    //只读型事务的配置
    @Transactional(propagation = Propagation.SUPPORTS,readOnly = true)
    public class AccountServiceImpl implements AccountService { 
        @Autowired
        private AccountDao accountDao;
    
    
    
        public Account findAccountById(int accountId) { 
            return accountDao.findAccountById(accountId);
        }
        //需要的是读写型事务配置
        @Transactional(propagation = Propagation.REQUIRED,readOnly = false)
        public void transfer(String sourceName, String targetName, double money) { 
            //查询转出账户
            Account source = accountDao.findAccountByName(sourceName);
            //查询转入账户
            Account target=accountDao.findAccountByName(targetName);
            //转出账户扣钱
            source.setMoney(source.getMoney()-money);
            //转入账户加钱
            target.setMoney(target.getMoney()+money);
            //更新转出账户
            accountDao.updateAccount(source);
    // int a=2/0;
            //更新转入账户
            accountDao.updateAccount(target);
        }
    }

**bean.xml代码**

**基于纯注解的声明事务的控制方式**

**定义配置类**

**SpringConfigruation**

package config;
    
    import org.springframework.context.annotation.ComponentScan;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.context.annotation.Import;
    import org.springframework.context.annotation.PropertySource;
    import org.springframework.transaction.annotation.EnableTransactionManagement;
    
    /** * spring的配置类，相当于bean.xml */
    @Configuration
    @ComponentScan("com.gzgs")
    @PropertySource("jdbcConfig.properties")
    @Import({ jdbcConfig.class,TransactionConfig.class})
    @EnableTransactionManagement//开启Spring对注解事务支持
    public class SpringConfiguration { 
    }

**jdbcConfig**

package config;
    
    import org.aspectj.lang.annotation.Before;
    import org.springframework.beans.factory.annotation.Value;
    import org.springframework.context.annotation.Bean;
    import org.springframework.jdbc.core.JdbcTemplate;
    import org.springframework.jdbc.datasource.DriverManagerDataSource;
    
    import javax.sql.DataSource;
    
    public class jdbcConfig { 
        @Value("${jdbc.driver}")
        private String driver;
        @Value("${jdbc.url}")
        private String url;
        @Value("${jdbc.username}")
        private String username;
        @Value("${jdbc.password}")
        private String password;
    
    
        /** * 返回用于进行数据查询的JdbcTemplate对象 * @param dataSource * @return */
        @Bean(name = "jdbcTemplate")
        public JdbcTemplate createJdbcTemplate(DataSource dataSource){ 
            return new JdbcTemplate(dataSource);
        }
        /** * * 创建数据源 * @return */
        @Bean(name = "dataSource")
        public DataSource createDataSource(){ 
            DriverManagerDataSource ds = new DriverManagerDataSource();
            ds.setDriverClassName(driver);
            ds.setUrl(url);
            ds.setUsername(username);
            ds.setPassword(password);
            return ds;
        }
    }

**TransactionConfig**

package config;
    
    import org.springframework.context.annotation.Bean;
    import org.springframework.jdbc.datasource.DataSourceTransactionManager;
    import org.springframework.transaction.PlatformTransactionManager;
    import org.springframework.transaction.TransactionManager;
    
    import javax.sql.DataSource;
    
    /** * 和事务相关的配置类 */
    
    public class TransactionConfig { 
        /** * 用于创建TransactionManager * @param dataSource * @return */
        @Bean(name = "txManager")
        public PlatformTransactionManager createTransactionManager(DataSource dataSource){ 
            return new DataSourceTransactionManager(dataSource);
        }
    }

**学习代码：https://download.csdn.net/download/weixin\_45680962/12539194**  
**本博客纯属个人学习笔记，学习资源来自黑马训练营，如有错误，感激指正**

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTY4MDk2Mg_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20200626101134329.jpg?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTY4MDk2Mg==,size_16,color_FFFFFF,t_70