Spring：IoC 用法（八、<bean>用法）

最新推荐文章于 2023-06-07 09:56:04 发布
最新推荐文章于 2023-06-07 09:56:04 发布
阅读量411 收藏
点赞数
分类专栏： Spring-IoC
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/csdn869368878/article/details/76021023
版权

XML 配置详解

1、<bean> 属性

作用：一个 <bean>元素对应一个 class 类

1）、id

作用：<bean>的全局唯一标识，也是 <bean>的别名，没有 id 时自动使用类名首字母小写（注入时使用）

测试：

测试 Controller

public class TestController {

    public String testController() {
        return "成功注入!!!";
    }
}

配置类

<?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="testController" class="test.define.controller.TestController"/>
</beans>

测试类

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:spring/spring.xml")
@ActiveProfiles("pro")
public class Test {

    @Autowired
    private TestController controller;

    @org.junit.Test
    public void testXMLConfig() {
        String data = controller.testController();
        System.out.println(data);
    }
}

结果

成功注入!!!

2）、name

作用：<bean>的别名，可以同时存在多个，多个时使用逗号分隔（注入时使用）

测试：

测试Controller

public class TestController {

    public String testController() {
        return "成功注入!!!";
    }
}

配置文件

<?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="testController" name="c1,c2" class="test.define.controller.TestController"></bean>
</beans>

测试类

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:spring/spring.xml")
@ActiveProfiles("pro")
public class Test {

    @Autowired
    @Qualifier("c1")
    private TestController c1;

    @Autowired
    @Qualifier("c2")
    private TestController c2;

    @org.junit.Test
    public void testXMLConfig() {
        String data;
        data = c1.testController();
        System.out.println("c1: " + data);

        data = c2.testController();
        System.out.println("c2: " + data);
    }
}

3）、class

作用：<bean>和 class的连接（实例化时使用）

测试：无

4）、parent

作用：将两个不相干的类，设置成父子关系

测试：

测试Controller基类

public class BaseController {

    public BaseController(){
        System.out.println("this is BaseController");
    }
}

测试Controller

public class TestController {

    public String testController() {
        return "成功注入!!!";
    }
}

配置文件

<?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">

    <!-- 注入Controller基类 -->
    <bean id="baseController" class="test.define.base.BaseController"/>
    <!-- 设置关联关系 -->
    <bean id="testController" name="c1,c2" class="test.define.controller.TestController" parent="baseController"/>
</beans>

测试类

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:spring/spring.xml")
@ActiveProfiles("pro")
public class Test {

    @Autowired
    private TestController controller;

    @org.junit.Test
    public void testXMLConfig() {
        String data = controller.testController();
        System.out.println("c1: " + data);
    }
}
结果 

this is BaseController
c1: 成功注入!!!

5）、abstract

作用：模板的一种用法，有如下特点

abstract 修饰的类，不允许定义 <bean>，除非使用 abstract=true 修饰<bean>

abstract 修饰的<bean>不会被预加载，不允许注入，值允许引用

三种情况：

1、抽象类定义模板

2、普通类定义模板

3、没有匹配类的末班

测试：（抽象类模板）

定义抽象类（模板）

public abstract class AbstractTemplate {

    private String id;
    private String name;

    public void setId(String id) {
        this.id = id;
    }

    public void setName(String name) {
        this.name = name;
    }
}

定义普通类（被初始化）

public class TestController {

    private String id;
    private String name;
    private int age;

    public void setId(String id) {
        this.id = id;
    }

    public void setName(String name) {
        this.name = name;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String toString() {
        return id + "-----" + name + "-----" + age;
    }
}

配置文件

<?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="template" class="test.define.abstrac.AbstractTemplate" abstract="true">
        <property name="id" value="ID"/>
        <property name="name" value="名称"/>
    </bean>

    <!-- 使用模板初始化参数 -->
    <bean id="testController" class="test.define.controller.TestController" parent="template"/>
</beans>

测试类

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:spring/spring.xml")
public class Test {

    @Autowired
    private TestController controller;

    @org.junit.Test
    public void testXMLConfig() {
        System.out.println(controller);
    }
}

结果

ID-----名称-----0


测试：（测试普通类模板）

定义普通类（模板）

public class Template {

    private String id;
    private String name;

    public void setId(String id) {
        this.id = id;
    }

    public void setName(String name) {
        this.name = name;
    }
}

定义普通类（被初始化）

public class TestController {

    private String id;
    private String name;
    private int age;

    public void setId(String id) {
        this.id = id;
    }

    public void setName(String name) {
        this.name = name;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String toString() {
        return id + "-----" + name + "-----" + age;
    }
}

配置文件

<?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="template" class="test.define.abstrac.Template" abstract="true">
        <property name="id" value="ID"/>
        <property name="name" value="名称"/>
    </bean>

    <!-- 使用模板初始化参数 -->
    <bean id="testController" class="test.define.controller.TestController" parent="template"/>
</beans>

测试类

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:spring/spring.xml")
public class Test {

    @Autowired
    private TestController controller;

    @org.junit.Test
    public void testXMLConfig() {
        System.out.println(controller);
    }
}

结果

ID-----名称-----0

测试：（测试单纯模板）

配置文件

<?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="template"  abstract="true">
        <property name="id" value="ID"/>
        <property name="name" value="名称"/>
    </bean>

    <!-- 使用模板初始化参数 -->
    <bean id="testController" class="test.define.controller.TestController" parent="template"/>
</beans>

测试类

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:spring/spring.xml")
public class Test {

    @Autowired
    private TestController controller;

    @org.junit.Test
    public void testXMLConfig() {
        System.out.println(controller);
    }
}

结果

ID-----名称-----0

6）、scope：（最早期版本的 singleton 属性已废除，现在替换为 scope="singleton"）

作用：不同类型作用域实例化时有所区别，Ioc部分分为两种类型（其他类型此处不说明）

              singleton：单例（所有单例<bean>在服务启动时会进行预加载实例）

              prototype：原型（多例，使用时创建实例）

单例测试：

测试Controller

public class TestController {

    public String testController() {
        return "成功注入!!!";
    }
}

配置文件

<?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 class="test.define.controller.TestController" scope="singleton"/>
</beans>

测试类

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:spring/spring.xml")
public class Test {

    @Autowired
    private TestController c1;

    @Autowired
    private TestController c2;

    @org.junit.Test
    public void testXMLConfig() {
        String data;
        data = c1.testController();
        System.out.println("c1: " + data);
        data = c2.testController();
        System.out.println("c2: " + data);
        if(c1 == c2){
            System.out.println("单例模式实例相等。");
        }else {
            System.out.println("原型模式实例不相等。");
        }
    }
}
结果 
c1: 成功注入!!!
c2: 成功注入!!!
单例模式实例相等。

原型测试：

配置文件：修改配置文件后，重新执行测试类，查看执行结果

<?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 class="test.define.controller.TestController" scope="prototype"/>
</beans>
结果 
c1: 成功注入!!!
c2: 成功注入!!!
原型模式实例不相等。


7）、lazy-init

作用：延迟加载 <bean>，优先级高于<beans > 的 default-lazy-init 属性

          当<bean>与<beans>冲突时，优先考虑<bean>级别的 lazy-init

          有两个属性可以选择：true、false

测试：无（通过启动时间或日志的方式判断）

<?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 class="test.define.controller.TestController" lazy-init="true"/>

</beans>

8）、autowire

作用：表示<bean>自动注入的方式，有五种选择：

              no：禁止自动注入（默认）

              defalut：继承容器级别<beans> 的 default-autowire 属性

              byName：根据别名注入（ID也属于别名的一种）（方法注入）

              byType：根据类型注入（方法注入）

              constructor：根据类型注入（构造方法注入）

测试：（autowire = no）

定义Controller控制层

public class TestController {

    // 当 autowire="no" 时，注入肯定失败
    // 使用 @Autowired 确保注入成功
    @Autowired
    private TestService testService;

