第一章：设计模式—代理模式

1.1 概述

• 代理模式：给某一个对象提供一个代理对象，并由代理对象控制对源对象的引用。代理就是一个人或一个机构代表另一个人或者一个机构采取行动。某些情况下，客户不想或者不能够直接引用一个对象，代理对象可以在客户和目标对象中间起到中介的作用。客户端分辨不出代理主题对象和真实主题对象的区别。代理模式可以并不知道被代理对象，而仅仅持有一个被代理对象的接口，这时代理对象不能够创建被代理对象，被代理对象必须有系统的其他角色代为创建并传入。
• 为什么需要代理模式？
  • ① 它有间接的特点，可以起到中介隔离作用。就好比在租房的时候，房东可能不在本地，而短期内又不能赶回来，此时中介的出场，就作为房东的代理实现和我们签订承租合同。而我们和房东之间就没有耦合了。
  • ② 它有增强的功能。还以租房为例，我们首先考虑的是找一个靠谱的中介，由中介给我们提供房源信息，并且告诉我们房屋的细节、合同的细节等等。当然我们也可以自己去找一些个人出租的房屋，但是在这之中，我们要了解租赁合同，房屋验收、租金监管等情况，这无疑对我们是繁重的工作。而有了中介作为我们的代理中间人，他把了解到的信息告诉我们，我们一样可以租到房子，而不必做哪些繁重的工作。

1.2 应用示例

1.2.1 准备工作

• sql脚本：

