菜鸟的成长之路——bean的生命周期

最新推荐文章于 2023-12-12 17:32:56 发布
最新推荐文章于 2023-12-12 17:32:56 发布
阅读量994 收藏
点赞数
分类专栏： spring 文章标签： spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/madman_donghui/article/details/79252740
版权

  所有的事物，都会有自己的生老病死，包括我们的程序的组件也有自己的生命周期，比如web中的servlet，spring的bean也不例外。bean生命周期由多个特定的生命阶段组成，每个生命阶段都留出了一扇门，来供外界对bean施加控制。这节课我们分别对BeanFactory和ApplicationContext中的bean的生命周期来进行解析。

1、BeanFactory中bean什么时候被实例的？

  为了研究这个问题，我们要是用一个带有构造方法的People类，并将类配置成bean。
People.java

package com.spring.test;

public class People{
    private String name;
    private int age;
    public People() {
        // TODO Auto-generated constructor stub
        System.out.println("people类的构造方法");
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        System.out.println("people类中设置name值");
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }


}

applicationContext.xml

    <bean id="people" class="com.spring.test.People">
        <property name="name" value="wangdonghui"></property>
        <property name="age" value="18"></property>
    </bean>

  在测试类SpringTest.java中实例出BeanFactory，代码如下：

    Resource resource = new ClassPathResource("applicationContext.xml");
        BeanFactory bf = new XmlBeanFactory(resource);

  我们发现控制台什么都没有打印，也就证明People没有走构造方法，也就是没有被实例，我们接着在SpringTest.java中写代码：

People people = (People) bf.getBean("people");

  发现控制台打印了如下信息

people类的构造方法
people类中设置name值

  由此可以证明，对于BeanFactory而言，当其调用getBean方法时，响应的bean才会被实例并赋值。

2、ApplicationContext中bean什么时候被实例的？

  结合上个问题的研究思路，我们继续用一个带有构造方法的People类，并将类配置成bean，步骤和上面的问题相同。
  接下来我们从SpringTest.java中使用应用上下文获取bean，首先我们将上下文实例出来，代码如下：

ApplicationContext content = new ClassPathXmlApplicationContext("applicationContext.xml");

控制台打印如下：

people类的构造方法
people类中设置name值

  由此可以证明，应用上下文实例的时候，bean就已经被创建并且赋值成功了。

3、BeanFactory如何进行bean生命周期的扩展的？

  第一个问题研究得出的结论，BeanFactory调用getBean方法后，bean开始实例。我们研究BeanFactory中bean的生命周期也就是从getBean方法调用之后开始。
  我们先看一下bean在BeanFactory中生命周期流程图。
这里写图片描述

  猛地一看这个流程图，我们都处于非常懵的状态，不要急，我们一点一点来分解这张图。从这张图中，可以分出三部分的内容

  • bean级别的扩展：准确的不能称为扩展了，就是bean类中自己的方法的调用，例如上面提到的构造方法的执行和setter方法的执行。
  • bean接口级别的扩展：这个扩展不仅仅是我们创建的bean类了，而是需要我们的bean实现特定的接口，接口中提供了方法，我们可以直接重写接口的方法，然后达到扩展bean生命周期的目的。接口级别的扩展是针对某个类型的bean进行扩展。
  • 容器级别的扩展：上面两种扩展都不离开bean，而容器级别的扩展和bean没有关系，他对所有的bean都进行生命周期的扩展，我们称这个容器为“后处理器”
      我们接下来就对这三种扩展方式进行详解。

4、哪些流程属于bean级别的扩展呢？

  流程图中，蓝色的部分都属于bean级别的扩展，我们可以做出验证，代码如下：

People.java

package com.spring.test;

public class People{
    private String name;
    private int age;
    public People() {
        // TODO Auto-generated constructor stub
        System.out.println("实例化（构造函数）");
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        System.out.println("设置属性值（setter方法）");
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        System.out.println("设置属性值（setter方法）");
        this.age = age;
    }
    public void init() {
        System.out.println("init-method属性指定的方法");
    }
}

