系列文章:Spring:IoC、AOP 与事务 的第 1 篇。
Spring
- Spring是一个轻量级的IoC和AOP容器框架。是为Java应用程序提供基础性服务的一套框架,目的是用于简化企业应用程序的开发,它使得开发者只需要关心业务需求。
Spring IOC = Spring Bean + Spring Context特性
- 主要由以下几个模块组成:
- Spring Core:核心类库,提供IOC服务
- Spring Context:提供框架式的Bean访问方式,以及企业级功能(JNDI、定时任务等)
- Spring AOP:AOP服务切面编程
- Spring Type Conversion:类型转换
- Spring Data Binding :数据绑定
- Spring Express Language:Spring 表达式
- Spring Resources:资源管理
- Spring Events:事件
- Spring i18n:国际化
- Spring Validation:校验
- Spring Data Access:数据存储
- JDBC Java API:对JDBC的抽象,简化了数据访问异常的处理
- Transactions:事务抽象 EJB简化版本
- O/R Mapping:映射
- DAO Support:对JDBC的抽象,简化了数据访问异常的处理
- XML Marshalling 编列
- Spring Integration
- Remoting:远程调用
- JMS:Java消息服务
- JCA:Java连接架构
- JMS:Java管理扩展
- Email:Java 邮件客户端
- Tasks:本地任务
- Scheduling:本地调度
- Caching:缓存抽象
- Test : Spring 测试
- Mock Objects:模拟对象框架
- Test Context Framework:TestContext框架
- Spring Mvc Test:Spring MVC 测试
- WebTestClient :Web 测试客户端
- Spring Web:提供了基本的面向Web的综合特性,例如多方文件上传
- Spring Servlet Support
- Spring MVC:提供面向Web应用的Model-View-Controller实现
- WebSocket
- SockJS
- Spring Reactive
- Spring WebFlux
- WebClient
- WebSocket
- Spring Servlet Support
Spring 编程模型
- 面向对象
- 契约接口:Aware、BeanPostProcess
- 设计模式:观察者、组合模式、模版模式
- 面向切面
- 动态代理:JdkDynamicAopProxy
- 字节码提升:ASM、CGLib、AspectJ
- 面向元编程
- 注解:模式注解 @Component @Service
- 配置:Environment抽象、PropertySources
- 范型:GenericTypeResolver
- 函数驱动
- ApplicationEventPubilsher
- Reactive Spring WebFlux
- 模块驱动
- Maven Artifacts
- OSGI Bundles
- Java 9 Automatic Modules
- Spring @Enable*
Spring 设计思想
- Object-Oriented Programming (OOP)
- IOC / DI
- Domain-DrivenDevelopment (DDD)
- Test-DrivenDevelopment (TDD)
- Event-DrivenPrograming (EDP)
- Functional Programing (FP)
Spring IOC
IOC对于Spring框架来说,就是由Spring来负责控制对象的生命周期和对象间的关系。
所谓依赖注入,就是由IOC容器在运行期间,动态地将某种依赖关系注入到对象之中,所以,以来注入DI 和控制反转IOC 是从不同的角度描述的同一间事情,就是值通过引用IOC容器,利用以来关系注入的方式,实现对象之间的解耦。DI是IOC的实现。
IoC(Inversion of Control,翻译为“控制反转”)不是一个具体的技术,而是一种设计思想。与传统控制流相比,IoC 会颠倒控制流,在传统的编程中需要开发者自行创建并销毁对象,而在 IoC 中会把这些操作交给框架来处理,这样开发者就不用关注具体的实现细节了,拿来直接用就可以了,这就是控制反转。
- IoC 很好的体现出了面向对象的设计法则之一——好莱坞法则:“别找我们,我们找你”。即由 IoC 容器帮对象找到相应的依赖对象并注入,而不是由对象主动去找。
- DI(Dependency Injection,翻译为“依赖注入”)表示组件间的依赖关系交由容器在运行期自动生成,也就是说,由容器动态的将某个依赖关系注入到组件之中,这样就能提升组件的重用频率。通过依赖注入机制,我们只需要通过简单的配置,就可指定目标需要的资源,完成自身的业务逻辑,而不需要关心资源来自哪里、由谁实现等问题。
- IoC 和 DI 其实是同一个概念从不同角度的描述的,由于控制反转这个概念比较含糊(可能只理解成了容器控制对象这一个层面,很难让人想到谁来维护对象关系),所以 2004 年被开发者尊称为“教父”的 Martin Fowler(世界顶级专家,敏捷开发方法的创始人之一)又给出了一个新的名字“依赖注入”,相对 IoC 而言,“依赖注入”明确描述了“被注入对象依赖 IoC 容器配置依赖对象”。
平常的Java开发中,程序员在某个类中需要依赖其它类的方法。通常是new一个依赖类再调用类实例的方法,这种开发存在的问题是new的类实例不好统一管理。 Spring提出了依赖注入的思想,即依赖类不由程序员实例化,而是通过Spring容器帮我们new指定实例并且将实例注入到需要该对象的类中。依赖注入的另一种说法是"控制反转"。通俗的理解是:平常我们new一个实例,这个实例的控制权是我们程序员。而控制反转是指new实例工作不由我们程序员来做而是交给Spring容器来做。
实现方式
- JavaSE
- Java Beans
- Java ServiceLoader SPI

