Spring 03 切面编程

简介

AOP（Aspect Oriented Programming），即面向切面编程

这是对面向对象思想的一种补充。

面向切面编程，就是在程序运行时，不改变程序源码的情况下，动态的增强方法的功能。

常见的使用场景有：

• 日志
• 事务
• 数据库操作

这些操作中，无一例外，都有很多模板化的代码，而解决模板化代码，消除臃肿就是 AOP 的强项。

在 AOP 中，有几个常见的概念

概念	说明
切点	要添加代码的地方，称作切点
通知（增强）	通知就是向切点动态添加的代码
切面	切点+通知
连接点	切点的定义

AOP的实现

AOP 实际上是基于 Java 动态代理来实现的。

Java 中的动态代理有两种实现方式：cglib 和 jdk。

动态代理

基于 JDK 的动态代理

定义一个计算器接口

public interface MyCalculator {

    void add(int a, int b);

}

定义计算机接口的实现

@Service
public class MyCalculatorImpl implements MyCalculator{
    @Override
    public void add(int a, int b) {
        System.out.println(a + "+" + b + "=" + (a + b));;
    }
}

定义代理类

public class CalculatorProxy {

    public static Object getInstance(final MyCalculatorImpl myCalculator) {
        return Proxy.newProxyInstance(CalculatorProxy.class.getClassLoader(), myCalculator.getClass().getInterfaces(), new InvocationHandler() {
            /**
             * @param proxy 代理对象
             * @param method 代理的方法
             * @param args 方法的参数
             * @return
             * @throws Throwable
             */
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                System.out.println("方法开始执行");
                Object invoke = method.invoke(myCalculator, args);
                System.out.println("方法结束执行");
                return invoke;
            }
        });
    }

}

Proxy.newProxyInstance 方法接收三个参数

• 第一个是一个 classloader，即类加载器。
• 第二个是代理多项实现的接口。
• 第三个是代理对象方法的处理器，所有要额外添加的行为都在 invoke 方法中实现。

方法调用的 invoke 方法有两个参数

• 第一个是执行方法的对象。
• 第二个是方法的参数数组。

调用方法

MyCalculatorImpl myCalculatorImpl = new MyCalculatorImpl();
MyCalculator myCalculator = (MyCalculator) CalculatorProxy.getInstance(myCalculatorImpl);
myCalculator.add(1, 2);

打印结果

方法开始执行
1+2=3
方法结束执行

五种通知

Spring 中的 Aop 的通知类型有 5 种

• 前置通知
• 后置通知
• 异常通知
• 返回通知
• 环绕通知

在项目中，引入 Spring 依赖（这次需要引入 Aop 相关的依赖）

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
</dependency>
<dependency>
    <groupId>org.aspectj</groupId>
    <artifactId>aspectjweaver</artifactId>
</dependency>
<dependency>
    <groupId>org.aspectj</groupId>
    <artifactId>aspectjrt</artifactId>
</dependency>

定义切点，这里介绍两种切点的定义方式

• 使用自定义注解
• 使用规则

其中，使用自定义注解标记切点，是侵入式的，所以这种方式在实际开发中不推荐，仅作为了解。

另一种使用规则来定义切点的方式，无侵入，一般推荐使用这种方式。

自定义注解

自定义一个注解

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface Action {
}

在需要拦截的方法上，添加该注解

在 reduce 方法上添加了 @Action 注解，表示该方法将会被 Aop 拦截，而其他未添加该注解的方法则不受影响

@Service
public class MyCalculatorImpl implements MyCalculator{

    @Override
    public void add(int a, int b) {
        System.out.println(a + "+" + b + "=" + (a + b));;
    }

    @Override
    @Action
    public int reduce(int a, int b) {
        int result = a - b;
        System.out.println(a + "-" + b + "=" + result);
        return result;
    }

}

接下来，定义增强（通知、Advice）

@Component
@Aspect //标注这是一个切面
public class LogAspect {

    /**
     * @param joinPoint 包含了目标方法的关键信息
     * @Before 注解表示这是一个前置通知，即在目标方法执行之前执行，注解中，需要填入切点
     */
    @Before(value = "@annotation(Action)")
    public void before(JoinPoint joinPoint) {
        Signature signature = joinPoint.getSignature();
        String methodName = signature.getName();
        System.out.println(methodName + "方法要执行了");
    }

    /**
     * 后置通知
     * @param joinPoint 包含了目标方法的所有关键信息
     * @After 表示这是一个后置通知，即在目标方法执行之后执行
     */
    @After(value = "@annotation(Action)")
    public void after(JoinPoint joinPoint) {
        Signature signature = joinPoint.getSignature();
        String methodName = signature.getName();
        System.out.println(methodName + "方法执行结束了");
    }

