0
0

【Spring篇】Spring中的Bean管理

** 🧸安清h：个人主页**

** 🎥个人专栏：【计算机网络】【Mybatis篇】**

🚦作者简介：一个有趣爱睡觉的intp，期待和更多人分享自己所学知识的真诚大学生。

🎯Spring IOC容器

Spring框架的主要功能是通过Spring容器实现的，Spring容器可以管理人们开发的各种Bean。Spring提供了相应API来管理Bean，在Spring容器的API里，最常用的是BeanFactory和ApplicationContext这两个接口。

🚦BeanFactory接口

BeanFactory

是 Spring 框架中的一个核心接口，它定义了 Spring IoC 容器的基本功能。

BeanFactory

提供了配置应用程序组件的方式，并且负责这些组件的生命周期和依赖关系的管理。它是 Spring 框架中最原始的 IoC 容器的表现形式。

BeanFactory

通常由 

ApplicationContext

接口实现。

BeanFactory接口的一些关键方法示例：

  1. Object getBean(String name)：根据给定的 Bean 名称获取一个 Bean 实例。
  2. <T> T getBean(String name, Class<T> requiredType)：根据给定的 Bean 名称和期望的类型获取一个 Bean 实例。
  3. Object getBean(String name, Object... args)：根据给定的 Bean 名称和构造函数参数获取一个 Bean 实例。
  4. <T> T getBean(Class<T> requiredType)：根据给定的类型获取一个 Bean 实例。
  5. <T> T getBean(Class<T> requiredType, Object... args)：根据给定的类型和构造函数参数获取一个 Bean 实例。
  6. boolean containsBean(String name)：检查是否包含一个具有给定名称的 Bean。
  7. boolean isSingleton(String name)：检查一个具有给定名称的 Bean 是否是单例作用域。
  8. boolean isPrototype(String name)：检查一个具有给定名称的 Bean 是否是原型作用域。
  9. boolean isTypeMatch(String name, Class<?> targetType)：检查一个具有给定名称的 Bean 是否是指定类型的一个匹配。
  10. Class<?> getType(String name)：获取一个具有给定名称的 Bean 的类型。
  11. String[] getAliases(String name)：获取一个具有给定名称的 Bean 的所有别名。

🚦ApplicationContext接口

ApplicationContext

接口是 Spring 框架中 

BeanFactory

的一个扩展，它提供了更多的高级功能和特性，以支持企业级应用开发。

ApplicationContext

包含了 

BeanFactory

的所有功能。

ApplicationContext

接口的一些关键实现包括：

  • ClassPathXmlApplicationContext：从类路径下的 XML 配置文件中加载上下文定义。
  • FileSystemXmlApplicationContext：从文件系统下的 XML 配置文件中加载上下文定义。
  • AnnotationConfigApplicationContext：从注解配置类中加载上下文定义。
  • WebApplicationContext：用于 Web 应用程序，如 ServletContext 或 PortletContext。

🎯Bean的配置

在Spring框架中，Bean的配置是将类定义为Spring容器管理的对象的过程。Spring支持多种方式来配置Bean，包括XML配置、注解和Java配置类。

🚦Bean元素的多个属性

在Spring的XML配置中，

<bean>

元素具有多个属性，用于定义和管理Bean的创建和行为。以下是一些常用的

<bean>

元素属性：

  1. id：Bean的唯一标识符。通常用于通过getBean方法按名称检索Bean。
  2. class：Bean的全限定类名。Spring将使用这个类名来实例化Bean。
  3. name：为Bean提供额外的名称。可以有多个名称，它们之间用逗号、空格或分号分隔。
  4. scope：定义Bean的作用域。常见的作用域包括singleton（单例，默认值）、prototype（原型）、request（Web应用中的请求）、session（Web应用中的会话）等。
  5. lazy-init：指定Bean是否应该延迟初始化，直到它被首次请求时才创建。

🚦Bean元素的多个子元素

在Spring的XML配置中，

<bean>

