Spring源码分析之IOC容器设计理念与核心注解

Spring源码分析之IOC容器设计理念与核心注解

一、 Spring框架功能整体介绍

image

1: Spring Core Container

模块作用:Core 和 Beans 模块是框架的基础部分,提供 IoC (转控制)和依赖注入特性。 这里 的基础 概念是 BeanFactory,它提供对 Factory 模式的经典实现来消除对程序性单 例模式的需要,并真正地允许你从程序逻辑中分离出依赖关系和配置。

  • 1.1) Core

主要包含 Spring 框架基本的核心工具类, Spring 的其他组件都要用到这个包里的类, Core 模块是其他组件的基本核心。

  • 1.2) Beans (BeanFacotry的作用)

它包含访问配直文件、创建和管理 bean 以及进行 Inversion of Control I Dependency Injection ( IoC/DI )操作相关的所有类。

  • 1.3) Context(处理BeanFactory,以下还是ApplicationContext的作用)

模构建于 Core 和 Beans 模块基础之上,提供了一种类似JNDI注册器的框架式的对象访问方 法。 Context 模块继承了 Beans 的特性,为 Spring 核心提供了大量 扩展,添加了对 国际化(例如资源绑定)、事件传播、资源加载和对 Context 的透明创 建的支持。 Context 模块同时 也支持 J2EE 的一些特性,ApplicationContext 接口是 Context
模块的关键

本质区别:(使用BeanFacotry的bean是延时加载的,ApplicationContext是非延时加载的)。

  • 1.4) Expression Language

模块提供了强大的表达式语言,用于在运行时查询和操纵对象。 它是 JSP 2.1 规范中定义的 unifed expression language 的扩展。 该语言支持设直/获取属 性的值,属性的分配,方法的调用,访问数 组上下文( accessiong the context of arrays )、 容器和索引器、逻辑和算术运算符、命名变量以 及从Spring的 IoC 容器中根据名称检 索对象。 它也支持 list 投影、选择和一般的 list 聚合

2: Spring Data Access/Integration
  • 2.1)JDBC 模块提供了一个 JDBC 抽象层,它可以消除冗长的 JDBC 编码和解析数据库厂商特有的错误代码。 这个模块包含了 Spring 对 JDBC 数据访问进行封装的所有类。
  • 2.2)ORM 模块为流行的对象-关系映射 API,如 JPA、 JDO、 Hibernate、 iBatis 等,提供了 一个交互层。 利用 ORM 封装包,可以混合使用所有 Spring 提供的特性进行 O/R 映射, 如前边提到的简单声明性事务管理。
  • 2.3)OXM 模块提供了一个对 ObjecνXML 映射实现的抽象层Object/XML 映射实现包括 JAXB、 Castor、 XMLBeans、 JiBX 和 XStrearn。
  • 2.4)JMS (Java Messaging Service )模块主要包含了 一些制造和消费消息的特性。
  • 2.5)Transaction支持编程和声明性的事务管理,这些事务类必须实现特定的接口,并 且对所有的 POJO 都适用
3: Spring Web

Web 模块:提供了基础的面向 Web 的集成特性例如,多文件上传、使用 servlet listeners 初始化 IoC 容器以及一个面向 Web 的应用上下文。 它还包含 Spring 远程支持中 Web 的相关部分。

4: Spring Aop
  • 4.1)Aspects 模块提供了对 AspectJ 的集成支持。
  • 4.2)Instrumentation 模块提供了 class instrumentation 支持和 classloader 实现,使得可以在特 定的应用服务器上使用
5:Test

Test 模块支持使用 JUnit 和 TestNG 对 Spring 组件进行测试

6:Spring 容器继承图:

image

7:控制反转和依赖注入
  • 7.1)什么是控制反转?我觉得有必要先了解软件设计的一个重要思想:依赖倒置原则(Dependency Inversion Principle )

①:什么是依赖倒置原则?假设我们设计一辆汽车:先设计轮子,然后根据轮子大小设计底盘,接着根据底 盘设计车身,最后根据车身设计好整个汽车。这里就出现了一个“依赖”关系:汽车依赖车身,车身依赖 底盘,底盘依赖轮子