    public String testController() {
        return testService.testService();
    }
}

定义Service服务层接口

public interface TestService {

    String testService();
}

定义Service服务层接口实现

public class TestServiceImpl implements TestService {

    public String testService() {
        return "this is TestServiceImpl";
    }
}

配置文件

<?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 class="test.define.controller.TestController" autowire="no"/>

    <bean id="testServiceImpl" class="test.define.service.impl.TestServiceImpl"/>

</beans>

测试类

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:spring/spring.xml")
public class Test {

    @Autowired
    private TestController testController;

    @org.junit.Test
    public void testXMLConfig() {
        String data = testController.testController();
        System.out.println(data);
    }
}

结果：因为使用了@Autowired，确保了测试成功，否则注入失败

this is TestServiceImpl


测试：（autowire = default）

<继承容器级别<beans> 的 default-autowire 属性>


测试：（autowire = byName）

测试Controller控制层

public class TestController {

    private TestService service;

    public String testController() {
        return service.testService();
    }

    // byName 方法注入方式，参数的名称必须与被注入 <bean> 的别名相同
    public void setTestService(TestService testService) {
        this.service = testService;
    }
}

测试Service服务层接口

public interface TestService {

    String testService();
}

测试Service服务层接口实现

public class TestServiceImpl implements TestService {

    public String testService() {
        return "this is TestServiceImpl";
    }
}
配置文件 

<?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">

    <!-- byName 方法注入方式，根据别名注入（完全自动注入），别名必须与参数的名相同 -->
    <bean class="test.define.controller.TestController" autowire="byName"/>

    <bean id="testService" class="test.define.service.impl.TestServiceImpl"/>
</beans>

测试类

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:spring/spring.xml")
public class Test {

    @Autowired
    private TestController testController;

    @org.junit.Test
    public void testXMLConfig() {
        String data = testController.testController();
        System.out.println(data);
    }
}

结果

this is TestServiceImpl


测试：（autowire = byType）

测试Controller控制层

<同 autowire = byName>

测试Service服务层接口

<同 autowire = byName>

测试Service服务层接口实现

<同 autowire = byName>

配置文件

<?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">

    <!-- byType 方法注入方式，根据类型注入，只要类型与参数的名相同，即注入 -->
    <bean class="test.define.controller.TestController" autowire="byType"/>

    <!-- 根据类型注入，不需要ID和别名 -->
    <bean class="test.define.service.impl.TestServiceImpl"/>
</beans>

测试类

<同 autowire = byName>

结果

<同 autowire = byName>


测试：（autowire = constructor）

测试Controller控制层

public class TestController {

    private TestService service;

    public String testController() {
        return service.testService();
    }

    // 过渡
    public TestController() {

    }

    // autowire="constructor" 构造方法注入方式，只要有与参数类型相匹配的，即注入
    public TestController(TestService testService) {
        this.service = testService;
    }
}

测试Service服务层接口

public interface TestService {

    String testService();
}

测试Service服务层接口实现

public class TestServiceImpl implements TestService {

    public String testService() {
        return "this is TestServiceImpl";
    }
}

配置文件

<?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">

    <!-- byType 方法注入方式，根据类型注入，只要类型与参数的名相同，即注入 -->
    <bean class="test.define.controller.TestController" autowire="constructor"/>

    <!-- 根据类型注入，不需要ID和别名 -->
    <bean class="test.define.service.impl.TestServiceImpl"/>
</beans>

测试类

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:spring/spring.xml")
public class Test {

    @Autowired
    private TestController testController;

    @org.junit.Test
    public void testXMLConfig() {
        String data = testController.testController();
        System.out.println(data);
    }
}

结果

this is TestServiceImpl

9）、autowire-candidate

作用：是否参与注入，当一个接口有多个实现类时，可能会导致注入冲突，该属性有三个选择

              default：忽略错误（运行时可能报错）

              true：参与注入

              false：不参与注入

测试：（已类型注入为例）

测试Controller控制层

public class TestController {

    private TestService service;

    public String testController() {
        return service.testService();
    }

    public void setTestService(TestService testService) {
        this.service = testService;
    }
}

测试Service服务层接口

public interface TestService {

    String testService();
}

测试Service服务层接口实现类

public class TestServiceImpl implements TestService {

    public String testService() {
        return "this is TestServiceImpl";
    }
}
public class ProServiceImpl implements TestService {

    public String testService() {
        return "this is ProServiceImpl";
    }
}

配置文件

<?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">

    <!-- byType 方法注入方式，根据类型注入，只要类型与参数的名相同，即注入 -->
    <bean class="test.define.controller.TestController" autowire="byType"/>

    <!-- 实现了同一个接口的两个类 -->
    <!-- 第一个实现类 -->
    <bean class="test.define.service.impl.TestServiceImpl"/>

    <!-- 第二个实现类：autowire-candidate="false" 不参与注入 -->
    <bean class="test.define.service.impl.ProServiceImpl" autowire-candidate="false"/>
</beans>

测试类

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:spring/spring.xml")
public class Test {

    @Autowired
    private TestController testController;

    @org.junit.Test
    public void testXMLConfig() {
        String data = testController.testController();
        System.out.println(data);
    }
}

结果

this is TestServiceImpl

10）、primary

作用：首选注入，当一个接口有多个实现类时，可能会导致注入冲突，有三个选择

测试：（已注解注入为例）

测试Controller控制层

public class TestController {

    @Autowired
    private TestService service;

    public String testController() {
        return service.testService();
    }
}

测试Service服务层接口

public interface TestService {

    String testService();
}

测试Service服务层接口实现

public class TestServiceImpl implements TestService {

    public String testService() {
        return "this is TestServiceImpl";
    }
}
public class ProServiceImpl implements TestService {

    public String testService() {
        return "this is ProServiceImpl";
    }
}

配置文件

<?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">

    <!-- byType 方法注入方式，根据类型注入，只要类型与参数的名相同，即注入 -->
    <bean class="test.define.controller.TestController"/>

    <!-- 实现了同一个接口的两个类 -->
    <!-- 第一个实现类 -->
    <bean class="test.define.service.impl.TestServiceImpl"/>

    <!-- 第二个实现类：primary="true" 首选注入 -->
    <bean class="test.define.service.impl.ProServiceImpl" primary="true"/>
</beans>

测试类

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:spring/spring.xml")
public class Test {

    @Autowired
    private TestController testController;

    @org.junit.Test
    public void testXMLConfig() {
        String data = testController.testController();
        System.out.println(data);
    }
}

结果

this is ProServiceImpl

11）、depends-on

作用：实例当前<bean>之前，先实例另一个<bean>（在使用过程中很少出现类似情况）

测试：（使用三个普通类测试，不要管类的名字）

测试Controller控制层

public class TestController {

    public String testController() {
        return TestServiceImpl.getValue();
    }
}

测试初始化数据

public class TestServiceImpl {

    private static String value = "初始化数据!!!";

    public static void setValue(String value) {
        TestServiceImpl.value = value;
    }

    public static String getValue() {
        return value;
    }
}

测试覆盖数据

public class InitClass {

    public InitClass() {
        TestServiceImpl.setValue("覆盖初始化数据!!!");
    }
}

配置文件

<?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="init" class="test.define.init.InitClass"/>

    <!-- depends-on="init" 实例当前<bean>之前，先实例 别名 = init 的 <bean> -->
    <bean class="test.define.controller.TestController" depends-on="init"/>
</beans>

测试类：（使用底层的加载机制模拟情况）

public class Test {

    @org.junit.Test
    public void testXMLConfig() {
        XmlBeanFactory beanFactory = new XmlBeanFactory(new ClassPathResource("spring/spring.xml"));
        TestController controller = beanFactory.getBean(TestController.class);
        System.out.println(controller.testController());
    }
}

结果

覆盖初始化数据!!!

12）、init-method 和 destroy-method

作用：实例<bean>之前执行的方法，销毁<bean>之前执行的方法

测试：

测试Controller控制层

public class TestController {

    public String testController() {
        return "---- >>> 方法调用成功!!!";
    }

