【Spring】使用注解存储Bean对象

最新推荐文章于 2024-08-09 13:57:32 发布

奋斗べ青年.

最新推荐文章于 2024-08-09 13:57:32 发布

阅读量812

点赞数 2

分类专栏： Spring 文章标签： spring java 数据库

本文链接：https://blog.csdn.net/m0_73067372/article/details/132098428

版权

Spring 专栏收录该内容

11 篇文章 1 订阅

订阅专栏

一、配置扫描路径（使用注解的方式存对象的前提）

上一篇博客中，说到的存储Bean对象的方式，每创建一个类都需要我们自己手动注入到spring中，这个过程比较繁琐。

Spring还有一种注入对象的方式，也就是使用注解。当我们学习使用Spring时，想要实现一个功能，首先需要考虑的是有没有实现对应功能的注解。下面我们来了解一下如何使用注解的方式来存储Bean对象。

一、配置扫描路径（使用注解的方式存对象的前提）

首先创建一个Spring项目，然后在resources包中创建一个spring-config.xml文件，然后向这个文件中配置下面的代码(Bean对象的扫描路径)，这一步非常重要，如果这里出现问题，那么后续的操作都是纸上谈兵。这一步是使用注解向Spring中储存对象的基石（前提）。

spring-config.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"
     xmlns:content="http://www.springframework.org/schema/context"
     xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">
     <content:component-scan base-package="com.java.demo"></content:component-scan>
</beans>

上述的代码中<content:component-scan base-package="com.java.demo"></content:component-scan>是用来配置Bean的扫描根路径的。其中的base-package属性的值，就是配置的扫描路径。只有在这些目录中的类才会被扫描是否添加了注解，如果添加了注解，就将这些类存放到IoC容器中。

像下图中设置的扫描路径为com.java.demo，那么在扫描的时候，就会扫描这个目录中的所有类，并且包括这个目录中的子目录中的类也会扫描。所以我们在设置扫描路径的时候，尽可能的设置的详细一点，就好比我们设置的扫描路径为com，那么在扫描时，会将com中的所有类包括com目录中的子目录中的类也扫描一遍，这就会导致在启动类的时候工作量比较大，启动时间比较长。

二、使用类注解存储Bean对象

想要将对象存储在Spring中，有两种注解类型可以实现

类注解：@Controller（控制器）、@Service（服务）、@Repository（仓库）、@Component（组件）、@Configuration（配置）。
方法注解：@Bean

1、使用五大类注解存储Bean对象

1️⃣我们先使用@Controller来存储Bean对象，代码如下

package com.java.demo;

import org.springframework.stereotype.Controller;

@Controller
public class User {
    public void sayHi(){
        System.out.println("hello User.");
    }
}

我们类的创建需要在我们设置的扫描路径下，这样启动类获取对象时，可以扫描到这个User类使用了@Controller注解，就会将这个Bean对象存储到spring中

下面是获取IoC容器中的Bean对象，这个写法还是和上一个博客中写的获取Bean对象的方法一样，通过依赖查找来获取对象，默认情况下，Bean对象名称是以大驼峰方式命名类的小写形式（也就是Bean对象名默认为小驼峰形式）。

import com.java.demo.User;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class App {
    public static void main(String[] args) {
        //1、得到容器对象
        ApplicationContext context = new ClassPathXmlApplicationContext("spring-config.xml");
        //2、得到Bean对象
            //这里获取Bean对象时，使用的对象名称是以大驼峰形式命名的类的小写形式（小驼峰）
        User user= context.getBean("user",User.class);
        //3、调用Bean方法
        user.sayHi();
    }
}

2️⃣使用@Service，@Repository，@Component，@Configuration注解来存储Bean对象，代码如下。

package com.java.demo;

import org.springframework.stereotype.Service;

@Service
public class UserService {
    public void sayHi(){
        System.out.println("hi,UserService.");
    }
}

package com.java.demo;

import org.springframework.stereotype.Repository;

@Repository
public class UserRepository {
    public void sayHi(){
        System.out.println("hello UserRepository .");
    }
}

package com.java.demo;

import org.springframework.context.annotation.Configuration;

@Configuration
public class UserConfiguration {
    public void sayHi(){
        System.out.println("hello userConfiguration .");
    }
}

package com.java.demo;

import org.springframework.stereotype.Component;

@Component
public class UserComponent {
    public void sayHi(){
        System.out.println("hello userComponent .");
    }
}

