2024年9月25日--- Spring-IOC 1

一 Spring的概要

1.1 简介

Spring，春天的意思，意指给软件行业带来春天。2002年，Rod Jahnson首次推出了Spring框架雏形interface21框架。2004年3月24日，Spring框架以interface21框架为基础，经过重新设计，发布了1.0正式版。

Spring理念 : 使现有技术更加实用 . 本身就是一个大杂烩 , 整合现有的框架技术

官网 : Spring | Home

官方下载地址 : JFrog

GitHub : Spring · GitHub

1.2 优点

Spring是一个开源的轻量级的应用开发框架，其目的是用于简化企业级应用程序开发，降低侵入性;
Spring提供的IOC和AOP功能，可以将组建的耦合度降至最低，即解耦，便于系统日后的维护和升级
提供了对持久层、事务的支持
提供了MVC框架思想的实现，用于开发企业级应用。
也可以与第三方框架和技术整合应用，可以自由选择采用哪种技术进行开发

一句话概括：Spring是一个轻量级的控制反转(IoC)和面向切面(AOP)的容器（框架）。

1.3 Spring的发展历程

1997 年 IBM提出了EJB 的思想

1998 年，SUN制定开发标准规范 EJB1.0

1999 年，EJB1.1 发布

2001 年，EJB2.0 发布

2003 年，EJB2.1 发布

2006 年，EJB3.0 发布

Rod Johnson （罗德·约翰逊，Spring 之父）

Expert One-to-One J2EE Development without EJB(2004)

阐述了 J2EE 开发不使用 EJB的解决方式（Spring 雏形）

2017年9月份发布了Spring的最新版本Spring 5.0通用版

1.4 模块

Spring 框架是一个分层架构，由 7 个定义良好的模块组成。Spring 模块构建在核心容器之上，核心容器定义了创建、配置和管理 bean 的方式

核心容器：核心容器提供 Spring 框架的基本功能。核心容器的主要组件是 BeanFactory，它是工厂模式的实现。BeanFactory 使用控制反转（IOC）模式将应用程序的配置和依赖性规范与实际的应用程序代码分开。
Spring 上下文：Spring 上下文是一个配置文件，向 Spring 框架提供上下文信息。Spring 上下文包括企业服务，例如 JNDI、EJB、电子邮件、国际化、校验和调度功能。
Spring AOP：通过配置管理特性，Spring AOP 模块直接将面向切面的编程功能 , 集成到了 Spring 框架中。所以，可以很容易地使 Spring 框架管理任何支持 AOP的对象。Spring AOP 模块为基于 Spring 的应用程序中的对象提供了事务管理服务。通过使用 Spring AOP，不用依赖组件，就可以将声明性事务管理集成到应用程序中。
Spring DAO：JDBC DAO 抽象层提供了有意义的异常层次结构，可用该结构来管理异常处理和不同数据库供应商抛出的错误消息。异常层次结构简化了错误处理，并且极大地降低了需要编写的异常代码数量（例如打开和关闭连接）。Spring DAO 的面向 JDBC 的异常遵从通用的 DAO 异常层次结构。
Spring ORM：Spring 框架插入了若干个 ORM 框架，从而提供了 ORM 的对象关系工具，其中包括 JDO、Hibernate 和 iBatis SQL Map。所有这些都遵从 Spring 的通用事务和 DAO 异常层次结构。
Spring Web 模块：Web 上下文模块建立在应用程序上下文模块之上，为基于 Web 的应用程序提供了上下文。所以，Spring 框架支持与 Jakarta Struts 的集成。Web 模块还简化了处理多部分请求以及将请求参数绑定到域对象的工作。
Spring MVC 框架：MVC 框架是一个全功能的构建 Web 应用程序的 MVC 实现。通过策略接口，MVC 框架变成为高度可配置的，MVC 容纳了大量视图技术，其中包括 JSP、Velocity、Tiles、iText 和 POI。

1.5 拓展 Spring Boot与Spring Cloud

