Spring学习记录----十二、Spring IoC注解式开发

我就是我 2024-03-17 22:51 88阅读 0赞

**目录**

十二、Spring IoC注解式开发

12.1 回顾注解

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

注解怎么使用？

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

代码

运行结果

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

代码

运行结果

12.2 声明Bean的注解

12.3 Spring注解的使用

第一步：加入aop的依赖

在pom.xml上加入spring context依赖：

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

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

即加入代码：

完整代码：

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

Bean类：User、Student、Order、Vip

编写测试程序：

执行结果：

上述程序的pom文件完整代码：

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

12.4 选择性实例化Bean

测试程序

执行结果：

12.5 负责注入的注解【非常重要！！！！】

12.5.1 @Value

代码

运行结果：

12.5.2 @Autowired与@Qualifier

看一下它的源码：

源码中有两处需要注意：

我们先在属性上使用@Autowired注解：

配置包扫描

测试程序

执行结果：

接下来，再来测试一下@Autowired注解出现在setter方法上：

执行结果：

我们再来看看能不能出现在构造方法上：

执行结果：

再来看看，这个注解能不能只标注在构造方法的形参上：

执行结果：

还有更劲爆的，当有参数的构造方法只有一个时，@Autowired注解可以省略。

执行结果：

当然，如果有多个构造方法，@Autowired肯定是不能省略的。

执行结果：

总结：

12.5.3 @Resource

@Resource注解的源码如下：

测试一下：

给这个UserDaoForOracle起名xyz

在UserService中使用Resource注解根据name注入

执行测试程序：

我们把UserDaoForOracle的名字xyz修改为userDao，让这个Bean的名字和UserService类中的UserDao属性名一致：

执行测试程序：

UserService的属性名修改为userDao2

执行结果：

UserService添加setter方法并使用注解标注

执行结果：

当然，也可以指定name：

执行结果：

一句话总结@Resource注解：

12.6 全注解式开发

配置类代替spring配置文件

编写测试程序：不再new ClassPathXmlApplicationContext()对象了。

执行结果

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

## 十二、Spring IoC注解式开发 ##

## 12.1 回顾注解 ##

注解的存在主要是为了简化XML的配置。**Spring6倡导全注解开发**。

来回顾一下：

*  第一：注解怎么定义，注解中的属性怎么定义？
 *  第二：注解怎么使用？
 *  第三：通过反射机制怎么读取注解？

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

package com.dong.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();
    }

以上是自定义了一个注解：Component

该注解上面修饰的注解包括：Target注解和Retention注解，这两个注解被称为元注解。

Target注解用来设置Component注解可以出现的位置，以上代表表示Component注解只能用在类和接口上。

Retention注解用来设置Component注解的保持性策略，以上代表Component注解可以被反射机制读取。

String value(); 是Component注解中的一个属性。该属性类型String，属性名是value。

### **注解怎么使用？** ###

package com.dong.bean;
    
    import com.powernode.annotation.Component;
    
    @Component(value = "userBean")
    public class User {
    }

用法简单，语法格式：@注解类型名(属性名=属性值, 属性名=属性值, 属性名=属性值......)

userBean为什么使用双引号括起来，因为value属性是String类型，字符串。

另外如果属性名是value，则在使用的时候可以省略属性名，例如：

package com.dong.bean;
    
    import com.powernode.annotation.Component;
    
    //@Component(value = "userBean")
    @Component("userBean")
    public class User {
    }

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

#### **代码** ####

@Component 注解

package com.dong.annotation;
    
    import java.lang.annotation.ElementType;
    import java.lang.annotation.Retention;
    import java.lang.annotation.RetentionPolicy;
    import java.lang.annotation.Target;
    
    /**
     * 自定义注解
     */
    //@Target注解用来修饰 @Component可以出现的位置
    @Target(ElementType.TYPE)
    //@Retention也是一个元注解，用来标注 @Component 注解最终保留在class文件当中，并且可以呗反射机制读取
    @Retention(RetentionPolicy.RUNTIME)
    public @interface Component {
        //定义注解属性
        String value();
    }

User.java

