【Spring6】| Spring IoC注解式开发

缺乏、安全感 2024-03-29 15:57 94阅读 0赞

**目录**

一：Spring IoC注解式开发

1. 回顾注解

2. 声明Bean的四个注解

3. Spring注解的使用

4. 选择性实例化Bean

5. 负责注入的注解（重点）

5.1 @Value

5.2 @Autowired与@Qualifier

5.3 @Resource

6. 全注解式开发

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

## 一：Spring IoC注解式开发 ##

### 1. 回顾注解 ###

> **注解的存在主要是为了简化XML的配置，Spring6倡导全注解开发。**
> 
> **我们来回顾一下：**
> 
> ①第一：注解怎么定义，注解中的属性怎么定义？
> 
> ②第二：注解怎么使用？
> 
> ③第三：通过反射机制怎么读取注解？

**注解怎么定义，注解中的属性怎么定义？**

自定义注解：Component

> （1）Target注解和Retention注解，这两个注解被称为元注解：
> 
> ①@Target注解用来设置Component注解可以出现的位置，以下代表表示Component注解只能用在类和接口上。
> 
> ②Retention注解用来设置Component注解的保持性策略，以下代表Component注解可以被反射机制读取。  
> **注：**使用某个注解的时候，如果注解的属性名是value的话，value可以省略。  
> **注：**使用某个注解的时候，如果注解的属性值是数组，并且数组中只有一个元素，大括号可以省略。

package com.bjpowernode.annotation;
    
    import java.lang.annotation.ElementType;
    import java.lang.annotation.Retention;
    import java.lang.annotation.RetentionPolicy;
    import java.lang.annotation.Target;
    
    @Target(value = {ElementType.TYPE})
    @Retention(value = RetentionPolicy.RUNTIME)
    public @interface Component {
        // 属性
        String value();
    }

**注解怎么使用？**

> （2）语法格式：@注解类型名(属性名=属性值, 属性名=属性值, 属性名=属性值......)
> 
> 并且如果属性名是value，则在使用的时候可以省略属性名，例如：

package com.bjpowernode.annotation;
    
    // @Component(value = "userBean")
    @Component("userBean")
    public class User {
    }

**通过反射机制怎么读取注解？**

> （3）**定义需求：当Bean类上有Component注解时，则实例化Bean对象，如果没有，则不实例化对象！**
> 
> **第一步：**先使用**Class.forName**获取类。
> 
> **第二步：**调用**isAnnotationPresent**方法看这个类上是否有**@Component**注解，**参数是Component.class**，返回的是一个布尔类型。
> 
> **第三步：**如果存在，调用**getDeclaredAnnotation**方法获取这个注解，**参数还是Component.class**，然后就可以获取注解的属性值。

package com.bjpowernode.annotation;
    
    public class Test {
        public static void main(String[] args) throws Exception{
            // 获取类
            Class<?> clazz = Class.forName("com.bjpowernode.annotation.User");
            // 看这个类上有没有Component注解
            if (clazz.isAnnotationPresent(Component.class)){
                // 有这个注解就获取注解的属性并就创建对象
                // 获取这个注解
                Component annotation = clazz.getDeclaredAnnotation(Component.class);
                // 获取这个注解的属性
                System.out.println(annotation.value());
                // 创建对象
                // User user = new User();
                User user = (User)clazz.newInstance()
                System.out.println(user);
            }
        }
    }

执行结果：

![f4792de19bea423295f3ec97f9aeacec.png][]

> （4）在（3）的基础上，提升一下难度；
> 
> **假设我们现在只知道包名：com.bjpowernode.annotation；至于这个包下有多少个Bean我们不知道！哪些Bean上有注解，哪些Bean上没有注解，这些我们都不知道！**如何通过程序全自动化扫描判断？
> 
> **注：**实际上**@ComponentScan注解**可以实现这个功能，包扫描，有Componenet注解的对象就会被创建出来，没有的则不会！

**目前只知道一个包的名字，扫描这个包下所有的类，当这个类上有@Component注解的时候，实例化该对象，然后放到Map集合中！**

User类：含有Component注解

package com.bjpowernode.annotation;
    
    @Component("userBean")
    public class User {
    }

Vip类：没有Component注解

package com.bjpowernode.annotation;
    
    public class Vip {
    }

Student类：含有Component注解

package com.bjpowernode.annotation;
    
    @Component("studentBean")
    public class Student {
    }

