文章目录

采用 spring 配置文件管理Bean
- 一、安装配置Maven
- 二、Spring 框架
- - 1、Spring 官网
- 三、Spring 容器演示-采用Spring配置文件管理Bean
- - 1、创建Manev项目
  - 2、添加Spring依赖
  - 3、创建杀龙骑士类
  - 4、创建勇敢骑士类
  - 5、采用传统方式让勇敢骑士完成杀龙任务
  - 6、采用Spring 容器让勇敢骑士完成杀龙任务
  - - 1) 创建日志属性文件 log4j.properties
    - 2) 创建Spring 配置文件
    - 3) 在Spring配置文件里面创建Bean
    - - (1) 创建杀龙任务Bean
      - (2) 创建勇敢骑士Bean
    - 4) 创建新勇敢骑士测试类
    - 5) 创建两个勇敢骑士bean
    - 6) 修改新勇敢骑士测试类
  - 7、采用构造方法注入方式注入属性值
  - - 1) 创建救美任务类
    - 2) 创建救美骑士类
    - 3) 配置救美骑士Bean
    - 4) 创建旧救美骑士测试类
    - 5) 创建新救美骑士测试类

采用 spring 配置文件管理Bean

一、安装配置Maven

下载链接：https://pan.baidu.com/s/1pL4IRhwjuXAkezgWQdrnYQ
提取码：hjzs
先创建一个 MAVEN_HOME 变量是包存放的路径
在这里插入图片描述
然后在Path 里面添加 %MAVEN_HOME%\bin

配置好之后，在命令行进行测试输入: mvn -version 可以

安装好之后在 IDEA 里面进行配置Maven
打开setting 选择自己的maven

二、Spring 框架

1、Spring 官网

链接：https://spring.io/

在这里插入图片描述
最新版本是6.0.4 因为我们用的JDK版本是17 为了与之对应所以我们这里使用的Spring Franework的版本是5.3.25

三、Spring 容器演示-采用Spring配置文件管理Bean

1、创建Manev项目

在这里插入图片描述

2、添加Spring依赖

Spring 框架与JDK版本对应关系

Spring框架版本	JDK版本
6.0.x	JDK17-21（预期）
5.3.x	JDK8-19（预期）
5.2.x	JDK8-15
5.1.x	JDK8-12
5.0.x	JDK8-10
4.3.x	JDK6-8

我们这篇博文的环境，JDK17，IntelliJ IDEA 2022，使用的是Spring 5.3.25

在Maven 仓库里面查找我们需要的依赖
Maven仓库地址：https://mvnrepository.com/artifact/org.springframework/spring-core/5.3.25
spring core里面选择5.3.25
在这里插入图片描述
下面是要添加的依赖

<?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>net.aex.spring</groupId>
    <artifactId>SpringDemo</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <maven.compiler.source>17</maven.compiler.source>
        <maven.compiler.target>17</maven.compiler.target>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>

    <dependencies>
        <!--Spring核心-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>5.3.25</version>
        </dependency>
        <!--Spring实体-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-beans</artifactId>
            <version>5.3.25</version>
        </dependency>
        <!--Spring容器-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.3.25</version>
        </dependency>
        <!--Spring Web-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-web</artifactId>
            <version>5.3.25</version>
        </dependency>
        <!--Spring MVC-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>5.3.25</version>
        </dependency>
        <!--Spring测试-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>5.3.25</version>
        </dependency>
        <!--单元测试-->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.13.2</version>
            <scope>test</scope>
        </dependency>
    </dependencies>

</project>

3、创建杀龙骑士类

创建 net.aex.spring.day01包，然后在包里创建 SlayDragonQuest 类
在这里插入图片描述

package net.aex.spring.day01;
//杀龙任务类
public class SlayDragonQuest {
    public void embaek(){
        System.out.println("执行杀龙任务.....");
    }
}

4、创建勇敢骑士类

在 net.aex.spring.day01包里创建BraveKnight类

package net.aex.spring.day01;
//勇敢骑士类
public class BraveKnight {
    private String name; //骑士姓名
    private SlayDragonQuest slayDragonQuest; //杀龙任务

    public String getName() {  //alt + insert 快捷键 创建get和set方法
        return name;
    }

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

    public SlayDragonQuest getSlayDragonQuest() {
        return slayDragonQuest;
    }

    //设置杀龙任务
    public void setSlayDragonQuest(SlayDragonQuest slayDragonQuest) {
        this.slayDragonQuest = slayDragonQuest;
    }

    //勇敢骑士执行任务
    public void embarkOnQuest(){
        System.out.print("勇敢骑士[" + name + "]"); //骑士留名
        slayDragonQuest.embaek(); //执行杀龙任务
        
    }
}

