Spring 注解

教程
Spring

春季注解允许我们通过Java程序配置依赖关系并实现依赖注入。

春季注解

  • 春季框架实现并推广控制反转（IOC）或依赖注入（DI）原则，实际上是一个IOC容器。
  • 传统上，Spring允许开发人员使用基于XML的配置来管理bean的依赖关系。
  • 还有一种定义bean及其依赖关系的替代方法，即基于Java的配置。
  • 与XML方法不同，基于Java的配置允许您以编程方式管理bean组件。这就是引入Spring注解的原因。

在本文中，我们将探讨最常用的Spring注解，并查看一些示例程序。

Spring注解列表

一些Spring核心框架注解包括：

  1. @Configuration：用于指示类声明一个或多个@Bean方法。这些类由Spring容器处理，以在运行时生成bean定义和为这些bean提供服务请求。

  2. @Bean：表示一个方法生成一个由Spring容器管理的bean。这是最常用且最重要的Spring注解之一。@Bean注解还可以与参数（如name、initMethod和destroyMethod）一起使用。

    • name – 允许为bean指定名称
    • initMethod – 允许选择在上下文注册时调用的方法
    • destroyMethod – 允许选择在上下文关闭时调用的方法

    例如：

    @Configuration
public class AppConfig {

    @Bean(name = "comp", initMethod = "turnOn", destroyMethod = "turnOff")
    Computer computer(){
        return new Computer();
    }
}

    public class Computer {

    public void turnOn(){
        System.out.println("加载操作系统");
    }
    public void turnOff(){
        System.out.println("关闭所有程序");
    }
}

  3. @PreDestroy 和 @PostConstruct 是 bean initMethod 和 destroyMethod 的替代方式。当我们定义 bean 类时，可以使用它们。例如：

     public class Computer {

    @PostConstruct
    public void turnOn(){
        System.out.println("Load operating system");
    }

    @PreDestroy
    public void turnOff(){
        System.out.println("Close all programs");
    }
}

  4. @ComponentScan: 配置与@Configuration类一起使用的组件扫描指令。在这里，我们可以指定要扫描的基础包以查找 spring 组件。

  5. @Component: 表示带注释的类是“组件”。在使用基于注解的配置和类路径扫描时，这些类被视为自动检测的候选项。

  6. @PropertySource：为将属性源添加到Spring的环境提供了一种简单的声明性机制。还有一个类似的注解用于添加属性源文件的数组，即@PropertySources。

  7. @Service：指示被注解的类是一个“服务”。此注解作为@Component的一个特殊化，允许通过类路径扫描自动检测实现类。

  8. @Repository：指示被注解的类是一个“存储库”。此注解作为@Component的一个特殊化，建议与DAO类一起使用。

  9. @Autowired：用于自动注入bean。Spring的@Autowired注释与@Qualifier注释一起使用，以避免当我们为相同类型配置两个或更多个bean时出现混淆。

Spring MVC注释

一些重要的Spring MVC注释包括：

  1. @Controller
  2. @RequestMapping
  3. @PathVariable
  4. @RequestParam
  5. @ModelAttribute
  6. @RequestBody 和 @ResponseBody
  7. @RequestHeader 和 @ResponseHeader

您可以在 Spring MVC 教程 中了解更多关于它们的信息。

Spring 事务管理注解

@Transactional 是 Spring 声明式事务管理的注解，更多信息请阅读 Spring MVC Hibernate。

Spring 安全注解

@EnableWebSecurity 与 @Configuration 类一起使用，以定义 Spring Security 配置，请阅读更多内容，请参阅 Spring Security 示例。

Spring Boot 注解

  1. @SpringBootApplication
  2. @EnableAutoConfiguration

阅读更多信息，请参阅 Spring Boot 示例。

Spring 注解示例

让我们看一个简单的示例，在这个示例中我们将在我们的应用程序中使用 Spring 注解。下面的图片展示了我的 Spring 注解示例项目。

Spring 框架依赖

I have created the maven project and added Spring Core Framework dependencies.

<project xmlns="https://maven.apache.org/POM/4.0.0" xmlns:xsi="https://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="https://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>
	<groupId>com.journaldev.spring</groupId>
	<artifactId>spring-annotations</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<name>Spring Annotations</name>

	<properties>
		<spring.framework>4.3.0.RELEASE</spring.framework>
	</properties>

	<dependencies>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-context</artifactId>
			<version>${spring.framework}</version>
		</dependency>
		<dependency>
			<groupId>org.springframework</groupId>
			<artifactId>spring-core</artifactId>
			<version>${spring.framework}</version>
		</dependency>

	</dependencies>

</project>

这将为我们的项目提取所有的 spring 核心 jar 包。

组件类

下一步是创建组件类。这里我正在模仿多个数据库组件，一个用于 MySQL，另一个用于 Oracle。

package com.journaldev.drivers;

public interface DataBaseDriver {
    public String getInfo();
}

DataBaseDriver 是我们将实现的基本 接口。

package com.journaldev.drivers;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.PropertySource;
import org.springframework.stereotype.Component;

@Component
@PropertySource("classpath:mysqldatabase.properties")
public class MySqlDriver implements DataBaseDriver {

    @Value("${databaseName}")
    private String databaseName;
    @Value("${disableStatementPooling}")
    private String disableStatementPooling;

    public String getInfo() {
        return "[ Driver: mySql" +
                ", databaseName: " + databaseName +
                ", disableStatementPooling: " + disableStatementPooling +
                " ]";
    }
}