ComponentScan类：编写测试

package com.bjpowernode.annotation;
    
    import java.io.File;
    import java.net.URL;
    import java.util.Arrays;
    import java.util.HashMap;
    import java.util.Map;
    
    public class ComponentScan {
        public static void main(String[] args) {
    
            // 创建Map集合
            Map<String,Object> beanMap = new HashMap<>();
    
            // 目前只知道一个包名
            String packageName = "com.bjpowernode.annotation";
            // 把包名转换成路径的形式，使用正则表达式
            // 直接使用“.”，正则表达式中代表任意字符，会把所有的内容都替换成/
            // 正则表达式中“\.”代表“.” ,而java中双\\就代表\，有一个用来转义
            String packagePath = packageName.replaceAll("\\.", "/");
            // String packagePath = packageName.replace(".", "/"); 这样也可以
            // System.out.println(packagePath); // com/bjpowernode/annotation
            // com是类的根路径下的一个目录，获取系统类加载器，从根目录下进行扫描，返回一个URL
            URL url = ClassLoader.getSystemClassLoader().getResource(packagePath);
            // 获取绝对路径
            String path = url.getPath();
            // 开始扫描，获取一个绝对路径下的所有文件
            File file = new File(path);
            File[] files = file.listFiles();
            // 流式编程
            Arrays.stream(files).forEach(f -> { // f.getName得到的是对应的.class字节码文件
                // 拼串成全限定包名
                String className = packageName+"."+f.getName().split("\\.")[0];
                // System.out.println(className);
                try {
                    // 通过反射机制创建对象
                    // 获取类
                    Class<?> clazz = Class.forName(className);
                    // 检查类上有没有Component注解
                    if (clazz.isAnnotationPresent(Component.class)) {
                        // 有的话获取注解
                        Component annotation = clazz.getDeclaredAnnotation(Component.class);
                        // 获取注解的属性值
                        String key = annotation.value();
                        // 创建对象
                        Object obj = clazz.newInstance();
                        // 把注解的属性值作为key，对象作为value放到Map集合当中
                        beanMap.put(key,obj);
                    }
    
                } catch (Exception e) {
                    e.printStackTrace();
                }
            });
    
            // 打印这个Map集合
            System.out.println(beanMap);
    
    
        }
    }

执行结果：应该创建User和Student对象

![b649cb8f6aa2469a839f94e91ee3dfc5.png][]

### 2. 声明Bean的四个注解 ###

**负责声明Bean的注解（实例化），常见的包括四个：**

> ①@**Component**注解：平常使用
> 
> ②@**Controller**注解：一般控制器上使用
> 
> ③@**Service**注解：一般service类上使用
> 
> ④@**Repositorys**注解：一般dao类上使用

**源码如下：**

@Component注解

package com.powernode.annotation;
    
    import java.lang.annotation.ElementType;
    import java.lang.annotation.Retention;
    import java.lang.annotation.RetentionPolicy;
    import java.lang.annotation.Target;
    
    @Target(value = {ElementType.TYPE})
    @Retention(value = RetentionPolicy.RUNTIME)
    public @interface Component {
        String value();
    }

@Controller注解

package org.springframework.stereotype;
    
    import java.lang.annotation.Documented;
    import java.lang.annotation.ElementType;
    import java.lang.annotation.Retention;
    import java.lang.annotation.RetentionPolicy;
    import java.lang.annotation.Target;
    import org.springframework.core.annotation.AliasFor;
    
    @Target({ElementType.TYPE})
    @Retention(RetentionPolicy.RUNTIME)
    @Documented
    @Component
    public @interface Controller {
        @AliasFor(
            annotation = Component.class
        )
        String value() default "";
    }

@Service注解

package org.springframework.stereotype;
    
    import java.lang.annotation.Documented;
    import java.lang.annotation.ElementType;
    import java.lang.annotation.Retention;
    import java.lang.annotation.RetentionPolicy;
    import java.lang.annotation.Target;
    import org.springframework.core.annotation.AliasFor;
    
    @Target({ElementType.TYPE})
    @Retention(RetentionPolicy.RUNTIME)
    @Documented
    @Component
    public @interface Service {
        @AliasFor(
            annotation = Component.class
        )
        String value() default "";
    }

@Repository注解

