spring-第十一章注解开发

spring

文章目录

spring
前言
1.注解回顾
- 1.1原理
- 1.2springIOC注解扫描原理
- - 1.2.1解释
  - 1.2.2案例
2.声明bean的注解
- 补充：@Bean注解，管理三方包对象
3.spring注解的使用
- 3.1加入aop依赖
- 3.2配置文件中添加context命名空间
- 3.3配置文件中指定要扫描的包
- 3.4在Bean上使用注解
- 3.5测试
- 3.6注意事项
4.选择性实例化Bean
5.负责注入的注解
- 5.1@Value
- 5.2@Autowired和@Qualifier
- - 5.2.1@Autowired按类型注入
  - 5.2.2@Autowired和@Qualifier按名称注入
- 5.3@Resource
- - 5.3.1使用
6.全注解式开发
总结

前言

本章我们介绍如何使用注解代替xml进行开发。

1.注解回顾

1.1原理

注解添加后可以使用反射机制来检查注解是否存在，然后取出其中的属性值，这样一来，我们在框架中就可以使用注解进行快速配置了。
比如：框架在调用某方法时，先检查该方法有没有注解，如果有就取出注解中的属性值作为方法参数，否则就使用默认参数。
详情看java基础。

1.2springIOC注解扫描原理

1.2.1解释

前面我们使用xml配置文件完成spring的bean配置功能，了解到spring从xml文件中读取id作为bean的名称，读取class获取类路径来使用反射机制创建bean实例。
如果我们能够注解来提供这两项信息，那么也就说明我们使用注解也能完成bean的实例化，这就是我们使用注解进行开发的原理。
具体实现思路：
我们可以在只知到包路径的情况下，逐一扫描该包下所有的类，来确定哪些类添加了注解，并为这些添加了注解的类进行实例化。

1.2.2案例

我们现在自定义一个注解——Component
提供一些可能需要管理的bean类——Order、User、Vip
提供扫描注解的功能类——ComponentScan
以下是它们的代码：
Component

@Target(ElementType.TYPE)  
@Retention(RetentionPolicy.RUNTIME)  
public @interface Component {  String value() default "";  
}

注意：
要添加元注解**Retention(RetntionPolicy.RUNTIME)**才可以让该注解被反射机制读取
Order

@Component("orderBean")  
public class Order {  
}

User

@Component("userBean")  
public class User {  
}

Vip

public class Vip {  
}

ComponentScan

