自用Spring笔记 Spring是分层的Java SE/EE应用 full-stack轻量级开源框架，以IoC（In

1、Spring概述

spring是什么？

Spring是分层的Java SE/EE应用 full-stack轻量级开源框架，以IoC（Inverse Of Control：反转控制）和AOP（Aspect Oriented Programming：面向切面编程）为内核，提供了展现层Spring MVC和持久层Spring JDBC以及业务层事务管理等众多的企业级应用技术，还能整合开源世界众多著名的第三方框架和类库，逐渐成为使用最多的Java EE企业应用开源框架。

Spring的优势

方便解耦，简化开发
通过Spring提供的IoC容器，可以将对象间的依赖关系交由Spring进行控制，避免硬编码所造成的过度程序耦合。用户也不必再为单例模式类、属性文件解析等这些很底层的需求编写代码，可以更专注于上层的应用。

AOP编程的支持
通过Spring的AOP功能，方便进行面向切面的编程，许多不容易用传统OOP实现的功能可以通过AOP轻松应付。

声明式事务的支持
可以将我们从单调烦闷的事务管理代码中解脱出来，通过声明式方式灵活的进行事务的管理，提高开发效率和质量。
方便程序的测试
可以用非容器依赖的编程方式进行几乎所有的测试工作，测试不再是昂贵的操作，而是随手可做的事情。
方便集成各种优秀框架
Spring可以降低各种框架的使用难度，提供了对各种优秀框架（Struts、Hibernate、Hessian、Quartz等）的直接支持。
降低JavaEE API的使用难度
Spring对JavaEE API（如JDBC、JavaMail、远程调用等）进行了薄薄的封装层，使这些API的使用难度大为降低。

Java源码是经典学习范例
Spring的源代码设计精妙、结构清晰、匠心独用，处处体现着大师对Java设计模式灵活运用以及对Java技术的高深造诣。它的源代码无意是Java技术的最佳实践的范例。

spring的两大核心

spirng的发展历程
1997年，IBM提出了EJB的思想
1998年，SUN制定开发标准规范EJB1.0
1999年，EJB1.1发布
2001年，EJB2.0发布
2003年，EJB2.1发布
2006年，EJB3.0发布
Rod Johnson（spring之父）
Expert One-to-One J2EE Design and Development(2002)
阐述了J2EE使用EJB开发设计的优点及解决方案
Expert One-to-One J2EE Development without EJB(2004)
阐述了J2EE开发不使用EJB的解决方式（Spring雏形）
2017年9月份发布了spring的最新版本spring 5.0通用版（GA）

spring的体系结构

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-0Tr6tO6c-1605424436806)(C:\Users\15745\Desktop\SSM笔记\spring-overview.png)]

2、程序的耦合及解耦

/**
 * 程序的耦合
 *     耦合：程序间的依赖关系
 *          包括：
 *              类之间的依赖
 *              方法间的依赖
 *     解耦：降低程序间的依赖关系
 *     实际开发中：
 *          应该做到，编译期不依赖，运行时才依赖
 *     解耦思路：
 *          第一步：使用反射来创建对象，而避免使用new关键字
 *          第二步：通过读取配置文件来获取要创建的对象全限定类名
 * 	   可以选用两种方式可以是xml或者properties
 */

曾经案例中的问题

工厂案例

3、IOC概念和Spring中的IOC

控制反转（Inversion of Control，缩写为IoC），是面向对象编程中的一种设计原则，可以用来减低计算机代码之间的耦合度。其中最常见的方式叫做依赖注入（Dependency Injection，简称DI），还有一种方式叫“依赖查找”（Dependency Lookup）。通过控制反转，对象在被创建的时候，由一个调控系统内所有对象的外界实体将其所依赖的对象的引用传递给它。也可以说，依赖被注入到对象中。

Spring基于XML的IOC环境搭建

bean.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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd">
    <!--把对象的创建交给Spring来管理-->
    <bean id="className" class="Path from Source Root"></bean>
</bean>