package org.springframework.stereotype;
    
    import java.lang.annotation.Documented;
    import java.lang.annotation.ElementType;
    import java.lang.annotation.Retention;
    import java.lang.annotation.RetentionPolicy;
    import java.lang.annotation.Target;
    import org.springframework.core.annotation.AliasFor;
    
    @Target({ElementType.TYPE})
    @Retention(RetentionPolicy.RUNTIME)
    @Documented
    @Component
    public @interface Repository {
        @AliasFor(
            annotation = Component.class
        )
        String value() default "";
    }

> （1）通过源码可以看到，**@Controller**、**@Service**、**@Repository**这三个注解都是**@Component**注解的别名。也就是说：**这四个注解的功能都一样**，用哪个都可以！
> 
> （2）那么为什么会提供那么多种方式呢？**只是为了增强程序的可读性，建议：**
> 
> **①控制器类上使用：Controller注解**
> 
> **②service类上使用：Service注解**
> 
> **③dao类上使用：Repository注解**
> 
> （3）都是只有一个value属性，value属性用来指定bean的id，也就是bean的名字！

![7c4b13609b249c65a2806c99a4a39497.png][]

###  ###

### 3. Spring注解的使用 ###

**如何使用以上的注解呢？**

> 第一步：加入aop的依赖（不用管）；
> 
> 第二步：在配置文件中添加context命名空间；
> 
> 第三步：在配置文件中指定扫描的包；
> 
> 第四步：在Bean类上使用注解；

**第一步：加入aop的依赖**

> 我们可以看到**当加入spring-context依赖之后，会关联加入aop的依赖**，所以这一步不用做

![ec7027beed7e9aa37328acf8c856631a.png][]

**第二步：在配置文件中添加context命名空间**

**第三步：在配置文件中指定要扫描的包**

> （1）就像我们前面回忆反射机制第四部分的代码一样，我们只需要知道包名，然后会扫描这个包下的所有类，通过反射机制，对含有注解的进行对象的创建！相当于我们只需要配置包名，就可以通过注解创建对象，不用一个个去进行配置了！
> 
> （2）**注：**就是使用**context**命名空间的**component-scan**进行组件扫描，使用属性**base-package**执行要扫描的包！

**第四步：在Bean类上使用注解**

User类：含有Component注解

package com.bjpowernode.spring.bean;
    
    import org.springframework.stereotype.Component;
    
    @Component("userBean")
    public class User {
        
    }

Vip类：含有Component注解

package com.bjpowernode.spring.bean;
    
    import org.springframework.stereotype.Component;
    
    @Component("vipBean")
    public class Vip {
    
    }

**编写测试程序**

package com.bjpowernode.spring.test;
    
    import com.bjpowernode.spring.bean.User;
    import com.bjpowernode.spring.bean.Vip;
    import org.junit.Test;
    import org.springframework.context.ApplicationContext;
    import org.springframework.context.support.ClassPathXmlApplicationContext;
    
    public class springAnnotationTest {
        @Test
        public void testAnnotation(){
            ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring.xml");
            User userBean = applicationContext.getBean("userBean", User.class);
            System.out.println(userBean);
            Vip vipBean = applicationContext.getBean("vipBean", Vip.class);
            System.out.println(vipBean);
    
        }
    }

**执行结果：成功创建两个对象**

![f970530e0fad4e6fa7d6703bc4c2d41b.png][]

**问题1：如果把value属性彻底去掉，spring会被Bean自动取名吗？**

> 答：会的，并且默认名字是：Bean类名首字母小写；例如：Vip类对应的名字就是vip

package com.bjpowernode.spring.bean;
    
    import org.springframework.stereotype.Component;
    
    // 自动取名就是vip
    @Component
    public class Vip {
    
    }

**问题2：如果是多个包怎么办？有两种解决方案：**

> ①第一种：在配置文件中指定多个包，用 “逗号,” 隔开。
> 
> ②第二种：指定多个包的共同父包，牺牲一部分效率。

<?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:context="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 http://www.springframework.org/schema/context/spring-context.xsd">
        
        
        <context:component-scan base-package="com.powernode.spring6.bean,com.powernode.spring6.dao"/>
        
        <context:component-scan base-package="com.powernode.spring6"/>
    </beans>

### 4. 选择性实例化Bean ###

**需求：假设在某个包下有很多Bean，有的Bean上标注了@Component，有的标注了@Controller，有的标注了@Service，有的标注了@Repository**，现在由于某种特殊业务的需要，**只允许其中所有的Controller注解的参与Bean管理，其他的都不实例化**！这应该怎么办呢？

