Spring深度剖析：基础认知与入门应用全解析_程序员社区

Spring深度剖析：基础认知与入门应用全解析

文章目录

Spring
- spring概述
- 1 Spring定义
- 2 Spring核心
- 3 Spring Framework的特点
- 入门案例
- 1 环境要求
- 2 构建工程
  - 2.1 构建子工程first - spring
  - 2.2 入门案例
  - 2.3 对象存储
- IoC容器
- 1 控制反转IoC
- 2 依赖注入DI
- 3 IoC容器实现
- 4 基于XML管理bean
  - 4.1 环境准备
  - 4.2 获取bean方式
  - 4.3 基于setter依赖注入
  - 4.4 基于构造器依赖注入
  - 4.5 特殊值处理注入
  - 4.5.1 字面量赋值
  - 4.5.2 null值
  - 4.5.3 xml实体
  - 4.5.4 CDATA区
  - 4.6 对象类型属性注入
  - 4.6.1 引用外部bean
  - 4.6.2 内部bean
  - 4.6.3 级联属性赋值（了解）
  - 4.7 数组类型属性注入
  - 4.8 集合类型属性注入
  - 4.8.1 List集合属性注入
  - 4.8.2 Map集合属性注入
  - 4.8.3 引用集合类型bean注入
  - 4.9 p命名空间
  - 4.10 引入外部属性文件
  - 4.11 bean的作用域
  - 4.12 bean的生命周期
  - 4.12.1 bean的完整生命周期
  - 4.12.2 生命周期验证
  - 4.12.3 bean生命周期扩展
  - 4.13 基于xml自动装配
- 5 基于注解管理bean
  - 5.1 创建子工程
  - 5.2 开启组件扫描
  - 5.3 使用注解定义Bean
  - 5.4 @Autowired注入
  - 5.4.1 属性注入
  - 5.4.2 set注入
  - 5.4.3 构造方法注入
  - 5.4.4 形参上注入
  - 5.4.5 只有一个构造函数，无注解
  - 5.4.6 @Autowire注解和@Qualifier注解联合
  - 5.5 @Resource注入
  - 5.6 Spring全注解开发

Spring

在这里插入图片描述

spring概述

1 Spring定义

Spring是一款主流的轻量级Java EE开源框架，其作用在于简化Java企业级应用的开发难度与周期。从简单性、可测试性以及松耦合的角度来看，任何Java应用都能从Spring中受益。Spring框架不仅能提供自身功能，还具备整合其他技术与框架的能力。

自诞生以来，Spring一直深受开发者的喜爱，长期作为Java企业级应用程序开发的首选。时至今日，Spring已然成为Java EE的代名词，成为构建Java EE应用的实际标准。

自2004年4月Spring 1.0版本正式发布后，Spring已发展到第6个大版本，即Spring 6，本文采用Spring 5.3.24正式版本。

在这里插入图片描述

2 Spring核心

Spring所指的是Spring Framework，通常被称为Spring框架。它是一个分层的面向切面的Java应用一站式解决框架，是Spring技术栈的核心与基础，用于解决企业级应用开发的复杂性问题。

Spring有两个核心模块：IoC和AOP。

IoC（Inverse of Control）即控制反转，是将创建对象的工作交由Spring进行管理。

AOP（Aspect Oriented Programming）即面向切面编程。AOP用于封装多个类的公共行为，把那些与业务无关但被业务模块共同调用的逻辑封装起来，减少系统的重复代码，降低模块间的耦合度。此外，AOP还能解决一些系统层面的问题，比如日志、事务、权限等。

3 Spring Framework的特点

控制反转（IoC）：反转资源获取的方向；将自身创建资源、向环境索取资源转变为环境准备好资源，由我们享受资源注入。
面向切面编程（AOP）：在不修改源代码的基础上增强代码功能。
容器：Spring IoC是一个容器，因为它包含并管理组件对象的生命周期；组件受到容器化管理，为程序员屏蔽了组件创建过程中的诸多细节，极大降低了使用门槛，大幅提高了开发效率。
一站式：在IOC和AOP的基础上能够整合各种企业应用的开源框架和优秀的第三方库，而且Spring旗下的项目覆盖了广泛领域，很多方面的功能性需求都可以在Spring Framework的基础上用Spring来实现。

入门案例

1 环境要求

JDK：Java 8 - 15
Spring：5.3.24

2 构建工程

2.1 构建子工程first - spring

在jsd2303 - spring中创建子工程spring - first

选择New - Module
点击Next
将Name设置为spring - first，然后点击Finish

2.2 入门案例

① 在spring - first/pom.xml中引入相关依赖，并刷新maven

