Spring 中存取 Bean 的相关注解

一、五大类注解

在Spring中，想要将Bean存储到Spring中，一共有两种注解类型可以实现：

一种是类注解，其包括@Controller,@Service,@Repository,@Component,@Configuration;

另一种则是方法注解，其仅有@Bean

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

1.1@Controller(控制器储存)

使⽤ @Controller 存储 bean 的代码如下所示：

package com.java.demo;
import org.springframework.stereotype.Controller;

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

我们再在启动类中，简单读取一下存入的对象

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) {
        ApplicationContext context = new
                ClassPathXmlApplicationContext("srping-config.xml");
        User user = context.getBean("user", User.class);
        user.sayHi();
    }
}

运行结果如下:

1.2@Service(服务存储)

使⽤ @Service 存储 Bean 的代码如下所示：

@Service
public class UserService {

    public int add(){
        System.out.println("hi UserService add");
    }
}

读取 bean 的代码：

public class Test {

    public static void main(String[] args) {
        ApplicationContext context = new
                ClassPathXmlApplicationContext("spring-config.xml");
        UserService userService =
                context.getBean("userService", UserService.class);
        userService.add();
    }
}

运行结果如下:

1.3@Repository(仓库存储)

使用@Repository存储Bean的代码如下：

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

读取Bean的代码:

public class Test {

    public static void main(String[] args) {
        ApplicationContext context = new
                ClassPathXmlApplicationContext("spring-config.xml");
        UserRepository userRepository =
                context.getBean("userRepository", UserRepository.class);
        userRepository.add();
    }
}

运行结果如下:

1.4@Component(组件存储)

使用@Component组件存储Bean的代码如下:

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

读取Bean的代码:

public class Test {

    public static void main(String[] args) {
        ApplicationContext context = new
                ClassPathXmlApplicationContext("spring-config.xml");
        UserComponent userComponent =
                context.getBean("userComponent", UserComponent.class);
        userComponent.add();
    }
}

运行结果如下:

1.5@Configuration(配置存储)

使用@Configuration存储Bean的代码如下：

@Configurable
public class UserConfiguration {
    public void add(){
        System.out.println("Hi Configuration add");
    }
}

读取Bean的代码:

public class Test {

    public static void main(String[] args) {
        ApplicationContext context = new
                ClassPathXmlApplicationContext("spring-config.xml");
        UserConfiguration userConfiguration =
                context.getBean("userConfiguration", UserConfiguration.class);
        userConfiguration.add();
    }
}

运行结果如下:

2、五大类注解小结

2.1为什么要这么多类注解

让代码的可读性更高,让程序员能直观的判断当前类的用途

Spring框架中有很多类注解，每个注解都有其特定的作用。这些注解使得开发人员能够更加方便地配置和管理应用程序。以下是其中一些注解的用途：

• @Component：用于将某个类标记为组件，方便自动扫描和注册为Bean。

• @Controller：用于标记控制器类，处理HTTP请求，并返回相应结果。

• @Service：用于标记服务类，对业务逻辑进行封装，通常被Controller层调用。

• @Repository：用于标记仓库类，封装对数据的访问和操作，通常被Service层调用。

• @Configuration：表明该类是Spring配置类，在其中定义Bean的创建和配置规则。

这些注解使得Spring框架变得更加灵活、可扩展、易用。开发人员可以根据需要选择合适的注解来达到自己的目的。

2.2 五大类注解之间的关系

Spring框架中，常用注解可以归为五大类，分别是：

1. @Component注解及其衍生注解：包括@Controller、@Service、@Repository等。这些注解用于在Spring容器中注册Bean。
2. @Configuration注解及其衍生注解：包括@Bean注解。这些注解用于在Spring容器中声明和配置Bean。
3. @Autowired注解及其衍生注解：包括@Qualifier、@Resource、@Inject等。这些注解用于进行Bean的自动注入。
4. @Value注解及其衍生注解：包括@PropertySource、@ConfigurationProperties等。这些注解用于进行配置属性的注入和读取。
5. @Transactional及其衍生注解：包括@Transactional、@TransactionalEventListener等。这些注解用于声明事务和监听事务事件。

这些注解之间的关系可以总结为：

1. @Component及其衍生注解是用于定义Bean的注解，可通过自动扫描或手动配置的方式注册Bean。
2. @Configuration及其衍生注解用于声明和配置Bean。
3. @Autowired及其衍生注解用于进行Bean的自动注入，可以与@Component和@Configuration注解一起使用。
4. @Value及其衍生注解用于进行配置属性的注入和读取。
5. @Transactional及其衍生注解用于声明事务和监听事务事件，通常用于@Service和@Repository注解的类。

