Spring框架开发的三种模式

第一节 IoC的综合案例 - 纯xml开发

1.1综合案例描述

案例的需求

实现账户表的增删改查操作

案例的要求

选用基于XML的Spring和Mybatis整合配置实现。

• 数据库表结构介绍

CREATE TABLE `account` (
`id`  int(11) NOT NULL ,
`name`  varchar(20) CHARACTER SET utf8 COLLATE utf8_general_ci NULL DEFAULT NULL ,
`money`  double NULL DEFAULT NULL ,
PRIMARY KEY (`id`)
)
ENGINE=InnoDB
DEFAULT CHARACTER SET=utf8 COLLATE=utf8_general_ci
ROW_FORMAT=COMPACT

1.2 案例的实现

1.2.1 创建工程导入坐标

<dependencies>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>5.1.9.RELEASE</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-jdbc</artifactId>
        <version>5.1.9.RELEASE</version>
    </dependency>
    <dependency>
        <groupId>org.mybatis</groupId>
        <artifactId>mybatis</artifactId>
        <version>3.5.2</version>
    </dependency>
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>5.1.47</version>
    </dependency>
    <dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>druid</artifactId>
        <version>1.1.20</version>
    </dependency>
    <dependency>
        <groupId>org.mybatis</groupId>
        <artifactId>mybatis-spring</artifactId>
        <version>2.0.1</version>
    </dependency>
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.12</version>
    </dependency>
</dependencies>

1.2.2 编写基础代码

/**
 * 账户的实体类
 */
public class Account {

    private Integer id;
    private String name;
    private Double money;

	//省略set,get,toString等方法
}

/**
 * 账户的业务层接口
 */
public interface AccountService {
    /**
     * 保存
     */
    void save(Account account);

    /**
     * 根据id删除
     */
    void delete(Integer id);

    /**
     * 更新账户
     */
    void update(Account account);

    /**
     * 根据id查询
     */
    Account findById(Integer id);

    /**
     * 根据名称查询账户
     */
    Account findByName(String name);

    /**
     * 查询所有
     */
    List<Account> findAll();
}

/**
 * 账户业务接口实现类
 */
public class AccountServiceImpl implements AccountService {

     // 依赖注入  通过依赖注入可以实现service调用dao的增删改查方法 通过方法进行增删改查的调用
    // 调用dao的时候要有接口所对应的SQL文件
    private AccountDao accountDao;

    public void setAccountDao(AccountDao accountDao) {
        this.accountDao = accountDao;
    }

    @Override
    public void save(Account account) {
        accountDao.save(account);
    }

    @Override
    public void delete(Integer id) {
        accountDao.delete(id);
    }

    @Override
    public void update(Account account) {
        accountDao.update(account);
    }

    @Override
    public Account findById(Integer id) {
        return accountDao.findById(id);
    }

    @Override
    public Account findByName(String name) {
        return accountDao.findByName(name);
    }

    @Override
    public List<Account> findAll() {
        return accountDao.findAll();
    }
}

/**
 * 账户持久层接口
 */
public interface AccountDao {
    /**
     * 保存
     */
    void save(Account account);

    /**
     * 根据id删除
     */
    void delete(Integer id);

    /**
     * 更新账户
     */
    void update(Account account);

    /**
     * 根据id查询
     */
    Account findById(Integer id);

    /**
     * 根据名称查询账户
     */
    Account findByName(String name);

    /**
     * 查询所有
     */
    List<Account> findAll();
}

1.2.3 编写mybatis的映射配置