applicationContext.xml

    <bean id="people" class="com.spring.test.People" init-method="init">
        <property name="name" value="wangdonghui"></property>
        <property name="age" value="18"></property>
    </bean>

SpringTest.java

import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.xml.XmlBeanFactory;
import org.springframework.core.io.ClassPathResource;
import org.springframework.core.io.Resource;

import com.spring.test.People;

public class SpringTest{
    public static void main(String[] args) {
        Resource resource = new ClassPathResource("applicationContext.xml");
        BeanFactory bf = new XmlBeanFactory(resource);
        People people = (People) bf.getBean("people");
    }
}

控制台打印

实例化（构造函数）
设置属性值（setter方法）
设置属性值（setter方法）
init-method属性指定的方法

  这样我们就验证了bean级别的三个步骤没有问题。接下来，我们在当前基础上继续研究接口级别的扩展。

5、哪些流程属于bean接口级别的扩展呢？

  第3问流程图中红色部分属于属于bean接口级别的扩展，分别有接口BeanNameAware、BeanFactoryAware以及InitializingBean三个接口，我们让People类实现这些接口，并且重写这三个接口的方法。
People.java

package com.spring.test;

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.BeanFactoryAware;
import org.springframework.beans.factory.BeanNameAware;
import org.springframework.beans.factory.InitializingBean;

public class People implements BeanNameAware,BeanFactoryAware,InitializingBean{
    private String name;
    private int age;
    public People() {
        // TODO Auto-generated constructor stub
        System.out.println("people类的构造方法");
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        System.out.println("people类的setter方法");
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        System.out.println("people类的setter方法");
        this.age = age;
    }
    public void init() {
        System.out.println("people类的init方法");
    }
    public void afterPropertiesSet() throws Exception {
        // TODO Auto-generated method stub
        System.out.println("InitializingBean的afterPropertiesSet()方法");

    }
    public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
        // TODO Auto-generated method stub
        System.out.println("BeanFactoryAware的setBeanFactory()方法");
    }
    public void setBeanName(String name) {
        // TODO Auto-generated method stub
        System.out.println("BeanNameAware的setBeanName()方法");
    }

}

applicationContext.xml

    <bean id="people" class="com.spring.test.People" init-method="init">
        <property name="name" value="wangdonghui"></property>
        <property name="age" value="18"></property>
    </bean>

SpringTest.java

import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.xml.XmlBeanFactory;
import org.springframework.core.io.ClassPathResource;
import org.springframework.core.io.Resource;

import com.spring.test.People;

public class SpringTest{
    public static void main(String[] args) {
        Resource resource = new ClassPathResource("applicationContext.xml");
        BeanFactory bf = new XmlBeanFactory(resource);
        People people = (People) bf.getBean("people");
    }
}

控制台打印

people类的构造方法
people类的setter方法
people类的setter方法
BeanNameAware的setBeanName()方法
BeanFactoryAware的setBeanFactory()方法
InitializingBean的afterPropertiesSet()方法
people类的init方法

  这个结果，恰好符合我们第3问中的流程图顺序，下面我们继续对容器级别的扩展进行研究。

6、哪些流程属于容器级别的扩展呢？

  图中绿色的都属于容器级别的扩展，可以看出，所有的容器级别扩展都出自类InstantiationAwareBeanPostProcessor和BeanPostProcess。
  我们开始提到过了，我们通常称这两个类为“后处理器”。对于这两个处理器接口，我们不能直接让People类直接去实现，不然的话，和bean接口级别扩展还有什么区别呢？当然，你实现了也不会达到我们要的扩展的效果。
  我们应该使用一个新的bean去实现后处理器的接口，然后把处理器注册到BeanFactory中,因为两种后处理器，所以有两个实现类。这样，我们就可以使用后处理器实现类扩展BeanFactory中所有的bean了。代码如下：
People.java

package com.spring.test;

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.BeanFactoryAware;
import org.springframework.beans.factory.BeanNameAware;
import org.springframework.beans.factory.InitializingBean;

