Spring IOC容器设计理念与常见底层核心注解

时间 2019-11-08

标签 spring ioc 容器设计理念常见底层核心注解栏目 Spring 繁體版

原文原文链接

1、Spring 框架总体功能介绍

Spring Framework是一个Java平台，为开发Java应用程序提供全面的基础架构支持。Spring处理基础架构，所以您能够专一于您的应用程序。java

Spring容许您从“普通旧Java对象”（POJO）构建应用程序，并以非侵入方式将企业服务应用于POJO。此功能适用于Java SE编程模型以及完整和部分Java EE。正则表达式

做为应用程序开发人员，您能够从Spring平台中受益的示例以下：spring

使Java方法在数据库事务中执行，而没必要处理事务API。
使本地Java方法成为远程过程，而无需处理远程API。
使本地Java方法成为管理操做，而无需处理JMX API。
使本地Java方法成为消息处理程序，而无需处理JMS API。

Spring Framework由大约20个模块组成的功能组成。这些模块分为核心容器，数据访问/集成，Web，AOP（面向方面编程），仪器，消息传递和测试，以下图所示。数据库

1. Spring Core Container

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

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 模块的关键bash

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

1.4 Expression Language

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

2. Spring Data Access/Integration

2.1 JDBC

模块提供了一个 JDBC 抽象层，它能够消除冗长的 JDBC 编码和解析数据库厂商特有的错误代码。这个模块包含了 Spring 对 JDBC 数据访问进行封装的全部类

2.2 ORM 模块为流行的对象-关系映射 API

如 JPA、 JDO、 Hibernate、 MyBatis 等，提供了一个交互层。利用 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

Aspects 模块提供了对 AspectJ 的集成支持。
Instrumentation 模块提供了 class instrumentation 支持和 classloader 实现，使得能够在特定的应用服务器上使用

5. Spring Test

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

6. Spring 容器继承图

7. 控制反转和依赖注入

什么是控制反转？

这里有必要先了解软件设计的一个重要思想：依赖倒置原则(Dependency Inversion Principle )

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

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

董事长依赖总经理挣钱，总经理依赖部门经理挣钱，部门经理依赖员工争取，那么员工离职了怎么办??????????

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

IOC 的思想最核心的地方在于，资源不禁使用资源的双方管理，而是不使用资源的第三方管理。这样能够带来不少好处，以下：

资源集中管理，实现资源的可配置和易管理
下降了使用资源的双方的依赖程度，也就是耦合度

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

一、xml配置文件的形式 VS 配置类的形式

1⃣ 基于xml的形式定义Bean的信息

<?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的信息
<bean id="car" class="com.niuh.compent.Car"></bean>
</beans>
复制代码

去容器中读取Bean

public static void main( String[] args ) {
   ClassPathXmlApplicationContext ctx = new ClassPathXmlApplicationContext("beans.xml");
   System.out.println(ctx.getBean("person")); 
}
复制代码

2⃣ 基于读取配置类的形式定义Bean信息

@Configuration
public class MainConfig {
    @Bean
    public Person person(){
        return new Person();
    }
}
复制代码

注意: 经过@Bean的形式是使用的话， bean的默认名称是方法名，若@Bean(value="bean的名称") 那么bean的名称是指定的

去容器中读取Bean的信息(传入配置类)

public static void main( String[] args ) {
    AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext(MainConfig.class);
    System.out.println(ctx.getBean("person")); 
}
复制代码

二、在配置类上写@CompentScan注解来进行包扫描

@Configuration
@ComponentScan(basePackages = {"com.niuh.testcompentscan"}) 
public class MainConfig {
}
复制代码

1⃣ 排除用法 excludeFilters（排除@Controller注解的和NiuhService的）

@Configuration
@ComponentScan(basePackages = {"com.niuh.testcompentscan"},excludeFilters = {
@ComponentScan.Filter(type = FilterType.ANNOTATION,value = {Controller.class}),
@ComponentScan.Filter(type = FilterType.ASSIGNABLE_TYPE,value = {NiuhService.class}) })
public class MainConfig {
}
复制代码

2⃣ 包含用法 includeFilters，注意：若使用包含的用法，须要把useDefaultFilters属性设置为false（true表示扫描所有）

@Configuration
@ComponentScan(basePackages = {"com.niuh.testcompentscan"},includeFilters = {
@ComponentScan.Filter(type = FilterType.ANNOTATION,value = {Controller.class, Service.class}) },useDefaultFilters = false)
public class MainConfig {
}
复制代码