依赖查找
单属性查找、集合对象查找
依赖查找是主动依赖查找方式,通常需要依赖容器API标准实现,而依赖注入是通过手动或者自动依赖绑定方式实现。
实时查找
- BeanFactory.getBean(String beanName) 根据名称查找
- BeanFactory.getBean(
Class<T>beanClazz) 根据Bean类型查找
延迟查找
查询条件
- 单个Bean对象
- 集合Bean对象
- 条件查找(在查找过程中 Name 和 Id都是坚定Bean的条件,在一个上下文中只能存在一种)
- Bean Name + Bean Type查找
- Bean Id + Bean Type查找
- Java 注解
演示代码
- xml配置文件
<?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
https://www.springframework.org/schema/beans/spring-beans.xsd">
<!-- more bean definitions go here -->
<bean id="delayLookup" class="cn.z201.spring.domain.DelayLookup">
<property name="name" value="spring"/>
</bean>
<bean id="objectFactory" class="org.springframework.beans.factory.config.ObjectFactoryCreatingFactoryBean">
<property name="targetBeanName" value="delayLookup"/>
</bean>
<!-- parent 继承等父类 primary 即使指定的 bean 标记为自动装配候选者。 -->
<bean id="annotationDelayLookup" class="cn.z201.spring.domain.AnnotationDelayLookup"
parent="delayLookup" primary="true">
<property name="address" value="杭州"/>
</bean>
</beans>
- Java代码
/**
* @author z201.coding@gmail.com
* spring ioc 延时查找
**/
public class DelayLookup {
private String name;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public String toString() {
return "DelayLookup{" +
"name='" + name + '\'' +
'}';
}
}
/**
* @author z201.coding@gmail.com
**/
@Point
public class AnnotationDelayLookup extends DelayLookup{
private String address;
public String getAddress() {
return address;
}
public void setAddress(String address) {
this.address = address;
}
@Override
public String toString() {
return "AnnotationDelayLookup{" +
"address='" + address + '\'' +
"} " + super.toString();
}
}
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface Point {
}
public class IOCDelayLookupTest {
@Test
public void testLookup() {
// 编辑 ioc-delay-lookup-context.xml 并创建对应bean。
// 启动 spring 上下文
BeanFactory beanFactory = new ClassPathXmlApplicationContext("classpath:META-INF/ioc-delay-lookup-context.xml");
lookup(beanFactory);
lookupLazy(beanFactory);
lookupType(beanFactory);
lookupCollectionType(beanFactory);
lookupAnnotationType(beanFactory);
}
/**
* 实时查找
*
* @param beanFactory
*/
private void lookup(BeanFactory beanFactory) {
// 根据id 获取bean
DelayLookup delayLookup = (DelayLookup) beanFactory.getBean("delayLookup");
// 重写 DelayLookup.toString()方法成功输出 spring 。
System.out.println("实时查找 " + delayLookup);
}
/**
* 延时查找
*
* @param beanFactory
*/
private void lookupLazy(BeanFactory beanFactory) {
// 根据id 获取bean
ObjectFactory<DelayLookup> delayLookup = (ObjectFactory<DelayLookup>) beanFactory.getBean("objectFactory");
// 重写 DelayLookup.toString()方法成功输出 spring 。
System.out.println("延时查找 " + delayLookup.getObject());
}
/**
* 单一类型查找
*
* @param beanFactory
*/
private void lookupType(BeanFactory beanFactory) {
// 根据id 获取bean
DelayLookup delayLookup = beanFactory.getBean(DelayLookup.class);
// 重写 DelayLookup.toString()方法成功输出 spring 。
System.out.println("单一类型查找 " + delayLookup);
}
/**
* 单一类型集合查找
*
* @param beanFactory
*/
private void lookupCollectionType(BeanFactory beanFactory) {
if (beanFactory instanceof ListableBeanFactory) {
ListableBeanFactory listableBeanFactory = (ListableBeanFactory) beanFactory;
Map<String, DelayLookup> delayLookupMap = listableBeanFactory.getBeansOfType(DelayLookup.class);
// getBeansOfType 匹配所有类型的 bean,无论是单例、原型还是 FactoryBean , bean name 作为key value 作为对象
delayLookupMap.forEach((key, value) -> {
System.out.println("单一类型集合查找 " + key + " " + value);
});
}
}
/**
* Java注解查找
* 通过注解查找只需要
*
* @param beanFactory
*/
private void lookupAnnotationType(BeanFactory beanFactory) {
// Point
if (beanFactory instanceof ListableBeanFactory) {
ListableBeanFactory listableBeanFactory = (ListableBeanFactory) beanFactory;
Map<String, AnnotationDelayLookup> delayLookupMap = (Map) listableBeanFactory.getBeansWithAnnotation(Point.class);
// getBeansOfType 匹配所有类型的 bean,无论是单例、原型还是 FactoryBean , bean name 作为key value 作为对象
delayLookupMap.forEach((key, value) -> {
System.out.println("Java注解 @Point 查找 " + key + " " + value);
});
}
}
}
- Console
实时查找 DelayLookup{name='spring'}
延时查找 DelayLookup{name='spring'}
单一类型查找 AnnotationDelayLookup{address='杭州'} DelayLookup{name='spring'}
单一类型集合查找 delayLookup DelayLookup{name='spring'}
单一类型集合查找 annotationDelayLookup AnnotationDelayLookup{address='杭州'} DelayLookup{name='spring'}
Java注解 @Point 查找 annotationDelayLookup AnnotationDelayLookup{address='杭州'} DelayLookup{name='spring'}
依赖注入
自定义Bean注入。
- 通过Bean注入。
- 通过Bean集合注入。
容器内部依赖注入。
容器内部建立Bean注入。
构造方法注入。
- 构造器注入是不允许循环依赖的存在,日常开发推荐该方式,如果出现循环依赖应该考虑自身代码实现是否合理。
工厂的方法注入。
字段注入
- 编码注入
- Java注解注入
- @Autowired
- @Resource
- @Inject
- Java注解注入
- 编码注入
方法注入
回调注入
演示代码
- 配置文件
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:util="http://www.springframework.org/schema/util"
xsi:schemaLocation="http://www.springframework.org/schema/beans
https://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/util
https://www.springframework.org/schema/util/spring-util.xsd">
<!-- more bean definitions go here -->
<!--
1.在注入集合类等时候,引入util配置信息
xmlns:util="http://www.springframework.org/schema/util"
http://www.springframework.org/schema/util
https://www.springframework.org/schema/util/spring-util.xsd
-->
<bean id="injectionBean" class="cn.z201.spring.injection.domain.InjectionBean">
<property name="name" value="spring"/>
</bean>
<bean id="superInjectionBean" class="cn.z201.spring.injection.domain.SuperInjectionBean"
parent="injectionBean" primary="true">
<property name="address" value="杭州"/>
</bean>
<bean id="objectFactory" class="org.springframework.beans.factory.config.ObjectFactoryCreatingFactoryBean">
<property name="targetBeanName" value="injectionBean"/>
</bean>
<!-- 自动配置 Auto-Wiring -->
<bean id="injectionRepository" class="cn.z201.spring.injection.repository.InjectionRepository" autowire="byType">
<!-- 手动配置 -->
<!-- <property name="beans">-->
<!-- <util:list>-->
<!-- <ref bean="injectionBean"/>-->
<!-- <ref bean="superInjectionBean"/>-->
<!-- </util:list>-->
<!-- </property>-->
</bean>
</beans>
- java代码
/**
* @author z201.coding@gmail.com
**/
public class InjectionBean {
private String name;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public String toString() {
return "InjectionBean{" +
"name='" + name + '\'' +
'}';
}
}
/**
* @author z201.coding@gmail.com
**/
public class InjectionRepository {
private Collection<InjectionBean> beans;
public Collection<InjectionBean> getBeans() {
return beans;
}
public void setBeans(Collection<InjectionBean> beans) {
this.beans = beans;
}
@Override
public String toString() {
return "InjectionRepository{" +
"beans=" + beans +
'}';
}
}
/**
* @author z201.coding@gmail.com
**/
public class IOCInjectionTest {
@Test
public void testInjection() {
// 编辑 ioc-delay-lookup-context.xml 并创建对应bean。
// 启动 spring 上下文
BeanFactory beanFactory = new ClassPathXmlApplicationContext("classpath:META-INF/ioc-delay-injection-context.xml");
lookupType(beanFactory);
lookupCollectionType(beanFactory);
}
/**
* 单一对象注入
*
* @param beanFactory
*/
private void lookupType(BeanFactory beanFactory) {
// 根据id 获取bean
InjectionBean injectionBean = beanFactory.getBean(InjectionBean.class);
// 重写 DelayLookup.toString()方法成功输出 spring 。
System.out.println("单一对象注入 " + injectionBean);
}
/**
* 集合对象注入
*
* @param beanFactory
*/
private void lookupCollectionType(BeanFactory beanFactory) {
if (beanFactory instanceof ListableBeanFactory) {
ListableBeanFactory listableBeanFactory = (ListableBeanFactory) beanFactory;
Map<String, InjectionRepository> delayLookupMap = listableBeanFactory.getBeansOfType(InjectionRepository.class);
// getBeansOfType 匹配所有类型的 bean,无论是单例、原型还是 FactoryBean , bean name 作为key value 作为对象
delayLookupMap.forEach((key, value) -> {
System.out.println("集合对象注入 " + key + " " + value);
});
}
}
}
- Console
单一类型查找 SuperInjectionBean{address='杭州'} InjectionBean{name='spring'}
单一类型集合查找 injectionRepository InjectionRepository{beans=[InjectionBean{name='spring'}, SuperInjectionBean{address='杭州'} InjectionBean{name='spring'}]}
Autowired和Resource关键字
- @Resource和@Autowired都是做bean的注入时使用,其实@Resource并不是Spring的注解,它的包是javax.annotation.Resource,需要导入,但是Spring支持该注解的注入。
- Autowired注解是按照类型(byType)装配依赖对象,默认情况下它要求依赖对象必须存在,如果允许null值,可以设置它的required属性为false。如果我们想使用按照名称(byName)来装配,可以结合@Qualififier注解一起使用:
public class TestServiceImpl {
// 下面两种@Autowired只要使用一种即可
@Autowired
private UserDao userDao; // 用于字段上
@Autowired // 用于属性的方法上
public void setUserDao(UserDao userDao)
{
this.userDao = userDao;
}
}
// @Autowired注解是按照类型(byType)装配依赖对象,默认情况下它要求依赖对象必须存在,如果允
// 许null值,可以设置它的required属性为false。如果我们想使用按照名称(byName)来装配,可以结
// 合@Qualifier注解一起使用。如下:
public class TestServiceImpl {
@Autowired
@Qualifier("userDao") private UserDao userDao;
}
- Resource默认按照ByName自动注入,由J2EE提供,需要导入包javax.annotation.Resource。@Resource有两个重要的属性:name和type,而Spring将@Resource注解的name属性解析为bean的名字,而type属性则解析为bean的类型。所以,如果使用name属性,则使用byName的自动注入策略,而使用type属性时则使用byType自动注入策略。如果既不制定name也不制定type属性,这时将通过反射机制使用byName自动注入策略。
public class TestServiceImpl {
// 下面两种@Resource只要使用一种即可
// 用于字段上
@Resource(name="userDao")
private UserDao userDao;
// 用于属性的setter方法上
@Resource(name="userDao")
public void setUserDao(UserDao userDao) {
this.userDao = userDao;
}
}
BeanFactory与ApplicationContext