image

上图看上去没有什么毛病?但是万一轮胎尺寸改了,那么地盘需要改,地盘改了,车身也改了,让后整个汽车构造都改了. 然后汽车公司倒闭了

反过来,假如汽车公司决定修改轮胎的我们就只需要改动轮子的设计,而不需要动底盘,车身,汽车 的设计了。

image

IOC容器的最最最最核心思想

ioc的思想最核心的地方在于资源不由使用资源的双方管理,而由不使用资源的第三方管理,这可以带来很多好处。

第一,资源集中管理,实现资源的可配置和易管理。

第二,降低了使用资源双方的依赖程度,也就是我们说的耦合度

如下图所示:

image

二、Spring IOC 容器底层注解使用

2.1)xml配置文件的形式VS配置类的形式
  • ①:基于xml的形式定义Bean的信息
1
2
3
4
5
6
7
<?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 http://www.springframework.org/schema/beans/spring-beans.xsd">

<bean id="person" class="com.tuling.xmlbeanfacotry.Person"></bean>
</beans>

去容器中读取Bean

1
2
3
4
public static void main(String[] args) {
//XmlBeanFactory xmlBeanFactory = new XmlBeanFactory(new ClassPathResource("XmlBean.xml"));
ClassPathXmlApplicationContext ctx = new ClassPathXmlApplicationContext("XmlBean.xml");
}
  • ②:基于读取配置类的形式定义Bean信息
1
2
3
4
5
6
7
8
9
10
11
/**
* @Configuration修饰的类其实对应的就是一个xml配置文件
*/
@Configuration
public class MainConfig {

@Bean
public Person person(){
return new Person();
}
}

注意: 通过@Bean的形式是使用的话, bean的默认名称是方法名,若@Bean(value=”bean的名称”) 那么bean的名称是指定的
去容器中读取Bean的信息(传入配置类)

1
2
3
4
public static void main(String[] args) {
AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext(MainConfig.class);
System.out.println(ctx.getBean("person"));
}
2.2)在配置类上写@CompentScan注解来进行包扫描
1
2
3
4
@Configuration
@ComponentScan(basePackages ={"com.tuling.testcompentscan"} )
public class MainConfig {
}
  • ①:排除用法excludeFilters(排除@Controller注解和TulingService的)
1
2
3
4
5
6
7
8
@Configuration
@ComponentScan(basePackages = {"com.tuling.testcompentscan"},excludeFilters = {
@ComponentScan.Filter(type = FilterType.ANNOTATION,value = {Controller.class}),
@ComponentScan.Filter(type = FilterType.ASSIGNABLE_TYPE,value = {TulingService.class})
})
@ComponentScan(basePackages ={"com.tuling.testcompentscan"} )
public class MainConfig {
}
  • ②:包含用法includeFilters ,注意,若使用包含的用法,需要把useDefaultFilters属性设置为false(true表
    示扫描全部的)
1
2
3
4
5
6
7
@Configuration
@ComponentScan(basePackages = {"com.tuling.testcompentscan"},includeFilters = {
@ComponentScan.Filter(type = FilterType.CUSTOM,value = TulingFilterType.class)
},useDefaultFilters = false)
@ComponentScan(basePackages ={"com.tuling.testcompentscan"} )
public class MainConfig {
}
  • ③@ComponentScan.Filter type的类型
    • a)注解形式的FilterType.ANNOTATION @Controller @Service @Repository @Compent - b)指定类型的 FilterType.ASSIGNABLE_TYPE @ComponentScan.Filter(type = FilterType.ASSIGNABLE_TYPE,value = {TulingService.class})
    • c)aspectj类型的 FilterType.ASPECTJ(不常用)
    • d)正则表达式的 FilterType.REGEX(不常用)
    • e)自定义的 FilterType.CUSTOM

自定义的 FilterType.CUSTOM代码示例:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
publicenum FilterType{ 
//注解形式比如@Controller @Service @Repositor @Compent ANNOTATION,
//指定的类型 ASSIGNABLE_TYPE,
//aspectJ形式的 ASPECTJ,
//正则表达式的 REGEX,
//自定义的 CUSTOM
}

