【编程不良人】快速入门Spring学习笔记06---AOP

Myth丶恋晨 2023-10-09 13:59 36阅读 0赞

**配套视频：**[【编程不良人】快速入门Spring,SpringBoot、SpringCloud学不好完全是因为Spring没有掌握!\_哔哩哔哩\_bilibili][Spring_SpringBoot_SpringCloud_Spring_bilibili]

#### 5.1 基本概念 ####

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

其中：Aspect（切面）、Oriented（面向）、Programming（编程）

**底层原理**：java代理设计模式（动态代理）

**好处**：在保证原始业务逻辑不变的情况下，通过代理对象完成业务中的附加操作（如事务等），将业务中核心操作放在目标对象中执行，实现了附加操作和核心操作解耦。

**基本概念**：

*  **通知（Advice）**：除了目标方法之外的操作都可以称之为通知，可理解为附加操作、额外功能，比如：事务通知、日志通知、性能通知......
 *  **切入点（Pointcut）**：将开发好的通知应用于项目中的哪些组件中的哪些方法，给方法加入通知，一般通知多用于业务层，例如：UserService
 *  **切面（Aspect）**=通知（Advice）+切入点（Pointcut）

![watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAQ29kZXJfQ3Vp_size_20_color_FFFFFF_t_70_g_se_x_16][]

**AOP面向切面编程实现可分为如下几步：**

1.  开发通知类（附加功能）---新建通知
2.  配置切面点---指定通知位置
3.  利用通知和切入点组装切面，对通知和切入点进行绑定

#### 5.2 编程步骤 ####

**配套视频：**[【编程不良人】快速入门Spring,SpringBoot、SpringCloud学不好完全是因为Spring没有掌握!\_哔哩哔哩\_bilibili][Spring_SpringBoot_SpringCloud_Spring_bilibili]

# 1.引入AOP编程相关依赖
           spring-aop
           spring-expression
           spring-aspects
      
      # 2.开发通知类
           MethodBeforeAdvice      前置通知
           MethodInterceptor       环绕通知
           AfterReturningAdvice    后置通知 / 返回后通知
           ThrowsAdvice            异常通知
            
           MyAdvice implements  通知接口{.....}
            
          //自定义通知类:用来完成额外功能
          //自定义记录业务方法名称前置通知，前置通知即目标方法执行之前先执行的额外操作
          public class MyAdvice  implements MethodBeforeAdvice {
              @Override
              //参数1:当前调用的方法对象    
              //参数2:当前调用方法对象的参数  
              //参数3:目标对象
              public void before(Method method, Object[] args, Object target) throws Throwable {
                  System.out.println("目标方法名: "+method.getName());
                  System.out.println("目标方法的参数: "+args[0]);
                  System.out.println("目标对象: "+target.getClass());
              }
          }
      # 3.配置切面
           a.引入aop命名空间
             <?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">
           b.注册通知类
               
               <bean id="myAdvice" class="before.MyAdvice"/>
           c.配置/组装切面 aspect = advice + pointcut
              
              <aop:config>
                  
                  <aop:pointcut id="pc" expression="execution(* aop.UserServiceImpl.*(..))"/>
                  
                  <aop:advisor advice-ref="myAdvice" pointcut-ref="pc"/>
              </aop:config>
      
      # 4.启动工厂测试
              ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("aop/spring.xml");
              UserService userSerivce = (UserService) context.getBean("userService");
              System.out.println(userSerivce.getClass());
              //代理对象
              userSerivce.save("小黑");

####  ####

#### 5.3 前置通知使用 ####

**EmpService.java**

package aop;
      
      /**
       * @ClassName EmpService
       * @Description 接口
       * @Author Jiangnan Cui
       * @Date 2022/4/4 18:36
       * @Version 1.0
       */
      public interface EmpService {
          void save(String name);
          String find(String name);
      }

**EmpServiceImpl.java**

package aop;
      
      /**
       * @ClassName EmpServiceImpl
       * @Description EmpService实现类 原始业务对象 / 目标对象
       * @Author Jiangnan Cui
       * @Date 2022/4/4 18:37
       * @Version 1.0
       */
      public class EmpServiceImpl implements EmpService{
          @Override
          public void save(String name) {
              System.out.println("处理业务逻辑saveDao！" + name);
          }
      
          @Override
          public String find(String name) {
              System.out.println("处理业务逻辑findDAO！" + name);
              return name;
          }
      }

