【Java知识体系】SpringIOC与AOP原理深入浅出，图解源码，入股不亏

已于 2022-04-03 09:53:56 修改
阅读量666 收藏 3
点赞数 3
分类专栏： 村长的Java知识体系 文章标签： java spring IOC AOP java后端
于 2022-03-06 15:41:28 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/apple_51976307/article/details/123311180
版权

大家好！我是未来村村长，就是那个“请你跟我这样做，我就跟你这样做！”的村长👨‍🌾！

||To Up||

​ 未来村村长正推出一系列【To Up】文章，该系列文章重要是对Java开发知识体系的梳理，关注底层原理和知识重点。”天下苦八股文久矣？吾甚哀，若学而作苦，此门无缘，望去之。“该系列与八股文不同，重点在于对知识体系的构建和原理的探究。

文章目录

一、概念性准备

1、Spring相关概念

（1）Spring

​ 定义：Spring是一个轻量级的控制反转(IoC)和面向切面(AOP)的容器框架。

​ 目标：Spring为开发者提供一站式的轻量级应用开发平台（框架），抽象了应用开发中的共性问题。

（2）依赖、依赖注入、控制反转

  • 依赖：A类中实例化了B类的对象，调用了其方法或属性，我们称A依赖B（类A示例化了B的对象）

  • 依赖注入（DI）：会将所依赖的关系自动交给目标对象，而不是让对象自己去获取依赖。依赖注入（DI）是控制反转（IoC）的一种方式。（类A不用实例化B的对象，交给第三方对象完成）

  • 控制反转（IoC）：IoC容器控制对象的创建和外部资源的获取，容器帮助我们查找以及注入对象，即解耦

  • AOP：Aspect Oriented Programming的缩写，意为：面向切面编程。通过预编译方 式和运行期动态代理实现程序功能的统一维护的一种技术。

（3）POJO、Bean、javaBean
  • Bean：在 Spring 中，构成应用程序主干并由SpringIOC容器管理的对象称为bean。bean是一个由Spring IoC容器实例化、组装和管理的对象。
  • POJO:（Plain Old Java Object）从字面上理解“简单老式的java对象”或者“普通java类”。POJO是一个简单的、普通java对象，特点是有private的属性和public的getter、setter，除此之外不具有任何特殊角色，不继承或不实现任何其它Java框架的类或接口。
  • JavaBean是一种JAVA语言写成的可重用组件。JavaBean符合一定规范编写的Java类，不是一种技术，而是一种规范。特点如下：
    • 1.所有属性为private。
      2.这个类必须具有一个公共的(public)无参构造函数。
      3.private属性必须提供public的getter和setter来给外部访问，并且方法的命名也必须遵循一定的命名规范。
      4.这个类应是可序列化的，要实现serializable接口。

二、IoC

1、IoC探究开始：简单的IoC应用实现

​ 要想有顺序地，自上而下地探究源码，就得从一个实现了IOC的应用程序出发。由于java面向对象的特性，我们可以从程序中的代码逐步探究到SpringIOC模块实现的最底层源码，所以我们先来看看一个基础的IOC应用如何实现。

（1）导入依赖

​ 这里我们导入520版本的spring-mvc，这个依赖包含了很多要用到的jar。

    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>5.2.0.RELEASE</version>
        </dependency>
    </dependencies>
（2）编写一个类

​ 这个类要遵循Spring的规范，才能被IOC容器控制反转：为接受设值注入的属性提供setter方法，sertter方法的命名为set+属性名。

public class HelloSpring {
    private String property;
    public String getProperty() {
        return property;
    }
    public void setProperty(String property) {
        this.property = property;
    }
    @Override
    public String toString() {
        return "HelloSpring{" +
                "property='" + property + '\'' +
                '}';
    }
}
（3）beans.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
        https://www.springframework.org/schema/beans/spring-beans.xsd">
    
    <bean id="hello" class="com.plord.pojo.HelloSpring">
        <property name="property" value="Hello,Spring!"/>
    </bean>
    
</beans>
（4）Bean的获取

​ IOC容器是对Bean的控制管理，我们现在调用IOC容器将Bean取出。

public class SpringController {
    public static void main(String[] args) {
        
        ApplicationContext context = new ClassPathXmlApplicationContext("baens.xml");

        HelloSpring hello = (HelloSpring) context.getBean("hello");
        System.out.println(hello.toString());
    }
}

2、IoC容器的设计

在这里插入图片描述

