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。

<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

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名称和别名的各种写法

<!-- 通过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的名称和其别名，如下：

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的名称

运行输出：

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的作用域

<bean id="" class="" scope="作用域" /> 

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接口

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

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从当前作用域中移除**/@NullableObject remove(String name);/*** 用于注册销毁回调，如果想要销毁相应的对象,则由Spring容器注册相应的销毁回调，而由自定义作用域选择是不是要销毁相应的对象*/void registerDestructionCallback(String name, Runnable callback);/*** 用于解析相应的上下文数据，比如request作用域将返回request中的属性。*/@NullableObject resolveContextualObject(String key);/*** 作用域的会话标识，比如session作用域将是sessionId*/@NullableString 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
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";//@1private ThreadLocal<Map<String, Object>> beanMap = new ThreadLocal() {@Overrideprotected Object initialValue() {return new HashMap<>();}};@Overridepublic 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@Overridepublic Object remove(String name) {return this.beanMap.get().remove(name);}@Overridepublic void registerDestructionCallback(String name, Runnable callback) {//bean作用域范围结束的时候调用的方法，用于bean清理System.out.println(name);}@Nullable@Overridepublic Object resolveContextualObject(String key) {return null;}@Nullable@Overridepublic String getConversationId() {return Thread.currentThread().getName();}
}

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

BeanScopeModel
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 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/beanshttp://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

测试用例
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();//向容器中注册自定义的scopecontext.getBeanFactory().registerScope(ThreadScope.THREAD_SCOPE, new ThreadScope());//@1//使用容器获取beanfor (int i = 0; i < 2; i++) { //@2new 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次，然后输出，我们来看一下效果。

运行输出
线程: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方法。

构造函数的方式

参数索引

<?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/beanshttp://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"）；

参数类型

<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只能用来给简单的类型设置值

参数名称

<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，会保留真实的方法参数，从而使反射获取到真实的参数名称。

javac -parameters yourClass.java

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

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

@ConstructorProperties({"第一个参数名称", "第二个参数的名称",..."第n个参数的名称"})
public 类名(String s1, String s2...,参数n) {
}
Car.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;}@Overridepublic String toString() {return "Car{" +"name='" + name + '\'' +", desc='" + desc + '\'' +'}';}
}
constructorParamName.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/beanshttp://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实例代码相当于下面代码：

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

用法

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

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

name：属性的名称

value：属性的值

Order.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;}@Overridepublic String toString() {return "Order{" +"name='" +name + '\'' +", sort=" + sort +'}';}
}
Setter.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/beanshttp://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
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;}@Overridepublic String toString() {return "Person{" +"user=" + user +", car=" + car +'}';}
}

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

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/beanshttp://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元素）

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

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

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

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

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

注入数组（array元素）

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

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

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

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

案例

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

OtherType.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;}@Overridepublic String toString() {return "OtherType{" +"list1=" + list1 +", set1=" + set1 +", map1=" + map1 +", array1=" + Arrays.toString(array1) +", properties1=" + properties1 +'}';}
}

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

OtherType.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/beanshttp://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/beanshttp://www.springframework.org/schema/beans/spring-beans-4.3.xsd"default-autowire="byName"></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。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mzph.cn/news/77078.shtml

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

2023年基因编辑行业研究报告

2023年基因编辑行业研究报告

第一章 行业发展概况 1.1 定义 基因编辑&#xff08;Gene Editing&#xff09;&#xff0c;又称基因组编辑&#xff08;Genome Editing&#xff09;或基因组工程&#xff08;Genome Engineering&#xff09;&#xff0c;是一项精确的科学技术&#xff0c;可以对含有遗传信息的…
阅读更多...
[JAVAee]Spring的基础介绍

[JAVAee]Spring的基础介绍

本文章介绍了Spring大致是什么,核心的功能. Spring是什么? Spring指的是Spring Framework(Spring框架). 支持广大的开发场景,能够使应用开发变得简单. 其集成了各种工具,还实现了底层的类的实例化和生命周期的管理. 简单来说,Spring就是拥有众多工具方法的IoC容器 容器?…
阅读更多...
常用百宝箱——日志处理

