加载spring -> 创建资源 -> 配置资源 -> 使用资源
 1. pom.xml中导入spring坐标（5.1.9.release）
     <dependency>
         <groupId>org.springframework</groupId>
         <artifactId>spring-context</artifactId>
         <version>5.1.9.RELEASE</version>
     </dependency>
 2. 编写业务层与表现层（模拟）接口与实现类
 3. 建立spring配置文件(主配置文件必须为applicationContext,xml)
 4. 配置所需资源（Service）为spring控制的资源
 <?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
     https://www.springframework.org/schema/beans/spring-beans.xsd">
        <!-- 1.创建spring控制的资源-->
        <bean id="userService"class="com.itheima.service.impl.UserServiceImpl"/>
     </beans>
 5. 表现层（App）通过spring获取资源（Service实例）
     //2.加载配置文件
     ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
     //3.获取资源
     UserService userService = (UserService) ctx.getBean("userService");
     userService.save();

 了解:可以通过BeanFactory来构建对象
 Resource res = new ClassPathResource("applicationContext.xml");
 BeanFactory bf = new XmlBeanFactory(res);
 UserService userService = (UserService)bf.getBean("userService");

 纯注解格式下加载上下文对象使用 AnnotationConfigApplicationContext
 AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext(SpringConfig.class);

@Import(JDBCConfig.class)
 public class MybatisConfig {
 
     @Bean
     public SqlSessionFactoryBean getSqlSessionFactoryBean(DataSource dataSource){
         SqlSessionFactoryBean sqlSessionFactoryBean = new SqlSessionFactoryBean();
         sqlSessionFactoryBean.setDataSource(dataSource);
         sqlSessionFactoryBean.setTypeAliasesPackage("com.river.domain");
         return sqlSessionFactoryBean;
    }
 
     @Bean
     public MapperScannerConfigurer getMapperScannerConfigurer(){
         MapperScannerConfigurer mapperScannerConfigurer = new MapperScannerConfigurer();
         mapperScannerConfigurer.setBasePackage("com.river.dao");
         return mapperScannerConfigurer;
    }
 }

 @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("dataSource")
 public  DruidDataSource getDataSource(){
     DruidDataSource dds = new DruidDataSource();
     dds.setDriverClassName(driver);
     System.out.println(driver);
     dds.setUrl(url);
     dds.setUsername(username);
     dds.setPassword(password);
     return dds;
 }

 1. 导入相关坐标
     <dependency>
         <groupId>org.aspectj</groupId>
         <artifactId>aspectjweaver</artifactId>
         <version>1.9.4</version>
     </dependency>
 2. 确认要抽取的功能，并将其制作成方法保存到专用的类中，删除原始业务中对应的功能
 (功能分离,实际开发过程先设计再制作)
 3. 将所有进行AOP操作的资源加载到IoC容器中
 beans标签中声明xmlns:aop的约束
 4. 使用配置的方式描述被抽取功能的位置，并描述被抽取功能与对应位置的关系(配置关系)
  <!--aop配置-->
     <aop:config>
         <!--配置切入点-->
         <aop:pointcut id="pt" expression="execution(* *..*())"/>
         <!--配置切面-->
         <aop:aspect ref="myAdvice">
             <!--通知与切入点之间的关系-->
             <aop:before method="logAdvice" pointcut-ref="pt"/>
         </aop:aspect>
     </aop:config>
 5. 运行程序

 ● Aspect（切面）用于描述切入点与通知间的关系，是AOP编程中的一个概念
 ● AspectJ是基于java语言对Aspect的实现

 1. * ：单个独立的任意符号，可以独立出现，也可以作为前缀或者后缀的匹配符出现
 execution（public * com.river.*.UserService.find*（*））
 ◆ 匹配com.river包下的任意包中的UserService类或接口中所有find开头的带有一个参数的方法
 2. .. ：多个连续的任意符号，可以独立出现，常用于简化包名与参数的书写
 execution（public User com..UserService.findById（..））
 ◆ 匹配com包下的任意包中的UserService类或接口中所有名称为findById的方法
 3. +：专用于匹配子类类型
 execution(* *..*Service+.*(..))

 ● && ：连接两个切入点表达式，表示两个切入点表达式同时成立的匹配
 ● || ：连接两个切入点表达式，表示两个切入点表达式成立任意一个的匹配
 ● ! ：连接单个切入点表达式，表示该切入点表达式不成立的匹配

