Spring、Bean 创建 和 使⽤

这篇具有很好参考价值的文章主要介绍了Spring、Bean 创建 和 使⽤。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

目录

前言

1、创建 Spring 项目

1.1、创建一个 Maven 项目

1.2、在 Maven 项目中,添加 Spring 框架支持(spring-context,spring-beans)

1.2.1添加依赖

 1.2.2 配置国内源 

1.2.3 添加maven

1.3、创建一个启动类 和 main 方法

 2、将 Bean 对象存储到容器(Spring)中

2.1  添加配置文件 【如果是第一添加Bean对象】

 2.2 创建⼀个 Bean

2.3 在配置文件中,将需要保存到 spring中的 bean 对象进行注册

3、从 Spring 中,将 Bean 对象读取出来

3.1、得到 Spring 上下文对象

3.2、通过 上下文对象提供的方法,获取 我们自己需要使用的 bean 对象

3.3、拿到 bean 对象之后,就可以调用 里面的方法。

拓展

ApplicationContext 与 BeanFactory 的区别

总结


前言

经过前面 Spring 核心 与 设计思想的学习,我们已经知道了:Spring 就是一个包含众多工具方法的 IoC 容器。
既然是容器,那额它就具有两个核心功能:

        1、将对象(Bean) 存储到容器中
        2、从容器中将对象(Bean)去出来

本文主要讲解的重点:

        1、创建项目
        2、将对象存储到 Spring
        3、从 Spring中取出对象 

1、创建 Spring 项目

接下来使用 Maven 方式 来创建一个 Spring 项目。
创建 Spring 项目 和 Servlet 相似。
总共分为以下 3 步:

1、创建一个普通 Maven 项目
其实 Spring Boot 也是基于 Maven 来实现的,只不过 Spring 需要我们自己去创建,而 Spring Boot 直接内置了。

2、在 Maven 项目中,添加 Spring 框架支持(spring-context,spring-beans)

3、创建一个启动类,并添加 main 方法。
其实第三步是一个非必要操作,但是我们后面需要去测试 Bean(对象)的存入 与 取出的。
因此,我们需要一个可以测试的类,
故:需要创建一个启动类(测试的类)和 main,而不是依靠 Tomcat 的错误提示。
如果你是创建的一个 Spring Web,或者 Spring MVC,那需要依靠Tomcat。
而我们现在创建的项目是 Spring Core 。
core 核心项目,也就是最基础的核心项目。
所以,我们不需要依靠 Tomcat,就一个类就可以了。

注意!我们现在学习的是 Spring,不是 Spring Boot。
Spring 是在 Spring Boot 之前的框架。
因此,Spring 操作起来。没有像 Spring Boot 那么方便!
难度,和 servlet 差不多。

凡事都要一个过程。
最初的框架,并没有那么好用。
总有一个发展的过程。
很显然,Spring 属于前者,Spring Boot 属于后者。
 

1.1、创建一个 Maven 项目

Spring、Bean 创建 和 使⽤

1.2、在 Maven 项目中,添加 Spring 框架支持(spring-context,spring-beans)

1.2.1添加依赖

直接复制粘贴到 pom.xml 文件中即可。

<dependencies>
   <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>5.2.3.RELEASE</version>
    </dependency>
  
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-beans</artifactId>
        <version>5.2.3.RELEASE</version>
    </dependency>
</dependencies>

Spring、Bean 创建 和 使⽤


 1.2.2 配置国内源 

另外,一定要配置 国内的源!!!!!
就算此时不出问题,以后也会出问题!

如果你还是使用默认的国外源
尤其是创建 Spring Boot 项目,引入依赖的时候,及其容易翻车!

如果你有 settings.xml 文件,就把上面框选的部分,手动拷贝进去。 

      <mirror>
        <id>alimaven</id>
        <name>aliyun maven</name>
        <url>http://maven.aliyun.com/nexus/content/groups/public/</url>
        <mirrorOf>central</mirrorOf>        
      </mirror> 

Spring、Bean 创建 和 使⽤

 如果你的文件中没有settings.xml,说明你之前没有配置过,新建文件,取名为settings.xml,然后把下面的代码复制进去

<?xml version="1.0" encoding="UTF-8"?>

<!--
Licensed to the Apache Software Foundation (ASF) under one
or more contributor license agreements.  See the NOTICE file
distributed with this work for additional information
regarding copyright ownership.  The ASF licenses this file
to you under the Apache License, Version 2.0 (the
"License"); you may not use this file except in compliance
with the License.  You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing,
software distributed under the License is distributed on an
"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
KIND, either express or implied.  See the License for the
specific language governing permissions and limitations
under the License.
-->

