【Spring】注解开发

为了提高开发效率，从 Spring 2.0 开始引入了多种注解，而在 Spring 3.0 中则实现了纯注解的开发方式。

一、注解的使用

在 Spring 2.0 之后，使用注解进行开发主要分为两个步骤：

定义 Bean：使用 @Component 注解来定义一个 Bean。
加载 Bean：在核心配置文件中，通过组件扫描功能来加载这些 Bean 所在包。

在定义和使用 Bean 时，我们可以通过指定 Bean 的名称来获取其实现对象，也可以通过类型自动装配来获取对象。

（1）通过指定名称获取 Bean 对象

在使用 @Component 定义 Bean 时，为 Bean 对象起名称。在实际应用时通过名称获取 Bean 对象：

// Bean 的定义
@Component("bookDao")
public class BookDaoImpl implements BookDao {
    @Override
    public void save() {
    }
}

// Bean 的应用
ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
BookDao bookDao = (BookDao) ctx.getBean("bookDao");
System.out.println(bookDao);

在定义 Bean 后，还需要在配置文件 applicationContext.xml 中指定需要 Spring 扫描的包，Spring 会扫描包下的类并注入相应的 Bean 对象：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       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.it"/>
</beans>

（2）通过类型自动装配 Bean 对象

这种方式与通过指定名称获取 Bean 对象的方式不同，因为它不需要为每个 Bean 设置唯一的名称。在实际应用中，Spring 会通过类型来自动装配 Bean 对象。虽然这种方法比指定名称更简便，但在存在多个相同类型的 Bean 的情况下，它就不太适用了。在使用时，仍然需要在配置文件中扫描指定的包。

// Bean 的定义
@Component
public class BookServiceImpl implements BookService {
    private BookDao bookDao;
    public void setBookDao(BookDao bookDao) {
        this.bookDao = bookDao;
    }
}

// Bean 的应用
ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
BookService bookService = ctx.getBean(BookService.class);
System.out.println(bookService);

另外，Spring 提供了 @Component 注解的三个衍生注解，分别是：

@Controller：用于表现层 bean 定义
@Service：用于业务层 bean 定义
@Repository：用于数据层 bean 定义

这些注解的功能与 @Component 相同，它们在不同层的使用主要是为了更清晰地表达代码结构。

二、纯注解模式

Spring 3.0 升级了纯注解开发模式，使用 Java 类代替配置文件，提高了 Spring 开发效率。下面是纯注解模式的简单使用过程：

（1）定义配置类

这里在 config 包下创建一个 SpringConfig 类，通过 @Configuration 注解设定当前类为配置类，通过 @ComponentScan 注解设定扫描路径，以此替代配置文件：

@Configuration
@ComponentScan("com.it")
public class SpringConfig {
}

其中，@ComponentScan 注解只能添加一次，但可以使用数组格式来实现多个扫描路径：

@Configuration
@ComponentScan({"com.it.dao", "com.it.service"})
public class SpringConfig {
}

（2）实际应用

在使用纯注解时，通过为 AnnotationConfigApplicationContext 指定配置类来获取上下文，并通过上下文获取需要的 Bean 对象：

ApplicationContext ctx = new AnnotationConfigApplicationContext(SpringConfig.class);
BookDao bookDao = (BookDao) ctx.getBean("bookDao");
BookService bookService = ctx.getBean(BookService.class);
System.out.println(bookDao);
System.out.println(bookService);

2.1 Bean 作用范围

在纯注解模式下，Bean 的作用范围通过 @Scope 指定：

@Repository("bookDao")
@Scope("singleton")
public class BookDaoImpl implements BookDao {
    @Override
    public void save() {
    }
}

2.2 Bean 生命周期

在纯注解模式下，Bean 生命周期中初始化和销毁阶段通过 @PostConstruct 和 @PreDestroy 注解实现。首先，在 pom.xml 文件中引入 javax 库：

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

接着，在定义 Bean 时，实现初始化和销毁操作：

@Repository("bookDao")
public class BookDaoImpl implements BookDao {
    @Override
    public void save() {
    }

    @PostConstruct
    public void init() {
        System.out.println("Init...");
    }

    @PreDestroy
    public void destroy() {
        System.out.println("Destroy...");
    }
}

在使用时，如果希望看到销毁操作的执行，需要调用 close() 方法：

public class AppForAnnotation {
    public static void main(String[] args) {
        AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext(SpringConfig.class);
        BookDao bookDao = (BookDao) ctx.getBean("bookDao");
        System.out.println(bookDao);
        ctx.close();
    }
}

2.3 Bean 依赖注入

与其他注解模式一样，纯注解模式的 Bean 依赖注入也分引用类型注入和简单类型注入。

（1）引用类型注入

在实现引用类型注入的过程中，可以选择自动装配注入，也可以通过指定名称的方式注入。

自动装配使用 @Autowired 注解实现注入。这种方式基于反射设计创建对象并暴力反射对应属性为私有属性初始化数据，因此无需提供 setter 方法。另外，
自动装配建议使用无参构造方法创建对象（默认），如果不提供对应构造方法，则需提供唯一的构造方法。

// 自动装配
@Component
public class BookServiceImpl implements BookService {
    @Autowired
    private BookDao bookDao;
    // ...
}

