spring 理解 - 技术栈

仅供个人学习，部分转自路人甲，侵删

spring容器

1.基本概念

2.Spring Ioc 容器

3.Spring Aop

4.数据访问

5.Spring MVC

6.事务管理

7.高级特性

8.整合其他框架

9.理解原理

基本概念

spring启动流程，加载配置文件，创建spring容器，实例化bean，注入依赖关系，初始化，aop配置。应用启动时，Spring会从配置中获取需要创建的对象以及对象依赖关系，spring容器会创建和组装好对象，然后将这些对象存放在spring容器中，当应用中需要使用的时候，可以到容器中查找获取。

spring 容器是用于管理和组织bean，有多个实现，常用就是ApplicationContext接口的实现类。

beanfactory 是最基本的容器接口，是延迟化的容器。

ApplicationContext 是 beanfactory子接口，提前初始化的容器，在启动完成时，对所有的bean对象实例子

di：spring容器中创建对象时给其设置依赖对象的方式

ioc：使用者使用依赖的对象需要自己去创建和组装，而现在交给spring容器去完成。如给spring一个配置，配置中列出了需要创建B对象以及其他的一些对象（可能包含了B类型中需要依赖对象），此时spring在创建B对象的时候，会看B对象需要依赖于哪些对象，然后去查找一下容器中有没有包含这些被依赖的对象，如果没有就去将其创建好，然后将其传递给B对象

BeanFactory接口

org.springframework.beans.factory.BeanFactory

spring容器中具有代表性的容器就是BeanFactory接口，这个是spring容器的顶层接口，提供了容器最基本的功能。

常用的几个方法

//按bean的id或者别名查找容器中的bean
Object getBean(String name) throws BeansException

//这个是一个泛型方法，按照bean的id或者别名查找指定类型的bean，返回指定类型的bean对象
<T> T getBean(String name, Class<T> requiredType) throws BeansException;

//返回容器中指定类型的bean对象
<T> T getBean(Class<T> requiredType) throws BeansException;

//获取指定类型bean对象的获取器，这个方法比较特别，以后会专门来讲
<T> ObjectProvider<T> getBeanProvider(Class<T> requiredType);

ApplicationContext接口

org.springframework.context.ApplicationContext

这个接口继承了BeanFactory接口，所以内部包含了BeanFactory所有的功能，并且在其上进行了扩展，增加了很多企业级功能，比如AOP、国际化、事件支持等

ClassPathXmlApplicationContext类

org.springframework.context.support.ClassPathXmlApplicationContext

这个类实现了ApplicationContext接口，注意一下这个类名称包含了ClassPath Xml，说明这个容器类可以从classpath中加载bean xml配置文件，然后创建xml中配置的bean对象

AnnotationConfigApplicationContext类

org.springframework.context.annotation.AnnotationConfigApplicationContext

这个类也实现了ApplicationContext接口，注意其类名包含了Annotation和config两个单词，上面我们有说过，bean的定义支持xml的方式和注解的方式，当我们使用注解的方式定义bean的时候，就需要用到这个容器来装载了，这个容器内部会解析注解来构建构建和管理需要的bean。

XML 复制代码

<dependencyManagement>
       <dependencies>
           <dependency>
               <groupId>org.springframework</groupId>
               <artifactId>spring-core</artifactId>
               <version>${spring.version}</version>
           </dependency>
           <dependency>
               <groupId>org.springframework</groupId>
               <artifactId>spring-context</artifactId>
               <version>${spring.version}</version>
           </dependency>
           <dependency>
               <groupId>org.springframework</groupId>
               <artifactId>spring-beans</artifactId>
               <version>${spring.version}</version>
           </dependency>
       </dependencies>
    </dependencyManagement>

spring-core 提供了轻量级、非入侵的方式管理对象。主要包含ioc，di。还提供aop支持，用来记录日志，性能监控。

spring-context 在spring-core的基础上，加载和管理bean，并提供处理配置依赖注入生命周期。

