引子

基于Spring的xml配置实现账户的CRUD案例
这个例子主要是熟悉一下JdbcTemplate的语法

步骤

  1. 创建java项目，导入坐标
  2. 编写Account实体类
  3. 编写AccountDao接口和实现类
  4. 编写AccountService接口和实现类
  5. 编写spring核心配置文件
  6. 编写测试代码
  1. <dependencies>
  2.     <dependency>
  3.         <groupId>mysql</groupId>
  4.         <artifactId>mysql-connector-java</artifactId>
  5.         <version>5.1.47</version>
  6.     </dependency>
  7.     <dependency>
  8.         <groupId>com.alibaba</groupId>
  9.         <artifactId>druid</artifactId>
  10.         <version>1.1.15</version>
  11.     </dependency>
  12.     <dependency>
  13.         <groupId>org.springframework</groupId>
  14.         <artifactId>spring-context</artifactId>
  15.         <version>5.1.5.RELEASE</version>
  16.     </dependency>
  17.     <dependency>
  18.         <groupId>org.aspectj</groupId>
  19.         <artifactId>aspectjweaver</artifactId>
  20.         <version>1.8.13</version>
  21.     </dependency>
  22.     <dependency>
  23.         <groupId>org.springframework</groupId>
  24.         <artifactId>spring-jdbc</artifactId>
  25.         <version>5.1.5.RELEASE</version>
  26.     </dependency>
  27.         <dependency>
  28.             <groupId>org.springframework</groupId>
  29.             <artifactId>spring-tx</artifactId>
  30.             <version>5.1.5.RELEASE</version>
  31.         </dependency>
  32.         <dependency>
  33.             <groupId>junit</groupId>
  34.             <artifactId>junit</artifactId>
  35.             <version>4.12</version>
  36.         </dependency>
  37.         <dependency>
  38.             <groupId>org.springframework</groupId>
  39.             <artifactId>spring-test</artifactId>
  40.             <version>5.1.5.RELEASE</version>
  41.         </dependency>
  42.     </dependencies>

实体以及dao层

  1. public class Account {
  2.     private Integer id;
  3.     private String name;
  4.     private Double money;
  5. }
  7. public interface AccountDao {
  8.     public List<Account> findAll();
  9.     public Account findById(Integer id);
  10.     public void save(Account account);
  11.     public void update(Account account);
  12.     public void delete(Integer id);
  13. }
  15. public class AccountDaoImpl implements AccountDao {
  17.     @Autowired
  18.     private JdbcTemplate jdbcTemplate;
  20.     @Override
  21.     public List<Account> findAll() {
  22.         String sql = "select * from account";
  23.         return jdbcTemplate.query(sql, new BeanPropertyRowMapper<Account>(Account.class));
  24.     }
  26.     @Override
  27.     public Account findById(int id) {
  28.         String sql = "select * from account where id = ?";
  29.         return jdbcTemplate.queryForObject(sql, new BeanPropertyRowMapper<Account>(Account.class), id);
  30.     }
  32.     @Override
  33.     public void save(Account account) {
  34.         String sql = "insert into account where values(null, ?, ?)";
  35.         jdbcTemplate.update(sql, account.getName(), account.getMoney());
  36.     }
  38.     @Override
  39.     public void update(Account account) {
  40.         String sql = "update account set money = ? where name = ?";
  41.         jdbcTemplate.update(sql, account.getMoney(), account.getName());
  42.     }
  44.     @Override
  45.     public void delete(int id) {
  46.         String sql = "delete from account where id = ?";
  47.         jdbcTemplate.update(sql, id);
  48.     }
  49. }

服务层

  1. public interface AccountService {
  2.     List<Account> findAll();
  3.     Account findById(int id);
  4.     void save(Account account);
  5.     void update(Account account);
  6.     void delete(int id);
  7. }
  9. @Service
  10. public class AccountServiceImpl implements AccountService {
  12.     @Autowired
  13.     private AccountDao accountDao;
  15.     @Override
  16.     public List<Account> findAll() {
  17.         return accountDao.findAll();
  18.     }
  20.     @Override
  21.     public Account findById(int id) {
  22.         return accountDao.findById(id);
  23.     }
  25.     @Override
  26.     public void save(Account account) {
  27.         accountDao.save(account);
  28.     }
  30.     @Override
  31.     public void update(Account account) {
  32.         accountDao.update(account);
  33.     }
  35.     @Override
  36.     public void delete(int id) {
  37.         accountDao.delete(id);
  38.     }
  39. }

