JavaEE开发之Spring框架整合2(完结撒花)

最新推荐文章于 2023-03-10 09:38:36 发布

nuist__NJUPT

最新推荐文章于 2023-03-10 09:38:36 发布

阅读量433

点赞数 1

分类专栏： SSM框架整合文章标签： spring java-ee java 事务管理 AOP

本文链接：https://blog.csdn.net/nuist_NJUPT/article/details/126611121

版权

SSM框架整合专栏收录该内容

45 篇文章 4 订阅

订阅专栏

随着时代发展，软件规模与功能都呈几何式增长，开发难度也在不断递增，该如何解决?
Spring可以简化开发，降低企业级开发的复杂性，使开发变得更简单快捷随着项目规模与功能的增长,遇到的问题就会增多，为了解决问题会引入更多的框架，这些框架如何协调工作?Spring可以框架整合，高效整合其他技术，提高企业级应用开发与运行效率，综上所述，Spring是一款非常优秀而且功能强大的框架。

一、IOC/DI注解开发

1.1、注解开发定义bean

1.2、纯注解开发模式

1.3、注解开发bean的作用范围与生命周期管理

一、IOC/DI注解开发

1.1、注解开发定义bean

1、创建maven项目，在dao层和service分别定义一个接口和一个实现类，并使用注解标记bean。

public interface BookDao {
    public void save() ;
}

import com.dao.BookDao;
import org.springframework.stereotype.Repository;

@Repository("bookDao")
public class BookDaoImpl implements BookDao {

    public void save() {
        System.out.println("book dao save ...");
    }

}

public interface BookService {
    public void save() ;
}


import com.dao.BookDao;
import com.service.BookService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class BookServiceImpl implements BookService {
    @Autowired
    BookDao bookDao ;

    public void setBookDao(BookDao bookDao) {
        this.bookDao = bookDao;
    }

    public void save() {
        bookDao.save();
        System.out.println("book service save...");
    }

}

2）在sping的配置文件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">
    <context:component-scan base-package="com" />

</beans>

3）编写测试类，获取IOC容器，根据bean对象访问对应的方法，如下：

import com.dao.BookDao;
import com.service.BookService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;


public class app {
    public static void main(String[] args) {
        //获取IOC容器
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml") ;
        //获取bean对象,并执行相应的方法
        BookDao bookDao = (BookDao) applicationContext.getBean("bookDao");
        bookDao.save();
        BookService bookService = applicationContext.getBean(BookService.class) ;
        bookService.save();

    }
}

1.2、纯注解开发模式

spring3.0之后升级了纯注解开发模式，不用写配置文件了，使用java类替代spring的核心配置文件。

1）将上述的spring配置文件applicationContext.xml替换为如下类：
@Configuration注解用于设定当前类为配置类
@ComponentScan注解用于设定扫描路径，此注解只能添加一次，多个数据请用数组格式

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;

@Configuration
@ComponentScan("com")
public class SpringConfig {
}

2）编写测试类，加载IOC容器，进行测试即可，这次直接配置类。

import com.SpringConfig;
import com.dao.BookDao;
import com.service.BookService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;


public class app1 {
    public static void main(String[] args) {
        //获取IOC容器
        ApplicationContext applicationContext = new AnnotationConfigApplicationContext(SpringConfig.class) ;
        //获取bean对象,并执行相应的方法
        BookDao bookDao = (BookDao) applicationContext.getBean("bookDao");
        bookDao.save();
        BookService bookService = applicationContext.getBean(BookService.class) ;
        bookService.save();

    }
}

1.3、注解开发bean的作用范围与生命周期管理

对于bean的作用范围加@scope注解，对于生命周期的初始化和销毁分别加@PostConstruct和@PreDestroy注解。

import com.dao.BookDao;
import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Repository;

import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;

@Repository("bookDao")
@Scope
public class BookDaoImpl implements BookDao {

