Spring 入门 - Oddpalmer

Spring 官方文档

架构#

Spring框架架构

Spring软件架构 Spring应用系统结构.drawio

IOC容器#

控制反转(Inversion of Control)

是一种编程思想，用于给程序降低耦合，所有对象均由IOC容器创建和管理，程序员不需要再new对象了

20160506104006901

创建容器#

主要通过org.springframework.context.ApplicationContext 接口

代表现代Spring IoC容器，容器负责实例化、配置和组装bean

层级关系#

1
BeanFactory                        顶层接口 懒加载
2
│
3
├── ListableBeanFactory
4
│   └── ApplicationContext
5
│
6
├── HierarchicalBeanFactory
7
│   └── ApplicationContext
8
│
9
ApplicationContext                                  核心接口 立即加载
10
│
11
└── ConfigurableApplicationContext
12
     │
13
     └── AbstractApplicationContext
14
          ├── ClassPathXmlApplicationContext        xml创建使用
15
          ├── FileSystemXmlApplicationContext
16
          └── AnnotationConfigApplicationContext    注解创建使用(主要)

XML创建

1
// 类路径
2
ApplicationContext ctx = new ClassPathXmlApplicationContext("文件名.xml");
3
// 文件路径
4
ApplicationContext ctx = new FileSystemXmlApplicationContext("文件名.xml");
5
// 加载多个配置文件
6
ApplicationContext ctx = new ClassPathXmlApplicationContext("文件1","文件2");

Java注解创建

1
// java注解配置
2
ApplicationContext ctx = new AnnotationConfigApplicationContext(配置类名.class);

Bean#

将一个类托管给Spring IOC管理，一个类对应一个bean，IOC管理的就是Bean

创建#

默认单例模式
Spring基于构造方法去实例化Bean，调用的是类的无参构造方法

1
<!--Bean概览-->
2
<bean
3
    id="唯一标识名"                id
4
    name="别名1,别名2"                多个别名
5
    alias="别名"                  一个别名
6
    class="com.oddpalmer.dao.UserDaoImpl"   类型
7
    scope="singleton"                实例数量
8
    init-method="init"                生命周期初始化方法
9
    destroy-method="destroy"           生命周期销毁方法
10
    autowire="byType"             自动装配类型
11
    factory-method="getInstance"       工厂方法
12
    factory-bean="...factory.UserDaoFactory" 实例工厂bean
13
    lazy-init="true"             控制bean延迟加载
14
    />

获取#

1
/* 创建容器 */
2
ApplicationContext ctx = new ClassPathXmlApplicationContext("beans.xml");
3
/* 从容器中获取Bean实例 */
4

5
// 1.通过名称 需要强转
6
UserDao useDao = (UserDao) ctx.getBean("userDao");
7

8
// 2.通过类型 Bean实例需要唯一
9
UserDao useDao = ctx.getBean(UserDao.class);
10

11
// 3.通过名称和类型
12
UserDao useDao = ctx.getBean("userDao",UserDao.class);
13

14
// 4.注解简化注入，无需getBean

生命周期#

1
1.初始化容器 （启动）
2

3
2.创建对象（内存分配）
4

5
3.执行构造方法 （这其实是“创建对象”的核心动作）
6

7
4.执行属性注入（set操作,依赖注入的核心）
8

9
5.执行Bean初始化方法
10

11
6.Bean就绪，执行业务操作 （使用阶段）
12

13
7.关闭容器
14

15
8.执行Bean销毁方法(包括@PreDestroy destroy-method等)

import导入#

不同的类被托管在不同的beans中，beans在xml配置文件中

一般用于团队开发，将多个 xml文件合并为1个
使用时，用合并之后的xml文件

1
<beans>
2
  <import resource="bean1"/>
3
    <import resource="bean2"/>
4
    <import resource="bean2"/>
5
</beans>
6
<!-- 最后在ClassPathXmlApplicationContext使用该.xml文件即可-->

官方模板

1
<beans xmlns="http://www.springframework.org/schema/beans"
2
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
3
       xsi:schemaLocation="http://www.springframework.org/schema/beans
4
        https://www.springframework.org/schema/beans/spring-beans.xsd">
5

6
</beans>

命名空间#

None 没写捏，看到教程用了一遍后续没用了，应该不重要

依赖注入#

依赖注入（Dependency Injection，DI）是一种解耦思想，通过反射实现。

将对象的依赖关系从内部创建改为外部注入。

解决组件间紧耦合问题，通过IoC容器管理依赖，便于替换依赖、单元测试和配置管理。

主要分为两种，构造器注入和setter注入。spring创建bean对象主要通过无参构造方法；如果通过setter注入，就会调用默认的无参构造方法，所以有些依赖可能为空值；如果通过有参构造注入，就不会为空值，找不到参数直接报错

引用类型用 ref、基本类型用 value

假设有Java pojo如下

1
public class People {
2
    private Cat cat;
3
    private String name;
4

5
    public People(Cat cat, String name) {
6
        this.cat = cat;
7
        this.name = name;
8
    }
9

10
    public void setCat(Cat cat) {
11
        this.cat = cat;
12
    }
13

14
    public void setName(String name) {
15
        this.name = name;
16
    }
17
}

XML方式#

构造器注入#

1
<!--按形参顺序-->
2
<bean id="people" class="com.example.People">
3
    <constructor-arg index="0" ref="cat"/>
4
    <constructor-arg index="1" value="Oddpalmer"/>
5
</bean>
6

7
<!--按形参类型-->
8
<bean id="people" class="com.example.People">
9
  <constructor-arg type="com.example.Cat" ref="cat"/>
10
  <constructor-arg type="java.lang.String" value="Oddplamer"/>
11
</bean>
12

13