package com.dong.bean;
    
    import com.dong.annotation.Component;
    
    @Component("userBean")
    public class User {
        /*private String name;*/
    }

**测试类：ReflectAnnotationTest1.java**

package com.dong.client;
    
    
    import com.dong.annotation.Component;
    
    
    public class ReflectAnnotationTest1 {
    
        public static void main(String[] args) throws Exception {
            //通过反射机制读取注解
            //获取类
            Class<?> clazz = Class.forName("com.dong.bean.User");
            //先判断你这类上有没有这个 @Component注解
            if (clazz.isAnnotationPresent(Component.class)) {
                //获取类上的注解
                Component annotation = clazz.getAnnotation(Component.class);
                //访问注解属性
                System.out.println(annotation.value());
            }
        }
    }

#### **运行结果** ####

![f640f5867b0c42e5a07e5c9d4f5646ff.png][]

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

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

接下来，我们来写一段程序，当Bean类上有Component注解时，则实例化Bean对象，如果没有，则不实例化对象。

我们准备3个Bean，2个上面有注解，1个上面没有注解。

#### 代码 ####

自定义@Component 注解：

package com.dong.annotation;
    
    import java.lang.annotation.ElementType;
    import java.lang.annotation.Retention;
    import java.lang.annotation.RetentionPolicy;
    import java.lang.annotation.Target;
    
    /**
     * 自定义注解
     */
    //@Target注解用来修饰 @Component可以出现的位置
    @Target(ElementType.TYPE)
    //@Retention也是一个元注解，用来标注 @Component 注解最终保留在class文件当中，并且可以呗反射机制读取
    @Retention(RetentionPolicy.RUNTIME)
    public @interface Component {
        //定义注解属性
        String value();
    }

package com.dong.bean;
    
    import com.dong.annotation.Component;
    
    @Component("userBean")
    public class User {
        /*private String name;*/
    }

package com.dong.bean;
    
    import com.dong.annotation.Component;
    
    @Component("orderBean")
    public class Order {
    }

3-【没有注解】

package com.dong.bean;
    
    public class Vip {
    }

测试类ComponentScan.Java

package com.dong.client;
    
    import com.dong.annotation.Component;
    
    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<String,Object>beanMap=new HashMap<>();
    
            //目前只知道一个包的名字，扫描这个包下的所有类，当这个类上有 @Component注解的时候，实例化该对象，然后放到Map集合中。
            String packageName = "com.dong.bean";
            //开始编写程序
            String packagePath = packageName.replaceAll("\\.", "/");
            // System.out.println(packagePath);
            URL url = ClassLoader.getSystemClassLoader().getResource(packagePath);
            //System.out.println(url);
            String path = null;
            if (url != null) {
                path = url.getPath();
            }
            //System.out.println(path);//得到绝对路径：/D:/CS/Code/IdeaCode/spring6-demo/review-annotation/target/classes/com/dong/bean
            File file = null;
            if (path != null) {
                file = new File(path);
            }
            File[] files = new File[0];//获取所有的子文件
            if (file != null) {
                files = file.listFiles();
            }
            if (files != null) {
                Arrays.stream(files).forEach(f -> {
                    try{
                         /* f:
                          Order.class
                          User.class
                          Vip.class
                     */
                        //System.out.println(f.getName());
                        // System.out.println(f.getName().split("\\.")[0]);
                    /*
                        Order 、User、Vip
                     */
                        //拼凑出全限定类名：  包名+“.”+类名
                        String className=packageName+"."+f.getName().split("\\.")[0];
                        //System.out.println(className);//得到类名：com.dong.bean.Order、com.dong.bean.User、com.dong.bean.Vip
    
                        //通过反射机制解析注解
                        Class<?> clazz = Class.forName(className);
                        //先判断这些类上有没有 @Component注解
                        if (clazz.isAnnotationPresent(Component.class)) {
                            //有这个注解就创建对象
                            //获取注解
                            Component annotation = clazz.getAnnotation(Component.class);
                            String id = annotation.value();
                            //有这个注解的都要创建对象
                            Object obj = clazz.newInstance();
                            beanMap.put(id,obj);
                        }
                    }catch (Exception e){
                        e.printStackTrace();
                    }
                });
            }
            System.out.println(beanMap);
        }
    }