/**
 * 获取spring的IOC核心容器，并根据id获取对象
 *
 * ApplicationContext的三个常用实现类
 *      ClassPathXmlApplicationContext:可以加载类路径下的配置文件，要求配置文件必须在类路径下(更常用)
 *      FileSystemXmlApplicationContext：可以加载磁盘任意路径下的配置文件（必须有访问权限）
 *      AnnotationConfigApplicationContext：用于读取注解创建容器
 *
 * 核心容器的两个接口引发出的问题：
 *  ApplicationContext:     单例对象适用      采用此接口
 *      在构建核心容器时，创建对象采用的策略是采用立即加载的方式。也就是说，只要一读取完配置文件马上就创建配置文件中配置的对象
 *  BeanFactory:            多例对象适用
 *      在构建核心容器时，创建对象采用的策略是采用延迟加载的方式，也就是说，什么时候根据id获取对象了，什么时候菜真正的创建对象
 */

spring对bean的管理细节

1、创建bean的三种方式

<!--把对象的创建交给Spring来管理-->
    <!--spring对bean的管理细节
        1、创建bean的三种方式
        2、bean对象的作用范围
        3、bean对象的生命周期
    -->

    <!--创建bean的三种方式-->
    <!--第一种方式：使用默认构造函数创建
            在spring配置文件中使用bean标签，配以id和class属性之后，且没有其他属性和标签时。
            采用的就是默认构造函数创建bean对象，此时如果没有默认构造函数，则对象无法创建
    -->
    <bean id="accountService" class="com.xin.service.impl.AccountServiceImpl"></bean>

    <!--第二种方式：使用普通工厂中的方法创建对象（使用某个类中的方法创建对象，并存入spring容器）-->
    <bean id="instanceFactory" class="com.xin.factory.InstanceFactory"></bean>
    <bean id="accountService" factory-bean="instanceFactory" factory-method="getAccountService"></bean>

    <!--第三种方式：使用工厂中的静态方法创建对象（使用某个类的静态方法创建对象，并存入spring容器）-->
    <bean id="accountService" class="com.xin.factory.StaticFactory" factory-method="getAccountService"></bean>

2、bean的作用范围调整

<!--bean的作用范围调整
        bean标签的scope属性
            作用：用于指定bean的作用范围
            取值：
                singleton：单例的（默认值）
                prototype：多例的
                request：  作用于web应用的请求范围
                session：  作用于web应用的会话范围
                global-session：作用于集群环境的会话范围（全局会话范围），当不是集群环境是就是session
    -->
    <bean id="accountService" class="com.xin.service.impl.AccountServiceImpl" scope="singleton"></bean>

3、bean的生命周期

单例对象
出生：当容器创建时，对象出生
活着：只要容器还在，对象一直活着
死亡：容器销毁，对象消亡
总结：单例对象的生命周期和容器相同

多例对象
出生：当我们使用对象时，spring框架为我们创建
活着：对象只要是在使用过程中就一直活着
死亡：当对象长时间不用且没有别的对象引用时，由Java的垃圾回收器回收

4、依赖注入(Dependency Injection)

spring中的依赖注入

依赖注入：Dependency Injection
IOC的作用：
降低程序间的耦合（依赖关系）
依赖关系的管理：
以后都交给spring来维护
在当前类需要用到其他类的对象，由spring为我们提供，我们只需要在配置文件中说明。
依赖关系的维护：
就称之为依赖注入
依赖注入：
能注入的数据：三类
基本数据类型String
其它bean类型（在配置文件中或注解配置过的bean）
复杂类型/集合类型
注入的方式有三种：

第一种：使用构造函数提供

构造函数注入

使用的标签是;constructor-arg
标签出现的位置：bean标签的内部
标签中的属性
type：用于指定要注入的数据的数据类型，该数据类型也是构造函数中某个或某些参数的类型
index：用于指定要注入的数据给构造函数中指定索引的参数赋值，索引的位置从0开始
name：用于指定给构造函数中指定名称的参数赋值
以上三个用于指定给构造函数中哪个参数赋值====
value：用于提供基本类型和String类型
ref：用于指定其他的bean类型数据。它指的就是在spring的IOC核心容器中出现过的bean对象
特点：
在获取bean对象时，注入数据是必须的操作，否这对象无法创建成功
弱点：
改变了bean对象的实例化方式，使我们在创建对象时，如果用不到这些数据，也必须提供

第二种：使用set方法