    public void save() {
        System.out.println("book dao save ...");
    }
    @PostConstruct
    public void init(){
        System.out.println("init ...");
    }
    @PreDestroy
    public void destroy(){
        System.out.println("destroy ...");
    }


}

1.4、注解开发的依赖注入

1）直接使用@Autowired进行自动装配，完成注入，setter方法可以省略，如下：

该注解和@Qualifier注解组合使用，开启指定名称装配bean。

import com.dao.BookDao;
import com.service.BookService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class BookServiceImpl implements BookService {
    @Autowired
    BookDao bookDao ;

    public void save() {
        bookDao.save();
        System.out.println("book service save...");
    }

}

2)上面是对引用类型的注入，下面使用@Value注解对简单类型进行注入，如下：

import com.dao.BookDao;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Repository;


@Repository("bookDao")
public class BookDaoImpl implements BookDao {
    @Value("一起学习吧")
    private String name ;

    public void save() {
        System.out.println("book dao save ..." + name);
    }

}

3）读取外部的Properties文件，首先创建一个jdbc.properties文件，然后再配置类使用注解@PropertySource加载文件，然后使用@Value注解获取jdbc.properties文件的值。


import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.PropertySource;

@Configuration
@ComponentScan("com")
@PropertySource("jdbc.properties")
public class SpringConfig {
}

import com.dao.BookDao;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Repository;


@Repository("bookDao")
public class BookDaoImpl implements BookDao {
    @Value("${jdbc.username}")
    private String name ;

    public void save() {
        System.out.println("book dao save ..." + name);
    }

}

文件jdbc.properties如下：

jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://127.0.0.1:3306/spring_db
jdbc.username=root
jdbc.password=root

1.5、注解开发管理第三方的bean

1）创建外部资源对象，使用@Bean注解标注为bean。

import com.alibaba.druid.pool.DruidDataSource;
import org.springframework.context.annotation.Bean;

import javax.sql.DataSource;

public class JdbcConfig {
    @Bean
    public DataSource dataSource(){
        DruidDataSource dataSource = new DruidDataSource() ;
        dataSource.setDriverClassName("com.mysql.jdbc.Driver");
        dataSource.setUrl("jdbc:mysql://127.0.0.1:3306/spring_db");
        dataSource.setUsername("root");
        dataSource.setPassword("root");
        return dataSource ;
    }
}

2）在spring的配置类中直接扫描@ComponentScan或者导入@Import的形式加载外部资源，如下：

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Import;

@Configuration
@ComponentScan("com")
@Import({JdbcConfig.class})
public class SpringConfig {
}

3）对应简单类型的注入，使用成员变量，对于引用类型的注入使用方法形参。


import com.alibaba.druid.pool.DruidDataSource;
import com.dao.BookDao;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;

import javax.sql.DataSource;

public class JdbcConfig {
    @Value("com.mysql.jdbc.Driver")
    private String driveClassName ;

    @Value("jdbc:mysql://127.0.0.1:3306/spring_db")
    private String url ;

    @Value("root")
    private String username ;

    @Value("root")
    private String password ;

    @Bean
    public DataSource dataSource(BookDao bookDao){
        System.out.println(bookDao);
        DruidDataSource dataSource = new DruidDataSource() ;
        dataSource.setDriverClassName(driveClassName);
        dataSource.setUrl(url);
        dataSource.setUsername(username);
        dataSource.setPassword(password);
        return dataSource ;
    }
}

1.6、XML配置和注解方式的对比

从如下5个角度进行对比，看图即可：

二、Spring整合

Spring有一个容器，叫做IoC容器，里面保存bean。在进行企业级开发的时候，其实除了将自己写的类让Spring管理之外，还有一部分重要的工作就是使用第三方的技术。前面已经讲了如何管理第三方bean了，下面结合IoC和DI，整合2个常用技术，进一步加深对Spring的使用理解。

2.1、Spring整合MyBatis