public class People implements BeanNameAware,BeanFactoryAware,InitializingBean{
    private String name;
    private int age;
    public People() {
        // TODO Auto-generated constructor stub
        System.out.println("people类的构造方法");
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        System.out.println("people类的setter方法");
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        System.out.println("people类的setter方法");
        this.age = age;
    }
    public void init() {
        System.out.println("people类的init方法");
    }
    public void afterPropertiesSet() throws Exception {
        // TODO Auto-generated method stub
        System.out.println("InitializingBean的afterPropertiesSet()方法");

    }
    public void setBeanFactory(BeanFactory beanFactory) throws BeansException {
        // TODO Auto-generated method stub
        System.out.println("BeanFactoryAware的setBeanFactory()方法");
    }
    public void setBeanName(String name) {
        // TODO Auto-generated method stub
        System.out.println("BeanNameAware的setBeanName()方法");
    }

}

MyInstantiationAwareBeanPostProcessor.java

package com.spring.test;

import java.beans.PropertyDescriptor;

import org.springframework.beans.BeansException;
import org.springframework.beans.PropertyValues;
import org.springframework.beans.factory.config.InstantiationAwareBeanPostProcessorAdapter;

public class MyInstantiationAwareBeanPostProcessor extends InstantiationAwareBeanPostProcessorAdapter {

    @Override
    public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) throws BeansException {
        // TODO Auto-generated method stub
        System.out.println("InstantiationAwareBeanPostProcessor的postProcessBeforeInstantiation()方法");
        return super.postProcessBeforeInstantiation(beanClass, beanName);
    }

    @Override
    public boolean postProcessAfterInstantiation(Object bean, String beanName) throws BeansException {
        // TODO Auto-generated method stub
        System.out.println("InstantiationAwareBeanPostProcessor的postProcessAfterInstantiation()方法");
        return super.postProcessAfterInstantiation(bean, beanName);
    }

    @Override
    public PropertyValues postProcessPropertyValues(PropertyValues pvs, PropertyDescriptor[] pds, Object bean,
            String beanName) throws BeansException {
        // TODO Auto-generated method stub
        System.out.println("InstantiationAwareBeanPostProcessor的postProcessPropertyValues()方法");
        return super.postProcessPropertyValues(pvs, pds, bean, beanName);
    }
}

MyBeanPostProcess.java

package com.spring.test;

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.BeanPostProcessor;

public class MyBeanPostProcess implements BeanPostProcessor {

    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        // TODO Auto-generated method stub
        System.out.println("BeanPostProcessor的postProcessBeforeInitialization()方法");
        return bean;
    }

    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        // TODO Auto-generated method stub
        System.out.println("BeanPostProcessor的postProcessAfterInitialization()方法");
        return bean;
    }

}

applicationContext.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
    xmlns:p="http://www.springframework.org/schema/p"
    xmlns:aop="http://www.springframework.org/schema/aop"
    xmlns:tx="http://www.springframework.org/schema/tx"
    xmlns:context="http://www.springframework.org/schema/context"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context 
        http://www.springframework.org/schema/context/spring-context-4.3.xsd
        http://www.springframework.org/schema/tx
        http://www.springframework.org/schema/tx/spring-tx.xsd
        http://www.springframework.org/schema/aop
        http://www.springframework.org/schema/aop/spring-aop-4.3.xsd">

    <bean id="people" class="com.spring.test.People" init-method="init">
        <property name="name" value="wangdonghui"></property>
        <property name="age" value="18"></property>
    </bean>
    <bean id="myInstantiationAwareBeanPostProcessor" class="com.spring.test.MyInstantiationAwareBeanPostProcessor"></bean>
    <bean id="myBeanPostProcess" class="com.spring.test.MyBeanPostProcess"></bean>

</beans>

SpringTest.java

import org.springframework.beans.factory.BeanFactory;
import org.springframework.beans.factory.config.ConfigurableBeanFactory;
import org.springframework.beans.factory.xml.XmlBeanFactory;
import org.springframework.core.io.ClassPathResource;
import org.springframework.core.io.Resource;

import com.spring.test.MyBeanPostProcess;
import com.spring.test.MyInstantiationAwareBeanPostProcessor;
import com.spring.test.People;

