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。
  这是最常用和重要的弹簧注释之一。
  @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类时可以使用它。
  例如;

• @ComponentScan：配置与@Configuration类一起使用的组件扫描指令。
  其中我们可以指定基本软件包以扫描弹簧组件。

• @Component：指示带注释的类是"组件"。
  当使用基于注释的配置和类路径扫描时，此类将被视为自动检测的候选。

• @PropertySource ：：提供了一种简单的声明机制，用于向Spring的环境中添加属性源。
  添加属性源文件数组也有类似的注释，即@PropertySources。

• @Service：表示带注释的类是"服务"。
  此批注用作@Component的特化，允许通过类路径扫描自动检测实现类。

• @Repository：指示带注释的类是"存储库"。
  此批注用作@Component的特殊化，建议与DAO类一起使用。

• @Autowired：Spring @Autowired注解用于自动注入bean。
  当我们为相同类型配置了两个以上的bean时，Spring @Qualifier注释与Autowired一起使用可以避免混淆。

Spring MVC注释

一些重要的Spring MVC注释是：

• @Controller
• @RequestMapping
• @PathVariable
• @RequestParam
• @ModelAttribute
• @RequestBody和@ResponseBody
• @RequestHeader和@ResponseHeader

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

Spring交易管理注释

@Transactional是Spring声明式事务管理注释，更多内容请参见Spring MVC Hibernate。

Spring安全性注释

@EnableWebSecurity与@Configuration类一起使用以定义Spring Security配置，有关更多信息，请参见Spring Security Example。

Spring Boot注释

• @SpringBootApplication
• @EnableAutoConfiguration

在Spring Boot Example中阅读更多信息。

弹簧注释示例

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

Spring框架依赖

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

public class Computer {

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

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

这将拉起我们项目的所有弹簧芯罐。

组件类别

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

<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.theitroad.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>

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

package com.theitroad.drivers;

public interface DataBaseDriver {
  public String getInfo();
}

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

package com.theitroad.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 +
              " ]";
  }
}

databaseName=school
disableStatementPooling=true

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

Spring服务班

package com.theitroad.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 +
              " ] ";
  }
}

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

spring bean

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

package com.theitroad.service;

import com.theitroad.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();
  }
}

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

这是在oracledatabase.properties文件中定义的属性。

package com.theitroad.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.theitroad.drivers.DataBaseDriver;
import com.theitroad.drivers.MySqlDriver;
import com.theitroad.drivers.OracleDriver;

@Configuration
@ComponentScan("com.theitroad")
@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();
	}
}

我们的spring注释示例项目已准备好进行测试。
作为总结，我们执行了以下步骤：

• 创建了maven项目并添加了必需的spring依赖项。

• 创建了组件类，并将资源文件中的属性注入到其变量中。

• 如果我们有第三方组件，则可以使用Service类将依赖项注入其中。
  就像我们通过UserService类为OracleDriver所做的一样。

• 最后，我们创建了Configuration类来定义spring bean，并将基本包设置为扫描spring组件类并对其进行配置。

Spring注释示例测试

这是测试Spring注释示例项目的主要类。

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

请注意，我们尚未配置任何日志记录框架，因此所有spring框架日志记录都将以红色打印到控制台中。