1.Spring项目的创建

1.1创建一个 Maven 项目

1.创建一个maven项目

2.配置一下国内源，

3.添加 Spring 框架支持（在项目的 pom.xml 文件中添加 Spring 框架的支持）：
Spring 项目需要添加的依赖有 spring-context（Spring 上下文）和 spring-beans（管理对象的模块）。

    <properties>
        <java.version>1.8java.version>
        <maven.compiler.source>${java.version}maven.compiler.source>
        <maven.compiler.target>${java.version}maven.compiler.target>
        <project.build.sourceEncoding>UTF-8project.build.sourceEncoding>
        <spring-framework.version>5.2.10.RELEASEspring-framework.version>
    properties>
    <dependencies>
        <dependency>
            <groupId>org.springframeworkgroupId>
            <artifactId>spring-beansartifactId>
            <version>${spring-framework.version}version>
        dependency>
        <dependency>
            <groupId>org.springframeworkgroupId>
            <artifactId>spring-contextartifactId>
            <version>${spring-framework.version}version>
        dependency>
        <dependency>
            <groupId>org.projectlombokgroupId>
            <artifactId>lombokartifactId>
            <version>1.18.16version>
        dependency>
    dependencies>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

4.添加启动类（在 /src/main/java 目录下创建一个启动类）：

1.2 存储 Bean 对象

1.创建好需要的Bean

2.将Bean注册到Spring容器中

1.3 获取并使用 Bean 对象

1.创建 Spring 上下文（这里使用 ApplicationContext 作为上下文对象，也可以使用 BeanFactory）

ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
1

2.获取指定的 Bean 对象

public class App {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
        User user = (User) context.getBean(User.class);
        user.say();
    }
}
1
2
3
4
5
6
7

获取 Bean 对象的三种方式：

User user = (User) context.getBean(User.class);
User user2 = (User) context.getBean("user");
User user3 = (User) context.getBean("user",User.class);
1
2
3

注意：Spring 中的 Bean 默认是单例模式

public class App {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
        User user = (User) context.getBean(User.class);
        User user2 = (User) context.getBean("user");
        User user3 = (User) context.getBean("user",User.class);
        user.say();
        user2.say();
        user3.say();
        System.out.println(user);
        System.out.println(user2);
        System.out.println(user3);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

2.Spring更简单的读取和存储对象的方式（注解）

2.1 存储 Bean 对象

2.1.1 配置扫描路径

使用注解，无需在存储一个 Bean 对象时，在 Spring 的配置文件中再添加一个注册内容，只要在 Spring 的配置文件中配置一个扫描路径即可实现 Bean 的批量注册。
在beans.xml中添加如下配置：

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
https://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context
https://www.springframework.org/schema/context/spring-context.xsd">
    <context:component-scan base-package="beans"/>
beans>
1
2
3
4
5
6
7
8
9
10

Spring 引入了组件自动扫描机制，它可以在类路径底下，扫描配置的 base-package 包下所有标注了 @Controller ， @Service ， @Repository ， @Component 注解的类，并把这些类纳入进Spring 容器中管理。

2.1.2 注册 Bean 的方式

（1）类注解

@Controller

package beans;

import org.springframework.stereotype.Controller;

@Controller
public class UserController {
    public static void say() {
        System.out.println("user controller");
    }
}
1
2
3
4
5
6
7
8
9
10

@Service

@Service
public class UserService {
    public static void say() {
        System.out.println("user service");
    }
}
1
2
3
4
5
6

@Repository

@Repository
public class UserRepository {
    public void say(){
        System.out.println("user Repository");
    }
}
1
2
3
4
5
6

@Component

@Component
public class UserComponent {
    public void say(){
        System.out.println("user Component");
    }
}
1
2
3
4
5
6

（2）@Configuration

@Configuration
public class UserConfiguration {
    public void say(){
        System.out.println("user Configuration");
    }
}
1
2
3
4
5
6

（3）@Bean（方法注解）

import lombok.Getter;
import lombok.Setter;
import lombok.ToString;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Getter
@Setter
@ToString
@Configuration
public class User {
    private String username;
    private String password;

    @Bean
    public User user1() {
        User user = new User();
        user.setUsername("user1");
        user.setPassword("111");
        return user;
    }