Spring Boot 是 Spring 的一套快速配置脚手架，可以基于Spring Boot 快速开发单个微服务;
Spring Cloud是基于Spring Boot实现的；
Spring Boot专注于快速、方便集成的单个微服务个体，Spring Cloud关注全局的服务治理框架；
Spring Boot使用了约束优于配置的理念，很多集成方案已经帮你选择好了，能不配置就不配置 , Spring Cloud很大的一部分是基于Spring Boot来实现，Spring Boot可以离开Spring Cloud独立使用开发项目，但是Spring Cloud离不开Spring Boot，属于依赖的关系。
SpringBoot在SpringClound中起到了承上启下的作用，如果你要学习SpringCloud必须要学习SpringBoot。

二 Spring IOC

2.1 IOC简介

IoC（Inverse Of Control）控制反转：即，把创建对象的权利交给框架，也就是指将对象的创建、对象的初始化、对象的存储、对象的管理交给了Spring容器。IOC本质是一种设计思想。

IoC 是一种通过描述来生成或者获取对象的技术，对于Java初学者更多时候所熟悉的是使用 new 关键字来创建对象，而在spring中则不是，它是通过描述（XML或注解）来创建对象。

在 Spring 中把每一个需要管理的对象称之为 Spring Bean（简称为Bean），而Spring中管理这些 Bean 的容器，被我们称之为 Spring IoC 容器（简称 IoC容器）

在此之前，当需要对象时，通常是利用new关键字创建一个对象：

/* 创建一个User对象——这里使用new对象的方式造成了程序之间的耦合性提升 */
User u = new User();

但由于new对象，会提高类和类之间的依赖关系，即代码之间的耦合性。

而现在我们可以将对象的创建交给框架来做：

// 获取Spring IoC容器对象
ApplicationContext ctx = new ClassPathXmlApplicationContext("beans.xml");
// 从spring的IoC容器中获取User对象
private User user = (User)ctx.getBean("user");

将需要的POJO提前在配置文件（XML或注解）中进行描述，Spring会根据配置文件将其中所描述生成 IoC容器并装配Bean，在需要使用时，再次获取即可

这样一来，当需要对象时不用自己创建，而是通过框架获取即可，不用硬编码去new对象，自然就降低类和类之间的依赖关系，也就是耦合性。

2.2 入门案例

在Spring中允许我们通过XML或注解方式装配Bean，下面先来介绍Spring中通过XML方法如何装配Bean。

扩展：

idea里的project 相当于 eclipse里的 workspace

idea里的module 相当于eclipse里的project 为了迎合现在的模块形式开发。

module可以称之为模块或者是子项目，依赖于父项目(project) . 开发时一般都是开发的module，因此父项目的src可以删掉

隐藏不想看到的文件或者文件夹

File—>settings—>Editor—>File Types—>ignored Files and Folders —->点击+号，输入想要隐藏的内容，回车

2.2.1 创建module

先创建父工程spring-demo，然后再创建module，命名spring-ioc1

<dependencies>
   <!-- 添加commons-logging依赖 -->
   <dependency>
      <groupId>commons-logging</groupId>
      <artifactId>commons-logging</artifactId>
      <version>1.1.3</version>
   </dependency>
   <!-- 添加junit依赖 -->
   <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.11</version>
   </dependency>
   <!-- 添加spring的依赖 -->
   <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-webmvc</artifactId>
      <version>5.1.10.RELEASE</version>
   </dependency>
</dependencies>

导入后保存pom文件，项目如图所示：

spring-core：Spring的核心工具包

这个jar 文件包含Spring 框架基本的核心工具类。Spring 其它组件要都要使用到这个包里的类，是其它组件的基本核心，当然你也可以在自己的应用系统中使用这些工具类。外部依赖Commons-Logging， Log4J。

spring-beans：Spring IOC的基础实现，包含访问配置文件、创建和管理bean等。