本次使用纯注解的方式在Spring中整合mybatis，把配置文件换成了java类+注解的方式，提高了开发效率，如果想看基于配置文件的方式整合mybatis，可以看我之前写的博客，地址如下：MyBatis与Spring的整合（Eclipse版本和IDEA版本）_nuist__NJUPT的博客-CSDN博客

1)创建一个数据库和表，如下：

create database if not exists spring_db character set utf8;
use spring_db;
create table if not exists tbl_account(
 id int primary key auto_increment,
 name varchar(35),
 money double
);
insert into tbl_account VALUES(null,'张三',100.00);
insert into tbl_account VALUES(null,'李四',200.00);
insert into tbl_account VALUES(null,'王五',300.00);

2）创建maven项目，并在pom.xml文件中添加相关依赖jar包，如下：

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>org.example</groupId>
    <artifactId>java02</artifactId>
    <version>1.0-SNAPSHOT</version>

    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.2.10.RELEASE</version>
        </dependency>

        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.1.16</version>
        </dependency>

        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.5.6</version>
        </dependency>

        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.47</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>5.2.10.RELEASE</version>
        </dependency>

        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis-spring</artifactId>
            <version>1.3.0</version>
        </dependency>
    </dependencies>

</project>

3）创建数据源配置，mybatis配置，以及spring配置，不使用配置文件，这里直接使用注解的方式进行，如下：

数据源的配置：

jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/spring_db
jdbc.username=root
jdbc.password=123456

import com.alibaba.druid.pool.DruidDataSource;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
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;

    @Bean
    public DataSource dataSource() {
        DruidDataSource ds = new DruidDataSource();
        ds.setDriverClassName(driver);
        ds.setUrl(url);
        ds.setUsername(userName);
        ds.setPassword(password);
        return ds ;
    }
}

mybatis配置：

import org.mybatis.spring.SqlSessionFactoryBean;
import org.mybatis.spring.mapper.MapperScannerConfigurer;
import org.springframework.context.annotation.Bean;

import javax.sql.DataSource;

public class MybatisConfig {
//定义bean，SqlSessionFactoryBean，用于产生SqlSessionFactory对象
  @Bean
  public SqlSessionFactoryBean sqlSessionFactory(DataSource dataSource){
    SqlSessionFactoryBean ssfb = new SqlSessionFactoryBean();
    //设置模型类的别名扫描
    ssfb.setTypeAliasesPackage("com.domain");
    ssfb.setDataSource(dataSource);
    return ssfb;
}
//定义bean，返回MapperScannerConfigurer对象
  @Bean
  public MapperScannerConfigurer mapperScannerConfigurer(){
    MapperScannerConfigurer msc = new MapperScannerConfigurer();
    msc.setBasePackage("com.dao");
    return msc;
  }
}

spring配置：

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Import;
import org.springframework.context.annotation.PropertySource;

@Configuration
@ComponentScan("com")
@PropertySource("jdbc.properties")
@Import({JdbcConfig.class,MybatisConfig.class})
public class SpringConfig {
}

4）创建实体对象，要保证和数据库中一致，如下：

import java.io.Serializable;

public class Account implements Serializable {
    private Integer id ;
    private String name ;
    private Double money ;

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public double getMoney() {
        return money;
    }

    public void setMoney(double money) {
        this.money = money;
    }

    @Override
    public String toString() {
        return "Account{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", money=" + money +
                '}';
    }
}

5）创建创建数据访问层，执行sql语句，如下：

import com.domain.Account;
import org.apache.ibatis.annotations.*;

import java.util.List;

public interface AccountDao {
    @Insert("insert into tbl_account(name,money)values(#{name},#{money})")
    void save(Account account) ;
    @Delete("delete from tbl_account where id = #{id} ")
    void delete(Integer id) ;
    @Update("update tbl_account set name = #{name} , money = #{money} where id = #{id} ")
    void update(Account account) ;
    @Select("select * from tbl_account")
    List<Account> findAll() ;
    @Select("select * from tbl_account where id = #{id}")
    Account findById(Integer id) ;
}