public class ComponentScan {  public static void main(String[] args) throws ClassNotFoundException, InstantiationException, IllegalAccessException {  
//        定义Map集合存储实例化完成的bean  HashMap beanMap = new HashMap<>();  //        目前只知道一个包的名字，我们需要扫描该包下所有的带注解的类，并为其实例化  String packageName = "org.example.bean";  
//        把包名替换为路径名  String replace = packageName.replace('.', '/');  
//        获取绝对路径  URL resource = ClassLoader.getSystemClassLoader().getResource(replace);  String path = resource.getPath();  
//        使用绝对路径创建File对象  File file = new File(path);  
//        遍历bean包下的所有文件  for (File listFile : file.listFiles()) {  
//            从文件名中提取出每个类的类名，比如从User.class中提取出User  String s = listFile.getName().split("\\.")[0];  
//            拼接包名，得到类路径  String className = packageName + "." + s;  
//            使用类路径和反射机制获取Class对象  Class aClass = Class.forName(className);  
//            判断当前类是否使用Component注解  if (aClass.isAnnotationPresent(Component.class)) {  
//                有Component注解，为其实例化  Component component = aClass.getAnnotation(Component.class);  
//                从注解中取出属性，即我们的beanName,或者说id  String id = component.value();  Object o = aClass.newInstance();  
//                把Component中的属性看作beanName，作为key传入map,并把创建的实例对象作为value传入  beanMap.put(id, o);  }  }  
//        查看map集合中是否有数据  System.out.println(beanMap);  }  
}

结果为：
请添加图片描述

可以看到，添加了我们自定义注解**@Component**的Order类和User类都成功实例化并存储。

2.声明bean的注解

spring提供了专门声明Bean的注解，常见的包括以下四个：

@Component：常规声明Bean的注解

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：声明控制层类为Bean的注解

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：声明业务层类为Bean的注解

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：声明DAO层为bean的注解

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

从源码上看，四个注解没什么区别，后三个注解是@Component注解的别名注解。但使用这四个注解都可以把当前类标注为bean,设置四个相同功能的注解只是为了从名称上进行区分，增加代码可读性。

补充：@Bean注解，管理三方包对象

上面的四个注解都是添加在类上，然后IOC会创建这些类的对象并管理成bean。
但是有时后我们可能想要把一个三方包中类的对象管理成bean使用，这种情况下我们不可能去三方包中改别人的源码（在他们的类上添加@component等注解）。
这种时候就需要使用@Bean注解，这个注解需要添加在一个有返回值的方法上。
这样一来，spring会执行这个方法，并将该方法返回的对象作为bean存到容器中。
这样一来我们就可以在容器中存储来自三方包中的对象。比如druid中会有一个数据源类DruidDataSource,我们可以用以下代码来存储一个创建好的DruidDataSource对象到容器中：

@Bean  public DataSource getDataSource(){  DruidDataSource dataSource = new DruidDataSource();  dataSource.setDriverClassName("com.mysql.cj.jdbc.Driver");  dataSource.setUrl("jdbc:mysql://localhost:3306/spring6");  dataSource.setUsername("root");  dataSource.setPassword("root");  return dataSource;  }

这样一来其他数据库相关框架在连接连接数据库时需要配置数据源，我们就可以使用该bean进行注入使用。

3.spring注解的使用

接下来我们使用上述的四个注解来对bean进行实例化。

3.1加入aop依赖

虽然说的是要导入spring-aop依赖，但我们导入spring-context依赖后就因为依赖继承的原因已经把spring-aop一起导入了，所有这里可以只要导入spring-context即可。
请添加图片描述

3.2配置文件中添加context命名空间

<?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"> </beans>

3.3配置文件中指定要扫描的包

<?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"/> </beans>

3.4在Bean上使用注解

package com.powernode.spring6.bean;  import org.springframework.stereotype.Component;  @Component(value = "userBean")  
public class User {  
}

3.5测试

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

3.6注意事项

如果注解的属性名是value，那么**value=**是可以省略的。
如果把value属性彻底去掉，spring会为bean自动取名,并且默认名字的规律是：Bean类名首字母小写即可。如BankDao的bean的名字为：bankDao

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

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

4.选择性实例化Bean

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

package com.powernode.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的无参数构造方法执行");  }  
}

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

