配置方法_让小白也能懂的Bean配置方法

最新推荐文章于 2024-04-05 02:51:46 发布

weixin_39888180

最新推荐文章于 2024-04-05 02:51:46 发布

阅读量257

点赞数

文章标签：配置方法

本文链接：https://blog.csdn.net/weixin_39888180/article/details/111697855

版权

今天整理了一些注入和Bean的知识点，希望能帮助到屏幕前的你

依赖注入(Dependency Injection，DI)和控制反转含义相同，它们是从两个角度描述的同一个概念。

当某个 Java 实例需要另一个 Java 实例时，传统的方法是由调用者创建被调用者的实例(例如，使用 new 关键字获得被调用者实例)，而使用 Spring框架后，被调用者的实例不再由调用者创建，而是由 Spring 容器创建，这称为控制反转。

Spring 容器在创建被调用者的实例时，会自动将调用者需要的对象实例注入给调用者，这样，调用者通过 Spring 容器获得被调用者实例，这称为依赖注入。

依赖注入主要有两种实现方式，分别是属性 setter 注入和构造方法注入。具体介绍如下。

1)属性 setter 注入

指 IoC 容器使用 setter 方法注入被依赖的实例。通过调用无参构造器或无参 static 工厂方法实例化 bean 后，调用该 bean 的 setter 方法，即可实现基于 setter 的 DI。

2)构造方法注入

指 IoC 容器使用构造方法注入被依赖的实例。基于构造器的 DI 通过调用带参数的构造方法实现，每个参数代表一个依赖。

下面通过属性 setter 注入的案例演示 Spring 容器是如何实现依赖注入的。具体步骤如下。

1. 创建 PersonService 接口

在 springDemo01 项目的 com.mengma.ioc 包下创建一个名为 PersonService 的接口，该接口中包含一个 addPerson() 方法，如下所示。

package com.mengma.ioc;

public interface PersonService {

public void addPerson();

}

2. 创建接口实现类 PersonServiceImpl

在 com.mengma.ioc 包下创建一个名为 PersonServiceImpl 的类，该类实现了 PersonService 接口，如下所示。

package com.mengma.ioc;