<dependencies>
    <!-- 引入spring context依赖，引入后会将Spring的基础依赖引入 -->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring - context</artifactId>
        <version>5.3.24</version>
    </dependency>
</dependencies>

② 在工程中创建包cn.tedu.spring.begin

③ 创建类User

④ 在User类中定义方法

public class User {
    public void add() {
        System.out.println("添加方法...");
    }
}

⑤ 创建spring配置文件：在resources目录下创建bean.xml

⑥ 在bean.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 http://www.springframework.org/schema/beans/spring-beans.xsd">
    <!-- 创建user对象，id为唯一标识，class为要创建对象所在类的绝对路径 -->
    <bean id="user" class="cn.tedu.spring.User"></bean>
</beans>

⑦ 创建测试类cn.tedu.spring.TestUser进行测试

public class TestUser {
    public static void main(String[] args) {
        // 1.加载spring配置文件，进行对象创建
        ApplicationContext context = new ClassPathXmlApplicationContext("bean.xml");
        // 2.获取spring创建好的对象
        User user = (User) context.getBean("user");
        // 3.使用对象调用方法测试
        System.out.println("user = " + user);
        user.add();
    }
}

2.3 对象存储

将对象存放到容器中，查看源码，在DefaultListableBeanFactory.java的第164行，可以看到key是唯一标识，value是类的定义（包含描述信息）。可以查看BeanDefinition的源码，其中有类的描述信息、是否初始化的状态等内容。

IoC容器

IoC是Inversion of Control的缩写，译为控制反转。

Spring通过IoC容器来管理所有Java对象的实例化和初始化，把控对象与对象之间的依赖关系。由IoC容器管理的Java对象被称为Spring Bean，它与使用关键字new创建的Java对象没有本质区别。

IoC容器是Spring框架中极为重要的核心组件之一，贯穿了Spring从诞生到发展的整个过程。

1 控制反转IoC

控制反转是一种思想
- 将对象的创建权交出去，交由第三方容器负责
- 将对象与对象之间的关系维护权交出去，交由第三方容器负责
实现方式
通过依赖注入DI的方式来实现

2 依赖注入DI

DI（Dependency Injection）即依赖注入，依赖注入实现了控制反转的思想，是指Spring在创建对象的过程中，把对象依赖的属性通过配置进行注入。

依赖注入常见的实现方式有两种：
- set注入
- 构造注入

所以，IoC是一种控制反转的思想，而DI是对IoC的具体实现。

Bean管理指的是Bean对象的创建，以及Bean对象中属性的赋值（或Bean对象之间关系的维护）

3 IoC容器实现

Spring中的IoC容器是IoC思想的一个落地产品。IoC容器中管理的组件也叫bean。在创建bean之前，首先要创建IoC容器，Spring提供了两种IoC容器的实现方式：

① BeanFactory
这是IoC容器的基本实现，是Spring内部使用的接口，面向Spring自身，不提供给开发人员使用。

② ApplicationContext
ApplicationContext是BeanFactory的子接口，提供了更多高级特性，面向Spring的使用者，几乎所有场合都使用ApplicationContext，而非底层的BeanFactory

源码说明：

4 基于XML管理bean

4.1 环境准备

① 创建子工程spring - ioc - xml

② 在pom.xml中引入spring依赖，并刷新maven

<dependencies>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring - context</artifactId>
        <version>5.3.24</version>
    </dependency>
</dependencies>

③ 在resources目录下创建spring配置文件bean.xml

④ 在工程的java目录下创建类cn.tedu.spring.iocxml.User

public class User {
    private String username;
    private String password;

    public void userMethod() {
        System.out.println("userMethod执行~~");
    }
}

4.2 获取bean方式

根据id获取
id属性是bean的唯一标识，所以依据bean标签的id属性能够精确获取到一个组件对象。

① bean.xml

<bean id="user" class="cn.tedu.spring.iocxml.User"></bean>

② 创建测试类UserTest

public class UserTest {
    public static void main(String[] args) {
        // 1.加载配置文件
        ApplicationContext context = new ClassPathXmlApplicationContext("bean.xml");
        // 2.根据id获取bean
        User user1 = (User) context.getBean("user");
        System.out.println("1-根据id获取对象:" + user1);
        user1.userMethod();

        User user2 = context.getBean(User.class);
        System.out.println("2-根据类型获取bean:" + user2);
        user2.userMethod();

        User user3 = context.getBean("user", User.class);
        System.out.println("3-根据id和类型获取bean：" + user3);
        user3.userMethod();
    }
}

注意
当依据类型获取bean时，要求IoC容器中指定类型的bean只能有一个，若配置两个会抛出异常