#### 运行结果 ####

创建了两个对象

![b4e9a0a08fb3458aaa57fa74106ae20f.png][]

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

## 12.2 声明Bean的注解 ##

负责声明Bean的注解，常见的包括四个：

*  @Component
 *  @Controller
 *  @Service
 *  @Repository

源码如下：

@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 "";
    }

通过源码可以看到，**@Controller、@Service、@Repository这三个注解都是@Component注解的别名。**

也就是说：这四个注解的功能都一样。用哪个都可以。

**只是为了增强程序的可读性，建议：**

*  控制器类上使用：Controller
 *  service类上使用：Service
 *  dao类上使用：Repository

他们都是只有一个value属性。value属性用来指定bean的id，也就是bean的名字。

![b25b19ece4625ce28aecbaa6814fad96.png][]

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

## 12.3 Spring注解的使用 ##

如何使用以上的注解呢？

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

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

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

![image.png][]

#### 在pom.xml上加入spring context依赖： ####

<dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-context</artifactId>
                <version>6.0.11</version>
            </dependency>

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

spring.xml

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

#### 即加入代码： ####

<context:component-scan base-package="com.dong.spring6.bean"/>

#### 完整代码： ####

<?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.dong.spring6.bean"/>
    </beans>

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

#### Bean类：User、Student、Order、Vip ####

package com.dong.spring6.bean;
    
    import org.springframework.stereotype.Component;
    
    @Component
    public class User {
    }

package com.dong.spring6.bean;
    
    import org.springframework.stereotype.Repository;
    
    @Repository(value = "studentBean")
    public class Student {
    }

**如果注解的属性名是value，那么value是可以省略的。**

**如果把value属性彻底去掉，spring会被Bean自动取名吗？会的。并且默认名字的规律是：Bean类名首字母小写即可。**

package com.dong.spring6.bean;
    
    import org.springframework.stereotype.Controller;
    
    @Controller
    public class Vip {
    }

package com.dong.spring6.bean;
    
    import org.springframework.stereotype.Service;
    
    @Service
    public class Order {
    }

#### 编写测试程序： ####

IOCAnnotationTest.java

package com.dong.spring6.test;
    
    import com.dong.spring6.bean.Order;
    import com.dong.spring6.bean.Student;
    import com.dong.spring6.bean.User;
    import com.dong.spring6.bean.Vip;
    import org.junit.Test;
    import org.springframework.context.ApplicationContext;
    import org.springframework.context.support.ClassPathXmlApplicationContext;
    
    public class IOCAnnotationTest {
        @Test
        public static void main(String[] args) {
            ApplicationContext applicationContext=new ClassPathXmlApplicationContext("spring.xml");
            User userBean = applicationContext.getBean("user", User.class);
            System.out.println(userBean);
    
            Vip vipBean = applicationContext.getBean("vip", Vip.class);
            System.out.println(vipBean);
    
            Object orderBean = applicationContext.getBean("order", Order.class);
            System.out.println(orderBean);
    
            Student studentBean = applicationContext.getBean("studentBean", Student.class);
            System.out.println(studentBean);
        }
    }

##### 执行结果： #####

4个对象创建成功！

![403ab9a844cb40d090107d8044bf575e.png][]

###### 上述程序的pom文件完整代码： ######

<?xml version="1.0" encoding="UTF-8"?>
    <project xmlns="http://maven.apache.org/POM/4.0.0"
             xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
             xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
        <modelVersion>4.0.0</modelVersion>
    
        <groupId>com.dong</groupId>
        <artifactId>spring6-008-ioc-annotation</artifactId>
        <version>1.0-SNAPSHOT</version>
    
        
        <dependencies>
            
            <dependency>
                <groupId>org.springframework</groupId>
                <artifactId>spring-context</artifactId>
                <version>6.0.0</version>
            </dependency>
    
            
            <dependency>
                <groupId>junit</groupId>
                <artifactId>junit</artifactId>
                <version>4.12</version>
                <scope>test</scope>
            </dependency>
    
        </dependencies>
        
        <properties>
            <maven.compiler.source>19</maven.compiler.source>
            <maven.compiler.target>19</maven.compiler.target>
            <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        </properties>
    
    </project>