<?xml version="1.0" encoding="utf-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.itheima.dao.AccountDao">

    <!--保存-->
    <insert id="save" parameterType="account">
        insert into account values(#{id},#{name},#{money})
    </insert>

    <!--根据id删除-->
    <delete id="delete" parameterType="int" >
        delete from account where id=#{id}
    </delete>

    <!--更新账户-->
    <update id="update" parameterType="account">
        update account set name=#{name},money=#{money} where id=#{id}
    </update>

    <!--根据id查询-->
    <select id="findById" parameterType="int" resultType="account">
        select * from account where id=#{id}
    </select>

    <!--根据名称查询账户-->
    <select id="findByName" parameterType="string" resultType="account">
        select * from account where name=#{name}
    </select>

    <!--查询所有-->
    <select id="findAll" resultType="account">
        select * from account
    </select>
</mapper>

1.2.4 连接数据库

jdbc.driverClassName=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/database?useUnicode=true&characterEncoding=UTF-8&serverTimezone=Asia/Shanghai
jdbc.username=root
jdbc.password=root
# 连接数据库

1.2.5 编写spring和mybatis整合配置

<?xml version="1.0" encoding="UTF-8"?>
<!-- Spring配置文件并导入约束 -->
<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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">
    <!-- SpringContext spring核心配置文件 -->
    <!-- dao层内容 -->
    <!-- 1.连接数据库的配置文件 -->
    <context:property-placeholder location="classpath:jdbc.properties"/>
    <!-- 2.配置Druid数据源 -->
    <bean id="druidDataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="driverClassName" value="${jdbc.driverClassName}"/>
        <property name="url" value="${jdbc.url}"/>
        <property name="username" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.password}"/>
    </bean>
    <!-- 3.配置SqlSessionFactory的对象 是为了让spring完成mybatis的对象创建的时候，可以知道通过SqlSessionFactoryBean就能帮助找到mybatis所用到的sqlsession -->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <!-- 数据源 -->
        <property name="dataSource" ref="druidDataSource"/>
        <!-- pojo的别名映射-->
        <property name="typeAliasesPackage" value="com.zhuxu.pojo"/>
    </bean>
    <!-- 4.配置dao层代码动态代理对象生成的扫描器 -->
    <bean id="mapperScannerConfigurer" class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <!-- 指定扫描的dao层的路径 -->
        <property name="basePackage" value="com.zhuxu.dao"/>
    </bean>
    <!-- 5.service层内容 spring的配置 -->
    <bean id="accountService" class="com.zhuxu.service.impl.AccountServiceImpl">
        <!-- 依赖注入 -->
        <property name="accountDao" ref="accountDao"/>
    </bean>
</beans>

1.2.6 测试

/*
测试类
 */
public class CRUDTest {
    @Test
    public void findByName(){
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("ApplicationContext.xml");
        AccountService accountService = applicationContext.getBean(AccountService.class);
        Account account = accountService.findByName("迪丽热巴");
        System.out.println("account = " + account);
    }

    @Test
    public void findAll(){
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("ApplicationContext.xml");
        AccountService accountService = applicationContext.getBean(AccountService.class);
        List<Account> accountList = accountService.findAll();
        for (Account account : accountList) {
            System.out.println("account = " + account);
        }
    }
}

第二节 注解开发

2.1 bean标签和注解的对应

• bean标签对应注解@Component对应的是把xml配置文件中impl文件替换掉 替换如下的代码

• 如：

  @Component("accountDao")
  public class AccountDaoImpl implements AccountDao {
      @Override
      public void saveAccount() {
          System.out.println("模拟保存账户");
      }
  }
  

  就不用在xml中写以下代码

  <!--配置accountService对象-->
  <bean id="accountService" class="com.itheima.service.impl.AccountServiceImpl"></bean>
  

  但是beans.xml配置没有指定接口实现类对象所以就需要开启springioc的注解扫描，扫描包中类的注解

  <context:component-scan base-package="com.itheima"></context:component-scan>
  

• • 注解属性value：bean标签的id属性
  • 不指定value属性，默认就是类名，首字母小写
  • 该注解衍生出了三个注解，@Controller(在servlet层),@Service（service层）,@Repository（dao层 ），用法和@Componet一致，为了更加清晰的提现层的概念。

• bean标签属性scope对应注解@Scope

  • 注解属性value：singleton，prototype

• bean标签属性init-method对应注解@PostConstruct 构造方法执行完毕后执行

• bean标签属性destroy-method对应注解@PreDestroy 对象销毁前执行的方法

• service层

  public interface AccountService {
  
      //模拟保存账户
      void save();
  }
  

  //@Component("accountService")
  @Service("accountService")
  @Scope("prototype")
  public class AccountServiceImpl implements AccountService {
  
      private AccountDao accountDao;
  
      public void setAccountDao(AccountDao accountDao) {
          this.accountDao = accountDao;
      }
  
      @Override
      public void saveAccount() {
          accountDao.saveAccount();
      }
  }
  

• dao层

  public interface AccountDao {
  
      //模拟保存账户
      void save();
  }
  

  //@Component("accountDao")
  @Repository("accountDao")
  public class AccountDaoImpl implements AccountDao {
      @Override
      public void saveAccount() {
          System.out.println("保存了账户");
      }
  
      private void init() {
          System.out.println("AccountDao对象初始化");
      }
  
      private void destroy() {
          System.out.println("AccountDao对象 销毁了");
      }
  }
  