> 为了便于理解，我们将这几个类都定义到同一个java源文件中，并且采用不同的注解方式！

package com.bjpowernode.spring.bean;
    
    import org.springframework.stereotype.Component;
    import org.springframework.stereotype.Controller;
    import org.springframework.stereotype.Repository;
    import org.springframework.stereotype.Service;
    
    @Component
    public class A {
        public A() {
            System.out.println("A的无参数构造方法执行");
        }
    }
    
    @Controller
    class B {
        public B() {
            System.out.println("B的无参数构造方法执行");
        }
    }
    
    @Service
    class C {
        public C() {
            System.out.println("C的无参数构造方法执行");
        }
    }
    
    @Repository
    class D {
        public D() {
            System.out.println("D的无参数构造方法执行");
        }
    }
    
    @Controller
    class E {
        public E() {
            System.out.println("E的无参数构造方法执行");
        }
    }

**第一种解决方案：use-default-filters="false"**

> 如果这个属性是false，表com.bjpowernode.spring.bean包下所有的带有**声明Bean的注解全部失效**；然后在使用**include-filter**标签**包含**让那个**注解生效**（使用全限定类名）

<?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:context="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 http://www.springframework.org/schema/context/spring-context.xsd">
        
        <context:component-scan base-package="com.bjpowernode.spring.bean" use-default-filters="false">
            
            <context:include-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
           
        </context:component-scan>
    </beans>

测试程序

> 当ClassPathXmlApplicationContext方法创建出来，类中对应的构造方法就会执行！

执行结果：只有Controller注解生效，对应的应该是B和E

![3fc4468d70324ec1b42d238ff59b4eda.png][]

**第二种解决方案：use-default-filters="true"**

> 如果这个属性的值是true，表示com.bjpowernode.spring.bean下的所有的带有**声明Bean的注解全部生效**；use-default-filters="true"**默认值就是true**，不用写也行。然后在使用**exclude-filter**标签**去除**让那个**注解失效**（使用全限定类名）

<?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:context="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 http://www.springframework.org/schema/context/spring-context.xsd">
    
    
        <context:component-scan base-package="com.bjpowernode.spring.bean" use-default-filters="true">
            
            <context:exclude-filter type="annotation" expression="org.springframework.stereotype.Repository"/>
            <context:exclude-filter type="annotation" expression="org.springframework.stereotype.Service"/>
        </context:component-scan>
    </beans>

执行结果：只有Service和Repository注解失效，对应的应该是A、B、E

![8d909df0c81a4db4a689dcd7538fc94e.png][]

### 5. 负责注入的注解（重点） ###

> （1）**@Component @Controller @Service @Repository**这四个注解是用来声明Bean的，声明后这些**Bean将被实例化。**
> 
> （2）接下来我们看一下，如何给Bean的属性赋值，**给Bean属性赋值**需要用到这些注解：
> 
> **@Value、@Autowired、@Qualifier、@Resource。**

#### 5.1 @Value ####

> 当属性的类型是**简单类型时**，可以**使用@Value注解**进行注入。

**第一种情况：什么都不提供，直接在属性上使用**

package com.bjpowernode.spring.bean;
    
    import org.springframework.beans.factory.annotation.Value;
    import org.springframework.stereotype.Component;
    
    @Component
    public class Person {
        @Value("张三")
        private String name;
        @Value("18")
        private int age;
        
        @Override
        public String toString() {
            return "Person{" +
                    "name='" + name + '\'' +
                    ", age=" + age +
                    '}';
        }
    }

**第二种情况：提供set方法，在set方法上使用**

package com.bjpowernode.spring.bean;
    
    import org.springframework.beans.factory.annotation.Value;
    import org.springframework.stereotype.Component;
    
    @Component
    public class Person {
        
        private String name;
        private int age;
    
        // 提供了set方法
        @Value("张三")
        public void setName(String name) {
            this.name = name;
        }
        @Value("18")
        public void setAge(int age) {
            this.age = age;
        }
    
        @Override
        public String toString() {
            return "Person{" +
                    "name='" + name + '\'' +
                    ", age=" + age +
                    '}';
        }
    }

**第三种情况：提供构造方法，在构造方法的形参上使用**

**注：直接声明构造方法上不可以，一定是声明在在构造方法的参数上才可以！**