应用程序的上下文由ApplicationContext接口表示，充当了同期角色，是spring-context 的核心接口之一。管理bean，作用域，并提供bean的访问。提供可扩展的方式管理应用程序的上下文，并支持各种配置及功能。

spring-boot 打印所有的bean

java 复制代码

ApplicationContext appctx = SpringApplication.run(DemoApplication.class, args)
String[] beanNames =appctx.getBeanDefinitionNames();
Arrays.sort(beanNames);
for(String beanNamse:beanNames){
    System.out.print("name:"+ beanName)
}

spring-beans 提供bean的定义，配置。xml，注解等；bean的实例化和初始化；bean的生命周期；bean的作用域管理

下面bean名称和别名的各种写法

java 复制代码

<!-- 通过id定义bean名称：user1 -->
<bean id="user1" class="com.javacode.lesson.demo.User"/>

<!-- 通过name定义bean名称：user2 -->
<bean name="user2" class="com.javacode.lesson.demo.User"/>

<!-- id为名称，name为别名；bean名称：user3，1个别名：[user3_1] -->
<bean id="user3" name="user3_1" class="com.javacode.lesson.demo.User"/>

<!-- bean名称：user4，多个别名：[user4_1,user4_2,user4_3,user4_4] -->
<bean id="user4" name="user4_1,user4_2;user4_3 user4_4" class="com.javacode.lesson.demo.User"/>

<!-- bean名称：user5，别名：[user5_1,user5_2,user5_3,user5_4] -->
<bean name="user5,user5_1,user5_2;user5_3 user5_4" class="com.javacode.lesson.demo.User"/>

我们来写个java来输出上面所有bean的名称和其别名，如下：

java 复制代码

package com.javacode2018.lesson001.demo2;

import org.springframework.beans.factory.BeanFactory;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import java.util.Arrays;


public class Client {

    public static void main(String[] args) {
        //1.bean配置文件位置
        String beanXml = "classpath:/com/javacode/lesson/demo/beans.xml";

        //2.创建ClassPathXmlApplicationContext容器，给容器指定需要加载的bean配置文件
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext(beanXml);

        for (String beanName : Arrays.asList("user1", "user2", "user3", "user4", "user5")) {
            //获取bean的别名
            String[] aliases = context.getAliases(beanName);
            System.out.println(String.format("beanName:%s, 别名:[%s]", beanName, String.join(",", aliases)));
        }

        System.out.println("spring容器中所有bean如下：");

        //getBeanDefinitionNames用于获取容器中所有bean的名称
        for (String beanName : context.getBeanDefinitionNames()) {
            //获取bean的别名
            String[] aliases = context.getAliases(beanName);
            System.out.println(String.format("beanName:%s, 别名:[%s]", beanName, String.join(",", aliases)));
        }

    }
}

上面有2个新的方法：

getAliases：通过bean名称获取这个bean的所有别名

getBeanDefinitionNames：返回spring容器中定义的所有bean的名称

运行输出：

java 复制代码

beanName:user1, 别名:[]
beanName:user2, 别名:[]
beanName:user3, 别名:[user3_1]
beanName:user4, 别名:[user4_1,user4_4,user4_2,user4_3]
beanName:user5, 别名:[user5_3,user5_4,user5_1,user5_2]
spring容器中所有bean如下：
beanName:user1, 别名:[]
beanName:user2, 别名:[]
beanName:user3, 别名:[user3_1]
beanName:user4, 别名:[user4_1,user4_4,user4_2,user4_3]
beanName:user5, 别名:[user5_3,user5_4,user5_1,user5_2]

bean的作用域

singleton：单例bean

prototype：多例bean，每次获取都是不同的bean，可能影响性能

下面三个spring web容器：

**request ：一次请求，一个bean对应一个实例。request结束，这个bean结束。**request作用域用在spring容器的web环境

**session：**session级别共享的bean，每个会话对应一个bean，不同的session对应不同的bean实例。