• 添加applicationContext配置文件命名空间

  <?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"
         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"
  >
      
      <!-- 开启spring的注解扫描，扫描包中类的注解-->
      <context:component-scan base-package="com.itheima"></context:component-scan>
  </beans>
  

• 测试注解

  @Test
  public void testIOC(){
      ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
      AccountService accountService = context.getBean(AccountService.class);
      AccountDao accountDao = context.getBean(AccountDao.class);
  
      System.out.println(accountService);
      System.out.println(accountDao);
  
      context.close();
  }
  

2.2 依赖注入注解

之前是私有化一对象，通过get或者set的方法进行依赖注入

   private AccountDao accountDao;

    public void setAccountDao(AccountDao accountDao) {
        this.accountDao = accountDao;
    }

• @Autowired注解（Spring框架提供）通过类型自动注入

  @Autowired
  private AccountDao accountDao;
  

• 当接口的实现类不止一个时，无法通过类型自动注入了

  按照类型注入，如果无法确定唯一类型（接口有多个实现类），需要配合注解@Qualifier的使用

• @Qualifier("id") 注解（Spring框架提供）

  • 按照id注入

• @Resource注解（JDK提供）

  • 注解属性name：配置类的id

@Resource(name="accountDao")
private AccountDao accountDao;

代码演示

• 业务层

@Service("accountService")
@Scope("singleton")
public class AccountServiceImpl implements AccountService {

     @Autowired
    //@Qualifier("accountDao2")
    //@Resource(name = "accountDao2")
    private AccountDao accountDao;

    @Override
    public void saveAccount(Account account) {
        accountDao.saveAccount(account);
    }
}

• dao层

package com.itheima.dao.impl;

/**
 * 账户dao实现类
 */
@Component("accountDao")
//@Repository("accountDao")
@Scope("singleton")
public class AccountDaoImpl implements AccountDao {

    @Override
    public void saveAccount(Account account) {
        System.out.println("模拟转账");
    }

    @PostConstruct()
    public void init(){
        System.out.println("AccountDaoImpl 初始化...");
    }

    @PreDestroy
    public void destroy(){
        System.out.println("AccountDaoImpl 销毁...");
    }
}

2.3 Spring对Junit的支持

• junit运行的时候底层使用了Runner对象，有一个默认使用的Runner对象。
• Spring对junit的支持，其实是自己实现了一个Runner对象（按照junit runner的要求实现）
• Spring对junit的支持的体现
  • 好处一：配置完之后，不需要我们手动的启动Spring
  • 好处二：可以在junit测试类中使用@AutoWired等方式注入对象，直接对其进行调用测试
• 使用步骤
  • 引入spring-test.jar包
  • 配置测试类

  //Spring框架中的Runner对象, 替换Junit中的Runner对象 （更换启动器  或者叫更换执行对象）
  @RunWith(SpringJUnit4ClassRunner.class)

  //框架启动入口, xml配置文件启动(2选1)加载xml启动执行配置文件  可以加载多个配置文件
  @ContextConfiguration(locations = "classpath:beans.xml")
  //框架启动入口, 注解方式配置文件启动(2选1)  纯注解开发推荐使用
  //@ContextConfiguration(classes = SpringConfig.class)

• 代码实现

  • pom.xml

  <dependencies>
      <dependency>
          <groupId>org.springframework</groupId>
          <artifactId>spring-context</artifactId>
          <version>5.1.9.RELEASE</version>
      </dependency>
      <dependency>
          <groupId>junit</groupId>
          <artifactId>junit</artifactId>
          <version>4.12</version>
      </dependency>
      <dependency>
          <groupId>org.springframework</groupId>
          <artifactId>spring-test</artifactId>
          <version>5.1.9.RELEASE</version>
      </dependency>
  </dependencies>
  

  • 测试类

  package com.itheima;
  
  //Spring框架中的Runner对象, 替换Junit中的Runner对象
  @RunWith(SpringJUnit4ClassRunner.class)
  //框架启动入口, 注解方式配置文件启动
  //@ContextConfiguration(classes = SpringConfig.class);
  //框架启动入口, xml配置文件启动
  @ContextConfiguration(locations = "classpath:ApplicationContext.xml")
  public class AccountTest {
  
      //注入业务层接口
      @Autowired
      private AccountService service;
  
      @Test
      public void testIOC(){
  
          System.out.println("service = " + service);
          Account account = new Account();
          account.setName("小米");
          account.setMoney(888.0F);
          service.saveAccount(account);
      }
  }
  

