Spring 更简单的读取和存储对象

最新推荐文章于 2024-08-06 23:51:38 发布

Lockey-s

最新推荐文章于 2024-08-06 23:51:38 发布

阅读量400

点赞数 5

分类专栏： JavaEE 文章标签： spring java jvm Bean 属性注入

本文链接：https://blog.csdn.net/sjp151/article/details/126759224

版权

JavaEE 专栏收录该内容

28 篇文章 0 订阅

订阅专栏

Spring 更简单的读取和存储对象

存储 Bean 对象
使用五大类注解实现
使用 Bean 注解来实现

存储 Bean 对象

通过注解，来实现更简单的存储和读取对象。但必须要配置扫描路径，就是在配置文件当作添加 content:component-scan：

<?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.beans"></content:component-scan>
</beans>

意思就是，当前要存储的对象是在 com.beans 包下的对象。

使用五大类注解实现

五个注解如下：

Controller 控制器
Service 服务
Repository 仓库
Configuration 配置
Component 组件

Controller

就像之前存储的话，是要在配置文件当中来实现注入，现在直接通过 Controller 就可以了：

@Controller
public class blog {

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

这样就完成了对象的注入，使用原始的读取方式读取对象：

public class Test1 {

    public static void main(String[] args) {
        //得到上下文对象
        ApplicationContext context = new ClassPathXmlApplicationContext("spring-config.xml");
        //得到 bean
        Blog blog = context.getBean("blog", Blog.class);
        //使用 bean
        blog.sayHi();
    }
}

运行结果如下：
在这里插入图片描述
但要注意的是，对象所在的包，只能是在配置文件的包下面。

Service

使用 Service 注解：

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

代码：

public class Test1 {

    public static void main(String[] args) {
        //得到上下文对象
        ApplicationContext context = new ClassPathXmlApplicationContext("spring-config.xml");
        //得到 bean
        UserService userService = context.getBean(UserService.class);
        //使用 bean
        userService.sayHi();
    }
}

运行结果如下：
在这里插入图片描述

Repository

使用 Repository 注解：

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

代码如下：

public class Test1 {

    public static void main(String[] args) {
        //得到上下文对象
        ApplicationContext context = new ClassPathXmlApplicationContext("spring-config.xml");
        //得到 bean
        UserRepository userRepository = context.getBean(UserRepository.class);
        //使用 bean
        userRepository.sayHi();
    }
}

运行结果如下：
在这里插入图片描述

Configuration

使用 Configuration 注解，要注意的是，千万不要把 Configuration 写成 Configurable：

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

代码如下：

public class Test1 {

    public static void main(String[] args) {
        //得到上下文对象
        ApplicationContext context = new ClassPathXmlApplicationContext("spring-config.xml");
        //得到 bean
        UserConfiguration userConfiguration = context.getBean(UserConfiguration.class);
        //使用 bean
        userConfiguration.sayHi();
    }
}

运行结果如下：

在这里插入图片描述

Component

通过 Component 注解来注入对象：

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

代码如下：

public class Test1 {

