正文
《Java Spring框架》SpringXML配置详解
小程序：扫一扫查出行【扫一扫了解最新限行尾号】
复制小程序
Spring框架作为Bean的管理容器，其最经典最基础的Bean配置方式就是纯XML配置，这样做使得结构清晰明了，适合大型项目使用。Spring的XML配置虽然很繁琐，而且存在简洁的注解方式，但读懂XML配置文件对我们来说依然很重要，尚且对于老系统维护必不可少的面对XML配置。
下面通过案例来理解XML配置。
案例：（一个基础的Bean）
public class Pet {
private String petType;
private String color ; public String getColor() {
return color;
} public void setColor(String color) {
this.color = color;
} public String getPetType() {
return petType;
} public void setPetType(String petType) {
this.petType = petType;
} public String toString(){
return"petType: "+petType+" color: "+color;
}
}
public class User {
String id;
String name;
String passWord; Pet pet; public Pet getPet() {
return pet;
} public void setPet(Pet pet) {
this.pet = pet;
} public User(){
System.out.println("spring 需要一个空参构造！");
} public String getId() {
return id;
} public void setId(String id) {
this.id = id;
} public String getName() {
return name;
} public void setName(String name) {
this.name = name;
} public String getPassWord() {
return passWord;
} public void setPassWord(String passWord) {
this.passWord = passWord;
} @Override
public String toString() {
return "User{" +
"id='" + id + '\'' +
", name='" + name + '\'' +
", passWord='" + passWord + '\'' +
", pet=" + pet +
'}';
} public void init(){
System.out.println("User初始化执行init方法！");
} public void userDestroy(){
System.out.println("userDestroy方法被执行！");
}
}
import com.bing.tao.bean.User;
import org.junit.jupiter.api.Test;
import org.springframework.context.support.ClassPathXmlApplicationContext;public class HelloSpring { /**
* IOC的反转：创建对象这份工作由我们自己执行反转给spring帮我们执行；
* IOC的控制：就是由spring帮我们负责创建销毁对象，掌控对象的生命周期等，我们在需要使用对象的时候跟Spring申请即可；
* IOC是一种编程思想，也是一种新的设计模式，它需要DI（依赖注入）技术的支持；
* spring是一个容器，它将帮我们管理对象
*/
@Test
public void Test1(){
//根据spring配置文件获取容器对象
//ApplicationContext 配置的所有bean都会在容器创建的时候被创建出来
//如果配置的bean较多，那么在创建容的时候，会产生内存过大的问题；这种情况在机器硬件性能较为落后的时候体现的比较明显；
//延迟加载 true就是创建容器时不加载配置的bean对象，在获取的时候才创建；
ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
User user= (User) applicationContext.getBean("user");
System.out.println("user: "+user);
//通过getBean获取配置好的user对象（程序员向spring容器要对象）
user= applicationContext.getBean(User.class);
System.out.println("user: "+user);
applicationContext.close();
}
}
重要的配置：(创建一个名字叫：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 http://www.springframework.org/schema/beans/spring-beans.xsd"> <!-- spring管理bean的XML，一个bean标签表示一个bean。-->
<!-- name属性给bean取名，代码中可以通过：applicationContext.getBean("user"); 获取class-->
<!-- class：是被管理对象的全包名，spring会通过这个包名来创建对象 -->
<!-- scope 属性，控制对象的单例还是多例，prototype多例-->
<!-- 在web环境下，如果scope属性为request 那么这个对象被创建出来 他的生命周期会与request请求一致-->
<!-- session 同理 ，生命周期与session一致 -->
<!-- lazy-init 延迟加载，获取bean 的时候才加载 ，否则在创建容器是就会加载bean。-->
<!-- 初始化方法：init-method，spring创建bean的时候会执行-->
<!-- 销毁bean方法：destroy-method spring销毁bean的时候会执行-->
<bean name = "user" class="com.bing.tao.bean.User" scope="singleton" lazy-init="false" init-method="init" destroy-method="userDestroy">
<!-- property 标签，是用于bean内部属性初始化值使用的。-->
<!-- name 对应bean的变量名，value 就是初始值。-->
<property name="id" value="1"></property>
<property name="name" value="蕾蕾"></property>
<property name="passWord" value="123456"></property>
<!-- 引用类型的初始化 -->
<property name="pet" ref="pet"></property>
</bean> <!-- 将pet对象交给spring管理，并注入值类型 -->
<bean name = "pet" class="com.bing.tao.bean.Pet">
<property name="petType" value="二哈"></property>
<property name="color" value="灰灰"></property>
</bean>
</beans>
运行结果：
配置文件，已经将标签含义说明清楚。补充一点：如果是多例则spring不在管理bean而是交给你管理，销毁方法将不再执行。
Spring XML配置如何支持构造函数和复杂数据类型（List等）：
修改User类：
public class User {
String id;
String name;
String passWord; Pet pet; public Pet getPet() {
return pet;
} public void setPet(Pet pet) {
this.pet = pet;
} public User(){
System.out.println("spring 需要一个空参构造！");
} public User(String name, Pet pet) {
System.out.println("打印构造方法1：name :"+name +"pet:"+pet);
this.name = name;
this.pet = pet;
} public User(Pet pet,String name) {
System.out.println("打印构造方法2：name :"+name +"pet:"+pet);
this.name = name;
this.pet = pet;
} public String getId() {
return id;
} public void setId(String id) {
this.id = id;
} public String getName() {
return name;
} public void setName(String name) {
this.name = name;
} public String getPassWord() {
return passWord;
} public void setPassWord(String passWord) {
this.passWord = passWord;
} @Override
public String toString() {
return "User{" +
"id='" + id + '\'' +
", name='" + name + '\'' +
", passWord='" + passWord + '\'' +
", pet=" + pet +
'}';
} public void init(){
System.out.println("User初始化执行init方法！");
} public void userDestroy(){
System.out.println("userDestroy方法被执行！");
}
}
新增测试方法：
import com.bing.tao.bean.MyCollection;
import com.bing.tao.bean.User;
import org.junit.jupiter.api.Test;
import org.springframework.context.support.ClassPathXmlApplicationContext;public class HelloSpring2 { @Test
public void Test1(){
ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext_Injection.xml");
User user= (User) applicationContext.getBean("user");
System.out.println(user);
System.out.println("-----------------分割线-----------------");
MyCollection myCollection= (MyCollection) applicationContext.getBean("myCollection");
System.out.println(myCollection);
}
}
新增配置文件：applicationContext_Injection.xml
配置内容如下：
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns="http://www.springframework.org/schema/beans"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd"> <!-- 构造方法注入 -->
<bean name="user" class="com.bing.tao.bean.User">
<!-- name 调用构造方法的参数名称 value 是注入值类型 ref 注入引用类型 -->
<!-- type 是指定参数的类型 -->
<!-- index 是指定参数的 -->
<constructor-arg name="name" value="老王" type="java.lang.String" index="1"/>
<constructor-arg name="pet" ref="pet"/>
</bean> <!-- 将pet对象交给spring管理，并注入值类型 -->
<bean name = "pet" class="com.bing.tao.bean.Pet">
<property name="petType" value="二哈"></property>
<property name="color" value="灰灰"></property>
</bean> <!-- 复杂类型注入 -->
<bean name="myCollection" class="com.bing.tao.bean.MyCollection">
<!-- Array -->
<property name="array">
<array>
<value>123</value>
<value>abc</value>
<ref bean="pet"></ref>
</array>
</property> <!-- List -->
<property name="list">
<list>
<value>456</value>
<value>def</value>
<ref bean="user"></ref>
</list>
</property> <!-- Set -->
<!-- 当只有一个值得时候，可以简写成一下方式。 -->
<property name="set" value="789"></property> <!-- Map -->
<property name="map">
<map>
<entry key="root" value="123"></entry>
<entry key="admin" value="456"></entry>
<entry key-ref="user" value-ref="pet"></entry>
</map>
</property> <!-- properties -->
<property name="prop">
<props>
<prop key="name">老李</prop>
<prop key="age">25</prop>
</props>
</property>
</bean>
</beans>
运行结果：
看到这边，大部分人都会觉得，每一个Bean都要这么操作一下，这么复杂，还不如直接写代码呢。
接下来，我们来简化配置。
先来简化配置：（新建一个配置文件：applicationContext_annotation.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"
xmlns:contest="http://www.springframework.org/schema/context"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd"> <!-- 将包 com.bing.tao.bean 下的Bean都交给Spring -->
<contest:component-scan base-package="com.bing.tao.bean"></contest:component-scan>
</beans>
将User修改成：
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Component;import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;/**
* @Component 用于标记该bean需要Spring实例化。
* @Scope 标签用于标记该bean是单例还是多例，singleton表示单例，prototype多例。
*/
@Component("user")
@Scope(scopeName = "singleton")
public class User { /**
* @Value标签可以将括号中的值注入到Spring生成的Bean中
*/
@Value("1")
String id;
@Value("蕾蕾")
String name;
@Value("123")
String passWord; public String getId() {
return id;
} public void setId(String id) {
this.id = id;
} public String getName() {
return name;
} public void setName(String name) {
this.name = name;
} public String getPassWord() {
return passWord;
} public void setPassWord(String passWord) {
this.passWord = passWord;
} public String toString(){
return"name: "+name+" id: "+id;
} //构造后调用
@PostConstruct
public void init(){
System.out.println("User初始化执行init方法！");
} //销毁前调用
@PreDestroy
public void userDestroy(){
System.out.println("userDestroy方法被执行！");
}
}
创建一个测试方法：
import com.bing.tao.bean.User;
import org.junit.jupiter.api.Test;
import org.springframework.context.support.ClassPathXmlApplicationContext;public class HelloSpring3 { @Test
public void Test1(){
ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext_annotation.xml");
//通过getBean获取配置好的user对象（程序员向spring容器要对象）
User user= (User) applicationContext.getBean("user"); System.out.println(user);
//scope="singleton" 是单例下才能出发销毁bean方法，如果是多例则spring不在关联bean而是交给你管理。
applicationContext.close();
}
}
运行结果：
这样就可以批量设置模式一样的Bean结构了。XML的配置就可以很好的简化。同时还倒逼了目录结构的整齐。
总结来源：http://www.sikiedu.com/ 网站学习。