DROP TABLE IF EXISTS `account`;
CREATE TABLE `account`  (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `name` varchar(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci NULL DEFAULT NULL,
  `money` double NULL DEFAULT NULL,
  PRIMARY KEY (`id`) USING BTREE
) ENGINE = InnoDB AUTO_INCREMENT = 1 CHARACTER SET = utf8mb4 COLLATE = utf8mb4_general_ci ROW_FORMAT = Dynamic;
INSERT INTO `account` VALUES (1, '张三', 1000);
INSERT INTO `account` VALUES (2, '李四', 1000);

• 导入相关jar包的Maven坐标：

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>5.2.7.RELEASE</version>
</dependency>
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-web</artifactId>
    <version>5.2.7.RELEASE</version>
</dependency>
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-webmvc</artifactId>
    <version>5.2.7.RELEASE</version>
</dependency>
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-aspects</artifactId>
    <version>5.2.7.RELEASE</version>
</dependency>
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>druid</artifactId>
    <version>1.1.23</version>
</dependency>
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-jdbc</artifactId>
    <version>5.2.7.RELEASE</version>
</dependency>
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-test</artifactId>
    <version>5.2.7.RELEASE</version>
</dependency>
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>8.0.19</version>
</dependency>
<!--    导入YAML解析工厂坐标    -->
<dependency>
    <groupId>org.yaml</groupId>
    <artifactId>snakeyaml</artifactId>
    <version>1.26</version>
</dependency>
<dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>4.13</version>
    <scope>test</scope>
</dependency>
<dependency>
    <groupId>javax.inject</groupId>
    <artifactId>javax.inject</artifactId>
    <version>1</version>
</dependency>
<dependency>
    <groupId>javax.annotation</groupId>
    <artifactId>javax.annotation-api</artifactId>
    <version>1.3.2</version>
</dependency>
<dependency>
    <groupId>javax.servlet</groupId>
    <artifactId>javax.servlet-api</artifactId>
    <version>4.0.1</version>
</dependency>

• 日志文件log4j2.xml

<?xml version="1.0" encoding="UTF-8"?>
<!--日志级别以及优先级排序: OFF > FATAL > ERROR > WARN > INFO > DEBUG > TRACE > ALL -->
<!--Configuration后面的status用于设置log4j2自身内部的信息输出，可以不设置，当设置成trace时，可以看到log4j2内部各种详细输出-->
<configuration status="INFO">
    <!--先定义所有的appender-->
    <appenders>
        <!--输出日志信息到控制台-->
        <console name="Console" target="SYSTEM_OUT">
            <!--控制日志输出的格式-->
            <PatternLayout pattern="%d{yyyy-MM-dd HH:mm:ss.SSS} [%t] %-5level %logger{36} - %msg%n"/>
        </console>
    </appenders>
    <!--然后定义logger，只有定义了logger并引入的appender，appender才会生效-->
    <!--root：用于指定项目的根日志，如果没有单独指定Logger，则会使用root作为默认的日志输出-->
    <loggers>
        <root level="info">
            <appender-ref ref="Console"/>
        </root>
    </loggers>
</configuration>

• jdbc.yml

# Yet Another Markup Language 另一种标记语言
jdbc:
  url: jdbc:mysql://192.168.2.112:3306/spring5?useUnicode=true&characterEncoding=UTF-8&autoReconnect=true&useSSL=false&serverTimezone=GMT%2B8&allowPublicKeyRetrieval=true&nullCatalogMeansCurrent=true
  driver: com.mysql.cj.jdbc.Driver
  user: root
  password: 123456

• 自定义YAML的PropertySourceFactory

package com.sunxiaping.spring5.factory;
import org.springframework.beans.factory.config.YamlPropertiesFactoryBean;
import org.springframework.core.env.PropertiesPropertySource;
import org.springframework.core.env.PropertySource;
import org.springframework.core.io.support.EncodedResource;
import org.springframework.core.io.support.PropertySourceFactory;
import java.io.IOException;
import java.util.Properties;
/**
 * 自定义YAML的PropertySourceFactory
 */
public class YAMLPropertySourceFactory implements PropertySourceFactory {
    /**
     * 返回PropertySource对象
     *
     * @param name
     * @param resource
     * @return
     * @throws IOException
     */
    @Override
    public PropertySource<?> createPropertySource(String name, EncodedResource resource) throws IOException {
        //创建YAML文件解析工厂
        YamlPropertiesFactoryBean factoryBean = new YamlPropertiesFactoryBean();
        //设置要解析的资源内容
        factoryBean.setResources(resource.getResource());
        //把资源解析为properties文件
        Properties properties = factoryBean.getObject();
        return (name != null ? new PropertiesPropertySource(name, properties) : new PropertiesPropertySource(resource.getResource().getFilename(), properties));
    }
}

• Account.java

package com.sunxiaping.spring5.domain;
import java.io.Serializable;
public class Account implements Serializable {
    private Integer id;
    private String name;
    private Double money;
    public Account() {
    }
    public Account(Integer id, String name, Double money) {
        this.id = id;
        this.name = name;
        this.money = 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 +
                '}';
    }
}

• AccountDao.java

package com.sunxiaping.spring5.dao;
import com.sunxiaping.spring5.domain.Account;
public interface AccountDao {
    /**
     * 保存账户信息
     *
     * @param account
     */
    void save(Account account);
    /**
     * 根据id查询账户信息
     *
     * @param id
     * @return
     */
    Account findById(Integer id);
    /**
     * 更新账户信息
     *
     * @param account
     */
    void update(Account account);
    /**
     * 删除账户信息
     *
     * @param id
     */
    void delete(Integer id);
    /**
     * 根据名称查询用户信息
     *
     * @param name
     * @return
     */
    Account findByName(String name);
}

• AccountDaoImpl.java

package com.sunxiaping.spring5.dao.impl;
import com.sunxiaping.spring5.dao.AccountDao;
import com.sunxiaping.spring5.domain.Account;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Repository;
import org.springframework.util.CollectionUtils;
import java.util.List;
@Repository
public class AccountDaoImpl implements AccountDao {
    @Autowired
    private JdbcTemplate jdbcTemplate;
    @Override
    public void save(Account account) {
        jdbcTemplate.update(" INSERT INTO `account` (`name`,`money`) VALUES (?,?)  ", account.getName(), account.getMoney());
    }
    @Override
    public Account findById(Integer id) {
        List<Account> accountList = jdbcTemplate.query(" SELECT * FROM `account` WHERE id = ? ", new BeanPropertyRowMapper<>(Account.class), id);
        if (CollectionUtils.isEmpty(accountList)) {
            return null;
        }
        return accountList.get(0);
    }
    @Override
    public void update(Account account) {
        jdbcTemplate.update(" UPDATE `account` set name =?,money =? WHERE id = ? ", account.getName(), account.getMoney(), account.getId());
    }
    @Override
    public void delete(Integer id) {
        jdbcTemplate.update(" DELETE FROM account WHERE id = ? ", id);
    }
    @Override
    public Account findByName(String name) {
        List<Account> accountList = jdbcTemplate.query(" SELECT * FROM `account` WHERE name = ? ", new BeanPropertyRowMapper<>(Account.class), name);
        if (CollectionUtils.isEmpty(accountList)) {
            return null;
        }
        if (accountList.size() > 1) {
            throw new RuntimeException("名称name不唯一");
        }
        return accountList.get(0);
    }
}

• 事务管理器TransactionManager

package com.sunxiaping.spring5.utils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import java.sql.Connection;
import java.sql.SQLException;
@Component
public class TransactionManager {
    @Autowired
    private Connection connection;
    /**
     * 开始事务
     */
    public void begin() {
        try {
            connection.setAutoCommit(false);
        } catch (SQLException throwables) {
            throwables.printStackTrace();
        }
    }
    /**
     * 提交事务
     */
    public void commit() {
        try {
            connection.commit();
        } catch (SQLException throwables) {
            throwables.printStackTrace();
        }
    }
    /**
     * 回滚事务
     */
    public void rollback() {
        try {
            connection.rollback();
        } catch (SQLException throwables) {
            throwables.printStackTrace();
        }
    }
    /**
     * 释放资源
     */
    public void close() {
        try {
            connection.close();
        } catch (SQLException throwables) {
            throwables.printStackTrace();
        }
    }
}

• JdbcConfig.java

package com.sunxiaping.spring5.config;
import com.alibaba.druid.pool.DruidDataSource;
import com.sunxiaping.spring5.factory.YAMLPropertySourceFactory;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.PropertySource;
import org.springframework.jdbc.datasource.DataSourceUtils;
import org.springframework.transaction.support.TransactionSynchronizationManager;
import javax.sql.DataSource;
import java.sql.Connection;
@Configuration
@PropertySource(value = "classpath:jdbc.yml",factory = YAMLPropertySourceFactory.class)
public class JdbcConfig {
    @Value("${jdbc.url}")
    private String url;
    @Value("${jdbc.driver}")
    private String driver;
    @Value("${jdbc.user}")
    private String user;
    @Value("${jdbc.password}")
    private String password;
    /**配置数据源
     * @return
     */
    @Bean
    public DataSource dataSource(){
        DruidDataSource dataSource = new DruidDataSource();
        dataSource.setDriverClassName(driver);
        dataSource.setUrl(url);
        dataSource.setUsername(user);
        dataSource.setPassword(password);
        return dataSource;
    }
    @Bean
    public Connection getConnection(DataSource dataSource){
        //初始化事务同步管理器
        TransactionSynchronizationManager.initSynchronization();
        //使用Spring的数据源工具类获取当前线程的连接
        Connection connection = DataSourceUtils.getConnection(dataSource);
        //返回连接
        return connection;
    }
}

• SpringConfig.java

package com.sunxiaping.spring5.config;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Import;
import org.springframework.jdbc.core.JdbcTemplate;
import javax.sql.DataSource;
/**
 * Spring的配置类
 */
@Configuration
@Import({JdbcConfig.class})
@ComponentScan(value = "com.sunxiaping")
public class SpringConfig {
    @Bean
    public JdbcTemplate jdbcTemplate(DataSource dataSource){
        return new JdbcTemplate(dataSource);
    }
}

1.2.2 没有动态代理的情况下实现事务管理

• AccountService.java

package com.sunxiaping.spring5.service;
public interface AccountService {
    /**
     * 转账
     *
     * @param sourceName 转出账户名称
     * @param targetName 转入账户名称
     * @param money      金额
     */
    void transfer(String sourceName, String targetName, Double money);
}

• AccountServiceImpl.java

package com.sunxiaping.spring5.service.impl;
import com.sunxiaping.spring5.dao.AccountDao;
import com.sunxiaping.spring5.domain.Account;
import com.sunxiaping.spring5.service.AccountService;
import com.sunxiaping.spring5.utils.TransactionManager;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
@Service
public class AccountServiceImpl implements AccountService {
    @Autowired
    private AccountDao accountDao;
    @Autowired
    private TransactionManager transactionManager;
    @Override
    public void transfer(String sourceName, String targetName, Double money) {
        try {
            //开启事务
            transactionManager.begin();
            //查询转出账户
            Account source = accountDao.findByName(sourceName);
            //查询转入账户
            Account target = accountDao.findByName(targetName);
            //转出账户减钱
            source.setMoney(source.getMoney() - money);
            //转入账户加钱
            target.setMoney(target.getMoney() + money);
            //更新账户
            accountDao.update(source);
            //模拟异常
            int num = 10 / 0;
            accountDao.update(target);
            //提交事务
            transactionManager.commit();
        } catch (Exception e) {
            //回滚事务
            transactionManager.rollback();
            e.printStackTrace();
        } finally {
            //释放连接
            transactionManager.close();
        }
    }
}

• 测试：

package com.sunxiaping.spring5;
import com.sunxiaping.spring5.config.SpringConfig;
import com.sunxiaping.spring5.service.AccountService;
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 Spring5Test {
    @Autowired
    private AccountService accountService;
    @Test
    public void test() {
        accountService.transfer("张三","李四",100d);
    }
}

在没有动态代理实现事务管理的情况下，几乎每个方法都需要写事务开启、事务提交、事务回滚和释放资源的代码，太繁琐了。

1.2.3 动态代理实现事务管理

• AccountService.java

package com.sunxiaping.spring5.service;
public interface AccountService {
    /**
     * 转账
     *
     * @param sourceName 转出账户名称
     * @param targetName 转入账户名称
     * @param money      金额
     */
    void transfer(String sourceName, String targetName, Double money);
}

• AccountServiceImpl.java

package com.sunxiaping.spring5.service.impl;
import com.sunxiaping.spring5.dao.AccountDao;
import com.sunxiaping.spring5.domain.Account;
import com.sunxiaping.spring5.service.AccountService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
@Service
public class AccountServiceImpl implements AccountService {
    @Autowired
    private AccountDao accountDao;
    @Override
    public void transfer(String sourceName, String targetName, Double money) {
        //查询转出账户
        Account source = accountDao.findByName(sourceName);
        //查询转入账户
        Account target = accountDao.findByName(targetName);
        //转出账户减钱
        source.setMoney(source.getMoney() - money);
        //转入账户加钱
        target.setMoney(target.getMoney() + money);
        //更新账户
        accountDao.update(source);
        //模拟异常
        int num = 10 / 0;
        accountDao.update(target);
    }
}

• ProxyServiceFactory.java

package com.sunxiaping.spring5.factory;
import com.sunxiaping.spring5.service.AccountService;
import com.sunxiaping.spring5.utils.TransactionManager;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.stereotype.Component;
import java.lang.reflect.Proxy;
/**
 * 实现对AccountService的代理创建，同时加入事务
 */
@Component
public class ProxyServiceFactory {
    @Autowired
    private AccountService accountService;
    @Autowired
    private TransactionManager transactionManager;
    @Bean("proxyAccountService")
    public AccountService proxyAccountService() {
        //创建代理对象
        AccountService proxy = (AccountService) Proxy.newProxyInstance(accountService.getClass().getClassLoader(), accountService.getClass().getInterfaces(), (proxy1, method, args) -> {
            Object result = null;
            try {
                //开启事务
                transactionManager.begin();
                result = method.invoke(accountService, args);
                //提交事务
                transactionManager.commit();
            } catch (Exception e) {
                //回滚事务
                transactionManager.rollback();
                e.printStackTrace();
            } finally {
                //释放资源
                transactionManager.close();
            }
            return result;
        });
        return proxy;
    }
}

• 测试：

package com.sunxiaping.spring5;
import com.sunxiaping.spring5.config.SpringConfig;
import com.sunxiaping.spring5.service.AccountService;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = SpringConfig.class)
public class Spring5Test {
    @Autowired
    @Qualifier(value = "proxyAccountService")
    private AccountService accountService;
    @Test
    public void test() {
        accountService.transfer("张三","李四",100d);
    }
}