元素可以包含多个子元素，这些子元素用于定义Bean的属性、构造函数参数、元数据以及其他配置。以下是一些常用的

<bean>

子元素：

  1. **<property>**：用于设置Bean的属性。它包含一个或多个<value>、<ref>或<bean>子元素，用于指定属性的值。
  2. **<constructor-arg>**：用于提供构造函数参数。可以包含<value>、<ref>或<bean>子元素，或者通过index或type属性指定参数的位置或类型。
  3. <property>的集合：可以定义多个<property>子元素来设置Bean的多个属性。

🎯Bean的实例化

在Spring框架中，Bean的实例化是指创建Bean实例的过程。Spring提供了多种方式来实例化Bean，这些方式可以通过配置来指定。以下是Spring中常见的Bean实例化方式：

🚦构造方法实例

在Spring中，构造方法实例化是通过调用类的构造方法来创建Bean实例的一种方式。这种方式适用于需要通过构造参数来初始化Bean的情况。以下是如何在Spring中使用构造方法实例化Bean的步骤：

✨pom.xml文件

 <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.2.8.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>5.2.8.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-beans</artifactId>
            <version>5.2.8.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-expression</artifactId>
            <version>5.2.8.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>commons-logging</groupId>
            <artifactId>commons-logging</artifactId>
            <version>1.2</version>
        </dependency>
    </dependencies>

✨创建Bean1类

public class Bean1 {
    public Bean1(){
        System.out.println("Bean1");
    }
}

✨编写applicationContext.xml文件

 <bean id="bean1" class="com.han.Bean1"></bean>

✨编写测试类

public class Bean1Test {
    public static void main(String[]args){
        ApplicationContext applicationContext=new ClassPathXmlApplicationContext("applicationContext.xml");
        Bean1 bean= (Bean1) applicationContext.getBean("bean1");
        System.out.println(bean);
    }
}

🚦静态工厂实例化

静态工厂实例化是指使用类的静态方法来创建Bean实例的方式。在Spring中，可以通过配置XML文件来指定使用哪个类的静态方法来创建Bean。这种方式特别适用于那些没有构造函数参数或者需要通过特定工厂方法来创建实例的情况。

✨创建Bean2类

public class Bean2 {
    public Bean2(){
        System.out.println("Bean2");
    }
}

✨创建MyBean2Factory类

public class Bean2Factory {
    public static Bean2 createBean(){
        return new Bean2();
    }
}

✨编写applicationContext.xml文件

 <bean id="bean2" class="com.han.Bean2Factory" factory-method="createBean"></bean>

✨编写测试类

public class Bean2Test {
    public static void main(String[]args){
        ApplicationContext applicationContext=new ClassPathXmlApplicationContext("applicationContext.xml");
        Bean2 bean2= (Bean2) applicationContext.getBean("bean2");
        System.out.println(bean2);
    }
}

🚦实例工厂实例化

在Spring中，实例工厂实例化是一种创建Bean实例的方法，它允许你通过工厂方法来创建Bean，而不是通过构造函数或静态工厂方法。这种方式提供了更高的灵活性，因为你可以在工厂方法中执行复杂的逻辑来决定哪个Bean的实例应该被创建

✨创建Bean3类

public class Bean3 {
    public Bean3(){
        System.out.println("Bean3");
    }
}

✨创建MyBean3Factory类

public class MyBean3Factory {
    public MyBean3Factory(){
        System.out.println("bean3工厂实例化中");
    }
    public Bean3 createBean(){
        return new Bean3();
    }
}

✨编写applicationContext.xml文件

    <bean id="mybean3" class="com.han.MyBean3Factory"/>
    <bean id="bean3" factory-bean="mybean3" factory-method="createBean"/>

✨编写测试类

public class Bean3Test {
    public static void main(String[]args){
        ApplicationContext applicationContext=new ClassPathXmlApplicationContext("applicationContext.xml");
        Bean3 bean3= (Bean3) applicationContext.getBean("bean3");
        System.out.println(bean3);
    }
}