#### 如果是多个包怎么办？有两种解决方案： ####

*  **第一种：在配置文件中指定多个包，用逗号隔开。**
 *  **第二种：指定多个包的共同父包。**

1、

<context:component-scan base-package="com.dong.spring6.bean,com.dong.spring6.bean2"/>

2、

<context:component-scan base-package="com.dong.spring6"/>

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

## 12.4 选择性实例化Bean ##

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

这里为了方便，将这几个类都定义到同一个java源文件中了

package com.dong.spring6.bean3;
    
    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的无参数构造方法执行");
        }
    }
    
    @Controller
    class F {
        public F() {
            System.out.println("F的无参数构造方法执行");
        }
    }

**我只想实例化bean3包下的Controller。配置文件这样写：**

**spring-choose.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: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.dong.spring6.bean3" use-default-filters="false">
            <context:include-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
        </context:component-scan>
        
    </beans>

>  *  use-default-filters="true" 表示：使用spring默认的规则，只要有Component、Controller、Service、Repository中的任意一个注解标注，则进行实例化。
>  *  **use-default-filters="false"** 表示：不再spring默认实例化规则，即使有Component、Controller、Service、Repository这些注解标注，也不再实例化。
>  *  <context:include-filter type="annotation" expression="org.springframework.stereotype.Controller"/> **表示只有Controller进行实例化。**

### 测试程序 ###

@Test
    public void testChoose(){
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring-choose.xml");
    }

### 执行结果： ###

![image.png][image.png 1]

> **也可以将use-default-filters设置为true（不写就是true），并且采用exclude-filter方式排出哪些注解标注的Bean不参与实例化：**

**spring-choose.xml**

<context:component-scan base-package="com.powernode.spring6.bean3">
      <context:exclude-filter type="annotation" expression="org.springframework.stereotype.Repository"/>
      <context:exclude-filter type="annotation" expression="org.springframework.stereotype.Service"/>
      <context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller"/>
    </context:component-scan>

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

## 12.5 负责注入的注解【非常重要！！！！】 ##

@Component @Controller @Service @Repository 这四个注解是用来声明Bean的，声明后这些Bean将被实例化。接下来我们看一下，如何给Bean的属性赋值。给Bean属性赋值需要用到这些注解：

*  @Value
 *  @Autowired
 *  @Qualifier
 *  @Resource

### 12.5.1 @Value ###

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

#### **代码** ####

<?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.dong.spring6.bean3"/>
    
    </beans>

package com.dong.spring6.bean3;
    
    import org.springframework.beans.factory.annotation.Value;
    import org.springframework.stereotype.Component;
    
    import javax.sql.DataSource;
    import java.io.PrintWriter;
    import java.sql.Connection;
    import java.sql.SQLException;
    import java.sql.SQLFeatureNotSupportedException;
    import java.util.logging.Logger;
    
    @Component
    public class MyDataSource implements DataSource {
        @Value(value = "com.mysql.cj.Driver")
        private String driver;
        @Value("jdbc:mysql://localhost:3306/spring6")
        private String url;
        @Value("root")
        private String username;
        @Value("123456")
        private String password;
    
        //使用@Value注解注入的话，可以用在属性上，并且可以不提供setter方法
    /*    public void setDriver(String driver) {
            this.driver = driver;
        }
    
        public void setUrl(String url) {
            this.url = url;
        }
    
        public void setUsername(String username) {
            this.username = username;
        }
    
        public void setPassword(String password) {
            this.password = password;
        }*/    
    
        @Override
        public String toString() {
            return "MyDataSource{" +
                    "driver='" + driver + '\'' +
                    ", url='" + url + '\'' +
                    ", username='" + username + '\'' +
                    ", password='" + password + '\'' +
                    '}';
        }
    
        @Override
        public Connection getConnection() throws SQLException {
            return null;
        }
    
        @Override
        public Connection getConnection(String username, String password) throws SQLException {
            return null;
        }
    
        @Override
        public PrintWriter getLogWriter() throws SQLException {
            return null;
        }
    
        @Override
        public void setLogWriter(PrintWriter out) throws SQLException {
    
        }
    
        @Override
        public void setLoginTimeout(int seconds) throws SQLException {
    
        }
    
        @Override
        public int getLoginTimeout() throws SQLException {
            return 0;
        }
    
        @Override
        public Logger getParentLogger() throws SQLFeatureNotSupportedException {
            return null;
        }
    
        @Override
        public <T> T unwrap(Class<T> iface) throws SQLException {
            return null;
        }
    
        @Override
        public boolean isWrapperFor(Class<?> iface) throws SQLException {
            return false;
        }
    }