    // 实例<bean>之前执行
    public void init(){
        System.out.println("初始化方法!!!");
    }

    // 销毁<bean>之前执行
    public void destroy(){
        System.out.println("销毁方法!!!");
    }
}

配置文件

<?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 class="test.define.controller.TestController" init-method="init" destroy-method="destroy"/>
</beans>

测试类

public class Test {

    @org.junit.Test
    public void testXMLConfig() {
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("spring/spring.xml");
        TestController controller = context.getBean(TestController.class);
        System.out.println(controller.testController());
        context.close();
    }
}

结果

初始化方法!!!
---- >>> 方法调用成功!!!
销毁方法!!!

13）、factory-method

作用：静态工厂方法（当前类方法）

测试：

定义 Model

public class Model {  
  
    private String id;  
    private String name;  
  
    public Model(String id, String name) {  
        this.id = id;  
        this.name = name;  
    }  
  
    public String toString() {  
        return id + "-----" + name;  
    }  
}

定义 ModelFactory

public class ModelFactory {  
  
    private static Map<Integer, Model> map = new HashMap<Integer, Model>();  
  
    static {  
        map.put(1, new Model("id1", "Honda"));  
        map.put(2, new Model("id2", "Audi"));  
        map.put(3, new Model("id3", "BMW"));  
    }  
  
    public static Model getModel(int id) {  
        return map.get(id);  
    }  
}
配置文件 
<?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">  
      
    <!-- 静态工厂对象：注入别名 = getModelById，返回当前类的类型 = getModel 方法的返回类型 -->  
    <bean id="getModelById" class="test.define.model.ModelFactory" factory-method="getModel">  
        <constructor-arg value="1"/>  
    </bean>  
</beans>

测试类

@RunWith(SpringJUnit4ClassRunner.class)  
@ContextConfiguration(locations = "classpath:spring/spring.xml")  
public class Test {  
  
    @Autowired  
    @Qualifier("getModelById")  
    private Model model;  
  
    @org.junit.Test  
    public void testXMLConfig() {  
        System.out.println(model);  
    }  
}
结果 

id1-----Honda

14）、factory-bean
作用：动态工厂方法（动态类：可注入）

测试：

测试 Model

public class Model {  
  
    private String id;  
    private String name;  
  
    public Model(String id, String name) {  
        this.id = id;  
        this.name = name;  
    }  
  
    public String toString() {  
        return id + "-----" + name;  
    }  
}

测试初始化数据 InitModel（注入的类）

public class InitModel {  
  
    private Map<Integer, Model> map = new HashMap<Integer, Model>();  
  
    {  
        map.put(1, new Model("id1", "Honda"));  
        map.put(2, new Model("id2", "Audi"));  
        map.put(3, new Model("id3", "BMW"));  
    }  
  
    public Model getModelById(int id) {  
        return map.get(id);  
    }  
}

测试 ModelFactory

public class ModelFactory {  
  
    @Autowired  
    private InitModel initModel;  
  
    public Model getModel(int id) {  
        return initModel.getModelById(id);  
    }  
}

配置文件

<?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 class="test.define.model.InitModel"/>  
  
    <!-- 普通类：简单的IoC类：包括自动注入、调用注入类的方法 -->  
    <bean id="initModel" class="test.define.model.ModelFactory"></bean>  
  
    <!-- 动态工厂对象：注入别名 = getModelById，返回<别名 = initModel 的 getModel 方法返回的类型> -->  
    <bean id="getModelById" factory-bean="initModel" factory-method="getModel">  
        <constructor-arg value="1"/>  
    </bean>  
</beans>

测试类

@RunWith(SpringJUnit4ClassRunner.class)  
@ContextConfiguration(locations = "classpath:spring/spring.xml")  
public class Test {  
  
    @Autowired  
    @Qualifier("getModelById")  
    private Model model;  
  
    @org.junit.Test  
    public void testXMLConfig() {  
        System.out.println(model);  
    }  
}

结果

id1-----Honda

2、<bean>元素

1）、<meta> 元素

作用：描述元素（key属性、value属性）

测试：略


2）、<lookup-method> 元素

作用：一个单例 <bean> 中，引用了多例 <bean> 时使用（注意：是引用关系，不是单个<bean>使用）

测试：

定义 Service 服务接口

public interface TestService {

    String testService();
}

定义 Service 服务接口实现

public class ProServiceImpl implements TestService {

    private int i = 1;

    public String testService() {
        return i++ + "";
    }
}
public class TestServiceImpl implements TestService{

    private int i = 1;

    public String testService() {
        return i++ + "";
    }
}

定义 Controller 控制层

public abstract class TestController {

    // 动态实例：使用cglib动态代理实例赋值
    public abstract TestService getService();

    public String testController() {
        // 抽象调用
        return getService().testService();
    }
}

配置文件

<?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="testService" class="test.define.service.impl.TestServiceImpl" scope="singleton" />
    <!-- 多例 -->
    <bean id="proService" class="test.define.service.impl.ProServiceImpl" scope="prototype"></bean>

    <!-- 测试单例注入 -->
    <bean id="testController1" class="test.define.controller.TestController" scope="singleton">
        <lookup-method name="getService" bean="testService"/>
    </bean>
    <!-- 测试多例注入 -->
    <bean id="testController2" class="test.define.controller.TestController" scope="singleton">
        <lookup-method name="getService" bean="proService"/>
    </bean>
</beans>

测试类

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:spring/spring.xml")
public class Test {

    // 单例注入
    @Autowired
    @Qualifier("testController1")
    private TestController c1;

    // 多例注入
    @Autowired
    @Qualifier("testController2")
    private TestController c2;

    @org.junit.Test
    public void testXMLConfig() {
        // 单例测试
        System.out.println(c1.testController());
        System.out.println(c1.testController());
        System.out.println(c1.testController());
        System.out.println("-----------------");
        // 多例测试
        System.out.println(c2.testController());
        System.out.println(c2.testController());
        System.out.println(c2.testController());
    }
}

结果

1
2
3
-----------------
1
1
1


3）、<replaced-method> 元素

作用：替换一个正在运行的方法

测试：

定义被替换类

public class TestController {

    // 被替换的方法：方法名称 testController
    public String testController() {
        return "SUCCESS!!!";
    }
}

定义替换类

public class ReplaceController implements MethodReplacer {

    // 该方法表示替换任何一个方法
    // obj 返回值类型
    // method 被替换的方法
    // args 额外参数
    public Object reimplement(Object obj, Method method, Object[] args) throws Throwable {
        // 返回与被替换的方法相同的类型
        System.out.println(method.getName());
        return "Replace Controller: SUCCESS!!!";
    }
}

配置文件

<?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">

    <!-- 替换其他方法的类：只有一个有效方法 reimplement，表示替换方法 -->
    <bean id="replaceController" class="test.define.replace.ReplaceController"/>

    <!-- 被替换方法的类 -->
    <bean id="testController" class="test.define.controller.TestController">
        <!-- name 表示被替换的方法名 -->
        <!-- replaceController 表示替换的方法 -->
        <replaced-method name="testController" replacer="replaceController">
            <!-- 替换方法的第一个参数 -->
            <arg-type>String</arg-type>
        </replaced-method>
    </bean>
</beans>

测试类

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:spring/spring.xml")
public class Test {

    @Autowired
    private TestController controller;

    @org.junit.Test
    public void testXMLConfig() {
        System.out.println(controller.testController());
    }
}

结果

testController
Replace Controller: SUCCESS!!!

4）、<constructor-arg> 元素

          index：索引赋值

          type：参数类型

          name：参数名称

          value：具体的值

分为三种：

基本类型注入

引用类型注入

集合类型注入

测试基本类型注入

测试注入类

public class TestController {

    private String str;

    public TestController() {
        str = "No params";
    }

    public TestController(int i) {
        str = "One param, type is int : " + i;
    }

    public TestController(String s) {
        str = "One param, type is string : " + s;
    }