这个jar文件是所有应用都要用到的，它包含访问配置文件、创建和管理bean 以及进行Inversion of Control / Dependency Injection（IoC/DI）操作相关的所有类。如果应用只需基本的IoC/DI 支持，引入spring-core.jar 及spring-beans.jar 文件就可以了。外部依赖spring-core，cglib-nodep.jar。

spring-context：在基础IOC功能上提供扩展服务，此外还提供许多企业级服务的支持，有邮件服务、任务调度、JNDI定位，EJB集成、远程访问、缓存以及多种视图层框架的支持。

这个jar文件为Spring核心提供了大量扩展。可以找到使用Spring ApplicationContext特性时所需的全部类，JDNI 所需的全部类，instrumentation组件以及校验Validation 方面的相关类。

外部依赖spring-core.jar，spring-beans.jar，spring-aop.jar，commons-collections.jar，aopalliance.jar。

spring-expression：Spring表达式语言

spring-aop：Spring的面向切面编程，提供AOP（面向切面编程）的实现

这个jar文件包含在应用中使用Spring的AOP特性时所需的类。使用基于AOP的Spring特性，如声明型事务管理（Declarative Transaction Management），也要在应用里包含这个jar包。

外部依赖spring-core.jar，spring-beans.jar，cglib-nodep.jar，aopalliance.jar

附：aopalliance.jar：这个包是AOP联盟的API包，里面包含了针对面向切面的接口。通常Spring等其它具备动态织入功能的框架依赖此包。

cglib-nodep.jar：这个包是一个强大的,高性能,高质量的Code生成类库。它可以在运行期扩展Java类与实现Java接口。当然这些实际的功能是asm所提供的，asm又是什么？Java字节码操控框架。cglib就是封装了asm，简化了asm的操作，实现了在运行期动态生成新的class。实际上CGlib为spring aop提供了底层的一种实现;为hibernate使用cglib动态生成VO/PO (接口层对象)。

2.2.2 编写实体类

package com.sldl.pojo;

public class User {
    private String username;

    public User() {
    }

    public User(String username) {
        this.username = username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    @Override
    public String toString() {
        return "User{" +
                "username='" + username + '\'' +
                '}';
    }
}

2.2.3 编写核心配置文件

在src/main/resources目录下 ,创建Spring的核心配置文件，这里我们命名为beans.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">
</beans>

2.2.4 配置Bean

在 beans.xml 文件中添加如下配置：将User类作为Bean装配到Spring IoC容器中

<?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">

