• 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容器的顶层接口，提供了容器最基本的功能。

    常用的几个方法
    1. //按bean的id或者别名查找容器中的bean
    2. Object getBean(String name) throws BeansException
    3.  
    4. //这个是一个泛型方法，按照bean的id或者别名查找指定类型的bean，返回指定类型的bean对象
    5. <T> T getBean(String name, Class<T> requiredType) throws BeansException;
    6.  
    7. //返回容器中指定类型的bean对象
    8. <T> T getBean(Class<T> requiredType) throws BeansException;
    9.  
    10. //获取指定类型bean对象的获取器，这个方法比较特别，以后会专门来讲
    11. <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。

    1. <dependencyManagement>
    2.        <dependencies>
    3.            <dependency>
    4.                <groupId>org.springframeworkgroupId>
    5.                <artifactId>spring-coreartifactId>
    6.                <version>${spring.version}version>
    7.            dependency>
    8.            <dependency>
    9.                <groupId>org.springframeworkgroupId>
    10.                <artifactId>spring-contextartifactId>
    11.                <version>${spring.version}version>
    12.            dependency>
    13.            <dependency>
    14.                <groupId>org.springframeworkgroupId>
    15.                <artifactId>spring-beansartifactId>
    16.                <version>${spring.version}version>
    17.            dependency>
    18.        dependencies>
    19.     dependencyManagement>

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

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

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

    spring-boot 打印所有的bean

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

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

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

    2. "user1" class="com.javacode.lesson.demo.User"/>
    3.  
    5. "user2" class="com.javacode.lesson.demo.User"/>
    6.  
    8. "user3" name="user3_1" class="com.javacode.lesson.demo.User"/>
    9.  
    11. "user4" name="user4_1,user4_2;user4_3 user4_4" class="com.javacode.lesson.demo.User"/>
    12.  
    14. "user5,user5_1,user5_2;user5_3 user5_4" class="com.javacode.lesson.demo.User"/>

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

    1. package com.javacode2018.lesson001.demo2;
    2.  
    3. import org.springframework.beans.factory.BeanFactory;
    4. import org.springframework.context.support.ClassPathXmlApplicationContext;
    5.  
    6. import java.util.Arrays;
    7.  
    8.  
    9. public class Client {
    10.  
    11.     public static void main(String[] args) {
    12.         //1.bean配置文件位置
    13.         String beanXml = "classpath:/com/javacode/lesson/demo/beans.xml";
    14.  
    15.         //2.创建ClassPathXmlApplicationContext容器，给容器指定需要加载的bean配置文件
    16.         ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext(beanXml);
    17.  
    18.         for (String beanName : Arrays.asList("user1", "user2", "user3", "user4", "user5")) {
    19.             //获取bean的别名
    20.             String[] aliases = context.getAliases(beanName);
    21.             System.out.println(String.format("beanName:%s, 别名:[%s]", beanName, String.join(",", aliases)));
    22.         }
    23.  
    24.         System.out.println("spring容器中所有bean如下：");
    25.  
    26.         //getBeanDefinitionNames用于获取容器中所有bean的名称
    27.         for (String beanName : context.getBeanDefinitionNames()) {
    28.             //获取bean的别名
    29.             String[] aliases = context.getAliases(beanName);
    30.             System.out.println(String.format("beanName:%s, 别名:[%s]", beanName, String.join(",", aliases)));
    31.         }
    32.  
    33.     }
    34. }

    上面有2个新的方法：

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

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

    运行输出：

    1. beanName:user1, 别名:[]
    2. beanName:user2, 别名:[]
    3. beanName:user3, 别名:[user3_1]
    4. beanName:user4, 别名:[user4_1,user4_4,user4_2,user4_3]
    5. beanName:user5, 别名:[user5_3,user5_4,user5_1,user5_2]
    6. spring容器中所有bean如下：
    7. beanName:user1, 别名:[]
    8. beanName:user2, 别名:[]
    9. beanName:user3, 别名:[user3_1]
    10. beanName:user4, 别名:[user4_1,user4_4,user4_2,user4_3]
    11. 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接口

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

    1. package org.springframework.beans.factory.config;
    2.  
    3. import org.springframework.beans.factory.ObjectFactory;
    4. import org.springframework.lang.Nullable;
    5.  
    6. public interface Scope {
    7.  
    8.     /**
    9.     * 返回当前作用域中name对应的bean对象
    10.     * name：查找bean的名称
    11.     * objectFactory：如果name对应的bean在当前作用域中没有找到，那么可以调用这个ObjectFactory来创建这个对象
    12.     **/
    13.     Object get(String name, ObjectFactory objectFactory);
    14.  
    15.     /**
    16.      * 将name对应的bean从当前作用域中移除
    17.      **/
    18.     @Nullable
    19.     Object remove(String name);
    20.  
    21.     /**
    22.      * 用于注册销毁回调，如果想要销毁相应的对象,则由Spring容器注册相应的销毁回调，而由自定义作用域选择是不是要销毁相应的对象
    23.      */
    24.     void registerDestructionCallback(String name, Runnable callback);
    25.  
    26.     /**
    27.      * 用于解析相应的上下文数据，比如request作用域将返回request中的属性。
    28.      */
    29.     @Nullable
    30.     Object resolveContextualObject(String key);
    31.  
    32.     /**
    33.      * 作用域的会话标识，比如session作用域将是sessionId
    34.      */
    35.     @Nullable
    36.     String getConversationId();
    37.  
    38. }
    第2步：将自定义的scope注册到容器

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

    1. /**
    2. * 向容器中注册自定义的Scope
    3. *scopeName：作用域名称
    4. * scope：作用域对象
    5. **/
    6. void registerScope(String scopeName, Scope scope);
    第3步：使用自定义的作用域

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

    案例
    需求

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

    实现分析

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

    下面我们来上代码。

    ThreadScope
    1. package com.javacode.lesson.demo;
    2.  
    3. import org.springframework.beans.factory.ObjectFactory;
    4. import org.springframework.beans.factory.config.Scope;
    5. import org.springframework.lang.Nullable;
    6.  
    7. import java.util.HashMap;
    8. import java.util.Map;
    9. import java.util.Objects;
    10.  
    11. /**
    12.  * 自定义本地线程级别的bean作用域，不同的线程中bean实例是不同的，同一个线程中同名的bean是一个实际例
    13.  */
    14. public class ThreadScope implements Scope {
    15.  
    16.     public static final String THREAD_SCOPE = "thread";//@1
    17.  
    18.     private ThreadLocal> beanMap = new ThreadLocal() {
    19.         @Override
    20.         protected Object initialValue() {
    21.             return new HashMap<>();
    22.         }
    23.     };
    24.  
    25.     @Override
    26.     public Object get(String name, ObjectFactory objectFactory) {
    27.         Object bean = beanMap.get().get(name);
    28.         if (Objects.isNull(bean)) {
    29.             bean = objectFactory.getObject();
    30.             beanMap.get().put(name, bean);
    31.         }
    32.         return bean;
    33.     }
    34.  
    35.     @Nullable
    36.     @Override
    37.     public Object remove(String name) {
    38.         return this.beanMap.get().remove(name);
    39.     }
    40.  
    41.     @Override
    42.     public void registerDestructionCallback(String name, Runnable callback) {
    43.         //bean作用域范围结束的时候调用的方法，用于bean清理
    44.         System.out.println(name);
    45.     }
    46.  
    47.     @Nullable
    48.     @Override
    49.     public Object resolveContextualObject(String key) {
    50.         return null;
    51.     }
    52.  
    53.     @Nullable
    54.     @Override
    55.     public String getConversationId() {
    56.         return Thread.currentThread().getName();
    57.     }
    58. }

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

    BeanScopeModel
    1. package com.javacode.lesson.demo;
    2.  
    3. public class BeanScopeModel {
    4.     public BeanScopeModel(String beanScope) {
    5.         System.out.println(String.format("线程:%s,create BeanScopeModel,{sope=%s},{this=%s}", Thread.currentThread(), beanScope, this));
    6.     }
    7. }

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

    bean配置文件

    beans-thread.xml内容

    1. "1.0" encoding="UTF-8"?>
    2. <beans xmlns="http://www.springframework.org/schema/beans"
    3.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    4.        xsi:schemaLocation="http://www.springframework.org/schema/beans
    5.     http://www.springframework.org/schema/beans/spring-beans-4.3.xsd">
    6.  
    7.     
    8.     <bean id="threadBean" class="com.javacode.lesson.demo.BeanScopeModel" scope="thread">
    9.         <constructor-arg index="0" value="thread"/>
    10.     bean>
    11. beans>

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

    测试用例
    1. package com.javacode.lesson.demo;
    2.  
    3. import org.springframework.context.support.ClassPathXmlApplicationContext;
    4.  
    5. import java.util.concurrent.TimeUnit;
    6.  
    7. /**
    8.  * 自定义scope
    9.  */
    10. public class ThreadScopeTest {
    11.     public static void main(String[] args) throws InterruptedException {
    12.         String beanXml = "classpath:/com/javacode/lesson/demo/beans-thread.xml";
    13.         //手动创建容器
    14.         ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext();
    15.         //设置配置文件位置
    16.         context.setConfigLocation(beanXml);
    17.         //启动容器
    18.         context.refresh();
    19.         //向容器中注册自定义的scope
    20.         context.getBeanFactory().registerScope(ThreadScope.THREAD_SCOPE, new ThreadScope());//@1
    21.  
    22.         //使用容器获取bean
    23.         for (int i = 0; i < 2; i++) { //@2
    24.             new Thread(() -> {
    25.                 System.out.println(Thread.currentThread() + "," + context.getBean("threadBean"));
    26.                 System.out.println(Thread.currentThread() + "," + context.getBean("threadBean"));
    27.             }).start();
    28.             TimeUnit.SECONDS.sleep(1);
    29.         }
    30.     }
    31. }

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

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

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

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

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

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

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

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

    构造函数的方式

    参数索引

    1. "1.0" encoding="UTF-8"?>
    2. "http://www.springframework.org/schema/beans"
    3.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    4.        xsi:schemaLocation="http://www.springframework.org/schema/beans
    5.     http://www.springframework.org/schema/beans/spring-beans-4.3.xsd">
    6.  
    7.     
    8.     "diByConstructorParamIndex" class="com.javacode.lesson.demo.User">
    9.         "0" value="name"/>
    10.         "1" value="sex"/>
    11.     
    12.

    相当于

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

    参数类型

    1. "diByConstructorParamType" class="com.javacode.lesson.demo.User">
    2.     "参数类型" value="参数值"/>
    3.     "参数类型" value="参数值"/>

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

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

    参数名称

    1. "diByConstructorParamName" class="com.javacode.lesson.demo.User">
    2.     "参数类型" value="参数值"/>
    3.     "参数类型" value="参数值"/>
    方法参数名称的问题

    java通过反射的方式可以获取到类的相关信息，源码中的变量名在编译为class文件后，参数的真实名称会丢失，例如会变成arg0,arg1,arg2这样的，在java8之后，编译加上-parameters，会保留真实的方法参数，从而使反射获取到真实的参数名称。

    javac -parameters yourClass.java

    但是难以保证编译的时候，一定会带上-parameters参数，所以方法的参数可能在class文件中会丢失，导致反射获取到的参数名称和实际参数名称不符.

    参数名称可能不稳定的问题，spring提供了解决方案，通过ConstructorProperties注解来定义参数的名称，将这个注解加在构造方法上面

    1. @ConstructorProperties({"第一个参数名称", "第二个参数的名称",..."第n个参数的名称"})
    2. public 类名(String s1, String s2...,参数n) {
    3. }
    Car.java
    1. package com.java.lesson.demo;
    2.  
    3. import java.beans.ConstructorProperties;
    4.  
    5. public class Car {
    6.     private String name;
    7.     //描述
    8.     private String desc;
    9.  
    10.     public CarModel() {
    11.     }
    12.  
    13.     @ConstructorProperties({"name", "desc"})
    14.     public CarModel(String name, String desc) {
    15.         this.name =name;
    16.         this.desc =desc;
    17.     }
    18.  
    19.     @Override
    20.     public String toString() {
    21.         return "Car{" +
    22.                 "name='" + name + '\'' +
    23.                 ", desc='" + desc + '\'' +
    24.                 '}';
    25.     }
    26. }
    constructorParamName.xml
    1. "1.0" encoding="UTF-8"?>
    2. "http://www.springframework.org/schema/beans"
    3.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    4.        xsi:schemaLocation="http://www.springframework.org/schema/beans
    5.     http://www.springframework.org/schema/beans/spring-beans-4.3.xsd">
    6.  
    7.     
    8.     "diByConstructorParamName" class="com.javacode.lesson.demo.Car">
    9.         "desc" value="我是通过构造器注入描述"/>
    10.         "name" value="BMW"/>
    11.     
    12.

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

    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方法将被依赖的对象注入进去。

    用法
    1. "" class="">
    2.     "属性名" value="属性值" />
    3.     ...
    4.     "属性名" value="属性值" />

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

    name：属性的名称

    value：属性的值

    Order.java
    1. package com.javacode.lesson.demo;
    2.  
    3. /**
    4.  * 订单类
    5.  */
    6. public class Order {
    7.     //订单
    8.     private String name;
    9.     //排序
    10.     private Integer sort;
    11.  
    12.     public String getName() {
    13.         return name;
    14.     }
    15.  
    16.     public void setLabel(String name) {
    17.         this.name = name;
    18.     }
    19.  
    20.     public Integer getSort() {
    21.         return sort;
    22.     }
    23.  
    24.     public void setSort(Integer sort) {
    25.         this.ort = ort;
    26.     }
    27.  
    28.     @Override
    29.     public String toString() {
    30.         return "Order{" +
    31.                 "name='" +name + '\'' +
    32.                 ", sort=" + sort +
    33.                 '}';
    34.     }
    35. }
    Setter.xml
    1. "1.0" encoding="UTF-8"?>
    2. <beans xmlns="http://www.springframework.org/schema/beans"
    3.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    4.        xsi:schemaLocation="http://www.springframework.org/schema/beans
    5.     http://www.springframework.org/schema/beans/spring-beans-4.3.xsd">
    6.  
    7.     <bean id="bySetter" class="com.javacode.lesson.demo.Order">
    8.         <property name="name" value="dingdan"/>
    9.     bean>
    10.  
    11. beans>
    优缺点

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

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

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

    注入容器中的bean

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

    • ref属性方式

    • 内置bean的方式

    ref属性方式

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

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

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

    setter方式，将value替换为ref：

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

    构造器的方式：

    1. <constructor-arg>
    2.     <bean class=""/>
    3. </constructor-arg>

    setter方式：

    1. <property name="属性名称">
    2.     <bean class=""/>
    3. </property>
    案例
    Person.java
    1. package com.javacode.lesson.demo;
    2.  
    3. public class Person {
    4.     private User user;
    5.     private Car car;
    6.  
    7.     public Person() {
    8.     }
    9.  
    10.     public Person(User user, Car car) {
    11.         this.user = user;
    12.         this.car = car;
    13.     }
    14.  
    15.     public User getUser() {
    16.         return user;
    17.     }
    18.  
    19.     public void setUser(User user) {
    20.         this.user = user;
    21.     }
    22.  
    23.     public Car getCar() {
    24.         return car;
    25.     }
    26.  
    27.     public void setCar(Car car) {
    28.         this.car = car;
    29.     }
    30.  
    31.     @Override
    32.     public String toString() {
    33.         return "Person{" +
    34.                 "user=" + user +
    35.                 ", car=" + car +
    36.                 '}';
    37.     }
    38. }

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

    Bean.xml
    1. "1.0" encoding="UTF-8"?>
    2. "http://www.springframework.org/schema/beans"
    3.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    4.        xsi:schemaLocation="http://www.springframework.org/schema/beans
    5.     http://www.springframework.org/schema/beans/spring-beans-4.3.xsd">
    6.  
    7.     "user" class="com.javacode.lesson.demo.User">
    8.  
    9.     
    10.     "ByConstructor" class="com.javacode.lesson.demo.Person">
    11.         
    12.         "0" ref="user"/>
    13.         "1">
    14.             "com.javacode.lesson.demo.Car">
    15.                 "0" value="name"/>
    16.                 "1" value=""/>
    17.             
    18.         
    19.     
    20.  
    21.     
    22.     "BySetter" class="com.javacode.lesson.demo.Person">
    23.         
    24.         "user" ref="user"/>
    25.         "car">
    26.             "com.javacode.lesson.demo.Car">
    27.                 "0" value="bmw"/>
    28.                 "1" value="aa"/>
    29.             
    30.         
    31.     
    32.

    其他类型注入：

    注入java.util.List（list元素）
    2.     Spring
    3.     or
    4.     "bean名称"/>
    5.     or
    6.     
    7.     
    8.     
    9.     
    10.     
    11.
    注入java.util.Set（set元素）
    2.     Spring
    3.     or
    4.     "bean名称"/>
    5.     or
    6.     
    7.     
    8.     
    9.  
    10.     
    11.
    注入java.util.Map（map元素）
    2.     "" value="" key-ref="key引用的bean名称" value-ref="value引用的bean名称"/>
    3.     或
    4.     
    5.         
    6.             value对应的值,任意类型
    7.         
    8.         
    9.             value对应的值，任意类型
    10.         
    11.     
    注入数组（array元素）
    2.     数组中的元素
    注入java.util.Properties（props元素）

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

    2.     "key1">java
    3.     "key2">go
    4.     "key3">python
    案例

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

    OtherType.java
    1. package com.javacode.lesson.demo;
    2.  
    3. import java.util.*;
    4.  
    5. public class OtherType {
    6.     private List list1;
    7.     private Set set1;
    8.     private Map map1;
    9.     private int[] array1;
    10.     private Properties properties1;
    11.  
    12.     public List getList1() {
    13.         return list1;
    14.     }
    15.  
    16.     public void setList1(List list1) {
    17.         this.list1 = list1;
    18.     }
    19.  
    20.     public Set getSet1() {
    21.         return set1;
    22.     }
    23.  
    24.     public void setSet1(Set set1) {
    25.         this.set1 = set1;
    26.     }
    27.  
    28.     public Map getMap1() {
    29.         return map1;
    30.     }
    31.  
    32.     public void setMap1(Map map1) {
    33.         this.map1 = map1;
    34.     }
    35.  
    36.     public int[] getArray1() {
    37.         return array1;
    38.     }
    39.  
    40.     public void setArray1(int[] array1) {
    41.         this.array1 = array1;
    42.     }
    43.  
    44.     public Properties getProperties1() {
    45.         return properties1;
    46.     }
    47.  
    48.     public void setProperties1(Properties properties1) {
    49.         this.properties1 = properties1;
    50.     }
    51.  
    52.     @Override
    53.     public String toString() {
    54.         return "OtherType{" +
    55.                 "list1=" + list1 +
    56.                 ", set1=" + set1 +
    57.                 ", map1=" + map1 +
    58.                 ", array1=" + Arrays.toString(array1) +
    59.                 ", properties1=" + properties1 +
    60.                 '}';
    61.     }
    62. }

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

    OtherType.xml
    1. "1.0" encoding="UTF-8"?>
    2. "http://www.springframework.org/schema/beans"
    3.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    4.        xsi:schemaLocation="http://www.springframework.org/schema/beans
    5.     http://www.springframework.org/schema/beans/spring-beans-4.3.xsd">
    6.  
    7.     "user1" class="com.javacode.lesson.demo.User"/>
    8.     "user2" class="com.javacode.lesson.demo.User"/>
    9.  
    10.     "OtherType" class="com.javacode.lesson.demo.OtherType">
    11.         
    12.         "list1">
    13.             
    14.                 A
    15.                 B
    16.             
    17.         
    18.  
    19.         
    20.         "set1">
    21.             
    22.                 "user1"/>
    23.                 "user2"/>
    24.                 "user1"/>
    25.             
    26.         
    27.  
    28.         
    29.         "map1">
    30.             
    31.                 "key1" value="0"/>
    32.                 "key2" value="1"/>
    33.             
    34.         
    35.  
    36.         
    37.         "array1">
    38.             
    39.                 1
    40.                 2
    41.                 3
    42.             
    43.         
    44.  
    45.         
    46.         "properties1">
    47.             
    48.                 "key1">java
    49.                 "key2">go
    50.                 "key3">python
    51.             
    52.         
    53.  
    54.     
    自动注入是约定大于配置

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

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

    • byteName：按照名称进行注入

    • byType：按类型进行注入，被注入的bean的类 是声明的set属性的类型的 子类或者同类型

    • constructor：按照构造方法进行注入

    • default：默认注入方式

      1. <?xml version="1.0" encoding="UTF-8"?>
      2. <beans xmlns="http://www.springframework.org/schema/beans"
      3.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
      4.        xsi:schemaLocation="http://www.springframework.org/schema/beans
      5.     http://www.springframework.org/schema/beans/spring-beans-4.3.xsd"
      6.        default-autowire="byName">
      7.  
      8. </beans>

    depeng on :

    1. bean对象的创建顺序和bean xml中定义的顺序一致

    2. bean销毁的顺序和bean xml中定义的顺序相反

    1. bean对象的创建顺序和bean依赖的顺序一致

    2. 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。

  • 相关阅读:
    四、2023.9.30.C++面向对象end.4
    浅析搭建视频监控汇聚平台的必要性及场景应用
    Java SPI（Service Provider Interface）
    windows编译ollvm笔记
    深度学习之压缩模型大小且不掉点的方法---知识蒸馏
    SpringBoot集成腾讯云云点播服务/视频上传
    C++练习题。。。
    如何在本地创建一个贪吃蛇小游戏node.js服务并实现无公网IP远程游玩
    Smart Copilot：大模型在技术服务和智能客服领域提效的最佳实践
    org.apache.hadoop.hbase.PleaseHoldException: Master is initializing
  • 原文地址：https://blog.csdn.net/aiengelangte/article/details/132766353