    public TestController(int i, String s) {
        str = "Two param, type is int and string: " + i + ", " + s;
    }

    public void testController() {
        System.out.println(str);
    }
}

配置文件

<?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="controllerNoParam" class="test.define.controller.TestController"/>

    <!-- 一个参数构造方法：默认注入（字符串） -->
    <bean id="attributeControllerOneParamWithString" class="test.define.controller.TestController">
        <constructor-arg value="默认方式赋值：默认字符串"/>
    </bean>

    <!-- 一个参数构造方法：根据类型注入 -->
    <bean id="attributeControllerOneParamWithInt" class="test.define.controller.TestController">
        <constructor-arg type="int" value="1"/>
    </bean>

    <!-- 一个参数构造方法：根据参数名注入 -->
    <bean id="attributeControllerOneParamWithStringAndName" class="test.define.controller.TestController">
        <constructor-arg value="参数名方式赋值" name="s"/>
    </bean>

    <!-- 两个参数构造方法：根据索引注入 -->
    <bean id="attributeControllerTwoParam" class="test.define.controller.TestController">
        <constructor-arg index="0" value="1"/>
        <constructor-arg index="1" value="两个参数构造方法"/>
    </bean>


    <!-- 一个参数构造方法：默认注入（字符串） -->
    <bean id="elementControllerOneParamWithString" class="test.define.controller.TestController">
        <constructor-arg>
            <value>默认方式赋值：默认字符串</value>
        </constructor-arg>
    </bean>

    <!-- 一个参数构造方法：根据类型注入 -->
    <bean id="elementControllerOneParamWithInt" class="test.define.controller.TestController">
        <constructor-arg>
            <value type="int">1</value>
        </constructor-arg>
    </bean>

    <!-- 一个参数构造方法：根据参数名注入 -->
    <bean id="elementControllerOneParamWithStringAndName" class="test.define.controller.TestController">
        <constructor-arg name="s">
            <value>参数名方式赋值</value>
        </constructor-arg>
    </bean>

    <!-- 两个参数构造方法：根据索引注入 -->
    <bean id="elementControllerTwoParam" class="test.define.controller.TestController">
        <constructor-arg index="0">
            <value>1</value>
        </constructor-arg>
        <constructor-arg index="1">
            <value>两个参数构造方法</value>
        </constructor-arg>
    </bean>
</beans>

测试类

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:spring/spring.xml")
public class Test {

    /**
     * 无参构造方法
     */
    @Autowired
    @Qualifier("controllerNoParam")
    private TestController controllerNoParam;

    /**
     * 基本类型注入：属性注入
     */
    @Autowired
    @Qualifier("attributeControllerOneParamWithInt")
    private TestController attributeControllerOneParamWithInt;

    @Autowired
    @Qualifier("attributeControllerOneParamWithString")
    private TestController attributeControllerOneParamWithString;
    @Autowired
    @Qualifier("attributeControllerOneParamWithStringAndName")
    private TestController attributeControllerOneParamWithStringAndName;

    /**
     * 基本类型注入：元素注入
     */
    @Autowired
    @Qualifier("elementControllerTwoParam")
    private TestController elementControllerTwoParam;

    @Autowired
    @Qualifier("elementControllerOneParamWithInt")
    private TestController elementControllerOneParamWithInt;

    @Autowired
    @Qualifier("elementControllerOneParamWithString")
    private TestController elementControllerOneParamWithString;
    @Autowired
    @Qualifier("elementControllerOneParamWithStringAndName")
    private TestController elementControllerOneParamWithStringAndName;

    @Autowired
    @Qualifier("attributeControllerTwoParam")
    private TestController attributeControllerTwoParam;


    @org.junit.Test
    public void testXMLConfig() {
        /**
         * 无参构造方法
         */
        controllerNoParam.testController();
        /**
         * 基本类型注入：属性注入
         */
        // 1 个参数构造方法
        attributeControllerOneParamWithInt.testController();
        // 1 个参数构造方法
        attributeControllerOneParamWithString.testController();
        // 1 个参数构造方法
        attributeControllerOneParamWithStringAndName.testController();
        // 2 个参数构造方法
        attributeControllerTwoParam.testController();
        /**
         * 基本类型注入：元素注入
         */
        // 1 个参数构造方法
        elementControllerOneParamWithInt.testController();
        // 1 个参数构造方法
        elementControllerOneParamWithString.testController();
        // 1 个参数构造方法
        elementControllerOneParamWithStringAndName.testController();
        // 2 个参数构造方法
        elementControllerTwoParam.testController();
    }
}

结果

No params
One param, type is int : 1
One param, type is string : 默认方式赋值：默认字符串
One param, type is string : 参数名方式赋值
Two param, type is int and string: 1, 两个参数构造方法
One param, type is int : 1
One param, type is string : 默认方式赋值：默认字符串
One param, type is string : 参数名方式赋值
Two param, type is int and string: 1, 两个参数构造方法

测试引用类型注入

引用对象

public class Model {

    private String name;

    public Model(String name) {
        this.name = name;
    }

    public String toString() {
        return name;
    }
}

测试注入类

public class TestController {

    private String str;

    public TestController(int i, Model model) {
        str = "Two param, type is int : " + i + ", model : " + model;
    }

    public TestController(String s, Model model) {
        str = "Two param, type is string : " + s + ", model : " + model;
    }

    public void testController() {
        System.out.println(str);
    }
}

配置文件

<?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="testModel" class="test.define.model.Model">
        <constructor-arg value="model 名称"/>
    </bean>

    <!-- 属性：类型注入 -->
    <bean id="attributeControllerWithIntAndRef" class="test.define.controller.TestController">
        <constructor-arg type="int" value="1"/>
        <constructor-arg type="test.define.model.Model" ref="testModel"/>
    </bean>

    <!-- 属性：参数名称注入 -->
    <bean id="attributeControllerWithStringAndRef" class="test.define.controller.TestController">
        <constructor-arg value="参数名方式赋值" name="s"/>
        <constructor-arg ref="testModel" name="model"/>
    </bean>

    <!-- 属性：索引注入 -->
    <bean id="attributeControllerWithIndex" class="test.define.controller.TestController">
        <constructor-arg index="0" value="1"/>
        <constructor-arg index="1" ref="testModel"/>
    </bean>



    <!-- 元素：类型注入 -->
    <bean id="elementControllerWithIntAndRef" class="test.define.controller.TestController">
        <constructor-arg>
            <value type="int">1</value>
        </constructor-arg>
        <constructor-arg>
            <ref bean="testModel"/>
        </constructor-arg>
    </bean>

    <!-- 元素：参数名称注入 -->
    <bean id="elementControllerWithStringAndRef" class="test.define.controller.TestController">
        <constructor-arg name="s">
            <value>参数名方式赋值</value>
        </constructor-arg>
        <constructor-arg name="model">
            <ref bean="testModel"/>
        </constructor-arg>
    </bean>

    <!-- 元素：索引注入 -->
    <bean id="elementControllerWithIndex" class="test.define.controller.TestController">
        <constructor-arg index="0">
            <value>1</value>
        </constructor-arg>
        <constructor-arg index="1">
            <ref bean="testModel"/>
        </constructor-arg>
    </bean>
</beans>

测试类

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:spring/spring.xml")
public class Test {

    /**
     * 引用类型注入：属性注入
     */
    @Autowired
    @Qualifier("attributeControllerWithIntAndRef")
    private TestController attributeControllerWithIntAndRef;

    @Autowired
    @Qualifier("attributeControllerWithStringAndRef")
    private TestController attributeControllerWithStringAndRef;
    @Autowired
    @Qualifier("attributeControllerWithIndex")
    private TestController attributeControllerWithIndex;

    /**
     * 引用类型注入：元素注入
     */
    @Autowired
    @Qualifier("elementControllerWithIntAndRef")
    private TestController elementControllerWithIntAndRef;

    @Autowired
    @Qualifier("elementControllerWithStringAndRef")
    private TestController elementControllerWithStringAndRef;