public class SpringTest{
    public static void main(String[] args) {
        Resource resource = new ClassPathResource("applicationContext.xml");
        BeanFactory bf = new XmlBeanFactory(resource);
//      两个后处理器实现类的创建
        MyInstantiationAwareBeanPostProcessor myInstantiationAwareBeanPostProcessor = (MyInstantiationAwareBeanPostProcessor) bf.getBean("myInstantiationAwareBeanPostProcessor");
        MyBeanPostProcess myBeanPostProcess = (MyBeanPostProcess) bf.getBean("myBeanPostProcess");
//      BeanFactory注册两个后处理器
        ((ConfigurableBeanFactory)bf).addBeanPostProcessor(myInstantiationAwareBeanPostProcessor);
        ((ConfigurableBeanFactory)bf).addBeanPostProcessor(myBeanPostProcess);
        People people = (People) bf.getBean("people");
    }
}

控制台打印

InstantiationAwareBeanPostProcessor的postProcessBeforeInstantiation()方法
people类的构造方法
InstantiationAwareBeanPostProcessor的postProcessAfterInstantiation()方法
InstantiationAwareBeanPostProcessor的postProcessPropertyValues()方法
people类的setter方法
people类的setter方法
BeanNameAware的setBeanName()方法
BeanFactoryAware的setBeanFactory()方法
BeanPostProcessor的postProcessBeforeInitialization()方法
InitializingBean的afterPropertiesSet()方法
people类的init方法
BeanPostProcessor的postProcessAfterInitialization()方法

  上面代码的打印结果，和我们讨论的流程同一致。
  但是值得注意的两个地方，对于MyInstantiationAwareBeanPostProcessor实现类并不是直接实现的InstantiationAwareBeanPostProcessor接口，而是继承了这个接口的适配器InstantiationAwareBeanPostProcessorAdapter。
  再一个，就是MyBeanPostProcess后处理器的两个方法返回值必须将参数bean返回过来，不然会有异常抛出，造成bean的丢失。
  致此，我们对bean在BeanFactory中的声生命周期探讨完成。
6、bean在ApplicationContext中的生命周期是什么样的呢？

  我们在第2问中已经研究过bean在ApplicationContext中被创建的时间，我们对照bean在BeanFactory中的生命周期，看看ApplicationContext中有哪些不同吧！
  参考上问的代码，除了SpringTest.java其余的都不改变。我们将SpringTest.java中的代码如下：
SpringTest.java

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

public class SpringTest{
    public static void main(String[] args) {
        ApplicationContext content = new ClassPathXmlApplicationContext("applicationcontext.xml");
    }
}

控制台打印

InstantiationAwareBeanPostProcessor的postProcessBeforeInstantiation()方法
people类的构造方法
InstantiationAwareBeanPostProcessor的postProcessAfterInstantiation()方法
InstantiationAwareBeanPostProcessor的postProcessPropertyValues()方法
people类的setter方法
people类的setter方法
BeanNameAware的setBeanName()方法
BeanFactoryAware的setBeanFactory()方法
BeanPostProcessor的postProcessBeforeInitialization()方法
InitializingBean的afterPropertiesSet()方法
people类的init方法
BeanPostProcessor的postProcessAfterInitialization()方法

  从上面的打印结果我们可以得出如下结论：
    applicationContext实例的时候所有的bean都会创建。
    applicationContext会自动注册后处理器，不需要手动注册。
    除了上述两点，其余的生命周期和BeanFactory大致相同。（还有不同点，本博客没有体现）

