首先创建一个工程

我们先创建一个maven工程,对于所有的spring注解驱动开发的学习,将都会在这个工程下完成。
工程名为:spring_annotation_gaoxiaobai
添加spring的依赖:

  1. <dependency>
  2. <groupId>org.springframework</groupId>
  3. <artifactId>spring-context</artifactId>
  4. <version>5.3.1</version>
  5. </dependency>

spring IOC

首先什么是IOC呢? :::info IOC的全称是:Inversion Of Control 控制反转
就是将对象的创建权力交给spring框架来实现,IOC就是一个对象容器,我们把需要的类全部放到IOC中,在spring中进行登记。通过spring来创建对象,那么这个对象的生命周期不再取决于引用他的对象,而是全部交给spring框架管理。对于对象来讲,之前是对象控制其他对象,现在是spring控制所有对象,这就是控制反转。 ::: 可以看出通过使用spring框架,可以大大降低程序员的开发成本,只需要提供需要管理的对象,在使用的时候直接从spring中去获取。那么问题来了,我们如何将我们后面需要的所有类放入到Spring IOC中呢,又是如何从容器中将我们需要的类取出来,而且不会取错呢?接下来学习通过XML配置文件和注解两种方式来完成容器中的组件的注册、管理及依赖注入。通过两种方式的比较来体现注解驱动开发的优势。

通过XML配置文件注入JavaBean

在刚刚创建的工程中com.gaoxiaobai.bean目录下创建一个Person类,作为测试使用的JavaBean,这个类的代码如下:

package com.gaoxiaobai.bean;

/**
* @Author:gaoxiaobai
* @Date:2022/7/116:16
*/
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 +
            '}';
    }
}

接着,在src/main/resources目录下创建Spring的配置文件,例如创建为bean.xml,通过这个配置文件中将Person类注入到Spring IOC容器中。配置文件的内容如下:

<?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="person" class="com.gaoxiaobai.bean.Person">
        <property name="name" value="gaoxiaobai"></property>
        <property name="age" value="22"></property>
    </bean>
</beans>

其中这个<bean id="person" class="com.gaoxiaobai.bean.Person">中的id就是在获取的时候需要指定的名字,这也就是前面提到的在spring中进行登记,这样便于需要获取对象的时候,spring通过给定的名词,哦,原来你想要这个对象呀,然后他就将这个对象给我们了。
创建一个测试方法,来验证,可以通过spring容器获取对象,并且可以获取到对象。

@Test
public void testBeanByXml(){
 ApplicationContext applicationContext = new ClassPathXmlApplicationContext("bean.xml");
 System.out.println(applicationContext.getBean("person"));
}
运行上面的代码,在控制台输出了对象的内容:<br />![image.png](https://cdn.nlark.com/yuque/0/2022/png/27017931/1656664914768-0c5e2a84-38f6-4b99-b73a-addd09396d13.png#clientId=ub8953541-db5e-4&crop=0&crop=0&crop=1&crop=1&from=paste&height=152&id=u42a159d7&margin=%5Bobject%20Object%5D&name=image.png&originHeight=228&originWidth=721&originalType=binary&ratio=1&rotation=0&showTitle=false&size=23978&status=done&style=none&taskId=uc1b5f90e-f836-40ab-a979-46eb2905ae0&title=&width=480.6666666666667)<br />可以看出,Person对象被注入到了Spring IOC中了。

通过注解注入JavaBean

通过XML配置文件的方式,可以实现将JavaBean注入到Spring IOC中,那么通过注解的方式怎么完成JavaBean的注入呢?
我们在工程中 com.gaoxiaobai.config包中创建一个mainConfig类,在这个类上添加@Configuration注解,来标注这是一个spring的配置类,在这个类中通过注解@Bean来将Person类注入到Spring IOC容器中。

import com.gaoxiaobai.bean.Person;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * @Author:gaoxiaobai
 * @Date:2022/7/116:52
 */
@Configuration
public class mainConfig {
    @Bean
    public Person person(){
        return new Person("gaoxiaobai1",22);
    }
}
在测试类中添加一个新的方法,测试通过注解注入的方式,也可以成功获取对象。
@Test
public void testBeanByAnnotation(){
    ApplicationContext ac = new AnnotationConfigApplicationContext(mainConfig.class);
    Person person =(Person)ac.getBean("person");
    System.out.println(person);
}
上面测试方法执行后,控制台输出的结果为:<br />![image.png](https://cdn.nlark.com/yuque/0/2022/png/27017931/1656666136894-f792a010-8c67-456a-a718-4268263f16a0.png#clientId=ub8953541-db5e-4&crop=0&crop=0&crop=1&crop=1&from=paste&height=203&id=u5ea6b4ce&margin=%5Bobject%20Object%5D&name=image.png&originHeight=304&originWidth=1225&originalType=binary&ratio=1&rotation=0&showTitle=false&size=42684&status=done&style=none&taskId=u86ed5a8f-0e2d-4348-ab13-f9768b0edf7&title=&width=816.6666666666666)

比较XML配置文件的方式与注解的方式的区别

可以看出注解的方式使用起来要比XML配置文件的方式简便许多。 :::info 在XML配置文件的方式中
通过创建bean.xml文件,在文件中添加标签。通过标签的id属性来指定注入的类在Spring IOC中的名字,classs属性,指定要注入的类
在注解方式中
通过创建一个mainConfig类与注解@Configuration来替代xml配置文件,通过注解@Bean来代替XML配置文件中的标签。通过创建一个方法,返回值为注入的类,将对象创建在spring IOC中。 ::: 接下来,小伙伴们就有疑问了,发现使用注解的时候,并没有像通过XML配置文件的方式,指定类的id,在获取对象的时候,我直接使用了 person,就能获取到对象,这是为什么呢?
其实,通过注解@Bean的方式,也可以指定创建的对象的名称,像xml配置文件中的id属性样。在注解Bean中有一个参数value来自定义对象的名称。@Bean(value="person") 这个value可以省略,直接写为:@Bean("person") 这里value这个单词可以省略是因为,Java中指出,当属性为value时,可以直接将value单词省略。
当我们没有指定value属性时,Java会默认以方法名来创建对象的名称。

@Configuration
public class mainConfig {
    @Bean //在这里我将方法名改为了PersonClass
    public Person PersonClass(){
        return new Person("gaoxiaobai1",22);
    }
}
@Test
public void testBeanByAnnotation(){
   ApplicationContext ac = new AnnotationConfigApplicationContext(mainConfig.class);
   Person person = (Person)ac.getBean("PersonClass");
   System.out.println(person);
}

通过getBean(“方法名”),也可以获得对象。那如果我们指定了创建的对象的名称,就会使用我们自定义的对象名称。

@Configuration
public class mainConfig {
    @Bean("personName")
    public Person PersonClass(){
        return new Person("gaoxiaobai1",22);
    }
}

image.png
可以看出,通过使用自定义的名称可以获取到对象。

xml配置文件方式与注解方式获取ApplicationContext对象

使用xml配置文件方式获取:
ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
使用注解方式注入时:
ApplicationContext ac = new AnnotationConfigApplicationContext(mainConfig.class);
两种传入的参数也不相同: :::info

  1. xml配置文件方式传入的是resoureces包下的.xml文件的名字
  2. 注解方式传入的配置类的class 即 配置类名.class :::