常用百宝箱——日志处理

目录 前言 一、logging库 二、logging日志等级 三、logging四大组件 四、封装示例 总结 前言 日志是记录特定时间段或事件的详细信息的文件或记录。它们通过时间戳和关键词或描述符来标识事件或行动。日志可以用于许多目的&#xff0c;例如&#xff1a;故障排除、网络安全…
阅读更多...
搭建springcloud注册中心eureka以及admin监控

搭建springcloud注册中心eureka以及admin监控

写该篇文章的目的是为了以后搭建微服务的时候避免踩坑 要求&#xff1a;搭建一个eureka-server注册中心&#xff0c;再构建两个eureka-client注册上去&#xff0c;然后再搭建admin服务注册到注册中心。实现在admin后管页面可观察已注册上去的服务 前提&#xff1a;使用的spri…
阅读更多...
Redis 初识与入门

Redis 初识与入门

1. 什么是Redis Redis 是一种基于内存的数据库&#xff0c;对数据的读写操作都是在内存中完成&#xff0c;因此读写速度非常快&#xff0c;常用于缓存&#xff0c;消息队列、分布式锁等场景。 Redis 提供了多种数据类型来支持不同的业务场景&#xff0c;比如 String(字符串)、…
阅读更多...
关系的定义及表示

关系的定义及表示

关系的定义及表示 1、若集合R是AA的子集&#xff0c;则称R是集合A上的二元关系&#xff0c;简称关系 例&#xff1a;A{1,2}&#xff0c; AA{<1,1>,<1,2>,<2,1>,<2,2>}&#xff0c;AA的任何一个子集都是A上的关系 如&#xff1a; R{<1,1>, &…
阅读更多...
java企业数据管理系统

java企业数据管理系统

项目介绍 此项目为企业数据管理系统的后端部分&#xff0c;前端部分请参考vue-admin&#xff0c;项目实现了菜单管理、用户管理、角色管理和权限管理四个基础模块&#xff0c;前端菜单管理结合动态路由可自由添加菜单。结合Shiro权限管理实现了菜单和按钮的权限控制。 ❝ 前端…
阅读更多...
贝塞尔曲线的一些资料收集

贝塞尔曲线的一些资料收集

一本免费的在线书籍&#xff0c;供你在非常需要了解如何处理贝塞尔相关的事情。 https://pomax.github.io/bezierinfo/zh-CN/index.html An algorithm to find bounding box of closed bezier curves? - Stack Overflow https://stackoverflow.com/questions/2587751/an-algo…
阅读更多...
歌曲推荐《最佳损友》

歌曲推荐《最佳损友》

最佳损友 陈奕迅演唱歌曲 《最佳损友》是陈奕迅演唱的一首粤语歌曲&#xff0c;由黄伟文作词&#xff0c;Eric Kwok&#xff08;郭伟亮&#xff09;作曲。收录于专辑《Life Continues》中&#xff0c;发行于2006年6月15日。 2006年12月26日&#xff0c;该曲获得2006香港新城…
阅读更多...
Python之OS模块

Python之OS模块

os模块负责程序与操作系统的交互&#xff0c;提供了访问操作系统底层的接口;即os模块提供了非常丰富的方法用来处理文件和目录。 使用的时候需要导入该模块:import os
阅读更多...
MojoTween：使用「Burst、Jobs、Collections、Mathematics」优化实现的Unity顶级「Tween动画引擎」

MojoTween：使用「Burst、Jobs、Collections、Mathematics」优化实现的Unity顶级「Tween动画引擎」

MojoTween是一个令人惊叹的Tween动画引擎&#xff0c;针对C#和Unity进行了高度优化&#xff0c;使用了Burst、Jobs、Collections、Mathematics等新技术编码。 MojoTween提供了一套完整的解决方案&#xff0c;将Tween动画应用于Unity Objects的各个方面&#xff0c;并可以通过E…
阅读更多...
HCIP学习-IPv6