6）业务层，将数据访问层bean注入业务层，调用数据访问层的方法，执行业务操作：

import com.domain.Account;
import java.util.List;

public interface AccountService {
    void save(Account account) ;
    void delete(Integer id) ;
    void update(Account account) ;
    List<Account> findAll() ;
    Account findById(Integer id) ;
}


import com.dao.AccountDao;
import com.domain.Account;
import com.service.AccountService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;
@Service
public class AccountServiceImpl implements AccountService {
    @Autowired
    private AccountDao accountDao ;
    public void save(Account account) {
        accountDao.save(account);
    }

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

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

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

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

7）编写测试类进行测试，如下：

import com.config.SpringConfig;
import com.domain.Account;
import com.service.AccountService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import java.util.List;

public class App {
    public static void main(String[] args) {
        ApplicationContext applicationContext = new AnnotationConfigApplicationContext(SpringConfig.class) ;
        AccountService accountService = applicationContext.getBean(AccountService.class);
        List<Account> list = accountService.findAll() ;
        for(Account account : list){
            System.out.println(account);
        }
        System.out.println(accountService.findById(1)) ;
        accountService.delete(1);

    }
}

2.2、Spring整合Junit

1）首先需要在pom.xml文件中田间test的相关jar包依赖，如下：

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>org.example</groupId>
    <artifactId>com.mybatis</artifactId>
    <version>1.0-SNAPSHOT</version>

    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.2.10.RELEASE</version>
        </dependency>

        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.1.16</version>
        </dependency>

        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.5.6</version>
        </dependency>

        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.47</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>5.2.10.RELEASE</version>
        </dependency>

        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis-spring</artifactId>
            <version>1.3.0</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>5.2.10.RELEASE</version>
        </dependency>
    </dependencies>

</project>

2）编写测试类进行测试，需要加载测试运行器，设置spring文件的位置，对需要的测试的bean进行自动装配，然后调用方法进行测试。

import com.config.SpringConfig;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

//设置运行器类
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = {SpringConfig.class})
public class AccountServiceTest {

    @Autowired
    private AccountService accountService ;

    @Test
    public void findAll(){
        System.out.println(accountService.findAll());
    }
}

三、面向切面编程(AOP)

3.1、AOP的基本概念

AOP(Aspect Oriented Programming)面向切面编程，一种编程范式，指导开发者如何组织程
序结构。
OOP(Object Oriented Programming)面向对象编程，我们都知道OOP是一种编程思想，那么AOP也是一种编程思想，编程思想主要的内容就是指导程序员该如何编写程序，所以它们两个是不同的编程范式。

作用:在不惊动原始设计的基础上为其进行功能增强，前面咱们有技术就可以实现这样的功能即代
理模式。

通过下图：我们可以形象的学习AOP中的一些名词的含义，通知类中定义的增强功能的方法叫做通知，连接点表示原始所有方法，切入点是进行增强的方法，切面是进行通知和切入点进行绑定的。

3.2、AOP的入门案例

1）创建maven项目，在pom.xml文件中添加相应的依赖jar包。

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <parent>
        <artifactId>com.mybatis</artifactId>
        <groupId>org.example</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>
    <artifactId>com.aop</artifactId>

    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.2.10.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.9.4</version>
        </dependency>
    </dependencies>


</project>

2）在dao层编写接口和实现类，需要加相应的数据访问层注解，如下：

public interface BookDao {
    public void save() ;
    public void update() ;
}

import com.dao.BookDao;
import org.springframework.stereotype.Repository;

@Repository
public class BookDaoImpl implements BookDao {
    public void save() {
        System.out.println("bookDao save ...");
    }

    public void update() {
        System.out.println("bookDao update ...");
    }
}

