04-SpringBoot @Configuration和@ImportResource注解

鸣鼓ming

已于 2022-06-07 21:08:45 修改

阅读量323

点赞数 1

分类专栏： SpringBoot入门文章标签： spring boot java spring

于 2022-06-07 20:24:16 首次发布

本文链接：https://blog.csdn.net/qq_41865229/article/details/125171773

版权

SpringBoot入门专栏收录该内容

36 篇文章 4 订阅

订阅专栏

1.相关介绍

@Configuration是用于配置类上的一个注解, 配置类被标注后会注入IOC容器中成为一个组件
@Configuration代码如下

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Component
public @interface Configuration {
    @AliasFor(
        annotation = Component.class
    )
    String value() default "";

    boolean proxyBeanMethods() default true;
}

2.与SSM配置文件对比

1.注册bean

之前我们SSM注册一个bean, 需要编写配置文件
bean1.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">

    <bean id="user" class="com.limi.entity.User">
        <property name="id" value="1"></property>
        <property name="userName" value="andy"></property>
        <property name="passWord" value="123456"></property>
    </bean>

</beans>

使用@Configuration编写配置类, 效果和上面一致

MyConfig

package com.limi.config;


import com.limi.entity.User;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * 1、配置类里面使用@Bean标注在方法上给容器注册组件，默认也是单实例的
 * 2、配置类本身也是组件
 * 3、proxyBeanMethods：代理bean的方法
 *      Full(proxyBeanMethods = true)（保证每个@Bean方法被调用多少次返回的组件都是单实例的）（默认）
 *      Lite(proxyBeanMethods = false)（每个@Bean方法被调用多少次返回的组件都是新创建的）
 */
@Configuration(proxyBeanMethods = false) //告诉SpringBoot这是一个配置类 == 配置文件
public class MyConfig {

    /**
     * Full:外部无论对配置类中的这个组件注册方法调用多少次获取的都是之前注册容器中的单实例对象
     * @return
     */
    @Bean //给容器中添加组件。以方法名作为组件的id。返回类型就是组件类型。返回的值，就是组件在容器中的实例
    public User user02(){
        return new User(2, "bob", "666666");
    }

}

2.@ImportResource

有的时候就是想用外部文件bean1.xml注册bean怎么办?
我们可以在配置类上使用@ImportResource注解
MyConfig

package com.limi.config;


import com.limi.entity.User;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.ImportResource;

/**
 * 1、配置类里面使用@Bean标注在方法上给容器注册组件，默认也是单实例的
 * 2、配置类本身也是组件
 * 3、proxyBeanMethods：代理bean的方法
 *      Full(proxyBeanMethods = true)（保证每个@Bean方法被调用多少次返回的组件都是单实例的）（默认）
 *      Lite(proxyBeanMethods = false)（每个@Bean方法被调用多少次返回的组件都是新创建的）
 */
@Configuration(proxyBeanMethods = false) //告诉SpringBoot这是一个配置类 == 配置文件
@ImportResource(value = {"classpath:bean1.xml"})
public class MyConfig {

    /**
     * Full:外部无论对配置类中的这个组件注册方法调用多少次获取的都是之前注册容器中的单实例对象
     * @return
     */
    @Bean //给容器中添加组件。以方法名作为组件的id。返回类型就是组件类型。返回的值，就是组件在容器中的实例
    public User user02(){
        return new User(2, "bob", "666666");
    }

}

测试一下
MainApplication

package com.limi;

import com.limi.entity.User;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ConfigurableApplicationContext;
import org.springframework.context.annotation.ComponentScan;

@SpringBootApplication
public class MainApplication {

    public static void main(String[] args) {

        //1、返回我们IOC容器
        ConfigurableApplicationContext run = SpringApplication.run(MainApplication.class, args);

        //使用外部文件bean1.xml创建的bean
        User user01 = (User)run.getBean("user01");
        System.out.println(user01);

        //使用配置类创建的bean
        User user02 = (User)run.getBean("user02");
        System.out.println(user02);

    }
}

在这里插入图片描述

3.proxyBeanMethods参数

proxyBeanMethods：代理bean的方法

Full(proxyBeanMethods = true)（保证每个@Bean方法被调用多少次返回的组件都是单实例的）（默认）
Lite(proxyBeanMethods = false)（每个@Bean方法被调用多少次返回的组件都是新创建的）

1.proxyBeanMethods = true

MyConfig

package com.limi;

import com.limi.config.MyConfig;
import com.limi.entity.User;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ConfigurableApplicationContext;
import org.springframework.context.annotation.ComponentScan;

@SpringBootApplication
public class MainApplication {

    public static void main(String[] args) {

        //1、返回我们IOC容器
        ConfigurableApplicationContext run = SpringApplication.run(MainApplication.class, args);

        //使用配置类创建的bean
        User user02a = (User)run.getBean("user02");
        User user02b = (User)run.getBean("user02");
        System.out.println(user02a.hashCode());
        System.out.println(user02b.hashCode());

        //获取配置类组件, 通过调用配置类的方法来获取User的bean
        MyConfig myConfig = (MyConfig) run.getBean(MyConfig.class);

        User user021 = myConfig.user02();
        User user022 = myConfig.user02();

        System.out.println(user021.hashCode());
        System.out.println(user022.hashCode());

    }
}