HCIP学习-IPv6

目录 前置学习内容 IPv6解决的一些IPv4的缺陷 无限的地址 层次化的地址结构 即插即用 简化报文头部 IPv4和IPv6报头比较 端到端的网络罗完整性 安全性增强 挣钱QoS特性 IPv6地址介绍 格式 首选格式 压缩格式 内嵌IPv4地址格式的IPv6地址格式 IPv6的网络前缀和接…
阅读更多...
MySQL——数据的增删改

MySQL——数据的增删改

2023.9.12 本章开始学习DML (数据操纵语言) 语言。相关学习笔记如下&#xff1a; #DML语言 /* 数据操作语言&#xff1a; 插入&#xff1a;insert 修改&#xff1a;update 删除&#xff1a;delete */#一、插入语句 #方式一&#xff1a;经典的插入 /* 语法&#xff1a; insert …
阅读更多...
python协程学习

python协程学习

import asyncio import time import csv import queue import aiosqlite import timeconn None # 定义一个队列&#xff0c;用于传递数据 data_queue queue.Queue()# 启动写文件 # def callback(): # await # print(f"执行结果:{future.result()}") async…
阅读更多...
后端入门教程：从零开始学习后端开发

后端入门教程：从零开始学习后端开发

1. 编程基础 首先&#xff0c;作为一名后端开发者&#xff0c;你需要掌握至少一门编程语言。Python是一个很好的选择&#xff0c;因为它易于学习且功能强大。让我们从一个简单的示例开始&#xff0c;在控制台输出 "Hello, World!"。 2. 学习Web基础 了解Web开发基…
阅读更多...
图的学习，深度和广度遍历

图的学习，深度和广度遍历

一、什么是图 表示“多对多”的关系 包括&#xff1a; 一组顶点&#xff1a;通常用V&#xff08;Vertex&#xff09;表示顶点集合一组边&#xff1a;通常用E&#xff08;Edge&#xff09;表示边的集合 边是顶点对&#xff1a;(v, w)∈E&#xff0c;其中v,w∈V有向边<v, w&…
阅读更多...
通过软件读取ESP8266/ESP32的MAC地址

通过软件读取ESP8266/ESP32的MAC地址

具体MAC地址可以学习相关书籍、网络、课程和网页等 这里只是给出代码作为本专栏完整性的一部分内容 作为嵌入式软件工程师来说 我只要把我的软件做得尽可能好就可以了 相关理论知识确实不想花太多时间研究&#xff0c;只是作为工程人员拿来使用&#xff0c;熟练掌握原理就可…
阅读更多...
蓝牙 - 什么是Man-in-the-middle protection

蓝牙 - 什么是Man-in-the-middle protection

中间人&#xff08;MITM&#xff09;攻击发生在当用户想要连接两台设备时&#xff0c;使得他们并没有直接连接对方&#xff0c;而是在不知情的情况下连接到了第三台&#xff08;攻击&#xff09;设备&#xff0c;该设备扮演了他们试图配对的设备的角色。第三台设备随后会在两台…
阅读更多...
Swoole 介绍以及 编译安装

Swoole 介绍以及 编译安装

Swoole是什么&#xff1f; Swoole是一个PHP语言的开源异步网络通信引擎&#xff0c;它是以PHP语言为基础&#xff0c;以C语言编写的扩展。它可以让PHP语言程序拥有异步网络通信能力&#xff0c;并且能够支持高并发、高性能的TCP/UDP/Unix Socket/HTTP服务器。 Swoole的优势 …
阅读更多...
最新遥感数据与作物模型同化教程

最新遥感数据与作物模型同化教程

详情点击公众号链接&#xff1a;最新遥感数据与作物模型同化教程一&#xff1a;遥感基础1.遥感平台&#xff08;如无人机&#xff09;与传感器、国内外主要陆地卫星&#xff08;如Landsat、SPOT、HJ、GF&#xff09; 2.遥感基本原理、光谱响应函数、遥感数据处理流程 3.遥感在陆…
阅读更多...
最新文章

Copyright @ 2022~2023