    @Bean
    public User user2() {
        User user = new User();
        user.setUsername("user2");
        user.setPassword("222");
        return user;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

public class App {
    public static void main(String[] args) {
        ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
        User user1 = (User) context.getBean("user1",User.class);
        User user2 = (User) context.getBean("user2",User.class);
        System.out.println(user1);
        System.out.println(user2);

    }
}
1
2
3
4
5
6
7
8
9
10

2.2 获取 Bean 对象

获取 Bean 对象也叫做对象装配或者对象注入，是把对象从容器中取出来放到某个类中。

对象注入的方法：
方法一：属性注入
方法二：构造方法注入
方法三：Setter 注入

2.2.1 属性注入

当前类被 Spring 扫描到时，可以在属性上使用 @Autowired 或 @Resource 注解，会将容器中的Bean对象装配进来。

@Controller
public class UserController {
    @Autowired
    private UserService userService;

    public void getUserService(){
        System.out.println(userService);
    }
}

1
2
3
4
5
6
7
8
9
10

@Controller
public class UserController {
    @Resource
    private UserService userService;

    public void getUserService(){
        System.out.println(userService);
    }
}
1
2
3
4
5
6
7
8
9

2.2.2 构造方法注入

@Controller
public class UserController {

    private UserService userService;
    @Autowired
    public UserController(UserService userService){
        this.userService = userService;
    }
    
    public void getUSerService(){
        System.out.println(userService);
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14

2.2.3 Setter 注入 Bean 对象

（1）使用 @Autowired 注解

@Controller
public class UserController {

    private UserService userService;
    @Autowired
    public void setUserService(UserService userService) {
        this.userService = userService;
    }

    public void getUSerService(){
        System.out.println(userService);
    }

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

（2）使用 @Resource 注解

@Controller
public class UserController {

    private UserService userService;
    @Resource
    public void setUserService(UserService userService) {
        this.userService = userService;
    }

    public void getUSerService(){
        System.out.println(userService);
    }

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

2.2.4 注入指定的 Bean

（1）@Autowired

@Controller
public class UserController {

    @Autowired
    @Qualifier(value = "user1")
    private User user;

    public void printUser(){
        System.out.println(user);
    }

}
1
2
3
4
5
6
7
8
9
10
11
12

（2）@Resource

@Controller
public class UserController {

    @Resource(name = "user2")
    private User user;

    public void printUser(){
        System.out.println(user);
    }

}

1
2
3
4
5
6
7
8
9
10
11
12

3.Bean 的作用域

3.1 singleton

该作用域下的Bean在IoC容器中只存在一个实例
Spring默认选择该作用域

3.2 prototype

每次对该作⽤域下的 Bean 的请求都会创建新的实例

3.3 request

每次 HTTP 请求会创建新的 Bean 实例，类似于 prototype
⼀次 HTTP 的请求和响应的共享 Bean
限定 Spring MVC 中使⽤

3.4 session

在⼀个 HTTP Session 中，定义⼀个 Bean 实例
⽤户会话的共享 Bean，⽐如：记录⼀个⽤户的登陆信息
限定 Spring MVC 中使⽤

3.5 全局作用域 application（了解）

在⼀个 http servlet Context 中，定义⼀个 Bean 实例
Web 应⽤的上下⽂信息，⽐如：记录⼀个应⽤的共享信息
限定 SpringMVC 中使⽤

3.6 websocket（了解）

在⼀个 HTTP WebSocket 的⽣命周期中，定义⼀个 Bean 实例

4.Bean 的原理分析

4.1 Spring 的执行流程

1.启动 Spring 容器（在 main 方法中启动）
2.实例化 Bean（加载 Spring 配置文件，实例化并申请内存）
3.将 Bean 注册到 Spring 中（将添加了和 Spring 注册 Bean 相关的注解的对象存储到容器中）
4.将 Bean 装配到需要的类中

4.2 Bean 的生命周期

1.实例化 Bean（在内存中生成对象）
2.设置 Bean 属性（依赖注入和装配，必须在初始化 Bean 之前，因为初始化的时候可能会用到 Bean 对象）
3.初始化 Bean
4.使用 Bean
5.销毁 Bean