Bean 的实例化与装配

已于 2022-09-22 23:58:14 修改
阅读量1.4k 收藏 13
点赞数 5
分类专栏： JavaEE实验 文章标签： spring java intellij-idea
于 2022-09-22 23:46:41 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_72151428/article/details/127000047
版权

主要程序代码块：

实验要求：
理解 Spring 的 IoC/DI 的原理，掌握 Spring 使用注解方式和编程及 Spring 的分层设计
方法。
实验 1：集合类型注入
编写 UserInfo 类，包含用户姓名（String）、性别（boolean）、年龄（int）、出生年月（Date）、个人爱好（list 集合），采用 set 注入和构造注入两种方式，实现这些属性值的注入，并在测试程序中显示所有属性的值。
实验 2：
编写工厂类（BeanFactory）、Print 类（属性：pName、pColor 等），要求利用 Spring 容器通过工厂类 BeanFactory 生成 Print 对象,并生成测试结果。
实验 3：
利用 Spring 框架，通过注解方式实现为自己的校园卡充值。
在 Dao 层建立 CardDao 类，编写充值方法，实现充值（在控制台显示充值金额，将用户充值信息保存到数据库），在 Biz 层建立 CardBiz 类，编写充值方法，调用 Dao层中的充值方法，完成充值。在 CardController 类中编写充值方法调用 CardBiz 的充值方法。在程序中，通过代码方式调用控制层充值方法，完成充值，并在控制台显示充值金额。在实现过程中不能利用 new 操作来完成类的实例化。观察@Autowired 和@Resource 进行注解时有何不同。
实验 4：
根据自己的理解，描述 Bean 的装配方式。

实验分析：

  • 实验一主要运用Bean基于XML的装配：设值注入、构造注入。
  • 实验二采用的是静态工厂实例化。
  • 实验三主要涉及到Bean的实例化与装配（基于注解的装配）、此外还涉及了Spring对于数据库的连接。此实验可参考利用Spring框架为自己的校园卡充值。

代码实现：

实验一

set注入

package com.cqust;

import java.util.Date;
import java.util.List;

public class UserInfo1 {
    private String name;
    private boolean male;
    private int age;
    private Date birth;
    private List<String> Hobby;

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

    public void setMale(boolean male) {
        this.male = male;
    }

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

    public void setBirth(Date birth) {
        this.birth = birth;
    }

    public void setHobby(List<String> hobby) {
        Hobby = hobby;
    }

    @Override
    public String toString() {
        return "UserInfo{" +
                "姓名='" + name + '\'' +
                ", 男性=" + male +
                ", 年龄=" + age +
                ", 出生日期='" + birth + '\'' +
                ", 兴趣爱好=" + Hobby +
                '}';
    }
}

配置文件

<?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="userInfo1" class="com.cqust.UserInfo1">
        <property name="name" value="Hades"></property>
        <property name="male" value="true"></property>
        <property name="age" value="20"></property>
        <property name="birth" value="2022/9/16"></property>
        <property name="hobby">
            <list>
                <value>阅读</value>
                <value>听音乐</value>
                <value>运动</value>
            </list>
        </property>
    </bean>
</beans>

构造注入

package com.cqust;

import java.util.Date;
import java.util.List;

public class UserInfo2 {
    private String name;
    private boolean male;
    private int age;
    private Date birth;
    private List<String> Hobby;

    public UserInfo2(String name, boolean male, int age, Date birth, List<String> hobby) {
        this.name = name;
        this.male = male;
        this.age = age;
        this.birth = birth;
        Hobby = hobby;
    }

    @Override
    public String toString() {
        return "UserInfo{" +
                "姓名='" + name + '\'' +
                ", 男性=" + male +
                ", 年龄=" + age +
                ", 出生日期='" + birth + '\'' +
                ", 兴趣爱好=" + Hobby +
                '}';
    }
}

配置文件