3）编写通知类，通知类中编写通知，通过切面对切入点进行绑定。对update方法进行增强。

@Component
@Aspect
public class MyAdvice {
    @Pointcut("execution(void com.dao.BookDao.update())")
    private void pt(){}

    @Before("pt()")
    public void method(){
        System.out.println(System.currentTimeMillis());
    }
}

4）编写spring配置类，加上相应的注解。


import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.EnableAspectJAutoProxy;

@Configuration
@ComponentScan("com")
@EnableAspectJAutoProxy
public class SpringConfig {
}

5）编写测试类进行测试。


import com.config.SpringConfig;
import com.dao.BookDao;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class App {
    public static void main(String[] args) {
        ApplicationContext applicationContext = new AnnotationConfigApplicationContext(SpringConfig.class) ;
        BookDao bookDao = applicationContext.getBean(BookDao.class) ;
        bookDao.update();
    }
}

3.3、AOP工作流程

流程1:Spring容器启动，容器启动就需要去加载bean,哪些类需要被加载呢?
需要被增强的类，如:BookServiceImpl，通知类，如:MyAdvice。注意此时bean对象还没有创建成功。

流程2：读取所有切面配置中的切入点。

流程3：始化bean，判定bean对应的类中的方法是否匹配到任意切入点，注意第1步在容器启动的时候，bean对象还没有被创建成功。要被实例化bean对象的类中的方法和切入点进行匹配。匹配成功，创建原始对象（目标对象）的代理对象,如: BookDao匹配成功说明需要对其进行增强
对哪个类做增强，这个类对应的对象就叫做目标对象，因为要对目标对象进行功能增强，而采用的技术是动态代理，所以会为其创建一个代理对象最终运行的是代理对象的方法，在该方法中会对原始方法进行功能增强。

流程4：获取的bean是代理对象时，根据代理对象的运行模式运行原始方法与增强的内容，完成操作。

目标对象(Target)：原始功能去掉共性功能对应的类产生的对象，这种对象是无法直接完成最终
工作的
代理(Proxy)：目标对象无法直接完成工作，需要对其进行功能回填，通过原始对象的代理对象实
现

3.4、AOP配置管理

1）切入点表达式

对于切入点表达式可以采用通配符的方式书写，通过符的书写一般采用如下格式：

2）AOP通知类型

前置通知：@Before
后置通知：@After
环绕通知(重点)：@Around
返回后通知(了解)：@AfterReturning
抛出异常后通知(了解)：@AfterThrowing

前置通知案例：

import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Component;

@Component
@Aspect
public class MyAdvice {
    @Pointcut("execution(void com.dao.BookDao.update())")
    private void pt(){}

    @Before("pt()")
    public void method(){
        System.out.println(System.currentTimeMillis());
    }
}

后置通知案例：

import com.config.SpringConfig;
import com.dao.BookDao;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class App {
    public static void main(String[] args) {
        ApplicationContext applicationContext = new AnnotationConfigApplicationContext(SpringConfig.class) ;
        BookDao bookDao = applicationContext.getBean(BookDao.class) ;
        bookDao.update();
    }
}

环绕通知案例：

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Component;

@Component
@Aspect
public class MyAdvice {
    @Pointcut("execution(void com.dao.BookDao.update())")
    private void pt(){}

    @Around("pt()")
    public Object method(ProceedingJoinPoint pjp) throws Throwable {
            System.out.println(System.currentTimeMillis());
            Object object = pjp.proceed() ;
            System.out.println(System.currentTimeMillis());
            return object ;
    }
}

3）测量接口万次代码执行效率：用环绕通知实现

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.Signature;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Component;

@Component
@Aspect
public class MyAdvice {
    @Pointcut("execution(void com.dao.BookDao.update())")
    private void pt(){}

