Java笔记——Java -- Spring_java spring

一、Spring简介

1. 概述

2. Spring两个核心特性

IoC(Inverse of Control)–> 控制反转

AoP(Aspect Oriented Programing) --> 面向切面编程

二、IoC详解

1. 核心容器

① ApplicationContext是BeanFactory的子接口,在基本功能之上提供了更多的功能:

    • 继承了MessageSource,支持国际化
    • 提供统一的资源访问方式
    • 同时加载多个配置文件,可载入上下文(具有层级关系)
    • 2. ApplicationContext常见实现

      ① FileSystemXmlApplicationContext:全路径名找Xml
      ② ClassPathXmlApplicationContext:在ClassPath中找Xml
      ③ WebXmlApplicationContext:一般从RequestContextUtils中获取Xml

      3. DI(Dependency Injection)依赖注入

      ① Xml配置:

      1. 接口注入:灵活性差,易用性差,Spring4后弃用
      2. 构造器注入:全属性注入,任何改动会导致新实例的创建<constructor-arg name="" value=""/)
      3. Setter方法注入:部分/全属性注入,改动不会导致新实例的创建 <property name="" value=""/)
      4. >
        1. @Component(“BeanName”) --> 可显示地指定BeanName,若不指定则按照类名驼峰命名 衍生出@Controller + @Service + @Repository/@Mapper
        2. 在属性上方@Value可以直接对该属性赋值
        >
        1. @Configuration + @Bean
        2. @Bean在方法上使用,方法返回值作为JavaBean被托管到容器中

        4. JavaBean作用域(Scope)

        ① SingleTon:单例模式(默认),每次返回的实例为同一个,适用于无状态的JavaBean
        ② ProtoType:原型模式,每次返回一个新的JavaBean,适用于有状态的JavaBean
        ③ Web应用中:

        request:为每一个请求创建一个实例
        session:同一个session会话共享一个实例,不同会话使用不同实例
        global-session:全局作用域,所有session会话共享一个实例

        5. Bean的装配机制

        1. 自动装配主要分为两种:byName和byType,可在xml中加入autowire=byName/byType来指定自动装配方法
        2. @Autowired自动装配:先按照byType装配,若对应type的对象有多个,则按照类名驼峰命名的名字进行byName装配
        3. @Qualifier(“BeanName”):指定具体JavaBean名,进行byName加载;主要是作为@Autowired的补充修饰,消除歧义
        4. @Resource:先按照byName进行装配,然后按照buType装配
        5. 6. Bean的生命周期

          [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-5s08on6a-1626181763936)(http://182.92.190.128:8090/upload/2021/07/image-a4e39ff9b3a54e44828f6be6b7e39ca7.png)]

          (1)实例化Bean:

          • 对于BeanFactory容器,当客户向容器请求一个尚未初始化的bean时,或初始化bean的时候需要注入另一个尚未初始化的依赖时,容器就会调用createBean进行实例化。
          • 对于ApplicationContext容器,当容器启动结束后,通过获取BeanDefinition对象中的信息,实例化所有的bean。
          > (2)设置对象属性(依赖注入):
          • 实例化后的对象被封装在BeanWrapper对象中,紧接着,Spring根据BeanDefinition中的信息 以及 通过BeanWrapper提供的设置属性的接口完成属性设置与依赖注入。
          > (3) InitializingBean:
          • 如果Bean实现了InitializingBean接口,执行afeterPropertiesSet()方法。
          > (4) destroy-method:
          • 最后,如果这个Bean的Spring配置中配置了destroy-method属性,会自动调用其配置的销毁方法。

          三、AoP详解

          1. SpringAop名词解释

          ① 切面(Aspect):由通知 + 切点组成
          ② 连接点(Join Point):能够插入切面的点
          ③ 通知(Advice):切面的逻辑(工作内容)
          ④ 切点(PointCut):切点的定义用于匹配通知所要织入的连接点
          ⑤ 引入(Introduction)
          ⑥ 目标对象(Target):被切面通知的对象
          ⑦ 织入(Wearing):切面插入,创建新代理对象

          在这里插入图片描述
          2. 通知类型

          1. Before
          2. After
          3. Around
          4. AfterReturning
          5. AfterThrowing
          6. 3. SpringAoP 和 AspectJAoP

            四、Spring容器的启动流程

            1. 总体流程

            1. 初始化Spring容器,注册内置的BeanPostProcessor的BeanDefinition到容器中
            2. 将配置类的BeanDefinition注册到容器中
            3. 调用refresh()方法刷新容器
            4. // 初始化容器
              public AnnotationConfigApplicationContext(Class<?>... annotatedClasses) {
                   
                   
              
                  this();				// 1. 注册 Spring 内置后置处理器的 BeanDefinition 到容器
                  
                  register(annotatedClasses);		// 2. 注册配置类 BeanDefinition 到容器
                  
                  refresh();				// 3. 加载或者刷新容器中的Bean
              }
              
              // 初始化容器
              public AnnotationConfigApplicationContext(Class<?>... annotatedClasses) {
                   
                   
              
                  this();				// 1. 注册 Spring 内置后置处理器的 BeanDefinition 到容器
                  
                  register(annotatedClasses);		// 2. 注册配置类 BeanDefinition 到容器
                  
                  refresh();				// 3. 加载或者刷新容器中的Bean
              }
              

              [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-samvvSU8-1626181763939)(http://182.92.190.128:8090/upload/2021/07/image-ff5602dda5ce4f70b56d6f22ed2ab112.png)]

              2. 初始化流程

              (1) 无参构造函数this()

              1. 实例化BeanFactory【DefaultListableBeanFactory】工厂,用于生成Bean对象
              2. 实例化BeanDefinitionReader注解配置读取器,用于对特定注解(如@Service、@Repository)的类进行读取转化成 BeanDefinition 对象,(BeanDefinition 是 Spring 中极其重要的一个概念,它存储了 bean 对象的所有特征信息,如是否单例,是否懒加载,factoryBeanName 等)
              3. 实例化ClassPathBeanDefinitionScanner路径扫描器,用于对指定的包目录进行扫描查找 bean 对象
              4. // 无参构造方法 
                public AnnotationConfigApplicationContext() {
                     
                     					// 实例化Spring容器
                		StartupStep createAnnotatedBeanDefReader = this.getApplicationStartup().start("spring.context.annotated-bean-reader.create");
                		this.reader = new AnnotatedBeanDefinitionReader(this);		// 实例化配置读取器
                		createAnnotatedBeanDefReader.end();
                		this.scanner = new ClassPathBeanDefinitionScanner(this);	// 实例化路径扫描器
                	}
                
                // 无参构造方法 
                public AnnotationConfigApplicationContext() {
                     
                     					// 实例化Spring容器
                		StartupStep createAnnotatedBeanDefReader = this.getApplicationStartup().start("spring.context.annotated-bean-reader.create");
                		this.reader = new AnnotatedBeanDefinitionReader(this);		// 实例化配置读取器
                		createAnnotatedBeanDefReader.end();
                		this.scanner = new ClassPathBeanDefinitionScanner(this);	// 实例化路径扫描器
                	}
                

                (2) 内置组件添加

                调用无参构造函数this()完成后,Spring容器已经构造完毕,这时需要为容器添加一些内置组件

                调用方法:org.springframework.context.annotation.AnnotationConfigUtils#registerAnnotationConfigProcessors

                主要组件:

                源码跟踪:

                构造方法源码:渐进调用

                public AnnotatedBeanDefinitionReader(BeanDefinitionRegistry registry) {
                     
                     
                	this(registry, getOrCreateEnvironment(registry));
                }
                
                public AnnotatedBeanDefinitionReader(BeanDefinitionRegistry registry, Environment environment) {
                     
                     
                	Assert.notNull(registry, "BeanDefinitionRegistry must not be null");
                	Assert.notNull(environment, "Environment must not be null");
                	this.registry = registry;
                	this.conditionEvaluator = new ConditionEvaluator(registry, environment, null);
                	AnnotationConfigUtils.registerAnnotationConfigProcessors(this.registry);	// 内置组件添加
                }
                
                public AnnotatedBeanDefinitionReader(BeanDefinitionRegistry registry) {
                     
                     
                	this(registry, getOrCreateEnvironment(registry));
                }
                
                public AnnotatedBeanDefinitionReader(BeanDefinitionRegistry registry, Environment environment) {
                     
                     
                	Assert.notNull(registry, "BeanDefinitionRegistry must not be null");
                	Assert.notNull(environment, "Environment must not be null");
                	this.registry = registry;
                	this.conditionEvaluator = new ConditionEvaluator(registry, environment, null);
                	AnnotationConfigUtils.registerAnnotationConfigProcessors(this.registry);	// 内置组件添加
                }
                
                public static Set<BeanDefinitionHolder> registerAnnotationConfigProcessors(
                	BeanDefinitionRegistry registry, @Nullable Object source) {
                     
                     
                
                	DefaultListableBeanFactory beanFactory = unwrapDefaultListableBeanFactory(registry);
                	if (beanFactory != null) {
                     
                     
                		if (!(beanFactory.getDependencyComparator() instanceof AnnotationAwareOrderComparator)) {
                     
                     
                				beanFactory.setDependencyComparator(AnnotationAwareOrderComparator.INSTANCE);
                		}
                		if (!(beanFactory.getAutowireCandidateResolver() instanceof ContextAnnotationAutowireCandidateResolver)) {
                     
                     
                			beanFactory.setAutowireCandidateResolver(new ContextAnnotationAutowireCandidateResolver());
                		}
                	}
                
                	Set<BeanDefinitionHolder> beanDefs = new LinkedHashSet<>(8);
                	
                	// 向beanDefinitionMap中注册BeanFactoryProcessor:ConfigurationClassPostProcessor
                	if (!registry.containsBeanDefinition(CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME)) {
                     
                     
                		RootBeanDefinition def = new RootBeanDefinition(ConfigurationClassPostProcessor.class);
                		def.setSource(source);
                		beanDefs.add(registerPostProcessor(registry, def, CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME));
                	}
                	
                	// 向beanDefinitionMap中注册BeanPostProcessor:AutowiredAnnotationBeanPostProcessor
                	if (!registry.containsBeanDefinition(AUTOWIRED_ANNOTATION_PROCESSOR_BEAN_NAME)) {
                     
                     
                		RootBeanDefinition def = new RootBeanDefinition(AutowiredAnnotationBeanPostProcessor.class);
                		def.setSource(source);
                		beanDefs.add(registerPostProcessor(registry, def, AUTOWIRED_ANNOTATION_PROCESSOR_BEAN_NAME));
                	}
                
                	// Check for JSR-250 support, and if present add the CommonAnnotationBeanPostProcessor.
                	// 向beanDefinitionMap中注册BeanPostProcessor:CommonAnnotationBeanPostProcessor
                	if (jsr250Present && !registry.containsBeanDefinition(COMMON_ANNOTATION_PROCESSOR_BEAN_NAME)) {
                     
                     
                		RootBeanDefinition def = new RootBeanDefinition(CommonAnnotationBeanPostProcessor.class);
                		def.setSource(source);
                		beanDefs.add(registerPostProcessor(registry, def, COMMON_ANNOTATION_PROCESSOR_BEAN_NAME));
                	}
                
                	// Check for JPA support, and if present add the PersistenceAnnotationBeanPostProcessor.
                	// 向beanDefinitionMap中注册BeanPostProcessor:PersistenceAnnotationBeanPostProcessor
                	if (jpaPresent && !registry.containsBeanDefinition(PERSISTENCE_ANNOTATION_PROCESSOR_BEAN_NAME)) {
                     
                     
                		RootBeanDefinition def = new RootBeanDefinition();
                		try {
                     
                     
                			def.setBeanClass(ClassUtils.forName(PERSISTENCE_ANNOTATION_PROCESSOR_CLASS_NAME,
                						AnnotationConfigUtils.class.getClassLoader()));
                			}
                		catch (ClassNotFoundException ex) {
                     
                     
                			throw new IllegalStateException("Cannot load optional framework class: " + PERSISTENCE_ANNOTATION_PROCESSOR_CLASS_NAME, ex);
                		}
                		def.setSource(source);
                		beanDefs.add(registerPostProcessor(registry, def, PERSISTENCE_ANNOTATION_PROCESSOR_BEAN_NAME));
                		}
                
                	if (!registry.containsBeanDefinition(EVENT_LISTENER_PROCESSOR_BEAN_NAME)) {
                     
                     
                		RootBeanDefinition def = new RootBeanDefinition(EventListenerMethodProcessor.class);
                		def.setSource(source);
                		beanDefs.add(registerPostProcessor(registry, def, EVENT_LISTENER_PROCESSOR_BEAN_NAME));
                	}
                
                	if (!registry.containsBeanDefinition(EVENT_LISTENER_FACTORY_BEAN_NAME)) {
                     
                     
                		RootBeanDefinition def = new RootBeanDefinition(DefaultEventListenerFactory.class);
                		def.setSource(source);
                		beanDefs.add(registerPostProcessor(registry, def, EVENT_LISTENER_FACTORY_BEAN_NAME));
                	}
                
                	return beanDefs;
                }
                
                public static Set<BeanDefinitionHolder> registerAnnotationConfigProcessors(
                	BeanDefinitionRegistry registry, @Nullable Object source) {
                     
                     
                
                	DefaultListableBeanFactory beanFactory = unwrapDefaultListableBeanFactory(registry);
                	if (beanFactory != null) {
                     
                     
                		if (!(beanFactory.getDependencyComparator() instanceof AnnotationAwareOrderComparator)) {
                     
                     
                				beanFactory.setDependencyComparator(AnnotationAwareOrderComparator.INSTANCE);
                		}
                		if (!(beanFactory.getAutowireCandidateResolver() instanceof ContextAnnotationAutowireCandidateResolver)) {
                     
                     
                			beanFactory.setAutowireCandidateResolver(new ContextAnnotationAutowireCandidateResolver());
                		}
                	}
                
                	Set<BeanDefinitionHolder> beanDefs = new LinkedHashSet<>(8);
                	
                	// 向beanDefinitionMap中注册BeanFactoryProcessor:ConfigurationClassPostProcessor
                	if (!registry.containsBeanDefinition(CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME)) {
                     
                     
                		RootBeanDefinition def = new RootBeanDefinition(ConfigurationClassPostProcessor.class);
                		def.setSource(source);
                		beanDefs.add(registerPostProcessor(registry, def, CONFIGURATION_ANNOTATION_PROCESSOR_BEAN_NAME));
                	}
                	
                	// 向beanDefinitionMap中注册BeanPostProcessor:AutowiredAnnotationBeanPostProcessor
                	if (!registry.containsBeanDefinition(AUTOWIRED_ANNOTATION_PROCESSOR_BEAN_NAME)) {
                     
                     
                		RootBeanDefinition def = new RootBeanDefinition(AutowiredAnnotationBeanPostProcessor.class);
                		def.setSource(source);
                		beanDefs.add(registerPostProcessor(registry, def, AUTOWIRED_ANNOTATION_PROCESSOR_BEAN_NAME));
                	}
                
                	// Check for JSR-250 support, and if present add the CommonAnnotationBeanPostProcessor.
                	// 向beanDefinitionMap中注册BeanPostProcessor:CommonAnnotationBeanPostProcessor
                	if (jsr250Present && !registry.containsBeanDefinition(COMMON_ANNOTATION_PROCESSOR_BEAN_NAME)) {
                     
                     
                		RootBeanDefinition def = new RootBeanDefinition(CommonAnnotationBeanPostProcessor.class);
                		def.setSource(source);
                		beanDefs.add(registerPostProcessor(registry, def, COMMON_ANNOTATION_PROCESSOR_BEAN_NAME));
                	}
                
                	// Check for JPA support, and if present add the PersistenceAnnotationBeanPostProcessor.
                	// 向beanDefinitionMap中注册BeanPostProcessor:PersistenceAnnotationBeanPostProcessor
                	if (jpaPresent && !registry.containsBeanDefinition(PERSISTENCE_ANNOTATION_PROCESSOR_BEAN_NAME)) {
                     
                     
                		RootBeanDefinition def = new RootBeanDefinition();
                		try {
                     
                     
                			def.setBeanClass(ClassUtils.forName(PERSISTENCE_ANNOTATION_PROCESSOR_CLASS_NAME,
                						AnnotationConfigUtils.class.getClassLoader()));
                			}
                		catch (ClassNotFoundException ex) {
                     
                     
                			throw new IllegalStateException("Cannot load optional framework class: " + PERSISTENCE_ANNOTATION_PROCESSOR_CLASS_NAME, ex);
                		}
                		def.setSource(source
              评论
              添加红包

              请填写红包祝福语或标题

              红包个数最小为10个

              红包金额最低5元

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

              打赏作者

              啊健的影子

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

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

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

              打赏作者

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

              抵扣说明:

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

              余额充值