package com.dong.spring6.test;
    
    import com.dong.spring6.bean.Order;
    import com.dong.spring6.bean.Student;
    import com.dong.spring6.bean.User;
    import com.dong.spring6.bean.Vip;
    import com.dong.spring6.bean3.MyDataSource;
    import org.junit.Test;
    import org.springframework.context.ApplicationContext;
    import org.springframework.context.support.ClassPathXmlApplicationContext;
    
    public class IOCAnnotationTest {
        @Test
        public void testDIByAnnotation(){
            ApplicationContext applicationContext=new ClassPathXmlApplicationContext("spring-di-annotation.xml");
            MyDataSource myDataSource = applicationContext.getBean("myDataSource", MyDataSource.class);
            /*
              MyDataSource{driver='com.mysql.cj.Driver', url='jdbc:mysql://localhost:3306/spring6', username='root', password='123456'}
             */
            System.out.println(myDataSource);
    
        }
    }

#### 运行结果： ####

![f06675007d5d45ed918bf93be267a69e.png][]

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

### 12.5.2 @Autowired与@Qualifier ###

**@Autowired注解可以用来注入非简单类型。被翻译为：自动连线的，或者自动装配。**

**单独使用@Autowired注解，默认根据类型装配。【默认是byType】**

#### 看一下它的源码： ####

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;
    }

##### 源码中有两处需要注意： #####

*  第一处：该注解可以标注在哪里？

*   *  构造方法上
     *  方法上
     *  形参上
     *  属性上
     *  注解上

*  第二处：该注解有一个required属性，默认值是true，表示在注入的时候要求被注入的Bean必须是存在的，如果不存在则报错。如果required属性设置为false，表示注入的Bean存在或者不存在都没关系，存在的话就注入，不存在的话，也不报错。

#### **我们先在属性上使用@Autowired注解：** ####

package com.dong.spring6.dao;
    
    public interface UserDao {
        void insert();
    }

package com.dong.spring6.dao;
    
    import org.springframework.stereotype.Repository;
    
    @Repository //纳入bean管理
    public class UserDaoForMySQL implements UserDao{
        @Override
        public void insert() {
            System.out.println("正在向mysql数据库插入User数据");
        }
    }

package com.dong.spring6.service;
    
    import com.dong.spring6.dao.UserDao;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Service;
    
    @Service // 纳入bean管理
    public class UserService {
    
        @Autowired // 在属性上注入
        private UserDao userDao;
        
        // 没有提供构造方法和setter方法。
    
        public void save(){
            userDao.insert();
        }
    }

#### **配置包扫描** ####

<?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.dao,com.powernode.spring6.service"/>
    </beans>

#### **测试程序** ####

@Test
    public void testAutowired(){
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("spring-injection.xml");
        UserService userService = applicationContext.getBean("userService", UserService.class);
        userService.save();
    }

#### 执行结果： ####

![image.png][image.png 2]

以上构造方法和setter方法都没有提供，经过测试，仍然可以注入成功。

#### **接下来，再来测试一下@Autowired注解出现在setter方法上：** ####

UserService

package com.dong.spring6.service;
    
    import com.dong.spring6.dao.UserDao;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Service;
    
    @Service
    public class UserService {
    
        private UserDao userDao;
    
        @Autowired
        public void setUserDao(UserDao userDao) {
            this.userDao = userDao;
        }
    
        public void save(){
            userDao.insert();
        }
    }