    public static void main(String[] args) {
        //得到上下文对象
        ApplicationContext context = new ClassPathXmlApplicationContext("spring-config.xml");
        //得到 bean
        UserComponent userComponent = context.getBean(UserComponent.class);
        //使用 bean
        userComponent.sayHi();
    }
}

运行结果如下：
在这里插入图片描述

为什么需要五大类注解

明明每个注解都能实现类的注入，那为什么还需要五个呢？因为这就涉及到软件工程方面的知识了，一个软件至少会分为一下四层：
在这里插入图片描述

Configuration 就是配置层：关于当前项目中的所有配置，都会写在这个文件夹里。
Controller 就是控制层：就是前端参数校验，主要就是校验前端数据的合理性和正确性。
Service 就是服务层，负责数据的组装和接口调用。更直白的说，服务器九四 “牵线搭桥” 让程序去调用对应的功能/接口/服务。
Repository 叫做仓库，但其实是数据持久层，也叫做 Dao 层，就是对数据进行持久化操作（对数据库进行增删改查操作）。

一个软件至少需要这四层，那么这五个类注解，可以更直观的让程序员知道当前类的用途。可以让代码的可读性更高。

五大类中间的关系

查看 Configuration 的源码，发现父类是 Component ：
在这里插入图片描述
查看 Controller 的源码，发现仍然是依靠 Component 来实现的：

查看 Repository 源码，还是依靠 Component 来实现的：

查看 Service 的源码，发现还是一样：

也就是说，这些注解的作用是一样的，但是对于开发人员的不一样的。Component 是所有类的父类。

Spring 使用五大类注解，生成 bean name：通过查看 AnnotationBeanNameGenerator.class 文件：
在这里插入图片描述
当然，字节码文件看起来是很累的，通过 gitee 里面可以找到源文件。在全站搜索 spring frame 相关项目就可以找到了：

然后就是源码了：

在 IDEA 里面查看 class 文件，找到名字相关的方法：

然后发现又调用了这个代码：
在这里插入图片描述
然后再次进入：

然后找到文件位置：

再往上找，发现是 JDK 里面的：

所以，只要看这段代码就知道为什么了：

也就是只有第一个字母是大写的，类名才是小写，当前两个字母都是大写的时候，返回的就是原类名了。

使用 Bean 注解来实现

听过 Bean 来注入，就是 Bean 方法注解。Bean 注解，是针对方法实现的，只能添加在方法上面：

先创建 User 对象：

public class User {
    private int id;
    private String name;

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

    public int getId() {
        return id;
    }

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

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

然后添加方法

@Component
public class UserBeans {
    @Bean
    public User user1() {
        User user = new User();
        user.setId(1);
        user.setName("张三");
        return user;
    }
}

这样就完成了对象的注入。

获取对象

public class Test1 {

    public static void main(String[] args) {
        //得到上下文对象
        ApplicationContext context = new ClassPathXmlApplicationContext("spring-config.xml");
        //得到 bean
        User user = context.getBean("user1", User.class);
        //使用 bean
        System.out.println(user);
    }
}

运行结果如下：
在这里插入图片描述

获取 Bean 对象

获取 bean 对象也叫做对象装配，是把对象从容器中取出来放到某个类中，有时候也叫对象注入。对象装配的实现方法有三种：

属性注入

通过 @Autowired 注入：

@Controller
public class UserController {
    @Autowired
    private UserService userService;
    public void sayHi() {
        userService.sayHi();
    }
}

就是把 UserService 类注入，然后就可以使用类了：

public class Test1 {

    public static void main(String[] args) {
        //得到上下文对象
        ApplicationContext context = new ClassPathXmlApplicationContext("spring-config.xml");
        //得到 bean
        UserController userController = context.getBean(UserController.class);
        //使用 bean
        userController.sayHi();
    }
}

运行结果如下：
在这里插入图片描述

构造方法注入

通过一个构造方法来实现属性注入：

@Controller
public class UserController {
    private UserService userService;

    @Autowired
    public UserController(UserService userService) {
        this.userService = userService;
    }

    public void sayHi() {
        userService.sayHi();
    }
}

运行结果如下：
在这里插入图片描述
如果类当中，只有一个构造方法，那么 @Autowird 可以省略。

Setter 注入

通过 Setter 方法注入：

@Controller
public class UserController {
    private UserService userService;
    @Autowired
    public void setUserService(UserService userService) {
        this.userService = userService;
    }
    public void sayHi() {
        userService.sayHi();
    }
}

运行结果如下：
在这里插入图片描述

属性注入和构造方法注入和 Setter 注入的区别

属性注入特点是写法简单，但是通用性不好，只能运行在 IoC 容器下，如果是非 IoC 容器的话，就会出现问题。
构造方法注入，通用性更好。因为构造方法的优先级是最高的。确保使用注入对象之前，对象一定初始化过了。当构造方法注入参数太多时，就需要检查自己的代码是否符合单一设计原则的规范了。构造方法注入，也是 Spring 推荐的注入方法。
Setter 注入是早期 Spring 版本推荐的写法，但是通用性没有构造方法注入通用，因为只有一个参数。

@Resource 和 @Autowired 的区别

相同点：都可以完成对象的注入。
不同点：
a）出身不同，@Resource 来自于 JDK，@Autowired 是由 Spring 框架提供的。

b）@Autowired 支持属性注入，构造方法注入和 Setter 注入，而 @Resource 不支持构造方法注入。

c）支持的参数不同：@Resource 支持更多的参数设置，比如 name、type 设置。而 @Autowired 只支持 required 参数设置。

重命名 Bean

比如我们有多个 User 对象，那么获取 Bean 的时候。就要通过方法名获取了，但是如果重命名对象。也可以得到，就是在 Bean 后面加个括号，里面重命名就好了：

@Component
public class UserBeans {
    @Bean(name = "userInfo")
    public User user1() {
        User user = new User();
        user.setId(1);
        user.setName("张三");
        return user;
    }
}

代码如下：

public class Test1 {