MainApplication

package com.limi;

import com.limi.config.MyConfig;
import com.limi.entity.User;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ConfigurableApplicationContext;
import org.springframework.context.annotation.ComponentScan;

@SpringBootApplication
public class MainApplication {

    public static void main(String[] args) {

        //1、返回我们IOC容器
        ConfigurableApplicationContext run = SpringApplication.run(MainApplication.class, args);

        //使用配置类创建的bean
        User user02 = (User)run.getBean("user02");
        System.out.println(user02.hashCode());

        //获取配置类组件, 通过调用配置类的方法来获取User的bean
        MyConfig myConfig = (MyConfig) run.getBean(MyConfig.class);

        User user021 = myConfig.user02();
        User user022 = myConfig.user02();

        System.out.println(user021.hashCode());
        System.out.println(user022.hashCode());

    }
}

可以看到它们的hashCode是一样的,说明是同一个实例
在这里插入图片描述

2.proxyBeanMethods = false

MyConfig

package com.limi.config;


import com.limi.entity.User;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.ImportResource;

/**
 * 1、配置类里面使用@Bean标注在方法上给容器注册组件，默认也是单实例的
 * 2、配置类本身也是组件
 * 3、proxyBeanMethods：代理bean的方法
 *      Full(proxyBeanMethods = true)（保证每个@Bean方法被调用多少次返回的组件都是单实例的）（默认）
 *      Lite(proxyBeanMethods = false)（每个@Bean方法被调用多少次返回的组件都是新创建的）
 */
@Configuration(proxyBeanMethods = false) //告诉SpringBoot这是一个配置类 == 配置文件
@ImportResource(value = {"classpath:bean1.xml"})
public class MyConfig {

    /**
     * Full:外部无论对配置类中的这个组件注册方法调用多少次获取的都是之前注册容器中的单实例对象
     * @return
     */
    @Bean //给容器中添加组件。以方法名作为组件的id。返回类型就是组件类型。返回的值，就是组件在容器中的实例
    public User user02(){
        return new User(2, "bob", "666666");
    }

}

MainApplication

package com.limi;

import com.limi.config.MyConfig;
import com.limi.entity.User;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ConfigurableApplicationContext;
import org.springframework.context.annotation.ComponentScan;

@SpringBootApplication
public class MainApplication {

    public static void main(String[] args) {

        //1、返回我们IOC容器
        ConfigurableApplicationContext run = SpringApplication.run(MainApplication.class, args);

        //使用配置类创建的bean
        User user02a = (User)run.getBean("user02");
        User user02b = (User)run.getBean("user02");
        System.out.println(user02a.hashCode());
        System.out.println(user02b.hashCode());

        //获取配置类组件, 通过调用配置类的方法来获取User的bean
        MyConfig myConfig = (MyConfig) run.getBean(MyConfig.class);

        User user021 = myConfig.user02();
        User user022 = myConfig.user02();

        System.out.println(user021.hashCode());
        System.out.println(user022.hashCode());

    }
}

可以看到通过(User)run.getBean(“user02”)获取的是同一个bean
而通过(MyConfig)run.getBean(MyConfig.class)先获取MyConfig组件,然后通过类方法myConfig.user02()获取的bean不是同一个

在这里插入图片描述

3.最佳设置

配置类组件之间无依赖关系用Lite模式(proxyBeanMethods = false)加速容器启动过程，减少判断

MyConfig

package com.limi.config;


import com.limi.entity.User;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.ImportResource;

/**
 * 1、配置类里面使用@Bean标注在方法上给容器注册组件，默认也是单实例的
 * 2、配置类本身也是组件
 * 3、proxyBeanMethods：代理bean的方法
 *      Full(proxyBeanMethods = true)（保证每个@Bean方法被调用多少次返回的组件都是单实例的）（默认）
 *      Lite(proxyBeanMethods = false)（每个@Bean方法被调用多少次返回的组件都是新创建的）
 */
@Configuration(proxyBeanMethods = false) //告诉SpringBoot这是一个配置类 == 配置文件
@ImportResource(value = {"classpath:bean1.xml"})
public class MyConfig {

    /**
     * Full:外部无论对配置类中的这个组件注册方法调用多少次获取的都是之前注册容器中的单实例对象
     * @return
     */
    @Bean //给容器中添加组件。以方法名作为组件的id。返回类型就是组件类型。返回的值，就是组件在容器中的实例
    public User user02(){
        return new User(2, "bob", "666666");
    }

    @Bean //给容器中添加组件。以方法名作为组件的id。返回类型就是组件类型。返回的值，就是组件在容器中的实例
    public User user03(){
        return new User(3, "cindy", "123456");
    }

}

配置类组件之间有依赖关系，方法会被调用得到之前单实例组件，用Full模式(proxyBeanMethods = true)（默认）
MyConfig

package com.limi.config;


import com.limi.entity.User;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.ImportResource;