配置文件

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <beans xmlns="http://www.springframework.org/schema/beans"
  3.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4.        xmlns:context="http://www.springframework.org/schema/context"
  5.        xsi:schemaLocation="
  6.         http://www.springframework.org/schema/beans
  7.         http://www.springframework.org/schema/beans/spring-beans.xsd
  8.         http://www.springframework.org/schema/context
  9.         http://www.springframework.org/schema/context/spring-context.xsd">
  10.     <context:component-scan base-package="com.ning"/>
  11.     <context:property-placeholder location="classpath:jdbc.properties"/>
  13.     <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
  14.         <property name="driverClassName" value="${jdbc.driverClassName}"/>
  15.         <property name="url" value="${jdbc.url}"/>
  16.         <property name="username" value="${jdbc.username}"/>
  17.         <property name="password" value="${jdbc.password}"/>
  18.     </bean>
  20.     <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
  21.         <constructor-arg name="dataSource" ref="dataSource"/>
  22.     </bean>
  24. </beans>

测试代码

  1. @RunWith(SpringJUnit4ClassRunner.class)
  2. @ContextConfiguration({"classpath:applicationContext.xml"})
  3. public class AccountServiceImplTest {
  5.     @Autowired
  6.     private AccountService accountService;
  8.     @Test
  9.     public void testSave() {
  10.         Account account = new Account();
  11.         account.setName("lux");
  12.         account.setMoney(1000d);
  13.         accountService.save(account);
  14.     }
  16.     @Test
  17.     public void testFindAll() {
  18.         final List<Account> list = accountService.findAll();
  19.         for (Account account : list) {
  20.             System.out.println(account);
  21.         }
  22.     }
  24.     @Test
  25.     public void testFindById() {
  26.         final Account byId = accountService.findById(3);
  27.         System.out.println(byId);
  28.     }
  30.     @Test
  31.     public void testUpdate() {
  32.         Account account = new Account();
  33.         account.setName("lux");
  34.         account.setMoney(2000d);
  35.         accountService.update(account);
  36.     }
  38.     @Test
  39.     public void testDelete() {
  40.         accountService.delete(4);
  41.     }
  43. }

引子2

实现一个transfer方法

  1. 创建java项目，导入坐标
  2. 编写Account实体类
  3. 编写AccountDao接口和实现类
  4. 编写AccountService接口和实现类
  5. 编写spring核心配置文件
  6. 编写测试代码
  1. <dependencies>
  2.     <dependency>
  3.         <groupId>mysql</groupId>
  4.         <artifactId>mysql-connector-java</artifactId>
  5.         <version>5.1.47</version>
  6.     </dependency>
  7.     <dependency>
  8.         <groupId>com.alibaba</groupId>
  9.         <artifactId>druid</artifactId>
  10.         <version>1.1.15</version>
  11.     </dependency>
  12.     <dependency>
  13.         <groupId>org.springframework</groupId>
  14.         <artifactId>spring-context</artifactId>
  15.         <version>5.1.5.RELEASE</version>
  16.     </dependency>
  17.         <dependency>
  18.             <groupId>org.aspectj</groupId>
  19.             <artifactId>aspectjweaver</artifactId>
  20.             <version>1.8.13</version>
  21.         </dependency>
  22.         <dependency>
  23.             <groupId>org.springframework</groupId>
  24.             <artifactId>spring-jdbc</artifactId>
  25.             <version>5.1.5.RELEASE</version>
  26.         </dependency>
  27.         <dependency>
  28.             <groupId>org.springframework</groupId>
  29.             <artifactId>spring-tx</artifactId>
  30.             <version>5.1.5.RELEASE</version>
  31.         </dependency>
  32.         <dependency>
  33.             <groupId>junit</groupId>
  34.             <artifactId>junit</artifactId>
  35.             <version>4.12</version>
  36.         </dependency>
  37.         <dependency>
  38.             <groupId>org.springframework</groupId>
  39.             <artifactId>spring-test</artifactId>
  40.             <version>5.1.5.RELEASE</version>
  41.         </dependency>
  42.     </dependencies>