    @Autowired
    @Qualifier("elementControllerWithIndex")
    private TestController elementControllerWithIndex;

    @org.junit.Test
    public void testXMLConfig() {
        /**
         * 基本类型注入：属性注入
         */
        attributeControllerWithIntAndRef.testController();
        attributeControllerWithStringAndRef.testController();
        attributeControllerWithIndex.testController();
        /**
         * 基本类型注入：元素注入
         */
        elementControllerWithIntAndRef.testController();
        elementControllerWithStringAndRef.testController();
        elementControllerWithIndex.testController();
    }
}

结果

Two param, type is int : 1, model : model 名称
Two param, type is string : 参数名方式赋值, model : model 名称
Two param, type is string : 1, model : model 名称
Two param, type is int : 1, model : model 名称
Two param, type is string : 参数名方式赋值, model : model 名称
Two param, type is string : 1, model : model 名称

测试集合类型注入

引用对象

public class Model {

    private String name;

    public Model(String name) {
        this.name = name;
    }

    public String toString() {
        return name;
    }
}

测试注入类

public class TestController {

    private String str;

    public TestController(int i, List<Integer> list) {
        str = i + "-----" + Arrays.toString(list.toArray());
    }

    public TestController(String s, List<Model> models) {
        str = s + "-----" + Arrays.toString(models.toArray());
    }

    public TestController(int i, Set<Integer> list) {
        str = i + "-----" + Arrays.toString(list.toArray());
    }

    public TestController(String s, Set<Model> models) {
        str = s + "-----" + Arrays.toString(models.toArray());
    }

    public TestController(int i, Map<Integer,String> map) {
        str = i + "-----" + Arrays.toString(map.entrySet().toArray());
    }

    public TestController(String s, Map<Integer,Model> modelMap) {
        str = s + "-----" + Arrays.toString(modelMap.entrySet().toArray());
    }

    public void testController() {
        System.out.println(str);
    }
}

配置文件

<?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="testModel" class="test.define.model.Model">
        <constructor-arg value="model 名称"/>
    </bean>

    <!-- List：类型注入 -->
    <bean id="list" class="test.define.controller.TestController">
        <constructor-arg type="int" value="1"/>
        <constructor-arg type="java.util.List">
            <list>
                <value type="int">1</value>
                <value type="int">2</value>
                <value type="int">3</value>
            </list>
        </constructor-arg>
    </bean>

    <!-- List：参数名称注入 -->
    <bean id="listAndRef" class="test.define.controller.TestController">
        <constructor-arg value="参数名方式赋值" name="s"/>
        <constructor-arg type="java.util.List">
            <list>
                <ref bean="testModel"/>
                <ref bean="testModel"/>
                <ref bean="testModel"/>
            </list>
        </constructor-arg>
    </bean>

    <!-- Set：索引注入 -->
    <bean id="set" class="test.define.controller.TestController">
        <constructor-arg index="0" value="1"/>
        <constructor-arg type="java.util.Set">
            <set>
                <value type="int">1</value>
                <value type="int">2</value>
                <value type="int">3</value>
            </set>
        </constructor-arg>
    </bean>

    <!-- Set：顺序注入 -->
    <bean id="setAndRef" class="test.define.controller.TestController">
        <constructor-arg>
            <value>参数名方式赋值</value>
        </constructor-arg>
        <constructor-arg type="java.util.Set">
            <set>
                <ref bean="testModel"/>
                <ref bean="testModel"/>
                <ref bean="testModel"/>
            </set>
        </constructor-arg>
    </bean>

    <!-- Map：参数名称注入 -->
    <bean id="map" class="test.define.controller.TestController">
        <constructor-arg  name="i">
            <value>1</value>
        </constructor-arg>
        <constructor-arg name="map">
            <map>
                <entry>
                    <key>
                        <value type="int">1</value>
                    </key>
                    <value type="java.lang.String">测试1</value>
                </entry>
                <entry>
                    <key>
                        <value type="int">2</value>
                    </key>
                    <value type="java.lang.String">测试2</value>
                </entry>
            </map>
        </constructor-arg>
    </bean>

    <!-- Map：索引注入 -->
    <bean id="mapAndRef" class="test.define.controller.TestController">
        <constructor-arg index="0">
            <value>1</value>
        </constructor-arg>
        <constructor-arg index="1">
            <map>
                <entry>
                    <key>
                        <value type="int">1</value>
                    </key>
                    <ref bean="testModel"/>
                </entry>
                <entry>
                    <key>
                        <value type="int">2</value>
                    </key>
                    <ref bean="testModel"/>
                </entry>
            </map>
        </constructor-arg>
    </bean>
</beans>

测试类

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:spring/spring.xml")
public class Test {

    @Autowired
    @Qualifier("list")
    private TestController list;

    @Autowired
    @Qualifier("listAndRef")
    private TestController listAndRef;
    @Autowired
    @Qualifier("set")
    private TestController set;

    @Autowired
    @Qualifier("setAndRef")
    private TestController setAndRef;

    @Autowired
    @Qualifier("map")
    private TestController map;

    @Autowired
    @Qualifier("mapAndRef")
    private TestController mapAndRef;

    @org.junit.Test
    public void testXMLConfig() {
        list.testController();
        listAndRef.testController();
        set.testController();
        setAndRef.testController();
        map.testController();
        mapAndRef.testController();
    }
}

结果

1-----[1, 2, 3]
参数名方式赋值-----[model 名称, model 名称, model 名称]
1-----[1, 2, 3]
参数名方式赋值-----[model 名称]
1-----[1=测试1, 2=测试2]
1-----[1=model 名称, 2=model 名称]


5）、<property> 元素

          name：属性名称

          type：属性类型  

          ref：引用类型

分为三种：

基本类型注入

引用类型注入

集合类型注入

测试基本类型注入

测试注入类

public class TestController {

    private String s;

    private int i;

    public String getS() {
        return s;
    }

    public void setS(String s) {
        this.s = s;
    }

    public int getI() {
        return i;
    }

    public void setI(int i) {
        this.i = i;
    }
}

配置文件

<?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="testInt" class="test.define.controller.TestController">
        <property name="i" value="1"/>
    </bean>

    <bean id="testString" class="test.define.controller.TestController">
        <property name="s">
            <value type="java.lang.String">字符串注入</value>
        </property>
    </bean>
</beans>

测试类

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:spring/spring.xml")
public class Test {

    @Autowired
    @Qualifier("testInt")
    private TestController testInt;

    @Autowired
    @Qualifier("testString")
    private TestController testString;

    @org.junit.Test
    public void testXMLConfig() {
        // 整型注入
        System.out.println(testInt.getI());
        // 字符串注入
        System.out.println(testString.getS());
    }
}

结果

1
字符串注入

测试引用类型注入

引用对象

public class Model {

    private String name;

    public Model(String name) {
        this.name = name;
    }

    public String toString() {
        return name;
    }
}

测试注入类

public class TestController {

    private Model model;

    public Model getModel() {
        return model;
    }

    public void setModel(Model model) {
        this.model = model;
    }
}

配置文件

<?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="model" class="test.define.model.Model">
        <constructor-arg name="name" value="model名称测试"/>
    </bean>

    <bean id="attributeModel" class="test.define.controller.TestController">
        <property name="model" ref="model"/>
    </bean>

    <bean id="elementModel" class="test.define.controller.TestController">
        <property name="model">
            <ref bean="model"/>
        </property>
    </bean>
</beans>

测试类

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:spring/spring.xml")
public class Test {

    @Autowired
    @Qualifier("attributeModel")
    private TestController attributeModel;

    @Autowired
    @Qualifier("elementModel")
    private TestController elementModel;

    @org.junit.Test
    public void testXMLConfig() {
        System.out.println(attributeModel.getModel());
        System.out.println(elementModel.getModel());
    }
}

结果

model名称测试
model名称测试


测试集合类型注入

引用对象

public class Model {

    private String name;

    public Model(String name) {
        this.name = name;
    }

