Spring中存取Bean的相关注解

ゞ浴缸里的玫瑰 2023-10-04 23:21 6阅读 0赞

**目录**

1. 将Bean存入Spring的相关注解

1.1 类注解

1.1.1 @Controller(控制器存储）

1.1.2 @Service(服务存储）

1.1.3 @Repository(仓库存储）

1.1.4 @Component(组件存储）

1.1.5 @Configuration(配置存储）

1.1.6 为什么要这么多类注解

1.2 方法注解

2.1 属性注入

2.1.1 属性注入的实现

2.1.2 属性注入的优缺点

2.2 Setter注入

2.2.1 Setter注入的实现

2.2.2 Setter注入的优缺点

2.3 构造器注入

2.3.1 构造器注入的实现

2.3.2 构造器注入的优缺点

2.4 @Resource：另一种注入关键字

2.4.1 @Resource的实现

2.4.2 @Resource和@Autowired的区别

--------------------

## 1. 将Bean存入Spring的相关注解 ##

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

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

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

--------------------

### 1.1 类注解 ###

#### 1.1.1 @Controller(控制器存储） ####

使用@Controller存取Bean的代码如下:

package demo.component.test;
    
    import org.springframework.stereotype.Controller;
    
    //将对象存储到Spring中
    @Controller
    public class UserController {
        public void print(String name){
            System.out.println(name);
        }
    }

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

package demo.component.test;
    import demo.component.test.UserController;
    import org.springframework.context.ApplicationContext;
    import org.springframework.context.support.ClassPathXmlApplicationContext;
    import org.springframework.stereotype.Component;
    
    @Component
    public class Main {
        public static void main(String[] args) {
            ApplicationContext context=new ClassPathXmlApplicationContext("spring-config.xml");
            UserController userController=(UserController) context.getBean("userController");
            userController.print("amagi");
        }
    }

--------------------

#### 1.1.2 @Service(服务存储） ####

使用@Service存储Bean的代码如下所示:

package demo.component.test;
    
    import org.springframework.stereotype.Service;
    
    //将对象存储到Spring中
    @Service
    public class UserService {
        public void print(String name){
            System.out.println(name);
        }
    }

我们再在启动类中进行代码的读取

package demo.component.test;
    import demo.component.test.UserController;
    import org.springframework.context.ApplicationContext;
    import org.springframework.context.support.ClassPathXmlApplicationContext;
    import org.springframework.stereotype.Component;
    
    @Component
    public class Main {
        public static void main(String[] args) {
            ApplicationContext context=new ClassPathXmlApplicationContext("spring-config.xml");
            UserService userService=(UserService) context.getBean("userService");
            userService.print("amagi");
        }
    }

--------------------

#### 1.1.3 @Repository(仓库存储） ####

package demo.component.test;
    
    import org.springframework.stereotype.Repository;
    
    @Repository
    public class UserRepository {
        public void print(String name){
            System.out.println("你干嘛");
        }
    }

在启动类中代码如下

package demo.component.test;
    import demo.component.test.UserController;
    import org.springframework.context.ApplicationContext;
    import org.springframework.context.support.ClassPathXmlApplicationContext;
    import org.springframework.stereotype.Component;
    
    @Component
    public class Main {
        public static void main(String[] args) {
            ApplicationContext context=new ClassPathXmlApplicationContext("spring-config.xml");
            UserRepository userRepository=context.getBean("userRepository",UserRepository.class);
            userRepository.print("你干嘛");
        }
    }

--------------------

#### 1.1.4 @Component(组件存储） ####

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

package demo.component.test;
    
    import org.springframework.stereotype.Component;
    
    @Component
    public class UserComponent {
        public void print(String name){
            System.out.println(name);
        }
    }

在启动类中代码如下:

package demo.component.test;
    import demo.component.test.UserController;
    import org.springframework.context.ApplicationContext;
    import org.springframework.context.support.ClassPathXmlApplicationContext;
    import org.springframework.stereotype.Component;
    
    @Component
    public class Main {
        public static void main(String[] args) {
            ApplicationContext context=new ClassPathXmlApplicationContext("spring-config.xml");
            UserComponent userComponent=context.getBean("userComponent",UserComponent.class);
            userComponent.print("梅狸猫");
        }
    }

--------------------

#### 1.1.5 @Configuration(配置存储） ####

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

package demo.component.test;
    
    import org.springframework.context.annotation.Configuration;
    
    @Configuration
    public class UserConfiguration {
        public void print(String name){
            System.out.println(name);
        }
    }

启动类代码如下：

package demo.component.test;
    import demo.component.test.UserController;
    import org.springframework.context.ApplicationContext;
    import org.springframework.context.support.ClassPathXmlApplicationContext;
    import org.springframework.stereotype.Component;
    
    @Component
    public class Main {
        public static void main(String[] args) {
            ApplicationContext context=new ClassPathXmlApplicationContext("spring-config.xml");
            UserConfiguration userConfiguration=context.getBean("userConfiguration",UserConfiguration.class);
            userConfiguration.print("ie");
        }
    }

--------------------

#### 1.1.6 为什么要这么多类注解 ####

在看完上面五个类注解的代码后，我们会发现，在进行类注解的时候，上面五种类注解的格式都是类似的，既然功能和格式都是一样的，那么我们为什么要这么多类注解呢？

这个道理其实是跟车牌号一样的，我们各个省，甚至各个市的车牌号的开头都是不一样的，这是为了标识这个车的来历；而类注解是类似的，当我们看到其中一个类注解的时候，**我们可以根据类注解的类型来得出当前类的作用及用途、**

--------------------

### 1.2 方法注解 ###

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

package demo.component.test;
    
    import demo.component.student.Student;
    import org.springframework.context.annotation.Bean;
    
    public class StudentBeans {
        @Bean
        public Student students(){
            Student student=new Student();
            student.setAge(12);
            student.setName("张三");
            student.setPassword("123");
            return student;
        }
        
    }

这里要注意了，当我们使用方法注解的时候，需要在类上面添加上@Component，否则无法正常的存储到Spring中

package demo.component.test;
    
    import demo.component.student.Student;
    import org.springframework.context.annotation.Bean;
    import org.springframework.stereotype.Component;
    
    @Component
    public class StudentBeans {
        @Bean
        public Student students(){
            Student student=new Student();
            student.setAge(12);
            student.setName("张三");
            student.setPassword("123");
            return student;
        }
    
    }

--------------------

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

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

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

### 2.1 属性注入 ###

属性注入是最简单，也是最常用的对象注入方式

#### 2.1.1 属性注入的实现 ####

属性注入常常使用@Autowired进行实现，比如说我们要在类StudentController中注入Student类的代码如下:

package demo.component.student;
    
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Controller;
    
    @Controller
    public class StudentControl {
        @Autowired
        private Student student;
        public void sayHi(){
            System.out.println(student);
        }
    }

属性注入的关键在于，在对应的对象上方添加@Autowired，此时会去Spring中查找相应的对象，并赋值给该student

#### 2.1.2 属性注入的优缺点 ####

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

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

--------------------

### 2.2 Setter注入 ###

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

#### 2.2.1 Setter注入的实现 ####

package demo.component.student;
    
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Controller;
    
    @Controller
    public class StudentControl {
        private Student student;
        @Autowired
        public void setStudent(Student student) {
            this.student = student;
        }
    
        public void sayHi(){
            System.out.println(student);
        }
    }

#### 2.2.2 Setter注入的优缺点 ####

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

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

--------------------

### 2.3 构造器注入 ###

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

#### 2.3.1 构造器注入的实现 ####

package demo.component.student;
    
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Controller;
    
    @Controller
    public class StudentControl {
        private Student student;
    
        public StudentControl(Student student) {
            this.student = student;
        }
    
        public void sayHi(){
            System.out.println(student);
        }
    }

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

#### 2.3.2 构造器注入的优缺点 ####

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

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

--------------------

### 2.4 @Resource：另一种注入关键字 ###

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

#### 2.4.1 @Resource的实现 ####

package demo.component.student;
    
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Controller;
    
    import javax.annotation.Resource;
    
    @Controller
    public class StudentControl {
        @Resource
        private Student student;
    
        public void sayHi(){
            System.out.println(student);
        }
    }

@Resource的用法与@Autowired相同

#### 2.4.2 @Resource和@Autowired的区别 ####

1. @Autowired来自Spring，而@Resource来自JDK的注解

2. @Resource支持更多的参数设置，可以添加name设置来根据名称获取Bean

3. @Resource不能用于构造函数注入