1.匹配所有三种格式
    execution(* *(..))
    execution(* *..*(..))
    execution(* *..*.*(..))
2.匹配所有公共的返回值为空的service包下的所有方法
    execution(public void com..service.*.*(..))

1.公共切入点
  在aop:aspect标签之外声明aop:pointcut
2.局部切入点
  在aop:aspect标签内部声明aop:pointcut
3.直接切入点
  在aop:aspect内部的通知中手动指定pointcut属性
  
● 示例配置
  <aop:config>
        <!--配置公共切入点--> 
        <aop:pointcut id="pt1" expression="execution(* *(..))"/>
            <aop:aspect ref="myAdvice">
                <!--配置局部切入点--> 
                <aop:pointcut id="pt2" expression="execution(* *(..))"/>
                <!--引用公共切入点--> 
                    <aop:before method="logAdvice" pointcut-ref="pt1"/>
                <!--引用局部切入点--> 
                    <aop:before method="logAdvice" pointcut-ref="pt2"/>
                <!--直接配置切入点--> 
                    <aop:before method="logAdvice" pointcut="execution(* *(..))"/>
            </aop:aspect>
    </aop:config>

作用:设置前置通知,可以在一个aop:aspect中配置多个aop:before
基本属性:
    ◆ method ：在通知类中设置当前通知类别对应的方法
    ◆ pointcut ：设置当前通知对应的切入点表达式，与pointcut-ref属性冲突
    ◆ pointcut-ref ：设置当前通知对应的切入点id，与pointcut属性冲突

作用:设置后置通知,可以在一个aop:aspect中配置多个aop:after
基本属性:
    ◆ method ：在通知类中设置当前通知类别对应的方法
    ◆ pointcut ：设置当前通知对应的切入点表达式，与pointcut-ref属性冲突
    ◆ pointcut-ref ：设置当前通知对应的切入点id，与pointcut属性冲突

作用：设置返回后通知,可以在一个aop:aspect中配置多个aop:after-returning
基本属性:
    ◆ method ：在通知类中设置当前通知类别对应的方法
    ◆ pointcut ：设置当前通知对应的切入点表达式，与pointcut-ref属性冲突
    ◆ pointcut-ref ：设置当前通知对应的切入点id，与pointcut属性冲突

作用：设置抛出异常后通知,可以在一个aop:aspect中配置多个aop:after-throwing
基本属性:
    ◆ method ：在通知类中设置当前通知类别对应的方法
    ◆ pointcut ：设置当前通知对应的切入点表达式，与pointcut-ref属性冲突
    ◆ pointcut-ref ：设置当前通知对应的切入点id，与pointcut属性冲突

作用：设置环绕通知,可以实现其他四种通知方式的功能,可以在一个aop:aspect中配置多个aop:around
基本属性:
    ◆ method ：在通知类中设置当前通知类别对应的方法
    ◆ pointcut ：设置当前通知对应的切入点表达式，与pointcut-ref属性冲突
    ◆ pointcut-ref ：设置当前通知对应的切入点id，与pointcut属性冲突

◆ 环绕通知是在原始方法的前后添加功能，在环绕通知中，存在对原始方法的显式调用
    public Object around(ProceedingJoinPoint pjp) throws Throwable {
        Object ret = pjp.proceed();  // 实现对原方法进行调用
        return ret; // 规范,需要存在返回值,返回类型为null
    }
● 环绕通知方法相关说明：
    ◆ 方法须设定Object类型的返回值，否则会拦截原始方法的返回。如果原始方法返回值类型为
void，通知方法也可以设定返回值类型为void，最终返回null
    ◆ 方法需在第一个参数位置设定ProceedingJoinPoint对象，通过该对象调用proceed()方法，实