    public String toString() {
        return name;
    }
}

测试注入类

public class TestController {

    private List<Integer> list;
    private List<Model> modelList;

    private Set<String> set;
    private Set<Model> modelSet;

    private Map<Integer,String> map;
    private Map<Integer,Model> modelMap;

    public String getList() {
        return Arrays.toString(list.toArray());
    }

    public void setList(List<Integer> list) {
        this.list = list;
    }

    public String getModelList() {
        return Arrays.toString(modelList.toArray());
    }

    public void setModelList(List<Model> modelList) {
        this.modelList = modelList;
    }

    public String getSet() {
        return Arrays.toString(set.toArray());
    }

    public void setSet(Set<String> set) {
        this.set = set;
    }

    public String getModelSet() {
        return Arrays.toString(modelSet.toArray());
    }

    public void setModelSet(Set<Model> modelSet) {
        this.modelSet = modelSet;
    }

    public String getMap() {
        return Arrays.toString(map.entrySet().toArray());
    }

    public void setMap(Map<Integer, String> map) {
        this.map = map;
    }

    public String getModelMap() {
        return Arrays.toString(modelMap.entrySet().toArray());
    }

    public void setModelMap(Map<Integer, Model> modelMap) {
        this.modelMap = modelMap;
    }
}

配置文件

<?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="model" class="test.define.model.Model">
        <constructor-arg name="name" value="model名称测试"/>
    </bean>

    <bean id="list" class="test.define.controller.TestController">
        <property name="list">
            <list>
                <value>1</value>
                <value>2</value>
                <value>3</value>
            </list>
        </property>
    </bean>

    <bean id="modelList" class="test.define.controller.TestController">
        <property name="modelList">
            <list>
                <ref bean="model"/>
                <ref bean="model"/>
                <ref bean="model"/>
            </list>
        </property>
    </bean>

    <bean id="set" class="test.define.controller.TestController">
        <property name="set">
            <set>
                <value>1</value>
                <value>2</value>
                <value>3</value>
            </set>
        </property>
    </bean>

    <bean id="modelSet" class="test.define.controller.TestController">
        <property name="modelSet">
            <set>
                <ref bean="model"/>
                <ref bean="model"/>
                <ref bean="model"/>
            </set>
        </property>
    </bean>

    <bean id="map" class="test.define.controller.TestController">
        <property name="map">
            <map>
                <entry>
                    <key>
                        <value type="int">1</value>
                    </key>
                    <value>测试1</value>
                </entry>
                <entry>
                    <key>
                        <value type="int">2</value>
                    </key>
                    <value>测试2</value>
                </entry>
            </map>
        </property>
    </bean>

    <bean id="modelMap" class="test.define.controller.TestController">
        <property name="modelMap">
            <map>
                <entry>
                    <key>
                        <value type="int">1</value>
                    </key>
                    <ref bean="model"/>
                </entry>
                <entry>
                    <key>
                        <value type="int">2</value>
                    </key>
                    <ref bean="model"/>
                </entry>
            </map>
        </property>
    </bean>
</beans>

测试类

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:spring/spring.xml")
public class Test {

    @Autowired
    @Qualifier("list")
    private TestController list;

    @Autowired
    @Qualifier("modelList")
    private TestController modelList;

    @Autowired
    @Qualifier("set")
    private TestController set;

    @Autowired
    @Qualifier("modelSet")
    private TestController modelSet;

    @Autowired
    @Qualifier("map")
    private TestController map;

    @Autowired
    @Qualifier("modelMap")
    private TestController modelMap;

    @org.junit.Test
    public void testXMLConfig() {
        System.out.println(list.getList());
        System.out.println(modelList.getModelList());
        System.out.println(set.getSet());
        System.out.println(modelSet.getModelSet());
        System.out.println(map.getMap());
        System.out.println(modelMap.getModelMap());
    }
}

结果

[1, 2, 3]
[model名称测试, model名称测试, model名称测试]
[1, 2, 3]
[model名称测试]
[1=测试1, 2=测试2]
[1=model名称测试, 2=model名称测试]


6）、<qualifier> 元素

作用：同@Qualifier直接

测试：略


7）、元素扩展

          util：工具：集合

              1、定义 Constant （常量）

              2、定义 List

              3、定义 Set

              4、定义 Map

          c：命名空间：构造注入简化版

              1、基本类型注入

              2、引用类型注入

              3、集合类型注入

          p：命名空间：属性注入简化版

              1、基本类型注入

              2、引用类型注入

              3、集合类型注入


测试 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: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">

    <bean id="model" class="test.define.model.Model">
        <constructor-arg value="model测试名称"/>
    </bean>

    <!-- 定义常量 -->
    <util:constant id="default_encode" static-field="test.define.constant.Constants.DEFAULT_ENCODE"/>

    <!-- 定义 List -->
    <util:list id="list">
        <value>1</value>
        <value>2</value>
        <value>3</value>
    </util:list>

    <!-- 定义 List -->
    <util:list id="modelList">
        <ref bean="model"/>
        <ref bean="model"/>
        <ref bean="model"/>
    </util:list>

    <!-- 定义 Set -->
    <util:set id="set">
        <value>1</value>
        <value>2</value>
        <value>3</value>
    </util:set>

    <!-- 定义 Set -->
    <util:set id="modelSet">
        <ref bean="model"/>
        <ref bean="model"/>
        <ref bean="model"/>
    </util:set>

    <!-- 定义 Map -->
    <util:map id="map">
        <entry>
            <key>
                <value>1</value>
            </key>
            <value>测试1</value>
        </entry>
        <entry>
            <key>
                <value>2</value>
            </key>
            <value>测试2</value>
        </entry>
    </util:map>

    <!-- 定义 Map -->
    <util:map id="modelMap">
        <entry>
            <key>
                <value>1</value>
            </key>
            <ref bean="model"/>
        </entry>
        <entry>
            <key>
                <value>2</value>
            </key>
            <ref bean="model"/>
        </entry>
    </util:map>
</beans>


测试 c：命名空间（基本类型注入）

测试 c：命名空间（引用类型注入）

测试 c：命名空间（集合类型注入）

引用对象

public class Model {

    private String name;

    public Model(String name) {
        this.name = name;
    }

    public String toString() {
        return name;
    }
}

定义测试Controller

public class TestController {

    private String str;

    // 基本类型
    public TestController(String name, int age) {
        str = name + "-----" + age;
    }

    // 引用类型
    public TestController(Model model) {
        str = model.toString();
    }

    // 集合类型
    public TestController(List<Integer> list, List<Model> modelList,
                          Set<Integer> set, Set<Model> modelSet,
                          Map<Integer, String> map, Map<Integer, Model> modelMap) {
        str = Arrays.toString(list.toArray()) + "\n" +
                Arrays.toString(modelList.toArray()) + "\n" +
                Arrays.toString(set.toArray()) + "\n" +
                Arrays.toString(modelSet.toArray()) + "\n" +
                Arrays.toString(map.entrySet().toArray()) + "\n" +
                Arrays.toString(modelMap.entrySet().toArray());
    }

    public String testController() {
        return str;
    }
}

配置文件

<?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:util="http://www.springframework.org/schema/util"
       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
       http://www.springframework.org/schema/util
       http://www.springframework.org/schema/util/spring-util.xsd">

    <!-- 属性赋值：基本类型赋值 -->
    <bean id="attributeProperty" class="test.define.controller.TestController" c:name="张三" c:age="18"/>

    <!-- 属性赋值：引用类型赋值 -->
    <bean id="attributeRef" class="test.define.controller.TestController" c:model-ref="model"/>

    <!-- 属性赋值：集合类型赋值 -->
    <bean id="attributeCollection" class="test.define.controller.TestController" c:list-ref="list"
          c:modelList-ref="modelList" c:set-ref="set"
          c:modelSet-ref="modelSet"
          c:map-ref="map" c:modelMap-ref="modelMap"/>

    <!-- 索引赋值：基本类型赋值 -->
    <bean id="indexProperty" class="test.define.controller.TestController" c:_0="张三" c:_1="18"/>