/**
 * 1、配置类里面使用@Bean标注在方法上给容器注册组件，默认也是单实例的
 * 2、配置类本身也是组件
 * 3、proxyBeanMethods：代理bean的方法
 *      Full(proxyBeanMethods = true)（保证每个@Bean方法被调用多少次返回的组件都是单实例的）（默认）
 *      Lite(proxyBeanMethods = false)（每个@Bean方法被调用多少次返回的组件都是新创建的）
 */
@Configuration(proxyBeanMethods = true) //告诉SpringBoot这是一个配置类 == 配置文件
@ImportResource(value = {"classpath:bean1.xml"})
public class MyConfig {

    /**
     * Full:外部无论对配置类中的这个组件注册方法调用多少次获取的都是之前注册容器中的单实例对象
     * @return
     */
    @Bean //给容器中添加组件。以方法名作为组件的id。返回类型就是组件类型。返回的值，就是组件在容器中的实例
    public User user02(){
        return new User(2, "bob", "666666");
    }

    @Bean //给容器中添加组件。以方法名作为组件的id。返回类型就是组件类型。返回的值，就是组件在容器中的实例
    public User user03(){
        System.out.println(user02().getUserName()); //组件user03依赖组件user02
        return new User(3, "cindy", "123456");
    }

}

4.完整项目代码

在这里插入图片描述

application.properties

# 设置端口号,如果不设置,默认是8080
server.port=8081

bean1.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">

    <bean id="user01" class="com.limi.entity.User">
        <property name="id" value="1"></property>
        <property name="userName" value="andy"></property>
        <property name="passWord" value="123456"></property>
    </bean>

</beans>

User

package com.limi.entity;


public class User {

    private Integer id;

    private String userName;

    private String passWord;

    public User(){}

    public User(Integer id, String userName, String passWord) {
        this.id = id;
        this.userName = userName;
        this.passWord = passWord;
    }

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", userName='" + userName + '\'' +
                ", passWord='" + passWord + '\'' +
                '}';
    }

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getUserName() {
        return userName;
    }

    public void setUserName(String userName) {
        this.userName = userName;
    }

    public String getPassWord() {
        return passWord;
    }

    public void setPassWord(String passWord) {
        this.passWord = passWord;
    }
}

MyConfig

package com.limi.config;


import com.limi.entity.User;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.ImportResource;

/**
 * 1、配置类里面使用@Bean标注在方法上给容器注册组件，默认也是单实例的
 * 2、配置类本身也是组件
 * 3、proxyBeanMethods：代理bean的方法
 *      Full(proxyBeanMethods = true)（保证每个@Bean方法被调用多少次返回的组件都是单实例的）（默认）
 *      Lite(proxyBeanMethods = false)（每个@Bean方法被调用多少次返回的组件都是新创建的）
 */
@Configuration(proxyBeanMethods = true) //告诉SpringBoot这是一个配置类 == 配置文件
@ImportResource(value = {"classpath:bean1.xml"})
public class MyConfig {

    /**
     * Full:外部无论对配置类中的这个组件注册方法调用多少次获取的都是之前注册容器中的单实例对象
     * @return
     */
    @Bean //给容器中添加组件。以方法名作为组件的id。返回类型就是组件类型。返回的值，就是组件在容器中的实例
    public User user02(){
        return new User(2, "bob", "666666");
    }

    @Bean //给容器中添加组件。以方法名作为组件的id。返回类型就是组件类型。返回的值，就是组件在容器中的实例
    public User user03(){
        System.out.println(user02().getUserName()); //组件user03依赖组件user02
        return new User(3, "cindy", "123456");
    }

}

MainApplication

package com.limi;

import com.limi.config.MyConfig;
import com.limi.entity.User;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ConfigurableApplicationContext;
import org.springframework.context.annotation.ComponentScan;

@SpringBootApplication
public class MainApplication {

    public static void main(String[] args) {

        //1、返回我们IOC容器
        ConfigurableApplicationContext run = SpringApplication.run(MainApplication.class, args);

        //使用配置类创建的bean
        User user02a = (User)run.getBean("user02");
        User user02b = (User)run.getBean("user02");
        System.out.println(user02a.hashCode());
        System.out.println(user02b.hashCode());

        //获取配置类组件, 通过调用配置类的方法来获取User的bean
        MyConfig myConfig = (MyConfig) run.getBean(MyConfig.class);

        User user021 = myConfig.user02();
        User user022 = myConfig.user02();

        System.out.println(user021.hashCode());
        System.out.println(user022.hashCode());

    }
}

鸣鼓ming

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
04-SpringBoot @Configuration和@ImportResource注解

@Configuration是用于配置类上的一个注解, 配置类被标注后会注入IOC容器中成为一个组件@Configuration代码如下2.与SSM配置文件对比之前我们SSM注册一个bean, 需要编写配置文件bean1.xml使用@Configuration编写配置类, 效果和上面一致MyConfig有的时候就是想用外部文件bean1.xml注入bean怎么办?我们可以在配置类上使用@ImportResource注解MyConfig测试一下MainApplicationproxyBe
复制链接

扫一扫