BeanFactory 是 Bean 容器,ApplicationContext通过组合BeanFactory提供依赖查找的能力。常用的 AOP、事务以及 事件等,这些都被 ApplicationContext 支持。
BeanFactory是Spring底层ioc容器,它维护存储了很多bean定义的信息、Bean配置、生命周期管理。
ApplicationContext是BeanFactory超子集。
BeanFactory与FactoryBean
BeanFactory与FactoryBean都是接口。
- BeanFactory是IOC容器,就是一个Factory或者说IOC容器对象工厂。
- BeanFactory是单一查找的核心

- FactoryBean是创建Bean的一种方式。FactoryBean就是一个Bean。
- 在Spring中,所有的Bean都是由BeanFactory管理。

ObjectFactory 与 BeanFactory
ObjectFactory 与 BeanFactory 均提供依赖查找的能力
ObjectFactory 仅关注一个或一种类型的 Bean 依赖查找,并
且自身不具备依赖查找。
BeanFactory 则提供了单一类型、集合类型以及层次性等多种依赖查
找方式。
生命周期
- 容器
- Java Beans
BeanDefinition
BeanDefinition是Spring Framework中定义Bean的配置元信息接口。
创建bean
- 基于xml创建
- 基于Java注解创建
- @Bean
- @Component
- @Import
/**
* @author z201.coding@gmail.com
* 演示
* DefaultListableBeanFactory 基于xml配置信息创建bean
* AnnotationConfigApplicationContext 基于注解类创建bean
**/
public class IocContainerTest {
@Test
public void setupXmlApplicationContext(){
// 创建BeanFactory 容器
DefaultListableBeanFactory defaultListableBeanFactory = new DefaultListableBeanFactory();
XmlBeanDefinitionReader reader = new XmlBeanDefinitionReader(defaultListableBeanFactory);
String location = "classpath:META-INF/ioc-delay-injection-context.xml";
// 加载 xml格式的配置文件,并获取bean的数量
int beanDefinitionCount = reader.loadBeanDefinitions(location);
System.out.println("bean 定义加载的数量 " + beanDefinitionCount);
lookupCollectionType(defaultListableBeanFactory);
}
@Test
public void setupAnnotationConfigApplicationContext(){
// 创建BeanFactory 容器
AnnotationConfigApplicationContext config = new AnnotationConfigApplicationContext();
// 加载 IocContainer 作为bean配置类,配置类需要添加@Configuration注解
config.register(IocContainer.class);
// 启动应用上下文
config.refresh();
lookupCollectionType(config);
// 关闭上下文
config.close();
}
/**
* 集合对象注入
*
* @param beanFactory
*/
private void lookupCollectionType(BeanFactory beanFactory) {
if (beanFactory instanceof ListableBeanFactory) {
ListableBeanFactory listableBeanFactory = (ListableBeanFactory) beanFactory;
Map<String, SuperInjectionBean> delayLookupMap = listableBeanFactory.getBeansOfType(SuperInjectionBean.class);
// getBeansOfType 匹配所有类型的 bean,无论是单例、原型还是 FactoryBean , bean name 作为key value 作为对象
delayLookupMap.forEach((key, value) -> {
System.out.println("集合对象注入 " + key + " " + value);
});
}
}
}
- Console
# 运行setupXmlApplicationContext
bean 定义加载的数量 4
集合对象注入 superInjectionBean SuperInjectionBean{address='杭州'} InjectionBean{name='spring'}
# 运行setupAnnotationConfigApplicationContext
集合对象注入 superInjectionBean SuperInjectionBean{address='杭州'} InjectionBean{name='spring'}
配置元信息
可以通过Bean定义、IOC容器配置、外部属性配置。
- 基于XML文件
- 基于Properties
- 基于Java注解
- 基于Java API
实际作用
- AOP抽象、事务抽象、事件机制、SPI机制、第三方集成。
小结
IoC 把对象创建与依赖装配交给容器,依赖查找按名称、类型、注解取实例;BeanFactory 延迟加载,ApplicationContext 启动时完成大部分准备工作。