<?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="userInfo2" class="com.cqust.UserInfo2">
        <constructor-arg name="name" value="Hades"></constructor-arg>
        <constructor-arg name="male" value="true"></constructor-arg>
        <constructor-arg name="age" value="20"></constructor-arg>
        <constructor-arg name="birth" value="2022/9/16"></constructor-arg>
        <constructor-arg name="hobby">
            <list>
                <value>阅读</value>
                <value>听音乐</value>
                <value>运动</value>
            </list>
        </constructor-arg>
    </bean>
</beans>

测试文件（Test1）

import com.cqust.UserInfo1;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Test1 {
    public static void main(String[] args){
        ApplicationContext applicationContext =
                new ClassPathXmlApplicationContext("applicationBean1_1.xml");	//这里展示的是setter方法，构造方法请更换applicationBean1_2.xml
        UserInfo1 userInfo1 = applicationContext.getBean("userInfo1", UserInfo1.class);	//更换为userInfo2
        System.out.println("属性setter方法注入：");	//更换为构造方法注入
        System.out.println(userInfo1);	//更换为userInfo2
    }
}

实验二

Beanfactory类

package com.cqust;

public class BeanFactory {
    public static Print createBean(){
        return new Print();
    }
}

Print类

package com.cqust;

public class Print {
    private String pName;
    private String pColor;

    public void setpName(String pName) {
        this.pName = pName;
    }

    public void setpColor(String pColor) {
        this.pColor = pColor;
    }

    @Override
    public String toString() {
        return "Print{" +
                "p名称='" + pName + '\'' +
                ", p颜色='" + pColor + '\'' +
                '}';
    }
}

配置文件

<?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="print" class="com.cqust.BeanFactory" factory-method="createBean">
        <property name="pName" value="Hades的静态工厂实例化"></property>
        <property name="pColor" value="red"></property>
    </bean>
</beans>

测试文件（Test2）

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Test2 {
    public static void main(String[] args){
        ApplicationContext applicationContext =
                new ClassPathXmlApplicationContext("applicationBean2.xml");
        System.out.println(applicationContext.getBean("print"));

    }
}

实验三

DataSource类：

package com.cqust.biz;