<!--
 | This is the configuration file for Maven. It can be specified at two levels:
 |
 |  1. User Level. This settings.xml file provides configuration for a single user,
 |                 and is normally provided in ${user.home}/.m2/settings.xml.
 |
 |                 NOTE: This location can be overridden with the CLI option:
 |
 |                 -s /path/to/user/settings.xml
 |
 |  2. Global Level. This settings.xml file provides configuration for all Maven
 |                 users on a machine (assuming they're all using the same Maven
 |                 installation). It's normally provided in
 |                 ${maven.conf}/settings.xml.
 |
 |                 NOTE: This location can be overridden with the CLI option:
 |
 |                 -gs /path/to/global/settings.xml
 |
 | The sections in this sample file are intended to give you a running start at
 | getting the most out of your Maven installation. Where appropriate, the default
 | values (values used when the setting is not specified) are provided.
 |
 |-->
<settings xmlns="http://maven.apache.org/SETTINGS/1.0.0"
          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
          xsi:schemaLocation="http://maven.apache.org/SETTINGS/1.0.0 http://maven.apache.org/xsd/settings-1.0.0.xsd">
  <!-- localRepository
   | The path to the local repository maven will use to store artifacts.
   |
   | Default: ${user.home}/.m2/repository
  <localRepository>/path/to/local/repo</localRepository>
  -->

  <!-- interactiveMode
   | This will determine whether maven prompts you when it needs input. If set to false,
   | maven will use a sensible default value, perhaps based on some other setting, for
   | the parameter in question.
   |
   | Default: true
  <interactiveMode>true</interactiveMode>
  -->

  <!-- offline
   | Determines whether maven should attempt to connect to the network when executing a build.
   | This will have an effect on artifact downloads, artifact deployment, and others.
   |
   | Default: false
  <offline>false</offline>
  -->

  <!-- pluginGroups
   | This is a list of additional group identifiers that will be searched when resolving plugins by their prefix, i.e.
   | when invoking a command line like "mvn prefix:goal". Maven will automatically add the group identifiers
   | "org.apache.maven.plugins" and "org.codehaus.mojo" if these are not already contained in the list.
   |-->
  <pluginGroups>
    <!-- pluginGroup
     | Specifies a further group identifier to use for plugin lookup.
    <pluginGroup>com.your.plugins</pluginGroup>
    -->
  </pluginGroups>

  <!-- proxies
   | This is a list of proxies which can be used on this machine to connect to the network.
   | Unless otherwise specified (by system property or command-line switch), the first proxy
   | specification in this list marked as active will be used.
   |-->
  <proxies>
    <!-- proxy
     | Specification for one proxy, to be used in connecting to the network.
     |
    <proxy>
      <id>optional</id>
      <active>true</active>
      <protocol>http</protocol>
      <username>proxyuser</username>
      <password>proxypass</password>
      <host>proxy.host.net</host>
      <port>80</port>
      <nonProxyHosts>local.net|some.host.com</nonProxyHosts>
    </proxy>
    -->
  </proxies>

  <!-- servers
   | This is a list of authentication profiles, keyed by the server-id used within the system.
   | Authentication profiles can be used whenever maven must make a connection to a remote server.
   |-->
  <servers>
    <!-- server
     | Specifies the authentication information to use when connecting to a particular server, identified by
     | a unique name within the system (referred to by the 'id' attribute below).
     |
     | NOTE: You should either specify username/password OR privateKey/passphrase, since these pairings are
     |       used together.
     |
    <server>
      <id>deploymentRepo</id>
      <username>repouser</username>
      <password>repopwd</password>
    </server>
    -->

    <!-- Another sample, using keys to authenticate.
    <server>
      <id>siteServer</id>
      <privateKey>/path/to/private/key</privateKey>
      <passphrase>optional; leave empty if not used.</passphrase>
    </server>
    -->
  </servers>

  <!-- mirrors
   | This is a list of mirrors to be used in downloading artifacts from remote repositories.
   |
   | It works like this: a POM may declare a repository to use in resolving certain artifacts.
   | However, this repository may have problems with heavy traffic at times, so people have mirrored
   | it to several places.
   |
   | That repository definition will have a unique id, so we can create a mirror reference for that
   | repository, to be used as an alternate download site. The mirror site will be the preferred
   | server for that repository.
   |-->
  <mirrors>
   <mirror>
        <id>alimaven</id>
        <name>aliyun maven</name>
        <url>http://maven.aliyun.com/nexus/content/groups/public/</url>
        <mirrorOf>central</mirrorOf>        
      </mirror>
    <!-- mirror
     | Specifies a repository mirror site to use instead of a given repository. The repository that
     | this mirror serves has an ID that matches the mirrorOf element of this mirror. IDs are used
     | for inheritance and direct lookup purposes, and must be unique across the set of mirrors.
     |
    <mirror>
      <id>mirrorId</id>
      <mirrorOf>repositoryId</mirrorOf>
      <name>Human Readable Name for this Mirror.</name>
      <url>http://my.repository.com/repo/path</url>
    </mirror>
     -->
  </mirrors>

  <!-- profiles
   | This is a list of profiles which can be activated in a variety of ways, and which can modify
   | the build process. Profiles provided in the settings.xml are intended to provide local machine-
   | specific paths and repository locations which allow the build to work in the local environment.
   |
   | For example, if you have an integration testing plugin - like cactus - that needs to know where
   | your Tomcat instance is installed, you can provide a variable here such that the variable is
   | dereferenced during the build process to configure the cactus plugin.
   |
   | As noted above, profiles can be activated in a variety of ways. One way - the activeProfiles
   | section of this document (settings.xml) - will be discussed later. Another way essentially
   | relies on the detection of a system property, either matching a particular value for the property,
   | or merely testing its existence. Profiles can also be activated by JDK version prefix, where a
   | value of '1.4' might activate a profile when the build is executed on a JDK version of '1.4.2_07'.
   | Finally, the list of active profiles can be specified directly from the command line.
   |
   | NOTE: For profiles defined in the settings.xml, you are restricted to specifying only artifact
   |       repositories, plugin repositories, and free-form properties to be used as configuration
   |       variables for plugins in the POM.
   |
   |-->
  <profiles>
    <!-- profile
     | Specifies a set of introductions to the build process, to be activated using one or more of the
     | mechanisms described above. For inheritance purposes, and to activate profiles via <activatedProfiles/>
     | or the command line, profiles have to have an ID that is unique.
     |
     | An encouraged best practice for profile identification is to use a consistent naming convention
     | for profiles, such as 'env-dev', 'env-test', 'env-production', 'user-jdcasey', 'user-brett', etc.
     | This will make it more intuitive to understand what the set of introduced profiles is attempting
     | to accomplish, particularly when you only have a list of profile id's for debug.
     |
     | This profile example uses the JDK version to trigger activation, and provides a JDK-specific repo.
    <profile>
      <id>jdk-1.4</id>

      <activation>
        <jdk>1.4</jdk>
      </activation>

      <repositories>
        <repository>
          <id>jdk14</id>
          <name>Repository for JDK 1.4 builds</name>
          <url>http://www.myhost.com/maven/jdk14</url>
          <layout>default</layout>
          <snapshotPolicy>always</snapshotPolicy>
        </repository>
      </repositories>
    </profile>
    -->

    <!--
     | Here is another profile, activated by the system property 'target-env' with a value of 'dev',
     | which provides a specific path to the Tomcat instance. To use this, your plugin configuration
     | might hypothetically look like:
     |
     | ...
     | <plugin>
     |   <groupId>org.myco.myplugins</groupId>
     |   <artifactId>myplugin</artifactId>
     |
     |   <configuration>
     |     <tomcatLocation>${tomcatPath}</tomcatLocation>
     |   </configuration>
     | </plugin>
     | ...
     |
     | NOTE: If you just wanted to inject this configuration whenever someone set 'target-env' to
     |       anything, you could just leave off the <value/> inside the activation-property.
     |
    <profile>
      <id>env-dev</id>

      <activation>
        <property>
          <name>target-env</name>
          <value>dev</value>
        </property>
      </activation>

      <properties>
        <tomcatPath>/path/to/tomcat/instance</tomcatPath>
      </properties>
    </profile>
    -->
  </profiles>

  <!-- activeProfiles
   | List of profiles that are active for all builds.
   |
  <activeProfiles>
    <activeProfile>alwaysActiveProfile</activeProfile>
    <activeProfile>anotherAlwaysActiveProfile</activeProfile>
  </activeProfiles>
  -->