import com.java.demo.*;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class App2 {
    public static void main(String[] args) {
        //1、得到容器对象
        ApplicationContext context = new ClassPathXmlApplicationContext("spring-config.xml");
        //2、得到Bean对象
        UserRepository userRepository= context.getBean("userRepository", UserRepository.class);
        //3、调用Bean方法
        userRepository.sayHi();

        UserComponent userComponent= context.getBean("userComponent", UserComponent.class);
        userComponent.sayHi();

        UserConfiguration userConfiguration= context.getBean("userConfiguration", UserConfiguration.class);
        userConfiguration.sayHi();

        UserService userService= context.getBean("userService", UserService.class);
        userService.sayHi();
    }
}

可以看到只要这些使用了五大类注解的类在我们设置的扫描路径中，那么获取这些Bean对象时都会获取成功。

3️⃣但是如果我们创建的类，没有在扫描路径下，那么获取Bean对象时，就会失败。

这里我们创建一个student类，将其放在com目录下，来观察出现的结果。我们指定的扫描路径为com.java.demo.这里创建的student在com下，但是和Java目录同级，所以没有在扫描路径中。

package com;

import org.springframework.stereotype.Component;

@Component
public class Student {
    public void sayHi(){
        System.out.println("hello Student");
    }
}

4️⃣使用五大类注解存储Bean和使用XML格式存储Bean是可以混合使用的。

这种使用场景一般是，就像上述的student类，他在com目录下，而扫描路径是com.java.demo。想要使用这个Bean对象，如果使用注解的方式，就需要将扫描路径设置为com。这样扫描范围就非常的大，类启动的时候就会很慢。这种情况我们就可以使用XML格式存储Bean，其他的类还是使用类注解的方式存储Bean，扫描路径不变。

2、为什么要这么多的类注解？

上述进行了五大类注解的使用，最终结果都是将Bean对象存储到spring中，那么为什么需要这么多的注解呢？

这些注解都是通过在类上添加注解来告诉Spring容器它们的作用和职责，从而实现依赖注入和自动装配。它们使得开发人员能够更方便地管理和组织代码，并提供了灵活的配置和扩展性。

@Controller：（控制器）将类标记为控制器组件，校验用户请求数据的正确性。
@Service：（服务）将类标记为业务逻辑组件，服务、编排和调度具体执行方法，不会直接进行操作，根据请求判断具体调用哪个方法。
@Repository：（数据持久层）将类标记为数据访问组件，用于直接与数据库进行交互
@Component：（工具类层）将类标记为Spring容器的组件，为整个项目存放一些需要使用的组件，但是又和其他层没有什么实际交互。
@Configuration：将类标记为配置类（项目中的一些配置）

上述的五大类注解也对应这个Java项目标准分层的层级，也就是说我们在写Java项目的时候需要按照这个分层类型来创建包和类，使用不同的注解，表示了这个类的作用，让程序员更好的管理程序代码。

2.1、五大类注解之间的关系

这些注解的作用都是相同的，都是将对象注入到对象中，所以他们之间一定存在一些共性的，我们来了解一下他们直接的关系。

可以看到五大类注解中，@Service（服务），@Repository（仓库），@Configuration（配置），@Controller（控制器）是基于@Component（组件）来实现的，这四个注解都是@Component的扩展。也可以理解为@Component是这个四个类注解的父类。

3、获取Bean对象时的默认命名规则

上述的代码中获取Bean对象的操作中，我们使用的对象名为小驼峰的形式，也就是类名的第一个字符小写其他字符不变形式。这种形式是使用类注解存储Bean对象之后，在获取对象时的默认形式，但是这个默认形成能够正常使用的前提是，这个类名是按照大驼峰的形式命名的，如果出现其他的类的命名方式，这个默认的用法就不能获取到Bean对象了。

下面我们使用一个列子来说明，我们创建一个UConfig类（不是按照大驼峰的形式命名的类），放在com.java.demo扫描路径下。然后来通过小驼峰的方式来命名Bean对象并获取（uConfig）观察结果。

package com.java.demo;

import org.springframework.context.annotation.Configuration;

@Configuration
public class UConfig {
    public void sayHi(){
        System.out.println("hello UConfig");
    }
}

使用小驼峰的形式命名对象名获取不到Bean对象，但是直接使用类名的方式可以作为对象名获取到Bean对象。