回顾一下传统方式怎么使用这两个类。需要我们自己通过new实例化两个类，然后设置勇敢骑士对象的姓名和杀龙任务属性，然后调用勇敢骑士执行任务的方法。

5、采用传统方式让勇敢骑士完成杀龙任务

在test/java里创建net.aex.spring.day01包，然后在包里面创建TestBraveKnightOld类
在这里插入图片描述

package net.aex.spring.day01;

import org.junit.Test;

//采用传统方式测试骑士勇士类
public class TestBraveKnightOld {

    @Test
    public void testBraveKninght(){
        //创建杀龙任务对象
        SlayDragonQuest slayDragonQuest = new SlayDragonQuest();
        //创建勇敢骑士对象
        BraveKnight braveKnight = new BraveKnight();
        //设置勇敢骑士属性
        braveKnight.setName("罗宾汉"); //这个是new 了 一个我们创建的BraveKnight的对象，调用了里面的setName的属性
        braveKnight.setSlayDragonQuest(slayDragonQuest);
        //调用勇敢骑士执行对象
        braveKnight.embarkOnQuest(); //这个也是调用了那里面的方法执行
    }
}

运行测试方法 testBraveKninght() 查看结果
在这里插入图片描述

6、采用Spring 容器让勇敢骑士完成杀龙任务

1) 创建日志属性文件 log4j.properties

在resources目录里创建log4j.properties
在这里插入图片描述

log4j.rootLogger=WARN, stdout, logfile
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%d %p [%c] - %m%n
log4j.appender.logfile=org.apache.log4j.FileAppender
log4j.appender.logfile.File=target/spring.log
log4j.appender.logfile.layout=org.apache.log4j.PatternLayout
log4j.appender.logfile.layout.ConversionPattern=%d %p [%c] - %m%n

2) 创建Spring 配置文件

在resources里创建xmlconfig目录，然后在里面创建spring-config.xml
选这个带有叶子的，注意只有IDEA 企业版才有这个
在这里插入图片描述

3) 在Spring配置文件里面创建Bean

(1) 创建杀龙任务Bean

 <!--配置杀龙任务Bean-->
    <bean id="slayDragonQuest" class="net.aex.spring.day01.SlayDragonQuest"/>

id属性 ：对应对象名，可以任取，然后在应用程序里我们可以通过这个id值从Spring容器中获取Bean对象。
class属性 ：表明Bean对象是基于哪个类来实例化，注意一定要包含包名。

(2) 创建勇敢骑士Bean

property元素：给对象设置属性值
name属性：Bean对象的属性名
ref属性：Bean对象的属性值（引用另一个Bean对象）
勇敢骑士Bean通过<property>元素将杀龙任务Bean注入作为其属性。注意，name属性值一定是BraveKnight类的属性名，ref属性值是已定义的杀龙任务Bean的id值。

<?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-->
    <bean id="slayDragonQuest" class="net.aex.spring.day01.SlayDragonQuest"/>

    <!--配置勇敢骑士Bean-->
    <bean id="braveKnight" class="net.aex.spring.day01.BraveKnight">
        <property name="name" value="罗宾汉"/>  <!-- RobinHood.setName("罗宾汉")-->
        <property name="slayDragonQuest" ref="slayDragonQuest"/>  <!--RobinHood.setSlayDragonQuest(slayDragonQuest)-->
    </bean>

</beans>

通过Spring配置文件，创建了两个Bean对象，它们之间存在依赖关系，第一个Bean对象是第二个Bean对象的任务属性值。

4) 创建新勇敢骑士测试类

在test/java/net.huawei.spring.day01里创建TestBraveKnightNew测试类
在这里插入图片描述

package net.aex.spring.day01;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.springframework.context.support.ClassPathXmlApplicationContext;


public class TestBraveKnightNew {
    private ClassPathXmlApplicationContext context; // 基于类路径XML配置文件的应用容器（Bean工厂）

    @Before // 每次测试方法执行前都要执行的代码就放在此方法里
    public void init() {
        // 基于Spring配置文件创建应用容器
        context = new ClassPathXmlApplicationContext("xmlconfig/spring-config.xml");
        // 提示用户
        System.out.println("Spring应用容器已创建~");
    }

    @Test
    public void testBraveKnight() {
        // 根据名称从应用容器中获取勇敢骑士对象
        BraveKnight braveKnight = (BraveKnight) context.getBean("braveKnight");
        // 勇敢骑士执行任务
        braveKnight.embarkOnQuest();
    }

    @After // 每次测试方法执行后都要执行的代码就放在此方法里
    public void destroy() {
        // 关闭应用容器
        context.close();
        // 提示用户
        System.out.println("Spring应用容器已关闭~");
    }

}