package com.bjpowernode.spring.bean;
    
    import org.springframework.beans.factory.annotation.Value;
    import org.springframework.stereotype.Component;
    
    @Component
    public class Person {
     
        private String name;
        private int age;
        
        // 提供了构造方法的形参上
        public Person(@Value("张三")String name, @Value("18")int age) {
            this.name = name;
            this.age = age;
        }
    
        @Override
        public String toString() {
            return "Person{" +
                    "name='" + name + '\'' +
                    ", age=" + age +
                    '}';
        }
    }

spring-annotation-di.xml配置，在配置中指定包扫描即可

执行结果

> 通过测试得知：**@Value注解：可以出现在属性上、setter方法上、以及构造方法的形参上**，可见Spring给我们提供了多样化的注入；很灵活了！

![841839e3fa354ad0a521d612d6ea1430.png][]

#### 5.2 @Autowired与@Qualifier ####

> **@Autowired注解**可以用来注入**非简单类型**。被翻译为：**自动连线的，或者自动装配**。
> 
> ①**单独使用@Autowired注解**，默认**根据类型装配**。【**默认是根据byType**】
> 
> ②**@Autowired注解和@Qualifier注解联合使用****，**才能**根据名字装配**【**根据byName**】

@Autowired源码

> **源码中有两处需要注意：**
> 
> ①第一处：该注解可以标注在哪里？构造方法上、方法上、形参上、属性上、注解上
> 
> ②第二处：该注解有一个**required属性**，默认**值是true**，表示在注入的时候要求被注入的Bean必须是存在，如果不存在则报错。如果required属性**值设置为false**，表示被注入的Bean存在或者不存在都没关系，存在的话就注入，不存在的话，也不报错！

package org.springframework.beans.factory.annotation;
    
    import java.lang.annotation.Documented;
    import java.lang.annotation.ElementType;
    import java.lang.annotation.Retention;
    import java.lang.annotation.RetentionPolicy;
    import java.lang.annotation.Target;
    
    @Target({ElementType.CONSTRUCTOR, ElementType.METHOD, ElementType.PARAMETER, ElementType.FIELD, ElementType.ANNOTATION_TYPE})
    @Retention(RetentionPolicy.RUNTIME)
    @Documented
    public @interface Autowired {
    	boolean required() default true;
    }

**第一种情况：什么都不提供，直接在属性上注入**

UserDao接口

package com.bjpowernode.spring.dao;
    
    public interface UserDao {
        void insert();
    }

接口的实现类UserDaoImpl

package com.bjpowernode.spring.dao.impl;
    
    import com.bjpowernode.spring.dao.UserDao;
    import org.springframework.stereotype.Repository;
    
    @Repository("userDaoImpl")
    public class UserDaoImpl implements UserDao {
        @Override
        public void insert() {
            System.out.println("正在插入信息");
        }
    }

UserService类：在属性上直接注入

package com.bjpowernode.spring.service;
    
    import com.bjpowernode.spring.dao.UserDao;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Service;
    
    @Service("userService")
    public class UserService {
        // 面向接口编程
        @Autowired // 不需要指定任何属性，直接使用即可
        private UserDao userDao;
    
        public void insertDate(){
            userDao.insert();
        }
    }

spring-annotation-di.xml配置包扫描

测试程序

package com.bjpowernode.spring.test;
    
    import com.bjpowernode.spring.bean.Person;
    import com.bjpowernode.spring.bean.User;
    import com.bjpowernode.spring.bean.Vip;
    import com.bjpowernode.spring.service.UserService;
    import org.junit.Test;
    import org.springframework.context.ApplicationContext;
    import org.springframework.context.support.ClassPathXmlApplicationContext;
    
    public class springAnnotationTest {
    
        @Test
        public void testAnnotationDI(){
            ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring-annotation-di.xml");
            UserService userService = applicationContext.getBean("userService", UserService.class);
            userService.insertDate();
        }
    }

执行结果：构造方法和setter方法都没有提供，经过测试，仍然可以注入成功

![c401c2bf791e4f30a162a05b9d4e1d50.png][]

**问题：目前UserDao下只有一个实现类，可根据类型完成自动装配；那如果在有多个实现类，那么在private UserDao userDao面向接口编程，Spring就不知道装配哪一个实现类？**

> **答：**此时就要使用@Autowired注解和@Qualifier注解联合使用，根据名字进行转配！