第二章：AOP思想及实现原理

2.1 AOP思想

• 在软件业，AOP为Aspect Oriented Programming的缩写，意为：面向切面编程，通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续，是软件开发的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。

2.2 实现原理

• 在上面的概念中描述出的AOP的实现原理是基于动态代理技术实现的。
• 动态代理的特点：字节码随用随创建，随用随加载。
• 动态代理的分类：基于接口的动态代理，基于子类的动态代理。
• 动态代理的作用：不修改源码的基础上对方法进行增强。
• 基于接口的动态代理：JDK官方。
• 基于子类的动态代理：第三方CGLIB包。

2.3 Spring中的AOP术语

• Joinpoint（连接点）：所谓连接点是指那些被拦截到的点。在Spring中，指的是方法，因为Spring只支持方法类型的连接点。
• Pointcut（切入点）：所谓切入点是指我们要对那些Pointcut进行拦截的定义。
• Advice（通知/增强）：
  • 所谓通知是指拦截到Joinpoint之后所要做的事情就是通知。
  • 通知的类型：前置通知，后置通知，异常通知，最终通知，环绕通知。
• Introduction（引介）：引介是一种特殊的通知，在不修改类代码的前提下，可以在运行期为类动态的添加一个方法或属性。
• Target（目标对象）：代理的目标对象。
• Weaving（织入）：
  • 是指把增强应用到目标对象来创建新的代理对象的过程。
  • Spring采用动态代理织入，而AspectJ采用编译期织入和类装载期织入。
