@Bean的使用

最新推荐文章于 2024-09-25 07:30:00 发布
最新推荐文章于 2024-09-25 07:30:00 发布
阅读量2.1w 收藏 105
点赞数 30
分类专栏： # spring java 文章标签： bean
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_34484062/article/details/101283056
版权
java 同时被 2 个专栏收录
145 篇文章 3 订阅
订阅专栏
spring
55 篇文章 1 订阅
订阅专栏

@Bean是一个方法级别上的注解，主要用在@Configuration注解的类里，也可以用在@Component注解的类里。目的是创建一个类。当spring需要创建指定的一个类时会调用这个注解（@Bean）的方法。
一个对象

@Data
@AllArgsConstructor
@NoArgsConstructor
public class Info {

    String name;
    int age;
}

就如同在在xml配置中添加一个类的配置。这样spring在自动创建这个类时会调用配置的方法。

<bean id="info" class="zhong.test.springbootdemo.usultestdemo.demo.Info">
	<property name="name" value="sjl"/>
    <property name="age" value="18"/>
</bean>

SprignBoot中 @Bean 完美的替换了了上面的这种在xml中配置的方法。使用以下方法就能让spring在需要自动创建Info对象时，自动调用这个方法。

@Configuration
public class BeanInit {
    /**
     * 测试@Bean的作用
     */
    @Bean(name = "info")
    public Info getInfo(){
        return new Info("gfagduis", 2343);
    }

    @Bean(name = "info1")
    public Info getInfo1(){
        return new Info("gfagdufasfdfdais", 2343);
    }
}

获取这个类的方法：

  1. AnnotationConfigApplicationContext 类获取
@Component
public class BeanTest implements CommandLineRunner {
    private void getBean(){
        ApplicationContext ctx = new AnnotationConfigApplicationContext(BeanInit.class);
        Info info1= ctx.getBean("info",Info.class);
        System.out.println(info1);
    }

    @Override
    public void run(String... args) throws Exception {
        System.out.println(">>>>>>>>>>>>>>>服务启动执行，执行加载数据等操作<<<<<<<<<<<<<");
        getBean();
    }
}
  1. 在spring自动创建的类中，在构造方法中设置这个值，这样spring就会调用该类的创建方法来获取这个初始化的类。
@Component
public class BeanTest implements CommandLineRunner {

    private Info info;

	/**
	 *spring创建BeanTest对象时会调用这个构造函数。参数是info1，所以会调用 @Bean(name = "info1") 注释的方法
	 *
	 */
    public BeanTest (Info info1){
        this.info = info1;
    }
    
   private void getBean2(){
        System.out.println(info);
    }

    @Override
    public void run(String... args) throws Exception {
        System.out.println(">>>>>>>>>>>>>>>服务启动执行，执行加载数据等操作<<<<<<<<<<<<<");
        getBean2();
    }
}

在构造函数中 BeanTest (Info info1) 参数的名称是info1.所以就调用 @Bean(name = “info1”) 的方法来获取初始化对象。
结果如下：

                          >>>>>>>>>>>>>>>服务启动执行，执行加载数据等操作<<<<<<<<<<<<<
                         Info(name=gfagdufasfdfdais, age=2343)

同时也是支持多别名配置的 例如：

    @Bean(name = { "info12", "info3", "info3" })
    public Info getInfo2(){
        return new Info("gfa4361783ais", 2343);
    }

测试一下

@Component
public class BeanTest implements CommandLineRunner {

    private Info info;
    private Info info1;
    private Info info2;

	/**
	 *spring创建BeanTest对象时会调用这个构造函数。参数是info1，所以会调用 @Bean(name = "info1") 注释的方法
	 *
	 */
    public BeanTest (Info info1， Info info2, Info info3){
        this.info = info1;
        this.info1 = info2;
        this.info2 = info3;
    }
    
   private void getBean2(){
        System.out.println(info);
        System.out.println(info1);
        System.out.println(info2);
    }

    @Override
    public void run(String... args) throws Exception {
        System.out.println(">>>>>>>>>>>>>>>服务启动执行，执行加载数据等操作<<<<<<<<<<<<<");
        getBean2();
    }
}