3⃣ @ComponentScan.Filter type的类型

*   注解形式的FIlterType.ANNOTATION @Controller @Service @Repository @Compent
*   指定类型的FilterType.ASSIGNABLE_TYPE @ComponentScan.Filter(type = FilterType.ASSIGNABLE_TYPE,value = {NiuhService.class}) })
*   aspectj 类型的 FilterType.ASPECTJ (不经常使用)
*   正则表达式的 FilterType.REGEX (不经常使用)
*   自定义的 FilterType.CUSTOM
复制代码

public enum FilterType {
    //注解形式 好比@Controller @Service @Repository @Compent 
    ANNOTATION,
    //指定的类型 
    ASSIGNABLE_TYPE,
    //aspectJ形式的 
    ASPECTJ,
    //正则表达式的 
    REGEX,
   //自定义的 
   CUSTOM
}
复制代码

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

public class NiuhFilterType 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();
       if(classMetadata.getClassName().contains("dao")) { 
            return true;
       }
       return false; 
    }
}

@ComponentScan(basePackages = {"com.niuh.testcompentscan"},includeFilters = { @ComponentScan.Filter(type = FilterType.CUSTOM,value = NiuhFilterType.class)},useDefaultFilters = false)
public class MainConfig {
}
复制代码

三、配置Bean的做用域对象

1⃣ 在不指定@Scope的状况下，全部的bean都是单实例的bean，并且是饿汉加载（启动启动实例就建立好了）

@Bean
public Person person() {
    return new Person(); 
}
复制代码

2⃣ 指定@Scope为prototype 表示为多实例，并且仍是懒汉加载模式（IOC容器启动的时候，并不会建立对象，而是在第一次使用的时候才会建立）

@Bean
@Scope(value = "prototype") 
public Person person() {
    return new Person(); 
}
复制代码

3⃣ @Scope 指定的做用域方法取值

singleton 单实例的(默认)
prototype 多实例的
request 同一次请求
session 同一个会话级别

四、Bean的懒加载 @lazy

主要针对单实例的bean ，容器启动的时候，不建立对象，在第一次使用的时候才会建立该对象

@Bean
@Lazy
public Person person() {
    return new Person(); 
}
复制代码

五、@Conditional 进行条件判断等

场景,有二个组件NiuhAspect 和 NiuhLog ，个人NiuhLog组件是依赖于NiuhAspect的组件应用:本身建立一个NiuhCondition的类实现Condition接口

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; 
    }
}

public class MainConfig {
    @Bean
    public NiuhAspect niuhAspect() {
        return new NiuhAspect();
    }
    //当切 容器中有niuhAspect的组件，那么niuhLog才会被实例化. @Bean
    @Conditional(value = NiuhCondition.class)
    public NiuhLog niuhLog() {
        return new NiuhLog(); 
    }
} 
复制代码

六、往IOC容器中添加组件的方式

1⃣ 经过@CompentScan + @Controller @Service @Respository @compent

适用场景：针对咱们本身写的组件能够经过该方式来进行加载到容器中。

2⃣ 经过@Bean 的方式来导入组件（适用于导入第三方组件的泪）

3⃣ 经过@Import 来导入组建（导入组件的id为全类名路径）

@Configuration
@Import(value = {Person.class, Car.class}) 
public class MainConfig {
}
复制代码

经过@Import 的ImportSeletor类实现组件的导入 (导入组件的id为全类名路径)

public class NiuhImportSelector implements ImportSelector { 
    //能够获取导入类的注解信息
    @Override
    public String[] selectImports(AnnotationMetadata importingClassMetadata) {
        return new String[]{"com.niuh.testimport.compent.Dog"}; 
    }
} 

@Configuration
@Import(value = {Person.class, Car.class, NiuhImportSelector.class}) 
public class MainConfig {
}
复制代码

经过@Import的 ImportBeanDefinitionRegister导入组件 (能够指定bean的名称)

public class NiuhBeanDefinitionRegister implements ImportBeanDefinitionRegistrar { 
    @Override
    public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) { //建立一个bean定义对象
        RootBeanDefinition rootBeanDefinition = new RootBeanDefinition(Cat.class);
        //把bean定义对象导入到容器中
        registry.registerBeanDefinition("cat",rootBeanDefinition); 
    }
}