##### 执行结果： #####

![image.png][image.png 3]

#### **我们再来看看能不能出现在构造方法上：** ####

package com.dong.spring6.service;
    
    import com.dong.spring6.dao.UserDao;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Service;
    
    @Service
    public class UserService {
    
        private UserDao userDao;
    
        @Autowired
        public UserService(UserDao userDao) {
            this.userDao = userDao;
        }
    
        public void save(){
            userDao.insert();
        }
    }

##### 执行结果： #####

![image.png][image.png 4]

####  **再来看看，这个注解能不能只标注在构造方法的形参上：** ####

package com.dong.spring6.service;
    
    import com.dong.spring6.dao.UserDao;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Service;
    
    @Service
    public class UserService {
    
        private UserDao userDao;
    
        public UserService(@Autowired UserDao userDao) {
            this.userDao = userDao;
        }
    
        public void save(){
            userDao.insert();
        }
    }

##### 执行结果： #####

![image.png][image.png 5]

#### **还有更劲爆的，当有参数的构造方法只有一个时，@Autowired注解可以省略。** ####

package com.dong.spring6.service;
    
    import com.dong.spring6.dao.UserDao;
    import org.springframework.stereotype.Service;
    
    @Service
    public class UserService {
    
        private UserDao userDao;
    
        public UserService(UserDao userDao) {
            this.userDao = userDao;
        }
    
        public void save(){
            userDao.insert();
        }
    }

##### 执行结果： #####

![image.png][image.png 6]

#### **当然，如果有多个构造方法，@Autowired肯定是不能省略的。** ####

package com.dong.spring6.service;
    
    import com.dong.spring6.dao.UserDao;
    import org.springframework.stereotype.Service;
    
    @Service
    public class UserService {
    
        private UserDao userDao;
    
        public UserService(UserDao userDao) {
            this.userDao = userDao;
        }
        
        public UserService(){
            
        }
    
        public void save(){
            userDao.insert();
        }
    }

##### 执行结果： #####

![0b341b9061105a1e8f5d925ca0ce3cd2.png][]

到此为止，我们已经清楚@Autowired注解可以出现在哪些位置了。

@Autowired注解默认是byType进行注入的，也就是说根据类型注入的，如果以上程序中，UserDao接口还有另外一个实现类，会出现问题吗？

错误信息中说：不能装配，UserDao这个Bean的数量大于1.

怎么解决这个问题呢？**当然要byName，根据名称进行装配了。**

@Autowired注解和@Qualifier注解联合起来才可以根据名称进行装配，在@Qualifier注解中指定Bean名称。

package com.dong.spring6.dao;
    
    import org.springframework.stereotype.Repository;
    
    @Repository // 这里没有给bean起名，默认名字是：userDaoForOracle
    public class UserDaoForOracle implements UserDao{
        @Override
        public void insert() {
            System.out.println("正在向Oracle数据库插入User数据");
        }
    }

package com.dong.spring6.service;
    
    import com.dong.spring6.dao.UserDao;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.beans.factory.annotation.Qualifier;
    import org.springframework.stereotype.Service;
    
    @Service
    public class UserService {
    
        private UserDao userDao;
    
        @Autowired
        @Qualifier("userDaoForOracle") // 这个是bean的名字。
        public void setUserDao(UserDao userDao) {
            this.userDao = userDao;
        }
    
        public void save(){
            userDao.insert();
        }
    }

执行结果：

![878eeca6e6b77ee826877bf9af99a0ff.png][]

#### 总结： ####

*  **@Autowired注解可以出现在：属性上、构造方法上、构造方法的参数上、setter方法上。**
 *  **当带参数的构造方法只有一个，@Autowired注解可以省略。**
 *  **@Autowired注解默认根据类型注入。如果要根据名称注入的话，需要配合@Qualifier注解一起使用。**

### 12.5.3 @Resource ###

@Resource注解也可以完成非简单类型注入。那它和@Autowired注解有什么区别？