**MyBeforeAdvice.java自定义前置通知**

package aop;
      
      import org.springframework.aop.MethodBeforeAdvice;
      
      import java.lang.reflect.Method;
      
      /**
       * @ClassName MyBeforeAdvice
       * @Description 自定义记录业务方法名称的前置通知
       * @Author Jiangnan Cui
       * @Date 2022/4/4 18:46
       * @Version 1.0
       */
      public class MyBeforeAdvice implements MethodBeforeAdvice {
          @Override
          //参数1：method表示当前执行方法的对象
          //参数2：objects表示当前执行方法的参数
          //参数3：o表示目标对象
          public void before(Method method, Object[] objects, Object o) throws Throwable {
              System.out.println("当前执行方法的名称：" + method.getName());
          }
      }

**spring.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">
          
          <bean class="aop.EmpServiceImpl" id="empService"></bean>
      
          
          <bean class="aop.MyBeforeAdvice" id="myBeforeAdvice"></bean>
      
          
          <aop:config>
              
              <aop:pointcut id="pc" expression="execution(* aop.*ServiceImpl.*(..))"/>
              
              <aop:advisor advice-ref="myBeforeAdvice" pointcut-ref="pc"/>
          </aop:config>
      </beans>

**TestSpring.java**

package aop;
      
      import org.springframework.context.ApplicationContext;
      import org.springframework.context.support.ClassPathXmlApplicationContext;
      
      /**
       * @ClassName TestSpring
       * @Description 测试
       * @Author Jiangnan Cui
       * @Date 2022/4/4 20:49
       * @Version 1.0
       */
      public class TestSpring {
          public static void main(String[] args) {
              ApplicationContext context = new ClassPathXmlApplicationContext("aop/spring.xml");
              EmpService empService = (EmpService)context.getBean("empService");
              System.out.println(empService.getClass());
              //此时的EmpService不再是单纯的类，而是动态代理类
              empService.save("小崔");
          }
      }

**输出结果：**

class com.sun.proxy.$Proxy2
      当前执行方法的名称：save
      处理业务逻辑saveDao！小崔

####  ####

#### 5.4 环绕通知的使用 ####

