Ioc 配置的三种方式之xml 配置

xml 配置顾名思义，就是将bean的信息配置.xml文件里，通过Spring加载文件为我们创建bean。这种方式出现很多早前的SSM项目中，将第三方类库或者一些配置工具类都以这种方式进行配置，主要原因是由于第三方类不支持Spring注解。

优点：可以使用于任何场景，结构清晰，通俗易懂
缺点：配置繁琐，不易维护，枯燥无味，扩展性差

一、创建模块并导入以下依赖

1.1.创建模块

1.2.在pom.xml中导入依赖

    <dependencies>

        <!-- spring-context -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.3.22</version>
        </dependency>

        <!-- lombok -->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.24</version>
            <scope>provided</scope>
        </dependency>

        <!--配置和加载测试计划的公共API – 典型的使用场景是IDE和构建工具-->
        <dependency>
            <groupId>org.junit.platform</groupId>
            <artifactId>junit-platform-launcher</artifactId>
            <version>1.7.0</version>
            <scope>test</scope>
        </dependency>

        <!--JUnit Jupiter测试引擎的实现，仅仅在运行时需要。-->
        <dependency>
            <groupId>org.junit.jupiter</groupId>
            <artifactId>junit-jupiter-engine</artifactId>
            <version>5.7.0</version>
            <scope>test</scope>
        </dependency>

        <!--JUnit Vintage测试引擎实现，允许在新的JUnit Platform上运行低版本的JUnit测试，即那些以JUnit 3或JUnit 4风格编写的测试。
        非必须
        -->
        <dependency>
            <groupId>org.junit.vintage</groupId>
            <artifactId>junit-vintage-engine</artifactId>
            <version>5.7.0</version>
            <scope>test</scope>
        </dependency>
        <!--编写测试 和 扩展 的JUnit Jupiter API。-->
        <dependency>
            <groupId>org.junit.jupiter</groupId>
            <artifactId>junit-jupiter-api</artifactId>
            <version>5.7.0</version>
        </dependency>

    </dependencies>
    <build>
        <resources>
            <resource>
                <directory>src/main/java</directory>
                <includes>
                    <include>**/*.xml</include>
                </includes>
            </resource>
            <resource>
                <directory>src/main/resources</directory>
                <includes>
                    <include>**/*.xml</include>
                    <include>**/*.properties</include>
                </includes>
            </resource>
        </resources>
    </build>

1.3.创建spring配置文件

一般spring的配置文件很多人约定俗称为applicationContext.xml

1.4.准备一个要实例化的类

@Data
@AllArgsConstructor
@NoArgsConstructor
public class User implements Serializable {
    private Integer userid;
    private String username;
    private String password;
}

二、IOC通过XML方法创建对象

通过无参构造方法构造对象

<bean id="user1" class="com.augus.pojo.User"></bean>

<bean> 标签的常见属性：

<bean id="user1" class="com.augus.pojo.User" name="user1" scope="prototype" lazy-init="true" ></bean>

属性含义解释

d 对象的id
class 类的全路径名
name 和id类似,一般不用
scope 控制对象单例多例和使用范围，有一下可选项
- singleton作用域(scope 默认值), Spring IOC容器中只会存在一个共享的bean实例
- prototype作用域部署的bean，每一次获取都会产生一个新的bean实例，相当与一个new的操作
- request表示该针对每一次HTTP请求都会产生一个新的bean，同时该bean仅在当前HTTP request内有效
- session作用域表示该针对每一次HTTP请求都会产生一个新的bean，同时该bean仅在当前HTTP session内有效
- global session作用域类似于标准的HTTP Session作用域，不过它仅仅在基于portlet的web应用中才有意义

lazy-init 懒加载调用getBean的时候再去实例化对象

三、通过XML的方式实现DI给对象属性赋值

3.1.方式一：通过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"
       xmlns:p="http://www.springframework.org/schema/p"
       xmlns:c="http://www.springframework.org/schema/c"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
    <!--DI方式一：-->
    <bean id="user1" class="com.augus.pojo.User" lazy-init="true">
        <!--property就是使用set的方法实现依赖注入的-->
        <property name="userid" value="1"/>
        <property name="username" value="黛绮丝"/>
        <property name="password" value="123321"/>
    </bean>
</beans>

3.2.方式二：通过有参构造给对象属性赋值

<?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:p="http://www.springframework.org/schema/p"
       xmlns:c="http://www.springframework.org/schema/c"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
    <!--DI方式一：-->
    <bean id="user1" class="com.augus.pojo.User" lazy-init="true">
        <!--property就是使用set的方法实现依赖注入的-->
        <property name="userid" value="1"/>
        <property name="username" value="黛绮丝"/>
        <property name="password" value="123321"/>
    </bean>

    <!--DI方式二：
    constructor-arg 就是在使用构造方法实现依赖注入
    constructor-arg 的个数必须和某个构造方法的参数个数向对应
    name 指的是参数名
    index 指的是参数的索引
    value 指的是参数值
    -->
    <bean id="user2" class="com.augus.pojo.User">
        <constructor-arg name="userid" value="2"/>
        <constructor-arg name="username" value="殷天正"/>
        <constructor-arg name="password" value="342123"/>
    </bean>

</beans>

3.3.方式三：通过p名称空间和c名称空间给对象属性赋值

<?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:p="http://www.springframework.org/schema/p"
       xmlns:c="http://www.springframework.org/schema/c"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
    <!--DI方式一：-->
    <bean id="user1" class="com.augus.pojo.User" lazy-init="true">
        <!--property就是使用set的方法实现依赖注入的-->
        <property name="userid" value="1"/>
        <property name="username" value="黛绮丝"/>
        <property name="password" value="123321"/>
    </bean>

    <!--DI方式二：
    constructor-arg 就是在使用构造方法实现依赖注入
    constructor-arg 的个数必须和某个构造方法的参数个数向对应
    name 指的是参数名
    index 指的是参数的索引
    value 指的是参数值
    -->
    <bean id="user2" class="com.augus.pojo.User">
        <constructor-arg name="userid" value="2"/>
        <constructor-arg name="username" value="殷天正"/>
        <constructor-arg name="password" value="342123"/>
    </bean>

    <!--DI方式三：-->
    <!--p名称空间,就是对property的简化处理-->
    <bean id="user3" class="com.augus.pojo.User" p:userid="3" p:username="谢逊" p:password="456654"/>

    <!--c名称空间,就是对constructor-arg的简化-->
    <bean id="user4" class="com.augus.pojo.User" c:userid="4" c:username="韦一笑" c:password="098890"/>

</beans>

注意方式三，需要添加p和c名称空间

3.4.测试

创建测试代码如下：

public class Test1 {

    @Test
    public void testGetBean(){
        //加载配置文件
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");

        //获取对象输出信息
        User user1 = context.getBean("user1", User.class);
        System.out.println(user1);

        User user2 = context.getBean("user2", User.class);
        System.out.println(user2);

        User user3 = context.getBean("user3", User.class);
        System.out.println(user3);

        User user4 = context.getBean("user4", User.class);
        System.out.println(user4);
    }
}

执行后结果如下‘：

四、给属性注入空值和特殊符号

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

    <bean id="user5" class="com.augus.User">
        <!--给属性注入null值-->
        <property name="userid">
            <null></null>
        </property>

        <!--给属性注入特殊符号：< &lt;  >&gt;  & &amp;-->
        <property name="username" value="&amp;马保国&lt;&gt;"></property>

        <!--给属性注入特殊符号 <![CDATA[内容]]> -->
        <property name="password">
            <value><![CDATA[&<132sdf>]]></value>
        </property>
    </bean>

</beans>

4.2.测试代码

import com.augus.User;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Test1 {
    @Test
    public void testGetBean(){
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        // 获取对象 , 并且输出其属性的值
   
        User user5 = context.getBean("user5", User.class);
        System.out.println(user5);
    }

}

执行后结果如下：

五、给集合属性注入

5.1.分别准备Book、Student两个类

Book类如下：

@Data
@AllArgsConstructor
@NoArgsConstructor
public class Book implements Serializable {
    private String bookname;
    private String author;
}

Student类如下：

@Data
@AllArgsConstructor
@NoArgsConstructor
public class Student implements Serializable {
    private String[] books;
    private Set<String> bookSet;
    private List<String> bookList;
    private Map<String, String> bookMap;
    private List<Book> bookList2;
}

5.2.准备创建applicationContext2.xml，在里面实现属性的注入

在spring的配置文件中util命名空间类似于java.util包类对应，util命名空间提供了集合相关的配置，在使用命名空间前要导入util命名空间，如下：

xmlns:util="http://www.springframework.org/schema/util"
xsi:schemaLocation="
       http://www.springframework.org/schema/util
       http://www.springframework.org/schema/util/spring-util.xsd
">

下面给集合、数组注入值的时候，需要先添加util名称空间

<?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:p="http://www.springframework.org/schema/p"
       xmlns:c="http://www.springframework.org/schema/c"
       xmlns:util="http://www.springframework.org/schema/util"
       xsi:schemaLocation="
       http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/util
       http://www.springframework.org/schema/util/spring-util.xsd
">
    <!--在上面需要先定义一个util名称空间-->
    <!--定义公共集合-->
    <util:list id="outerbookList">
        <!--声明多个book对象-->
        <bean id="b1" class="com.augus.Book" p:bookname="selenium从入门到精通" p:author="大聪明1"></bean>
        <bean id="b2" class="com.augus.Book" p:bookname="appium从入门到精通" p:author="大聪明2"></bean>
        <bean id="b3" class="com.augus.Book" p:bookname="python从入门到精通" p:author="大聪明3"></bean>
    </util:list>

    <bean id="student" class="com.augus.Student">
        <!--给数组注入-->
        <property name="books">
            <array>
                <value>Linux</value>
                <value>MySQL</value>
                <value>java</value>
            </array>
        </property>

        <!--给set集合注入-->
        <property name="bookSet">
            <set>
                <value>Linux</value>
                <value>MySQL</value>
                <value>java</value>
            </set>
        </property>

        <!--给list集合注入-->
        <property name="bookList">
            <list>
                <value>Linux</value>
                <value>MySQL</value>
                <value>java</value>
            </list>
        </property>

        <!--给map集合注入-->
        <property name="bookMap">
            <map>
                <entry key="java" value="詹姆斯高斯林"></entry>
                <entry key="python" value="几多范罗苏姆"></entry>
                <entry key="Linux" value="林纳斯托瓦斯"></entry>
            </map>
        </property>

        <!--list对象集合注入-->
        <property name="bookList2" ref="outerbookList"></property>
    </bean>

</beans>

5.3.测试代码

import com.augus.Student;
import com.augus.User;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Test2 {
    @Test
    public void testGetBean(){
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext2.xml");
        // 获取对象 , 并且输出其属性的值
        Student student = context.getBean("student", Student.class);
        System.out.println(student);
    }

}

六、工厂方式获取bean

特点 : bean标签中定义的class类不是返回的对象的类,而是生产该对象的工厂

工厂模式:GOF 设计模式

spring中给我们定义好了一个工厂接口,可以生产对象的接口,我们可以通过工厂来获取bean

1.定义工厂对象实现 FactoryBean接口

package com.augus;

import org.springframework.beans.factory.FactoryBean;

public class BookFactory implements FactoryBean<Book> {

    public Book getObject() throws Exception {
        Book book = new Book();
        book.setBookname("三天学完python");
        book.setAuthor("张无忌");
        return book;
    }

    public Class<?> getObjectType() {
        return null;
    }

    public boolean isSingleton() {
        return false;
    }
}

2.创建配置文件

<?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
">
    <bean id="bookFactory" class="com.augus.BookFactory"></bean>
</beans>

3.测试

import com.augus.Book;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Test3 {
    @Test
    public void testGetBean(){
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext3.xml");
        // 获取对象 , 并且输出其属性的值
        Book book = context.getBean("bookFactory", Book.class);
        System.out.println(book);
    }

}