    <!--在spring的配置文件里，注册User类的bean配置，
    此时User类的对象就是Spring容器帮助我们创建对象，默认调用无参构造器-->
    <bean id="u1" class="com.sldl.pojo.User"></bean>
</beans>

2.2.5 测试

package com.sldl.test;

import com.sldl.pojo.User;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class IOCTest {
    @Test
    public void test1(){
        //先获取SpringIOC的容器，因为核心配置文件在resources里，即根目录下，因此直接写文件名即可
        ApplicationContext ctx =
                new ClassPathXmlApplicationContext("beans.xml");

        //使用容器的getBean方法，从容器中获取User类型的对象
        User user = (User)ctx.getBean("u1");

        //因为SpringIOC容器使用无参构造器创建的对象，因此属性值为null
        System.out.println(user);
    }
}

运行结果：

2.2.6 Spring小结

1）在程序运行后，Spring会到配置文件中读取 Bean 配置信息，根据配置信息生产 Spring IoC容器对象

2）Spring IoC 容器根据读取到的Bean配置信息，到硬盘上加载相应的 Class 字节码文件，根据反射创建 Bean 实例。

3）Spring会将创建的Bean存储到 Spring 容器中，也就是所谓的 Bean Pool（Bean池，底层是一个Map）中

4）根据 Spring 提供的 getBean 方法获取Bean实例并应用到我们的应用程序中。

思考：

User 对象是谁创建的 ? 【User对象是由Spring创建的】

User 对象的属性是怎么设置的 ? 【User 对象的属性是由Spring容器设置的】

这个过程就叫控制反转 :

控制 : 谁来控制对象的创建 , 传统应用程序的对象是由程序本身控制创建的 , 使用Spring后 , 对象是由Spring来创建的

反转 : 程序本身不创建对象 , 而变成被动的接收对象

练习：定义一个cn.huac.pojo.UserInfo类，并将UserInfo作为 Bean 装配到 Spring IoC容器中，在程序中通过 getBean 方法获取 UserInfo 实例，并输出到控制台。

2.2.7 扩展1(自学)

下面列出了BeanFactory接口的几个常用方法，可以在程序中试一试。

/* 根据bean的名称，返回指定bean的一个实例（如果有） */
Object getBean(String name) throws BeansException;

/* 根据Bean的类型（也可以是父类或父接口，可以创建一个Person接口，让User实现），返回唯一匹配给定对象类型的bean实例（如果有） */
<T> T getBean(Class<T> requiredType) throws BeansException;

/* 检索这个Bean工厂是否包含一个给定名称的bean实例  */
boolean containsBean(String name);

/* 获取Bean的类型  */
Class<?> getType(String name) throws NoSuchBeanDefinitionException;

/* 根据Bean的名称，检索当前Bean是不是单例，如果是则返回true */
boolean isSingleton(String name) throws NoSuchBeanDefinitionException;

/* 根据Bean的名称，检索当前Bean是不是多例，如果是则返回true */
boolean isPrototype(String name) throws NoSuchBeanDefinitionException;

package cn.huac.test;

import cn.huac.pojo.User;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class IOCTests {
    @Test
    public void testIOC(){
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("beans.xml");
        User user = (User) applicationContext.getBean("user");
        System.out.println(user);
        User user2 = applicationContext.getBean(User.class);
        System.out.println(user2);
        boolean b1 = applicationContext.containsBean("user");
        boolean b2 = applicationContext.containsBean("userInfo");
        System.out.println(b1 + ", " + b2);
        Class cls = applicationContext.getType("user");
        System.out.println(cls);
        boolean singleton = applicationContext.isSingleton("user");
        boolean prototype = applicationContext.isPrototype("user");
        System.out.println(singleton + ", " + prototype);
    }
}

2.2.8 扩展2(自学)

每个<bean>元素配置一个由Spring IoC容器所管理的应用程序对象。在Spring框架的术语中，一个<bean>元素代表一个Bean。id属性指定bean的唯一名称，class属性指定bean的完全限定类名。

import导入这个import，一般用于团队开发；

可以将多个配置文件，导入合并为一个；

applicationContext.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">
   <import resource="beans.xml"></import>
   <import resource="beans2.xml"></import>
   <import resource="beans3.xml"></import>
</beans>

项目多人开发，多个人复制不同的类开发，不同的类需要注册不同的bean中，我们就可以利用import将所有人的beans.xml合并成一个总的！

2.3 Bean的作用域

在Spring容器中管理的Bean对象的作用域，可以通过scope属性或用相关注解指定其作用范围。

<bean id="user" scope="singleton" class="xxxxx.User"></bean>

2.3.1 作用域的种类

1）singleton

单实例（默认），这个作用域标识的对象具备全局唯一性。

当把一个 bean 定义设置 scope 为singleton作用域时，那么Spring IoC容器只会创建该bean定义的唯一实例。也就是说，整个Spring IoC容器中只会创建当前类的唯一一个对象。
这个单一实例会被存储到 bean池中，并且所有针对该 bean 的后续请求和引用都将返回被缓存的、唯一的这个对象实例。
单例的bean对象由spring负责创建、初始化、存储、销毁（在spring容器销毁时销毁）

配置如下