UConfig uConfig = context.getBean("UConfig", UConfig.class);

这里我们就需要看一下命名规则的源码了

按两下Shift键，idea就会弹出一个全局搜索的框，然后输入BeanName（查找对象的命名规则），然后点击圈出来的这个类。

进入AnnotationBeanNameGenerator类之后，找到下面的方法，他表示的就是生成BeanName

但是这个方法中并没有明确的写出Bean的命名，他最后调用的方法为创建默认对象名。进入这个方法继续查看。

进入decapitate方法，继续查看。这个方法给出了默认命名的细节实现。

如果类名的长度大于1并且满足第一个与第二个字符为大写，则构造的默认BeanName为原类名，按照大驼峰的规则命名的类名（第一个字符为大写，第二个字符为小写），构造的默认BeanName为原类名的小驼峰形式（第一个字符小写，其他字符不变）。

我们点击追踪，来查看一下这个默认命名的方法的实现，他是有JDK实现的。

✨ 总结：BeanName的规范命名规则

如果类名不存在或类名为空，BeanName为原类名
如果类名长度超过1，并且第一个与第二个字符为大写，则BeanName为原类名
类名按照大驼峰命名，也就是第一个字符大写，第二个字符小写，BeanName为原类名的小驼峰形式。

三、使用方法注解来存储Bean对象

1、使用方法注解@Bean需要注意的事项

我们说到类注解的时候，只需要将类注解加在类上就可以直接使用依赖查找的方式获取Bean对象，但是这里的方法注解的使用和类注解存在较大的差异。

1️⃣使用方法注解@Bean，需要方法的返回值是一个对象。

2️⃣方法注解@Bean不能单独使用，需要和五大类注解搭配使用。

这里我们通过一个示例来了解一下，创建一个普通的ArticleInfo（文章实体）类。给这个类并没有添加五大类注解。

package com.java.demo.model;

import java.time.LocalDateTime;

public class ArticleInfo {
    private int id;
    private String title;
    private String content;
    private LocalDateTime createTime;
    public void setId(int id) {
        this.id = id;
    }
    public void setTitle(String title) {
        this.title = title;
    }
    
    public void setContent(String content) {
        this.content = content;
    }
    
    public void setCreateTime(LocalDateTime createTime) {
        this.createTime = createTime;
    }

    @Override
    public String toString() {
        return "ArticleInfo{" +
                "id=" + id +
                ", title='" + title + '\'' +
                ", content='" + content + '\'' +
                ", createTime=" + createTime +
                '}';
    }
}

这里写一个伪代码，因为给文章实体类没有添加五大类注解，所以我们没有办法从容器中获取对象，这里我们自己在ArticleInfo方法中实例了一个对象，为其设置属性的值。给ArticleInfo方法添加@Bean注解。

package com.java.demo;

import com.java.demo.model.ArticleInfo;
import org.springframework.context.annotation.Bean;

import java.time.LocalDateTime;

public class Articles {
    @Bean
    public ArticleInfo ArticleInfo(){
        //伪代码
        ArticleInfo articleInfo = new ArticleInfo();
        articleInfo.setId(1);
        articleInfo.setTitle("今天周几？");
        articleInfo.setContent("今天周一");
        articleInfo.setCreateTime(LocalDateTime.now());
        return articleInfo;
    }
}

获取bean对象

import com.java.demo.model.ArticleInfo;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class App {
    public static void main(String[] args) {
        //1、得到容器对象
        ApplicationContext context = new ClassPathXmlApplicationContext("spring-config.xml");
        //2、得到Bean对象
        ArticleInfo articleInfo = context.getBean("ArticleInfo", ArticleInfo.class);
        //3、调用Bean方法
        System.out.println(articleInfo.toString());
    }
}

❓❓❓ 为什么方法注解不能和类注解一样，添加了之后就可以直接获取对象？

❗❗❗原因在与在我们创建的扫描路径中，存在很多类，每个类里面又存在很多方法，如果按照类注解的方式对目录中的方法进行扫描，那么程序的执行效率就会非常慢，所以规定在使用@Bean方法注解的时候，需要添加上类注解，这就相当于我们了解五大类注解的时候设置扫描路径是一个道理，精确扫描范围，提高程序的效率。

下面我们对Articles类添加一个类注解，表示扫描这个对象中的方法。再次执行扫描到添加了@Bean注解的方法的返回值就会被保存在容器中了，获取对象就会成功。