import com.cqust.dao.CardDao;
import com.cqust.entity.User;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service("cardBiz") // 注册 bean
public class CardBiz {
    // 使用注解自动注入并指定注入的 bean 的 id
    @Autowired
    private CardDao cardDao;
    public int save(User user) {
        try {
            // 执行 dao 中的方法并返回结果
            return cardDao.insert(user);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return 0;
    }
    public double selectMoney(String username){
        try {
            return cardDao.selectMoney(username);
        }catch (Exception e) {
            e.printStackTrace();
        }
        return -1;
    }
    public int charge(String username,double money){
        try {
            return cardDao.charge(username, cardDao.selectMoney(username)+money);
        }catch (Exception e) {
            e.printStackTrace();
        }
        return 0;
    }
}

配置文件（properties）

jdbc.dirver = com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=utf8&useSSL=false&serverTimezone=GMT%2B8
jdbc.username=root
jdbc.password=1

User类

package com.cqust.entity;

import org.springframework.stereotype.Component;

@Component
public class User {
    private String username;
    private double money;
    public User(String username, double money) {
        this.username = username;
        this.money = money;
    }
    public String getUsername() {return username;}
    public double getMoney() {
        return money;
    }
    public void setUsername(String username) {
        this.username = username;
    }
    public void setMoney(double money) {
        this.money = money;
    }
    @Override
    public String toString() {
        return "User{" +
                "username='" + username + '\'' +
                ", money=" + money +
                '}';
    }
}

CardDao类

package com.cqust.dao;

import com.cqust.entity.User;
import com.mchange.v2.c3p0.ComboPooledDataSource;
import org.springframework.stereotype.Repository;

import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;

@Repository("cardDao")
public class CardDao {
    private ComboPooledDataSource dataSource;
    public CardDao(ComboPooledDataSource dataSource) {
        this.dataSource = dataSource;
    }
    public int insert(User p) throws Exception {
        // 获取数据库连接并预编译 sql 语句
        PreparedStatement ps = dataSource.getConnection().prepareStatement("insert into user(username,money)values(?,?)");
        // 设置？的值
        ps.setString(1,p.getUsername());
        ps.setDouble(2,p.getMoney());
        // 执行并返回结果
        return ps.executeUpdate(); // 省略关闭资源
    }
    public double selectMoney(String username) throws SQLException {
        PreparedStatement ps = dataSource.getConnection().prepareStatement("select money from user where username=?");
        ps.setString(1,username);
        ResultSet rs= ps.executeQuery();
        while(rs.next()){
            return rs.getDouble("money");
        }
        return -1;
    }
    public int charge(String username,double money) throws SQLException {
        PreparedStatement ps = dataSource.getConnection().prepareStatement("update user set money = ? where username = ? ");
        ps.setDouble(1,money);
        ps.setString(2,username);
        return ps.executeUpdate();
    }
}

CardBiz类

package com.cqust.biz;

import com.cqust.dao.CardDao;
import com.cqust.entity.User;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service("cardBiz") // 注册 bean
public class CardBiz {
    // 使用注解自动注入并指定注入的 bean 的 id
    @Autowired
    private CardDao cardDao;
    public int save(User user) {
        try {
            // 执行 dao 中的方法并返回结果
            return cardDao.insert(user);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return 0;
    }
    public double selectMoney(String username){
        try {
            return cardDao.selectMoney(username);
        }catch (Exception e) {
            e.printStackTrace();
        }
        return -1;
    }
    public int charge(String username,double money){
        try {
            return cardDao.charge(username, cardDao.selectMoney(username)+money);
        }catch (Exception e) {
            e.printStackTrace();
        }
        return 0;
    }
}

CardController类

package com.cqust.controller;

import com.cqust.biz.CardBiz;
import com.cqust.entity.User;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;

@Controller
public class CardController {
    @Autowired
    private CardBiz cardBiz;
    public void save(User user){
        double money=cardBiz.selectMoney(user.getUsername());
        int rs=0;
        if(money==-1){
            rs=cardBiz.save(user);
        }
        if (rs==0){
            System.out.println("保存失败，该用户已存在！");
        }else{
            System.out.println("保存成功");
        }
    }
    public double show(User user){
        Double money=cardBiz.selectMoney(user.getUsername());
        if (money==null){
            System.out.println("该用户不存在！");
            return 0.0;
        }
        return money;
    }
    public void charge(User user,Double money){
        int rs=cardBiz.charge(user.getUsername(),money+ user.getMoney());
        if(rs==0){
            System.out.println("该用户不存在！");
        }else{
            System.out.println("充值成功！");
        }
    }
}

测试文件（Test3）

import com.cqust.controller.CardController;
import com.cqust.dao.DataSource;
import com.cqust.entity.User;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class Test3 {
    public static void main(String[] args) {
        //获取核心容器(IoC)对象 需要引用DataSource类
        ApplicationContext anno = new
                AnnotationConfigApplicationContext(DataSource.class);
        // 根据 bean 的 id 获取对象
        CardController cardController = anno.getBean("cardController", CardController.class);
        // 执行方法
        User user = anno.getBean("user",User.class);
        user.setUsername("Hades");
        user.setMoney(4.50);
        System.out.println(user);
        cardController.save(user);
        cardController.show(user);
        cardController.charge(user,888.88);
    }
}

实验四

Bean的装配方式：
&Bean的装配可以理解为依赖关系注入，Bean的装配方式即Bean的依赖注入的方式。

Spring容器支持多种形式的Bean的装配方式，如基于XML的装配、基于注解的装配、自动装配等。其中最常用的是基于注解的装配。

一、基于XML的装配
Spring提供了两种基于XML的装配方式：设值（setter）注入、构造注入

Spring实例化Bean的过程中，Spring首先会调用Bean的默认构造方法来实例化Bean对象，然后通过反射的方式调用setter方法来注入属性值。

设值（setter）注入：