​ 在Spring容器的设计中，有两个主要的容器设计系列，一个是实现BeanFactory接口的简单容器系列，另外一个是ApplicationContext应用上下文系列，它作为容器的高级形态而存在。我们将设计路线的

  • 第一条线路：

    • BeanFactory接口定义了基本的IoC容器的规范，定义了getBean()、getType()、isSingleton()、isPrototype()等基本方法。
    • HierarchicalBeanFactory接口增加了getParentBeanFactory()接口功能，使BeanFactory具备了双亲IOC管理功能。
    • ConfigurableBeanFactory接口定义了对BeanFactory的配置功能，配置了Bean后置处理器，实现了简单Ioc的基本功能，实现对工厂的配置以及对bean属性的自动装配。
    • DefaultListableBEanfactory实现类是其它许多BeanFactory的扩展基础。

  • 第二条线路：

    • ApplicationContext接口除了继承HierarchicalBeanFactory、ListableBeanFactory以外，还继承了MessageSource、ResourceLoader、ApplicationEventPublisher接口，即在BeanFactory简单Ioc容器基础上添加了许多高级容器特性。
    • ConfigurableApplicationContext接口结合了所有ApplicationContext需要实现的接口。因此大多数的ApplicationContext都要实现此接口。它在ApplicationContext的基础上增加了一系列配置应用上下文的功能。
    • AbstractApplicationContext实现类是Spring应用上下文中最重要的一个类，这个抽象类中提供了几乎ApplicationContext的所有操作。主要有容器工厂的处理，事件的发送广播，监听器添加，容器初始化操作refresh()方法，然后就是bean的生成获取方法接口等。是其它许多ApplicationContext应用上下文的扩展基础。
      • ClassPathXmlApplication实现类：它是从类的根路径下加载xml配置文件（推荐用这种）。
      • FileSystemXmlApplication实现类: 它是从磁盘路径上加载配置文件，配置文件可以在磁盘的任意位置。（但使用不灵活，不推荐）
      • AnnotationConfigApplication实现类：当我们使用注解配置容器对象时，需要使用此类来创建spring容器。它用来读取注解。（springboot默认使用这个）

两者装载Bean的区别：

  • BeanFactory：BeanFactory在启动的时候不会去实例化Bean，中有从容器中拿Bean的时候才会去实例化；

  • ApplicationContext：ApplicationContext在启动的时候就把所有的Bean全部实例化了。它还可以为Bean配置lazy-init=true来让Bean延迟实例化；

3、Bean与BeanDifinition

（1）Bean与BeanDifinition定义和关系

​ BeanDefinition与Bean的关系, 就好比类与对象的关系。根据BeanDefinition得到的对象就是我们需要的Bean。还记得上面我们的程序，是如何getBean的吗？

ApplicationContext context = new ClassPathXmlApplicationContext("baens.xml");
HelloSpring hello = (HelloSpring) context.getBean("hello");

​ 简简单单两句话，我们获得了Bean。可以看到，我们是通过解析baens.xml文件来初始化Ioc容器，通过容器的getBean方法获得了id为hello的Bean，此处的id就是bean的标识符。我们可以知道bean在xml文件中的形式为

<bean id="hello" class="com.plord.pojo.HelloSpring">
   <property name="property" value="Hello,Spring!"/>
</bean>

​ 在Spring中, 是根据配置（XML、注解等）, 生成用来描述Bean的BeanDefinition。 类似于Java中描述类的Class。Bean是我们需要的对象，是我们从spring内得到的结果，也就是对象实例。BeanDefinition就是配置文件与最终生成bean之间的桥梁。

​ BeanDefinition 是定义 Bean 的配置元信息接口，定义了Bean 行为配置信息，作用域、自动绑定模式、生命周期回调、延迟加载、初始方法、销毁方法等。关于Bean的建立我们将在后面继续进行讲解，在讲解前我们先来看看BeanDifinition。

（2）BeanDifinition的设计

在这里插入图片描述

  • BeanDefinition接口顶级基础接口,用来描述Bean,里面存放Bean元数据，比如Bean类名、scope、属性、构造函数参数列表、依赖的bean、是否是单例类、是否是懒加载等一些列信息。
  • AnnotatedBeanDefinition接口：表示注解类型BeanDefinition。有两个重要的属性，AnnotationMetadata，MethodMetadata分别表示BeanDefinition的注解元信息和方法元信息实现了此接口的BeanDefinition可以获取到注解元数据和方法元数据。
  • AbstractBeanDefinition类：抽象类统一实现了BeanDefinition定义的一部分操作，可以说是定义了BeanDefinition很多默认的属性。 正是在AbstractBeanDefinition基础上， Spring衍生出了一些列BeaDefinition。
    • RootBeanDefinition:代表一个xml,java Config来的BeanDefinition
    • ChildBeanDefinition:可以让子BeanDefinition定义拥有从父母哪里继承配置的能力。
    • GenericBeanDefinition:spring2.5后注册bean首选的是GenericBeanDefinition。GenericBeanDefinition允许动态的设置父bean.GenericBeanDefinition可以作为RootBeanDefinition与ChildBeanDefinition的替代品。
      • AnnotatedGenericBeanDefinition类:表示@Configuration注解注释的BeanDefinition
      • ScannedGenericBeanDefinition类:表示@Component、@Service、@Controller等注解注释的Bean类
（3） spring解析xml生成BeanDefinition的过程