第三节 IoC的综合案例(CRUD) - 半注解半xml开发

企业主流的开发方式

注意：往往第三方jar中的对象我们使用xml配置（比如druid数据库连接池、Mybatis的SQLSessionFactory）,类似于service层和dao层的实现类，这属于我们自己写的代码，往往会使用注解，这就是半xml半注解的模式。

• applicationContext.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"
         xmlns:context="http://www.springframework.org/schema/context"
         xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">
  
      <!--配置dao-->
      <!--配置properties文件的位置-->
      <context:property-placeholder location="classpath:jdbc.properties"></context:property-placeholder>
      <!--配置数据源-->
      <bean id="druidDataSource" class="com.alibaba.druid.pool.DruidDataSource">
          <property name="driverClassName" value="${jdbc.driverClassName}"></property>
          <property name="url" value="${jdbc.url}"></property>
          <property name="username" value="${jdbc.username}"></property>
          <property name="password" value="${jdbc.password}"></property>
      </bean>
      <!--配置mybatis的SqlSessionFactory工厂-->
      <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
          <property name="dataSource" ref="druidDataSource"></property>
          <property name="typeAliasesPackage" value="com.itheima.pojo"></property>
      </bean>
      <!--配置创建dao代理实现类的扫描器-->
      <bean id="mapperScannerConfigurer" class="org.mybatis.spring.mapper.MapperScannerConfigurer">
          <property name="basePackage" value="com.itheima.dao"></property>
      </bean>
  
      <!--配置service-->
      <!--让Spring开启注解扫描-->
      <context:component-scan base-package="com.itheima"></context:component-scan>
  </beans>
  

• service层

  package com.itheima.service.impl;
  
  /**
   * 账户业务接口实现类
   */
  @Service("accountService")
  public class AccountServiceImpl implements AccountService {
  
      //依赖注入
      @Autowired
      private AccountDao accountDao;
  
      //增删改查方法 无修改, 笔记中代码省略
      
  }
  

• 测试类

/*
测试类
 */
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = {"classpath:ApplicationContext.xml"})
public class AccountServiceTest {

    @Autowired
    private AccountService accountService;

    //测试类方法省略
    @Test
    public void findAll() {
        List<Account> accountList = accountService.findAll();
        for (Account account : accountList) {
            System.out.println("account = " + account);
        }
    }
}

第四节 IoC的综合案例(CRUD) - 纯注解开发

• @Configuration标识当前类是Spring的一个配置类

• @ComponentScan替代xml中的<context:component-scan/>

• @Import引入其他配置类,被引入的配置类可以不加@Configuration注解

• @PropertySource：引入外部properties文件，注意加classpath:

• @Value对成员变量赋值

• @Bean将一个方法的返回值对象加入到Spring的容器当中管理

• @Qualifier可以使用在方法参数上，表明对应的形参引入/注入的对象类型

4.1 SpringConfig框架启动配置类

只要在一个类上加@Configuration,那么这个类就是spring的配置类

/**
 * Spring框架的核心配置文件（注解配置）
 * @author Lucky
 * @date 2020/8/29
 */
// 标识当前类是spring的一个配置类
@Configuration
// 开启SpringIOC容器的注解扫描
/**
 * xml代码
 *   <!-- 扫描包，开启注解 -->
 *     <context:component-scan base-package="com.zhuxu" />
 * */

@ComponentScan({"com.zhuxu"})
// 加载properties配置文件
// @PropertySource({"classpath:jdbc.properties"})
public class SpringConfig {
    // 配置数据源
    /**
     * xml源码
     * <!-- 配置Druid数据源 -->
     *     <bean id="druidDataSource" class="com.alibaba.druid.pool.DruidDataSource">
     *         <property name="driverClassName" value="${jdbc.driverClassName}"/>
     *         <property name="url" value="${jdbc.url}"/>
     *         <property name="username" value="${jdbc.username}"/>
     *         <property name="password" value="${jdbc.password}"/>
     *     </bean>
     */
    @Bean("druidDataSource")
    public DataSource createDataSource(){
        DruidDataSource druidDataSource = new DruidDataSource();
        // 配置相关驱动信息（驱动、url、用户名、密码）
        druidDataSource.setDriverClassName("com.mysql.jdbc.Driver");
        druidDataSource.setUrl("jdbc:mysql://localhost:3306/ssm_lx");
        druidDataSource.setUsername("root");
        druidDataSource.setPassword("root");

        return  druidDataSource;

    }