结果如下

>>>>>>>>>>>>>>>服务启动执行，执行加载数据等操作<<<<<<<<<<<<<
Info(name=gfagdufasfdfdais, age=2343)
Info(name=gfa4361783ais, age=2343)
Info(name=gfa4361783ais, age=2343)

当然也可以使用 Qualifier(“xxx”) 来指定 @Bean(name = “xxx”) 中的xxx就可以调用对应的方法。

  1. 使用 @Autowired 注解获取变量，如果有多个初始化方法，则会根据变量名称来获取。
    在初始化类中建立以下多个初始方法
 @Configuration
public class BeanInit {

    /**
     * 测试@Bean的作用
     */
    @Bean/*(initMethod = "init")*/
    public Info getInfo(){
        System.out.println("进入方法");
        Info info = new Info("gfagduis", 2343);
        System.out.println("结束方法");
        return info;
    }

    @Bean(name = "info1")
    public Info getInfo1(){
        return new Info("gfagdufasfdfdais", 2343);
    }

    @Bean(name = { "info2", "info3", "info3" })
    public Info getInfo2(){
        return new Info("gfa4361783ais", 2343);
    }

    @Bean
    public Info info(){
        return new Info("gfsdfadsfad4361783ais", 23143);
    }

然后在测试方法中分别用 @Autowired注释Info类来获取对应的对象

@Component
public class BeanTest implements CommandLineRunner {

    //private Info info;

    @Autowired
    private Info getInfo;

    @Autowired
    private Info info1;

    @Autowired
    private Info info3;

    @Autowired
    private Info info;

    /*public BeanTest (Info info){
        this.info = info;
    }*/

    private void getBean(){
        /*ApplicationContext ctx = new AnnotationConfigApplicationContext(BeanInit.class);
        Info person = ctx.getBean("info",Info.class);
        System.out.println(person);*/

        System.out.println(getInfo);
        System.out.println(info1);
        System.out.println(info3);
        System.out.println(info);

    }

    @Override
    public void run(String... args) throws Exception {
        System.out.println(">>>>>>>>>>>>>>>服务启动执行，执行加载数据等操作<<<<<<<<<<<<<");
        getBean();
    }
}

测试结果如下：

>>>>>>>>>>>>>>>服务启动执行，执行加载数据等操作<<<<<<<<<<<<<
Info(name=gfagduis, age=2343)
Info(name=gfagdufasfdfdais, age=2343)
Info(name=gfa4361783ais, age=2343)
Info(name=gfsdfadsfad4361783ais, age=23143)

在使用 @Autowired 注解时，也可以与 @Qualifier(“xxx”) 指定使用哪个方法来获取对象。

@Bean 注解的属性解析

value 和 name
name 和 value 两个属性是相同的含义的， 在代码中定义了别名。 为 bean 起一个名字，如果默认没有写该属性，那么就使用方法的名称为该 bean 的名称

autowire
装配方式 有三个选项
Autowire.NO (默认设置)
Autowire.BY_NAME
Autowire.BY_TYPE
指定 bean 的装配方式， 根据名称 和 根据类型 装配， 一般不设置，采用默认即可。

initMethod
bean 的初始化方法， 直接指定方法名称即可，不用带括号。初始方法要在对应的POHO中，也就是Info类中。


@Data
@AllArgsConstructor
@NoArgsConstructor
public class Info {

    String name;
    int age;

    private void init(){
        System.out.println("进入方法2");
        name = "fhasjdf";
        age = 12;
    }
}

@Configuration
public class BeanInit {

