• spring成神之路第三篇：Spring容器基本使用及原理（ApplicationContext接口获取bean的4种方式）

    环境

    1. jdk1.8

    2. idea

    3. maven-3.6.1

    4. spring-5.2.3.RELEASE

    IOC容器

    IOC容器是具有依赖注入功能的容器，负责对象的实例化、对象的初始化，对象和对象之间依赖关系配置、对象的销毁、对外提供对象的查找等操作，对象的整个生命周期都是由容器来控制。我们需要使用的对象都由ioc容器进行管理，不需要我们再去手动通过new的方式去创建对象，由ioc容器直接帮我们组装好，当我们需要使用的时候直接从ioc容器中直接获取就可以了。

    那么spring ioc容器是如何知道需要管理哪些对象呢？

    需要我们给ioc容器提供一个配置清单，这个配置支持xml格式和java注解的方式，在配置文件中列出需要让ioc容器管理的对象，以及可以指定让ioc容器如何构建这些对象，当spring容器启动的时候，就会去加载这个配置文件，然后将这些对象给组装好以供外部访问者使用。

    这里所说的IOC容器也叫spring容器。

    Bean概念

    由spring容器管理的对象统称为Bean对象。Bean就是普通的java对象，和我们自己new的对象其实是一样的，只是这些对象是由spring去创建和管理的，我们需要在配置文件中告诉spring容器需要创建哪些bean对象，所以需要先在配置文件中定义好需要创建的bean对象，这些配置统称为bean定义配置元数据信息，spring容器通过读取这些bean配置元数据信息来构建和组装我们需要的对象。

    Spring容器使用步骤

    1. 引入spring相关的maven配置
    2. 创建bean配置文件，比如bean xml配置文件
    3. 在bean xml文件中定义好需要spring容器管理的bean对象
    4. 创建spring容器，并给容器指定需要装载的bean配置文件，当spring容器启动之后，会加载这些配置文件，然后创建好配置文件中定义好的bean对象，将这些对象放在容器中以供使用
    5. 通过容器提供的方法获取容器中的对象，然后使用

    Spring容器对象

    spring内部提供了很多表示spring容器的接口和对象，我们来看看比较常见的几个容器接口和具体的实现类。

    BeanFactory接口

    org.springframework.beans.factory.BeanFactory

    spring容器中具有代表性的容器就是BeanFactory接口，这个是spring容器的顶层接口，提供了容器最基本的功能。

    常用的几个方法
    //按bean的id或者别名查找容器中的bean
Object getBean(String name) throws BeansException

//这个是一个泛型方法，按照bean的id或者别名查找指定类型的bean，返回指定类型的bean对象
<T> T getBean(String name, Class<T> requiredType) throws BeansException;

//返回容器中指定类型的bean对象
<T> T getBean(Class<T> requiredType) throws BeansException;