​ 参考：https://www.iteye.com/blog/liudeh-009-1966616

在这里插入图片描述

spring解析xml生成BeanDefinition对象的过程主要涉及到以下几个类,它们职责分别是:

  1. XmlBeanDefinitionReader根据xml的文件路径生成InputStream对象,进而得到InputStream的xml的包装类InputSource对象。

  2. DocumentLoader解析InputSource得到Document对象。

  3. DefaultBeanDefinitionDocumentReader类委托BeanDefinitionParserDelegate类解析Document对象生成BeanDefinition对象,BeanDefinition对象中包含xml中配置的bean的元信息。

  4. 生成的BeanDefinition对象最终都会注册到DefaultListableBeanFactory,供后续生成bean对象使用。

（4）Bean的生命周期

​ 首先我们要清楚Bean的四个生命周期，我们将在后续展开对四个生命周期进行扩展探究Bean的一生。

  • 实例化 Instantiation

  • 属性赋值 Populate

  • 初始化 Initialization

  • 销毁 Destruction

4、IoC容器初始化

（1）IoC容器的初始化步骤
  • Resource定位：指BeanDefinition的资源定位，由ResourceLoader通过统一的Resource接口来完成。
  • BeanDefinition载入：把用户定义好的Bean表示成Ioc容器内部的数据结构，即BeanDefinition。
  • Beandifinition注册：通过调用BeanDefinitionRegistry接口的实现，把载入过程中解析得到的BeanDefinition向IoC容器进行注册。实际上是在IoC容器内部将BeanDefinition注入到一个HashMap中去，IoC容器通过HashMap来持有和管理BeanDefinition。
（2）Resource定位

参考：https://blog.csdn.net/sinat_34596644/article/details/80394209

在这里插入图片描述

  • AbstractApplicationContext：
    • refresh()：在ClassPathXmlApplicationContext的构造器中会调用到AbstractApplicationContext的refresh方法。在初始化ClassPathXmlApplicationContext这个IoC容器时，会通过refresh方法来启动整个调用。
    • obtainFreshBeanFactory()：在调用AbstractApplicationContext的refresh方法时，该方法中会通过调用refreshBeanFactory和getBeanFactory方法，重新获取一个新的BeanFactory实例，代表IoC容器初始化过程的启动。
  • AbstractRefreshableApplicationContext：
  • refreshBeanFactory()：销毁原BeanFactory，新建DefaultListableBeanFactory实例，并对其进行一些初始化工作。
  • AbstractXmlApplicationContext：
    • loadBeanDefinitions()：上一步创建BeanFactory实例之后，通过该BeanFactory创建XmlBeanDefinitionReader实例，也就是ApplicationContext上下文将BeanDefinition的定位加载工作交付到了XmlBeanDefinitionReader。
      • 该方法会调用其同名方法loadBeanDefinitions(XmlBeanDefinitionReader reader)，这一步完成了将部分XML文件资源封装为Resource对象，而用户以XML文件路径传入的BeanDefinition资源文件也会在AbstractBeanDefinitionReader的loadBeanDefinitions(String…locations)方法逐一封装为Resource对象，并进行进一步的处理。
（3）BeanDefinition载入

在这里插入图片描述

  • XmlBeanDefinitionReader：

    • loadBeanDefinitions()：这一步主要是通过Resource对象获取XML文件的输入流，继续执行doLoadBeanDefinitions。因为是XML文件格式组织的BeanDefinition，因此AbstractBeanDefinitionReader需要委托到其子类XmlBeanDefinitionReader。
    • doLoadBeanDefinitions()：通过上一步获取到的输入流和Resource对象，获取Document对象。
    • registerBeanDefinitions()：初始化DefaultBeanDefinitionDocumentReader对象，将上一步得到的Document对象交由DefaultBeanDefinitionDocumentReader对象解析，并统计解析的BeanDefinition个数。

  • DefaultBeanDefinitionDocumentReader：

    • registerBeanDefinitions()：获取Document对象的根元素，执行doRegisterBeanDefinitions。
    • parseBeanDefinitions()：初始化BeanDefinitionParserDelegate实例，递归解析Document。DefaultBeanDefinitionDocumentReader负责读入Document对象，实际将Document解析为BeanDefinition的却是BeanDefinitionParserDelegate对象。
    • processBeanDefinition()：传入Document对象的单个Element元素，将其交由上一步的BeanDefinitionParserDelegate对象解析，解析后得到BeanDefinitionHolder对象。解析过程较为复杂，有兴趣可以自行跟踪。
（4）Beandifinition的注册

在这里插入图片描述

  • BeanDefinitionReaderUtils：
    • registerBeanDefinition()：传入上一步的BeanDefinitionHolder对象，将BeanDefinition注册到IoC容器中。完成的是向IoC容器注册这些BeanDefinition，BeanFactory是以HashMap的结构组织这些BeanDefinition的。可以在DefaultListableBeanFactory中看到此HashMap的定义。