<?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.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进行实例化。
```

5.负责注入的注解

spring提供了专门的注解完成依赖注入功能：

@Value：注入简单类型
@Autowired：根据类型自动完成注入
@Qualifier：配合Autowired完成根据名称自动装配
@Resource：和@Autowired一样完成非简单类型装配，区别看下面

5.1@Value

可以注入简单类型，直接传入简单类型的参数值即可，比如我们现在注入一个User类中的属性。
User类

package org.example.pojo;  import org.springframework.beans.factory.annotation.Value;  
import org.springframework.stereotype.Component;  @Component  
public class User {  @Value("张三")  private String name;  @Value("20")  private int age;  public String getName() {  return name;  }  public void setName(String name) {  this.name = name;  }  public int getAge() {  return age;  }  public void setAge(int age) {  this.age = age;  }  @Override  public String toString() {  return "User{" +  "name='" + name + '\'' +  ", age=" + age +  '}';  }  
}

需要先将User类管理成bean
不要求必须提供属性对应的set方法
注解中的参数值是字符串

配置文件
实例化操作、注入操作都使用注解完成，这里的配置文件作用是指定bean扫描路径，让spring能够根据传入的路径正确的扫描到我们的User类，并根据注解对其完成实例化和属性注入操作。

<?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="org.example.pojo"/> </beans>

测试类
编写测试类看是否能够成功获取注入完成的user实例

import org.example.pojo.User;  
import org.springframework.context.ApplicationContext;  
import org.springframework.context.support.ClassPathXmlApplicationContext;  public class Test {  @org.junit.jupiter.api.Test  public void valueTest(){  ApplicationContext context = new ClassPathXmlApplicationContext("spring-di-annotation.xml");  User user = context.getBean("user", User.class);  System.out.println(user);  }  
}

补充：
@Value注解还可以用在方法中，包括构造方法
用在普通方法中
请添加图片描述

用在构造方法中
请添加图片描述

5.2@Autowired和@Qualifier

这两个注解用来进行非简单类型属性的注入。
先看注解的源码

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存在或者不存在都没关系，存在的话就注入，不存在的话，也不报错。

5.2.1@Autowired按类型注入

单独使用@Autowired注解会按类型进行属性注入。
接下来进行使用，我们还是以UserDao和UserService类为例进行测试，会向UserService类中注入UserDao.
UserDao接口

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

UserDao实现类

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

需要将其管理为bean并进行实例化，后面作为值注入
UserService

package com.powernode.spring6.service;  import com.powernode.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();  }  
}

不依靠set方法

配置文件
需要配置扫描路径，让spring能够成功扫描到类并

<?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();  
}

补充

当有参数的构造方法只有一个并且参数名与属性名对应时，@Autowired注解可以省略，比如以下代码虽然没使用注解，但userDao属性也会自动注入.

package com.powernode.spring6.service;  import com.powernode.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();  }  
}

5.2.2@Autowired和@Qualifier按名称注入

当我们有多个同类型的bean可以作为注入的参数值时，就无法按类型进行注入了，这个时候需要通过指定bean的名称来进行注入。
@Autowired和@Qualifier注解一起使用可以按照名称进行注入，在@Qualifier注解中指定Bean名称。
比如：
UserDaoForOracle

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

UserService

package com.powernode.spring6.service;  import com.powernode.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();  }  
}

5.3@Resource

@Resource注解和@Autowired注解一样用来为非简单属性进行注入，但是两者之间还是有以下差别：

@Resource是JDK扩展包中的注解，@Autowired是spring框架中提供的注解
@Resource注解默认先根据名称进行装配，不传入参数值作为名称时，就先把属性名当作实例名尝试进行装配，如果找不到对应的bean就按类型进行装配。
@Autowired默认按类型进行装配，想要经过名称装配需要配合@Qualifier
@Resource可用于属性、setter方法，@Atowrired可用于属性、setter方法、构造方法、构造

5.3.1使用

导入依赖包
要使用@Resource注解需要先导入依赖包，对于spring6版本需要导入以下依赖

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

如果是之前的版本，需要导入其他版本的依赖。
创建bean
这里创建一个dao层对象并管理成bean,并且手动设置bean的名称

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

使用@Resource进行注入
上面设置了bean的名称为"xyz",所以下面要为注解传入参数yz,才可以根据名称成功注入。

package com.powernode.spring6.service;  import com.powernode.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();  }  
}

如果不传入参数，最终根据类型注入也会成功，但是当有多个同类型的bean对象时还是会失效。
最后还是要使用配置文件指定bean的扫描目录。

6.全注解式开发

前面已经把bean的实例化、依赖注入两个工作交给注解完成，但还是需要在配置文件中指定bean的扫描目录。
如果有注解能够完成这个工作，那么我们就不再需要配置文件了。
spring中提供了两个注解来完成这个工作：

@Configuration:标识一个类为配置类
@ComponentScan:配置bean的扫描路径，可以传入字符串数组作为参数。

如：

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

因为已经没有配置文件了，所以我们获取容器的方式也有所改变

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