//获取指定类型bean对象的获取器，这个方法比较特别，以后会专门来讲
<T> ObjectProvider<T> getBeanProvider(Class<T> requiredType);

    ApplicationContext接口

    org.springframework.context.ApplicationContext

    这个接口继承了BeanFactory接口，所以内部包含了BeanFactory所有的功能，并且在其上进行了扩展，增加了很多企业级功能，比如AOP、国际化、事件支持等等。

    我们知道可以通过ApplicationContext的getBean方法来获取Spring容器中已初始化的bean。getBean一共有以下四种方法原型：

    下来我们分别来探讨以上四种方式获取bean的区别。

    （1）getBean(String name)
    参数name表示IOC容器中已经实例化的bean的id或者name,且无论是id还是name都要求在IOC容器中是唯一的不能重名。那么这种方法就是通过id或name去查找获取bean.

    （2）getBean(Class type)
    参数Class type表示要加载的Bean的类型。如果该类型没有继承任何父类(Object类除外)和实现接口的话，那么要求该类型的bean在IOC容器中也必须是唯一的。比如applicationContext.xml配置两个类型完全一致的bean,且都没有配置id和name属性

    我们可以总结getBean(String name)和getBean(Class type)的异同点。
    相同点：都要求id或者name或者类型在容器中的唯一性。
    不同点：getBean(String name)获得的对象需要类型转换而getBean(Class type)获得的对象无需类型转换。

    （3）getBean(String name,Class type)
    这种方式比较适合当类型不唯一时，再通过id或者name来获取bean。

    （4）getBean(String name,Object[] args)
    这种方式本质还是通过bean的id或者name来获取bean,通过第二个参数Object[] args可以给bean的属性赋值，赋值的方式有两种：构造方法和工厂方法。但是通过这种方式获取的bean必须把scope属性设置为prototype，也就是非单例模式。

    下来我们分别来探讨以上四种方式获取bean的区别。

    其中实体类Person定义如下：

    public class Person {
 
private String name;
private int age;
public Person(){}
 
public Person(String name, int age) {
this.name = name;
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
 
public int getAge() {
return age;
}
 
public void setAge(int age) {
this.age = age;
}
 
@Override
public String toString() {
return "Person [name=" + name + ", age=" + age + "]";
}
}

    applicationContext.xml注册有id为p的bean，配置如下：

    <bean id="p" class="com.bean.Person">
<property name="name" value="张三"/>
<property name="age" value="18"/>
</bean>
    第一种：l getBean(String name)

    参数name表示IOC容器中已经实例化的bean的id或者name,且无论是id还是name都要求在IOC容器中是唯一的不能重名。那么这种方法就是通过id或name去查找获取bean.获取bean的参考代码如下：

    @Test
 
 
public void testPerson()
{
ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
 
Person p = (Person) ctx.getBean("p");
 
System.out.println(p);
}
    第二种：l getBean(Class<T> type)

    参数Class<T> type表示要加载的Bean的类型。如果该类型没有继承任何父类(Object类除外)和实现接口的话，那么要求该类型的bean在IOC容器中也必须是唯一的。比如applicationContext.xml配置两个类型完全一致的bean,且都没有配置id和name属性。

    <bean class="com.bean.Person">
<property name="name" value="张三"/>
<property name="age" value="18"/>
</bean>
<bean class="com.bean.Person">
<property name="name" value="李四"/>
<property name="age" value="20"/>
</bean>

    那么通过com.bean.Person这种类型来查找bean,参考代码如下：

    @Test
public void testPerson()
 
{
ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
 
Person p = ctx.getBean(Person.class);
 
System.out.println(p);
}

    但是由于属于com.bean.Person的bean在IOC容器中不唯一，所以这里会抛出NoUniqueBeanDefinitionException异常。
    由此我们可以总结getBean(String name)和getBean(Class<T> type)的异同点。
    相同点：都要求id或者name或者类型在容器中的唯一性。
    不同点：getBean(String name)获得的对象需要类型转换而getBean(Class<T> type)获得的对象无需类型转换。

    第三种：l getBean(String name,Class<T> type)

    这种方式比较适合当类型不唯一时，再通过id或者name来获取bean。
    例如applicationContext.xml配置有如下bean:

    <bean id="p1" class="com.bean.Person">
<property name="name" value="张三"/>
<property name="age" value="18"/>
</bean>
<bean name="p2" class="com.bean.Person">
<property name="name" value="李四"/>
<property name="age" value="20"/>
</bean>

    参考代码如下：

    @Test
public void testPerson()
{
ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
 
Person p = ctx.getBean("p2",Person.class);
 
System.out.println(p);
}

    这样可以获取到名字叫”李四”的对象。

    第四种：l getBean(String name,Object[] args)

    这种方式本质还是通过bean的id或者name来获取bean,通过第二个参数Object[] args可以给bean的属性赋值，赋值的方式有两种：构造方法和工厂方法。但是通过这种方式获取的bean必须把scope属性设置为prototype，也就是非单例模式。
    先在com.factory包下设计有如下的工厂类：

    public class PersonFactory {
//静态工厂注入
public static Person getPersonInstance(String name,int age)throws Exception
{
 
Person p = (Person)Class.forName("com.bean.Person").newInstance();
 
Method m = p.getClass().getMethod("setName", java.lang.String.class);
 
m.invoke(p, name);
 
m = p.getClass().getMethod("setAge", int.class);
 
m.invoke(p, age);
 
return p;
}
}

    在applicationContext.xml中配置有如下bean:

    <bean name="p3" class="com.bean.Person" scope="prototype"/>

    获取bean的参考代码如下：

    @Test
 
public void testPerson()
 
{
 
ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
 
Person p = (Person) ctx.getBean("p3",new Object[]{"王五",35});
 
System.out.println(p);
}

    如果想通过工厂注入属性，在applicationContext.xml配置如下bean:

    <bean name="p3" class="com.factory.PersonFactory" factory-method="getPersonInstance" scope="prototype">
<constructor-arg name="name">
 
<null/>
 
</constructor-arg>
 
<constructor-arg name="age" value="0"/>
 
</bean>

    ClassPathXmlApplicationContext类

    org.springframework.context.support.ClassPathXmlApplicationContext

    这个类实现了ApplicationContext接口，注意一下这个类名称包含了ClassPath Xml，说明这个容器类可以从classpath中加载bean xml配置文件，然后创建xml中配置的bean对象，一会后面的案例就会用到这个类。

    AnnotationConfigApplicationContext类

    org.springframework.context.annotation.AnnotationConfigApplicationContext

    这个类也实现了ApplicationContext接口，注意其类名包含了Annotation和config两个单词，上面我们有说过，bean的定义支持xml的方式和注解的方式，当我们使用注解的方式定义bean的时候，就需要用到这个容器来装载了，这个容器内部会解析注解来构建构建和管理需要的bean。

    注解的方式相对于xml方式更方便一些，也是我们比较推荐的方式，后面我们会大量使用这种方式，具体会详解。

    案例

    来个helloworld来详细看一下spring如何使用。

    创建项目spring-series

    使用idea创建maven项目spring-series，项目坐标：

    <groupId>com.javacode2018</groupId>
<artifactId>spring-series</artifactId>
<packaging>pom</packaging>
<version>1.0-SNAPSHOT</version>

    spring-series项目中创建一个子模块lesson-001，项目maven父子结构

    spring-series/pom.xml

    <?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.javacode2018</groupId>
    <artifactId>spring-series</artifactId>
    <packaging>pom</packaging>
    <version>1.0-SNAPSHOT</version>
    <modules>
        <module>lesson-001</module>
    </modules>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <!-- 配置maven编译的时候采用的编译器版本 -->
        <maven.compiler.compilerVersion>1.8</maven.compiler.compilerVersion>
        <!-- 指定源代码是什么版本的，如果源码和这个版本不符将报错，maven中执行编译的时候会用到这个配置，默认是1.5，这个相当于javac命令后面的-source参数 -->
        <maven.compiler.source>1.8</maven.compiler.source>
        <!-- 该命令用于指定生成的class文件将保证和哪个版本的虚拟机进行兼容，maven中执行编译的时候会用到这个配置，默认是1.5，这个相当于javac命令后面的-target参数 -->
        <maven.compiler.target>1.8</maven.compiler.target>
        <spring.version>5.2.3.RELEASE</spring.version>
    </properties>

    <dependencyManagement>
       <dependencies>
           <dependency>
               <groupId>org.springframework</groupId>
               <artifactId>spring-core</artifactId>
               <version>${spring.version}</version>
           </dependency>
           <dependency>
               <groupId>org.springframework</groupId>
               <artifactId>spring-context</artifactId>
               <version>${spring.version}</version>
           </dependency>
           <dependency>
               <groupId>org.springframework</groupId>
               <artifactId>spring-beans</artifactId>
               <version>${spring.version}</version>
           </dependency>
       </dependencies>
    </dependencyManagement>
</project>

    目前我们使用spring最新的版本5.2.3.RELEASE，需要引入spring提供的3个构件

    spring-core、spring-context、spring-beans

    lesson-001\pom.xml

    <?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <parent>
        <artifactId>spring-series</artifactId>
        <groupId>com.javacode2018</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <artifactId>lesson-001</artifactId>

    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-beans</artifactId>
        </dependency>
    </dependencies>

</project>

    lesson-001中创建HelloWord类

    package com.javacode2018.lesson001.demo1;

/**
 * 公众号：路人甲Java，工作10年的前阿里P7分享Java、算法、数据库方面的技术干货！坚信用技术改变命运，让家人过上更体面的生活!
 */
public class HelloWorld {
    public void say() {
        System.out.println("hello,欢迎和【路人甲Java】一起学spring!");
    }
}

    HelloWord中我们创建了一个say方法，里面会输一段文字。

    使用spring容器

    下面我们通过spring容器来创建HelloWord对象，并从容器中获取这个对象，然后调用其say方法输出文字。

    创建bean xml配置文件

    新建一个文件，文件路径如下：

    spring-series\lesson-001\src\main\resources\com\javacode2018\lesson001\demo1\bean.xml

    bean.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-4.3.xsd">

    <!--
    定义一个bean
    id：bean的唯一标识，可以通过这个标识从容器中获取这个bean对象
    clss：这个bean的类型，完整类名称
    -->
    <bean id="helloWorld" class="com.javacode2018.lesson001.demo1.HelloWorld"/>

</beans>

    上面就是bean的定义文件，每个xml中可以定义多个bean元素，通过bean元素定义需要spring容器管理的对象，bean元素需指定id和class属性

    • id表示这个bean的标识，在容器中需要唯一，可以通过这个id从容器中获取这个对象；
    • class用来指定这个bean的完整类名

    上面的配置文件中我们定义了一个helloWorld标识的HellWorld类型的bean对象。

    创建测试类

    创建一个Client类，如下：

    package com.javacode2018.lesson001.demo1;

import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 * 公众号：路人甲Java，工作10年的前阿里P7分享Java、算法、数据库方面的技术干货！坚信用技术改变命运，让家人过上更体面的生活!
 */
public class Client {

    public static void main(String[] args) {
        //1.bean配置文件位置
        String beanXml = "classpath:/com/javacode2018/lesson001/demo1/beans.xml";

        //2.创建ClassPathXmlApplicationContext容器，给容器指定需要加载的bean配置文件
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext(beanXml);

        //3.从容器中获取需要的bean
        HelloWorld helloWorld = context.getBean("helloWorld", HelloWorld.class);

        //4.使用对象
        helloWorld.say();

    }
}

    上面main方法中有容器的详细使用步骤，需要先创建容器对象，创建容器的对象的时候需要指定bean xml文件的位置，容器启动之后会加载这些配文件，然后将这些对象构建好。

    代码中通过容器提供的getBean方法从容器中获取了HellWorld对象，第一个参数就是xml中bean的id，第二个参数为bean对应的Class对象。

    运行输出

    hello,欢迎和【路人甲Java】一起学spring!

    总结

    本文主要介绍了spring容器的概念、bean的概念、常见的spring容器，以及spring容器的使用步骤；下一篇我们将详解bean的定义。

    来源：

    https://mp.weixin.qq.com/s?__biz=MzA5MTkxMDQ4MQ==&mid=2648933940&idx=1&sn=6c8c6dc1d8f955663a9874c9f94de88e&chksm=88621e0abf15971c796248e35100c043dac0f5173a870c1d952d4d88a336fa4b76db6885a70c&token=339287021&lang=zh_CN&scene=21#wechat_redirect

    https://blog.csdn.net/qq_23927391/article/details/80625578
  • 相关阅读:
    2015多校.Zero Escape (dp减枝 && 滚动数组）
    UVa-11809
    UVa-1588 Kickdown
    UVa-1587
    UVa-10340
    UVa-202
    UVa-1368
    UVa-232 Crossword Answers
    UVa-227
    UVa-455 Periodic Strings
  • 原文地址：https://www.cnblogs.com/konglxblog/p/15415738.html
Copyright © 2020-2023  润新知