set方法注入（更常用）
涉及的标签：property
出现的位置：bean标签的内部
标签的属性
name：用于指定注入时所调用的方法名称
value：用于提供基本类型和String类型
ref：用于指定其他的bean类型数据。它指的就是在spring的IOC核心容器中出现过的bean对象
优点：
创建对象没有明确的限制，可以直接使用默认构造函数
缺点：
如果有某个成员必须有值，则获取对象时set方法没有执行

复杂/集合类型的注入
用于给List结构集合注入的标签有
list array set
用于给Map结构集合注入的标签有
map props
结构相同，标签可以互换

第三种：使用注解注入（详情请看第5点）

5、spring中IOC的常用注解

1、用于创建对象的

他们的作用就和在xml配置文件中编写一个实现的功能是一样的

Component

用于把当前对象存入spring对象容器中
属性：
value：用于指定bean的id。当我们不写时，他的默认值是当前类名，且首字母改小写
Controller：一般用在表现层
Service：一般用在业务层
Repository：一般用在持久层
以上三个注解他们的作用与Component是一模一样的，
他们三个是spring框架为我们提供明确的三层注解，使我们的三层对象更加清晰

2、用于注入数据的

他们的作用就和在xml配置文件中的标签中写一个标签作用是一样的

Autowired

作用：自动按照类型注入，只要容器中有唯一的一个bean对象类型和要注入的变量类型匹配，就可以成功注入
如果IOC容器中没有任何bean的类型和要注入的类型匹配，则报错
如果IOC容器中，有多个类型匹配时，先按照类型圈定出匹配的对象，再以变量名称为依据查找
出现位置：
可以是变量上，也可以是方法上
细节：
在使用注解注入时，set方法就不是必须的了

Qualifier

作用：在按照类中注入的基础之上再按照名称注入。它在给类成员注入时不能单独使用，但在给方法参数注入时可以
属性：
value：用于指定注入bean的id。

Resource

作用：直接按照bean的id注入。他可以独立使用
属性：
name：用于指定bean的id
以上三个注解都只能注入其他bean类型的数据，而基本类型和String类型无法使用上述注解实现
另外，集合类型的注入只能通过xml来实现。

Value

用于注入基本类型和String类型的数据
属性：
value：用于指定数据的值。他可以使用spring中的SpEL（也就是Spring中的EL表达式）
SpEL的写法：${表达式}

3、用于改变作用范围的

他们的作用就和在标签中使用scope属性是一样的

Scope

作用：用于指定bean的作用范围
属性：
value：指定范围的取值。常用取值：singleton(单例) prototype(多例) 默认为singleton

4、和生命周期相关的（了解）

他们的作用就和在标签中使用init-method属性和destory-method属性是一样的

PreDestroy

用于指定销毁方法

PostConstruct

用于指定初始化方法

6、案例使用xml方式和注解方式实现单表的CRUD操作

持久层技术操作选择：dbutils

pom.xml

<?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>day02_eesy_03account_annoioc</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>jar</packaging>

    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.3.0</version>
        </dependency>
        <dependency>
            <groupId>commons-dbutils</groupId>
            <artifactId>commons-dbutils</artifactId>
            <version>1.7</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.21</version>
        </dependency>
        <dependency>
            <groupId>c3p0</groupId>
            <artifactId>c3p0</artifactId>
            <version>0.9.1.2</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.13</version>
            <scope>test</scope>
        </dependency>
    </dependencies>
</project>

bean.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
        http://www.springframework.org/schema/context/spring-context.xsd">

    <!--告知Spring在创建容器是要扫描的包-->
    <context:component-scan base-package="com.xin"></context:component-scan>
    <!--配置QueryRunner对象-->
    <bean id="runner" class="org.apache.commons.dbutils.QueryRunner" scope="prototype">
        <!--注入数据源-->
        <constructor-arg name="ds" ref="dataSource"></constructor-arg>
    </bean>

    <!--配置数据源-->
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <!--链接数据库的必备信息-->
        <property name="driverClass" value="com.mysql.cj.jdbc.Driver"></property>
        <property name="jdbcUrl" value="jdbc:mysql://localhost:3306/spring?serverTimezone=Asia/Shanghai"></property>
        <property name="user" value="root"></property>
        <property name="password" value="123456"></property>
     </bean>