</settings>

配置好了,可以用 VSCode ,再来打开这个文件。
来查看一下,有没有配置的代码
有,就说明国内源,完全配置好了。


还没有完,此时我们设置的,只是针对当前项目。 还需要对之后新建的项目进行配置

Spring、Bean 创建 和 使⽤

另外,还有一个特殊的情况,在我们配置化好了之后。
仍然,下载依赖失败,或者代码运行有问题。
这是因为 你的 jar包(依赖)下载缺失,锁导致的问题。 

Spring、Bean 创建 和 使⽤

如果你还是失败,那就是你自己网络的问题了!过会再试试

1.2.3 添加maven

在pom.xml中添加以下代码

        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.3.26</version>
        </dependency>


        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-beans</artifactId>
            <version>5.2.3.RELEASE</version>
        </dependency>

Spring、Bean 创建 和 使⽤


1.3、创建一个启动类 和 main 方法

在 java目录下,创建一个 Java类。
名字随意,至于类的内容,暂时写成下方中的内容

Spring、Bean 创建 和 使⽤


 2、将 Bean 对象存储到容器(Spring)中

要实现这个目的,我们需要 两个 或 三 个 步骤。

为什么,这里要有个或呢?
换个说法:到底是2个,还是3个步骤呢?
这个是取决于 你 添加的这个 Bean 对象,是第一次添加,还是非第一次添加。