（5）流程图简化版

在这里插入图片描述

5、依赖注入

​ IoC容器初始化过程完成的主要工作是建立BeanDefinition数据映射，在此过程中，并没有对Bean依赖关系进行注入。依赖注入的过程，主要以AbstractBeanFactory的getBean()方法作为依赖注入的起点，最后以BeanWeapper对象的setPropertyValue()来具体实现依赖注入的发生。由于涉及的方法较多，我根据方法调用的三条线路展开依赖注入的过程讲解。

在这里插入图片描述

  • 1：
    • getBean()：依赖注入的入口，触发依赖注入的发生。getBean()中会调用doGetBean()，dogetBean()会调用creatBean()。
    • creatBean()：会进行Bean是否可以实例化或是否可以通过类装载器来载入，若判断成功，会看需要创建的Bean是否配置的PostProcessor，若没有则会调用dogetBean()方法进行Bean的创建()。
    • dogetBean()：调用createBeanInstance()对Bean进行实例化即Bean的生成（转到2）。然后会调用populateBean()通过已注册的BeanDefinition对需要创建的Bean进行属性的注入（转到3）。
  • 2：
    • createBeanInstance()：如果构造函数的参数使用了Autowire，会调用autowireConstructor进行实例化。若没使用Autowire，则会调用instantiateBean()进行对Bean进行实例化。
    • instantiateBean()：这里使用CGLIB对Bean进行实例化。
  • 3：
    • populateBean()：这里将取得在BeanDefinition中设置的property值，来源于对BeanDefinition的解析，具体是通过调用applyPropertyValues()来实现，解析后会调用setPropertyValue()最终实现依赖注入的发生。
    • applyPropertyValues()：若Property值是MutablePropertyValues类型的实例，会直接将property值设置到属性中，若不是则会创建property值的副本，进行进一步解析，具体解析过程由resolveValueIfNecessary()完成。
    • resolveValueIfNecessary()：根据property值的不同类型，进行不同类型的解析
    • setPropertyValue()：真正把Bean对象设置到它所依赖的另一个Bean的属性中去的地方，其中处理的属性是各种各样的，依赖注入的发生在Bean Wrapper的setPropertyValue()中实现，具体完成是在Bean WrapperImpl中实现。

6、ApplicationContext与Bean的生命周期

​ 对于普通的 Java 对象来说，它们的生命周期就是：实例化，或该对象不再被使用时通过垃圾回收机制进行回收。

​ 对于 Spring Bean 的生命周期来说：

  • 实例化 Instantiation：Bean实例的创建
  • 属性赋值 Populate：为Bean实例设置属性
  • 初始化 Initialization：调用Bean的初始化方法，应用可以通过IoC容器使用Bean
  • 销毁 Destruction：当容器关闭时，调用Bean的销毁方法

​ 我们之前在依赖注入过程中，已经对Bean的实例化和属性赋值做了讲解，所以我们现在简单回顾下实例化和属性赋值过程，然后说明下Bean的初始化和销毁过程。

  • 实例化：通过getBean()方法开启，主要通过AbstractAutowireCapableBeanFactory这个类的doCreateBean()调用instantiateBean()方法通过使用CGLIB对Bean进行实例化。

  • 属性赋值：主要通过AbstractAutowireCapableBeanFactory这个类的doCreateBean()调用populateBean()方法，即解析得到的BeanDefinition作为依据进行依赖关系的处理，最后通过调用BeanWrapper对象的setPropertyValue()中实现。

  • 初始化：

    • 在调用Bean初始化方法前，会调用一系列aware接口实现，把相关的BeanName、BeanClassLoader以及BeanFactory注入到Bean中去。
    • 若Bean实现了InitializingBean接口，对应的初始化处理会在该接口中的afterPropertiesSet方法中实现，这里触及到对Bean的回调。
    • 在执行这个方法前后，会执行BeanPostProcessor的前置处理方法和后置处理方法。
    • 若开发者有自定义init-method方法，则会执行用户自定义的初始化方法。

  • 销毁：首先会对postProcessBeforeDestruction进行调用，然后调用Bean的destory方法，若开发者配置了destory-method等自定义销毁方法，则会执行该方法，完成Bean的销毁过程。

三、AOP

1、AOP的理解

​ AOP英文名为Aspect Oriented Programming，意为面向切面编程，通过预编译方式和运行期间动态代理实现程序功能统一维护的一种技术。

​ 在OOP中，以类作为程序的基本单元，通过封装继承的方式达到代码的复用。尽管如此，依然需要在不同类中创建相同的对象，调用相同的属性或方法，对于复杂的系统依然使得代码比较冗余。AOP的出现便是为了解决此问题，AOP中的基本单元是Aspect(切面)。