• Proxy（代理）：一个类被AOP织入增强后，就产生了一个结果代理类。
• Aspect（切面）：是切入点和通知（引介）的结合。

第三章：Spring注解驱动AOP开发入门

3.1 注解驱动AOP入门案例介绍

• 实现在执行Service方法时输出日志。

3.2 案例实现

• 导入相关jar包的Maven坐标：

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>5.2.7.RELEASE</version>
</dependency>
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-web</artifactId>
    <version>5.2.7.RELEASE</version>
</dependency>
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-webmvc</artifactId>
    <version>5.2.7.RELEASE</version>
</dependency>
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-aspects</artifactId>
    <version>5.2.7.RELEASE</version>
</dependency>
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-aop</artifactId>
    <version>5.2.7.RELEASE</version>
</dependency>
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>druid</artifactId>
    <version>1.1.23</version>
</dependency>
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-jdbc</artifactId>
    <version>5.2.7.RELEASE</version>
</dependency>
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-test</artifactId>
    <version>5.2.7.RELEASE</version>
</dependency>
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>8.0.19</version>
</dependency>
<!--    导入YAML解析工厂坐标    -->
<dependency>
    <groupId>org.yaml</groupId>
    <artifactId>snakeyaml</artifactId>
    <version>1.26</version>
</dependency>
<dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>4.13</version>
    <scope>test</scope>