<bean id="user" class="cn.tedu.spring.iocxml.User"></bean>
<bean id="user2" class="cn.tedu.spring.iocxml.User"></bean>

4.3 基于setter依赖注入

类具有属性，在创建对象的过程中，向属性注入具体的值。

方式1：使用set方法完成（通过xml中的标签实现）

方式2：基于构造器完成

案例

① 创建Package名为dibase，创建Book类

package cn.tedu.spring.DI;

public class Book {
    private String bookName;
    private String bookAuthor;

    public Book() {}

    public Book(String bookName, String bookAuthor) {
        this.bookName = bookName;
        this.bookAuthor = bookAuthor;
    }

    public String getBookName() {
        return bookName;
    }

    public void setBookName(String bookName) {
        this.bookName = bookName;
    }

    public String getBookAuthor() {
        return bookAuthor;
    }

    public void setBookAuthor(String bookAuthor) {
        this.bookAuthor = bookAuthor;
    }

    @Override
    public String toString() {
        return "Book{" +
                "bookName='" + bookName + '\'' +
                ", bookAuthor='" + bookAuthor + '\'' +
                '}';
    }
}

② 创建spring配置文件：在resources目录下创建bean - di.xml

<!-- set方法注入 -->
<bean id="book" class="cn.tedu.spring.DI.Book">
    <!-- 使用property标签注入 -->
    <property name="bookName" value="java"></property>
    <property name="bookAuthor" value="tedu"></property>
</bean>

③ 创建测试类TestBook进行测试

public class BookTest {
    @Test
    public void springSetTest() {
        ApplicationContext context = new ClassPathXmlApplicationContext("bean-di.xml");
        Book book = context.getBean("book", Book.class);
        System.out.println("book = " + book);
    }
}

4.4 基于构造器依赖注入

说明
通过构造器的方式实现依赖注入
操作步骤说明
1. 创建类，定义属性，生成有参数构造方法
2. 进行xml配置
3. 创建测试类测试

① 创建电影信息类Film，定义属性并生成全参构造方法

public class Film {
    private String title;
    private String actor;

    public Film(String title, String actor) {
        System.out.println("Film的有参构造已经执行~~");
        this.title = title;
        this.actor = actor;
    }

    public String getTitle() {
        return title;
    }

    public void setTitle(String title) {
        this.title = title;
    }

    public String getActor() {
        return actor;
    }

    public void setActor(String actor) {
        this.actor = actor;
    }

    @Override
    public String toString() {
        return "Film{" +
                "title='" + title + '\'' +
                ", actor='" + actor + '\'' +
                '}';
    }
}

② 在bean - di.xml中进行注入配置

<!-- 构造器注入演示：Film类 -->
<bean id="film" class="cn.tedu.spring.DI.Film">
    <constructor-arg name="title" value="霸王别姬"></constructor-arg>
    <constructor-arg name="actor" value="张国荣"></constructor-arg>
</bean>

③ 创建测试类TestFilm测试

public class FilmTest {
    @Test
    public void FilmConsDITest() {
        // 1.加载配置文件
        ApplicationContext context = new ClassPathXmlApplicationContext("bean-di.xml");
        // 2.获取指定bean
        Film film = context.getBean("film", Film.class);
        // 3.输出测试
        System.out.println("film = " + film);
    }
}

4.5 特殊值处理注入

4.5.1 字面量赋值

当使用value属性给bean的属性赋值时，spring会把value的属性值当作字面量

<property name="number" value="1016"></property>

4.5.2 null值

使用标签或者标签实现注入。

① Film类中增加电影描述属性

private String description;

public String getDescription() {
    return description;
}

public void setDescription(String description) {
    this.description = description;
}

② bean - di.xml配置文件调整

<!-- 构造器注入演示：Film类 -->
<bean id="film" class="cn.tedu.spring.DI.Film">
    <constructor-arg name="title" value="霸王别姬"></constructor-arg>
    <constructor-arg name="actor" value="张国荣"></constructor-arg>
    <!-- 电影描述注入空值null -->
    <constructor-arg name="description">
        <null></null>
    </constructor-arg>
</bean>

③ 执行测试类进行测试

课堂练习：

在cn.tedu.spring下创建包exercise，在包下创建商品表Product，类属性如下：

商品标题：title

商品库存：num

商品销量：sales

商品描述：comment

实现商品Product类的创建，包含setter()、getter()、toString()方法

```java
public class Product {
private String title;
private Integer num;
private Integer sales;
private String comment;

public Product() {}

文章整理自互联网，只做测试使用。发布者：Lomu，转转请注明出处：https://www.it1024doc.com/13550.html

Spring深度剖析：基础认知与入门应用全解析