Spring Framework 5 Core 学习笔记

IoC 容器

Bean 的作用域

作用域	使用	描述
singleton	@Scope("singleton")	IoC 容器（ApplicationContext）范围单例
prototype	@Scope("prototype")	每次获取该 Bean 都会 new 一个新的对象返回
request	@Scope("request") 或 @RequestScope	单次 HTTP 请求范围单例
session	@Scope("session") 或 @SessionScope	单个 HTTP 会话范围单例
application	@Scope("application") 或 @ApplicationScope	Web 应用（ServletContext）范围单例
websocket	@Scope("websocket")	单个 WebSocket 会话范围单例

1. 自定义作用域

   实现 org.springframework.beans.factory.config.Scope 接口，并将其对象注册到 BeanFactory 中，然后即可通过 @Scope("...") 方式使用。
   Spring 内置了一个线程范围单例作用域 org.springframework.context.support.SimpleThreadScope ，但默认没有注册，可通过如下方式注册：

    @Bean
    public static CustomScopeConfigurer customScopeConfigurer() {
        CustomScopeConfigurer customScopeConfigurer = new CustomScopeConfigurer();
        customScopeConfigurer.addScope("thread", new SimpleThreadScope());
        return customScopeConfigurer;
    }
   

2. 当在 singleton Bean 中注入短作用域 Bean 时，需要通过 AOP 为短作用域 Bean 生成代理 Bean，才能确保在 singleton Bean 中每次获取到最新的短作用域 Bean。配置 @Scope 注解的 proxyMode 属性即可。比如：

    @Scope(value = "prototype", proxyMode = ScopedProxyMode.TARGET_CLASS)
   

   proxyMode 属性可配置值如下：

   代理模式	描述
   ScopedProxyMode.DEFAULT	默认值，等同于 NO
   ScopedProxyMode.NO	不创建代理
   ScopedProxyMode.INTERFACES	通过实现接口的方式生成代理（JDK），注入到接口时适用
   ScopedProxyMode.TARGET_CLASS	通过继承的方式生成代理（CGLIB），非 final 类适用

Bean 的生命周期

1. 在 Spring 管理的 Bean 中，可以使用 @PostConstruct 和 @PreDestroy 注解标注需要在 Bean 初始化之后和销毁之前需要执行的方法。比如：

    @Service
    public class Foo {
    
        @PostConstruct
        public void init() {
            // 该方法会在 Bean 初始化完成、装载所有依赖之后、AOP 拦截器应用到该 Bean 之前执行
        }
        
        @PreDestroy
        public void destroy() {
            // 该方法会在 Bean 销毁之前执行
        }
    }
   

2. 通过 @Bean 注解的 initMethod 和 destroyMethod 属性指定初始化之后和销毁之前需要执行的方法。比如：

    public class Foo {
    
        public void init() {
            // initialization logic
        }
    }
    
    public class Bar {
    
        public void cleanup() {
            // destruction logic
        }
    }
    
    @Configuration
    public class AppConfig {
    
        @Bean(initMethod = "init")
        public Foo foo() {
            return new Foo();
        }
    
        @Bean(destroyMethod = "cleanup")
        public Bar bar() {
            return new Bar();
        }
    }
   

   注意： 如果不指定 @Bean 注解的 destroyMethod 属性，默认以 public 类型的 close 方法或 shutdown 方法作为销毁方法。如果开发者的类中有这些方法且不希望作为销毁方法，需指定 destroyMethod = ""。

3. 让 Bean 实现 InitializingBean 和 DisposableBean 接口，afterPropertiesSet() 方法和 destroy() 方法会在该 Bean 初始化之后和销毁之前执行。比如：

    @Compenent
    public class AnotherExampleBean implements InitializingBean, DisposableBean {
   
        @Override
        public void afterPropertiesSet() {
            // do some initialization work
        }
   
        @Override
        public void destroy() {
            // do some destruction work (like releasing pooled connections)
        }
    }
   

@Autowired