 <bean id="ServiceImpl" class="cn.csdn.service.ServiceImpl" scope="singleton">

测试：

@Test
public void test03(){
   ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
   User user = (User) context.getBean("user");
   User user2 = (User) context.getBean("user");
   System.out.println(user==user2);
}

2）prototype

多实例。这个作用域标识的对象每次获取都会创建新的对象。

当把一个 bean 定义设置 scope 为prototype作用域时，Spring IoC容器会在每一次获取当前Bean时，都会产生一个新的Bean实例（相当于new的操作），该实例不会被存储到bean池中，spring也不负责销毁，当程序不再使用这个对象时，由GC负责销毁。

<bean id="account" class="com.foo.DefaultAccount" scope="prototype"/>  
或者
<bean id="account" class="com.foo.DefaultAccount" singleton="false"/>

3）Request

当一个bean的作用域为Request，表示在一次HTTP请求中，一个bean定义对应一个实例；即每个HTTP请求都会有各自的bean实例，它们依据某个bean定义创建而成。该作用域仅在基于web的Spring ApplicationContext情形下有效。考虑下面bean定义：

 <bean id="loginAction" class=cn.csdn.LoginAction" scope="request"/>

针对每次HTTP请求，Spring容器会根据loginAction bean的定义创建一个全新的LoginAction bean实例，且该loginAction bean实例仅在当前HTTP request内有效，因此可以根据需要放心的更改所建实例的内部状态，而其他请求中根据loginAction bean定义创建的实例，将不会看到这些特定于某个请求的状态变化。当处理请求结束，request作用域的bean实例将被销毁。

4）Session

当一个bean的作用域为Session，表示在一个HTTP Session中，一个bean定义对应一个实例。该作用域仅在基于web的Spring ApplicationContext情形下有效。考虑下面bean定义：

 <bean id="userPreferences" class="com.foo.UserPreferences" scope="session"/>

针对某个HTTP Session，Spring容器会根据userPreferences bean定义创建一个全新的userPreferences bean实例，且该userPreferences bean仅在当前HTTP Session内有效。与request作用域一样，可以根据需要放心的更改所创建实例的内部状态，而别的HTTP Session中根据userPreferences创建的实例，将不会看到这些特定于某个HTTP Session的状态变化。当HTTP Session最终被废弃的时候，在该HTTP Session作用域内的bean也会被废弃掉。

2.3.2 作用域的选择

咱们从使用频率和线程安全的角度来思考

1）从使用频次上考虑，如果一个对象使用的频率非常高，建议使用单例，这样会将bean对象存储到bean池中，从始至终只有一个实例，可以减少对象创建，减少对资源的消耗。

2）在没有线程安全问题的前提下，没必要每次获取都创建一个对象，这样子既浪费CPU又浪费内存；

3）从使用频次上考虑，如果一个对象使用的频率非常低，没有必要将对象存储到map中（存储到bean池中的对象会一直存在bean池中，在spring容器销毁时销毁），建议使用多例。

4）如果一个对象被多个线程所共享，并且对象中存在共享数据，一旦这个数据被多个线程所操作，就可能会产生线程不安全问题，可以考虑使用多例

2.3.3 Bean的生命周期

生命周期：指一个对象何时创建、何时销毁以及从创建之后到销毁之前的所处的状态

单实例对象（singleton）：

出生：当spring容器对象创建时，bean对象就会被创建
活着：只要容器没有销毁，bean对象就会一直存活
死亡：当spring容器销毁，bean对象也会跟着消亡

总结：单例对象的生命周期和容器相同，spring容器负责singleton对象的创建、存储、销毁（随着spring容器销毁而销毁）。

多实例对象（prototype）：

出生：当获取bean对象时，spring框架才会为我们创建bean对象
活着：只要对象是在使用过程中，就会一直存活
死亡：当对象长时间不用，且没有别的对象引用时，由Java垃圾回收机制负责回收

总结：spring容器只负责prototype对象的创建和初始化，不负责存储和销毁。当对象长时间不用时，由Java垃圾回收机制负责回收

2.4 依赖注入(DI)

DI（Dependency Injection）依赖注入。即组件之间的依赖关系由容器在应用系统（项目）运行期来决定，也就是由容器动态地将存在某种依赖关系的目标对象实例注入到应用系统中的各个关联的组件之中。

简单来说，所谓的依赖注入其实就是，在创建对象的同时或之后，如何给对象的属性赋值。

如果对象由我们自己创建，这一切都变得很简单，例如：

User user = new User();
user.setName("小明"); //通过setName方法为name属性赋值
user.setAge(18); //通过setAge方法为age属性赋值

或者：

User user = new User("小明", 18); //在创建对象的同时,通过有参构造函数为对象的属性赋值

如果对象由Spring IoC容器创建，那么Spring是怎么给属性赋值的？Spring主要提供两种方式为属性赋值：

即：set方法注入和构造方法注入。

此外还有：@Autowired注解方式；静态工厂的方法注入；实例工厂的方法注入等。

2.4.1 set方法注入

顾名思义，即要求被注入的属性 , 必须在类中有set方法 , set方法的方法名由set + 属性首字母大写 , 如果属性是boolean类型 , 没有set方法 , 是 is。spring框架底层会调用set方法为成员变量赋值。

例如：Spring框架负责创建User的Bean对象之后，会通过调用User对象的setName方法为name属性赋值。

1）数据准备

Address.java

package com.shuilidianli.pojo;

public class Address {
    private String province;
    private String city;