指定名称注入使用 @Qualifier 注解指定装配 Bean 的名称。需要注意的是 @Qualifier 注解无法单独使用，必须配合 @Autowired 注解使用。

// 指定名称
@Component
public class BookServiceImpl implements BookService {
    @Autowired
    @Qualifier("bookDao")
    private BookDao bookDao;
    // ...
}

（2）简单类型注入

使用 @Value 注解实现简单类型注入：

@Repository("bookDao")
public class BookDaoImpl implements BookDao {
    @Value("test")
    private String name;
    // ...
}

（3）配置文件注入

在引用类型和简单类型注入的基础上，可以使用配置文件完成更加复杂的注入。在 resources 文件夹下创建配置文件 jdbc.properties，其内容为：

name=test

使用 @PropertySource 注解在配置类中加载内容：

@Configuration
@ComponentScan({"com"})
@PropertySource("jdbc.properties")
public class SpringConfig {
}

通过 @Value 注解和 ${} 配合使用完成注入：

@Repository("bookDao") // 起名称为 bookDao
public class BookDaoImpl implements BookDao {
    @Value("${name}")
    private String name;

    @Override
    public void save() {
        System.out.println("Book dao save ..." + name);
    }
}

注意：路径仅支持单一文件配置，多文件请使用数组格式配置，不允许使用通配符*。

2.4 第三方 Bean 管理

在纯注解模式下，管理自定义 Bean 的过程可以遵循之前提到的定义 Bean 和包扫描的步骤。对于第三方提供的 Bean 对象，管理过程如下：以 Druid 数据库连接池为例。首先，我们需要定义一个方法来获取要管理的对象，也就是 DruidDataSource 对象。然后，在这个方法上添加 @Bean 注解，以表明该方法的返回值是一个 Bean 对象：

public class JdbcConfig {
    // 1. 定义一个方法获取要管理的对象
    // 2. 添加 @Bean，表示当前方法的返回值是一个 Bean
    @Bean("dataSource")
    public DataSource dataSource () {
        DruidDataSource ds = new DruidDataSource();
        ds.setDriverClassName("com.mysql.jdbc.Driver");
        ds.setUrl("jdbc:mysql://localhost:3306/db");
        ds.setUsername("root");
        ds.setPassword("123456");
        return ds;
    }
}

这里将 JDBC 相关的配置类分离出来，并利用 @Import 注解手动加入配置类到核心配置，实现多个配置类的使用：

@Configuration
@Import({JdbcConfig.class})
public class SpringConfig {
}

之后，同样通过 AnnotationConfigApplicationContext 类对象获取上下文，再从上下文中获取指定的 Bean 对象：

public class App {
    public static void main(String[] args) {
        AnnotationConfigApplicationContext ctx = new AnnotationConfigApplicationContext(SpringConfig.class);
        DataSource dataSource = ctx.getBean(DataSource.class);
        System.out.println(dataSource);
    }
}

2.5 第三方 Bean 依赖注入

在纯注解模式下，当管理第三方 Bean 时，如果涉及到 Bean 对象的依赖注入，简单类型和引用类型的依赖注入可以通过以下方式实现：

（1）第三方简单类型注入

简单类型注入只需要为 Bean 定义对应成员变量，并通过 @Value 注解和变量调用实现注入：

public class JdbcConfig {
    @Value("com.mysql.jdbc.Driver")
    private String driver;
    @Value("jdbc:mysql://localhost:3306/db")
    private String url;
    @Value("root")
    private String userName;
    @Value("123456")
    private String password;
    
    // 1. 定义一个方法获取要管理的对象
    // 2. 添加 @Bean，表示当前方法的返回值是一个 Bean
    @Bean("dataSource")
    public DataSource dataSource () {
        DruidDataSource ds = new DruidDataSource();
        ds.setDriverClassName(driver);
        ds.setUrl(url);
        ds.setUsername(userName);
        ds.setPassword(password);
        return ds;
    }
}

（2）第三方引用类型注入

引用类型注入只需要为 Bean 定义方法设置形参即可，容器会根据类型自动装配对象：

public class JdbcConfig {
    @Value("com.mysql.jdbc.Driver")
    private String driver;
    @Value("jdbc:mysql://localhost:3306/db")
    private String url;
    @Value("root")
    private String userName;
    @Value("123456")
    private String password;

    // 1. 定义一个方法获取要管理的对象
    // 2. 添加 @Bean，表示当前方法的返回值是一个 Bean
    @Bean("dataSource")
    public DataSource dataSource (BookDao bookDao) {
        System.out.println(bookDao);
        DruidDataSource ds = new DruidDataSource();
        ds.setDriverClassName(driver);
        ds.setUrl(url);
        ds.setUsername(userName);
        ds.setPassword(password);
        return ds;
    }
}

需要注意的是，使用这种方式的前提是 Bean 对象已经注入，即需要确保传入的 Bean 对象被扫描到（添加 @ComponentScan 注解和对应 @Component 注解）：

@Configuration
@Import({JdbcConfig.class})
@ComponentScan({"com.it"})
public class SpringConfig {
}

@Repository
public class BookDaoImpl implements BookDao {
}