</beans>

查询所有

@Test
public void testFindAll(){
    //1、获取容器
    ApplicationContext applicationContext = new ClassPathXmlApplicationContext("bean.xml");
    //2、得到业务处理对象
    IAccountService iAccountService = applicationContext.getBean("accountService", IAccountService.class);
    //3、执行方法
    List<Account> accounts = iAccountService.findAllAccount();
    for (Account account : accounts){
        System.out.println(account);
    }
}

7、改造基于注解的ioc案例，使用纯注解的方式实现

spring的一些新注解方式

Configuration
作用：指定当前类是一个配置类
细节：当配置类作为AnnotationConfigApplicationContext对象创建的参数时，此时可不写，但并不绝对
ComponetScan
作用：用于通过注解指定spring在创建容器时要扫描的包
属性：
value：它和basePackages的作用是一样的，都是用于指定创建容器是要扫描的包
我们使用此注解就等同于在xml中配置了：
<context:component-scan base-package=“com.xin”>< /context:component-scan>
Bean
作用：用于把当前方法的返回值作为bean对象存入spring的ioc容器中
属性：
name：用于指定bean的id。当不写时，默认值是当前方法的名称
细节：
当我们使用注解配置方法时，如果方法有参数，spring框架会去容器中查找有没有可用的bean对象
查找的方式和Autowired注解的作用是一样的
Import
作用：用于导入其他的配置类
属性：
value：用于指定其他配置类的字节码文件
当我们使用Import的注解之后，有Import注解的类就父配置类，而倒入的都是子配置类
PropertySource
作用：用于指定properties文件的位置
属性：
value：指定文件的名称和路径
关键字：classpath，表示类路径下

SpringConfiguration.java

@Configuration
@ComponentScan(basePackages = "com.xin")
@Import(JdbcConfiguration.class)
@PropertySource("classpath:jdbcConfig.properties")
public class SpringConfiguration {

}

jdbcConfiguration.java

public class JdbcConfiguration {

    @Value("${jdbc.driver}")
    private String driver;

    @Value("${jdbc.url}")
    private String url;

    @Value("${jdbc.username}")
    private String username;

    @Value("${jdbc.password}")
    private String password;

    /**
     * 用于创建一个QueryRunner对象
     * @param dataSource
     * @return
     */
    @Bean(name = "runner")
    @Scope(value = "prototype")
    public QueryRunner createQueryRunner(DataSource dataSource){
        return new QueryRunner(dataSource);
    }

    /**
     * 创建数据对象
     * @return
     */
    @Bean(name = "dataSource")
    public DataSource createDataSource(){
        try{
            ComboPooledDataSource dataSource = new ComboPooledDataSource();
            dataSource.setDriverClass(driver);
            dataSource.setJdbcUrl(url);
            dataSource.setUser(username);
            dataSource.setPassword(password);
            return dataSource;
        }catch (Exception e){
            throw new RuntimeException(e);
        }
    }
}

测试类

@Test
public void testFindAll(){
    //1、获取容器
    ApplicationContext applicationContext = new AnnotationConfigApplicationContext(SpringConfiguration.class);
    //2、得到业务处理对象
    IAccountService iAccountService = applicationContext.getBean("accountService", IAccountService.class);
    //3、执行方法
    List<Account> accounts = iAccountService.findAllAccount();
    for (Account account : accounts){
        System.out.println(account);
    }
}

8、spring和Junit整合

1、应用程序的入口

main方法

2、junit单元测试中，没有main方法也能执行

junit集成了一个main方法

该方法就会判断当前测试类中那些方法有***@Test***注解

junit就会让有***@Test***注解的方法执行

3、junit不会管我们是否采用spring框架

在测试方法时，根本不知道我们是不是使用了spring框架

所以也就不会为我们读取配置文件/配置类创建spring核心容器

4、由以上三点可知

当测试方法执行时，没有IOC容器，就算写了***@Autowired***注解，也无法实现注入