    public void setProvince(String province) {
        this.province = province;
    }

    public void setCity(String city) {
        this.city = city;
    }

    @Override
    public String toString() {
        return "Address{" +
                "province='" + province + '\'' +
                ", city='" + city + '\'' +
                '}';
    }
}

Student.java

package com.shuilidianli.pojo;

import java.util.*;

public class Student {
private int id;
private String name;
private Address addr;
private String[] books;
private List<String> hobbys;
private Set<String> games;
private Map<String,String> cards;
private Properties info;
private String mgr;

public void setId(int id) {
this.id = id;
}

public void setName(String name) {
this.name = name;
}

public void setAddr(Address addr) {
this.addr = addr;
}

public void setBooks(String[] books) {
this.books = books;
}

public void setHobbys(List<String> hobbys) {
this.hobbys = hobbys;
}

public void setGames(Set<String> games) {
this.games = games;
}

public void setCards(Map<String, String> cards) {
this.cards = cards;
}

public void setInfo(Properties info) {
this.info = info;
}

public void setMgr(String mgr) {
this.mgr = mgr;
}

@Override
public String toString() {
return "Employee{" +
"id=" + id + "\n"+
", name='" + name + '\'' +"\n"+
", addr=" + addr +"\n"+
", books=" + Arrays.toString(books) +"\n"+
", hobbys=" + hobbys +"\n"+
", games=" + games +"\n"+
", cards=" + cards +"\n"+
", info=" + info +"\n"+
", mgr=" + mgr +
'}';
}
}

2）常量注入

<bean id="e1" class="com.shuilidianli.pojo.Employee">
   <property name="id" value="1001"/>
   <property name="name" value="小明"/>
</bean>

测试：

package com.shuilidianli.test;

import com.shuilidianli.pojo.Employee;
import com.shuilidianli.pojo.User;
import com.shuilidianli.web.EmpController;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class IOCTest {
    @Test
    public void test1() {
        ApplicationContext ctx =
                new ClassPathXmlApplicationContext("beans.xml");
        Employee con =
                ctx.getBean("emp1", Employee.class);
        System.out.println(con);

    }
}

3）Bean注入

注意：这里的值是一个引用，ref

4）数组注入

<bean id="e1" class="com.shuilidianli.pojo.Employee">
   <property name="id" value="1001"/>
   <property name="name" value="小明"/>
   <property name="addr" ref="a1"/>
   <property name="books">
      <array>
         <value>完美世界</value>
         <value>无限恐怖</value>
         <value>警世通言</value>
      </array>
   </property>
</bean>

5）List注入

<property name="hobbys">
   <list>
      <value>读书</value>
      <value>电影</value>
      <value>音乐</value>
   </list>
</property>

6）set注入

<property name="games">
   <set>
      <value>王者荣耀</value>
      <value>和平精英</value>
      <value>原神</value>
   </set>
</property>

7）Map注入

8）Properties注入

<property name="info">
   <props>
      <prop key="A001">迈巴赫</prop>
      <prop key="A002">玛莎拉蒂</prop>
      <prop key="A003">劳斯莱斯</prop>
   </props>
</property>

9）Null注入

<property name="mgr">
   <null/>
</property>

测试结果如下：

10）p命名空间

什么是 P 命名空间？

P命名空间不是新的东西，它是对 IoC 和 DI 的简化。使用 p 命名空间可以更加方便地完成 bean 的配置以及 bean 之间的依赖注入。

如何使用 p 命名空间？

首先必须确保 xml 文件中引入了 p 命名空间。

.....
xmlns:p="http://www.springframework.org/schema/p"
.....

修改bean


<bean id="a1" class="com.shuilidianli.pojo.Address">
   <property name="province" value="吉林"/>
   <property name="city" value="长春"/>
</bean>

<!--P(属性: properties)命名空间 , 属性依然要设置set方法-->
<bean id="e1" class="com.shuilidianli.pojo.Employee" p:id="1002" p:name="小红" p:addr-ref="a1">
   <property name="books">
      <array>
         <value>完美世界</value>
         <value>无限恐怖</value>
         <value>警世通言</value>
      </array>
   </property>
   //.......
</bean>

测试结果

2.4.2 构造方法注入

顾名思义，就是使用类中的构造函数，为成员变量赋值——即构造方法注入。

需要注意的是：为成员变量赋值是通过配置的方式，让spring框架在创建bean对象的同时，为成员变量赋值。而不是我们自己去实现。

1）准备数据

package com.shuilidianli.pojo;

public class Student {
    private int id;
    private String name;
    private int age;
    private Address addr;

