# Spring 5
- for reactive
- Reactive
  - https://www.reactivemanifesto.org
  - https://www.reactive-streams.org
- Responsive(반응), Resilient(탄력), Elastic(유연), Message Driven(메시지)
- Non-blocking io
- Spring WebFlux

- <img src="images/diagram-reactive.webp" alt="reactive" class="img"/>

## JavaEE 지원
- Servlet API ([JSR 340](https://jcp.org/en/jsr/detail?id=340))
- WebSocket API ([JSR 356](https://jcp.org/en/jsr/detail?id=356))
- Concurrency Utilities ([JSR 236](https://jcp.org/en/jsr/detail?id=236))
- JSON Binding API ([JSR 367](https://jcp.org/en/jsr/detail?id=367))
- Bean Validation ([JSR 303](https://jcp.org/en/jsr/detail?id=303))
- JPA ([JSR 338](https://jcp.org/en/jsr/detail?id=338))
- JMS ([JSR 914](https://jcp.org/en/jsr/detail?id=914))
- JTA/JCA setups for transaction coordination, if necessary.
- Dependency Injection ([JSR 330](https://jcp.org/en/jsr/detail?id=330))
- Common Annotations ([JSR 250](https://jcp.org/en/jsr/detail?id=250))

## Core Technologies
- https://docs.spring.io/spring/docs/5.0.0.RELEASE/spring-framework-reference/core.html#spring-core

### The IoC container
```
1.1. Introduction to the Spring IoC container and beans
1.2. Container overview
1.3. Bean overview
1.4. Dependencies
1.5. Bean scopes
1.6. Customizing the nature of a bean
1.7. Bean definition inheritance
1.8. Container Extension Points
1.9. Annotation-based container configuration
1.10. Classpath scanning and managed components
1.11. Using JSR 330 Standard Annotations
1.12. Java-based container configuration
1.13. Environment abstraction
1.14. Registering a LoadTimeWeaver
1.15. Additional Capabilities of the ApplicationContext
1.16. The BeanFactory
```

### Resources
```
2.1. Introduction
2.2. The Resource interface
2.3. Built-in Resource implementations
2.4. The ResourceLoader
2.5. The ResourceLoaderAware interface
2.6. Resources as dependencies
2.7. Application contexts and Resource paths
```

### Validation, Data Binding, and Type Conversion
```
3.1. Introduction
3.2. Validation using Spring’s Validator interface
3.3. Resolving codes to error messages
3.4. Bean manipulation and the BeanWrapper
3.5. Spring Type Conversion
3.6. Spring Field Formatting
3.7. Configuring a global date & time format
3.8. Spring Validation
```

### Spring Expression Language (SpEL)
```
4.1. Introduction
4.2. Feature Overview
4.3. Expression Evaluation using Spring’s Expression Interface
4.4. Expression support for defining bean definitions
4.5. Language Reference
4.6. Classes used in the examples
```
### Aspect Oriented Programming with Spring
```
5.1. Introduction
5.2. @AspectJ support
5.3. Schema-based AOP support
5.4. Choosing which AOP declaration style to use
5.5. Mixing aspect types
5.6. Proxying mechanisms
5.7. Programmatic creation of @AspectJ Proxies
5.8. Using AspectJ with Spring applications
5.9. Further Resources
```

### Spring AOP APIs
```
6.1. Introduction
6.2. Pointcut API in Spring
6.3. Advice API in Spring
6.4. Advisor API in Spring
6.5. Using the ProxyFactoryBean to create AOP proxies
6.6. Concise proxy definitions
6.7. Creating AOP proxies programmatically with the ProxyFactory
6.8. Manipulating advised objects
6.9. Using the "auto-proxy" facility
6.10. Using TargetSources
6.11. Defining new Advice types
6.12. Further resources
```

### Null-safety
```
7.1. Use cases
7.2. JSR 305 meta-annotations
```