</dependency>
<dependency>
    <groupId>javax.inject</groupId>
    <artifactId>javax.inject</artifactId>
    <version>1</version>
</dependency>
<dependency>
    <groupId>javax.annotation</groupId>
    <artifactId>javax.annotation-api</artifactId>
    <version>1.3.2</version>
</dependency>
<dependency>
    <groupId>javax.servlet</groupId>
    <artifactId>javax.servlet-api</artifactId>
    <version>4.0.1</version>
</dependency>

• 实体类User.java

package com.sunxiaping.spring5.domain;
import java.io.Serializable;
import java.util.Date;
public class User implements Serializable {
    private String id;
    private String username;
    private String password;
    private Date birthday;
    private String gender;
    private String mobile;
    private String nickname;
    public String getId() {
        return id;
    }
    public void setId(String id) {
        this.id = id;
    }
    public String getUsername() {
        return username;
    }
    public void setUsername(String username) {
        this.username = username;
    }
    public String getPassword() {
        return password;
    }
    public void setPassword(String password) {
        this.password = password;
    }
    public Date getBirthday() {
        return birthday;
    }
    public void setBirthday(Date birthday) {
        this.birthday = birthday;
    }
    public String getGender() {
        return gender;
    }
    public void setGender(String gender) {
        this.gender = gender;
    }
    public String getMobile() {
        return mobile;
    }
    public void setMobile(String mobile) {
        this.mobile = mobile;
    }
    public String getNickname() {
        return nickname;
    }
    public void setNickname(String nickname) {
        this.nickname = nickname;
    }
    @Override
    public String toString() {
        return "User{" +
                "id='" + id + '\'' +
                ", username='" + username + '\'' +
                ", password='" + password + '\'' +
                ", birthday=" + birthday +
                ", gender='" + gender + '\'' +
                ", mobile='" + mobile + '\'' +
                ", nickname='" + nickname + '\'' +
                '}';
    }
}