application：全局web应用级别。一个web容器对应一个bean实例，和singleton效果类似；一个应用程序可以创建多个容器，sope=aplication，多个容器也只能有一个bean

自定义scope，

第1步：实现Scope接口

我们来看一下这个接口定义

java 复制代码

package org.springframework.beans.factory.config;

import org.springframework.beans.factory.ObjectFactory;
import org.springframework.lang.Nullable;

public interface Scope {

    /**
    * 返回当前作用域中name对应的bean对象
    * name：查找bean的名称
    * objectFactory：如果name对应的bean在当前作用域中没有找到，那么可以调用这个ObjectFactory来创建这个对象
    **/
    Object get(String name, ObjectFactory<?> objectFactory);

    /**
     * 将name对应的bean从当前作用域中移除
     **/
    @Nullable
    Object remove(String name);

    /**
     * 用于注册销毁回调，如果想要销毁相应的对象,则由Spring容器注册相应的销毁回调，而由自定义作用域选择是不是要销毁相应的对象
     */
    void registerDestructionCallback(String name, Runnable callback);

    /**
     * 用于解析相应的上下文数据，比如request作用域将返回request中的属性。
     */
    @Nullable
    Object resolveContextualObject(String key);

    /**
     * 作用域的会话标识，比如session作用域将是sessionId
     */
    @Nullable
    String getConversationId();

}

第2步：将自定义的scope注册到容器

需要调用org.springframework.beans.factory.config.ConfigurableBeanFactory#registerScope的方法，看一下这个方法的声明

/**
* 向容器中注册自定义的Scope
*scopeName：作用域名称
* scope：作用域对象
**/
void registerScope(String scopeName, Scope scope);

第3步：使用自定义的作用域

定义bean的时候，指定bean的scope属性为自定义的作用域名称。

案例

需求

下面我们来实现一个线程级别的bean作用域，同一个线程中同名的bean是同一个实例，不同的线程中的bean是不同的实例。

实现分析

需求中要求bean在线程中是贡献的，所以我们可以通过ThreadLocal来实现，ThreadLocal可以实现线程中数据的共享。

下面我们来上代码。

ThreadScope

java 复制代码

package com.javacode.lesson.demo;

import org.springframework.beans.factory.ObjectFactory;
import org.springframework.beans.factory.config.Scope;
import org.springframework.lang.Nullable;

import java.util.HashMap;
import java.util.Map;
import java.util.Objects;

/**
 * 自定义本地线程级别的bean作用域，不同的线程中bean实例是不同的，同一个线程中同名的bean是一个实际例
 */
public class ThreadScope implements Scope {

    public static final String THREAD_SCOPE = "thread";//@1

    private ThreadLocal<Map<String, Object>> beanMap = new ThreadLocal() {
        @Override
        protected Object initialValue() {
            return new HashMap<>();
        }
    };

    @Override
    public Object get(String name, ObjectFactory<?> objectFactory) {
        Object bean = beanMap.get().get(name);
        if (Objects.isNull(bean)) {
            bean = objectFactory.getObject();
            beanMap.get().put(name, bean);
        }
        return bean;
    }

    @Nullable
    @Override
    public Object remove(String name) {
        return this.beanMap.get().remove(name);
    }

    @Override
    public void registerDestructionCallback(String name, Runnable callback) {
        //bean作用域范围结束的时候调用的方法，用于bean清理
        System.out.println(name);
    }

    @Nullable
    @Override
    public Object resolveContextualObject(String key) {
        return null;
    }

    @Nullable
    @Override
    public String getConversationId() {
        return Thread.currentThread().getName();
    }
}

@1：定义了作用域的名称为一个常量thread，可以在定义bean的时候给scope使用

BeanScopeModel

java 复制代码

package com.javacode.lesson.demo;

public class BeanScopeModel {
    public BeanScopeModel(String beanScope) {
        System.out.println(String.format("线程:%s,create BeanScopeModel,{sope=%s},{this=%s}", Thread.currentThread(), beanScope, this));
    }
}