🎯Bean的作用域

在bean标签中可以通过scope属性指定对象的作用域

scope="singleton"表示当前bean是单例模式（默认饿汉模式，Spring容器初始化阶段就会完成此对象的创建，在bean标签中设置lazy-init="true"时变为懒汉模式）

scope="prototype"表示当前bean为非单例模式，每次通过Spring容器获取此bean的对象时都会创建一个新的对象。

单例

<bean id="book2Spring" class="com.haust.pojo.Book" scope="singleton" lazy-init="true"></bean>

非单例

<bean id="book1Spring" class="com.haust.pojo.Book" scope="prototype"></bean>

bean的声明周期方法

在bean标签中通过init-method属性指定当前bean的初始化方法，初始化方法在构造器执行之后执行。

在bean标签中通过destory-method属性指定当前bean的销毁方法，销毁方法在对象销毁之前执行。

🎯Bean的装配方式

🚦基于Xml的装配

基于XML的装配是Spring框架中的一种配置方式，它允许开发者通过XML文件来定义和管理Bean的创建和依赖关系。这种方式在早期的Spring应用中非常常见，尽管现在注解和Java配置逐渐成为主流，但XML配置仍然是一种重要的配置手段，特别是在需要配置大量复杂Bean关系时。

在XML配置中，Bean的装配可以通过以下几种方式实现：

  1. setter注入（Setter Injection）：这是最常见的装配方式，通过在XML文件中使用<property>标签来注入依赖。这种方式要求Bean类必须提供一个无参构造方法，并且需要注入的属性必须有对应的setter方法。例如：<bean id="student1" class="educoder.Student"> <property name="name" value="张三" /> <property name="age" value="25" /></bean>
  2. 构造注入（Constructor Injection）：通过构造器注入的方式装配Bean，需要在XML配置文件中使用<constructor-arg>标签来定义构造方法的参数。这种方式适用于需要通过构造器传递依赖的场景。例如：<bean id="student2" class="educoder.Student"> <constructor-arg index="0" value="李四" /> <constructor-arg index="1" value="24" /></bean>

🎯基于注解的装配

基于注解的装配是Spring框架中的一种依赖注入方式，它通过在代码中使用特定的注解来实现Bean的自动装配，从而减少了XML配置的复杂性。这种方式使得配置更加简洁，代码与配置的耦合度更低，提高了开发效率。以下是Spring中常用的几种注解装配方式：

  • @Component、@Service、@Repository、@Controller：这些注解用于声明一个类作为Spring容器管理的Bean。@Component是通用的，而其他注解提供了额外的语义信息。
  • @Value：用于注入外部配置的值，如properties文件中的值。
  • @Resource：这是Java标准的一部分，可以通过名称来自动装配Bean，如果Bean的名称与字段名或setter方法名相同，Spring容器会自动装配。
  • @Autowired：这是最常见的自动装配注解，Spring容器会通过类型来自动装配Bean。如果存在多个相同类型的Bean，可以通过@Qualifier注解来指定具体的Bean。

下面通过一个案例来演示用注解装配Bean，具体步骤及代码如下：

🚦导入依赖

<dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aop</artifactId>
            <version>5.2.8.RELEASE</version>
        </dependency>

🚦创建XML配置文件

在appicationContext.xml文件中添加如下代码：

<context:component-scan base-package="com.han"/>

代码中指定要扫描的包为com.han，这个包下的注解就会生效。

🚦定义实体类

实体类

User

是一个简单的Java类，使用

@Component

注解标记为Spring管理的Bean，并设置了作用域为单例。类中定义了三个属性：

id

、

username

和

password

，以及它们的getter和setter方法。

@Value

注解用于注入配置文件中的值。

toString

方法被覆盖以提供类的字符串表示。

@Component("user")
@Scope("singleton")
public class User {
    @Value("1")
    private int id;
    @Value("haha")
    private String username;
    @Value("789")
    private String password;