现对原始方法的调用。如省略该参数，原始方法将无法执行
    ◆ 使用proceed()方法调用原始方法时，因无法预知原始方法运行过程中是否会出现异常，强制抛
出Throwable对象，封装原始方法中可能出现的异常信息

1.所有的通知均可以获取参数,设置通知方法的首个参数为JoinPoint,通过该对象调用getArgs()方法,获取原始方法运行的参数数组
  public void before(JoinPoint jp) throws Throwable {
        Object[] args = jp.getArgs();
    }
2.XML配置文件方式获取参数
  (1)通过在标签中切入点表达式添加args()选项指定获取到的参数
  (2)通过通知标签中的agr-name改变参数传入通知的顺序

● 在XML格式基础上
    ◆ 导入坐标（伴随spring-context坐标导入已经依赖导入完成）
    ◆ 开启AOP注解支持
      <aop:aspectj-autoproxy/>
    ◆ 配置切面@Aspect
      类上声明该类为一个切面@Aspect
    ◆ 定义专用的切入点方法，并配置切入点@Pointcut
      切入点最终体现为一个方法，无参无返回值，无实际方法体内容，但不能是抽象方法
    ◆ 为通知方法配置通知类型及对应切入点@Before
      引用切入点时必须使用方法调用名称,方法后面的()不能省略

1.@Aspect -- 设置当前类为切面类
  @Aspect
    public class AopAdvice {
    }
2.@Pointcut -- 使用当前方法名作为切入点引用名称,被修饰的方法忽略其
业务功能，格式设定为无参无返回值的方法，方法体内空实现（非抽象）
  @Pointcut("execution(* *(..))")
    public void pt() {}
3.通知 -- @Before,@After,@AfterReturning,@AfterThrowing,@Around
    在方法定义上方进行通知类型的声明,可以设置局部切入点也可以配置全局切入点
    @Around("pt()") / @Around("execution(* *..*.*(..))")

1.XML中开启AOP注解支持
  <aop:AspectJ-AutoProxy />
2.注解驱动用于代替XML开启注解支持的方式,在Spring注解配置类定义上方声明注解驱动
  @EnableAspectJAutoProxy
  @Configuration /// 代替XML文件
  @ComponentScan("com.river") // 设置扫描范围
  @EnableAspectJAutoProxy // 开启AOP注解驱动
  public class SpringConfig {
  }

对项目进行业务层接口执行监控，测量业务层接口的执行效率
实现思想:
● 测量接口执行效率：接口方法执行前后获取执行时间，求出执行时长
  ◆ System.currentTimeMillis( )
● 对项目进行监控：项目中所有接口方法，AOP思想，执行期动态织入代码
    ◆ 环绕通知
    ◆ proceed()方法执行前后获取系统时间
   
实现步骤:
  1.定义切入点（务必要绑定到接口上，而不是接口实现类上）
  2.制作AOP环绕通知，完成测量功能
  3.注解配置AOP
  4.开启注解驱动支持
  
核心方法:
    //获取执行签名信息,pjp为方法声明参数类型的ProceddingJoinPoint的参数名称
    Signature signature = pjp.getSignature();
    //通过签名获取执行类型（接口名）
    String targetClass = signature.getDeclaringTypeName();
    //通过签名获取执行操作名称（方法名）
    String targetMethod = signature.getName();

JDKProxy动态代理是针对对象做代理，要求原始对象具有接口实现，并对接口方法进行增强
public StudentService save(StudentService studentService){
        return (StudentService) Proxy.newProxyInstance(
            studentService.getClass().getClassLoader(),
            studentService.getClass().getInterfaces(), 
            new InvocationHandler() {
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                if (method.getName().equals("save")) {
                    System.out.println("刮大白");
                    System.out.println("柏木板");
                }
                return method.invoke(studentService,args);
            }
        });
    }

PlatformTransactionManager -- 平台事务管理器,接口定义了事务的基本操作
  DataSourceTransactionManager -- 适用于Spring JDBC或MyBatis