public class PersonServiceImpl implements PersonService {

// 定义接口声明

private PersonDao personDao;

// 提供set()方法，用于依赖注入

public void setPersonDao(PersonDao personDao) {

this.personDao = personDao;

}

// 实现PersonService接口的方法

@Override

public void addPerson() {

personDao.add(); // 调用PersonDao中的add()方法

System.out.println("addPerson()执行了...");

}

上述代码中，首先声明了 personDao 对象，并为其添加 setter 方法，用于依赖注入，然后实现了 PersonDao 接口的 addPerson() 方法，并在方法中调用 save() 方法和输出一条语句。

3. 在 applicationContext.xml 中添加配置信息

在 applicationContext.xml 配置文件中添加一个元素，用于实例化 PersonServiceImpl 类，并将 personDao 的实例注入到 personService 中，其实现代码如下所示：

id="personService" class="com.mengma.ioc.PersonServiceImpl">

name="personDao" ref="personDao"/>

4. 编写测试方法

在 FirstTest 类中创建一个名为 test2() 的方法，编辑后如下所示：

@Test

public void test2() {

// 定义Spring配置文件的路径

String xmlPath = "applicationContext.xml";

// 初始化Spring容器，加载配置文件

ApplicationContext applicationContext = new ClassPathXmlApplicationContext(

xmlPath);

// 通过容器获取personService实例

PersonService personService = (PersonService) applicationContext

.getBean("personService");

// 调用personService的addPerson()方法

personService.addPerson();

}

5. 运行项目并查看结果

使用 JUnit 测试运行 test2() 方法，运行成功后，控制台的输出结果如图 1 所示。

图 1 运行结果

从图 1 的输出结果中可以看出，使用 Spring 容器获取 userService 的实例后，调用了该实例的 addPerson() 方法，在该方法中又调用了 PersonDao 实现类中的 add() 方法，并输出了结果。这就是 Spring 容器属性 setter 注入的方式，也是实际开发中较为常用的一种方式。

作为 Spring 核心机制的依赖注入，改变了传统的编程习惯，对组件的实例化不再由应用程序完成，转而交由 Spring 容器完成，在需要时注入应用程序中，从而对组件之间依赖关系进行了解耦。这一切都离不开 Spring 配置文件中使用的元素。

Spring 容器可以被看作一个大工厂，而 Spring 容器中的 Bean 就相当于该工厂的产品。如果希望这个大工厂能够生产和管理 Bean，这时则需要告诉容器需要哪些 Bean，以及需要以何种方式将这些 Bean 装配到一起。

Spring 配置文件支持两种不同的格式，分别是 XML 文件格式和 Properties 文件格式。

通常情况下，Spring 会以 XML 文件格式作为 Spring 的配置文件，这种配置方式通过 XML 文件注册并管理 Bean 之间的依赖关系。

XML 格式配置文件的根元素是，该元素包含了多个子元素，每一个子元素定义了一个 Bean，并描述了该 Bean 如何被装配到 Spring 容器中。

定义 Bean 的示例代码如下所示：

xmlns="http://www.springframework.org/schema/beans"

xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p"

xsi:schemaLocation="http://www.springframework.org/schema/beans

http://www.springframework.org/schema/beans/spring-beans-3.2.xsd">

id="person1" class="com.mengma.damain.Person1" />

name="Person2" class="com.mengma.domain.Person2"/>

在上述代码中，分别使用 id 和 name 属性定义了两个 Bean，并使用 class 元素指定了 Bean 对应的实现类。

元素中包含很多属性，其常用属性如表 1 所示。

在面向对象的程序中，要想调用某个类的成员方法，就需要先实例化该类的对象。在Spring中，实例化 Bean 有三种方式，分别是构造器实例化、静态工厂方式实例化和实例工厂方式实例化。本节将针对这三种方式分别进行讲解。

构造器实例化

构造器实例化是指 Spring 容器通过 Bean 对应的类中默认的构造函数实例化 Bean。下面通过案例演示如何使用构造器实例化 Bean。

1. 创建项目并导入 JAR 包

在 MyEclipse 中创建一个名称为 springDemo02 的 Web 项目，然后将 Spring 支持和依赖的 JAR 包复制到项目的 lib 目录中，并发布到类路径下。

2. 创建实体类

在项目的 src 目录下创建一个名为 com.mengma.instance.constructor 的包，在该包下创建一个实体类 Person1，如下所示。

package com.mengma.instance.constructor;

public class Person1 {

}

3. 创建 Spring 配置文件

在 com.mengma.instance.constructor 包下创建 Spring 的配置文件 applicationContext.xml，编辑后如下所示。

xmlns="http://www.springframework.org/schema/beans"

xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p"

xsi:schemaLocation="http://www.springframework.org/schema/beans

http://www.springframework.org/schema/beans/spring-beans-3.2.xsd">

id="person1" class="com.mengma.instance.constructor.Person1" />

在上述配置中，定义了一个 id 为 person1 的 Bean，其中 class 属性指定了其对应的类为 Person1。

4. 创建测试类

在 com.mengma.instance.constructor 包下创建一个名为 InstanceTest1 的测试类，编辑后如下所示。

package com.mengma.instance.constructor;

import org.junit.Test;

import org.springframework.context.ApplicationContext;

import org.springframework.context.support.ClassPathXmlApplicationContext;

public class InstanceTest1 {

@Test

public void test() {

// 定义Spring配置文件的路径

String xmlPath = "com/mengma/instance/constructor/ApplicationContext.xml";

// 初始化Spring容器，加载配置文件，并对bean进行实例化

ApplicationContext applicationContext = new ClassPathXmlApplicationContext(

xmlPath);

// 通过容器获取id为person1的实例

System.out.println(applicationContext.getBean("person1"));

}

上述文件中，首先在 test() 方法中定义了 Spring 配置文件的路径，然后 Spring 容器会加载配置文件。在加载的同时，Spring 容器会通过实现类 Person1 中默认的无参构造函数对 Bean 进行实例化。

5. 运行程序并查看结果

使用 JUnit 测试运行 test() 方法，运行成功后，控制台的输出结果如图 1 所示。

图 1 输出结果

从图 1 的输出结果中可以看出，Spring 容器已经成功对 Bean 进行了实例化，并输出了结果。

注意：为了方便读者的学习，本节中的所有配置文件和 Java 文件都根据知识点放置在同一个包中。在实际开发中，为了方便管理和维护，建议将这些文件根据类别放置在不同目录中。

静态工厂方式实例化

在 Spring 中，也可以使用静态工厂的方式实例化 Bean。此种方式需要提供一个静态工厂方法创建 Bean 的实例。下面通过案例演示如何使用静态工厂方式实例化 Bean。

1. 创建实体类

在项目的 src 目录下创建一个名为 com.mengma.instance.static_factory 的包，并在该包下创建一个实体类 Person2，该类与 Person1 相同，不需要添加任何成员。

2. 创建静态工厂类

在 com.mengma.instance.static_factory 包下创建一个名为 MyBeanFactory 的类，并在该类中创建一个名为 createBean() 的静态方法，用于创建 Bean 的实例，如下所示。

package com.mengma.instance.static_factory;

public class MyBeanFactory {

// 创建Bean实例的静态工厂方法

public static Person2 createBean() {

return new Person2();

}

3. 创建 Spring 配置文件

在 com.mengma.instance.static_factory 包下创建 Spring 的配置文件 applicationContext.xml，编辑后如下所示。

xmlns="http://www.springframework.org/schema/beans"

xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p"

xsi:schemaLocation="http://www.springframework.org/schema/beans

http://www.springframework.org/schema/beans/spring-beans-3.2.xsd">

id="person2" class="com.mengma.instance.static_factory.MyBeanFactory"

factory-method="createBean" />

上述代码中，定义了一个 id 为 person2 的 Bean，其中 class 属性指定了其对应的工厂实现类为 MyBeanFactory，而 factory-method 属性用于告诉 Spring 容器调用工厂类中的 createBean() 方法获取 Bean 的实例。

4. 创建测试类

在 com.mengma.instance.static_factory 包下创建一个名为 InstanceTest2 的测试类，编辑后如下所示。

package com.mengma.instance.static_factory;

import org.junit.Test;

import org.springframework.context.ApplicationContext;

import org.springframework.context.support.ClassPathXmlApplicationContext;

public class InstanceTest2 {

@Test

public void test() {

// 定义Spring配置文件的路径

String xmlPath = "com/mengma/instance/static_factory/applicationContext.xml"; // 初始化Spring容器，加载配置文件，并对bean进行实例化

ApplicationContext applicationContext = new ClassPathXmlApplicationContext(

xmlPath);

// 通过容器获取id为person2实例

System.out.println(applicationContext.getBean("person2"));

}

5. 运行程序并查看结果

使用 JUnit 测试运行 test() 方法，运行成功后，控制台的输出结果如图 2 所示。

从图 2 的输出结果中可以看出，使用静态工厂的方式也成功对 Bean 进行了实例化。

图 2 输出结果

实例工厂方式实例化

在 Spring 中，还有一种实例化 Bean 的方式就是采用实例工厂。在这种方式中，工厂类不再使用静态方法创建 Bean 的实例，而是直接在成员方法中创建 Bean 的实例。

同时，在配置文件中，需要实例化的 Bean 也不是通过 class 属性直接指向其实例化的类，而是通过 factory-bean 属性配置一个实例工厂，然后使用 factory-method 属性确定使用工厂中的哪个方法。下面通过案例演示实例工厂方式的使用。

1. 创建实体类

在项目的 src 目录下创建一个名为 com.mengma.instance.factory 的包，在该包下创建一个 Person3 类，该类与 Person1 类相同，不需要添加任何成员。

2. 创建实例工厂类

在 com.mengma.instance.factory 包下创建一个名为 MyBeanFactory 的类，编辑后如下所示。

package com.mengma.instance.factory;

public class MyBeanFactory {

public MyBeanFactory() {

System.out.println("person3工厂实例化中");

}

// 创建Bean的方法

public Person3 createBean() {

return new Person3();

}

上述代码中，使用默认无参的构造方法输出 person3 工厂实例化中语句，使用 createBean 成员方法创建 Bean 的实例。

3. 创建 Spring 配置文件

在 com.mengma.instance.factory 包下创建 Spring 的配置文件 applicationContext.xml，如下所示。

xmlns="http://www.springframework.org/schema/beans"

xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p"

xsi:schemaLocation="http://www.springframework.org/schema/beans

http://www.springframework.org/schema/beans/spring-beans-3.2.xsd">

id="myBeanFactory" class="com.mengma.instance.factory.MyBeanFactory" />

id="person3" factory-bean="myBeanFactory" factory-method="createBean" />

上述代码中，首先配置了一个实例工厂 Bean，然后配置了需要实例化的 Bean。在 id 为 person3 的 Bean 中，使用 factory-bean 属性指定一个实例工厂，该属性值就是实例工厂的 id 属性值。使用 factory-method 属性确定使用工厂中的 createBean() 方法。

4. 创建测试类

在 com.mengma.instance.factory 包下创建一个名为 InstanceTest3 的测试类，编辑后如下所示。

package com.mengma.instance.factory;

import org.junit.Test;

import org.springframework.context.ApplicationContext;

import org.springframework.context.support.ClassPathXmlApplicationContext;

public class InstanceTest3 {

@Test

public void test() {

// 定义Spring配置文件的路径

String xmlPath = "com/mengma/instance/factory/applicationContext.xml"; // 初始化Spring容器，加载配置文件，并对bean进行实例化

// 初始化Spring容器，加载配置文件，并对bean进行实例化

ApplicationContext applicationContext = new ClassPathXmlApplicationContext(

xmlPath);

// 通过容器获取id为person3实例

System.out.println(applicationContext.getBean("person3"));

}

5. 运行程序并查看结果

使用 JUnit 测试运行 test() 方法，运行成功后，控制台的输出结果如图 3 所示。

图 3 输出结果

从图 3 的输出结果中可以看出，使用实例工厂的方式也同样对 Bean 进行了实例化。

如果你喜欢我的文章，请点击关注我会尽量每天更新，如果想联系我请加入:943064644

weixin_39888180

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
配置方法_让小白也能懂的Bean配置方法

今天整理了一些注入和Bean的知识点，希望能帮助到屏幕前的你依赖注入(Dependency Injection，DI)和控制反转含义相同，它们是从两个角度描述的同一个概念。当某个 Java 实例需要另一个 Java 实例时，传统的方法是由调用者创建被调用者的实例(例如，使用 new 关键字获得被调用者实例)，而使用 Spring框架后，被调用者的实例不再由调用者创建，而是由 Spring 容器创...
复制链接

扫一扫