上面的构造方法中会输出当前线程的信息，到时候可以看到创建bean的线程。

bean配置文件

beans-thread.xml内容

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-4.3.xsd">

    <!-- 自定义scope的bean -->
    <bean id="threadBean" class="com.javacode.lesson.demo.BeanScopeModel" scope="thread">
        <constructor-arg index="0" value="thread"/>
    </bean>
</beans>

注意上面的scope是我们自定义的，值为thread

测试用例

java 复制代码

package com.javacode.lesson.demo;

import org.springframework.context.support.ClassPathXmlApplicationContext;

import java.util.concurrent.TimeUnit;

/**
 * 自定义scope
 */
public class ThreadScopeTest {
    public static void main(String[] args) throws InterruptedException {
        String beanXml = "classpath:/com/javacode/lesson/demo/beans-thread.xml";
        //手动创建容器
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext();
        //设置配置文件位置
        context.setConfigLocation(beanXml);
        //启动容器
        context.refresh();
        //向容器中注册自定义的scope
        context.getBeanFactory().registerScope(ThreadScope.THREAD_SCOPE, new ThreadScope());//@1

        //使用容器获取bean
        for (int i = 0; i < 2; i++) { //@2
            new Thread(() -> {
                System.out.println(Thread.currentThread() + "," + context.getBean("threadBean"));
                System.out.println(Thread.currentThread() + "," + context.getBean("threadBean"));
            }).start();
            TimeUnit.SECONDS.sleep(1);
        }
    }
}

注意上面代码，重点在@1，这个地方向容器中注册了自定义的ThreadScope。

@2：创建了2个线程，然后在每个线程中去获取同样的bean 2次，然后输出，我们来看一下效果。

运行输出

java 复制代码

线程:Thread[Thread-1,5,main],create BeanScopeModel,{sope=thread},{this=com.javacode.lesson.demo.BeanScopeModel@4049d532}
Thread[Thread-1,5,main],com.javacode.lesson.demo.BeanScopeModel@4049d532
Thread[Thread-1,5,main],com.javacode.lesson.demo.BeanScopeModel@4049d532
线程:Thread[Thread-2,5,main],create BeanScopeModel,{sope=thread},{this=com.javacode.lesson.demo.BeanScopeModel@87a76dd}
Thread[Thread-2,5,main],com.javacode.lesson.demo.BeanScopeModel@87a76dd
Thread[Thread-2,5,main],com.javacode.lesson.demo.BeanScopeModel@87a76dd

从输出中可以看到，bean在同样的线程中获取到的是同一个bean的实例，不同的线程中bean的实例是不同的。

依赖注入：（spring容器内部支持）

一个类对外提供的功能需要通过调用其他类的方法来实现的时候，这两个类之间存在依赖关系

参考：Spring系列第7篇：依赖注入之手动注入

两个类组合，直接new赋值，或者使用set方法。

构造函数的方式

参数索引

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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
    http://www.springframework.org/schema/beans/spring-beans-4.3.xsd">

    <!-- 通过构造器参数的索引注入 -->
    <bean id="diByConstructorParamIndex" class="com.javacode.lesson.demo.User">
        <constructor-arg index="0" value="name"/>
        <constructor-arg index="1" value="sex"/>
    </bean>

</beans>

相当于

User user= new User（"name","sex"）；

参数类型

java 复制代码

<bean id="diByConstructorParamType" class="com.javacode.lesson.demo.User">
    <constructor-arg type="参数类型" value="参数值"/>
    <constructor-arg type="参数类型" value="参数值"/>
</bean>

type：构造函数参数类型，如：java.lang.String,int,double

value：构造器参数的值，value只能用来给简单的类型设置值

参数名称

java 复制代码

<bean id="diByConstructorParamName" class="com.javacode.lesson.demo.User">
    <constructor-arg name="参数类型" value="参数值"/>
    <constructor-arg name="参数类型" value="参数值"/>