    public static void main(String[] args) {
        //得到上下文对象
        ApplicationContext context = new ClassPathXmlApplicationContext("spring-config.xml");
        //得到 bean
        User user = context.getBean("userInfo", User.class);
        //使用 bean
        System.out.println(user);
    }
}

运行结果如下：
在这里插入图片描述
如果是重命名多个名字的时候，就用大括号把名字括起来：

@Component
public class UserBeans {
    @Bean(name = {"userInfo", "user1"})
    public User user1() {
        User user = new User();
        user.setId(1);
        user.setName("张三");
        return user;
    }
}

@Bean 的命名规则： 当没有设置 name 属性的时候，那么 bean 默认的名称就是方法名。当设置了 name 属性之后，只能通过重命名的那么属性对应的值类获取。也就是重命名之后，再使用方法名就获取不到 bean 对象了。

把 Bean 对象注入到其他类

我们把 User 对象（有多个对象）注入到 Controller 当中，看看能不能实现对象的使用：

@Controller
public class UserController {
    @Autowired
    private User user;
    public void sayHi() {
        System.out.println("User-> " + user);
    }
}

然后通过 UserController 来使用对象：

public class Test1 {

    public static void main(String[] args) {
        //得到上下文对象
        ApplicationContext context = new ClassPathXmlApplicationContext("spring-config.xml");
        //得到 bean
        UserController userController = context.getBean(UserController.class);
        //使用 bean
        userController.sayHi();
    }
}

运行结果如下：
在这里插入图片描述
报错提示说，User 对象被注入了两个。一个是 userInfo，一个是 user2。因为 Autowired 在注入的时候，是先根据类型来查找，然后就会去找 User 对象，找 User 类型的对象在 Spring 当中有没有。然后就找到了两个，然后就报错。

一个对象注入多次的问题

就是上面这种情况，在扫描的时候，发现了多个对象。解决方案如下：

精确的描述 bean 的名称，就是将注入的名称写对。比如说我们注入 user1 ：

@Controller
public class UserController {
    @Autowired
    private User user1;
    public void sayHi() {
        System.out.println("User-> " + user1);
    }
}

运行结果如下：
在这里插入图片描述

使用 Resource 注解，Resource 是来自 JDK 的，Resource 有 name 属性，就是类似于重命名：

@Controller
public class UserController {
    @Resource(name = "user1")
    private User user;
    public void sayHi() {
        System.out.println("User-> " + user);
    }
}

运行结果如下：
在这里插入图片描述

通过 Autowired 搭配 Qualifier ：

@Controller
public class UserController {
    @Autowired
    @Qualifier("user1")
    private User user;
    public void sayHi() {
        System.out.println("User-> " + user);
    }
}

运行结果如下：
在这里插入图片描述

Lockey-s

关注

5
点赞
踩
3

收藏

觉得还不错? 一键收藏
打赏
6
评论
Spring 更简单的读取和存储对象

文章讲解了存储 Bean 对象，通过五大类注解实现对对象的存储，还有通过 Bean 注解来实现对对象的存储。从属性注入，构造方法注入，Setter注入来玩出注入。还有把 Bean 对象注入到其他类。一个对象诸如多次的问题
复制链接

扫一扫