*  @Resource注解是JDK扩展包中的，也就是说属于JDK的一部分。所以该注解是标准注解，更加具有通用性。(JSR-250标准中制定的注解类型。JSR是Java规范提案。)
 *  @Autowired注解是Spring框架自己的。
 *  **@Resource注解默认根据名称装配byName，未指定name时，使用属性名作为name。通过name找不到的话会自动启动通过类型byType装配。**
 *  **@Autowired注解默认根据类型装配byType，如果想根据名称装配，需要配合@Qualifier注解一起用。**
 *  @Resource注解用在属性上、setter方法上。
 *  @Autowired注解用在属性上、setter方法上、构造方法上、构造方法参数上。

@Resource注解属于JDK扩展包，所以不在JDK当中，需要额外引入以下依赖：【**如果是JDK8的话不需要额外引入依赖。高于JDK11或低于JDK8需要引入以下依赖。**】

**如果你是Spring6+版本请使用这个依赖**

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

一定要注意：**如果你用Spring6，要知道Spring6不再支持JavaEE，它支持的是JakartaEE9。（Oracle把JavaEE贡献给Apache了，Apache把JavaEE的名字改成JakartaEE了，大家之前所接触的所有的 javax.\* 包名统一修改为 jakarta.\*包名了。）**

**如果你是spring5-版本请使用这个依赖**

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

#### @Resource注解的源码如下： ####

![image.png][image.png 7]

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

#### 测试一下： ####

##### 给这个UserDaoForOracle起名xyz #####

package com.dong.spring6.dao;
    
    import org.springframework.stereotype.Repository;
    
    @Repository("xyz")
    public class UserDaoForOracle implements UserDao{
        @Override
        public void insert() {
            System.out.println("正在向Oracle数据库插入User数据");
        }
    }

##### 在UserService中使用Resource注解根据name注入 #####

package com.dong.spring6.service;
    
    import com.dong.spring6.dao.UserDao;
    import jakarta.annotation.Resource;
    import org.springframework.stereotype.Service;
    
    @Service
    public class UserService {
    
        @Resource(name = "xyz")
        private UserDao userDao;
    
        public void save(){
            userDao.insert();
        }
    }

##### 执行测试程序： #####

![image.png][image.png 8]

#### **我们把UserDaoForOracle的名字xyz修改为userDao，让这个Bean的名字和UserService类中的UserDao属性名一致：** ####

UserDaoForOracle

package com.dong.spring6.dao;
    
    import org.springframework.stereotype.Repository;
    
    @Repository("userDao")
    public class UserDaoForOracle implements UserDao{
        @Override
        public void insert() {
            System.out.println("正在向Oracle数据库插入User数据");
        }
    }

UserService类中Resource注解并没有指定name

package com.dong.spring6.service;
    
    import com.dong.spring6.dao.UserDao;
    import jakarta.annotation.Resource;
    import org.springframework.stereotype.Service;
    
    @Service
    public class UserService {
    
        @Resource
        private UserDao userDao;
    
        public void save(){
            userDao.insert();
        }
    }

##### 执行测试程序： #####

![image.png][image.png 9]

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

接下来把UserService类中的属性名修改一下：

#### UserService的属性名修改为userDao2 ####

package com.dong.spring6.service;
    
    import com.dong.spring6.dao.UserDao;
    import jakarta.annotation.Resource;
    import org.springframework.stereotype.Service;
    
    @Service
    public class UserService {
    
        @Resource
        private UserDao userDao2;
    
        public void save(){
            userDao2.insert();
        }
    }

##### 执行结果： #####

![6876ff0bb751221e97f769ac988de4e1.png][]

根据异常信息得知：显然当通过name找不到的时候，自然会启动byType进行注入。以上的错误是因为UserDao接口下有两个实现类导致的。所以根据类型注入就会报错。

我们再来看@Resource注解使用在setter方法上可以吗？

#### UserService添加setter方法并使用注解标注 ####