1. @Autowired 注解可用在 Bean 的有参构造函数上。如果只有一个有参构造函数，该注解可省略；如果有多个有参构造函数（且无无参构造函数），必须在其中一个构造函数上声明。

2. @Autowired 注解也可用在数组、Set 等数据结构上。比如：

    @Component
    public class MovieRecommender {
    
        @Autowired
        private MovieCatalog[] movieCatalogs;
    
        @Autowired
        private Set movieCatalogs;
    }
   

   目标 Bean 即 MovieCatalog 可通过实现 org.springframework.core.Ordered 接口、使用 @Order 注解指定其在数组、List 中的顺序，默认为注册顺序。

3. @Autowired 注解也可用在 Map 上（Map 的 Key 必须为 String 类型）。

4. @Autowired 注解标注的属性或方法如果没有找到可装载的 Bean，Spring 会抛出异常，与 @Required 注解作用相同。如下三种方式可避免异常抛出：

    @Component
    public class SimpleMovieLister {
    
        @Autowired(required = false)
        public void setMovieFinder(MovieFinder movieFinder) {
            ...
        }
    
        @Autowired
        public void setMovieFinder(Optional movieFinder) {
            ... // Java 8 支持
        }
    
        @Autowired
        public void setMovieFinder(@Nullable MovieFinder movieFinder) {
            ... // Spring Framework 5.0 支持
        }
    }
   

@Primary

@Autowired 注解基于类型自动装载，当有多个类型匹配的 Bean 可供装载但只需要装载一个时，Spring 会优先装载 @Primary 注解标注的目标 Bean。

@Qualifier

1. @Autowired 注解基于类型自动装载，当有多个类型匹配的 Bean 可供装载但只需要装载一个时，可配合使用 @Qualifier 注解（的 value 属性）指定目标 Bean 的名称。

2. 当需要装载到数组、List、Set、Map 等数据结构时，也可配合使用 @Qualifier 注解缩小装载范围。

@Component、@Repository、@Service、@Controller

@Component 注解标注当前类为受 Spring 管理的通用组件，@Repository、@Service、@Controller 是 @Component 的特殊形式，分别对应持久层、服务层、表现层，方便对每个层进行针对性的拓展。

@Profile

@Profile 注解表示当前组件在何种 Environment 下适用。只有满足当前 Environment 的组件才会被注册到 Spring 的上下文中。比如为开发和生产环境指定不同的数据源：

@Configuration
@Profile("dev")
public class StandaloneDataConfig {

    @Bean
    public DataSource dataSource() {
        return new EmbeddedDatabaseBuilder()
            .setType(EmbeddedDatabaseType.HSQL)
            .addScript("classpath:com/bank/config/sql/schema.sql")
            .addScript("classpath:com/bank/config/sql/test-data.sql")
            .build();
    }
}

@Configuration
@Profile("production")
public class JndiDataConfig {

    @Bean(destroyMethod="")
    public DataSource dataSource() throws Exception {
        Context ctx = new InitialContext();
        return (DataSource) ctx.lookup("java:comp/env/jdbc/datasource");
    }
}

@Profile 注解也可以在方法级别使用：

@Configuration
public class AppConfig {

    @Bean("dataSource")
    @Profile("development")
    public DataSource standaloneDataSource() {
        return new EmbeddedDatabaseBuilder()
            .setType(EmbeddedDatabaseType.HSQL)
            .addScript("classpath:com/bank/config/sql/schema.sql")
            .addScript("classpath:com/bank/config/sql/test-data.sql")
            .build();
    }

    @Bean("dataSource")
    @Profile("production")
    public DataSource jndiDataSource() throws Exception {
        Context ctx = new InitialContext();
        return (DataSource) ctx.lookup("java:comp/env/jdbc/datasource");
    }
}

通过配置 Environment 属性 spring.profiles.active 来激活 Profile。比如在 Spring Boot 中配置 application.properties：

spring.profiles.active=dev

如果没有指定需要激活的 Profile，Spring 会激活名为 default 的默认 Profile，如下配置会生效：