  • Bean类必须提供一个默认的无参构造方法
  • Bean类必须为需要注入的属性提供对应的setter方法
  • 在配置文件中，需要使用 元素为每个属性注入值

构造注入：

  • Bean类必须提供有参构造方法
  • 在配置文件中，需要使用元素来定义构造方法的参数，也可以使用其value属性来设置该参数的值

二、基于注解的装配
Spring中定义了一系列的注解，常用的注解如下：

  • @Component：描述Spring中的Bean，可以作用在任何层次

  • @Repository：用于将持久层（Dao层）的类标识为Spring中的Bean

  • @Service：用于将业务层（Service层）的类标识为Spring中的Bean

  • @Controller：用于将控制层（Controller层）的类标识为Spring中的Bean

  • @Autowired：用于对Bean的属性变量、属性的setter方法以及构造方法进行标注，配合对应的注解处理器完成Bean的自动装配工作。默认按照Bean的类型进行装配

  • @Resource：其作用与@Autowired一样。其区别在于@Autowired默认Bean的类型装配，而@Resource默认按照Bean的实例名称进行装配

@Resource中有两个重要属性：name和type。Spring将name属性解析为Bean实例名称，type属性解析为Bean实例类型。如果指定name属性，则按实例名称进行装配；如果指定type属性，则按Bean类型进行装配；如果都不指定，则先按Bean的实例名称装配，如果不能匹配，再按照Bean类型进行装配；如果都无法匹配，则抛出 NoSuchBeanDefinitionException异常。

  • @Qualifier：与@Autowired注解配合使用，会将默认的按Bean类型装配修改为Bean的实例名称装配，Bean的实例名称由 @Qualifier注解的参数指定

此时，在配置文件中，Spring注解提供了另外一种高效的注解配置方式。
含义是：告知Spring在创建容器时要扫描的包（通知Spring扫描指定包下的所有Bean）

<context:component-scan base-package="cn.itcast"></context:component-scan>

三、自动装配
自动装配：将一个Bean自动地注入到其他Bean的Property中。

Spring的<bean>元素中包含一个 autowire 属性，我们可以通过设置 autowire 的属性值来自动装配Bean。

autowire属性的5个值：