使用Junit单元测试，测试配置
Spring整合Junit的配置
1、导入Spring整合junit的jar包（坐标）
2、使用junit提供的一个注解把原有的main方法替换了，替换成Spring提供的
@Runwith
3、告知Spring的运行器，spring和ioc创建是基于xml还是注解的，并且说明位置
@ContextConfiguration
locations：指定xml文件的位置，加上classpath关键字，表示在类路径下
classes: 指定注解类所在的位置

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = SpringConfiguration.class)
public class AccountServiceTest {

    @Autowired
    private IAccountService iAccountService;

    @Test
    public void testFindAll(){
        List<Account> accounts = iAccountService.findAllAccount();
        for (Account account : accounts){
            System.out.println(account);
        }
    }
}

9、动态代理

特点：字节码随用随创建，随用随加载
作用：不修改源码的基础上对方法增强
分类：
基于接口的动态代理
基于子类的动态代理

基于接口的动态代理：

涉及的类：Proxy
提供方：JDK官方
如何创建代理对象：
使用Proxy类中的newProxyInstance方法
创建代理对象的要求：
被代理最少实现一个接口，如果没有则不能使用
newProxyInstance方法的参数：
ClassLoader:类加载器
他是用于加载代理对象字节码的。和被代理对象使用相同的类加载器。固定写法
Class[ ]:字节码数组
用于让代理对象和被代理对象有相同的方法。固定写法
InvocationHandler:用于增强的代码
让我们如何写代理。一般都是些一个该接口的实现类，通常情况下都是匿名类，但不是必须的
此接口的实现类都是谁用谁写

IProducer proxyProducer = (IProducer)Proxy.newProxyInstance(producer.getClass().getClassLoader(),
                producer.getClass().getInterfaces(),
                new InvocationHandler() {
                    /**
                     * 作用：执行被代理对象的任何接口方法都会经过该方法
                     * 方法参数的含义
                     * @param proxy     代理对象的引用
                     * @param method    当前执行的方法
                     * @param args      当前执行方法所需的参数
                     * @return          和被代理对象有相同的返回值
                     * @throws Throwable
                     */
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        //提供增强的代码
                        Object returnValue = null;
                        //1、获取方法执行的参数
                        Double money = (Double)args[0];
                        //2、判断当前方法是不是销售
                        if ("saleProduct".equals(method.getName())){
                            returnValue = method.invoke(producer, money * 0.8);
                        }
                        return  returnValue;
                    }
                });
        proxyProducer.saleProduct(10000);

基于子类的动态代理：

涉及的类：Enhancer
提供方：第三方cglib库

导入依赖pom.xml

<dependency>
    <groupId>cglib</groupId>
    <artifactId>cglib</artifactId>
    <version>3.3.0</version>
</dependency>

如何创建代理对象：
使用Enhancer类中的create方法
创建代理对象的要求：
被代理类不能是最终类
create方法的参数：
Class:字节码
用于指定被代理对象的字节码。固定写法
Callback:用于增强的代码
让我们如何写代理。一般都是些一个该接口的实现类，通常情况下都是匿名类，但不是必须的
此接口的实现类都是谁用谁写
一般写的是该接口的子类实现类，MethodInterceptor

Producer cglibProducer = (Producer)Enhancer.create(producer.getClass(),
                new MethodInterceptor() {
                    /**
                     * 执行被代理对象的任何方法都会经过该方法
                     * @param proxy
                     * @param method
                     * @param args
                     *      以上三个参数和基于接口的动态代理中invoke方法的参数是一样的
                     * @param methodProxy   当前执行方法的代理对象
                     * @return
                     * @throws Throwable
                     */
                    public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
                        //提供增强的代码
                        Object returnValue = null;
                        //1、获取方法执行的参数
                        Double money = (Double)args[0];
                        //2、判断当前方法是不是销售
                        if ("saleProduct".equals(method.getName())){
                            returnValue = method.invoke(producer, money * 0.8);
                        }
                        return  returnValue;
                    }
                });
        cglibProducer.saleProduct(12000);

10、AOP

Aspect Oriented Programming 面向切面编程

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

简单的说它就是把我们重复的程序抽取出来，在需要执行的时候，使用动态代理的技术，在不修改源码的基础上对我们已有的方法进行增强。

作用：在程序运行期间，不修改源码对已有的方式进行增强

优势：减少重复代码，提高开发效率，维护方便

11、spring中的AOP相关术语