    // 配置SqlSessionFactory对象
    // 参数DataSource dataSource，会自动从Spring IOC容器中找配置的Bean对象
    /**
     * 配置SqlSessionFactory对象xml源码
     * <!-- 配置SqlSessionFactory的对象 是为了让spring完成mybatis的对象创建的时候，可以知道通过SqlSessionFactoryBean就能帮助找到mybatis所用到的sqlsession
     * -->
     *     <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
     *         <!-- 数据源 -->
     *         <property name="dataSource" ref="druidDataSource"/>
     *         <!-- pojo的别名映射-->
     *         <property name="typeAliasesPackage" value="com.zhuxu.pojo"/>
     *     </bean>
     * */
    @Bean
    public SqlSessionFactoryBean createSqlSessionFactoryBean(@Qualifier("druidDataSource") DataSource dataSource){
        SqlSessionFactoryBean sqlSessionFactoryBean = new SqlSessionFactoryBean();
        // 配置相关信息（数据源，pojo别名）
        sqlSessionFactoryBean.setDataSource(dataSource);
        sqlSessionFactoryBean.setTypeAliasesPackage("com.zhuxu.pojo");

        return sqlSessionFactoryBean;
    }

    /**
     * xml代码
     *     <!-- 配置dao层代码动态代理对象生成的扫描器 -->
     *     <bean id="mapperScannerConfigurer" class="org.mybatis.spring.mapper.MapperScannerConfigurer">
     *         <!-- 指定扫描的dao层的路径 -->
     *         <property name="basePackage" value="com.zhuxu.dao"/>
     *     </bean>
     * */
    // dao 扫描器
    @Bean
    public MapperScannerConfigurer createMapperScannerConfigurer(){
        MapperScannerConfigurer scannerConfigurer = new MapperScannerConfigurer();
        // 配置相关信息（指定扫描的dao层的路径）
        scannerConfigurer.setBasePackage("com.zhuxu.dao");
        return scannerConfigurer;
    }



}

• 测试

/*
测试类
 */
@RunWith(SpringJUnit4ClassRunner.class)
//框架启动入口, 注解方式配置文件启动(2选1)
@ContextConfiguration(classes = SpringConfig.class)
public class CRUDTest {

    @Autowired
    private AccountService accountService;

    @Test
    public void findByName(){
        Account account = accountService.findByName("迪丽热巴");
        System.out.println("account = " + account);
    }

    @Test
    public void findAll(){
        List<Account> accountList = accountService.findAll();
        for (Account account : accountList) {
            System.out.println("account = " + account);
        }
    }
}

4.2 注解开发的SpringConfig配置优化

• SpringConfig框架启动配置类

  /*
  作为Spring框架的主配置文件
   */
  @Configuration
  //开启Spring容器的注解扫描
  @ComponentScan({"com.itheima"})
  //导入子配置文件
  @Import({JDBCConfig.class, MybatisConfig.class})
  public class SpringConfig {
  
  }
  

• JDBCConfig配置类

  //用于指定与数据库相关配置的配置文件
  @Configuration
  @PropertySource({"classpath:jdbc.properties"})
  public class JDBCConfig {
  
      @Value("${jdbc.driverClassName}")
      private String driverClassName;
      @Value("${jdbc.url}")
      private String url;
      @Value("${jdbc.username}")
      private String username;
      @Value("${jdbc.password}")
      private String password;
  
      //配置数据源
      @Bean("ataSource")
      public DataSource createDataSource(){
          //创建Druid数据源
          DruidDataSource druidDataSource = new DruidDataSource();
          //配置相关信息(Driver, url, username, password)
          druidDataSource.setDriverClassName(driverClassName);
          druidDataSource.setUrl(url);
          druidDataSource.setUsername(username);
          druidDataSource.setPassword(password);
  
          return druidDataSource;
      }
  }
  