    //提供无参构造器
    public Student() {
    }
    //提供有参数构造器              注：如果添加了有参构造器，无参构造器必须添加。 因为框架底层很多地方都用到了无参构造器的
    public Student(int id, String name, int age,Address addr) {
        this.id = id;
        this.name = name;
        this.age = age;
        this.addr = addr;
    }

    public void setId(int id) {
        this.id = id;
    }

    public void setName(String name) {
        this.name = name;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public void setAddr(Address addr) {
        this.addr = addr;
    }

    @Override
    public String toString() {
        return "Student{" +
                "id=" + id + "\n" +
                ", name='" + name + '\'' +"\n" +
                ", age=" + age +"\n" +
                ", addr=" + addr +
                '}';
    }
}

2）配置beans.xml文件

<bean id="student" class="com.shuilidianli.pojo.Student">

<constructor-arg name="id" value="2001"/>
<constructor-arg name="name" value="小天"/>
<constructor-arg name="age" value="23"/>
<constructor-arg name="addr" ref="a1"/>
</bean>

其中，constructor-arg标签name属性的值必须和构造函数中参数的名字相同!

同样的，普通属性直接通过value注入即可；对象属性通过ref属性注入。

3）测试

4）c 命名空间注入

需要在头文件中加入约束文件

导入约束 : xmlns:c="http://www.springframework.org/schema/c"

修改beans.xml

<!-- 将Student类作为bean装配到Spring IoC容器中(即Student类的实例由Spring创建) -->
<bean id="student" class="com.shuilidianli.pojo.Student" c:id="2002" c:name="小王" c:age="24">
   <!-- 通过构造方法为Student Bean的id、name、age、addr属性赋值 -->
   <!--<constructor-arg name="id" value="2001"/>
        <constructor-arg name="name" value="小天"/>
        <constructor-arg name="age" value="23"/>-->
   <constructor-arg name="addr" ref="a1"/>
</bean>

这里也能知道，c 就是所谓的构造器注入！

测试结果：

5）其他构造方法注入写法

<bean id="student" class="com.shuilidianli.pojo.Student">

<constructor-arg index="0" value="2001"/>
<constructor-arg index="1" value="小舞"/>
<constructor-arg index="2" value="23"/>
<constructor-arg index="3" ref="a1"/>
</bean>