Joinpoint(连接点): 所谓连接点是指那些被拦截到的点。在spring中,这些点指的是方法,因为spring只支持方法类型的连接点。

Pointcut(切入点): 所谓切入点是指我们要对哪些Joinpoint进行拦截的定义。

Advice(通知/增强) : 所谓通知是指拦截到Joinpoint之后所要做的事情就是通知。通知的类型：前置通知,后置通知,异常通知,最终通知,环绕通知。

Introduction(引介) : 引介是一种特殊的通知在不修改类代码的前提下, Introduction可以在运行期为类动态地添加一些方法或Field。

Target(目标对象) : 代理的目标对象。也就是被代理对象

Weaving(织入) : 是指把增强应用到目标对象来创建新的代理对象的过程。 spring采用动态代理织入，而AspectJ采用编译期织入和类装载期织入。

Proxy(代理) : 一个类被AOP织入增强后，就产生一个结果代理类。代理对象

Aspect(切面) : 是切入点和通知（引介）的结合。

明确的事

12、spring中基于XML和注解的AOP配置

XML的配置

pom.xml

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>5.3.0</version>
</dependency>
<dependency>
    <groupId>org.aspectj</groupId>
    <artifactId>aspectjweaver</artifactId>
    <version>1.9.6</version>
</dependency>

bean.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:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop.xsd">
     <!--配置Spring的IOC，把service对象配置进来-->
    <bean id="accountService" class="com.xin.service.impl.AccountServiceImpl"></bean>
    <!--配置logger类-->
    <bean id="logger" class="com.xin.utils.Logger"></bean>
    <!--配置AOP-->
    <aop:config>
        <!--配置切面-->
        <aop:aspect id="logAdvice" ref="logger">
            <!--配置通知的类型，并且建立通知方法和切入点方法的关联-->
            <aop:before method="printLog" pointcut="execution(* com.xin.service.impl.*.*(..))"></aop:before>
        </aop:aspect>
    </aop:config>
</beans>

Spring中基于xml的AOP配置步骤
1、把通知Bean也交给spring来管理
2、使用aop:config标签表明开始AOP的配置
3、使用aop:aspect标签表明开始配置切面
属性：
id：给切面提供一个唯一标志
ref：是指定通知类bean的id
4、在aop:aspect标签内部来使用对应标签来配置通知的类型
我们现在的示例是让printLog方法在切入点方法之前执行，所以是前置通知
aop:before：表示配置前置通知
属性：
method：用于指定log类中哪个方法是前置通知
pointcut:用于指定切入点表达式，该表达式的含义指的是对业务层中哪些方法增强
切入点表达式的写法：

关键字：execution（表达式）
	表达式：
		访问修饰符   返回值     包名.类名.方法名（参数列表）
		标准表达式写法：
			public void com.xin.service.impl.AccountServiceImpl.saveAccount()
		访问修饰符可以省略
			void com.xin.service.impl.AccountServiceImpl.saveAccount()
		返回值可以使用通配符，表示返回任意值
			* com.xin.service.impl.AccountServiceImpl.saveAccount()
		包名可以使用通配符表示任意包。但是有几级包就要写几个*.
			* *.*.*.*.AccountServiceImpl.saveAccount()
		包名可以使用..表示当前包及其子包
			* *..AccountServiceImpl.saveAccount()
		类名和方法名都可以使用*来实现通配
			* *..*.saveAccount()
			* *..*.*()
		参数列表
			可以直接写数据类型
			基本类型直接写名称
				* *..*.*(int)
			引用类型写包名.类名的方法   java.lang.String
				* *..*.*(java.lang.String)
			可以使用通配符表示任意类型，但是必须有参数
				* *..*.*(*)
			可以使用..表示有无参数均可
				* *..*.*(..)
		全通配写法：
			* *..*.*(..)
		实际开发中切入点表达式的通常写法
			* com.xin.service.impl.*.*(..)

前置、后置、异常、最终和环绕通知