• 业务层接口UserService.java

package com.sunxiaping.spring5.service;
import com.sunxiaping.spring5.domain.User;
public interface UserService {
    /**
     * 模拟保存用户信息
     *
     * @param user
     */
    void saveUser(User user);
}

• 业务层实现类UserServiceImpl.java

package com.sunxiaping.spring5.service.impl;
import com.sunxiaping.spring5.domain.User;
import com.sunxiaping.spring5.service.UserService;
import org.springframework.stereotype.Service;
@Service("userService")
public class UserServiceImpl implements UserService {
    @Override
    public void saveUser(User user) {
        System.out.println("保存用户信息" + user);
    }
}

• 切面类LogUtil.java

package com.sunxiaping.spring5.utils;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.stereotype.Component;
@Component
@Aspect //表明当前类是一个切面类
public class LogUtil {
    @Before(value = "execution(* com.sunxiaping.spring5.service.impl.*.*(..))")
    public void printLog() {
        System.out.println("输出日志");
    }
}

• Spring的配置类SpringConfig.java

package com.sunxiaping.spring5.config;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.EnableAspectJAutoProxy;
/**
 * Spring的配置类
 */
@Configuration
@ComponentScan(value = "com.sunxiaping.spring5")
@EnableAspectJAutoProxy //开启Spring的AOP注解的支持
public class SpringConfig {
}

• 测试：

package com.sunxiaping.spring5;
import com.sunxiaping.spring5.config.SpringConfig;
import com.sunxiaping.spring5.domain.User;
import com.sunxiaping.spring5.service.UserService;
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;
import java.util.Date;
import java.util.UUID;
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = SpringConfig.class)
public class Spring5Test {
    @Autowired
    private UserService userService;
    @Test
    public void test() {
        User user = new User();
        user.setId(UUID.randomUUID().toString());
        user.setUsername("张三");
        user.setPassword("123456");
        user.setBirthday(new Date());
        user.setGender("男");
        user.setMobile("110");
        user.setNickname("唐三葬");
        userService.saveUser(user);
    }
}

第四章：AOP常用注解分析

4.1 用于开启注解AOP注解的注解

4.1.1 @EnableAspectJAutoProxy注解

• @EnableAspectJAutoProxy注解：

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Import(AspectJAutoProxyRegistrar.class)
public @interface EnableAspectJAutoProxy {
    /**
     * Indicate whether subclass-based (CGLIB) proxies are to be created as opposed
     * to standard Java interface-based proxies. The default is {@code false}.
     */
    boolean proxyTargetClass() default false;
    /**
     * Indicate that the proxy should be exposed by the AOP framework as a {@code ThreadLocal}
     * for retrieval via the {@link org.springframework.aop.framework.AopContext} class.
     * Off by default, i.e. no guarantees that {@code AopContext} access will work.
     * @since 4.3.1
     */
    boolean exposeProxy() default false;
}