代码说明：首先通过Spring配置文件创建Spring应用容器，然后就可以利用容器的getBean方法通过名称获取容器里的Bean对象，然后调用该对象的方法。
运行测试方法testBraveKnight()，查看结果
在这里插入图片描述
根据名称从应用容器中获取勇敢骑士对象可能会报错，因为配置文件里没有定义那个名称的Bean

5) 创建两个勇敢骑士bean

基于一个类可以创建多个对象，因此，在spring-config.xml文件里，也可以基于同一个类创建多个Bean。
基于BraveKnight类再创建两个Bean，id值分别为knight1和knight2。
在这里插入图片描述
在Spring配置文件里，同一个Bean不能重复定义，也就是说不允许两个Bean有相同的id值

6) 修改新勇敢骑士测试类

获取新建的两个勇敢骑士Bean，调用执行任务方法
在这里插入图片描述
执行testBraveKnight()测试方法，查看结果

勇敢骑士Bean采用属性注入方式将杀龙任务Bean注入作为其属性。

初始化对象其实可以调用有参构造方法来设置属性的初始值，对应到Spring的Bean工厂，就还有一种注入方式，叫做构造方法注入。同样地，我们还是通过案例来演示如何通过构造方法来注入属性值。

7、采用构造方法注入方式注入属性值

1) 创建救美任务类

在net.aex.spring.day01包里创建RescueDamselQuest类
在这里插入图片描述

package net.aex.spring.day01;
//救美任务类
public class RescueDamselQuest {
    public void embark(){
        System.out.println("执行救美任务....");
    }
}

2) 创建救美骑士类

在net.aex.spring.day01包里创建RescueDamselKnight类
在这里插入图片描述

package net.aex.spring.day01;
//救美骑士类
public class RescueDamselKnight {
    private String name;
    private RescueDamselQuest rescueDamselQuest;

    /**
     * 有参构造方法
     *
     * @param name
     * @param rescueDamselQuest
     */
    public RescueDamselKnight(String name, RescueDamselQuest rescueDamselQuest) {
        this.name = name;
        this.rescueDamselQuest = rescueDamselQuest;
    }

    public void embarkOnQuest() {
        System.out.print("救美骑士[" + name + ']');
        rescueDamselQuest.embark();
    }
}

代码说明：通过构造方法来设置骑士的姓名与要执行的任务。

3) 配置救美骑士Bean

在Spring配置文件里创建救美骑士Bean
在这里插入图片描述
arg: argument 参数

<!--创建救美任务Bean-->
    <bean id="rescueDamselQuest" class="net.aex.spring.day01.RescueDamselQuest"/>
    <!--配置救美骑士Bean-->
    <bean id="Galahad" class="net.aex.spring.day01.RescueDamselKnight">
        <constructor-arg value="格拉海德"/>
        <constructor-arg ref="rescueDamselQuest"/>
    </bean>

4) 创建旧救美骑士测试类

在test/java/net.huawei.spring.day01包里创建TestRescueDamselKnightOld类
在这里插入图片描述

package net.aex.spring.day01;

import org.junit.Test;

public class TestRescueDamselKnightOld {
    @Test
    public void testRescueDamselKnight() {
        // 创建救美任务对象
        RescueDamselQuest rescueDamselQuest = new RescueDamselQuest();
        // 创建救美骑士对象
        RescueDamselKnight rescueDamselKnight = new RescueDamselKnight("格拉海德", rescueDamselQuest);
        // 救美骑士执行任务
        rescueDamselKnight.embarkOnQuest();
    }

}

运行testRescueDamselKnight()方法，查看结果
在这里插入图片描述

5) 创建新救美骑士测试类

在test/java/net.huawei.spring.day01包里创建TestRescueDamselKnightNew类
在这里插入图片描述

package net.aex.spring.day01;

import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.springframework.context.support.ClassPathXmlApplicationContext;

//采用Spring容器测试救美骑士类
public class TestRescueDamselKnightNew {
    private ClassPathXmlApplicationContext context; // 基于类路径XML配置文件的应用容器

    @Before // 每次测试方法执行前都要执行的代码
    public void init() {
        // 基于Spring配置文件创建应用容器
        context = new ClassPathXmlApplicationContext("xmlconfig/spring-config.xml");
        // 提示用户
        System.out.println("Spring应用容器已创建~");
    }

    @Test
    public void testRescueDamselKnight() {
        // 根据名称从应用容器里获取救美骑士对象
        RescueDamselKnight rescueDamselKnight = (RescueDamselKnight) context.getBean("Galahad");
        // 救美骑士执行任务
        rescueDamselKnight.embarkOnQuest();
    }

    @After // 每次测试方法执行后都要执行的代码
    public void destroy() {
        // 关闭应用容器
        context.close();
        // 提示用户
        System.out.println("Spring应用容器已关闭~");
    }

}