package com.dong.spring6.service;
    
    import com.dong.spring6.dao.UserDao;
    import jakarta.annotation.Resource;
    import org.springframework.stereotype.Service;
    
    @Service
    public class UserService {
    
        private UserDao userDao;
    
        @Resource
        public void setUserDao(UserDao userDao) {
            this.userDao = userDao;
        }
    
        public void save(){
            userDao.insert();
        }
    }

注意这个setter方法的方法名，setUserDao去掉set之后，将首字母变小写userDao，userDao就是name

##### 执行结果： #####

![image.png][image.png 10]

#### 当然，也可以指定name： ####

UserService

package com.dong.spring6.service;
    
    import com.dong.spring6.dao.UserDao;
    import jakarta.annotation.Resource;
    import org.springframework.stereotype.Service;
    
    @Service
    public class UserService {
    
        private UserDao userDao;
    
        @Resource(name = "userDaoForMySQL")
        public void setUserDao(UserDao userDao) {
            this.userDao = userDao;
        }
    
        public void save(){
            userDao.insert();
        }
    }

##### 执行结果： #####

![fad0f8ae6b8a3607721dc4f59e950a85.png][]

#### **一句话总结@Resource注解：** ####

**默认byName注入，没有指定name时把属性名当做name，根据name找不到时， 才会byType注入。byType注入时，某种类型的Bean只能有一个。**

## 12.6 全注解式开发 ##

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

#### 配置类代替spring配置文件 ####

package com.dong.spring6.config;
    
    import org.springframework.context.annotation.ComponentScan;
    import org.springframework.context.annotation.ComponentScans;
    import org.springframework.context.annotation.Configuration;
    
    @Configuration
    @ComponentScan({"com.dong.spring6.dao", "com.dong.spring6.service"})
    public class Spring6Configuration {
    }

##### 编写测试程序：不再new ClassPathXmlApplicationContext()对象了。 #####

@Test
    public void testNoXml(){
        ApplicationContext applicationContext = new AnnotationConfigApplicationContext(Spring6Configuration.class);
        UserService userService = applicationContext.getBean("userService", UserService.class);
        userService.save();
    }

##### 执行结果 #####

![image.png][image.png 11]

[f640f5867b0c42e5a07e5c9d4f5646ff.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/ca89f818893545d694526bef5c73b5ec.png
[b4e9a0a08fb3458aaa57fa74106ae20f.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/74316dc74cc34de9ad90fd5075366b17.png
[b25b19ece4625ce28aecbaa6814fad96.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/643e4094475a4b92a435b034dea01fc4.png
[image.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/d120997b24a04632bec907b090c360fb.png
[403ab9a844cb40d090107d8044bf575e.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/9018cfd078344169bed8f14434854206.png
[image.png 1]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/9aaeff4d79f64b188388ac862fb7673a.png
[f06675007d5d45ed918bf93be267a69e.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/53ea79080ac446f897a4cfac7b9b4bb0.png
[image.png 2]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/557ae67a04b14175ab215563ecf905ee.png
[image.png 3]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/ff99439c781142eca345b9bf0e2b1810.png
[image.png 4]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/d91087a2d1b14ca397cc21f1c5762d73.png
[image.png 5]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/958db53f48004426b26d0ca2ff57778f.png
[image.png 6]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/50edd04d44584e60b1a8da0d333dcd36.png
[0b341b9061105a1e8f5d925ca0ce3cd2.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/a00ce4be18064bba9f72c9e49d30182b.png
[878eeca6e6b77ee826877bf9af99a0ff.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/da3ca71c528e42eca3ddf82f8ef7f3c4.png
[image.png 7]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/7afa9dc7f9d7434296560e12c2a45f92.png
[image.png 8]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/1dde57e579674618aa190f171db60317.png
[image.png 9]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/d3fc891e667f4f55be7fe4ab6311e2ed.png
[6876ff0bb751221e97f769ac988de4e1.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/5007e8ddaf51439fa4cde0063bcaedb8.png
[image.png 10]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/a4deb73b3d284bae8e3dc1fc71698a04.png
[fad0f8ae6b8a3607721dc4f59e950a85.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/e465baef154345ed86b61d5e4712e89d.png
[image.png 11]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/9e77c73ee8914f70a6b468d2aedbf719.png