@Configuration
@Profile("default")
public class DefaultDataConfig {

    @Bean
    public DataSource dataSource() {
        return new EmbeddedDatabaseBuilder()
            .setType(EmbeddedDatabaseType.HSQL)
            .addScript("classpath:com/bank/config/sql/schema.sql")
            .build();
    }
}

@PropertySource

@PropertySource 注解提供了一种方便的机制来将 PropertySource 增加到 Spring 的 Environment 之中：

# /com/myco/app.properties
testbean.name=myTestBean

@Configuration
@PropertySource("classpath:/com/myco/app.properties")
public class AppConfig {
    @Autowired
    Environment env;

    @Bean
    public TestBean testBean() {
        TestBean testBean = new TestBean();
        testBean.setName(env.getProperty("testbean.name"));
        return testBean;
    }
}

@Value

@Value 注解可以将 Environment 中的属性注入到对象属性中：

@Value("${testbean.name}")
private String testBeanName;

@ConfigurationProperties（Spring Boot 特性）

Spring Boot 的 @ConfigurationProperties 注解可以很方便的将属性批量注入到一个配置对象中：

# /com/myco/app.properties
my.name=example
my.port=8080
my.servers[0]=dev.bar.com
my.servers[1]=foo.bar.com

@Compenent  
@PropertySource("classpath:/com/myco/app.properties")
@ConfigurationProperties(prefix="my")
public class Config {
    private String name;
    private Integer port;
    private List servers = new ArrayList();

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getPort() {
        return port;
    }

    public void setPort(Integer port) {
        this.port = port;
    }

    public List getServers() {
        return servers;
    }

    public void setServers(List servers) {
        this.servers = servers;
    }
}

事件

ApplicationContext 中的事件处理是通过 ApplicationEvent 类和 ApplicationListener 接口提供的。 如果一个实现 ApplicationListener 接口的 Bean 被部署到上下文中，则每当 ApplicationEvent 发布到 ApplicationContext 时，都会通知该 Bean。本质上，这是标准的观察者模式。

Spring 提供了以下几种标准事件：

事件	描述
ContextRefreshedEvent	在 ApplicationContext 初始化或刷新时发布。例如，使用 ConfigurableApplicationContext 接口上的 refresh() 方法。 这里的“初始化”意味着所有的 Bean 都被加载，检测并激活后置处理器 Bean，单例被预先实例化，并且 ApplicationContext 对象已经可以使用了。 只要上下文没有关闭，只要所选的 ApplicationContext 实际上支持这种“热”刷新，刷新可以被触发多次。例如，XmlWebApplicationContext 支持热刷新，但 GenericApplicationContext 不支持。
ContextStartedEvent	在 ApplicationContext 启动时发布，使用 ConfigurableApplicationContext 接口上的 start() 方法时。这里的“开始”意味着所有的生命周期 Bean 都会收到明确的启动信号。通常，这个信号用于在显式停止后重新启动 Bean，但也可以用于启动尚未配置为自动启动的组件，例如尚未启动的组件。
ContextStoppedEvent	在 ApplicationContext 停止时发布，使用 ConfigurableApplicationContext 接口上的 stop() 方法时。 这里“停止”意味着所有生命周期的 Bean 都会收到明确的停止信号。 停止的上下文可以通过 start() 调用重新启动。
ContextClosedEvent	在 ApplicationContext 关闭时发布，在 ConfigurableApplicationContext 接口上使用 close() 方法时。 这里的“关闭”意味着所有的单例 Bean 被销毁。 一个关闭的上下文到达其生命的尽头; 它不能刷新或重新启动。
RequestHandledEvent	一个 Web 特定的事件，告诉所有的 Bean 一个 HTTP 请求已被处理。 此事件在请求完成后发布。 此事件仅适用于使用 Spring 的 DispatcherServlet 的 Web 应用程序。

可通过继承 ApplicationEvent 自定义事件：

public class BlackListEvent extends ApplicationEvent {

    private final String address;
    private final String test;

    public BlackListEvent(Object source, String address, String test) {
        super(source);
        this.address = address;
        this.test = test;
    }