注意使用 @Component 注解来指示 Spring 框架将此类视为组件。我们还在运行时使用 @PropertySource 和 @Value 注解，Spring 将使用这些注解来从指定的属性文件中注入和设置这些变量值。下面是在 mysqldatabase.properties 文件中声明的属性。

databaseName=school
disableStatementPooling=true

package com.journaldev.drivers;

public class OracleDriver implements DataBaseDriver {

    protected String url;
    protected String user;
    protected String password;
    protected String driver;
    protected Integer port;


    public String getUrl() {
        return url;
    }

    public String getUser() {
        return user;
    }

    public void setUser(String user) {
        this.user = user;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public String getDriver() {
        return driver;
    }

    public void setDriver(String driver) {
        this.driver = driver;
    }

    public Integer getPort() {
        return port;
    }

    public void setPort(Integer port) {
        this.port = port;
    }

    public void setUrl(String url) {
        this.url = url;
    }

    public String getInfo() {
        return "[ Driver: Oracle" +
                ", url: " + url +
                ", port; " + port +
                ", user: " + user +
                ", password: " + password  +
                ", driver: " + driver +
                " ] ";
    }
}

OracleDriver 是一个简单的 bean，我们将使用服务类将属性注入到此 bean 中。

Spring 服务类

package com.journaldev.service;

import com.journaldev.drivers.DataBaseDriver;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Service;

@Service
public class UserService {

    @Autowired
    @Qualifier("oracleDriver")
    private DataBaseDriver dataBaseDriver;

    public String getDriverInfo(){
        return dataBaseDriver.getInfo();
    }
}

在这里，我们使用 @Service 注解来指示 Spring 框架将其视为服务类。然后，我们使用 @Autowired 和 @Qualifier("oracleDriver") 注解来告诉 Spring 框架将名为 oracleDriver 的 bean 注入到类属性 dataBaseDriver 中。请注意，我们尚未创建此 Spring bean。

Spring Beans

最后一步是创建我们的 Spring beans 和配置类，将所有内容粘合在一起。

package com.journaldev.config;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.PropertySource;
import org.springframework.core.env.Environment;

import com.journaldev.drivers.DataBaseDriver;
import com.journaldev.drivers.MySqlDriver;
import com.journaldev.drivers.OracleDriver;

@Configuration
@ComponentScan("com.journaldev")
@PropertySource("classpath:oracledatabase.properties")
public class AppConfig {

	@Autowired
        Environment environment;
	
	@Bean
	DataBaseDriver oracleDriver() {
        OracleDriver oracleDriver = new OracleDriver();
	oracleDriver.setDriver(environment.getProperty("db.driver"));
        oracleDriver.setUrl(environment.getProperty("db.url"));
        oracleDriver.setPort(Integer.parseInt(environment.getProperty("db.port")));
        oracleDriver.setUser(environment.getProperty("db.user"));
        oracleDriver.setPassword(environment.getProperty("db.password"));

        return oracleDriver;

	}

	@Bean
	DataBaseDriver mysqlDriver() {
		return new MySqlDriver();
	}
}

请注意 oracleDriver 的 bean 定义。在这种方法中，我们正在从 oracledatabase.properties 文件中读取属性，该文件由 Spring 框架设置为 environment 变量。以下是在 oracledatabase.properties 文件中定义的属性。

db.url=localhost
db.port=4444
db.user=vasiliy
db.password=yilisav
db.driver=driver_name

我们的Spring注解示例项目已经准备好测试了。总结一下，我们执行了以下步骤：

  1. 创建了Maven项目并添加了所需的Spring依赖项。
  2. 创建了组件类，并将资源文件中的属性注入到其变量中。
  3. 如果我们有第三方组件，我们可以使用Service类将依赖项注入其中。就像我们为OracleDriver通过UserService类所做的那样。
  4. 最后，我们创建了Configuration类来定义Spring beans并设置基本包以扫描Spring组件类并配置它们。

Spring注解示例测试

这是我们的主类，用于测试我们的Spring注解示例项目。

package com.journaldev;

import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.support.AbstractApplicationContext;

import com.journaldev.config.AppConfig;
import com.journaldev.drivers.DataBaseDriver;
import com.journaldev.service.UserService;

public class Main {
	public static void main(String[] args) {
	AbstractApplicationContext appContext = new AnnotationConfigApplicationContext(AppConfig.class);

	DataBaseDriver oracle = appContext.getBean("oracleDriver", DataBaseDriver.class);
	DataBaseDriver mysql = appContext.getBean("mysqlDriver", DataBaseDriver.class);
		
        System.out.println("Oracle driver info:");
        System.out.println(oracle.getInfo());
        
        System.out.println("MySQL driver info:");
        System.out.println(mysql.getInfo());

        System.out.println("UserService Information");
	UserService userService = appContext.getBean(UserService.class);
	System.out.println(userService.getDriverInfo());

	appContext.close();
	}
}

下面的图片显示了生成的输出。请注意，我们尚未配置任何日志记录框架，因此所有Spring框架日志都以红色打印到控制台中。这就是关于Spring注解的简要介绍。我在这里列出了大多数重要的注解，但还有很多其他用于特定任务的注解。您可以从下面的链接下载我的Spring注解示例项目。

下载 Spring 注解示例项目

参考：API 文档

Source:
https://www.digitalocean.com/community/tutorials/spring-annotations