如果是 第一次添加,那么,有三个步骤:
1、在 Spring 项目中 添加配置文件【非第一次,此步骤可以省略】

2、存储 Bean 之前,先得有 Bean 才⾏,因此先要创建⼀个 Bean。

3、在配置文件中,将需要保存到 spring中的 bean 对象进行注册。 

2.1  添加配置文件 【如果是第一添加Bean对象】

和 Servlet 配置 web,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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

</beans>

将上述的 代码进行拷贝,进行如下操作。
Spring、Bean 创建 和 使⽤


 2.2 创建⼀个 Bean

所谓的 Bean 对象,其实就是 Java 中的普通类。
只不过 权限是由 spring 所持有。
Spring、Bean 创建 和 使⽤


2.3 在配置文件中,将需要保存到 spring中的 bean 对象进行注册

我们需要对 spring-config.xml 配置文件,进行如下操作。

就和我们在 pom.xml 中一样,dependency标签是具体用来引入依赖的标签,而 dependencies 就是 dependency的容器。这就不就印证了那句话: spring 是 一个 存储 loC (控制反转)的容器。其实就是存储控制反转的 对象 (Bean)

Spring、Bean 创建 和 使⽤


3、从 Spring 中,将 Bean 对象读取出来

读取操作,可分为三步:
1、先得到 spring 上下文对象

就是你要读取 Spring 里面的东西,需要先得到 Spring。
你可以这么认为:上下文对象 等价于 Spring

2、得到Spring上下文对象之后,再通过 上下文对象提供的方法,获取 我们自己需要使用的 bean 对象

3、拿到 bean 对象之后,就可以调用 里面的方法。

拿到 bean 对象之后,就可以使用 bean 对象了。


3.1、得到 Spring 上下文对象

Spring、Bean 创建 和 使⽤

3.2、通过 上下文对象提供的方法,获取 我们自己需要使用的 bean 对象

Spring、Bean 创建 和 使⽤

3.3、拿到 bean 对象之后,就可以调用 里面的方法。

此时,获取到 bean 对象,也就是 User 类的对象。
里面包含着,此次我们需要调用的 sayHi 方法。

Spring、Bean 创建 和 使⽤


 注意事项1

Spring、Bean 创建 和 使⽤

 快速锁定异常位置的技巧Ctrl + F : 搜索功能

Spring、Bean 创建 和 使⽤

注意事项2

因为 编辑器 产生运行缓存。
你的运行结果,它直接照搬 上次运行出错的状态。
我们需要做的就是:将 target 目录删除,重新执行程序即可。

Spring、Bean 创建 和 使⽤

准确来说:target目录,和 servlet 一样,就是 JVM 运行的目录。
这个目录,是自动生成的。
根据项目中的 源代码 和 资源文件,自己去生成一个 target文件的。
而且,你展开 target 目录,就会发现 和 上面的目录结构,完全是一样的。

 注意事项3

Bean 的 Id 要⼀⼀对应

Spring、Bean 创建 和 使⽤

拓展

除了 ApplicationContext 之外,我们还可以使⽤ BeanFactory 来作为 Spring 的上下文

BeanFactory -> Bean Factory(Bean对象工厂)

Spring、Bean 创建 和 使⽤