</bean>

方法参数名称的问题

java通过反射的方式可以获取到类的相关信息，源码中的变量名在编译为class文件后，参数的真实名称会丢失，例如会变成arg0,arg1,arg2这样的，在java8之后，编译加上-parameters，会保留真实的方法参数，从而使反射获取到真实的参数名称。
java 复制代码
javac -parameters yourClass.java
但是难以保证编译的时候，一定会带上-parameters参数，所以方法的参数可能在class文件中会丢失，导致反射获取到的参数名称和实际参数名称不符.

参数名称可能不稳定的问题，spring提供了解决方案，通过ConstructorProperties注解来定义参数的名称，将这个注解加在构造方法上面
java 复制代码
@ConstructorProperties({"第一个参数名称", "第二个参数的名称",..."第n个参数的名称"})
public 类名(String s1, String s2...,参数n) {
}

Car.java

java 复制代码

package com.java.lesson.demo;

import java.beans.ConstructorProperties;

public class Car {
    private String name;
    //描述
    private String desc;

    public CarModel() {
    }

    @ConstructorProperties({"name", "desc"})
    public CarModel(String name, String desc) {
        this.name =name;
        this.desc =desc;
    }

    @Override
    public String toString() {
        return "Car{" +
                "name='" + name + '\'' +
                ", desc='" + desc + '\'' +
                '}';
    }
}

constructorParamName.xml

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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
    http://www.springframework.org/schema/beans/spring-beans-4.3.xsd">

    <!-- 通过构造器参数的名称注入 -->
    <bean id="diByConstructorParamName" class="com.javacode.lesson.demo.Car">
        <constructor-arg name="desc" value="我是通过构造器注入描述"/>
        <constructor-arg name="name" value="BMW"/>
    </bean>

</beans>

上面创建Car实例代码相当于下面代码：

java 复制代码

Car car = new Car("BWM","我是通过构造器注入的描述");

set属性的方式

通常情况下，我们的类都是标准的javabean，javabean类的特点：

属性都是private访问级别的
属性通常情况下通过一组setter（修改）和getter（访问）方法来访问
setter方法，以set开头，后跟首字母大写的属性名，如：setUserName，简单属性一般只有一个方法参数，方法返回值通常为void;
getter方法，一般属性以get开头，对于boolean类型一般以is开头，后跟首字母大写的属性名，如：getUserName，isOk；

spring对符合javabean特点类，提供了setter方式的注入，会调用对应属性的setter方法将被依赖的对象注入进去。

用法

java 复制代码

<bean id="" class="">
    <property name="属性名" value="属性值" />
    ...
    <property name="属性名" value="属性值" />
</bean>

property用于对属性的值进行配置，可以有多个

name：属性的名称

value：属性的值

Order.java

java 复制代码

package com.javacode.lesson.demo;

/**
 * 订单类
 */
public class Order {
    //订单
    private String name;
    //排序
    private Integer sort;

    public String getName() {
        return name;
    }

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

    public Integer getSort() {
        return sort;
    }

    public void setSort(Integer sort) {
        this.ort = ort;
    }

    @Override
    public String toString() {
        return "Order{" +
                "name='" +name + '\'' +
                ", sort=" + sort +
                '}';
    }
}

Setter.xml

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-4.3.xsd">

    <bean id="bySetter" class="com.javacode.lesson.demo.Order">
        <property name="name" value="dingdan"/>
    </bean>

</beans>

优缺点

setter注入相对于构造函数注入要灵活，构造函数需要指定对应构造函数中所有参数的值，而setter注入的方式没有这种限制，不需要对所有属性都进行注入，可以按需注入。

上面介绍的都是注入普通类型的对象，都是通过value属性来设置需要注入的对象的值的，value属性的值是String类型的，spring容器内部自动会将value的值转换为对象的实际类型。

若我们依赖的对象是容器中的其他bean对象的时候，需要用下面的方式进行注入。