**配套视频：**[https://www.bilibili.com/video/BV12k4y167jK?p=11][https_www.bilibili.com_video_BV12k4y167jK_p_11]

**DeptDAO.java**

package dao;
      
      /**
       * @ClassName DeptDAO
       * @Description TODO
       * @Author Jiangnan Cui
       * @Date 2022/4/5 20:58
       * @Version 1.0
       */
      public interface DeptDAO {
          void save(String name);
          void update(String name);
          void delete(Integer id);
          String find(String name);
      }

**DeptDAOImpl.java**

package dao;
      
      /**
       * @ClassName DeptDAOImpl
       * @Description TODO
       * @Author Jiangnan Cui
       * @Date 2022/4/5 20:59
       * @Version 1.0
       */
      public class DeptDAOImpl implements DeptDAO{
          @Override
          public void save(String name) {
              System.out.println("save DAO :" + name);
          }
      
          @Override
          public void update(String name) {
              System.out.println("update DAO :" + name);
          }
      
          @Override
          public void delete(Integer id) {
              System.out.println("delete DAO :" + id);
          }
      
          @Override
          public String find(String name) {
              System.out.println("find DAO :" + name);
              return name;
          }
      }

**DeptService.java**

package service;
      
      /**
       * @ClassName DeptService
       * @Description TODO
       * @Author Jiangnan Cui
       * @Date 2022/4/5 21:02
       * @Version 1.0
       */
      public interface DeptService {
          void save(String name);
          void update(String name);
          void delete(Integer id);
          String find(String name);
      }

**DeptServiceImpl.java**

package service;
      
      import dao.DeptDAO;
      
      /**
       * @ClassName DeptServiceImpl
       * @Description 业务层组件
       * @Author Jiangnan Cui
       * @Date 2022/4/5 21:03
       * @Version 1.0
       */
      public class DeptServiceImpl implements DeptService{
          //业务层需要DAO组件
          private DeptDAO deptDAO;
          public void setDeptDAO(DeptDAO deptDAO) {
              this.deptDAO = deptDAO;
          }
      
          @Override
          public void save(String name) {
              System.out.println("处理save业务逻辑！");
              deptDAO.save(name);
          }
      
          @Override
          public void update(String name) {
              System.out.println("处理update业务逻辑！");
              deptDAO.update(name);
          }
      
          @Override
          public void delete(Integer id) {
              System.out.println("处理delete业务逻辑！");
              deptDAO.delete(id);
          }
      
          @Override
          public String find(String name) {
              System.out.println("处理find业务逻辑！");
              deptDAO.find(name);
              try {
                  Thread.sleep(1000);
              } catch (InterruptedException e) {
                  e.printStackTrace();
              }
              //throw new RuntimeException("执行出错啦！");
              return null;
          }
      }

**MethodInvokeTimeAdvice.java自定义环绕通知用来记录目标方法的执行时长**

package advices;
      
      import org.aopalliance.intercept.MethodInterceptor;
      import org.aopalliance.intercept.MethodInvocation;
      
      import java.util.Date;
      
      /**
       * @ClassName MethodInvokeTimeAdvice
       * @Description 自定义环绕通知用来记录目标方法的执行时长
       * @Author Jiangnan Cui
       * @Date 2022/4/5 21:17
       * @Version 1.0
       */
      public class MethodInvokeTimeAdvice implements MethodInterceptor {
          @Override
          //参数：methodInvocation将invoke之前的参数封装到一个参数里，
          //     可通过该参数获得当前执行的方法、当前执行的方法参数、目标对象
          public Object invoke(MethodInvocation methodInvocation) throws Throwable {
              System.out.println("进入环绕通知......");
              System.out.println("当前执行方法：" + methodInvocation.getMethod().getName());
              System.out.println("当前执行方法的参数：" + methodInvocation.getArguments()[0]);
              System.out.println("当前执行的目标对象：" + methodInvocation.getThis());
              try {
                  long start = new Date().getTime();
                  //放行目标方法：返回值为目标方法返回值，这个返回值一定要在通知中返回
                  Object proceed = methodInvocation.proceed();//继续处理
                  long end = new Date().getTime();
                  System.out.println(methodInvocation.getMethod().getName() + "方法执行了" + (end-start) + "ms！");
                  return proceed;
              } catch (Exception e) {
                  e.printStackTrace();
                  System.out.println("出现异常时业务处理");
              }
              return null;
          }
      }

**spring.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">
          
          <bean class="dao.DeptDAOImpl" id="deptDAO"/>
      
          
          <bean class="service.DeptServiceImpl" id="deptService">
              <property name="deptDAO" ref="deptDAO"/>
          </bean>
      
          
          <bean class="advices.MethodInvokeTimeAdvice" id="methodInvokeTimeAdvice"/>
      
          
          <aop:config>
              
              <aop:pointcut id="pc" expression="execution(* service.*ServiceImpl.*(..))"/>
              
              <aop:advisor advice-ref="methodInvokeTimeAdvice" pointcut-ref="pc"/>
          </aop:config>
      </beans>

**环绕通知测试**

package test;
      
      import org.springframework.context.ApplicationContext;
      import org.springframework.context.support.ClassPathXmlApplicationContext;
      import service.DeptService;
      
      /**
       * @ClassName TestDeptService
       * @Description 测试环绕通知
       * @Author Jiangnan Cui
       * @Date 2022/4/5 21:32
       * @Version 1.0
       */
      public class TestDeptService {
          public static void main(String[] args) {
              ApplicationContext context = new ClassPathXmlApplicationContext("spring.xml");
              DeptService deptService = (DeptService) context.getBean("deptService");
              System.out.println(deptService.getClass());
              deptService.find("小崔");
          }
      }

**输出结果：**

（1）正常执行时

class com.sun.proxy.$Proxy2
      进入环绕通知......
      当前执行方法：find
      当前执行方法的参数：小崔
      当前执行的目标对象：service.DeptServiceImpl@5ad851c9
      处理find业务逻辑！
      find DAO :小崔
      find方法执行了1000ms！

（2）执行出错时

class com.sun.proxy.$Proxy2
      进入环绕通知......
      当前执行方法：find
      当前执行方法的参数：小崔
      当前执行的目标对象：service.DeptServiceImpl@5ad851c9
      处理find业务逻辑！
      find DAO :小崔
      java.lang.RuntimeException: 执行出错啦！
          at service.DeptServiceImpl.find(DeptServiceImpl.java:47)
          at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
          at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)
          at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
          at java.lang.reflect.Method.invoke(Method.java:498)
          at org.springframework.aop.support.AopUtils.invokeJoinpointUsingReflection(AopUtils.java:333)
          at org.springframework.aop.framework.ReflectiveMethodInvocation.invokeJoinpoint(ReflectiveMethodInvocation.java:190)
          at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:157)
          at advices.MethodInvokeTimeAdvice.invoke(MethodInvokeTimeAdvice.java:27)
          at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:179)
          at org.springframework.aop.interceptor.ExposeInvocationInterceptor.invoke(ExposeInvocationInterceptor.java:92)
          at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:179)
          at org.springframework.aop.framework.JdkDynamicAopProxy.invoke(JdkDynamicAopProxy.java:213)
          at com.sun.proxy.$Proxy2.find(Unknown Source)
          at test.TestDeptService.main(TestDeptService.java:19)
      出现异常时业务处理