    public int getId() {
        return id;
    }

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

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", username='" + username + '\'' +
                ", password='" + password + '\'' +
                '}';
    }
}

🚦定义DAO层

DAO层定义了一个接口

UserDao

，其中包含一个

save

方法。这个接口代表了与数据库交互的数据访问对象，

save

方法用于表示保存数据的操作。

public interface UserDao {
    public void save();
}

🚦实现DAO层

UserDaoImpl

类实现了

UserDao

接口，并使用

@Repository

注解标记为Spring的Repository Bean。它的

save

方法中通过Spring的

ApplicationContext

获取了

User

Bean的实例，并打印了用户信息和保存操作的消息。

//使用Repository将UserDaoImpl类标识为Spring中的Bean
@Repository("userDao")
public class UserDaoImpl implements UserDao{
    @Override
    public void save() {
        ApplicationContext applicationContext=new ClassPathXmlApplicationContext("applicationContext.xml");
        User user= (User) applicationContext.getBean("user");
        System.out.println(user);
        System.out.println("执行UserDaoImpl.save()");
    }
}

🚦定义Service层

Service层定义了一个接口

UserService

，其中包含一个

save

方法。这个接口代表了业务逻辑层，

save

方法用于表示执行保存操作的业务逻辑。

public interface UserService {
    public void save();
}

🚦实现Service层

UserServiceImpl

类实现了

UserService

接口，并使用

@Repository

注解标记为Spring的Service Bean。它通过

@Resource

注解注入了

UserDao

，并在

save

方法中调用了

UserDao

的

save

方法，然后打印了业务逻辑层的保存操作消息。

@Repository("userService")
public class UserServiceImpl implements UserService{
    //使用Resource注解注入UserDao
    @Resource(name="userDao")
    private UserDao userDao;
    @Override
    public void save() {
       this.userDao.save();
       System.out.println("执行UserServiceImpl.save()");
    }
}

🚦定义Controller层

Controller层定义了一个

UserController

类，使用

@Controller

注解标记为Spring的Controller Bean。它通过

@Resource

注解注入了

UserService

，并在

save

方法中调用了

UserService

的

save

方法，然后打印了控制器层的保存操作消息。

//使用Controller注解将UserController类标识为Bean
@Controller
public class UserController {
    @Resource(name="userService")
    private UserService userService;
    public void save(){
        this.userService.save();
        System.out.println("执行UserController.save()");
    }
}

🚦定义测试类

测试类

AnnotationTest

包含了一个main方法，用于初始化Spring的

ApplicationContext

并获取

UserController

的实例。然后调用

UserController

的

save

方法来执行保存操作，从而测试整个Spring应用的流程是否正确。

public class AnnotationTest {
    public static void main(String[]args){
        ApplicationContext applicationContext=new ClassPathXmlApplicationContext("applicationContext.xml");
        UserController userController= (UserController) applicationContext.getBean("userController");
        userController.save();
    }
}

以上就是今天要讲的内容了，主要介绍了Bean的配置，实例化，作用域以及装配方式等相关内容，如果您感兴趣的话，可以订阅我的相关专栏。非常感谢您的阅读，如果这篇文章对您有帮助，那将是我的荣幸。我们下期再见啦🧸！

标签： spring java
本文转载自: https://blog.csdn.net/m0_74202856/article/details/142881403
版权归原作者 安清h 所有， 如有侵权，请联系我们删除。
登录后发布评论

“【Spring篇】Spring中的Bean管理”的评论:

还没有评论
关于作者
...
overfit同步小助手
文章同步
相关阅读

安全见闻八：量子计算

【Linux】开发工具make/Makefile、进度条小程序

Linux下学【MySQL】表的必备操作（ 配实操图和SQL语句）

软件测试学习笔记丨Selenium学习笔记：常用页面信息对比方法expected_conditions

将 GitHub 关联到 Git 的详细教程

大数据新视界 -- 大数据大厂之 Impala 性能优化：融合人工智能预测的资源预分配秘籍（上）（29 / 30）

NAT的基本介绍

文章导航