注入容器中的bean

注入容器中的bean有两种写法：

ref属性方式
内置bean的方式

ref属性方式

将上面介绍的constructor-arg或者property元素的value属性名称替换为ref，ref属性的值为容器中其他bean的名称，如：

构造器方式，将value替换为ref：

<constructor-arg ref="需要注入的bean的名称"/>

setter方式，将value替换为ref：

<property name="属性名称" ref="需要注入的bean的名称" />

内置bean的方式

构造器的方式：

<constructor-arg>
    <bean class=""/>
</constructor-arg>

setter方式：

<property name="属性名称">
    <bean class=""/>
</property>

案例

Person.java

java 复制代码

package com.javacode.lesson.demo;

public class Person {
    private User user;
    private Car car;

    public Person() {
    }

    public Person(User user, Car car) {
        this.user = user;
        this.car = car;
    }

    public User getUser() {
        return user;
    }

    public void setUser(User user) {
        this.user = user;
    }

    public Car getCar() {
        return car;
    }

    public void setCar(Car car) {
        this.car = car;
    }

    @Override
    public String toString() {
        return "Person{" +
                "user=" + user +
                ", car=" + car +
                '}';
    }
}

Person中有依赖于2个对象User、Car，下面我们通过spring将User和Car创建好，然后注入到Person中，下面创建bean配置文件

Bean.xml

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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
    http://www.springframework.org/schema/beans/spring-beans-4.3.xsd">

    <bean id="user" class="com.javacode.lesson.demo.User"></bean>

    <!-- 通过构造器方式注入容器中的bean -->
    <bean id="ByConstructor" class="com.javacode.lesson.demo.Person">
        <!-- 通过ref引用容器中定义的其他bean，user对应上面定义的id="user"的bean -->
        <constructor-arg index="0" ref="user"/>
        <constructor-arg index="1">
            <bean class="com.javacode.lesson.demo.Car">
                <constructor-arg index="0" value="name"/>
                <constructor-arg index="1" value=""/>
            </bean>
        </constructor-arg>
    </bean>

    <!-- 通过setter方式注入容器中的bean -->
    <bean id="BySetter" class="com.javacode.lesson.demo.Person">
        <!-- 通过ref引用容器中定义的其他bean，user对应上面定义的id="user"的bean -->
        <property name="user" ref="user"/>
        <property name="car">
            <bean class="com.javacode.lesson.demo.Car">
                <constructor-arg index="0" value="bmw"/>
                <constructor-arg index="1" value="aa"/>
            </bean>
        </property>
    </bean>

</beans>

其他类型注入：

注入java.util.List（list元素）

java 复制代码

<list>
    <value>Spring</value>
    or
    <ref bean="bean名称"/>
    or
    <list></list>
    
    <array></array>
    
    <map></map>
    <bean></bean>
</list>

注入java.util.Set（set元素）

java 复制代码

<set>
    <value>Spring</value>
    or
    <ref bean="bean名称"/>
    or
    <list></list>
    
    <array></array>
 
    <map></map>
    <bean></bean>
</set>

注入java.util.Map（map元素）

java 复制代码

<map>
    <entry key="" value="" key-ref="key引用的bean名称" value-ref="value引用的bean名称"/>
    或
    <entry>
        <key>
            value对应的值,任意类型
        </key>
        <value>
            value对应的值，任意类型
        </value>
    </entry>
</map>

注入数组（array元素）

java 复制代码

<array>
    数组中的元素
</array>

注入java.util.Properties（props元素）

Properties类相当于键值都是String类型的Map对象，使用props进行注入，如下：

java 复制代码

<props>
    <prop key="key1">java</prop>
    <prop key="key2">go</prop>
    <prop key="key3">python</prop>
</props>

案例

对于上面这些类型来个综合案例。

OtherType.java

java 复制代码

package com.javacode.lesson.demo;

import java.util.*;