    <!-- 索引赋值：引用类型赋值 -->
    <bean id="indexRef" class="test.define.controller.TestController" c:_0-ref="model"/>

    <!-- 索引赋值：集合类型赋值 -->
    <bean id="indexCollection" class="test.define.controller.TestController" c:_0-ref="list" c:_1-ref="modelList"
          c:set-ref="set"
          c:modelSet-ref="modelSet"
          c:map-ref="map" c:modelMap-ref="modelMap"/>


    <!-- ############################################################################################### -->
    <bean id="model" class="test.define.model.Model">
        <constructor-arg value="model测试名称"/>
    </bean>

    <!-- 定义常量 -->
    <util:constant id="default_encode" static-field="test.define.constant.Constants.DEFAULT_ENCODE"/>

    <!-- 定义 List -->
    <util:list id="list">
        <value>1</value>
        <value>2</value>
        <value>3</value>
    </util:list>

    <!-- 定义 List -->
    <util:list id="modelList">
        <ref bean="model"/>
        <ref bean="model"/>
        <ref bean="model"/>
    </util:list>

    <!-- 定义 Set -->
    <util:set id="set">
        <value>1</value>
        <value>2</value>
        <value>3</value>
    </util:set>

    <!-- 定义 Set -->
    <util:set id="modelSet">
        <ref bean="model"/>
        <ref bean="model"/>
        <ref bean="model"/>
    </util:set>

    <!-- 定义 Map -->
    <util:map id="map">
        <entry>
            <key>
                <value>1</value>
            </key>
            <value>测试1</value>
        </entry>
        <entry>
            <key>
                <value>2</value>
            </key>
            <value>测试2</value>
        </entry>
    </util:map>

    <!-- 定义 Map -->
    <util:map id="modelMap">
        <entry>
            <key>
                <value>1</value>
            </key>
            <ref bean="model"/>
        </entry>
        <entry>
            <key>
                <value>2</value>
            </key>
            <ref bean="model"/>
        </entry>
    </util:map>
</beans>

测试类

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:spring/spring.xml")
public class Test {
    /**
     * 属性赋值
     */
    @Autowired
    @Qualifier("attributeProperty")
    private TestController attributeProperty;

    @Autowired
    @Qualifier("attributeRef")
    private TestController attributeRef;

    @Autowired
    @Qualifier("attributeCollection")
    private TestController attributeCollection;

    /**
     * 索引赋值
     */
    @Autowired
    @Qualifier("indexProperty")
    private TestController indexProperty;

    @Autowired
    @Qualifier("indexRef")
    private TestController indexRef;

    @Autowired
    @Qualifier("indexCollection")
    private TestController indexCollection;

    @org.junit.Test
    public void testXMLConfig() {
        // 属性赋值
        System.out.println(attributeProperty.testController());
        System.out.println(attributeRef.testController());
        System.out.println(attributeCollection.testController());
        // 索引赋值
        System.out.println(indexProperty.testController());
        System.out.println(indexRef.testController());
        System.out.println(indexCollection.testController());
    }
}

结果

张三-----18
model测试名称
[1, 2, 3]
[model测试名称, model测试名称, model测试名称]
[1, 2, 3]
[model测试名称]
[1=测试1, 2=测试2]
[1=model测试名称, 2=model测试名称]
default_encode-----18
model测试名称
[1, 2, 3]
[model测试名称, model测试名称, model测试名称]
[1, 2, 3]
[model测试名称]
[1=测试1, 2=测试2]
[1=model测试名称, 2=model测试名称]


测试 p：命名空间（基本类型注入）

测试 p：命名空间（引用类型注入）

测试 p：命名空间（集合类型注入）

引用对象

public class Model {

    private String name;

    public Model(String name) {
        this.name = name;
    }

    public String toString() {
        return name;
    }
}

测试Controller

public class TestController {

    // 基本类型
    private String name;
    private int age;
    // 引用类型
    private Model model;
    // 集合类型
    List<Integer> list;
    List<Model> modelList;
    Set<Integer> set;
    Set<Model> modelSet;
    Map<Integer, String> map;
    Map<Integer, Model> modelMap;

    public void setName(String name) {
        this.name = name;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public void setModel(Model model) {
        this.model = model;
    }

    public void setList(List<Integer> list) {
        this.list = list;
    }

    public void setModelList(List<Model> modelList) {
        this.modelList = modelList;
    }

    public void setSet(Set<Integer> set) {
        this.set = set;
    }

    public void setModelSet(Set<Model> modelSet) {
        this.modelSet = modelSet;
    }

    public void setMap(Map<Integer, String> map) {
        this.map = map;
    }

    public void setModelMap(Map<Integer, Model> modelMap) {
        this.modelMap = modelMap;
    }

    public String getProperty() {
        return name + "-----" + age;
    }

    public String getRef() {
        return model.toString();
    }

    public String getCollection() {
        return Arrays.toString(list.toArray()) + "\n" +
                Arrays.toString(modelList.toArray()) + "\n" +
                Arrays.toString(set.toArray()) + "\n" +
                Arrays.toString(modelSet.toArray()) + "\n" +
                Arrays.toString(map.entrySet().toArray()) + "\n" +
                Arrays.toString(modelMap.entrySet().toArray());
    }
}

配置文件

<?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:util="http://www.springframework.org/schema/util"
       xmlns:p="http://www.springframework.org/schema/p"
       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">

    <!-- 基本类型赋值 -->
    <bean id="propertyProperty" class="test.define.controller.TestController" p:name="张三" p:age="18"/>

    <!-- 引用类型赋值 -->
    <bean id="propertyRef" class="test.define.controller.TestController" p:model-ref="model"/>

    <!-- 集合类型赋值 -->
    <bean id="propertyCollection" class="test.define.controller.TestController" p:list-ref="list"
          p:modelList-ref="modelList" p:set-ref="set"
          p:modelSet-ref="modelSet"
          p:map-ref="map" p:modelMap-ref="modelMap"/>

    <!-- ############################################################################################### -->
    <bean id="model" class="test.define.model.Model">
        <constructor-arg value="model测试名称"/>
    </bean>

    <!-- 定义常量 -->
    <util:constant id="default_encode" static-field="test.define.constant.Constants.DEFAULT_ENCODE"/>

    <!-- 定义 List -->
    <util:list id="list">
        <value>1</value>
        <value>2</value>
        <value>3</value>
    </util:list>

    <!-- 定义 List -->
    <util:list id="modelList">
        <ref bean="model"/>
        <ref bean="model"/>
        <ref bean="model"/>
    </util:list>

    <!-- 定义 Set -->
    <util:set id="set">
        <value>1</value>
        <value>2</value>
        <value>3</value>
    </util:set>

    <!-- 定义 Set -->
    <util:set id="modelSet">
        <ref bean="model"/>
        <ref bean="model"/>
        <ref bean="model"/>
    </util:set>

    <!-- 定义 Map -->
    <util:map id="map">
        <entry>
            <key>
                <value>1</value>
            </key>
            <value>测试1</value>
        </entry>
        <entry>
            <key>
                <value>2</value>
            </key>
            <value>测试2</value>
        </entry>
    </util:map>

    <!-- 定义 Map -->
    <util:map id="modelMap">
        <entry>
            <key>
                <value>1</value>
            </key>
            <ref bean="model"/>
        </entry>
        <entry>
            <key>
                <value>2</value>
            </key>
            <ref bean="model"/>
        </entry>
    </util:map>
</beans>

测试类

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:spring/spring.xml")
public class Test {
    @Autowired
    @Qualifier("propertyProperty")
    private TestController propertyProperty;

    @Autowired
    @Qualifier("propertyRef")
    private TestController propertyRef;

    @Autowired
    @Qualifier("propertyCollection")
    private TestController propertyCollection;