    // accessor and other methods...
}

可通过调用 ApplicationEventPublisher 的 publishEvent() 方法发布事件：

@Service
public class EmailService implements ApplicationEventPublisherAware {

    private List blackList;
    private ApplicationEventPublisher publisher;

    public void setBlackList(List blackList) {
        this.blackList = blackList;
    }

    public void setApplicationEventPublisher(ApplicationEventPublisher publisher) {
        this.publisher = publisher;
    }

    public void sendEmail(String address, String text) {
        if (blackList.contains(address)) {
            BlackListEvent event = new BlackListEvent(this, address, text);
            publisher.publishEvent(event);
            return;
        }
        // send email...
    }
}

可通过 ApplicationListener 的 onApplicationEvent(event) 回调方法处理事件：

@Component
public class BlackListNotifier implements ApplicationListener {

    private String notificationAddress;

    public void setNotificationAddress(String notificationAddress) {
        this.notificationAddress = notificationAddress;
    }

    public void onApplicationEvent(BlackListEvent event) {
        // notify appropriate parties via notificationAddress...
    }
}

也可通过 @EventListener 注解标注的方法处理事件：

@EventListener
public void processBlackListEvent(BlackListEvent event) {
    // notify appropriate parties via notificationAddress...
}

修改方法返回事件类型即可支持处理完当前事件后发布另一个事件：

@EventListener
public ListUpdateEvent handleBlackListEvent(BlackListEvent event) {
    // notify appropriate parties via notificationAddress and
    // then publish a ListUpdateEvent...
}

使用 @Async 注解异步处理事件：

@EventListener
@Async
public void processBlackListEvent(BlackListEvent event) {
    // BlackListEvent is processed in a separate thread
}

注意：

1. 异步处理事件的方法抛出的异常不会被发布者接收到
2. 异步处理事件的方法不能通过返回事件类型的对象发布新的事件

使用 @Order 注解指定事件处理方法调用的优先级：

@EventListener
@Order(42)
public void processBlackListEvent(BlackListEvent event) {
    // notify appropriate parties via notificationAddress...
}

类型转换、字段格式化与验证

使用 BeanWrapper 操作 JavaBeans

JavaBean 是指遵循统一标准的简单类，拥有无参构造器，所有属性都有遵循命名约定的 getter/setter 方法。举例来说：名为 bingoMadness 的属性将具有 getBingoMadness() 和 setBingoMadness(...) 方法。

Spring 提供了 BeanWrapper 接口和它的实现类 BeanWrapperImpl，可以以一种通用便捷的方式操作 JavaBean。

1. 使用 getPropertyValue 和 setPropertyValues 方法对 JavaBean 的属性进行读写操作。

   支持如下表达式：

   表达式	描述
   name	标示名为 name 的属性，对应的方法 getName()/isName() 和 setName(...)
   account.name	标示名为 account 的属性的嵌套属性 name，对应的方法如 getAccount().getName() 和 getAccount().setName()
   account[2]	标示名为 account 的属性的第 3 个元素，该属性可以是数组、列表或者其它有自然顺序的集合
   account[COMPANYNAME]	标示名为 account 的属性的 key 为 COMPANYNAME 键值对对应的 value 值，该属性可以是 Map

   假设有如下两个类：

    public class Company {
   
        private String name;
        private Employee managingDirector;
   
        public String getName() {
            return this.name;
        }
   
        public void setName(String name) {
            this.name = name;
        }
   
        public Employee getManagingDirector() {
            return this.managingDirector;
        }
   
        public void setManagingDirector(Employee managingDirector) {
            this.managingDirector = managingDirector;
        }
    }
   
    public class Employee {
   
        private String name;
   
        private float salary;
   
        public String getName() {
            return this.name;
        }
   
        public void setName(String name) {
            this.name = name;
        }
   
        public float getSalary() {
            return salary;
        }
   
        public void setSalary(float salary) {
            this.salary = salary;
        }
    }
   

   下列代码展示了如何检索和操作 Companies 和 Employees 属性：

    BeanWrapper company = new BeanWrapperImpl(new Company());
    // setting the company name..
    company.setPropertyValue("name", "Some Company Inc.");
    // ... can also be done like this:
    PropertyValue value = new PropertyValue("name", "Some Company Inc.");
    company.setPropertyValue(value);
   
    // ok, let's create the director and tie it to the company:
    BeanWrapper jim = new BeanWrapperImpl(new Employee());
    jim.setPropertyValue("name", "Jim Stravinsky");
    company.setPropertyValue("managingDirector", jim.getWrappedInstance());
   
    // retrieving the salary of the managingDirector through the company
    Float salary = (Float) company.getPropertyValue("managingDirector.salary");
   

