Spring注解详解：@Configuration，@Bean，@Scope，@Lazy注解

男娘i 2023-09-28 09:59 19阅读 0赞

**目录**

原始Spring开发

编辑注解Spring开发

@Configuration与@Bean作用总结

@Scope的用法

@Lazy的用法

--------------------

## 原始Spring开发 ##

**Person.java**

准备Person.java类

package com.jektong.spring;
    
    public class Person {
    
    	private String name;
    
    	private int age;
    
    	public Person() {
    		super();
    	}
    
    	public Person(String name, int age) {
    		super();
    		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 + "]";
    	}
    
    }

**pom.xml**

在pom文件导入Spring基本依赖:

<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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    	<modelVersion>4.0.0</modelVersion>
    	<groupId>com.jektong</groupId>
    	<artifactId>maven01</artifactId>
    	<version>0.0.1-SNAPSHOT</version>
    	<name>maven01</name>
    	<description>maven01</description>
    
    	<dependencies>
    		
    		<dependency>
    			<groupId>org.springframework</groupId>
    			<artifactId>spring-context</artifactId>
    			<version>4.3.12.RELEASE</version>
    		</dependency> 
    	</dependencies>
    </project>

**bean.xml**

在没有使用Spring注解开发之前，我们通常会通过一个xml配置文件(**bean.xml**)去将我们需要使用的对象通过Bean的方式去注入到Spring容器中。

下面就是将Person作为对象注入Spring容器中：

**PersonTest.java**

使用一个PersonTest.java测试类测试:

package com.jektong.spring;
    
    import org.springframework.context.ApplicationContext;
    import org.springframework.context.support.ClassPathXmlApplicationContext;
    
    public class PersonTest {
    	
    	public static void main(String[] args) {
            // 加载配置文件，此文件放在类路径下。
    		ApplicationContext applicationContext = new ClassPathXmlApplicationContext("bean.xml");
            // 获取bean.xml文件中注入的Person对象，并输出。
    		Person bean = (Person) applicationContext.getBean("person");
    		System.out.println(bean);		
    	}
    
    }

输出结果如下：

## ![ab575a1b54a94abb9ef97d5bc532ec5f.png][]注解Spring开发 ##

舍弃上面的**bean.xml**文件，通过注解的方式将xml文件转换成配置类，建立**PersonConfig**配置类：

package com.jektong.config;
    
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    
    import com.jektong.spring.Person;
    
    @Configuration // 告诉spring这是配置类相当于配置文件bean.xml
    public class PersonConfig {
    
        // 这是注入到spring容器的对象ID
        // 括号内指定唯一ID，不指定则是默认以方法名为唯一ID，相当于：<bean>标签中的ID值。
    	@Bean("person01") 
    	public Person person() {
    		return new Person("李四",21);
    	}
    }

测试使用AnnotationConfigApplicationContext类读取注解：

package com.jektong.spring;
    
    import org.springframework.context.ApplicationContext;
    import org.springframework.context.annotation.AnnotationConfigApplicationContext;
    
    import com.jektong.config.PersonConfig;
    
    public class PersonTest {
    	
    	public static void main(String[] args) {	
    		ApplicationContext ac = new AnnotationConfigApplicationContext(PersonConfig.class);
    		Person bean = ac.getBean(Person.class);
    		System.out.println(bean);
    		
            // 查看BEAN的id
    		String[] beanDefinitionNames = ac.getBeanNamesForType(Person.class);
    		for (int i = 0; i < beanDefinitionNames.length; i++) {
    			System.out.println("beanid为："+ beanDefinitionNames[i]);
    		}
    	}
    
    }

输出如下：

![6f6c806bb01149a698c9eae4f0b9637a.png][]

### @Configuration与@Bean作用总结 ###

**@Configuration**相当于spring中的XML配置文件，将此XML文件替代成配置类，声明在类上。**@Bean**相当于**XML**文件中所配置的各个Bean对象，现声明在方法上，默认以方法名作为注入的**Bean的id**。

## @Scope的用法 ##

之前每一次获取的Bean对象默认范围都是单实例对象（**singleton**）若使用其他范围需要使用**@Scope**注解来指定对应的参数。

@Test
    public  void test01() {
    	ApplicationContext ac = new AnnotationConfigApplicationContext(PersonConfig.class);
    	Person bean = ac.getBean(Person.class);
    	Person bean2 = ac.getBean(Person.class);
    	System.out.println(bean==bean2);
    }

输出的结果是**true：说明是一个对象。也就是在容器创建的范围内，只有一个Person对象。**

如果需要多个对象，使用**@Scope，**将PersonConfig.java修改一下，以上测试的结果就是**false**。

@Configuration
    @ComponentScan("com.jektong")
    public class PersonConfig {
    
    	@Scope(scopeName = "prototype")
    	@Bean("person01")
    	public Person person() {
    		return new Person("李四",21);
    	}
    }

## **@Lazy**的用法 ##

单实例Bean的情况下，默认是在容器启动的时候就创建对象，若想在容器启动后不创建对象，在第一次使用对象时创建，使用**@Lazy**注解：

@Configuration
    @ComponentScan("com.jektong")
    public class PersonConfig {
    
    	@Lazy
    	@Bean("person01")
    	public Person person() {
    		System.out.println("容器获取创建对象...");
    		return new Person("李四",21);
    	}
    }

这样这个单例Bean就不会在容器启动的时候加载了。

[ab575a1b54a94abb9ef97d5bc532ec5f.png]: https://img-blog.csdnimg.cn/ab575a1b54a94abb9ef97d5bc532ec5f.png
[6f6c806bb01149a698c9eae4f0b9637a.png]: https://img-blog.csdnimg.cn/6f6c806bb01149a698c9eae4f0b9637a.png