既然 BeanFactory 可以达到 ApplicationContext 相同的效果。
那么,这两者之间又有什么区别?
这可以非常经典的面试题哦!!!!!

ApplicationContext 与 BeanFactory 的区别

相同点:
        1、都提供了getBean 方法

不同点:
        1、ApplicationContext 是 BeanFactory 的子类,因此 ApplicationContext 所具有的方法,肯定是比 BeanFactory 多的。因此在 Java 中,子类继承父类,将会拥有父类的一切(子承父业),而且自己自身还自带了一些方法。两者一累加,子类 ApplicationContext 中的方法,自然也就比 父类 BanFactory 多了。BeanFactory 只提供了基础访问 Bean 的方法,而 ApplicationContext 除了拥有 BeanFactory 的所有功能之外,还提供了更多的方法实现。比如:添加了对国际化支持、资源访问支持、以及事件传播等方面的支持。

        2、性能:从性能方面来说:两者是不一样的!ApplicationContext 是一次性加载并初始化所有的 Bean 对象而 BeanFactory是需要,才去加载的(按需加载->懒加载)。因此更加轻量。这两种方式,各有优点。
        像BeanFactory,这种懒加载读取 Bean 对象的方式,是很低效的,但是对于 系统的开销是非常小的,毕竞不用一次性加载全部的 Bean 对象。之所以说:读取 Bean对象的速度很慢,是因为 第一次读取 Bean 对象的时候,是需要 将 pom.xml 中的 bean 对象存入 Spring的,然后才能从 Spring 中取出它。因此,像懒加载这种,如果使用的每个 Bean 对象,都是第一次使用,那就非常影响访问的速度。

        ApplicationContext 虽然是一次性加载并初始化所有的 Bean 对象,对于系统的开销比较大,但是后面需要用到 bean 对象的时候,直接拿,不需要在加载 Bean 对象了。获取对象 Bean 的速度,非常快!在性能这一点,大部分用户 对于 访问的速度,更加偏爱因此 ApplicationContext 的加载方式,更受人们的喜爱。毕竟现在的人,追求效率。并不会关注系统背后做了些什么。
那么,问题来了: ApplicationContext 和 BeanFactory,那一个更好呢?
这就得根据实际情况来看了。
如果是以性能至上的场景,Application首选。反之,以 稳定性 为主,BeanFactory是首选。

下面,我们来通过代码来模拟验证一下。
BeanFactory 究竟是不是 懒加载
ApplicationContext 是不是 一次性将 bean 对象,全部加载。Spring、Bean 创建 和 使⽤

 getBean 方法的更多用法

getBean() ⽅法有很多种重载⽅法,我们也可以使⽤其他⽅式来获取 Bean 对象.

这是 ApplicationContext 的所提供的 getBean 方法

Spring、Bean 创建 和 使⽤

 BeanFactory 用的还是很少的,所以,我们以 ApplicationContext 为主

 1、使用 bean id 获取 bean对象。

这个就是我们上面所使用的方法

Spring、Bean 创建 和 使⽤

 2、根据 bean 的 类型 来获取 bean对象

方法还是 getBean 方法,只是传的参数不同,
Spring、Bean 创建 和 使⽤

 3、第三种写法,属于 第一种 和 第二种 的 结合。

使用 Bean 的 id 和 对象类型(两个参数)来锁定唯一的对象(bean)。

Spring、Bean 创建 和 使⽤

 第三种写法,是最推荐的!
因为 它 最稳。

总结

本文重点有三大点:

1、操作容器之前,先要有容器,所以先要得到容器。
  1.1、创建 maven项目
  1.2、添加 Spring 框架支持,引入 spring-context 和 spring-beans 依赖
  1,3、创建一个启动类 和 main方法

2、存对象
  2.1、创建 Bean(普通类)
  2.2、将 Bean 注册(配置)到 spring-config.xml 中。【bean标签】

3、取对象
  3.1、得到 Spring 上下文对象,并读取到 Spring 的配置文。【ApplicationContext】
  3.2、获取某一个bean(对象)
  3.3、使用 Bean(对象)

操作流程图 

Spring、Bean 创建 和 使⽤文章来源地址https://www.toymoban.com/news/detail-514629.html