<!--配置AOP-->
    <aop:config>
        <!--配置切入点表达式 id用于指定表达式的唯一标识 expression用于指定表达式内容
                此标签写在aop:aspect标签内部只能在当前切面使用
                他还可以写在aop:aspect外面，此时就变成了所有切面可用
            -->
        <aop:pointcut id="pt1" expression="execution(* com.xin.service.impl.*.*(..))"/>
        <!--配置切面-->
        <aop:aspect id="logAdvice" ref="logger">
            <!--配置前置通知，在切入点方法之前执行-->
            <aop:before method="beforePrintLog" pointcut-ref="pt1"></aop:before>
            <!--配置后置通知，再切入点方法正常执行之后执行。它和异常通知永远只能执行一个-->
            <aop:after-returning method="afterReturningPrintLog" pointcut-ref="pt1"></aop:after-returning>
            <!--配置异常通知，在切入点方法产生异常之后执行。它和后置通知永远只能执行一个-->
            <aop:after-throwing method="afterThrowingPrintLog" pointcut-ref="pt1"></aop:after-throwing>
            <!--配置最终通知，无论切入点方法是否正常执行都会在其后面执行-->
            <aop:after method="afterPrintLog" pointcut-ref="pt1"></aop:after>
            <aop:around method="aroundPrintLog" pointcut-ref="pt1"></aop:around>
        </aop:aspect>
    </aop:config>

环绕通知

问题：
当我们配置了环绕通知之后，切入点方法没有执行，而通知方法执行了
分析：
通过对比动态代理中环绕通知的代码，发现动态代码通知有明确的切入点方法调用，而我们的代码中没有
解决：
Spring框架为我们提供了一个接口，ProceedingJoinPoint。该接口有一个方法proceed()，此方法就相当于明确调用切入点方法
该借口可以作为环绕通知的方法参数，在程序执行时，spring框架会为我们提供该接口的实现类供我们使用

spring的环绕通知：
是spring框架为我们提供的一种可以在代码中手动控制增强代码何时执行的方式

注解配置

pom.xml

<dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.3.0</version>
        </dependency>
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.9.6</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aop</artifactId>
            <version>5.3.0</version>
        </dependency>
    </dependencies>

Logger.java

@Component("logger")
/**
 * 当前类是一个切面类
 */
@Aspect
public class Logger {

    @Pointcut("execution(* com.xin.service.impl.*.*(..))")
    private void pt1(){}

    /**
     * 前置通知
     */
//    @Before("pt1()")
    public void beforePrintLog(){
        System.out.println("前置通知Logger类中的beforePrintLog方法开始执行了^^");
    }
    /**
     * 后置通知
     */
//    @AfterReturning("pt1()")
    public void afterReturningPrintLog(){
        System.out.println("后置通知Logger类中的afterReturningPrintLog方法开始执行了^^");
    }
    /**
     * 异常通知
     */
//    @AfterThrowing("pt1()")
    public void afterThrowingPrintLog(){
        System.out.println("异常通知Logger类中的afterThrowingPrintLog方法开始执行了^^");
    }
    /**
     * 最终通知
     */
//    @After("pt1()")
    public void afterPrintLog(){
        System.out.println("最终通知Logger类中的afterPrintLog方法开始执行了^^");
    }
    /**
     * 环绕通知
     */
    @Around("pt1()")
    public Object aroundPrintLog(ProceedingJoinPoint proceedingJoinPoint){
        Object rtValue = null;
        try{
            //得到方法执行所需的参数
            Object[] args = proceedingJoinPoint.getArgs();
            System.out.println("Logger类中的aroundPrintLog方法开始执行了^^前置");
            //明确调用业务层方法(切入点方法)
            rtValue = proceedingJoinPoint.proceed(args);
            System.out.println("Logger类中的aroundPrintLog方法开始执行了^^后置");
            return rtValue;
        }catch (Throwable t){
            System.out.println("Logger类中的aroundPrintLog方法开始执行了^^异常");
            throw new RuntimeException(t);
        }finally {
            System.out.println("Logger类中的aroundPrintLog方法开始执行了^^最终");
        }

    }
}

bean.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:aop="http://www.springframework.org/schema/aop"
       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/aop
        http://www.springframework.org/schema/aop/spring-aop.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd">
    <!--配置Spring创建容器是要扫描的包-->
    <context:component-scan base-package="com.xin"></context:component-scan>
    <!--配置Spring开启注解AOP的支持-->
    <aop:aspectj-autoproxy></aop:aspectj-autoproxy>
</beans>