FilterType.CUSTOM 自定义类型如何使用

public class TulingFilterType implements TypeFilter {

@Override
public boolean match(MetadataReader metadataReader, MetadataReaderFactory metadataReaderFactory) throws IOException {
//获取当前类的注解源信息
AnnotationMetadata annotationMetadata = metadataReader.getAnnotationMetadata();

//获取当前类的class的源信息
ClassMetadata classMetadata = metadataReader.getClassMetadata();
//获取当前类的资源信息
Resource resource = metadataReader.getResource();
System.out.println("类的路径:"+classMetadata.getClassName());
if(classMetadata.getClassName().contains("dao")) {
return true;
}
return false;
}
}

代码示例:

1
2
3
4
5
6
7
8
9
10
@Configuration
@ComponentScan(basePackages = {"com.tuling.testcompentscan"},excludeFilters = {
//@ComponentScan.Filter(type = FilterType.ANNOTATION,value = {Controller.class, Service.class}),
@ComponentScan.Filter(type = FilterType.CUSTOM,value = TulingFilterType.class)
},includeFilters = {
@ComponentScan.Filter(type = FilterType.ANNOTATION,value = Repository.class)
})
@ComponentScan(basePackages ={"com.tuling.testcompentscan"} )
public class MainConfig {
}
2.3)配置Bean的作用域对象
  • ①:在不指定@Scope的情况下,所有的bean都是单实例的bean,而且是饿汉加载(容器启动实例就创建 好了)
1
2
3
4
@Bean
public Person person(){
return new Person();
}
  • ②:指定@Scope为prototype表示为多实例的,而且还是懒汉模式加载(IOC容器启动的时候,并不会创建对象,而是 在第一次使用的时候才会创建)
1
2
3
4
5
@Bean
@Scope(value="prototype")
public Person person(){
return new Person();
}
  • ③:@Scope指定的作用域方法取值
1
2
3
4
singleton 单实例的(默认)
prototype 多实例的
request 同一次请求
session 同一个会话级别
  • ④:Bean的懒加载@Lazy(主要针对单实例的bean 容器启动的时候,不创建对象,在第一次使用的时候才会创建该对象)
1
2
3
4
5
@Bean
@Lazy
public Person person(){
return new Person();
}
  • ⑤:@Conditional进行条件判断等.
    场景,有二个组件TulingAspect和TulingLog ,我的TulingLog组件是依赖于TulingAspect的组件
    应用:自己创建一个TulingCondition的类 实现Condition接口
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
public class TulingCondition implements Condition {

/**
*
* @param context
* @param metadata
* @return
*/
@Override
public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
//判断容器中是否有tulingAspect的组件
if(context.getBeanFactory().containsBean("tulingAspect")) {
return true;
}
return false;
}
}

当容器中有tulingAspect的组件,那么tulingLog才会被实例化。

1
2
3
4
5
@Bean
@Conditional(value = TulingCondition.class)
public TulingLog tulingLog() {
return new TulingLog();
}
  • ⑥:往IOC 容器中添加组件的方式
    • 通过@CompentScan + @Controller @Service @Respository @compent
      适用场景: 针对我们自己写的组件可以通过该方式来进行加载到容器中。
    • 通过@Bean的方式来导入组件(适用于导入第三方组件的类)
    • 通过@Import来导入组件 (导入组件的id为全类名路径)
      1
      2
      3
      4
      @Configuration @Import(value={Person.class,Car.class}) 
      public class MainConfig{

      }

-------------已经触及底线 感谢您的阅读-------------

本文标题:Spring源码分析之IOC容器设计理念与核心注解

文章作者:趙小傑~~

发布时间:2019年08月10日 - 17:09:33

最后更新:2019年08月13日 - 22:49:52

原始链接:https://cnsyear.com/posts/1887c3a8.html

许可协议: 署名-非商业性使用-禁止演绎 4.0 国际 转载请保留原文链接及作者。

0%