#### 5.5 后置通知与异常通知使用 ####

**配套视频：**[【编程不良人】快速入门Spring,SpringBoot、SpringCloud学不好完全是因为Spring没有掌握!\_哔哩哔哩\_bilibili][Spring_SpringBoot_SpringCloud_Spring_bilibili 1]

**UserService.java**

package service;
      
      /**
       * @ClassName UserService
       * @Description TODO
       * @Author Jiangnan Cui
       * @Date 2022/4/6 17:34
       * @Version 1.0
       */
      public interface UserService {
          String save(String name);
      }

**UserServiceImpl.java**

package service;
      
      /**
       * @ClassName UserServiceImpl
       * @Description TODO
       * @Author Jiangnan Cui
       * @Date 2022/4/6 17:34
       * @Version 1.0
       */
      public class UserServiceImpl implements UserService{
          @Override
          public String save(String name) {
              System.out.println("UserService save" + name);
              return name;
          }
      }

**自定义后置通知和异常通知MyAfterAndThrowsAdvice.java**

package advices;
      
      import org.springframework.aop.AfterReturningAdvice;
      import org.springframework.aop.ThrowsAdvice;
      
      import java.lang.reflect.Method;
      
      /**
       * @ClassName MyAfterAndThrowsAdvice
       * @Description 自定义后置通知和异常通知
       * @Author Jiangnan Cui
       * @Date 2022/4/6 17:36
       * @Version 1.0
       */
      public class MyAfterAndThrowsAdvice implements AfterReturningAdvice, ThrowsAdvice {
          @Override
          //后置通知
          //主体逻辑：此中的过程将在核心业务执行之后执行
          //参数1：目标方法返回值 如果方法返回值时void，返回值为null
          //参数2：当前执行方法对象
          //参数3：执行方法参数
          //参数4：目标对象
          public void afterReturning(Object returnValue, Method method, Object[] args, Object target) throws Throwable {
              System.out.println("进入后置通知...");
              System.out.println("返回值：" + returnValue);
              System.out.println("当前执行方法对象：" + method.getName());
              System.out.println("当前执行方法的参数：" + args[0]);
              System.out.println("目标对象：" + target);
          }
      
          //异常通知
          //注意：异常通知继承了后置通知，虽然实现该接口时不用实现方法，但最好实现afterThrowing方法，以免异常报错
          //主体逻辑：此中的过程将在核心业务出现异常之后执行
          //参数1：当前执行方法对象
          //参数2：执行方法参数
          //参数3：目标对象
          //参数4：目标抛出的异常
          public void afterThrowing(Method method, Object[] args, Object target, Exception ex){
              System.out.println("进入异常通知.......");
              System.out.println("方法名: " + method.getName());
              System.out.println("方法的参数: " + args[0]);
              System.out.println("目标对象: " + target);
              System.out.println("异常信息: "+ ex.getMessage());
          }
          
          //注意：两者不能同时工作
      }

**spring.xml配置文件**

**测试自定义后置通知和异常通知MyAfterAndThrowsAdviceTest.java**