package com.bjpowernode.spring.service;
    
    import com.bjpowernode.spring.dao.UserDao;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.beans.factory.annotation.Qualifier;
    import org.springframework.stereotype.Service;
    
    @Service("userService")
    public class UserService {
        // 不需要指定任何属性，直接使用即可
        @Autowired 
        // 要自动装配那个实现类，就把实现类的名字写上
        @Qualifier("userDaoImpl")
        private UserDao userDao;
    
        public void insertDate(){
            userDao.insert();
        }
    }

**第二种情况：出现在setter方法上**

package com.bjpowernode.spring.service;
    
    import com.bjpowernode.spring.dao.UserDao;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.beans.factory.annotation.Qualifier;
    import org.springframework.stereotype.Service;
    
    @Service("userService")
    public class UserService {
        
        private UserDao userDao;
        // 出现在set方法上
        @Autowired
        public void setUserDao(UserDao userDao) {
            this.userDao = userDao;
        }
    
        public void insertDate() {
            userDao.insert();
        }
    }

**第三种情况：出现在构造方法上**

package com.bjpowernode.spring.service;
    
    import com.bjpowernode.spring.dao.UserDao;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.beans.factory.annotation.Qualifier;
    import org.springframework.stereotype.Service;
    
    @Service("userService")
    public class UserService {
        
        private UserDao userDao;
    
        // 出现在构造方法上
        @Autowired
        public UserService(UserDao userDao) {
            this.userDao = userDao;
        }
    
        public void insertDate() {
            userDao.insert();
        }
    }

**第四种情况：出现在构造方法的属性上**

package com.bjpowernode.spring.service;
    
    import com.bjpowernode.spring.dao.UserDao;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.beans.factory.annotation.Qualifier;
    import org.springframework.stereotype.Service;
    
    @Service("userService")
    public class UserService {
        
        private UserDao userDao;
    
        // 出现在构造方法的属性上
        public UserService(@Autowired UserDao userDao) {
            this.userDao = userDao;
        }
    
        public void insertDate() {
            userDao.insert();
        }
    }

**第五种情况：直接省略不写（前提要有构造方法）**

> **注：**如果**一个类中**的**构造方法只有一个**，并且**构造方法上的参数和属性能够对应上**；此时**@Autowired注解能够省略！**

package com.bjpowernode.spring.service;
    
    import com.bjpowernode.spring.dao.UserDao;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.beans.factory.annotation.Qualifier;
    import org.springframework.stereotype.Service;
    
    @Service("userService")
    public class UserService {
        
        private UserDao userDao;
    
        // 一个构造方法并且参数能和上面的属性对应上，直接可以省略不写
        public UserService(UserDao userDao) {
            this.userDao = userDao;
        }
    
        public void insertDate() {
            userDao.insert();
        }
    }

**总结：**

**①@Autowired注解可以出现在：属性上、构造方法上、构造方法的参数上、setter方法上。**

**②当带参数的构造方法只有一个，@Autowired注解可以省略。**

**③@Autowired注解默认根据类型注入；如果要根据名称注入的话，需要配合@Qualifier注解一起使用。**

#### 5.3 @Resource ####

> **（1）****@Resource注解也可以完成非简单类型注入，那它和@Autowired注解有什么区别？**
> 
> ①**@Resource注解是JDK扩展包中的**，也就是说**属于JDK的一部分**；所以该注解是标准注解，更加具有通用性。(JSR-250标准中制定的注解类型，JSR是Java规范提案)
> 
> ②@Autowired注解是Spring框架自己的。
> 
> ③**@Resource注解默认根据名称装配byName；未指定name时，使用属性名作为name；**
> 
> **通过name找不到的话会自动启动通过类型byType装配。**
> 
> ④@Autowired注解默认根据类型装配byType，如果想根据名称装配，需要配合@Qualifier注解一起用。
> 
> ⑤**@Resource注解**主要用在**属性上、setter方法**上。
> 
> ⑥**@Autowired注解**用在**属性上、setter方法上、构造方法上、构造方法参数上**。
> 
> （2）**@Resource注解属于JDK扩展包**，所以不在JDK当中，需要额外引入以下依赖：【如果是JDK8的话不需要额外引入依赖，高于JDK11或低于JDK8需要引入以下依赖】

**注意：如果用Spring6，要知道Spring6不再支持JavaEE，它支持的是JakartaEE9！**