    @org.junit.Test
    public void testXMLConfig() {
        System.out.println(propertyProperty.getProperty());
        System.out.println(propertyRef.getRef());
        System.out.println(propertyCollection.getCollection());
    }
}

结果

张三-----18
model测试名称
[1, 2, 3]
[model测试名称, model测试名称, model测试名称]
[1, 2, 3]
[model测试名称]
[1=测试1, 2=测试2]
[1=model测试名称, 2=model测试名称]


晚虫
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
spring在IoC容器中装配Bean详解
08-28
Spring 将根据配置文件中的 `<bean>` 元素来实例化对象，并使用方法返回实例对象。 Spring 在 IoC 容器中装配 Bean 的过程包括配置概述、Bean 基本配置、依赖注入、自动装配和方法注入等步骤。了解这些步骤可以帮助...
Spring5学习笔记
m0_53303967的博客
09-19 254
spring注入对象bean(IOC)speing动态(静态)代理类(AOP)spring声明事物。
Bean 配置
Thinker_lk的博客
03-26 399
Bean配置 1.    通过xml文件进行配置 bean id="hello"class="com.spring.pojo.Sys_user"><!-- 默认会调用java类的无参构造 -->    property name="username"value="Spring">property> bean> id：标识容器中的bean，唯一 class：bean的全类名获取be
bean标签属性介绍
lihai755的博客
06-29 360
bean标签常用属性介绍 1.id：不能包含特殊符号，根据id值得到配置对象 2.class：创建对象所在类的全路径 3.name：功能和id属性值一样，但name可以包含特殊符号 4.scope： ①singleton:默认值，单例 ②prototype：多例 ③request：创建对象把对象放到request域里面
Spring之bean对象
qq_66924116的博客
08-08 2468
目录一、了解Bean二、Bean的生命周期三、Bean的应用单例模式多例模式单例模式与多例模式优劣势： 什么是javaBean对象?----- Spring Bean的生命周期： 1）通过XML、Java annotation（注解）以及Java Configuration（配置类） 等方式加载Spring Bean2）BeanDefinitionReader：解析Bean的定义。在Spring容器启动过程中， 会将Bean解析成Spring内部的BeanDefinition结构； 理解为：将spring
Spring 篇：Bean 详解
村雨遥
04-29 2036
Bean 的别名配置 接着上一篇文章中的 <bean> 配置，其中配置了 id 属性，通过 id 属性我们就可以获取到对象。其实 <bean> 配置也提供了 name 属性，它是用于定义 Bean 的别名，一个 Bean 的别名是可以有多个的，各个别名之间可以通过逗号（,）、分号（;）、空格（ ）分隔。 <!-- 配置 bean --> <bean id="bookDao" name="dao bookDaoImpl" class="com.cunyu.dao.
浅谈springioc实例化bean的三个方法
08-29
Spring IOC实例化Bean有三种方法：构造器实例化、静态工厂方法实例化和实例工厂方法实例化。每种方法都有其优缺，选择哪种方法取决于实际需求。 在实际开发中，我们可以根据需要选择合适的实例化方法。例如，如果...
实验一：Spring IoC中Bean的装置的jar包
03-15
XML配置是最传统的Spring Bean定义方式，它通过`<bean>`标签来声明Bean，设置其属性，以及定义Bean之间的依赖关系。例如： ```xml <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi=...
spring ioc的简单实例及bean的作用域属性解析
08-28
}}</code></pre></div></div></div><h2 id="bean的作用域">bean的作用域</h2><p>在Spring中，bean有多种作用域，分别是：</p><ul><li><strong>singleton（单例）</strong>：默认作用域，Spring容器中只会存在一个...
详解Spring框架---IOC装配Bean
08-31
在上面的配置中，Spring框架将使用Bean2的静态工厂方法createInstance来实例化Bean2。 3. 实例工厂实例化 实例工厂实例化是第三种Bean实例化方式。在这种方式中，Spring框架将使用实例工厂来实例化Bean。例如，在...
JS学习记录2
十三月的博客
09-27 383
Global对象 eval json Math对象 Number对象 Object对象
Spring中的bean标签详解
最新发布
write less , do more
06-07 5958
实际开发中，Spring的配置内容非常多，这就导致Spring配置很繁杂且体积很大，所以，可以将部分配置拆解到其他配置文件中，而在Spring主配置文件通过import标签进行加载。其中引用数据类型，此处就不再赘述了，之前的操作都是对UserDao对象的引用进行注入的，下面将以set方法注入为例，演示普通数据类型和集合数据类型的注入。上面的操作，都是注入的引用Bean，除了对象的引用可以注入，普通数据类型，集合等都可以在容器中进行注入。对象创建：当应用加载，创建容器时，对象就被创建了。
Spring系列--Bean标签详解
qq_43404873的博客
11-17 5544
Bean的配置 Spring如同一个工厂，用于生产和管理Spring容器中的Bean。在实际开发中，最常采用XML格式的配置方式，我们将通过XML文件来注册并管理Bean之间的依赖关系。
4.xml中bean定义详解(-)
TiAmonal的博客
09-21 2654
Spring系列第4篇：xml中bean定义详解(-) 本文内容 bean xml配置文件 bean元素详解 名称和别名详解 alias元素详解 通过import元素引入外部配置 环境 jdk1.8 idea maven-3.6.1 spring-5.2.3.RELEASE bean概念回顾 我们再来回顾一下，被spring管理的对象统称为bean，我们程序中需要用到很多对象，我们将这些对象让spring去帮我们创建和管理，我们可以通过bean xml配置文件告诉spring容器需要管理哪些bean
bean标签的常用属性
lzgsea的博客
04-03 1万+
这篇文章总结spring中bean标签的常用属性。bean标签常用属性有：idnameclassfactory-methodfactory-beaninit-methoddestory-methodscopeautowire下面具体来所有这些属性怎么使用。id属性id标签是bean的唯一标识，IoC容器中bean的id标签不能重复，否则报错。name属性name是bean的名称标识，在网上看到有的...
Spring 配置中 bean 的 class 使用工厂 Bean 的含义解析
太阳火神的美丽人生
11-29 4988
Spring 配置中 bean 的 class 使用工厂 Bean 的含义解析
Spring第4篇：bean定义详解
chenzoff的专栏
04-11 908
本文内容 1. bean xml配置文件 2. bean元素详解 2. 名称和别名详解 4. alias元素详解 5. 通过import元素引入外部配置 环境 1. jdk1.8 2. idea 3. maven-3.6.1 4. spring-5.2.3.RELEASE bean概念回顾 我们再来回顾一下，被spring管理的对象统称为bean，我们程序中需要用到很多对象，我们将这些对象让spring去帮我们创建和管理，我们可以通过bean xml配置文件告诉spring容器需要管
Spring定义Bean的两种方式：＜bean＞和@Bean
热门推荐
恐龙弟旺仔的博客
05-02 2万+
前言： Spring中最重要的概念IOC和AOP，实际围绕的就是Bean的生成与使用。 什么叫做Bean呢？我们可以理解成对象，每一个你想交给Spring去托管的对象都可以称之为Bean。 今天通过Spring官方文档来了解下，如何生成bean，如何使用呢？ 1.通过XML的方式来生成一个bean 最简单也是最原始的一种方式，通过XML来定义一个be...
java bean.class_JAVA BEAN和CLASS的区别?
weixin_39837727的博客
02-27 1156
LEATHJavaBean和class的区别：JavaBean只是比class多一些限制条件，其他无区别。JavaBean实质也是一个类,这个类遵循：类必须是具体的和公共的。具有无参数的构造器。通过提供符合一致性设计模式的公共方法将内部域暴露成员属性(即getters和setters)。实现java.io.Serializable接口(这个目前是默认实现的，不需要特殊申明)。例如以下为一个简单的J...
Spring框架：IOC容器与Bean管理详解
"Spring框架.docx - 详细介绍了Spring 5的初始代码和用法，主要涉及IOC（控制反转）的概念、原理以及在XML和注解基础上的bean管理。" 在Spring框架中，控制反转（IOC）是一个核心概念，它实现了对象的创建和依赖...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值