  • default（默认）：由的default-autowire属性值来确定。
  • byName：根据属性的名称自动装配。容器将根据名称查找与属性完全一致的Bean，并将其属性自动装配
  • byType：根据属性的数据类型自动装配。
  • constructor：根据构造函数参数的数据类型，进行byType模式的自动装配
  • no：在默认情况下，不使用自动装配，Bean依赖必须通过ref元素定义

写作时间比较仓促且水平有限，可能导致文中很多地方写的比较简略，没有写太多的注释，部分代码请读者根据自己的电脑设置更改配置，也可能还存在大量的错误，欢迎广大猿友不吝指正！

谢谢浏览！

基础较差的cs菜鸟
关注
  • 5
    点赞
  • 踩
  • 13
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
[JAVAEE] 实验03：Spring Bean的配置、实例化、作用域、生命周期与装配方式
Topus的博客
03-15 948
【一】实验目的： （1）掌握Bean的实例化 （2）掌握Bean的装配方式 （3）掌握Bean的作用域和生命周期 【二】结构： 1️⃣配置（不具体介绍） 2️⃣实例化：构造方法实例化（最常用）、静态工厂实例化、实例工厂实例化 3️⃣作用域 4️⃣生命周期 5️⃣装配方式 【三】实验代码： ##一、实例化 BeanClass.java package instance; //一、bean的构造方法...
SpringBean（配置、实例化、作用域、生命周期、装配方式）
weixin_51423778的博客
09-15 549
SpringBean（配置、实例化、作用域、生命周期、装配方式）
02、Spring中的Bean实例化、作用域、生命周期及装配方式介绍
执手天涯@的博客
11-21 846
简介：本笔记主要介绍以下几点1、Bean的常见属性及其子元素2、实例化Bean的三种方式3、Bean的生命周期和作用域4、Bean的三种装配方式。
Spring中的Bean——配置、实例化、生命周期、装配方式
qq_44871613的博客
12-01 347
Bean的配置 通常一个普通的Bean只需要定义id(或者name)和class两个属性就可以了 Bean的实例化 1.构造器实例化（最常用的方式） <!-- 通过构造器实例化——默认的无参构造方法来实例化Bean --> <bean id="bean1" class="com.daier.instance.constructor.Bean1"/> 2.静态工厂方式实例化 <bean id="bean2" class="com.daier.instance...
spring bean的实例化与xml装配
shroud666的博客
03-12 431
实验训练内容（包括实验原理和操作步骤）： 1定义一个学生类Student，在类中定义(id,name,required(必修课，用list实现)，选修课（用map实现，可以录入专业选修，公共选修课）。 请用静态工厂实例化、设置注入完成对Student实例的装配。 请用实例工厂实例化，p命名空间注入完成对Student实例的装配。 实验源码：Student.ja...
Spring装配bean方法实例总结
08-19
在Spring框架中，XML配置是最早的一种配置方式，通过在XML文件中定义bean，然后在Java类中使用依赖注入的方式来实例化bean。这种方式已经逐渐被Java配置所取代，但是在一些老项目中仍然可以看到这种配置方式。 二、...
Spring bean对象实例化实现过程图解
08-18
在 Spring 框架中，Bean 对象实例化是一个非常重要的过程，本文将详细介绍 Spring Bean 对象实例化实现过程图解，通过示例代码介绍了 Bean 对象实例化的整个过程，对大家的学习或者工作具有一定的参考学习价值。...
JSP Spring 自动化装配Bean实例详解
10-20
主要介绍了JSP Spring 自动化装配Bean实例详解的相关资料,需要的朋友可以参考下
spring装配bean实例代码
07-23
在Spring框架中，Bean装配是核心功能之一，它负责初始化、配置和管理应用程序中的对象。本文将深入探讨Spring装配Bean的实例代码，帮助你更好地理解这一关键概念。 首先，Spring装配Bean主要有两种方式：XML配置和...
Java开发学习(四)----bean的三种实例化方式
10-10 1077
需要注意的一点是，构造方法在类中默认会提供，但是如果重写了构造方法，默认的就会消失，在使用的过程中需要注意，如果需要重写构造方法，最好把默认的构造方法也重写下。看到这，可能有人会问了，你这种方式在工厂类中不也是直接new对象的，和我自己直接new没什么太大的区别，而且静态工厂的方式反而更复杂，这种方式的意义是什么?方法三:没有被重写，因为它已经给了默认值，从方法名中可以看出其作用是设置对象是否为单例，默认true，从意思上来看，我们猜想默认应该是单例，如何来验证呢?这也是我们以后比较常用的一种方式。
Bean的配置以及实例化
qq_56444564的博客
03-05 126
Spring容器支持XML和Properties两种格式的配置文件，在实际开发中，最常用的是XML格式的配置文件。XML是标准的数据传输和存储格式，方便查看和操作数据。在Spring中，XML配置文件的根元素是,元素包含子元素，每个子元素可以定义一个Bean，通过元素将Bean注册到Spring容器中。熟悉Spring构造方法实例化，能够通过构造方法实例化Bean。
装配Bean基于XML（实例化方式）
weixin_42310216的博客
07-11 126
前言 3种bean实例化方法：默认构造、静态工厂、实例工厂 一、默认构造 <bean id="" class=""> //必须提供默认构造 二、静态工厂 2.1工厂 2.2spring配置 3.3目标类 3.4测试 三、实例工厂 实例工厂：必须先有工厂实例对象，通过实例对象创建对象。提供所有的方法都是“非静态”的。 ...
Spring - Spring一个Bean装配过程以及Bean实例化过程
迦南的专栏
02-23 951
主要流程： 1、读取配置文件 2、实例化bean和填充bean属性 这个粗略的流程感觉更像是一个需求，有了这个需求，那么spring内部是怎么处理的呢？ 我们知道spring的两个核心接口BeanFactory和ApplicationContext。BeanFactory主要定义容器的核心方法，ApplicationContext加以扩展，主要使用的还是ApplicationContext。在ApplicationContext的子类中，AbstractApplicationContext中的ref
Bean的作用域Scope
mmmmmlj的博客
09-17 143
在Spring中，bean作用域用于确定哪种类型的bean实例应该从Spring容器中返回给调用者。 目前Spring Bean的作用域或者说范围主要有五种。 作用域 描述 singleton 在spring IoC容器仅存在一个Bean实例，Bean以单例方式存在，bean作用域范围的默认值。 prototype 每次从容器中调用Bean时，都返回一个新的实例，即每次调用getBean()时，相当于执行newXxxBean()。 request 每次HTTP请求都会创建一个新的Be
maven项目源码下载
weixin_43172032的博客
08-24 414
在pom.xml同级目录下执行如下命令： mvn dependency:resolve -Dclassifier=sources $ mvn dependency:resolve -Dclassifier=sources [INFO] Scanning for projects... [INFO] [INFO] -------------------------< cchen:spark_learn >-------------------------- [INFO] Building sp
Bean的装配方式
乐以风的博客
11-04 652
文章目录1. 基于XML配置的装配2.基于注解的装配     bean的装配方式可以理解为将bean依赖注入到Spring容器中。Spring容器支持基于XML配置的装配、基于注解的装配和自动装配等。最常用的是基于注解的装配。 1. 基于XML配置的装配     Spring提供了两种基于XML配置的装配方式，即使用构...
4.Bean的装配方式
一介书生
01-27 600
1.Bean的生命周期 Spring容器可以管理singleton作用域的Bean的生命周期，在此作用域下，Spring能够精确地知道该Bean何时被创建， 何时初始化完成 以及何时被销毁。对于prototype作用域的Bean，Spring只负责创建，当容器他好地Bean实例后，Bean的实例就交给客户端代码来管理，Spring容器将不再跟踪生命周期。每次客户端请求prototype作用域的Be...
JavaEE笔记（三）：Bean的装配方式
饮tom的博客
11-10 565
JavaEE笔记（三）：Bean的装配方式 Bean 的装配可以理解为依赖关系注入， Bean 的装配方式即 Bean 依赖注入的方式 Bean的三种装配方式 基于 XML 的装配 设值注入( Setter Injection ) 构造注入( Constructor Injection ) 基于注解( Annotation )的装配 自动装配 基于 XML 的装配方式：<...
Java bean配置，bean的实例化和生命周期
weixin_46140377的博客
05-02 1048
Java bean配置，bean的实例化和生命周期
springbean实例化
最新发布
06-14
Spring中的Bean是指由Spring容器管理的对象。Spring容器在启动时会根据配置文件或注解扫描机制自动实例化Bean，并将它们装配到相应的组件中。Bean的实例化流程如下： 1. 根据配置文件或注解扫描机制找到Bean的定义。 2. 实例化Bean对象，可以通过构造函数或工厂方法进行实例化。 3. 设置Bean对象的属性，可以通过setter方法或注解进行属性注入。 4. 如果Bean实现了BeanNameAware、BeanFactoryAware、ApplicationContextAware等Aware接口，Spring会自动将相应的资源注入到Bean中。 5. 如果Bean实现了InitializingBean接口，Spring会在Bean初始化完成后自动调用其afterPropertiesSet方法。 6. 如果Bean配置了init-method属性，Spring会在Bean初始化完成后调用指定的初始化方法。 7. 如果Bean实现了DisposableBean接口，Spring会在Bean销毁前自动调用其destroy方法。 8. 如果Bean配置了destroy-method属性，Spring会在Bean销毁前调用指定的销毁方法。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值