@Configuration
//@Import(value = {Person.class, Car.class})
//@Import(value = {Person.class, Car.class, TulingImportSelector.class})
@Import(value = {Person.class, Car.class, NiuhImportSelector.class, NiuhBeanDefinitionRegister.class}) 
public class MainConfig {
}
复制代码

4⃣ 经过实现FactoryBean 接口来实现注册组建

public class CarFactoryBean implements FactoryBean<Car> {
    //返回bean的对象
    @Override
    public Car getObject() throws Exception {
        return new Car(); 
    }
    //返回bean的类型
    @Override
    public Class<?> getObjectType() {
        return Car.class; 
   }
    //是否为单例
    @Override
    public boolean isSingleton() {
        return true; 
    }
}
复制代码

七、Bean的初始化方法和销毁方法

1⃣ 什么是Bean 的生命周期？

bean的建立-------> 初始化 ---------> 销毁方法

由容器管理Bean的生命周期，咱们能够经过本身指定bean的初始化方法和bean的销毁方法

@Configuration
public class MainConfig {
    //指定了bean的生命周期的初始化方法和销毁方法.
    @Bean(initMethod = "init",destroyMethod = "destroy") 
    public Car car() {
        return new Car(); 
    }
}
复制代码

针对单实例bean的话，容器启动的时候，bean的对象就建立了，并且容器销毁的时候，也会调用Bean的销毁方法

针对多实例bean的话,容器启动的时候，bean是不会被建立的而是在获取bean的时候被建立，并且bean的销毁不受 IOC容器的管理.

2⃣ 经过InitializingBean 和 DisposableBean 的2个接口实现bean的初始化以及销毁方法

@Component
public class Person implements InitializingBean,DisposableBean {
    public Person() { 
        System.out.println("Person的构造方法");
    }
    
    @Override
    public void destroy() throws Exception {
        System.out.println("DisposableBean的destroy()方法 "); 
    }
    
    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("InitializingBean的 afterPropertiesSet方法"); 
    }
}
复制代码

3⃣ 经过JSR250规范提供的注解 @PostConstruct 和 @ProDestory 标注的方法

@Component
public class Book {
    public Book() {
        System.out.println("book 的构造方法");
    }
    
    @PostConstruct 
    public void init() {
        System.out.println("book 的PostConstruct标志的方法"); 
   }
   
    @PreDestroy
    public void destory() {
        System.out.println("book 的PreDestory标注的方法"); 
    }
}
复制代码

4⃣ 经过Spring的BeanPostProcessor的 bean的后置处理器会拦截全部bean建立过程

postProceessBeforInitialization 在init方法以前调用

postProcessAfterInitialization 在init方法以后调用

@Component
public class NiuhBeanPostProcessor implements BeanPostProcessor {
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("TulingBeanPostProcessor...postProcessBeforeInitialization:"+beanName);
        return bean; 
    }
    
    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        System.out.println("TulingBeanPostProcessor...postProcessAfterInitialization:"+beanName);
        return bean; 
    }
}
复制代码

BeanPostProcessor 的执行时机

populateBean(beanName, mbd, instanceWrapper) 
initializeBean{
    applyBeanPostProcessorsBeforeInitialization() 
    invokeInitMethods{
        isInitializingBean.afterPropertiesSet
    自定义的init方法 
    }
    applyBeanPostProcessorsAfterInitialization()方法 
}
复制代码

八、经过@Value + @PropertySource来给组件赋值

public class Person {
    //经过普通的方式 
    @Value("一角钱")
    private String firstName;
    
    //spel方式来赋值 
    @Value("#{28-8}")
    private Integer age; 
    
   经过读取外部配置文件的值 
   @Value("${person.lastName}") 
   private String lastName;
}

@Configuration
@PropertySource(value = {"classpath:person.properties"}) //指定外部文件的位置 
public class MainConfig {
    @Bean
    public Person person() {
        return new Person();
    }
}
复制代码

九、自动装配

@AutoWired的使用

自动注入：

//一个Dao
@Repository
public class NiuhDao { 
}

@Service
public class NiuhService {
    @Autowired
    private NiuhDao niuhDao;
}
复制代码

结论：

1⃣ 自动装配首先按照类型进行装配，若在IOC容器中发现了多个相同类型的组件，那么就按照属性名称来进行装配

@Autowired

private NiuhDao niuhDao;
复制代码

好比，容器中有二个NiuhDao类型的组件，一个叫niuhDao，一个叫niuhDao2