    @Around("pt()")
    public void method(ProceedingJoinPoint pjp) throws Throwable {
            Signature signature = pjp.getSignature() ;
            String className = signature.getDeclaringTypeName() ;
            String methodName = signature.getName() ;
            long start = System.currentTimeMillis() ;
            for(int i=0; i<10000; i++) {
                pjp.proceed();
            }
            long end = System.currentTimeMillis() ;
        System.out.println("万次执行" + className + "." + methodName + "------->" + "时间为:" + (end-start) + "ms");
    }
}

四、Spring事务管理

4.1、Spring事务简介

事务作用：在数据层保障一系列的数据库操作同成功同失败
Spring事务作用：在数据层或业务层保障一系列的数据库操作同成功同失败
数据层有事务我们可以理解，为什么业务层也需要处理事务呢?
举个简单的例子，
转账业务会有两次数据层的调用，一次是加钱一次是减钱
把事务放在数据层，加钱和减钱就有两个事务
没办法保证加钱和减钱同时成功或者同时失败
这个时候就需要将事务放在业务层进行处理。
Spring为了管理事务，提供了一个平台事务管理器 PlatformTransactionManager

下面看一个简单的转账案例

1）创建数据库的表，并添加两条记录用于模拟转账，如下：


create database if not exists spring_db character set utf8;
use spring_db;
create table if not exists tbl_account(
 id int primary key auto_increment,
 name varchar(35),
 money double
);

insert into tbl_account values(1,'Tom',1000);
insert into tbl_account values(2,'Jerry',1000);

2）创建maven项目，加载相关依赖jar包，如下：

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <parent>
        <artifactId>com.mybatis</artifactId>
        <groupId>org.example</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>com.transaction</artifactId>

    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.2.10.RELEASE</version>
        </dependency>

        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.1.16</version>
        </dependency>

        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.5.6</version>
        </dependency>

        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.47</version>
        </dependency>

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>5.2.10.RELEASE</version>
        </dependency>

        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis-spring</artifactId>
            <version>1.3.0</version>
        </dependency>
    </dependencies>
</project>

3）添加数据的配置文件jdbc.properties，如下：

jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://127.0.0.1:3306/spring_db?characterEncoding=utf-8
jdbc.username=root
jdbc.password=123456

4）添加Account实体类。

import java.io.Serializable;

public class Account implements Serializable {
    private Integer id ;
    private String name ;
    private Double money ;

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Double getMoney() {
        return money;
    }

    public void setMoney(Double money) {
        this.money = money;
    }

    @Override
    public String toString() {
        return "Account{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", money=" + money +
                '}';
    }
}

5）创建数据层，执行操作数据库的操作。

import org.apache.ibatis.annotations.Param;
import org.apache.ibatis.annotations.Update;


public interface AccountDao {
    @Update("update tbl_account set money = money + #{money} where name = #{name}")
    void inMoney(@Param("name") String name, @Param("money") Double money) ;
    @Update("update tbl_account set money = money - #{money} where name = #{name}")
    void outMoney(@Param("name") String name, @Param("money") Double money) ;
}

6）创建业务层的接口和实现类，实现数据层注入和调用数据层的方法等业务操作，需要在接口添加事务注解。

import org.springframework.transaction.annotation.Transactional;

@Transactional
public interface AccountService {
    public void transfer(String out,String in ,Double money) ;
}

import com.dao.AccountDao;
import com.service.AccountService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class AccountServiceImpl implements AccountService {
    @Autowired
    private AccountDao accountDao ;

    public void transfer(String out, String in, Double money) {
        accountDao.outMoney(out,money);
//        int a = 1 / 0 ;
        accountDao.inMoney(in,money);
    }
}

7）完成数据源，mybatis以及spring的配置，在mybatis配置中配置事务管理器，在spring配置中启动事务管理器。

数据源配置：