Spring6+版本引入的依赖

<dependency>
      <groupId>jakarta.annotation</groupId>
      <artifactId>jakarta.annotation-api</artifactId>
      <version>2.1.1</version>
    </dependency>

spring5-版本引入的依赖

<dependency>
      <groupId>javax.annotation</groupId>
      <artifactId>javax.annotation-api</artifactId>
      <version>1.3.2</version>
    </dependency>

@Resource注解的源码如下

> 虽然可以用在类上，但是主要是用在属性上和方法上！

![7743234e922453d00baadca17c136f5e.png][]

**第一种情况：出现在属性上，使用时必须加上name属性（根据名字装配）**

package com.bjpowernode.spring.service;
    
    import com.bjpowernode.spring.dao.UserDao;
    import jakarta.annotation.Resource;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.beans.factory.annotation.Qualifier;
    import org.springframework.stereotype.Service;
    
    @Service("userService")
    public class UserService {
    
        // 出现在属性上，必须加上name属性
        @Resource(name = "userDaoImpl")
        private UserDao userDao;
        
        public void insertDate() {
            userDao.insert();
        }
    }

**第二种情况：出现在set方法上，使用时必须加上name属性（根据名字装配）；不能出现在构造方法上**

package com.bjpowernode.spring.service;
    
    import com.bjpowernode.spring.dao.UserDao;
    import jakarta.annotation.Resource;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.beans.factory.annotation.Qualifier;
    import org.springframework.stereotype.Service;
    
    @Service("userService")
    public class UserService {
       
        private UserDao userDao;
        // 出现在set方法上，必须加上name属性
        @Resource(name = "userDaoImpl")
        public void setUserDao(UserDao userDao) {
            this.userDao = userDao;
        }
    
        public void insertDate() {
            userDao.insert();
        }
    }

**第三种情况：不指定名字，还是根据name自动装配，把属性作为name（根据名字装配）**

UserDaoImpl类，名字修改为属性名

package com.bjpowernode.spring.dao.impl;
    
    import com.bjpowernode.spring.dao.UserDao;
    import org.springframework.stereotype.Repository;
    
    // 这里也改成属性的名字
    // @Repository("userDaoImpl")
    @Repository("userDao")
    public class UserDaoImpl implements UserDao {
        @Override
        public void insert() {
            System.out.println("正在插入信息");
        }
    }

UserService类：使用Resource注解，不指定名字，默认把属性名作为名字

package com.bjpowernode.spring.service;
    
    import com.bjpowernode.spring.dao.UserDao;
    import jakarta.annotation.Resource;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.beans.factory.annotation.Qualifier;
    import org.springframework.stereotype.Service;
    
    @Service("userService")
    public class UserService {
        // 这里未指定名字，会把属性名作为名字
        @Resource
        private UserDao userDao;
    
        public void setUserDao(UserDao userDao) {
            this.userDao = userDao;
        }
    
        public void insertDate() {
            userDao.insert();
        }
    }

执行结果：

> 通过测试得知，当@Resource注解使用时没有指定name的时候，还是根据name进行查找，这个name是属性名。

![da30870d52214e47b90e626dd8236795.png][]

**第四种情况：当使用属性名字装配时，再找不到；才会按照类型进行装配（根据类型装配）**

UserDaoImpl类，名字修改为不是属性名

package com.bjpowernode.spring.dao.impl;
    
    import com.bjpowernode.spring.dao.UserDao;
    import org.springframework.stereotype.Repository;
    
    // 名字不是属性名
    @Repository("xxx")
    public class UserDaoImpl implements UserDao {
        @Override
        public void insert() {
            System.out.println("正在插入信息");
        }
    }

UserService类：使用Resource注解，不指定名字，默认把属性名作为名字，但是与上面名字不匹配，此时也能执行成功；**此时不是根据名字进行装配，而是根据类型进行装配了！**

package com.bjpowernode.spring.service;
    
    import com.bjpowernode.spring.dao.UserDao;
    import jakarta.annotation.Resource;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.beans.factory.annotation.Qualifier;
    import org.springframework.stereotype.Service;
    
    @Service("userService")
    public class UserService {
        // 这里未指定名字，会把属性名作为名字
        @Resource
        private UserDao userDao;
    
        public void setUserDao(UserDao userDao) {
            this.userDao = userDao;
        }
    
        public void insertDate() {
            userDao.insert();
        }
    }