总的来说，这些注解是相互关联的，可以结合使用，达到更加灵活和高效的开发效果。

二、方法注解

1.方法注解的存储

1.1 @Bean注解的使用

我们先创建一个用户类

public class User {

    public 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) {
        Id = id;
    }

    public String getName() {
        return name;
    }

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

与类注解不同，类注解是添加到某个类上的；而方法注解自然就是添加到某个方法上的

之后再创建一个方法类,我们要注意在定义方法Bean的时候也要定义五大类注解,因为@Bean要配合类注解才能将对象正常的存储到Spring容器中才能获取到

@Component
public class Users {

    @Bean()
    public User getUser(){
        User user = new User();
        user.setId(66);
        user.setName("竹筒子");
        return user;
    }
}

public class test {
    public static void main(String[] args) {
        ApplicationContext context = new
                ClassPathXmlApplicationContext("spring-config.xml");
        User user = (User) context.getBean("getUser");
        System.out.println(user.toString());
    }
}

1.2 @Bean方法的重命名

可以通过设置 name 属性给 Bean 对象进⾏重命名操作，如下图所示：

Bean命名规则,当没有设置name属性时,那么bean默认的名称就是方法名,当设置了name属性后,只能通过重命名的name属性对应的值获取,也就是说重命名后,再使用方法名就获取不到Bean对象了.此外要注意Bean name是区分大小写的

2.方法注解的获取

在Spring中获取Bean对象也叫做对象装配或者对象注入

从Spring中获取Bean对象的实现方法有以下三种：

属性注入，Setter方法注入，以及构造方法注入

2.1 属性注入

属性注⼊是使⽤ @Autowired 实现的，将 Service 类注⼊到 Controller 类中。
Service 类的实现代码如下：

@Controller
public class UserController {

    @Autowired
    private UserService userService;
    public User getUser(){
        return userService.getUser();
    }
}

public class Test {

    public static void main(String[] args) {
        ApplicationContext context = new
                ClassPathXmlApplicationContext("spring-config.xml");
        UserController userController=
                context.getBean("userController", UserController.class);
        userController.Hi();
    }
}

属性注入的优缺点:

属性注入的优点在于，足够的简单以及简洁

缺点在于只能用于IOC容器，同时无法注入被final修饰的对象，而且较容易违背单一性原则

2.2 Setter注入

Setter注入的实现也需要依赖@Autowired进行实现，不过其主要针对setter方法进行

@Controller
public class UserController {

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

    public User getUser(){
        return userService.getUser();
    }
}

Setter注入的优缺点:

Setter注入的优点在于，其较不容易违背单一性原则

缺点在于，不如属性注入来的简介，同时无法注入被final修饰的对象

2.3 构造方法注入

与前面类似，构造方法注入从名字上看，其实就是在构造器上添加@Autowired注解

 
@Controller
public class StuController {
    private Stu stu;
 
    @Autowired
    public StuController(Stu stu) {
        this.stu = stu;
    }
 
    public void sayHi(){
        System.out.println(stu);
    }
}

**由于构造器注入是比较后面出的，其实它也有一定的智能性：当我们只存在一个构造器的时候，我们可以选择不添加@Autowired，但是当有多个构造器的时候我们必须手动添加@Autowired来指定构造器来进行注入 **

构造方法注入优缺点:

优点：构造器是Spring推荐的注入方式，同时构造器注入的通用性较强，能够注入被final修饰的对象

缺点在于不如属性注入来的简介及方便

三、总结

1.三种注⼊优缺点分析

• 属性注⼊的优点是简洁，使⽤⽅便；缺点是只能⽤于 IoC 容器，如果是⾮ IoC 容器不可⽤，并且只有在使⽤的时候才会出现 NPE（空指针异常）
• Setter ⽅式是 Spring 前期版本推荐的注⼊⽅式，但通⽤性不如构造⽅法，所有 Spring 现版本已经推荐使⽤构造⽅法注⼊的⽅式来进⾏类注⼊了
• 构造⽅法注⼊是 Spring 推荐的注⼊⽅式，它的缺点是如果有多个注⼊会显得⽐较臃肿，但出现这种情况你应该考虑⼀下当前类是否符合程序的单⼀职责的设计模式了，它的优点是通⽤性，官方推荐,在使⽤之前⼀定能把保证注⼊的类不为空

2.Resource和@Autowired的区别

当我们在进行类注入的时候，除了使用@Autowired的时候，我们也可以使用@Resource进行注入

@Resource的用法与@Autowired相同

1. @Autowired来自Spring，而@Resource来自JDK的注解
2. @Resource支持更多的参数设置，可以添加name设置来根据名称获取Bean
3. @Resource不能用于构造函数注入