Spring的两大核心是IoC(控制反转) 和AOP(面向切面编程)。 IoC: 控制反转是指将对象之间的依赖关系由开发人员控制转移到Spring容器来管理，它将实现对象之间的耦合度降低，使得程序更加灵活，容易维护。 AOP: 面向切面编程是指将业务逻辑的公共部分抽取出来，封装成一个模块，然后在业务逻辑运行之前或之后调用该模块，使得业务逻辑更加清晰，容易维护。

什么是aop

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

AOP是在运行期间执行的一种技术，底层是通过动态代理实现的

动态代理: 指的是不修改源码的情况下，对目标方法进行相应的增强，作用是完成程序功能间的松耦合

AOP的作用及其优势

作用: 在程序运行期间，在不修改源码的情况下对方法进行功能增强 优势: 减少重复代码，提高开发效率，并且便于维护

目标方法+增强 = AOP(切面)

AOP的底层实现

实际上，AOP的底层是通过Spring提高的动态代理技术实现的。在运行期间，Spring通过动态代理技术，动态的生成代理对象，代理对象方法执行时进行增强功 能的介入，再去调用目标对象的方法，从而完成功能的增强

AOP的底层实现

常用的动态代理技术:

1、JDK代理: 基于接口的动态代理技术 缺点: 目标对象必须要有接口，因为是基于接口动态生成的，当这个对象没有接口时，就无法完成动态代理

2、cglib代理: 基于父类的动态代理技术 特点:第三方的动态代理工具，实现动态代理的原理是基于父类

基于jdk的动态代理

具体操作:

第一步: 在src/main/java目录下新建com.huanf.proxy.jdk目录

第二步: 右键com.huanf.proxy.jdk，新建Advice类，里面写入如下

//增强类
public class Advice {
 //前置增强
 public void before(){
     System.out.println("前置增强...");
 }
 //后置增强
 public void afterReturning(){
     System.out.println("后置增强...");
 }
}

第三步: 右键com.huanf.proxy.jdk，新建Target类，里面写入如下

//目标类，该类的save方法会被Advice类增强
public class Target implements TargetInterface{
 @Override
 public void save() {
     System.out.println("save方法正在启动...");
 }
}

第四步: 右键com.huanf.proxy.jdk，新建TargetInterface接口，里面写入如下

public interface TargetInterface {
 public void save();
}

第五步: 右键com.huanf.proxy.jdk，新建ProxyText类，里面写入如下

//测试类
public class ProxyTest {
 public static void main(String[] args) {
     //创建目标对象
     final Target target = new Target();
     //获得Advice增强类的对象
     Advice advice = new Advice();
     //返回值 是动态生成的代理对象
     TargetInterface proxy = (TargetInterface) Proxy.newProxyInstance(
             target.getClass().getClassLoader(),//第一个参数:目标对象的类加载器
             target.getClass().getInterfaces(),//第二个参数:与目标对象相同的接口字节码对象数组，由于目标对象可能不止一个接口所以用数组
             new InvocationHandler() {
                 @Override
                 //当我们在调用代理对象的任何方法时，实际执行的就是下面那行的invoke方法,这个invoke是终端代理的invoke
                 public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                     advice.before();//前置增强
                     Object invoke = method.invoke(target, args);//执行目标方法，这个invoke是我们写的反射的invoke
                     advice.afterReturning();//后置增强
                     return invoke;
                 }
             }//第三个参数:接口
     );
     //调用代理对象的方法,我们目前只写了save方法
     proxy.save();
 }
}

基于cglib的动态代理

第一步: 右键java，新建com.huanf.proxy.cglib目录

第二步: 在pom.xml里面添加如下

<dependencies>
 <dependency>
   <groupId>org.springframework</groupId>
   <artifactId>spring-context</artifactId>
   <version>5.0.5.RELEASE</version>
 </dependency>
 <dependency>
   <groupId>junit</groupId>
   <artifactId>junit</artifactId>
   <version>4.11</version>
 </dependency>
 <dependency>
   <groupId>org.springframework</groupId>
   <artifactId>spring-core</artifactId>
   <version>5.0.5.RELEASE</version>
</dependency>

第三步: 右键cglib目录，新建Advice类，里面写入如下

//增强类
public class Advice {
 //前置增强
 public void before(){
     System.out.println("前置增强-cglib...");
 }
 //后置增强
 public void afterReturning(){
     System.out.println("后置增强-cglib...");
 }
}

第四步: 右键cglib目录，新建Target类，里面写入如下

//目标类，该类的save方法会被Advice类增强
public class Target{
 public void save() {
     System.out.println("save方法正在启动-cglib...");
 }
}

第五步: 右键cglib目录，新建ProxyText类，里面写入如下

//测试类
public class ProxyTest {
 public static void main(String[] args) {
     //创建目标对象
     final Target target = new Target();
     //获得Advice增强类的对象
     Advice advice = new Advice();
     //cglib，基于父类的动态生成代理技术，如下
     //第1步:创建增强器
     Enhancer enhancer = new Enhancer();
     //第2步:设置父类，也就是目标
     enhancer.setSuperclass(Target.class);
     //第3步:设置回调
     enhancer.setCallback(new MethodInterceptor() {
         @Override
         public Object intercept(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
             advice.before();//前置增强
             Object invoke = method.invoke(target, args);//执行目标方法
             advice.afterReturning();//后置增强
             return invoke;
         }
     });
     //第4步:创建代理对象
     Target proxy = (Target) enhancer.create();
     //第5步:测试
     proxy.save();
 }
}

aop相关概念

Spring的AOP实现底层就是对上面学过的动态代理的代码进行了封装，封装后我们就不需要写一大堆代码了，只需要对需要关注的部分进行代码编写，并通过配 置的方式完成指定目标的方法增强

在正式讲解AOP的操作之前，我们必须理解AOP的相关术语，常用的术语如下:

1、Target: 目标对象，指的是代理的目标对象

2、Proxy: 代理，指的是一个类被AOP织入增强后，就产生一个结果代理类

3、Joinpoint: 连接点，指的是可以被增强的方法

4、Pointcut: 切入点简称切点，指的是实际被增强了的方法，也叫目标方法

5、Advice: 官方叫法是通知，我们一般习惯叫增强，指的是具体的增强代码，这个代码往往是封装到一个方法中的，这个方法就叫增强方法

6、Aspect: 切面，指的是切点+增强

7、Weaving: 织入，这个是动词，指的是'切点+增强'结合的过程

aop动态代理

aop开发明确的事项，也就是开发前准备

一、需要编写的内容

1、核心业务代码，即目标类的目标方法，就是你要增强的方法

2、编写切面类，原因是切面类中有通知，所以要编写切面类

3、在配置文件中，配置织入关系，即将哪些通知与哪些连接点进行结合

二、AOP技术实现的内容

增强(也叫通知)类别: 分为前置增强(前置通知)、后置增强(后置通知)、其它增强(其它通知)

1、Spring框架监控切入点方法的执行。一旦监控到切入点方法被执行，spring就使用代理机制，动态地创建'切点方法所在的目标对象'的代理对象，然后根据增强类别，在代理对象的对应位置，将增强对应的功能织入，完成完整的代码逻辑运行

三、AOP底层使用哪种代理方式

3、AOP底层共使用两种代理方式，分别为jdk代理、cglib代理。那AOP到底使用哪种代理方式呢。在spring中，框架会根据目标类是否实现了接口来决定采用哪种动态代理的方式。也就是你有接口的话，就自动帮你选择jdk代理，没有接口的话就自动使用cglib代理