14
<bean id="people" class="com.example.People">
15
  <constructor-arg name="cat" ref="cat"/>
16
  <constructor-arg name="name" value="Oddpalmer"/>
17
</bean>

Setter 注入#

property的name必须与setter方法去掉"set"后的首字母小写单词匹配

1
<bean id="beanOne" class="x.y.ThingOne">
2
    <property name="thingTwo" ref="beanTwo"/>
3
    <property name="name" value="example"/>
4
</bean>
5

6
<!--集合框架属于特殊的setter注入-->
7
<property name="list">
8
    <list><value>a</value></list>
9
</property>
10

11
<property name="set">
12
    <set><value>a</value></set>
13
</property>
14

15
<property name="map">
16
    <map><entry key="k" value="v"/></map>
17
</property>
18

19
<property name="properties">
20
    <props><prop key="k">v</prop></props>
21
</property>

自动装配#

自动装配(Autowire)，容器自动将依赖的 Bean 注入到当前 Bean 中，无需在 XML 中显式配置 <property> 或 <constructor-arg>。

byName

必须有对应的 setter 方法、精确匹配，不易冲突

1
<!-- XML配置 -->
2
<beans>
3
    <!-- 自动装配：根据属性名 userDao 找同名bean -->
4
    <bean id="userService" class="com.example.UserService" autowire="byName"/>
5

6
    <!-- 注意：bean id 必须与属性名完全一致 -->
7
    <bean id="userDao" class="com.example.UserDao"/>
8
    <bean id="orderDao" class="com.example.OrderDao"/>
9
</beans>

工作原理：

Spring 看到 userService 有 userDao 属性

在容器中查找 id=“userDao” 的 Bean

在容器中查找 id=“orderDao” 的 Bean

自动调用 setUserDao() 和 setOrderDao() 并注入

byType

规则：根据属性类型匹配、同类型多个 Bean 会冲突、简洁但需确保类型唯一

constructor

规则：按构造器参数类型自动装配

注意事项

显式配置优先：显式配置会覆盖自动装配
冲突处理：byType 需确保类型唯一

流程#

创建关于XML文件的容器
配置<Beans/>
获取bean

注解方式#

组件扫描加载Bean#

哪个类要通过Spring IOC自动创建Bean，就对哪个类扫描

XML配置

1
<context:component-scan base-package="类名"/>

纯注解

@Configuration 标识这是一个Spring配置类，会被Spring容器扫描并处理
**@ComponentScan**用于设定扫描路径，此注解只能添加一次，多个数据请用数组格式

1
@Configuration
2
@ComponentScan("com.example.dao")
3
public class AppConfig {
4
}
5

6
@Configuration
7
@ComponentScan({"com.example.dao","com.example.service"})
8
public class AppConfig1 {
9
}

注解声明Bean#

**@Component**将1个 Java 类标识为 Spring 容器管理的 Bean，默认id为类名首字母小写，也可以自己定义

1
@Component("UserDao")
2
public class UserDaoImpl implements UserDao{
3
}
4
@Component
5
public class UserServiceImpl implements UserService

配置类#

主应用配置类

替代传统的 applicationContext.xml
作为Spring应用的配置入口
整合各个模块的配置

1
@Configuration  // 标识这是一个Spring配置类，会被Spring容器扫描并处理
2
@Import({DatabaseConfig.class, SecurityConfig.class})  // 导入其他配置类
3
@ComponentScan("com.example.service")  // 扫描指定包下的@Component、@Service、@Repository等注解
4
@PropertySource("classpath:app.properties")  // 加载属性文件
5
public class AppConfig {
6
    // 主配置类
7
    @Bean
8
    public GlobalConfig globalConfig() {
9
        return new GlobalConfig();
10
    }
11
}
12

13
@Configuration
14
public class DatabaseConfig {
15
    @Bean
16
    public DataSource dataSource() {
17
        // 数据库配置
18
    }
19
}

常用注解#

Bean相关#

@Service、@Repository … 都是基于@Component，方便开发人员理解而使用，本质功能无区别

@Component 在普通类上定义的Bean @Service 业务层Bean @Repository 数据访问层Bean @Controller 表现层Bean @RestController REST控制器（包含@Controller和@ResponseBody）

@Bean 在配置类上定义的Bean, Spring 将方法返回值注册为Bean @Scope 定义Bean作用域 @PostConstruct 生命周期构造之后执行的方法 @PreDestroy 声明周期容器关闭前执行的方法

配置相关#

@Configuration 设置当前类为配置类

@ComponentScan 组件扫描

@PropertySource 读取配置的属性文件

依赖注入#

@Autowired 默认按类型自动装配（最常用） @Qualifier 按名称指定具体Bean @Value 注入基本数据类型，SpEL表达式

第三方Bean管理#

@Bean 配置类上定义的Bean 将方法返回值注册为Spring Bean

@Import 加载其他配置类

比较#

功能	XML配置	注解配置
定义bean	bean标签 id属性 class属性	@Component @Controller @Service @Repository @ComponentScan
设置依赖注入	setter、constructor、autowire	@Autowired @Qualifier @Value
配置第三方bean	bean标签静态工厂、实例工厂、FactoryBean	@Bean
作用范围	scope属性	@Scope
生命周期	标准接口、init-method、destroy-method	@PostConstruct @PreDestroy

I'm Oddpalmer

架构#

IOC容器#

创建容器#

层级关系#

Bean#

创建#

获取#

生命周期#

import导入#

命名空间#

依赖注入#

XML方式#

构造器注入#

Setter 注入#

自动装配#

流程#

注解方式#

组件扫描加载Bean#

注解声明Bean#

配置类#

常用注解#

Bean相关#

配置相关#

依赖注入#

第三方Bean管理#

比较#