每个bean都有一个或多个标识符,这些标识符在容器内必须是唯一的。一个bean一般只有一个标识符,如果需要多个的话,额外的可以认为是别名。
基于xml的配置元数据,使用id,name都可以来标识bean。属性id是一个精确的标识。一般,名称使用字母数字,特殊字符也可以。如果你想要引进bean的别名,可以使用name属性,使用逗号,分号或空格隔离。在spring3.1版本之前,id被定义为xsd:ID类型,限制了可能的字符。从3.1开始,被定义为xsd:string类型。bean的id唯一性由容器保证,不在由xml解析器执行。
bean的id和name不是必需的。如果不显示提供,容器为指定一个唯一的name。然而,如果你想用ref元素或服务定位模式通过name来引用bean,那么必须提供一个name。不提供name的场景适合内部类和自动装配。
>:-: **bean命名规则**
>
>bean的命名规则使用java实例的属性命名规则。即小写字母开头,驼峰式。例如(不带引号):'accountManager', 'accountService', 'userDao', 'loginController'。
>
>按规则命名,会使你的配置可读性更高和便于理解,如果你使用spring aop,bean按规则命名会有很大帮助。
>
>通过类路径的组件扫描,spring按照以上规则,对未命名的组件生成名称:本质上就是把简单类名首字母改成小写。然而,特殊场景下当类名有多个字母且强两个都是大写的时候,则保留原名。这和spring在用的规则`java.beans.Introspector.decapitalize`一样
>
## Aliasing a bean outside the bean definition
标识一个bean,可以使用属性id和name,id只能有一个值,name可以有多个值。这些name的值就是bean的别名,别名在某些场景下很有用,如每个模块可以使用特定的name值来标识引用的公共依赖。
然而,在定义bean的时候把所有的别名都指定是不够的。有时候需要在别处为bean定义别名。在大型系统中通常是这样的,配置信息分布在各个子系统中,每个子系统有自己的对象定义。在xml配置元数据中,可以使用`<alias/>`来完成这个操作。
~~~xml
<alias name="fromName" alias="toName"/>
~~~
在上面这个示例中,容器中name为fromName的bean,在使用别名定义之后,toName也引用了此bean。
例如,子系统A通过name为`subsystemA-dataSource`引用数据源。子系统B通过name为`subsystemB-dataSource`引用同样的数据源。主系统包含这两个子系统,同时通过`myApp-dataSource`引用同样的数据源。总共有3个name引用了同样的数据源对象,要在主系统中添加如下配置
~~~xml
<alias name="subsystemA-dataSource" alias="subsystemB-dataSource"/>
<alias name="subsystemA-dataSource" alias="myApp-dataSource" />
~~~
现在,每个组件和主应用都能使用一个唯一的name来指定同一个DataSource,并保证和其他定义不冲突(有效的创建命名空间)。
> :-: java-configuration
>
> 如果使用java语言配置,可以使用@Bean注解提供别名。参考[@bean](https://docs.spring.io/spring/docs/5.0.6.RELEASE/spring-framework-reference/core.html#beans-java-bean-annotation)
- 正确打开本书的姿势
- 第一部分 Core
- 1. Ioc container
- 1.1. Introduction to the Spring IoC container and beans
- 1.2. Container overview
- 1.2.1. Configuration metadata
- 1.2.2. Instantiating a container
- 1.2.3. Using the container
- 1.3. Bean overview
- 1.3.1. Naming beans
- 1.3.2. Instantiating beans
- 1.4. Dependencies
- 1.4.1. Dependency Injection
- 1.4.2. Dependencies and configuration in detail
- 1.4.3. Using depends-on
- 1.4.4. Lazy-initialized beans
- 1.4.5. Autowiring collaborators
- 1.4.6. Method injection
- 1.5 Bean Scopes
- 1.6. Customizing the nature of a bean TODO
- 1.7. Bean definition inheritance TODO
- 1.8. Container Extension Points TODO
- 1.9. Annotation-based container configuration
- 1.9.1. @Required
- 1.9.2. @Autowired
- 1.9.3. Fine-tuning annotation-based autowiring with @Primary
- 1.9.4. Fine-tuning annotation-based autowiring with qualifiers TODO
- 1.9.5. Using generics as autowiring qualifiers TODO
- 1.9.6. CustomAutowireConfigurer TODO
- 1.10. Classpath scanning and managed components
- 1.10.1. @Component and further stereotype annotations
- 1.11. Using JSR 330 Standard Annotations TODO
- 1.12. Java-based container configuration
- 1.12.1. Basic concepts: @Bean and @Configuration
- 1.12.2. Instantiating the Spring container using AnnotationConfigApplicationContext
- 2. Resources
- 2.1. Introduction
- 2.2. The Resource interface
- 2.3. Built-in Resource implementations
- 2.3.1. UrlResource
- 2.3.2. ClassPathResource
- 2.3.3. FileSystemResource
- 2.3.4. ServletContextResource
- 2.3.5. InputStreamResource
- 2.3.6. ByteArrayResource
- 2.4. The ResourceLoader
- 2.5. The ResourceLoaderAware interface
- 2.6. Resources as dependencies
- 2.7. Application contexts and Resource paths
- 2.7.1. Constructing application contexts
- 2.7.2. Wildcards in application context constructor resource paths
- 2.7.3. FileSystemResource caveats
- 3. Validation, Data Binding, and Type Conversion
- 4. Spring Expression Language (SpEL)
- 5. Aspect Oriented Programming with Spring
- 5.1. Introduction
- 5.1.1. AOP concepts
- 5.1.2. Spring AOP capabilities and goals
- 5.1.3. AOP Proxies
- 5.2. @AspectJ support
- 5.2.1. Enabling @AspectJ Support
- 5.2.2. Declaring an aspect
- 5.2.3. Declaring a pointcut
- 5.2.4. Declaring advice
- 5.2.5. Introductions TODO
- 5.2.6. Aspect instantiation models TODO
- 5.2.7. Example
- 5.3. Schema-based AOP support TODO
- 5.4. Choosing which AOP declaration style to use TODO
- 5.5. Mixing aspect types TODO
- 5.6. Proxying mechanisms
- 5.6.1. Understanding AOP proxies
- 5.7. Programmatic creation of @AspectJ Proxies
- 5.8. Using AspectJ with Spring applications
- 5.8.1. Using AspectJ to dependency inject domain objects with Spring
- 5.8.2. Other Spring aspects for AspectJ
- 第二部分 Testing
- 第三部分 Data Access
- 1. Transaction Management
- 1.1. Introduction to Spring Framework transaction management
- 1.2 Advantages of the Spring Framework’s transaction support model
- 1.2.1. Global transactions
- 1.2.2. Local transactions
- 1.2.3. Spring Framework’s consistent programming model
- 1.3. Understanding the Spring Framework transaction abstraction
- 1.4. Synchronizing resources with transactions
- 1.4.1. High-level synchronization approach
- 1.4.2. Low-level synchronization approach
- 1.4.3. TransactionAwareDataSourceProxy
- 1.5. Declarative transaction management
- 1.5.1. Understanding the Spring Framework’s declarative transaction implementation
- 1.5.2. Example of declarative transaction implementation
- 1.5.3. Rolling back a declarative transaction
- 1.5.4. Configuring different transactional semantics for different beans
- 1.5.5. tx:advice元素的 settings
- 1.5.6. Using @Transactional
- 1.5.7. Transaction propagation
- 1.5.8. Advising transactional operations
- 1.5.9. Using @Transactional with AspectJ TODO
- 第四部分 web servlet
- 第五部分 Web Reactive
- 第六部分 Integration
- 第七部分 Languages