TransactionDefinition -- 事务定义,接口定义了事务的基本信息
TransactionStatus -- 事务状态,接口定义了事务在执行过程中某个时间点上的状态信息及对应的状态操作

● 使用spring提供的专用于mybatis的事务管理器在业务层硬编码进行事务管理,业务层要注入dataSource对象
● 将业务层的事务处理功能抽取出来制作成AOP通知，利用环绕通知运行期动态织入
public Object transactionManager(ProceedingJoinPoint pjp) throws Throwable {
    // 定义事务管理器
    PlatformTransactionManager tx = new DataSourceTransactionManager();
    //为事务管理器设置与数据层相同的数据源
    tx.setDataSource(dataSource);
    // 定义事务定义对象
    TransactionDefinition definition = new DefaultTransactionDefinition();
    // 定义事务状态,用于控制事务执行
    TransactionStatus status = tx.getTransaction(definition);
    // 执行原方法
    Object ret = pjp.proceed(pjp.getArgs());
    // 提交事务
    tx.commit(status);
    return ret;
}

● 由于事务管理的代码是固定的,Spring将这一操作进行了封装,通过一系列配置就可以
实现事务管理,而不必编写对应的事务管理代码
● 在aop:config中配置了全局的切入点,而在tx:advice中可以定义事务专属的方法匹配,
进行事务管理的前提是先要匹配切入点并且匹配事务专属的方法名
1.XML beans标签中声明事务管理 
   xmlns:tx="http://www.springframework.org/schema/tx"
     http://www.springframework.org/schema/aop
     https://www.springframework.org/schema/aop/spring-aop.xsd
2.定义事务管理   
         <bean id="txManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource"/>
3.配置事务专属通知类
    <tx:advice id="txAdvice" transaction-manager="txManager">
        <tx:attributes>
          <!-- name可使用通配符 -->
            <tx:method name="transfer" read-only="false"/>
        </tx:attributes>
    </tx:advice>
4.使用aop:advisor 在AOP配置中引用事务专属通知类
    <aop:config>
        <aop:pointcut id="pt" expression="execution(* *..*.transfer(..))"/>
        <aop:advisor advice-ref="txAdvice" pointcut-ref="pt"/>
    </aop:config>

● aop:advice配置的通知类可以是普通java对象，不实现接口，也不使用继承关系
● aop:advisor配置的通知类必须实现通知接口,advisor是一种特殊的advice
    ◆ MethodBeforeAdvice
    ◆ AfterReturningAdvice
    ◆ ThrowsAdvice
    ◆ ……

1.tx:advice -- 用于声明事务通知
  ◆ id ：用于配置aop时指定通知器的id
  ◆ transaction-manager ：指定事务管理器bean
2.tx:attributes -- 定义通知属性
3.tx:method -- 设置具体的事务属性
  ◆ 通常事务属性会配置多个，包含1个读写的全事务属性，1个只读的查询类事务属性

1.@Transactional // (tx:advice) -- 方法注解/类注解/接口注解,在方法定义/类定义/接口定义上方进行定义
  作用:设置当前类/接口中所有方法或具体方法开启事务，并指定相关事务属性
2.XML:标签tx:annotation-driven -- 开启事务注解驱动，并指定对应的事务管理器
  <tx:annotation-driven transaction-manager="txManager"/
3.配置纯注解驱动 -- @EnableTransactionManagement 
          // (annotation-driven) -- 在Spring注解配置类上方进行声明
  ● 开启注解驱动，等同XML格式中的注解驱动

事务管理员:方法一中的事务
事务协调员:方法二中的事务
事务传播行为就是指方法二中的事务对于方法一中的事务的态度
    常用的传播属性:required supports

模板对象可以将每一个功能都单独拿出来作为一个模板
常用模板对象有以下这些:
  ● TransactionTemplate
    ● JdbcTemplate
    ● RedisTemplate
    ● RabbitTemplate
    ● JmsTemplate
    ● HibernateTemplate
    ● RestTemplate