菜鸟学习Spring——初识Spring
空空行者
09-27 3882
一、概念。         Spring是一个开源框架，Spring是于2003 年兴起的一个轻量级的Java 开发框架，由Rod Johnson 在其著作Expert One-On-One J2EE Development and Design中阐述的部分理念和原型衍生而来。它是为了解决企业应用开发的复杂性而创建的。Spring使用基本的JavaBean来完成以前只可能由EJB完成的事情。
ym——Andorid-15k+的面试题。
热门推荐
陈宇明
08-07 2万+
最近才开的博客，希望大家多多关注，andorid开发也做了3年有余了，也面试很多加企业，借此机会分享一下，我们中遇到过的问题以及解决方案吧，希望能够对正在找工作的andoird程序员有一定的帮助。学完本人博客发表《ym--andorid从零开始教程》+面试题目全理解，年薪18w以上绝对没问题。 特别献上整理过的50道面试题目 1.listView的优化方式 重用conve
nfvo通过调用哪个接口实现对vnf生命周期的管理_Spring Bean 生命周期 （实例结合源码彻底讲透）...
weixin_39654465的博客
11-26 170
前言本篇文章主要是要介绍如何在Spring IoC 容器中 如何管理Spring Bean生命周期。在应用开发中，常常需要执行一些特定的初始化工作，这些工作都是相对比较固定的，比如建立数据库连接，打开网络连接等，同时，在结束服务时，也有一些相对固定的销毁工作需要执行。为了便于这些工作的设计，Spring IoC容器提供了相关的功能，可以让应用定制Bean的初始化和销毁过程。Spring Bean ...
Bean 的生命周期（Bean的实例化过程）
dl674756321的博客
09-10 274
Bean 的生命周期（Bean的实例化过程） 通过构造方法实例化 Bean 对象，并利用 set 方法设置对象属性。 如果 Bean 实现了接口 BeanNameAware 的 setBeanName 方法，它就会调用这个方法，传入Bean的名字。 如果 Bean 实现了接口 BeanFactoryAware 的 setBeanFactory 方法，它就会调用这个方法，传入BeanFactory对象的实例。 与前面类似，只要 bean 调用了以 Aware 结尾的接口，都会调用它的方法。 如果 Bean
Spring系列（三）之Bean的生命周期以及Bean的单例与多例模式
lijie1025的博客
08-18 1469
Spring中Bean的生命周期以及Bean的单例与多例模式
spring中的JavaBean的生命周期
03-16 414
Bean的生命周期： 1，实例化bean 2，设置javaBean的属性值 3，若该bean实现了BeanNameAware接口，则调用该接口的setBeanName()方法 4，若该bean实现了BeanFactoryAware接口，则调用该接口的setBeanFactory()方法 5, 若spin...
JAVA面试题：Spring中bean的生命周期
weixin_34174105的博客
07-16 1万+
Spring 中bean 的生命周期短暂吗? 在spring中，从BeanFactory或ApplicationContext取得的实例为Singleton，也就是预设为每一个Bean的别名只能维持一个实例，而不是每次都产生一个新的对象使用Singleton模式产生单一实例，对单线程的程序说并不会有什么问题，但对于多线程的程序，就必须注意安全(Thread-safe)的议题，防止多个线程同时存取...
菜鸟之路——Spring MVC（三）DispatcherServlet详解
sjjsh2的博客
11-06 7895
前言：回顾一下Spring的启动过程： 1、首先，对于一个web应用，其部署在web容器中，web容器提供其一个全局的上下文环境，这个上下文就是ServletContext，其为后面的spring IoC容器提供宿主环境； 2、其次，在web.xml中会提供有contextLoaderListener。在web容器启动时，会触发容器初始化事件，此时contextLoaderListene...
菜鸟之路——Spring MVC（五）ViewResolver
sjjsh2的博客
11-07 4063
在Spring MVC中，ViewResolver 用来将用户控制器生成的返回结果解析成视图，View定义了不同的视图，并渲染给用户，但是Spring是怎样工作的呢？现在我们就分析下Spring如何解析返回的结果生成响应的视图。 一、概念 View ---View接口表示一个响应给用户的视图，例如jsp文件，pdf文件，html文件等，它的定义如下 public inte...
阿里巴巴——三面，面试经历记录
bjmsb0051的博客
11-03 1644
在 boss 直聘上无意间看到了阿里巴巴菜鸟网络的招聘信息，现在的部门已经有两名同学被蚂蚁金服录取了，自己就不服气的也想试试。这次面试其实并没有准备充分。 之前就听说总共有很多轮数，不仅会考察基础知识的深度，也会考察算法能力、项目设计能力、价值观世界观等。 自己抱着能走多远走多远的态度，挑战一下自己。 在发过去简历的一周后，大概是2月28号左右，一面的小哥哥下午打来电话约我2月28号晚上9点钟面试。 结果在 2 月 29 白天的时候，我基本上都没有怎么工作，而是把我平时积累的一些基础知识总结了一下，
Spring中Bean的生命周期详解
qq_33436031的博客
11-16 163
Spring中Bean的生命周期详解 Spring最重要的功能就是帮助程序员创建对象（也就是IOC），而启动Spring就是为创建Bean对象做准备，所以我们先明白Spring到底是怎么去创建Bean的，也就是先弄明白Bean的生命周期。 Bean的生命周期就是指：在Spring中，一个Bean是如何生成的，如何销毁的？ ...
JavaBean的生命周期
01-25 930
%@page contentType="text/html;charset=GB2312"%> public class Counter {    private int counter=0;    public String getCounter()    {       return ""+counter++    } } 1.page范围 当前计数是：
Java - Bean的生命周期
最新发布
m0_65228708的博客
12-12 428
Bean的生命周期之5步 Bean生命周期之7步 Bean生命周期之10步
Spring（三）：JavaBean的生命周期
F道人
05-15 5272
JavaBean的生命周期 一：基本概念 bean 就是由IOC 容器初始化、装配及管理的对象。 Spring中的bean默认都是单例的，那么单例Bean在多线程程序下如何保证线程安全呢？ Spring的单例是基于BeanFactory也就是Spring容器的，单例Bean在此容器内只有一个，Java的单例是基于 JVM，每个 JVM 内只有一个实例。所以非分布式服务情况下，单例Bean可以保证线程安全。 二：Bean的作用范围 创建一个bean定义，其实质是用该bean定义对应的类来创建真正实例的“配方”
【Java第35期】：Bean的生命周期
m0_62262008的博客
11-27 885
Bean不容错过的内容，一篇文章带你解读Bean的生命周期的各个阶段。关注小猪，小猪带你一起学习！！
Java spring bean 生命周期
java 学习天地
03-03 1119
Spring bean生命周期 在传统的Java应用中，Bean的生命周期非常简单。 Java的关键词new用来实例化Bean（或许他是非序列化的）。这样就够用了。 相反，Bean的生命周期在Spring容器中更加细致。 理解Spring Bean的生命周期非常重要，因为你或许要利用Spring提供的机会来订制Bean的创建过程。 1.容器寻找Bean的定义信息并且将其实例化。 2.
【java spring】bean的生命周期
yqs的博客
12-18 340
bean的生命周期如下（原文：http://c.biancheng.net/spring/bean-life-cycle.html）： 1、Spring 启动，查找并加载需要被 Spring 管理的 Bean，并实例化 Bean。 2、利用依赖注入完成 Bean 中所有属性值的配置注入。 3、如果 Bean 实现了 BeanNameAware 接口，则 Spring 调用 Bean 的 setBeanName() 方法传入当前 Bean 的 id 值。 4、如果 Bean 实现了 BeanFactoryAw
Spring中JavaBean的生命周期及模式
GitHub质检员
08-20 272
在Spring框架中，JavaBean的背景可以追溯到Java语言的发展和面向对象编程的原则。JavaBean作为一种特定的编程规范和约定，被引入到Spring框架中，以实现更加灵活和可扩展的开发方式。在Spring框架中，JavaBean是一个普通的Java类，遵循一些特定的_命名和属性规范1. 私有的成员变量：JavaBean类中的属性通常是私有的，以保护数据，同时提供公共的getter和setter方法来访问和修改属性的值。
java中 bean的生命周期
05-30
在Java中，Bean的生命周期包括以下阶段： 1. 实例化：在IoC容器启动时，根据Bean定义信息创建Bean对象，可以通过构造函数、工厂方法或者其他方式创建Bean实例。 2. 属性注入：容器通过反射机制将Bean的属性值注入...
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值