• 作用：
  • 表明开启Spring对注解AOP的支持。它有两个属性，分别是指定采用的代理方式和是否暴露代理对象，通过AopContext可以进行访问。从定义中可以看出，它引入AspectJAutoProxyRegistrar的字节码对象，该对象是基于注解@EnableAspectJAutoProxy注册了一个AnnotationAwareAspectJAutoProxyCreator，该对象通过调用AopConfigUtils的registerAspectJAnnotationAutoProxyCreatorIfNecessary(registry):注册一个AOP代理对象生成器。
• 属性：
  • proxyTargetClass：指定是否采用CGLIB进行代理。默认值是false，表示使用JDK的代理。
  • exposeProxy：指定是否暴露代理对象，通过AopContext可以进行访问。

• 使用场景：当我们注解驱动开发的时候，在需要使用AOP实现某些功能的情况下，都需要用到此注解。

• 示例：

package com.sunxiaping.spring5.config;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.EnableAspectJAutoProxy;
/**
 * Spring的配置类
 */
@Configuration
@ComponentScan(value = "com.sunxiaping.spring5")
@EnableAspectJAutoProxy //开启Spring的AOP注解的支持
public class SpringConfig {
}

4.2 用于配置切面的注解

4.2.1 @Aspect注解

• @Aspect注解：

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public @interface Aspect {
    /**
     * @return the per clause expression, defaults to singleton aspect.
     * Valid values are "" (singleton), "perthis(...)", etc
     */
    public String value() default "";
}

• 作用：声明当前类是一个切面类。
• 属性：
  • value：支持指定切入点表达式，或者用@Pointcut修改的方法名称（要求全限定方法名）。

• 使用场景：此注解也是一个注解驱动开发AOP的必备注解。

• 示例：

package com.sunxiaping.spring5.utils;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.stereotype.Component;
@Component
@Aspect //表明当前类是一个切面类
public class LogUtil {
    @Before(value = "execution(* com.sunxiaping.spring5.service.impl.*.*(..))")
    public void printLog() {
        System.out.println("输出日志");
    }
}

4.2.2 @Order注解

• @Order注解：

@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.TYPE, ElementType.METHOD, ElementType.FIELD})
@Documented
public @interface Order {
    /**
     * The order value.
     * <p>Default is {@link Ordered#LOWEST_PRECEDENCE}.
     * @see Ordered#getOrder()
     */
    int value() default Ordered.LOWEST_PRECEDENCE;
}

• 作用：@Order注解是定义Spring的IOC容器中的Bean的执行顺序的优先级。
• 属性：
  • value：最低优先级，值越小，优先级越高。

• 使用场景：可以改变默认的Spring加载多个切面的执行顺序（默认情况下是按照切面类名的自然顺序排序）。

• 示例：

• UserService.java

package com.sunxiaping.spring5.service;
import com.sunxiaping.spring5.domain.User;
public interface UserService {
    /**
     * 模拟保存用户信息
     *
     * @param user
     */
    void saveUser(User user);
}

• UserServiceImpl.java

package com.sunxiaping.spring5.service.impl;
import com.sunxiaping.spring5.domain.User;
import com.sunxiaping.spring5.service.UserService;
import org.springframework.stereotype.Service;
@Service("userService")
public class UserServiceImpl implements UserService {
    @Override
    public void saveUser(User user) {
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("保存用户信息" + user);
    }
}

• LogUtil.java

package com.sunxiaping.spring5.utils;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;
/**
 * 日志工具类
 */
@Component
@Aspect
@Order(1)
public class LogUtil {
    @Before(value = "execution(* com.sunxiaping.spring5.service.impl.*.*(..))")
    public void printLog() {
        System.out.println("输出日志");
    }
}

• EfficiencyUtil.java

package com.sunxiaping.spring5.utils;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;
import java.time.Duration;
import java.time.LocalDateTime;
/**
 * 方法效率的工具类
 */