​ 我们从下图中了解AOP的过程：切面（Aspect）中描述了切入点（Pointcut）和具体实现方法通知（Advice），其中切入点描述了需要被处理的连接点（Joinpoint），连接点指程序运行中的时间点（方法调用或异常发生等）。目标对象(target object)运行时，织入器会根据Aspect中的Pointcut的描述，找到需要执行的时间点（或连接点），在该点动态创建一个切面对象(称为代理Proxy)来代理增强对象，并执行相关方法（即Advice）。

在这里插入图片描述

​ 在Spring框架中，默认采用动态代理的方式进行织入（JDK或CGLIB），而AspectJ（基于java语言的AOP框架），采用编译期织入或类装载期织入的方式进行，Spring也可以通过XML或注解的方式整合Aspect实现AOP。

2、动态代理实现方式

​ 假定我们现在需要对数据访问层(DAO)的TestDao的所有方法进行异常处理和日志记录等操作，虽然我们可以将这些操作封装到一个类中，然后在TestDao的每个方法都创建该类的对象并调用这四个方法，但是我们现在不这么做，我们采用动态代理的方式来实现。

​ ① Dao层

public interface TestDao{
    public void save();
    public void delete();
}

public class TestDaoImpl implements TestDao{
    public void save(){
    	System.out.println("保存");
    }
    public void delete(){
    	System.out.println("删除")
    }

​ ② 切面类

public class Aspect1{
	
    public void exceptAdvice(){
      	System.out.println("异常处理");
    }
    public void logAdvice(){
      	System.out.println("日志记录");
    }
}

​ 我们来看看不同的代理类创建方式。

（1）JDK 动态代理

​ JDK动态代理是java.lang.reflect.*包提供是方式，它必须借助一个接口才能产生代理对象。对于使用业务接口的类，Spring默认使用JDK动态代理实现AOP。

​ ① 动态代理类

//必须实现java.lang.reflect.InvocationHandler
public class JDKProxy implements InvocationHandler{
	//1、声明需要代理对象的接口
    private TestDao testDao;
    
    //2、创建代理方法，建立代理关系,返回被代理的增强对象
    public Object createProxy(TestDao testDao){
        this.testDao = testDao;
     	//① 类加载器   
        ClassLoader classLoader = JDKProxy.class.getClassLoader();
        //② 被代理对象实现的所有接口
        Class[] clazz = testDao.getClass().getInterfaces();
        //③ 使用代理类进行增强，返回被增强的代理对象
        return Proxy.new.newProxyInstance(classLoader,clazz,this);
    }
	
    //3、代理实现方法，程序执行目标方法时被调用
    @Override
    public Object invoke(Object proxy,Method method,Object[] args) throws Throwable{
    	//① 创建一个切面
        Aspect1 aspect1 = new Aspect();
        //前增强
        aspect1.exceptAdvice();
        //相当于调用testDao中的方法
        Object obj = method.invoke(testDao,args);
        //后增强
        aspect1.logAdvice();
        return obj;
    
    }
}

​ ② 测试类

public class TEST1{
    public static void main(String[] args){
        //创建目标对象
        TestDao testDao = new TestDaoImpl();
        //创建代理类对象
        JDKProxy jdkproxy = new JDKproxy();
        //获取增强后的被代理对象
        TestDao testDaoAdvicer = (TextDao) jdkproxy.creatProxy(testDao);
        //执行方法
        testDaoAdvicer.save();
        testDaoAdvicer.delete();
    }
}
（2）CGLIB动态代理

​ 对于没有提供接口的类，我们采用CGLIB动态代理，这是基于父类的动态代理技术。

​ CGLIB(Code Generation Library)：高性能开源的代码生成包，运用底层字节码技术，对指定目标生成一个子类，并对子类进行增强。

① 动态代理类

//必须实现java.lang.reflect.InvocationHandler
public class CGLIBProxy implements MethodInterceptor{
    
    //1、创建代理方法，建立代理关系,返回被代理的增强对象
    public Object createProxy(Object target){
        //创建增强类对象
        Enhancer enhancer = new Enhancer();
        //确定需要增强的类
        enhancer.setSuperclass(target.getClass());
        //确定代理逻辑对象为当前对象，要求当前对象实现MethodInterceptor的方法
        enhancer.setCallback(this);
        //返回创建的代理对象
        return enhancer.creater();
    }
	
    //2、代理实现方法，程序执行目标方法时被调用
    @Override
    public Object intercept(Object proxy,Method method,Object[] args,MethodProxy methodProxy) throws Throwable{
    	//① 创建一个切面
        Aspect1 aspect1 = new Aspect();
        //前增强
        aspect1.exceptAdvice();
        //相当于调用testDao中的方法
        Object obj = methodProxy.invokeSuper(proxy,args);
        //后增强
        aspect1.logAdvice();
        return obj;
    
    }
}

​ ② 测试类

public class TEST1{
    public static void main(String[] args){
        //创建目标对象
        TestDao testDao = new TestDaoImpl();
        //创建代理类对象
        CGLIBProxy cglibproxy = new CGLIBproxy();
        //获取增强后的被代理对象
        TestDao testDaoAdvicer = (TextDao) cglibproxy.creatProxy(testDao);
        //执行方法
        testDaoAdvicer.save();
        testDaoAdvicer.delete();
    }
}

3、基于XML配置或注解开发AspectJ

（1）基于XML

① 目标对象的类(target class)

public class TestDaoImpl implements TestDao {
    public void save() {
        System.out.println("saved");
    }
    public void delete() {
        System.out.println("deleted");
    }
}

② 切面类(Aspect)

package com.plord.aspect;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;

public class Aspect1 {