    /**
     * 测试@Bean的作用
     */
    @Bean(name = "info", initMethod = "init")
    public Info getInfo(){
        System.out.println("进入方法");
        Info info = new Info("gfagduis", 2343);
        System.out.println("结束方法");
        return info;
    }

最终结果、：

进入方法
结束方法
进入方法2
2019-09-24 14:57:11.917  INFO 11656 --- [           main] o.s.s.concurrent.ThreadPoolTaskExecutor  : Initializing ExecutorService 'applicationTaskExecutor'
2019-09-24 14:57:12.048  INFO 11656 --- [           main] o.s.b.w.embedded.tomcat.TomcatWebServer  : Tomcat started on port(s): 8080 (http) with context path ''
2019-09-24 14:57:12.051  INFO 11656 --- [           main] z.t.s.u.start.UsulTestStartApplication   : Started UsulTestStartApplication in 1.74 seconds (JVM running for 2.246)
>>>>>>>>>>>>>>>服务启动执行，执行加载数据等操作<<<<<<<<<<<<<
Info(name=fhasjdf, age=12)

所以最终调用的是init()方法来创建类。

destroyMethod
bean 的销毁方法， 在调用 IoC 容器的 close() 方法时，会执行到该属性指定的方法。不过，只是单实例的 bean 才会调用该方法，如果是多实例的情况下，不会调用该方法。

注意
由于spring构造的对象都是单例的，所以只要是从spring ioc中获取的对象都是同一个，他们中的属性，即便是私有的非静态属性。都是公用的。

public class MyDisposableBean implements DisposableBean {

    public Map<String, String> map = new HashMap<>();
    int i = 0;

    private void init(){
        System.out.println("MyDisposableBean自定义初始化方法");
    }
    private void destroyMethod(){
        System.out.println("自定义销毁方法，MyDisposableBean对象销毁");
    }
    public void pringt(){
        System.out.println("-------------------------------");
        System.out.println("i=" + i);
        System.out.println("map.size=" + map.size());
        map.entrySet().stream().forEach(item -> System.out.println("map ->   "+ item.getKey() + "---" + item.getValue()));
    }
}

@Configuration
public class BeanConfigurer {
    @Bean(name = "MyDisposableBean", initMethod = "init", destroyMethod = "destroyMethod")
    public MyDisposableBean getMyDisposableBean(){
        System.out.println("MyDisposableBean构造方法");
        return new MyDisposableBean();
    }
}

@Component
public class DisposableBeanTest implements CommandLineRunner {