@Component
@Aspect
@Order(2)
public class EfficiencyUtil {
    private LocalDateTime startTime;
    /**
     * 记录方法执行之前的时间
     */
    @Before(value = "execution(* com.sunxiaping.spring5.service.impl.*.*(..))")
    public void printBeforeExecutionTime() {
        startTime = LocalDateTime.now();
        System.out.println("方法开始执行时间 = " + startTime);
    }
    /**
     * 记录方法执行之后的时间
     */
    @After(value = "execution(* com.sunxiaping.spring5.service.impl.*.*(..))")
    public void printAfterExecutionTime() {
        LocalDateTime endTime = LocalDateTime.now();
        System.out.println("方法结束执行时间 = " + endTime);
        Duration duration = Duration.between(startTime, endTime);
        System.out.println("方法执行的时间 = " + duration.getSeconds() );
    }
}

• 测试：

package com.sunxiaping.spring5;
import com.sunxiaping.spring5.config.SpringConfig;
import com.sunxiaping.spring5.domain.User;
import com.sunxiaping.spring5.service.UserService;
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;
import java.util.Date;
import java.util.UUID;
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = SpringConfig.class)
public class Spring5Test {
    @Autowired
    private UserService userService;
    @Test
    public void test() {
        User user = new User();
        user.setId(UUID.randomUUID().toString());
        user.setUsername("张三");
        user.setPassword("123456");
        user.setBirthday(new Date());
        user.setGender("男");
        user.setMobile("110");
        user.setNickname("唐三葬");
        userService.saveUser(user);
    }
}

4.3 用于配置切入点表达式的注解

4.3.1 @Pointcut注解

• @Pointcut注解：

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface Pointcut {
    /**
     * @return the pointcut expression
     * We allow "" as default for abstract pointcut
     */
    String value() default "";
    /**
     * When compiling without debug info, or when interpreting pointcuts at runtime,
     * the names of any arguments used in the pointcut are not available.
     * Under these circumstances only, it is necessary to provide the arg names in 
     * the annotation - these MUST duplicate the names used in the annotated method.
     * Format is a simple comma-separated list.
     * 
     * @return argNames the argument names (should match those in the annotated method)
     */
    String argNames() default "";
}

• 作用：此注解是用于指定切入点表达式的。
• 属性：
  • value：用于指定切入点表达式。
  • argNames：用于指定切入点表达式中的参数。参数可以是execution中的，也可以是args中的。通常情况下不使用此属性也可以获得切入点的方法参数。

• 使用场景：在实际开发中，当我们的多个通知需要执行。

• 示例：

• LogUtil.java

package com.sunxiaping.spring5.utils;
import com.sunxiaping.spring5.domain.User;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;
/**
 * 日志工具类
 */
@Component
@Aspect
@Order(1)
public class LogUtil {
    /**
     * 用于定义通用的切入点表达式
     * 在value属性中使用了&&符号，表示并且的关系。
     * &&符号后面的args和execution一样，都是切入点表达式支持的关键字，表示匹配参数。指定的内容可以是全限定类名或者名称，当指定参数名称时，要求和方法中形参名称相同。
     * argNames属性，是定义参数的名称，该名称必须和args关键字中的名称一致。
     */
    @Pointcut(value = "execution(* com.sunxiaping.spring5.service.impl.*.*(..)) && args(user))", argNames = "user")
    public void pointcut(User user) {
    }
    @Before(value = "pointcut(user)", argNames = "user")
    public void printLog(User user) {
        System.out.println("输出日志" + user);
    }
}

4.4 用于配置通知的注解

4.4.1 @Before注解

• @Before注解：

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface Before {
    /**
     * @return the pointcut expression where to bind the advice
     */
    String value();
    /**
     * When compiling without debug info, or when interpreting pointcuts at runtime,
     * the names of any arguments used in the advice declaration are not available.
     * Under these circumstances only, it is necessary to provide the arg names in 
     * the annotation - these MUST duplicate the names used in the annotated method.
     * Format is a simple comma-separated list.
     * 
     * @return the argument names (should match the annotated method parameter names)
     */
    String argNames() default "";
}