**总结：**

**①自己指定名字，@Resource注解默认根据名称【byName】注入，只要UserDaoImpl类的@Repository("userDaoImpl")注解的名称与UserService类里面的userDao属性上面的@Resource(“userDaoImpl”)注解名称保持一致即可！【byName】**

**②当不指定名字时，直接使用@Resource注解，此时是根据属性userDao的名字进行注入；需要保证UserDaoImpl类的@Repository("userDao")注解的名称就是userDao属性的名字!【byName】**

**③如果②中UserDaoImpl类的@Repository("userXxx")注解的名称与属性userDao的名字没有保持一致，****根据属性名找不到时，才会根据类型进行注入！【byType】**

**④byType注入时，某种类型的Bean只能有一个（实现类有多个就不知道注入哪一个了），此时@Resource注解也可以省略不写！**

### 6. 全注解式开发 ###

> 所谓的**全注解开发就是不再使用spring配置文件**了；**写一个配置类来代替配置文件！**

**第一步：配置类代替spring配置文件**

**主要使用到两个注解：**

> **①@Configuration：就相当于xml文件中的基础配置；**
> 
> **②@ComponentScan：包扫描，用来指定包名；**

package com.bjpowernode.spring.config;
    
    import org.springframework.context.annotation.ComponentScan;
    import org.springframework.context.annotation.Configuration;
    
    @Configuration
    @ComponentScan("com.bjpowernode.spring")
    public class Spring6Configuration {
        // 类中什么都不用写
    }

**第二步：编写测试程序**

> ①不需要在编写Spring.xml配置文件了，直接在测试代码中引用上面的类即可！
> 
> ②不再new ClassPathXmlApplicationContext()对象了，而是创建**AnnotationConfigApplicationContext**对象，参数就是上面我们的配置类Spring6Configuration对应的.class！

package com.bjpowernode.spring.test;
    
    import com.bjpowernode.spring.bean.Person;
    import com.bjpowernode.spring.bean.User;
    import com.bjpowernode.spring.bean.Vip;
    import com.bjpowernode.spring.config.Spring6Configuration;
    import com.bjpowernode.spring.service.UserService;
    import org.junit.Test;
    import org.springframework.context.ApplicationContext;
    import org.springframework.context.annotation.AnnotationConfigApplicationContext;
    import org.springframework.context.support.ClassPathXmlApplicationContext;
    
    public class springAnnotationTest {
    
        @Test
        public void testNoXML(){
            // 创建AnnotationConfigApplicationContext对象
            ApplicationContext context = new AnnotationConfigApplicationContext(Spring6Configuration.class);
            UserService userService = context.getBean("userService", UserService.class);
            userService.insertDate();
        }
    }

执行结果：全注解式开发也没问题

![7d12513cae594dc49f125ddc79de38fc.png][]

[f4792de19bea423295f3ec97f9aeacec.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/28/c9fdc94fc463406186b80119f659d0e9.png
[b649cb8f6aa2469a839f94e91ee3dfc5.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/28/5a7eb2fa2c3e4886b167b15f05e98e3f.png
[7c4b13609b249c65a2806c99a4a39497.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/28/b2942bc5aabf4958a0674f77f95a6da1.png
[ec7027beed7e9aa37328acf8c856631a.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/28/1cf582feb06f45bf9fe94587926d0340.png
[f970530e0fad4e6fa7d6703bc4c2d41b.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/28/2433a6b7b5db480b86bd7f3c099bc306.png
[3fc4468d70324ec1b42d238ff59b4eda.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/28/65df31a331974669ba3396725315de82.png
[8d909df0c81a4db4a689dcd7538fc94e.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/28/ef8a5e6d9d384f3e88ec5dfe061c1c4d.png
[841839e3fa354ad0a521d612d6ea1430.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/28/70253460ac6745ccaa774a1a346bff1c.png
[c401c2bf791e4f30a162a05b9d4e1d50.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/28/b36245e2780d4c019a7f0772a2511a89.png
[7743234e922453d00baadca17c136f5e.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/28/bd1fcf1971be4732ae1ac450095af1b3.png
[da30870d52214e47b90e626dd8236795.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/28/c4c757eaaadc4778bb7dd75b2cefd037.png
[7d12513cae594dc49f125ddc79de38fc.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/28/573ac1fc88d348d0809688e6a7ef964e.png