package com.java.demo;

import com.java.demo.model.ArticleInfo;
import org.springframework.context.annotation.Bean;
import org.springframework.stereotype.Component;

import java.time.LocalDateTime;

@Component
public class Articles {
    @Bean
    public ArticleInfo ArticleInfo(){
        //伪代码
        ArticleInfo articleInfo = new ArticleInfo();
        articleInfo.setId(1);
        articleInfo.setTitle("今天周几？");
        articleInfo.setContent("今天周一");
        articleInfo.setCreateTime(LocalDateTime.now());
        return articleInfo;
    }
}

3️⃣我们使用方法注解@Bean将对象存入到容器中，我们在获取对象时默认的对象名为方法名。

2、添加@Bean注解的方法的重命名

使用依赖查找获取使用方法注解@Bean存储的对象时，传入的对象名默认的情况下为方法名，虽然说这样获取没有问题，但是在一个项目中的方法起名时有getXXX或者setXXX，用这种默认的方式获取对象，总是看起来不是很舒服。所以这里我们要说到重命名的问题。

@Bean注解是可以设置参数的，设置name属性就可以给存储的对象设置一个别名。

package com.java.demo;

import com.java.demo.model.ArticleInfo;
import org.springframework.context.annotation.Bean;
import org.springframework.stereotype.Component;

import java.time.LocalDateTime;

@Component
public class Articles {
    @Bean("abc")
    public ArticleInfo ArticleInfo(){
        //伪代码
        ArticleInfo articleInfo = new ArticleInfo();
        articleInfo.setId(1);
        articleInfo.setTitle("今天周几？");
        articleInfo.setContent("今天周一");
        articleInfo.setCreateTime(LocalDateTime.now());
        return articleInfo;
    }
}




import com.java.demo.model.ArticleInfo;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class App {
    public static void main(String[] args) {
        //1、得到容器对象
        ApplicationContext context = new ClassPathXmlApplicationContext("spring-config.xml");
        //2、得到Bean对象
        ArticleInfo articleInfo = context.getBean("abc", ArticleInfo.class);
        //3、调用Bean方法
        System.out.println(articleInfo.toString());
    }
}

✨重命名@Bean的几种方式

//方式一
@Bean("abc");
//方式二
@Bean(name="abc")
//方式三
@Bean(value="abc")
//方式四:支持指定多个名称
@Bean(name={"abc","ddd","ccc"})
//方式五
@Bean(value={"aabc","ddd","eee"})
//方式六
@Bean({"aaa","bbb"})

2.1、需要注意细节

1️⃣当我们给Bean重命名了之后，就不能在使用Bean默认的对象名，也就是使用方法名获取对象，这个时候就会报错。

2️⃣在对Bean重命名时，不要使用当前类（以大驼峰形式命名的类）的小驼峰形式给Bean重命名，因为当前类添加了类注解，获取对象的时候默认是当前类名的小驼峰形式。当你获取Bean对象的时候，对象的名称重复了，就会报错。

3️⃣当我们对同一个类中多个方法返回的对象Bean重命名时，使用了相同的名字，这个时候程序执行的时候，从上往下执行，只会将第一个方法返回的Bean存储到Spring中，之后的相同名称的Bean就不会在存储到Spring中了，容器会忽略掉。

4️⃣当我们对不同类中的方法返回的对象Bean重命名时，使用了相同的名字，这个时候想要指定某个类中的方法先执行，我们使用@Order注解来控制类加载的顺序，在@Order()中设置的参数越大，表示当前类的加载权重越高，越先被加载，进而影响到类中方法的加载，也就影响到Spring中存放的是那个Bean了。

5️⃣在Spring中对一个方法添加了@Bean注解，那么这个方法不能设置参数。

奋斗べ青年.

关注

2
点赞
踩
3

收藏

觉得还不错? 一键收藏
0
评论
【Spring】使用注解存储Bean对象

一、配置扫描路径（使用注解的方式存对象的前提）二、使用类注解存储Bean对象1、使用五大类注解存储Bean对象2、为什么要这么多的类注解？2.1、五大类注解之间的关系3、获取Bean对象时的默认命名规则三、使用方法注解来存储Bean对象1、使用方法注解@Bean需要注意的事项2、添加@Bean注解的方法的重命名2.1、需要注意细节
复制链接

扫一扫

专栏目录