那么咱们经过@AutoWired 来修饰的属性名称时niuhDao，那么就加载容器的niuhDao组件，若属性名称为niuhDao2那么就加载niuhDao2组件。

2⃣ 假设咱们须要指定特定的组件来进行装配，咱们能够经过使用@Qualifilter("niuhDao")来指定装配的组件或者在配置类上的@Bean加上@Primary注解

@Autowired 
@Qualifier("niuhDao") 
private NiuhDao niuhDao2;
复制代码

3⃣ 假设容器中即没有niuhDao 和 niuhDao2，那么在装配的时候就会抛出异常

No qualifying bean of type 'com.niuh.testautowired.NiuhDao' available

若咱们想不抛异常，咱们须要指定 required为false的时候能够了

@Autowired(required = false)
@Qualifier("niuhDao") 
private NiuhDao niuhDao2;
复制代码

4⃣ @Resource （JSR250规范）

功能和@AutoWired的功能差很少同样，可是不支持@Primary 和@Qualifier的支持

5⃣ @InJect （JSR330规范）

须要导入jar包以来，功能支持@Primary功能 ,可是没有Require=false的功能

<dependency>
    <groupId>javax.inject</groupId>
    <artifactId>javax.inject</artifactId>
    <version>1</version>
</dependency>
复制代码

6⃣ 使用autowired 能够标注在方法上

标注在set方法上

//@Autowired
public void setNiuhLog(NiuhLog niuhLog) {
    this.niuhLog = niuhLog; 
}
复制代码

标注在构造方法上

@Autowired
public NiuhAspect(NiuhLog niuhLog) {
    this.niuhLog = niuhLog; 
}
复制代码

标注在配置类上的入参中（能够不写）

@Bean
public NiuhAspect niuhAspect(@Autowired NiuhLog niuhLog) {
    NiuhAspect niuhAspect = new NiuhAspect(niuhLog);
    return niuhAspect; 
}
复制代码

十、咱们本身的组件须要使用spring ioc 的底层组件的时候，好比ApplicationContext等，咱们能够经过实现XXXAware接口来实现

@Component
public class NiuhCompent implements ApplicationContextAware,BeanNameAware {
    private ApplicationContext applicationContext;
    
    @Override
    public void setBeanName(String name) {
        System.out.println("current bean name is :【"+name+"】");
    }
    
    @Override
    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        this.applicationContext = applicationContext; 
    }
}
复制代码

十一、经过@Profile 注解来根据环境激活标识不一样的Bean

@Profile 标识在类上，那么只有当前环境匹配，整个配置类才会生效

@Profile 标识在Bean上，那么只有当前环境的Bean才会被激活

没有标志为@Profile的bean 无论在什么环境均可以被激活

@Configuration
@PropertySource(value = {"classpath:ds.properties"})
public class MainConfig implements EmbeddedValueResolverAware {
    @Value("${ds.username}")
    private String userName;
     
    @Value("${ds.password}") 
    private String password;
    
   private String jdbcUrl; 
   
   private String classDriver;
   
    @Override
    public void setEmbeddedValueResolver(StringValueResolver resolver) {
        this.jdbcUrl = resolver.resolveStringValue("${ds.jdbcUrl}");
        this.classDriver = resolver.resolveStringValue("${ds.classDriver}"); 
    }
    
    //标识为测试环境才会被装配 @Bean
    @Profile(value = "test")
    public DataSource testDs() {
        return buliderDataSource(new DruidDataSource()); 
    }
    
    //标识开发环境才会被激活 @Bean
    @Profile(value = "dev")
    public DataSource devDs() {
        return buliderDataSource(new DruidDataSource());
    }
    
    //标识生产环境才会被激活 @Bean
    @Profile(value = "prod")
    public DataSource prodDs() {
        return buliderDataSource(new DruidDataSource());
    }

    private DataSource buliderDataSource(DruidDataSource dataSource) { 
        dataSource.setUsername(userName); 
        dataSource.setPassword(password); 
        dataSource.setDriverClassName(classDriver); 
        dataSource.setUrl(jdbcUrl);
        return dataSource; 
    }
}
复制代码

激活切换环境的方法

方法一：经过运行时jvm参数来切换 -Dspring.profiles.active=test|dev|prod

方法二：经过代码方式来激活

public static void main(String[] args) {
    AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext(); 
    ctx.getEnvironment().setActiveProfiles("test","dev");
    ctx.register(MainConfig.class); 
    ctx.refresh(); 
    printBeanName(ctx);
}
复制代码