    @Override
    public void run(String... args) throws Exception {
        MyDisposableBean myDisposableBean = new MyDisposableBean();
        MyDisposableBean myDisposableBean1 = new MyDisposableBean();

        MyDisposableBean myDisposableBean2 = SpringContextUtils.getBean(MyDisposableBean.class);
        myDisposableBean2.pringt();
        myDisposableBean2.map.put("1", "2");
        myDisposableBean2.i = 2;
        MyDisposableBean myDisposableBean3 = SpringContextUtils.getBean(MyDisposableBean.class);
        myDisposableBean3.pringt();

        myDisposableBean1.pringt();
    }
}

测试结果：

MyDisposableBean构造方法
MyDisposableBean自定义初始化方法
-------------------------------
i=0
map.size=0
-------------------------------
i=0
map.size=0
-------------------------------
i=2
map.size=1
map ->   1---2
-------------------------------
i=0
map.size=0

可以看出，如果是我们自己在程序中new的对象(myDisposableBean 和 myDisposableBean1)，其私有属性map和i是不变的。不相互影响。
另外两从spring ioc中获取的对象(myDisposableBean2 和 myDisposableBean3 )的map和i两个属性，是公用的。其中一个对象修改值，name另外一个对象的属性也相应的变化

Spring注解深入解析：@Bean与@Component共存的奥秘
fudaihb的博客
04-19 1569
本文将深入探讨两个核心注解：@Bean和@Component，特别是它们在同一类中共存的情况。虽然这两个注解都用于定义Spring组件，但它们在功能和用法上有所不同，同时使用时也可能带来一些特殊的问题和挑战。通过本文，我们将详细解析它们的定义、使用方式以及最佳实践，帮助读者更好地理解和应用这两个注解，从而提高Spring应用的开发效率和质量。
Springboot @Configuration @bean注解作用解析
08-25
在上面的示例代码中，我们使用 @Bean 注解注册了 ShiroFilterFactoryBean 到 Spring 容器中，以便其他组件可以使用该 Bean。 三、@Configuration 和 @Bean 注解的使用场景 在 Spring Boot 框架中，@Configuration ...
@Bean详解
Kaiser__的博客
03-08 3157
在上文我们简单的通过注解类+@bean注解的方式将第三方类注入到了IOC容器进行管理，那么本文我们来详细介绍@bean的用法。
Spring @Bean注解配置及使用方法解析
08-19
主要介绍了Spring @Bean注解配置及使用方法解析,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
@Bean注解的使用：深入解析与实战指南
xycxycooo的博客
09-25 759
在Spring框架中，Bean是指由Spring容器管理的对象。Spring容器负责创建、配置和管理这些对象的生命周期。Bean通常是应用程序中的组件，如服务、存储库、控制器等。@Bean注解是Spring框架中非常重要的一个注解，用于在配置类中显式声明Bean。通过@Bean注解，开发者可以精确控制Bean的创建和管理过程，包括指定Bean的名称、初始化和销毁方法、作用域等。在实际项目中，@Bean注解广泛应用于第三方库的Bean注册、数据源配置等场景。希望这篇文章能帮助你更好地理解@Bean。
@Bean 的用法
hellozhxy的博客
09-18 4万+
@Bean是一个方法级别上的注解，主要用在@Configuration注解的类里，也可以用在@Component注解的类里。添加的bean的id为方法名 定义bean 下面是@Configuration里的一个例子 @Configuration public class AppConfig { @Bean public TransferService transferService() { return new TransferServiceImpl();
@Bean注解使用
qq_37924396的博客
07-10 2211
@Bean 注解的使用
Spring @Bean vs @Service注解区别
08-28
一般来说，如果你需要在应用程序中创建一个复杂的Bean，或者需要手动控制Bean的生命周期，那么使用@Bean是一个不错的选择。例如，在上面的例子中，我们使用@Configuration和@Bean的组合来创建SearchService的Bean。...
通过@Autowired注解注入bean的顺序,以及@bean注入.rar
11-11
当我们在字段、构造函数、方法或方法参数上使用`@Autowired`时，Spring会自动查找与所需类型匹配的bean，并将其注入到相应的位置。如果找到多个匹配的bean，可以通过指定`@Qualifier`来明确选择一个特定的bean。默认...
@Bean使用场景
及时当勉励，岁月不待人
03-09 1474
@Bean使用场景
@Bean注解详解
怪咖@的博客
10-20 3万+
@Bean属于spring当中的注解，@Bean用于将对象存入spring的ioc容器中，同`@controller、@Service、@Component、@Configuration`等几个注解是一样的，都是负责`将对象存入容器当中`。只不过方式不同，他们是用在类上面的，然后将当前类`通过无参构造函数创建对象`然后放入容器，而`@Bean`是用在方法上，将当前方法的`返回值对象`放到容器当中！可以理解为前者是由spring自动创建对象，而@Bean创建对象是交给我们自己来控制。
【Spring】使用@Bean和@Import注解配置Bean，与Bean的实例化
m0_65277261的博客
04-03 2429
在 Spring 中，Bean 是指由 Spring 容器管理的对象。Spring IOC 容器负责创建、配置和管理这些 Bean 对象的生命周期。Spring IOC 容器会管理应用程序中的组件，并通过依赖注入（DI）将它们组装在一起。Bean 是应用程序的核心构建块，它们通常代表应用程序中的各种对象，例如服务、数据访问对象（DAO）、控制器等。
【Spring框架全系列】方法注解@Bean的使用
冲击大厂之路!!!
05-03 9166
【Spring框架全系列】方法注解@Bean的使用；
@Bean注解的使用和详解
热门推荐
学源客的博客
03-16 5万+
@Bean：Spring的@Bean注解用于告诉方法，产生一个Bean对象，然后这个Bean对象交给Spring管理。产生这个Bean对象的方法Spring只会调用一次，随后这个Spring将会将这个Bean对象放在自己的IOC容器中。 SpringIOC 容器管理一个或者多个bean，这些bean都需要在@Configuration注解下进行创建，在一个方法上使用@Bean注解就表明这个方法需...
@bean 使用示例
最新发布
10-18
下面是一个简单的`@Bean`使用示例： ```java import org.springframework.beans.factory.annotation.Bean; import org.springframework.beans.factory.annotation.Configuration; @Configuration public class ...
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值