public class OtherType {
    private List<String> list1;
    private Set<UserModel> set1;
    private Map<String, Integer> map1;
    private int[] array1;
    private Properties properties1;

    public List<String> getList1() {
        return list1;
    }

    public void setList1(List<String> list1) {
        this.list1 = list1;
    }

    public Set<UserModel> getSet1() {
        return set1;
    }

    public void setSet1(Set<UserModel> set1) {
        this.set1 = set1;
    }

    public Map<String, Integer> getMap1() {
        return map1;
    }

    public void setMap1(Map<String, Integer> map1) {
        this.map1 = map1;
    }

    public int[] getArray1() {
        return array1;
    }

    public void setArray1(int[] array1) {
        this.array1 = array1;
    }

    public Properties getProperties1() {
        return properties1;
    }

    public void setProperties1(Properties properties1) {
        this.properties1 = properties1;
    }

    @Override
    public String toString() {
        return "OtherType{" +
                "list1=" + list1 +
                ", set1=" + set1 +
                ", map1=" + map1 +
                ", array1=" + Arrays.toString(array1) +
                ", properties1=" + properties1 +
                '}';
    }
}

上面这个类中包含了刚才我们介绍的各种类型，下面来进行注入。

OtherType.xml

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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
    http://www.springframework.org/schema/beans/spring-beans-4.3.xsd">

    <bean id="user1" class="com.javacode.lesson.demo.User"/>
    <bean id="user2" class="com.javacode.lesson.demo.User"/>

    <bean id="OtherType" class="com.javacode.lesson.demo.OtherType">
        <!-- 注入java.util.List对象 -->
        <property name="list1">
            <list>
                <value>A</value>
                <value>B</value>
            </list>
        </property>

        <!-- 注入java.util.Set对象 -->
        <property name="set1">
            <set>
                <ref bean="user1"/>
                <ref bean="user2"/>
                <ref bean="user1"/>
            </set>
        </property>

        <!-- 注入java.util.Map对象 -->
        <property name="map1">
            <map>
                <entry key="key1" value="0"/>
                <entry key="key2" value="1"/>
            </map>
        </property>

        <!-- 注入数组对象 -->
        <property name="array1">
            <array>
                <value>1</value>
                <value>2</value>
                <value>3</value>
            </array>
        </property>

        <!-- 注入java.util.Properties对象 -->
        <property name="properties1">
            <props>
                <prop key="key1">java</prop>
                <prop key="key2">go</prop>
                <prop key="key3">python</prop>
            </props>
        </property>

    </bean>
</beans>

自动注入是约定大于配置

xml中可以在bean元素中通过autowire属性来设置自动注入的方式：

<bean id="" class="" autowire="byType|byName|constructor|default" />

byteName：按照名称进行注入
byType：按类型进行注入，被注入的bean的类是声明的set属性的类型的子类或者同类型
constructor：按照构造方法进行注入

default：默认注入方式

<?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-4.3.xsd"
       default-autowire="byName">

</beans>

depeng on :

bean对象的创建顺序和bean xml中定义的顺序一致
bean销毁的顺序和bean xml中定义的顺序相反
bean对象的创建顺序和bean依赖的顺序一致
bean销毁的顺序和bean创建的顺序相反

depend-on使用方式：

<bean id="bean1" class="" depend-on="bean2,bean3; bean4" />

depend-on：设置当前bean依赖的bean名称，可以指定多个，多个之间可以用",;空格"进行分割

上面不管bean2,bean2,bean4在任何地方定义，都可以确保在bean1创建之前，会先将bean2,bean3,bean4创建好，表示bean1依赖于这3个bean，可能bean1需要用到bean2、bean3、bean4中生成的一些资源或者其他的功能等，但是又没有强制去在bean1类中通过属性定义强依赖的方式去依赖于bean2、bean3、bean4；当然销毁的时候也会先销毁当前bean，再去销毁被依赖的bean，即先销毁bean1，再去销毁depend-on指定的bean。