entity dao

  1. public class Account {
  2.     private Integer id;
  3.     private String name;
  4.     private Double money;
  5.     // setter getter....
  6. }
  8. public interface AccountDao {
  9.     public void out(String outUser, Double money);
  10.     public void in(String inUser, Double money);
  11. }
  13. @Repository
  14. public class AccountDaoImpl implements AccountDao {
  16.     @Autowired
  17.     private JdbcTemplate jdbcTemplate;
  19.     @Override
  20.     public void out(String outUser, double money) {
  21.         String sql = "update account set money = money - ? where name = ?";
  22.         jdbcTemplate.update(sql, money, outUser);
  23.     }
  25.     @Override
  26.     public void in(String inUser, double money) {
  27.         String sql = "update account set money = money + ? where name = ?";
  28.         jdbcTemplate.update(sql, money, inUser);
  29.     }
  30. }
  1. service
  1. public interface AccountService {
  2.     void transfer(String outUser, String inUser, double money);
  3. }
  6. @Service
  7. public class AccountServiceImpl implements AccountService {
  9.     @Autowired
  10.     private AccountDao accountDao;
  12.     @Override
  13.     public void transfer(String outUser, String inUser, double money) {
  14.         accountDao.out(outUser, money);
  15.         accountDao.in(inUser, money);
  16.     }
  17. }
  1. 核心配置文件
  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <beans xmlns="http://www.springframework.org/schema/beans"
  3.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4.        xmlns:context="http://www.springframework.org/schema/context"
  5.        xmlns:aop="http://www.springframework.org/schema/aop"
  6.        xsi:schemaLocation="
  7. http://www.springframework.org/schema/beans
  8. http://www.springframework.org/schema/beans/spring-beans.xsd
  9. http://www.springframework.org/schema/context
  10. http://www.springframework.org/schema/context/spring-context.xsd
  11. http://www.springframework.org/schema/aop
  12. http://www.springframework.org/schema/aop/spring-aop.xsd">
  14.     <context:component-scan base-package="com.ning"/>
  15.     <context:property-placeholder location="classpath:jdbc.properties"/>
  16.     <aop:aspectj-autoproxy/>
  18.     <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
  19.         <property name="driverClassName" value="${jdbc.driverClassName}"/>
  20.         <property name="url" value="${jdbc.url}"/>
  21.         <property name="username" value="${jdbc.username}"/>
  22.         <property name="password" value="${jdbc.password}"/>
  23.     </bean>
  25.     <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
  26.         <constructor-arg name="dataSource" ref="dataSource"/>
  27.     </bean>
  30. </beans>
  1. 测试代码
  1. @RunWith(SpringJUnit4ClassRunner.class)
  2. @ContextConfiguration({"classpath:applicationContext.xml"})
  3. public class AccountServiceImplTest {
  4.     @Autowired
  5.     private AccountService accountService;
  6.     @Test
  7.     public void testTransfer() {
  8.         accountService.transfer("tom", "jerry", 100d);
  9.     }
  10. }
  1. <br />到目前为止其实正常情况下是实现了功能的，唯一的问题在于事务控制。现在的in和out是两个事务。

事务

Spring的事务控制可以分为编程式事务控制和声明式事务控制。
编程式
开发者直接把事务的代码和业务代码耦合到一起，在实际开发中不用。
声明式
开发者采用配置的方式来实现的事务控制，业务代码与事务代码实现解耦合，使用的AOP思想。