    /**
     * @param joinPoint
     * @param r 返回值
     * @AfterReturning 表示这是一个返回通知，即有目标方法有返回值的时候才会触发
     * 该注解中的 returning 属性表示目标方法返回值的变量名，这个需要和参数一一对应
     * 注意：目标方法的返回值类型要和这里方法返回值参数的类型一致，否则拦截不到，如果想拦截所有（包括返回值为 void），则方法返回值参数可以为 Object
     */
    @AfterReturning(value = "@annotation(Action)", returning = "r")
    public void afterReturning(JoinPoint joinPoint, Integer r) {
        Signature signature = joinPoint.getSignature();
        String methodName = signature.getName();
        System.out.println(methodName + "方法返回了" + r);
    }

    /**
     * 异常通知
     * @param joinPoint
     * @param e 目标方法所抛出的异常
     *          注意，这个参数必须是目标方法所抛出的异常或者所抛出的异常的父类，只有这样，才会捕获
     *          如果想拦截所有，参数类型声明为 Exception
     */
    @AfterThrowing(value = "@annotation(Action)", throwing = "e")
    public void afterThrowing(JoinPoint joinPoint, Exception e) {
        Signature signature = joinPoint.getSignature();
        String methodName = signature.getName();
        System.out.println(methodName + "方法抛出了异常：" + e.getMessage());

    }

    /**
     * 环绕通知
     *
     * 环绕通知是集大成者，可以用环绕通知实现上面的四个通知，这个方法的核心有点类似于在这里通过反射执行方法
     * @param pjp
     * @return 注意这里的返回值类型最好是 Object ，和拦截到的方法相匹配
     */
    @Around(value = "@annotation(Action)")
    public Object around(ProceedingJoinPoint pjp) {
        Object proceed = null;
        try {
            //这个相当于 method.invoke 方法，我们可以在这个方法的前后分别添加日志，就相当于是前置/后置通知
            proceed = pjp.proceed();
        } catch (Throwable throwable) {
            throwable.printStackTrace();
        }
        return proceed;
    }

}

在配置类中，开启包扫描和自动代理

@Configuration
@ComponentScan
@EnableAspectJAutoProxy // 开启自动代理
public class JavaConfig {
}

开启调用

@Resource
private MyCalculator myCalculator;

@Test
public void testAutoProxy() {
    myCalculator.add(1, 2);
    myCalculator.reduce(5, 2);
}

打印结果

1+2=3
reduce方法要执行了
5-2=3
reduce方法返回了3
reduce方法执行结束了

LogAspect 切面中，切点的定义是不够灵活的，切点直接写在注解里边，如果要修改切点，每个方法的注解都要修改。

我们可以将切点统一定义，然后统一调用。

@Pointcut("@annotation(Action)")
public void pointCut() {
}

@Before("pointCut()")
public void before(JoinPoint joinPoint) {
}

不过，使用注解是侵入式的，还可以改为非侵入式的。

下面这种方式是更为通用的拦截方式

/**
 * 可以统一定义切点
 * 第一个 * 表示要拦截的目标方法返回值任意（也可以明确指定返回值类型）
 * 第二个 * 表示包中的任意类（也可以明确指定类）
 * 第三个 * 表示类中的任意方法
 * 最后面的两个点表示方法参数任意，个数任意，类型任意
 */
@Pointcut("execution(* cn.sail.training.spring.aop.*.*(..))")
public void pointCut() {
    
}

XML 配置 AOP

定义切面，不再需要注解

public class LogAspectXml {

    public void before(JoinPoint joinPoint) {
        Signature signature = joinPoint.getSignature();
        String methodName = signature.getName();
        System.out.println(methodName + "方法要执行了");
    }

    public void after(JoinPoint joinPoint) {
        Signature signature = joinPoint.getSignature();
        String methodName = signature.getName();
        System.out.println(methodName + "方法执行结束了");
    }

    public void afterReturning(JoinPoint joinPoint, Integer r) {
        Signature signature = joinPoint.getSignature();
        String methodName = signature.getName();
        System.out.println(methodName + "方法返回了" + r);
    }

    public void afterThrowing(JoinPoint joinPoint, Exception e) {
        Signature signature = joinPoint.getSignature();
        String methodName = signature.getName();
        System.out.println(methodName + "方法抛出了异常：" + e.getMessage());

    }