类型转换

1. 类型转换器 Converter

    package org.springframework.core.convert.converter;
   
    public interface Converter {
        T convert(S source);
    }
   

   通过实现 Converter 接口可以定义自己的类型转换器。范型 S 表示需要转换的类型，范型 T 表示转换成的类型。
   下面是一个简单的例子，定义了一个可以将 String 对象转成 Integer 对象的转换器：

    final class StringToInteger implements Converter {
        public Integer convert(String source) {
            return Integer.valueOf(source);
        }
    }
   

   注意：convert 方法的入参不能为 null，如果入参不符合要求，应该抛出 IllegalArgumentException 异常。如果转换失败，可以抛出非检查型异常。

2. 类型转换器工厂 ConverterFactory

    package org.springframework.core.convert.converter;
    
    public interface ConverterFactory {
         Converter getConverter(Class targetType);
    }
   

   当开发者需要集中整个类层次结构的转换逻辑时，可以实现 ConverterFactory 接口。范型 S 表示需要转换的类型，范型 R 表示转换成的类型的范围，范型 T 表示转换成的具体类型，T 是 R 的子类。
   比如，将 String 对象转换成 java.lang.Enum 对象的转换器工厂：

    package org.springframework.core.convert.support;
    
    final class StringToEnumConverterFactory implements ConverterFactory {
    
        public  Converter getConverter(Class targetType) {
            return new StringToEnumConverter(targetType);
        }
    
        private final class StringToEnumConverter implements Converter {
    
            private Class enumType;
    
            public StringToEnumConverter(Class enumType) {
                this.enumType = enumType;
            }
    
            public T convert(String source) {
                return (T) Enum.valueOf(this.enumType, source.trim());
            }
        }
    }
   

3. 通用类型转换器 GenericConverter

    package org.springframework.core.convert.converter;
    
    public interface GenericConverter {
        public Set getConvertibleTypes();
        Object convert(Object source, TypeDescriptor sourceType, TypeDescriptor targetType);
    }
   

   当开发者需要设计一个复杂的通用转换器，可以转换多种类型到多种类型时，可以实现 GenericConverter 接口。
   getConvertibleTypes 方法返回所有支持的源类型和目标类型键值对。调用 convert 方法时，需要提供源类型和目标类型的类型描述 TypeDescriptor 对象。
   ArrayToCollectionConverter 是一个很好的例子，用于把数组转换成集合：

    package org.springframework.core.convert.support;
   
    final class ArrayToCollectionConverter implements ConditionalGenericConverter {
   
        // ...
   
        @Override
        public Set getConvertibleTypes() {
            return Collections.singleton(new ConvertiblePair(Object[].class, Collection.class));
        }
   
        @Override
        public boolean matches(TypeDescriptor sourceType, TypeDescriptor targetType) {
            return ConversionUtils.canConvertElements(
                    sourceType.getElementTypeDescriptor(), targetType.getElementTypeDescriptor(), this.conversionService);
        }
   
        @Override
        @Nullable
        public Object convert(@Nullable Object source, TypeDescriptor sourceType, TypeDescriptor targetType) {
            if (source == null) {
                return null;
            }
   
            int length = Array.getLength(source);
            TypeDescriptor elementDesc = targetType.getElementTypeDescriptor();
            Collection