到了这里,关于Spring、Bean 创建 和 使⽤的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • 【Spring框架全系列】如何创建一个SpringBoot项目

    🌇哈喽,大家好,我是小浪。前几篇博客我们已经介绍了什么是Spring,以及如何创建一个Spring项目,OK,那么单单掌握Spring是完全不够的,Spring的家族体系十分强大,我们还需要深入学习,以便于我们后续达到能独立做项目的水平。今天我们来学习SpringBoot。🏜 📲目录 一、

    2024年02月03日
    浏览(46)
  • 如何使用社区版IDEA创建一个Spring Boot项目

    这篇博客,我们要教大家如何使用社区版IDEA来创建一个Spring Boot的项目。 首先我们要下载一个插件——Spring Boot Helper,只有安装了这个插件我们才能创建Spring Boot项目,如下图所示:  【注意】这个时候和平时下载插件不同,不要直接点“下载”按钮, 因为这个插件是需要

    2024年02月12日
    浏览(60)
  • Spring、Bean 创建 和 使⽤

    目录 前言 1、创建 Spring 项目 1.1、创建一个 Maven 项目 1.2、在 Maven 项目中,添加 Spring 框架支持(spring-context,spring-beans) 1.2.1添加依赖  1.2.2 配置国内源  1.2.3 添加maven 1.3、创建一个启动类 和 main 方法  2、将 Bean 对象存储到容器(Spring)中 2.1  添加配置文件 【如果是第一

    2024年02月11日
    浏览(33)
  • 源码:Spring常规Bean创建过程

    一、版本 二、学习内容 三、Bean生命周期 时间轴地址:点击 四、bean创建过程脑图总结 脑图地址:点击 五、源码过程 doGetBean() getSingleton(String beanName,ObjectFactory? singletonFactory)方法: createBean()方法: doCreateBean()方法

    2024年01月20日
    浏览(39)
  • Spring: Bean的创建原理解析

    1.读取Bean的定义信息 通过BeanDefinitionReader这个接口解析xml配置、配置类或其他的一些方式定义的类,得到BeanDefinition(Bean定义信息) 2.实例化Bean 通过BeanPostProcessor这个接口(增强器)可以对我们的BeanDefinition进行一些修改,然后BeanFactory通过反射实例化Bean对象,但是此时的

    2024年02月06日
    浏览(38)
  • Spring 创建 Bean 的三种方式

    在使用 Spring 框架后,对象以 Bean 的形式统一交给 IOC 容器去创建和管理。现阶段主流的方式是基于 SpringBoot 框架,基于注解的方式实现 Bean 的创建,但在原生 Spring 框架中其实存在三种创建 Bean 的方式。 BeanProcess 实体类,虽然加了 @Component 等三个注解,但只在注解方式创建

    2024年02月14日
    浏览(50)
  • Spring 容器原始 Bean 是如何创建的?

    以下内容基于 Spring6.0.4。 这个话题其实非常庞大,我本来想从 getBean 方法讲起,但一想这样讲完估计很多小伙伴就懵了,所以我们还是一步一步来,今天我主要是想和小伙伴们讲讲 Spring 容器创建 Bean 最最核心的 createBeanInstance 方法,这个方法专门用来创建一个原始 Bean 实例

    2024年02月14日
    浏览(34)
  • Spring-1-透彻理解Spring XML的Bean创建--IOC

    上一篇文章我们介绍了什么是Spring,以及Spring的一些核心概念,并且快速快发一个Spring项目,实现IOC和DI,今天具体来讲解IOC 能够说出IOC的基础配置和Bean作用域 了解Bean的生命周期 能够说出Bean的实例化方式 问题导入 问题1:在 bean 标签上如何配置别名? 问题2:Bean的默认作用

    2024年02月13日
    浏览(39)
  • 从 Spring 的创建到 Bean 对象的存储、读取

    目录 创建 Spring 项目: 1.创建一个 Maven 项目:  2.添加 Spring 框架支持: 3.配置资源文件: 4.添加启动类: Bean 对象的使用: 1.存储 Bean 对象: 1.1 创建 Bean: 1.2 存储 Bean 到容器内: 2.获取 Bean 对象: 2.1 创建 Spring 上下文: 2.2 获取指定 Bean 对象: ApplicationContext 和 BeanFactor

    2024年02月06日
    浏览(40)
  • 【框架源码】Spring源码解析之Bean创建源码流程

    问题:Spring中是如何初始化单例bean的? 我们都知道Spring解析xml文件描述成BeanDefinition,解析BeanDefinition最后创建Bean将Bean放入单例池中,那么Spring在创建Bean的这个过程都做了什么。 Spring核心方法refresh()中最最重要的一个方法 finishBeanFactoryInitialization() 方法,该方法负责初始化

    2024年02月09日
    浏览(39)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包