    public Object around(ProceedingJoinPoint pjp) {
        Object proceed = null;
        try {
            //这个相当于 method.invoke 方法，我们可以在这个方法的前后分别添加日志，就相当于是前置/后置通知
            proceed = pjp.proceed();
        } catch (Throwable throwable) {
            throwable.printStackTrace();
        }
        return proceed;
    }

}

在 XML 中配置 AOP

<bean class="cn.sail.aop.LogAspectXml" id="logAspectXml"/>
<aop:config>
    <aop:pointcut id="pointCut1" expression="execution(* cn.sail.aop.*.*(..))"/>
    <aop:aspect ref="logAspectXml">
        <aop:before method="before" pointcut-ref="pointCut1"/>
        <aop:after method="after" pointcut-ref="pointCut1"/>
        <aop:after-returning method="afterReturning" pointcut-ref="pointCut1" returning="r"/>
        <aop:after-throwing method="afterThrowing" pointcut-ref="pointCut1" throwing="e"/>
        <aop:around method="around" pointcut-ref="pointCut1"/>
    </aop:aspect>
</aop:config>

JdbcTemplate

JdbcTemplate 是 Spring 利用 AOP 思想封装的 JDBC 操作工具。

添加依赖

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

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

准备数据库

create table grade
(
    id   int auto_increment comment 'ID'
        primary key,
    name varchar(30) null comment '名称'
);

准备实体类

public class Grade implements Serializable {

    private static final long serialVersionUID = 1L;

    private int id;

    private String name;

    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;
    }

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

    public Grade() {
    }

    public Grade(int id, String name) {
        this.id = id;
        this.name = name;
    }
}

Java 配置

@Configuration
public class JdbcConfig {

    @Bean
    DataSource dataSource() {
        DriverManagerDataSource driverManagerDataSource = new DriverManagerDataSource();
        driverManagerDataSource.setDriverClassName("com.mysql.cj.jdbc.Driver");
        driverManagerDataSource.setUrl("jdbc:mysql://localhost:3306/test");
        driverManagerDataSource.setUsername("数据库用户名");
        driverManagerDataSource.setPassword("数据库密码");
        return driverManagerDataSource;
    }

    @Bean
    JdbcTemplate jdbcTemplate() {
        return new JdbcTemplate(dataSource());
    }

}

调用

public class TestDemo {

    private JdbcTemplate jdbcTemplate;

    @Before
    public void before() {
        AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext(JdbcConfig.class);
        jdbcTemplate = ctx.getBean(JdbcTemplate.class);
    }

    @Test
    public void insert() {
        jdbcTemplate.update("insert into grade (name) values (?);", "高一");
    }

    @Test
    public void update() {
        jdbcTemplate.update("update grade set name = ? where id = ?", "大五", 5);
    }

    @Test
    public void delete() {
        jdbcTemplate.update("delete from grade where id = ?", 5);
    }

    @Test
    public void select() {
        Grade grade = jdbcTemplate.queryForObject("select * from grade where id = ?", new BeanPropertyRowMapper<>(Grade.class), 1);
        System.out.println(grade);
    }

在查询时，如果使用了 BeanPropertyRowMapper，要求查出来的字段必须和 Bean 的属性名一一对应。

如果不一样，则不要使用 BeanPropertyRowMapper，此时需要自定义 RowMapper 或者给查询的字段取别名。

@Test
public void select1() {
    Grade grade = jdbcTemplate.queryForObject("select * from grade where id = ?", new RowMapper<Grade>() {
        @Override
        public Grade mapRow(ResultSet resultSet, int i) throws SQLException {
            int id = resultSet.getInt("id");
            String name = resultSet.getString("name");
            return new Grade(id, name);
        }
    }, 2);
    System.out.println(grade);
}

如果要查询多条记录，方式如下

@Test
public void select2() {
    List<Grade> gradeList = jdbcTemplate.query("select * from grade", new BeanPropertyRowMapper<>(Grade.class));
    System.out.println(gradeList);
}

以上配置，也可以通过 XML 文件来实现。

通过 XML 文件实现只是提供 JdbcTemplate 实例，剩下的代码还是 Java 代码，就是 JdbcConfig 被 XML 文件代替而已。

<bean class="org.springframework.jdbc.datasource.DriverManagerDataSource" id="dataSource2">
    <property name="driverClassName" value="com.mysql.cj.jdbc.Driver"/>
    <property name="url" value="jdbc:mysql://localhost:3306/test"/>
    <property name="username" value="数据库用户名"/>
    <property name="password" value="数据库密码"/>
</bean>

<bean class="org.springframework.jdbc.core.JdbcTemplate" id="jdbcTemplate">
    <property name="dataSource" ref="dataSource2"/>
</bean>

事务

Spring 中的事务主要是利用 AOP 思想，简化事务的配置，可以通过 Java 配置也可以通过 XML 配置。

建表

CREATE TABLE `account` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `username` varchar(255) COLLATE utf8mb4_general_ci DEFAULT NULL,
  `money` int(11) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=3 DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_general_ci;

配置JdbcTemplate

<!--配置数据源-->
<bean class="org.springframework.jdbc.datasource.DriverManagerDataSource" id="dataSource2">
    <property name="driverClassName" value="com.mysql.cj.jdbc.Driver"/>
    <property name="url" value="jdbc:mysql://localhost:3306/test"/>
    <property name="username" value="数据库用户名"/>
    <property name="password" value="数据库密码"/>
</bean>

<!--配置数据访问模板-->
<bean class="org.springframework.jdbc.core.JdbcTemplate" id="jdbcTemplate">
    <property name="dataSource" ref="dataSource2"/>
</bean>

开启自动化扫描

<context:component-scan base-package="cn.sail.transactional"/>

编写持久层

@Repository
public class UserDao {