    //前置通知
    public void beforeAdvice(JoinPoint joinPoint){
        System.out.println("前置通知：模拟权限控制");
        System.out.println("目标对象"+joinPoint.getTarget()+"\n被增强的方法："+joinPoint.getSignature().getName());
    }

    //后置返回通知
    public void afterReturningAdvice(JoinPoint joinPoint){
        System.out.println("后置返回通知：模拟删除文件");
        System.out.println("目标对象"+joinPoint.getTarget()+"\n被增强的方法："+joinPoint.getSignature().getName());
    }

    //环绕通知
    public Object aroundAdvice(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
        System.out.println("环绕通知");
        //执行当前目标的方法
        Object obj = proceedingJoinPoint.proceed();
        System.out.println("通知结束");
        return  obj;
    }

    //异常通知
    public void throwingAdvice(Throwable e){
        System.out.println("异常通知"+"程序执行异常"+e.getMessage());
    }

    //后置通知（最终通知）
    public void after(){
        System.out.println("最终通知：模拟释放资源");
    }

}

③ 配置文件(application.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 id="testDao1" class="com.plord.Dao.TestDaoImpl"/>
<!--注册切面-->
    <bean id="aspect1" class="com.plord.aspect.Aspect1"/>

<!--AOP配置-->
    <aop:config>
    <!--配置切面-->
        <aop:aspect ref="aspect1">
    <!--配置切入点：连接点的集合，通知增强哪些方法-->
            <aop:pointcut id="pointcut1" expression="execution(* com.plord.Dao.*.*(..))"/>
    <!--关联通知与切入点-->
            <aop:before method="beforeAdvice" pointcut-ref="pointcut1"/>
            <aop:after-returning method="afterReturningAdvice" pointcut-ref="pointcut1"/>
            <aop:around method="aroundAdvice" pointcut-ref="pointcut1"/>
            <aop:after-throwing method="throwingAdvice" pointcut-ref="pointcut1" throwing="e"/>
            <aop:after method="after" pointcut-ref="pointcut1"/>
        </aop:aspect>
    </aop:config>

</beans>

④ 测试类(TestController)

public class TestController {
    public static void main(String[] args) {
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
        TestDao testDao = (TestDao) applicationContext.getBean("testDao1");
        testDao.save();
        System.out.println("\n============\n");
        testDao.delete();
    }
}

（2）基于注解

① 切面

@Aspect
@Component
public class Aspect1 {

    @PointCut("execution(* com.plord.Dao.*.*(..))")
    private void PointCut(){
      
    }
    
    //前置通知
    @Before("PointCut()")
    public void beforeAdvice(JoinPoint joinPoint){
        System.out.println("前置通知：模拟权限控制");
        System.out.println("目标对象"+joinPoint.getTarget()+"\n被增强的方法："+joinPoint.getSignature().getName());
    }

    //后置返回通知
    @AfterReturning("PointCut()")
    public void afterReturningAdvice(JoinPoint joinPoint){
        System.out.println("后置返回通知：模拟删除文件");
        System.out.println("目标对象"+joinPoint.getTarget()+"\n被增强的方法："+joinPoint.getSignature().getName());
    }

    //环绕通知
    @Around("PointCut()")
    public Object aroundAdvice(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
        System.out.println("环绕通知");
        //执行当前目标的方法
        Object obj = proceedingJoinPoint.proceed();
        System.out.println("通知结束");
        return  obj;
    }

    //异常通知
    @AfterThrowing("PointCut()")
    public void throwingAdvice(Throwable e){
        System.out.println("异常通知"+"程序执行异常"+e.getMessage());
    }

    //后置通知（最终通知）
    @After("PointCut()")
    public void after(){
        System.out.println("最终通知：模拟释放资源");
    }

}

② 目标类

@Repository("testDao")
public class TestDaoImpl implements TestDao {
    public void save() {
        System.out.println("saved");
    }
    public void delete() {
        System.out.println("deleted");
    }
}

③ 配置文件application.xml

<context:component-scan base-package=""/>
<aop:aspectj-autoproxy/>

4、Spring AOP原理剖析与总结

​ 刚才我们已经展示了Spring所提供的三种AOP实现方法，即从JDK自带的动态代理，到Spring整合的CGLIB动态代理，再到后续集成的AspectJ技术。

​ 织入可以简单理解为aspect(切面)应用到目标函数(类)的过程。对于这个过程，一般分为动态织入和静态织入，动态织入的方式是在运行时动态将要增强的代码织入到目标类中，这样往往是通过动态代理技术完成的。

​ 动态织入：Java JDK的动态代理(Proxy，底层通过反射实现)或者CGLIB的动态代理(底层通过继承实现)，Spring AOP采用的就是基于运行时增强的代理技术。

​ 静态织入：ApectJ采用的就是静态织入的方式。ApectJ主要采用的是编译期织入，在这个期间使用AspectJ的acj编译器(类似javac)把aspect类编译成class字节码后，在java目标类编译时织入，即先编译aspect类再编译目标类。

​ Spring AOP ：遵循AOP规范，特别是以AspectJ（与java无缝整合）为参考，因此在Spring AOP的术语概念上与AspectJ的AOP术语是一样的，如切点(pointcut)定义需要应用通知的目标函数，通知则是那些需要应用到目标函数而编写的函数体，切面(Aspect)则是通知与切点的结合。织入(weaving)，将aspect类应用到目标函数(类)的过程，只不过Spring AOP底层是通过动态代理技术。

（1）JDK动态代理
  • 创建一个实现接口InvocationHandler的类，它必须实现invoke方法
  • 创建被代理的类以及接口
  • 通过Proxy的静态方法newProxyInstance(ClassLoaderloader, Class[] interfaces, InvocationHandler h)创建一个代理
  • 通过creatProxy()建立代理关系，调用相关方法
（2）CGLIB动态代理

  • 创建一个实现接口MethodInterceptor的类，它必须实现intercept方法

  • 创建Enhancer实例；

  • 通过setSuperclass方法来设置目标类；

  • 通过setCallback方法来设置拦截对象；

  • create方法生成Target的代理类，并返回代理类的实例。

未来村村长
关注
  • 3
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 4
    评论
专栏目录
Spring的IOC和AOP原理
YangTongA的博客
03-07 3398
对Spring的理解：Spring是一个轻型容器，其核心是bean工厂，用以构造我们所需的Model。 IOC：依赖注入，又叫控制反转。利用了工厂模式 IOC中将对象交给容器管理，你只需要在Spring配置文件中配置对应的Bean以及相关的属性即可，让Spring容器来生成类的实例对象以及管理对象，当Spring容器启动时会自动初始化好已经配置好的bean以及相关属性，当你调用时只需要把已经初...
spring ioc和aop原理流程图(详细)
08-27
spring ioc容器初始化流程图 spring ioc容器依赖注入流程图 spring aop实现原理流程图
Spring IOC和AOP 原理彻底搞懂
热门推荐
luoshenFU的专栏
08-16 18万+
<br />Spring提供了很多轻量级应用开发实践的工具集合，这些工具集以接口、抽象类、或工具类的形式存在于Spring中。通过使用这些工具集，可以实现应用程序与各种开源技术及框架间的友好整合。比如有关jdbc封装的数据访问工具Spring JDBC，有关编写单元测试的spring test包以及spring-mock，有关访问动态脚本语言的Spring Script，另外还有发送邮件的工具Spring Mail、日程及任务处理工具Spring scheduling等。 可以这么说，大多数企业级应用开发中
spring ioc与aop原理
daolicloud的博客
09-08 763
spring IoC和AOP的原理 (2012-04-07 11:54:33) 转载▼ 标签： spring ioc aop   下面为spring的主要原理： IoC(Inversion of Control)：IoC就是应用本身不依赖对象的创建和维护而是交给外部容器(这里为spring),这要就把应用和对象之间解耦,控制权交给了外部容器。即Don'...
spring、sringBoot资料
weixin_44981498的博客
03-06 212
Spring 原理 它是一个全面的、企业应用开发一站式的解决方案，贯穿表现层、业务层、持久层。但是 Spring 仍然可以和其他的框架无缝整合。 Spring 特点 轻量级 控制反转 面向切面 容器 框架集合 Spring 核心组件 Spring 常用模块 Spring 主要包 Spring 常用注解 bean 注入与装配的的方式有很多种，可以通过 xml，get set 方式，构造函数或者注解等。简单易用的方式就是使用 Spring 的注解了，Spring 提供了大量的注解方式。 Spring
AOP和IOC
右京的博客
08-14 140
用过spring的朋友都知道spring的强大和高深，都觉得深不可测，其实当你真正花些时间读一读源码就知道它的一些技术实现其实是建立在一些最基本的技术之上而已；例如AOP(面向方面编程)的实现是建立在CGLib提供的类代理和jdk提供的接口代理，IOC(控制反转)的实现建立在工厂模式、java反射机制和jdk的操作XML的DOM解析方式. 下面来对spring源码中的基本技术进行深入的剖析：先来说说AOP的实现，其实AOP就靠代理模式实现的，如：org.springframework.aop.framewo
Spring Ioc和Aop原理
03-10 657
参考资料 关于 Spring AOP (AspectJ) 你该知晓的一切 1.Spring Ioc（控制反转，依赖注入，两者意思相同）和Aop（面向切面编程） Ioc： 作用：通过Ioc容器实现对对象的管理，实现各组件之间的解耦 实现原理：反射 可以借助工厂+反射来理解 图示： 代码in
spring ioc 原理 spring aop原理
本事记的富伟徐
06-10 287
[color=red]1.关于spring ioc [/color] 　这段时间也着实好好的看了下spring的相关书籍，对其也有了大概和初步的认识和理解，虽然之前也一直听说spring是一个非常优秀的开源框架，可一直没有机会学习和使用（是不是有点落伍了？呵呵），所以呢，这段时间就重点学习了spring（一个星期的时间当然是入门级的啦~~） 　　大家一直都说spring的IOC如何如...
Spring框架IOC和AOP的实现原理
weixin_30785593的博客
03-30 1017
IoC（Inversion of Control） (1). IoC（Inversion of Control）是指容器控制程序对象之间的关系，而不是传统实现中，由程序代码直接操控。控制权由应用代码中转到了外部容器，控制权的转移是所谓反转。 对于Spring而言，就是由Spring来控制对象的生命周期和对象之间的关系；IoC还有另外一个名字——“依赖注入（Dependency Injec...
Spring的IoC和AOP原理
放羊的大飞
03-25 887
IoC和AOP IoC简介: 1.Inversion of Control 控制反转。一种设计思想，为了降低耦合度。 2.A实例调用B实例，通常是A通过new B来创建B实例，从而调用；而在依赖注入的模式下创建被调用者的工作不再由调用者来完成，而是通过Spring来创建，因此称之为“控制反转”；获得依赖对象的过程被反转了。 3.DI: Dependency Inje...
spring中IOC和AOP原理
weixin_34247155的博客
02-26 88
IoC（Inversion of Control）： （1）IoC（Inversion of Control）是指容器控制程序对象之间的关系，而不是传统实现中，由程序代码直接操控。控制权由应用代码中转到了外部容器，控制权的转移是所谓反转。对于Spring而言，就是由Spring来控制对象的生命周期和对象之间的关系；IoC还有另外一个名字——“依赖注入（Dependency Injection...
spring的IOC和AOP图解
陌上人如玉，公子世无双
09-12 670
spring的IOC和AOP图解 bean的生命周期 DI依赖注入
灵魂画手：图解Spring AOP实现原理
weixin_57907028的博客
06-06 407
本篇旨在让读者对Spring AOP实现原理有一个宏观上的认识，因此会丢失一些细节，阅读本篇文章前，希望读者对Spring Ioc以及Spring AOP的使用(@Aspect)由一定了解，话不多说，直接上图在service bean的创建过程中(也就是)，AOP通过后置处理器操作进行介入 分为2种情况：所有的重点都在做了什么操作创建完代理，代理如果调用方法呢？我们以Jdk动态代理为例子，方法的调用将会触发invoke方法。从上面可以看出，Spring AOP的代理invoke方法，其实是拦截器的执行。我们
Spring IOC和AOP原理解读(一)
u011102650的博客
07-17 500
spring开发,,,
IoC与AOP
最新发布
weixin_51360664的博客
08-16 1519
IoC与AOP
深入理解Spring两大特性：IoC和AOP
null
02-14 9万+
众所周知，Spring拥有两大特性：IoC和AOP。。Spring核心容器的主要组件是Bean工厂（BeanFactory），Bean工厂使用控制反转（IoC）模式来降低程序代码之间的耦合度，并提供了面向切面编程（AOP）的实现。简单来说，Spring是一个轻量级的控制反转（IoC）和面向切面编程（AOP）的容器框架。下面，我们简要说明下这两大特性。
关于Spring IOC和AOP的实现原理
mengyichang1234的博客
06-28 8455
Spring框架IOC和AOP的实现原理 1、IOC是指容器控制程序对象之间的关系，而不是我们传统实现中，由程序代码直接操作。控制权由应用代码转到外部容器，控制权的转移是所谓反转。对于Spring而言，就是由Spring来控制对象的生命周期和对象之间的关系；IOC还有另外一个名字--"依赖注入"，从名字上理解，所谓依赖注入，即组件之间的依赖关系由容器在运行期决定，即由容器动态的将某种依赖关系注入到...
SpringBoot实现AOP和IOC的原理
m0_62031104的博客
07-05 3445
本文主要是通过代码实现Spring Boot中的IOC和AOP配置。这里的AOP和IOC是属于Spring容器框架的范畴。和SpringBoot关系不大，因为Spring Boot的初中是整合简化了Spring和Spring MVC的开发。1、概念扩展：在Spring&Spring中我们式如何注册Bean的？ 1、基于XML的配置方式；打个比方: 假如使用Spring基于XML的配置的话，开发的基本流程就是: Java Bean实体编写——>XML（配置Bean）。 ...
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

未来村村长

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值