package test;
      
      import org.springframework.context.ApplicationContext;
      import org.springframework.context.support.ClassPathXmlApplicationContext;
      import service.UserService;
      
      /**
       * @ClassName MyAfterAndThrowsAdviceTest
       * @Description 测试自定义后置通知和异常通知
       * @Author Jiangnan Cui
       * @Date 2022/4/6 17:47
       * @Version 1.0
       */
      public class MyAfterAndThrowsAdviceTest {
          public static void main(String[] args) {
              ApplicationContext context = new ClassPathXmlApplicationContext("after/spring.xml");
              UserService userService = (UserService) context.getBean("userService");
              System.out.println(userService.getClass());
              userService.save("小崔");
          }
      }

**测试结果：**

（1）正常执行时，后置通知起作用

class com.sun.proxy.$Proxy2
      UserService save 小崔
      进入后置通知...
      返回值：小崔
      当前执行方法对象：save
      当前执行方法的参数：小崔
      目标对象：service.UserServiceImpl@17c1bced

（2）抛出异常时，异常通知起作用

class com.sun.proxy.$Proxy2
      UserService save 小崔
      进入异常通知.......
      方法名: save
      方法的参数: 小崔
      目标对象: service.UserServiceImpl@2d9d4f9d
      异常信息: save方法执行出错啦
      Exception in thread "main" java.lang.RuntimeException: save方法执行出错啦
          at service.UserServiceImpl.save(UserServiceImpl.java:15)
          at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
          at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)
          at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
          at java.lang.reflect.Method.invoke(Method.java:498)
          at org.springframework.aop.support.AopUtils.invokeJoinpointUsingReflection(AopUtils.java:333)
          at org.springframework.aop.framework.ReflectiveMethodInvocation.invokeJoinpoint(ReflectiveMethodInvocation.java:190)
          at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:157)
          at org.springframework.aop.framework.adapter.ThrowsAdviceInterceptor.invoke(ThrowsAdviceInterceptor.java:125)
          at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:179)
          at org.springframework.aop.framework.adapter.AfterReturningAdviceInterceptor.invoke(AfterReturningAdviceInterceptor.java:52)
          at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:179)
          at org.springframework.aop.interceptor.ExposeInvocationInterceptor.invoke(ExposeInvocationInterceptor.java:92)
          at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:179)
          at org.springframework.aop.framework.JdkDynamicAopProxy.invoke(JdkDynamicAopProxy.java:213)
          at com.sun.proxy.$Proxy2.save(Unknown Source)
          at test.MyAfterReturningAdviceTest.main(MyAfterReturningAdviceTest.java:19)
      
      Process finished with exit code 1

#### 5.6 切入点表达表 ####

**配套视频：**[【编程不良人】快速入门Spring,SpringBoot、SpringCloud学不好完全是因为Spring没有掌握!\_哔哩哔哩\_bilibili][Spring_SpringBoot_SpringCloud_Spring_bilibili 2]

**spring (pointcut)切入点表达式：主要是用来决定项目中那些组件中那些方法需要加入通知**

1.execution方法级别

execution 切入点表达式   --->方法级别的切入点表达式  控制粒度: 方法级别   效率低
      格式：expression="切入点表达式"
      完整语法:
             1.execution(访问权限修饰符 返回值 包名.类名.方法名(参数类型))
             2.execution(返回值 包名.类名.方法名(参数类型))，默认public访问，因此可以省略访问修饰符
                        * 任意多个字符
                        ..作用于参数类型：表示任意多个
                          作用于类：表示当前包及子包
              1).execution(* com.baizhi.service.*.*(..))              [比较多一种]
                  包:       com.baizhi.service
                  类:       任意类
                  方法:     任意方法
                  参数:     参数任意
                  返回值:   任意返回值类型
              2).execution(String com.baizhi.service.*ServiceImpl.*(..))
                  包:       com.baizhi.service
                  类:       以ServiceImpl结尾的类
                  方法:     方法名任意
                  参数:     任意参数
                  返回值:   返回值必须String类型相关方法
              3).execution(String com.baizhi.service.*Service*.*(String))
                  包:      com.baizhi.service
                  类:      类名中包含Service关键字的类
                  方法:    任意
                  参数:    参数只有一个类型必须是String
                  返回值:  返回值必须是String
              4).execution(* com.baizhi.service..*.*(..))             [比较多一种]
                  包:     com.baizhi.service及这个包中子包的子包
                  类:     任意类
                  方法:   任意方法
                  参数:   任意参数
                  返回值:  任意类型
              5).execution(* com.baizhi.service.*ServiceImpl.*(..)) [比较多一种]
                  包:     com.baizhi.service 包
                  类:     以ServiceImpl结尾的类
                  方法:   任意方法
                  参数:   任意参数
                  返回值:  任意类型
              6).execution(* *.*(..))   //全部方法 避免使用这种方式
                  包:     项目中所有包
                  类:     项目中所有类
                  方法:   所有方法
                  参数:   所有参数
                  返回值: 任意类型
                  *注意*: 方法级别的切入点表达式尽可能精准,避免不必要的切入,否则程序运行可能出现异常

