《Java Spring框架》SpringXML配置详解

时间：2023-03-09 03:44:43
《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>

运行结果：

《Java Spring框架》SpringXML配置详解

配置文件，已经将标签含义说明清楚。补充一点：如果是多例则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>

运行结果：

《Java Spring框架》SpringXML配置详解

看到这边，大部分人都会觉得，每一个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();

    }

}

运行结果：

《Java Spring框架》SpringXML配置详解

这样就可以批量设置模式一样的Bean结构了。XML的配置就可以很好的简化。同时还倒逼了目录结构的整齐。

总结来源：http://www.sikiedu.com/ 网站学习。

相关文章