import com.alibaba.druid.pool.DruidDataSource;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;
import org.springframework.transaction.PlatformTransactionManager;

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;

    @Bean
    public DataSource dataSource() {
        DruidDataSource ds = new DruidDataSource();
        ds.setDriverClassName(driver);
        ds.setUrl(url);
        ds.setUsername(userName);
        ds.setPassword(password);
        return ds;
    }
    //配置事务管理器，mybatis使用的是jdbc事务
    @Bean
    public PlatformTransactionManager transactionManager(DataSource dataSource) {
         DataSourceTransactionManager transactionManager = new DataSourceTransactionManager();
         transactionManager.setDataSource(dataSource);
         return transactionManager;
    }
}

mybatis配置：

import org.mybatis.spring.SqlSessionFactoryBean;
import org.mybatis.spring.mapper.MapperScannerConfigurer;
import org.springframework.context.annotation.Bean;

import javax.sql.DataSource;

public class MybatisConfig {
    //定义bean，SqlSessionFactoryBean，用于产生SqlSessionFactory对象
    @Bean
    public SqlSessionFactoryBean sqlSessionFactory(DataSource dataSource){
        SqlSessionFactoryBean ssfb = new SqlSessionFactoryBean();
        //设置模型类的别名扫描
        ssfb.setTypeAliasesPackage("com.domain");
        ssfb.setDataSource(dataSource);
        return ssfb;
    }
    //定义bean，返回MapperScannerConfigurer对象
    @Bean
    public MapperScannerConfigurer mapperScannerConfigurer(){
        MapperScannerConfigurer msc = new MapperScannerConfigurer();
        msc.setBasePackage("com.dao");
        return msc;
    }
}

spring配置：


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;

@Configuration
@ComponentScan("com")
@PropertySource("jdbc.properties")
@Import({JdbcConfig.class,MybatisConfig.class})
@EnableTransactionManagement
public class SpringConfig {
}

8）编写测试类，测试事务管理。

import com.config.SpringConfig;
import com.service.AccountService;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class App {
    public static void main(String[] args) {
        ApplicationContext applicationContext = new AnnotationConfigApplicationContext(SpringConfig.class) ;
        AccountService accountService = applicationContext.getBean(AccountService.class) ;
        accountService.transfer("Tom","Jerry",100.00);
    }
}

4.2、Spring事务属性

1）事务配置，我们可以对事务设置属性，特别是回滚属性，可以设置在什么异常下产生回滚。

2）事务的传播行为，如果事务管理员已经开启事务，事务协调员不想加入，就需要另外开辟一个事务，通过设置事务传播属性是实现。

3）事务传播属性设置案例

需求：在以上的基础上，无论转账是否成功，都记录转账日志信息。

第一步，在上述的数据库中创建一个表用于记录转账信息，如下：

create table tbl_log(
 id int primary key auto_increment,
 info varchar(255),
 createDate datetime
)

然后，添加数据层接口，如下：

import org.apache.ibatis.annotations.Insert;

public interface LogDao {
    @Insert("insert into tbl_log (info,createDate) values(#{info},now())")
    void log(String info);
}

然后添加业务层接口和实现类，需要设置事务为另外开启一个新的事务，即修改事务的传播行为：

import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;

@Transactional(propagation = Propagation.REQUIRES_NEW)
public interface LogService {
    void log(String out, String in, Double money);
}

import com.dao.LogDao;
import com.service.LogService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class LogServiceImpl implements LogService {
    @Autowired
    private LogDao logDao;

    public void log(String out, String in, Double money) {
        logDao.log("转账操作由"+out+"到"+in+",金额："+money);
    }
}

然后需要转账业务中添加日志记录业务，如下：

import com.dao.AccountDao;
import com.service.AccountService;
import com.service.LogService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class AccountServiceImpl implements AccountService {
    @Autowired
    private AccountDao accountDao ;

    @Autowired
    private LogService logService ;

    public void transfer(String out, String in, Double money) {
        try {
            accountDao.outMoney(out, money);
          int a = 1 / 0 ;
            accountDao.inMoney(in, money);
        }finally {
            logService.log(out,in,money);
        }
    }
}