2.within类级别

within    切入点表达式   --->类级别的切入点表达式    控制粒度: 类级别    效率高  推荐
      格式：expression="within()"
      完整语法:
              1. within(包.类名)
              1).within(com.baizhi.service.*ServiceImpl)
                   包：com.baizhi.service
                   类：以ServiceImpl结尾的类
              2）within(com.baizhi.service.*) 
                   包: com.baizhi.service
                   类: 所有类中所有方法不关心返回值和参数
              3）within(com.baizhi.service.UserServiceImpl)
                   包: com.baizhi.service
                   类: UserServiceImpl类中所有方法不关心返回值和参数

--------------------

> **注意：within的效率高于execution表达式，推荐使用within表达式，切入到方法级别时在使用execution表达式**

#### 5.7 IOC和AOP总结 ####

**配套视频：**[【编程不良人】快速入门Spring,SpringBoot、SpringCloud学不好完全是因为Spring没有掌握!\_哔哩哔哩\_bilibili][Spring_SpringBoot_SpringCloud_Spring_bilibili 3]

spring 框架核心
      1).IOC and DI
          Inversion of Controll 控制反转
          Dependency Injection 依赖注入
      定义: 就是将手动通过new关键字创建对象的权力交给spring,交给工厂由工厂创建对象,
           spring不仅要创建对象还要在创建对象的同时维护组件与组件的依赖关系
      
      2).AOP
          Aspects(切面)
          Oriented(面向)
          Programming(编程)
      底层原理: java中动态代理对象的封装
      定义: 通过在程序运行的过程中动态的为项目中某些组件生成动态代理对象,
           通过在生成的动态代理对象中执行相应的附加操作|额外功能,减少
           项目中通用代码的冗余问题
      通知(advice): 除了核心业务方法以外的附加操作都称之为通知 额外功能  事务通知....性能 日志 ...
      切入点(pointcut): 用来指定项目中那些组件中那些方法需要加入 通知(附加操作,额外功能) 常用于业务层组件
      切面(aspect) = 通知 + 切入点
      注意：切面、aop:pointcut、aop:advisor都可以有多个，可以配置不同的切入点表达式
          myadvice1  性能通知
          myadvice2  日志通知
          1).工厂管理通知
             myadvice1
             myadvice2
          2).配置切面
             <aop:config>
                   <aop:pointcut id="pc" expression="execution()|within()"/>
                   <aop:pointcut id="pc1" expression="execution()|within()"/>         
                   .......
                   <aop:advisor advice-ref="myadvice1" pointcut-ref="pc"/>
                   <aop:advisor advice-ref="myadvice2" pointcut-ref="pc"/>
                   ........
             <aop:config>

[Spring_SpringBoot_SpringCloud_Spring_bilibili]: https://www.bilibili.com/video/BV12k4y167jK?p=10
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAQ29kZXJfQ3Vp_size_20_color_FFFFFF_t_70_g_se_x_16]: https://img-blog.csdnimg.cn/4c41f20396124fed909e0d759270a4d6.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBAQ29kZXJfQ3Vp,size_20,color_FFFFFF,t_70,g_se,x_16
[https_www.bilibili.com_video_BV12k4y167jK_p_11]: https://www.bilibili.com/video/BV12k4y167jK?p=11
[Spring_SpringBoot_SpringCloud_Spring_bilibili 1]: https://www.bilibili.com/video/BV12k4y167jK?p=13
[Spring_SpringBoot_SpringCloud_Spring_bilibili 2]: https://www.bilibili.com/video/BV12k4y167jK?p=12
[Spring_SpringBoot_SpringCloud_Spring_bilibili 3]: https://www.bilibili.com/video/BV12k4y167jK?p=14