• Mybatis配置类

  //用于配置与Mybatis相关的配置
  @Configuration
  public class MybatisConfig {
      //配置SqlSessionFactoryBean对象
      @Bean("sqlSessionFactory")
      public SqlSessionFactoryBean createSqlSessionFactoryBean(DataSource ds){
          //创建SqlSessionFactoryBean 对象
          SqlSessionFactoryBean sqlSessionFactory = new SqlSessionFactoryBean();
          //配置相关信息(数据源, pojo别名映射)
          sqlSessionFactory.setDataSource(ds);
          sqlSessionFactory.setTypeAliasesPackage("com.itheima.pojo");
  
          return sqlSessionFactory;
      }
  
      //配置dao的包扫描
      @Bean("scannerConfigurer")
      public MapperScannerConfigurer createMapperScannerConfigurer(){
          //创建MapperScannerConfigurer 对象
          MapperScannerConfigurer scannerConfigurer = new MapperScannerConfigurer();
          //配置相关信息(扫描的dao包, 找到了dao层的接口文件, 找到了SQL映射文件, 生成接口实现类对象并存到Spring容器中)
          scannerConfigurer.setBasePackage("com.itheima.dao");
  
          return scannerConfigurer;
      }
  }
  

• 测试类

  /*
  测试类
   */
  @RunWith(SpringJUnit4ClassRunner.class)
  //加载的xml配置文件
  //@ContextConfiguration(locations = {"classpath:ApplicationContext.xml"})
  
  //加载的注解形式的Spring主配置文件
  @ContextConfiguration(classes = {SpringConfig.class})
  public class AccountServiceTest {
  
      @Autowired
      private AccountService accountService;
  	
      //其他方法省略
  
      @Test
      public void findAll() {
          List<Account> accountList = accountService.findAll();
          for (Account account : accountList) {
              System.out.println("account = " + account);
          }
      }
  }
  

第五节 案例：模拟转账

案例：模拟转账（并且模拟转账异常）

• 汇款人账户减少一定的金额
• 收款人账户增加一定的金额
• 计算之后，更新数据库
• 问题：模拟转账异常（人为制造异常，在两次update之间造了异常）

5.1 转账编码

1、引入依赖

<dependencies>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>5.1.9.RELEASE</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-jdbc</artifactId>
        <version>5.1.9.RELEASE</version>
    </dependency>
    <dependency>
        <groupId>org.mybatis</groupId>
        <artifactId>mybatis</artifactId>
        <version>3.5.2</version>
    </dependency>
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>5.1.47</version>
    </dependency>
    <dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>druid</artifactId>
        <version>1.1.20</version>
    </dependency>
    <dependency>
        <groupId>org.mybatis</groupId>
        <artifactId>mybatis-spring</artifactId>
        <version>2.0.1</version>
    </dependency>
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.12</version>
    </dependency>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-test</artifactId>
        <version>5.1.9.RELEASE</version>
    </dependency>
</dependencies>

2、业务层

/**
 * 账户的业务层接口
 */
public interface AccountService {
    /**
     * 转账
     */
    void transfer(String source, String target, double money);
    
    //其他方法省略
}

/**
 * 账户业务接口实现类
 */
@Service("accountService")
public class AccountServiceImpl implements AccountService {

    //依赖注入
    @Autowired
    private AccountDao accountDao;

    /*
    转账业务逻辑
    1.先查询账户信息
    2.修改账户信息
    3.持久化账户信息
     */
    @Override
    public void transfer(String source, String target, double money) {
        try {
            //开启事务

            // 转账业务逻辑
            //1 先查询账户信息
            Account sourceAccount = accountDao.findByName(source);
            Account targetAccount = accountDao.findByName(target);
            //2 修改账户信息
            sourceAccount.setMoney(sourceAccount.getMoney() - money);
            targetAccount.setMoney(targetAccount.getMoney() + money);
            //3 持久化账户信息
            accountDao.update(sourceAccount);
            //int i = 1/0;
            accountDao.update(targetAccount);

            //提交事务
        } catch (Exception e){
            e.printStackTrace();
            //回滚事务

        } finally {
            //关闭资源
        }
    }
    
    //其他方法省略
}

3、测试

/*
测试类
 */
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:ApplicationContext.xml")
public class CRUDTest {

    @Autowired
    private AccountService accountService;

    @Test
    public void tranfer(){
        accountService.transfer("迪丽热巴","古力娜扎",1);
    }
}

4、发现问题

转账过程出现事务问题