Spring 注释

发表 admin at 2024年8月26日

类别

未分类

标签

Spring Annotations允许我们通过java程序来配置依赖关系并实现依赖注入。

Spring 注解

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

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

Spring 注解列表

Spring核心框架的一些注解如下：

@Configuration：用于指示类声明一个或多个@Bean方法。这些类由 Spring 容器处理，以在运行时生成 bean 定义并为这些 bean 提供服务请求。
@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("Load operating system");
    }
    public void turnOff(){
        System.out.println("Close all programs");
    }
}
```

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

@ComponentScan：配置用于@Configuration类的组件扫描指令。在这里我们可以指定要扫描 Spring 组件的基础包。
@Component：表示注释类是“组件”。使用基于注释的配置和类路径扫描时，此类类被视为自动检测的候选对象。
@PropertySource：提供了一种简单的声明机制，用于将属性源添加到 Spring 的环境中。有一个类似的注释用于添加属性源文件数组，即@PropertySources。
@Service：表示注释的类是“服务”。此注释充当@Component的特化，允许通过类路径扫描自动检测实现类。
@Repository：表示注释的类是“存储库”。此注释是@Component的特化，建议与 DAO类一起使用。
@Autowired：Spring @Autowired 注释用于自动注入 bean。Spring @Qualifier注释与 Autowired 结合使用，以避免在为相同类型配置两个或多个 bean 时产生混淆。

Spring MVC 注解

一些重要的 Spring MVC 注释是：

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

Spring 事务管理注解

@Transactional是 spring 声明式事务管理注解，更多内容请阅读Spring MVC Hibernate。

Spring Security 注解

@EnableWebSecurity与@Configuration类一起使用来定义 Spring Security 配置，有关详细信息，请参阅Spring Security 示例。

Spring Boot 注解

更多内容请阅读Spring Boot 示例。

Spring 注解示例

让我们看一个简单的示例，我们将在应用程序中使用 Spring 注释。下图说明了我的 Spring Annotations 示例项目。 spring 注解

Spring 框架依赖项

我已经创建了 maven 项目并添加了 Spring Core Framework 依赖项。

<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 框架将其视为 Service 类。然后我们使用@Autowired注释@Qualifier("oracleDriver")来告诉 Spring 框架将名为的 bean 注入oracleDriver到类属性中dataBaseDriver。请注意，我们尚未创建此 Spring bean。

Spring Bean

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

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

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

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

我们的 Spring 注释示例项目已准备好进行测试。总而言之，我们执行了以下步骤：

创建 maven 项目并添加所需的 spring 依赖项。
创建组件类并将资源文件中的属性注入到其变量中。
如果我们有第三方组件，我们可以使用 Service 类向其中注入依赖项。就像我们通过 UserService 类对 OracleDriver 所做的那样。
最后，我们创建了配置类来定义spring bean并设置基础包来扫描 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 Annotations 示例项目

参考：API文档