    @Resource
    private JdbcTemplate jdbcTemplate;

    public void addMoney(String username, Integer money) {
        jdbcTemplate.update("update account set money = money + ? where username = ?", money, username);
    }

    public void reduceMoney(String username, Integer money) {
        jdbcTemplate.update("update account set money = money - ? where username = ?", money, username);
    }

}

编写服务层

@Service
public class UserService {

    @Resource
    private UserDao userDao;

    public void updateMoney() {
        userDao.addMoney("zhangsan", 100);
        int i = 1 / 0;
        userDao.reduceMoney("lisi", 100);
    }

}

这里的int i = 1 / 0;是为了让方法报错才写的。

XML配置

配置事务管理器

<bean class="org.springframework.jdbc.datasource.DataSourceTransactionManager" id="dataSourceTransactionManager">
    <property name="dataSource" ref="dataSource2"/>
</bean>

配置事务要处理的方法

<tx:advice transaction-manager="dataSourceTransactionManager" id="txAdvice">
    <tx:attributes>
        <tx:method name="add*"/>
        <tx:method name="delete*"/>
        <tx:method name="update*"/>
        <tx:method name="get*"/>
    </tx:attributes>
</tx:advice>

一旦配置了方法名称规则之后，service 中的方法一定要按照这里的名称规则来，否则事务配置不会生效。

配置 Aop

<aop:config>
    <aop:pointcut id="pointCut2" expression="execution(* cn.sail.transactional.*.*(..))"/>
    <aop:advisor advice-ref="txAdvice" pointcut-ref="pointCut2"/>
</aop:config>

测试

public class TestDemo {

    private JdbcTemplate jdbcTemplate;

    private UserService userService;

    @Before
    public void before() {
        ClassPathXmlApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
        jdbcTemplate = ctx.getBean(JdbcTemplate.class);
        userService = ctx.getBean(UserService.class);
    }

    @Test
    public void testTransactional() {
        userService.updateMoney();
    }

}

由于UserService中的updateMoney方法会报错，addMoney的执行结果会被回滚，表的数据保持不变，即实现了事务的效果。

Java 配置

在 XML 中添加如下配置

<tx:annotation-driven transaction-manager="dataSourceTransactionManager"/>

这行代码可以代替如下代码

<tx:advice transaction-manager="dataSourceTransactionManager" id="txAdvice">
    <tx:attributes>
        <tx:method name="add*"/>
        <tx:method name="delete*"/>
        <tx:method name="update*"/>
        <tx:method name="get*"/>
    </tx:attributes>
</tx:advice>

<aop:config>
    <aop:pointcut id="pointCut2" expression="execution(* cn.sail.transactional.*.*(..))"/>
    <aop:advisor advice-ref="txAdvice" pointcut-ref="pointCut2"/>
</aop:config>

添加 @Transactional 注解

此注解表示该方法开启事务。

这个注解也可以放在类上，表示这个类中的所有方法都开启事务。

@Service
public class UserService {

    @Resource
    private UserDao userDao;

    @Transactional
    public void updateMoney1() {
        userDao.addMoney("zhangsan", 100);
        int i = 1 / 0;
        userDao.reduceMoney("lisi", 100);
    }

}

测试

@Test
public void testTransactional() {
    userService.updateMoney1();
}

执行方法，会得到与 XML 配置一样的结果。