编程式事务

  1.  PlatformTransactionManager接口，是spring的事务管理器，里面提供了我们常用的操作事务的方法。  <br />![image.png](https://cdn.nlark.com/yuque/0/2021/png/12718322/1635102565290-f86f1e4e-e5d1-43c3-8a7c-33463717013f.png#clientId=ubd96acc2-8a08-4&from=paste&height=134&id=ucf8dbd6f&margin=%5Bobject%20Object%5D&name=image.png&originHeight=267&originWidth=1180&originalType=binary&ratio=1&size=60237&status=done&style=none&taskId=ube6a54ba-3155-42f0-88e2-b6b749fde3c&width=590)
  1. * PlatformTransactionManager 是接口类型，不同的 Dao 层技术则有不同的实现类。
  2. * Dao层技术是jdbcTemplate或mybatis时：
  3. DataSourceTransactionManager
  4. * Dao层技术是hibernate时：
  5. HibernateTransactionManager
  6. * Dao层技术是JPA时：
  7. JpaTransactionManager

TransactionDefinition

TransactionDefinition接口提供事务的定义信息（事务隔离级别、事务传播行为等等）
image.png

隔离级别

设置隔离级别，可以解决事务并发产生的问题，如脏读、不可重复读和虚读（幻读）。 

  1. * ISOLATION_DEFAULT 使用数据库默认级别
  2. * ISOLATION_READ_UNCOMMITTED 读未提交
  3. * ISOLATION_READ_COMMITTED 读已提交
  4. * ISOLATION_REPEATABLE_READ 可重复读
  5. * ISOLATION_SERIALIZABLE 串行化

事务传播行为

事务传播行为指的就是当一个业务方法【被】另一个业务方法调用时，应该如何进行事务控制。
image.png
查询一般设计成SUPPORTS 增删改用REQUIRED

事务状态

TransactionStatus 接口提供的是事务具体的运行状态
image.png
可以简单的理解三者的关系：事务管理器通过读取事务定义参数进行事务管理，然后会产生一系列的事 务状态。

声明式事务

声明式事务控制明确事项：
核心业务代码(目标对象) （切入点是谁？）
事务增强代码(Spring已提供事务管理器)）（通知是谁？）
切面配置（切面如何配置？）

例子

使用声明式事务完成案例

  1. 引入tx命名空间
  2. 事务管理器通知配置
  3. 事务管理器AOP配置
  4. 测试事务控制转账业务代码
  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <beans xmlns="http://www.springframework.org/schema/beans"
  3.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4.        xmlns:context="http://www.springframework.org/schema/context"
  5.        xmlns:aop="http://www.springframework.org/schema/aop"
  6.        xmlns:tx="http://www.springframework.org/schema/tx"
  7.        xsi:schemaLocation="
  8. http://www.springframework.org/schema/beans
  9. http://www.springframework.org/s chema/beans/spring-beans.xsd
  10. http://www.springframework.org/schema/context
  11. http://www.springframework.org/schema/context/spring-context.xsd
  12. http://www.springframework.org/schema/aop
  13. http://www.springframework.org/schema/aop/spring-aop.xsd
  14. http://www.springframework.org/schema/tx
  15. http://www.springframework.org/schema/tx/spring-tx.xsd">
  18. <context:component-scan base-package="com.ning"/>
  19.     <context:property-placeholder location="classpath:jdbc.properties"/>
  20.     <aop:aspectj-autoproxy/>
  22.     <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
  23.         <property name="driverClassName" value="${jdbc.driverClassName}"/>
  24.         <property name="url" value="${jdbc.url}"/>
  25.         <property name="username" value="${jdbc.username}"/>
  26.         <property name="password" value="${jdbc.password}"/>
  27.     </bean>
  29.     <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
  30.         <constructor-arg name="dataSource" ref="dataSource"/>
  31.     </bean>
  33.     <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
  34.         <constructor-arg name="dataSource" ref="dataSource"/>
  35.     </bean>
  37.     <tx:advice id="txAdvice" transaction-manager="transactionManager">
  38.         <tx:attributes>
  39.             <tx:method name="transfer" isolation="REPEATABLE_READ" propagation="REQUIRED" read-only="false" timeout="-1"/>
  40.         </tx:attributes>
  41.     </tx:advice>
  43.     <aop:config>
  44.         <aop:advisor advice-ref="txAdvice" pointcut="execution(* com.ning.service.impl.AccountServiceImpl.*(..))"/>
  45.     </aop:config>
  47. </beans>

CRUD常用配置

  1. <tx:attributes>
  2.   <tx:method name="save*" propagation="REQUIRED"/>
  3.   <tx:method name="delete*" propagation="REQUIRED"/>
  4.   <tx:method name="update*" propagation="REQUIRED"/>
  5.   <tx:method name="find*" read-only="true"/>
  6.   <tx:method name="*"/>
  7. </tx:attributes>

注解方式

在你想加事务的方法前面加这个注解

  1. @Transactional(propagation = Propagation.REQUIRED, isolation = Isolation.REPEATABLE_READ, timeout = -1, readOnly = false)
  1. 注意，注解可以加在类上。

然后修改配置文件，加这个

  1. <tx:annotation-driven/>

纯注解方式

  1. @Configuration
  2. @ComponentScan("com.ning")
  3. @Import(DataSourceConfig.class)
  4. @EnableTransactionManagement
  5. public class SpringConfig {
  7.     @Bean
  8.     public JdbcTemplate getJdbcTemplate(@Autowired DataSource dataSource) {
  9.         return new JdbcTemplate(dataSource);
  10.     }
  12.     @Bean
  13.     public PlatformTransactionManager getPlatformTransactionManager(@Autowired DataSource dataSource) {
  14.         return new DataSourceTransactionManager(dataSource);
  15.     }
  17. }
  20. @PropertySource("classpath:jdbc.properties")
  21. public class DataSourceConfig {
  23.     @Value("${jdbc.driverClassName}")
  24.     private String driver;
  25.     @Value("${jdbc.url}")
  26.     private String url;
  27.     @Value("${jdbc.username}")
  28.     private String username;
  29.     @Value("${jdbc.password}")
  30.     private String password;
  32.     @Bean
  33.     public DataSource getDataSource() {
  34.         final DruidDataSource dataSource = new DruidDataSource();
  35.         dataSource.setDriverClassName(driver);
  36.         dataSource.setUrl(url);
  37.         dataSource.setUsername(username);
  38.         dataSource.setPassword(password);
  39.         return dataSource;
  40.     }
  41. }

别忘了修改测试类上面的ContextConfiguration注解。

在Servlet中避免多次加载上下文对象

应用上下文对象是通过 new ClasspathXmlApplicationContext(spring配置文件) 方式获取的，但是每次从容器中获得Bean时都要编写 new ClasspathXmlApplicationContext(spring配置文件) ， 这样的弊端是配置文件加载多次，应用上下文对象创建多次。

解决思路分析：
在Web项目中，可以使用ServletContextListener监听Web应用的启动，我们可以在Web应用启动时，就加载Spring的配置文件，创建应用上下文对象ApplicationContext，在将其存储到最大的域 servletContext域中，这样就可以在任意位置从域中获得应用上下文ApplicationContext对象了。

Spring提供获取应用上下文的工具

上面的分析不用手动实现，Spring提供了一个监听器ContextLoaderListener就是对上述功能的封 装，该监听器内部加载Spring配置文件，创建应用上下文对象，并存储到ServletContext域中，提供 了一个客户端工具WebApplicationContextUtils供使用者获得应用上下文对象。
所以我们需要做的只有两件事：

  1. 在web.xml中配置ContextLoaderListener监听器（导入spring-web坐标）
  2. 使用WebApplicationContextUtils获得应用上下文对象ApplicationContext
  1.     <!--全局参数-->
  2.     <context-param>
  3.         <param-name>contextConfigLocation</param-name>
  4.         <param-value>classpath:applicationContext.xml</param-value>
  5.     </context-param>
  6.     <!--Spring的监听器-->
  7.     <listener>
  8.         <listener-class>
  9.             org.springframework.web.context.ContextLoaderListener
  10.         </listener-class>
  11.     </listener>
  1. public class AccountServlet extends HttpServlet {
  3.     @Override
  4.     protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
  5.         this.doPost(req, resp);
  6.     }
  8.     @Override
  9.     protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
  10.         final WebApplicationContext context = WebApplicationContextUtils.getWebApplicationContext(req.getServletContext());
  11.         final Account account = (Account)context.getBean("account");
  12.         System.out.println(account);
  13.     }
  14. }