SpringBoot常用注解详解含使用示例(值得珍藏)

1. 启动注解

1.1 @SpringBootApplication

@SpringBootApplication 是一个组合注解,它结合了 @SpringBootConfiguration、@EnableAutoConfiguration 和 @ComponentScan。这个注解用于简化 Spring Boot 应用的初始化和开发过程。

具体来说,@SpringBootConfiguration 表明该类是一个 Spring Boot 配置类,用于定义和注册 Spring Beans。@EnableAutoConfiguration 启用了 Spring Boot 的自动配置功能,根据项目中的依赖关系自动配置应用程序。@ComponentScan 则指示 Spring Boot 在指定的包及其子包中查找组件、配置和服务。

使用 @SpringBootApplication 注解可以简化 Spring Boot 应用的开发过程,使得开发人员能够快速构建独立、生产级别的 Spring 应用。同时,它还提供了一些便利的特性,如嵌入式容器、自动化配置、简化 Maven 配置等,使得应用更加易于部署和管理。

以下是一个简单的 Spring Boot 应用程序示例,其中使用了 @SpringBootApplication 注解:

import org.springframework.boot.SpringApplication;  
import org.springframework.boot.autoconfigure.SpringBootApplication;  
  
@SpringBootApplication  
public class MySpringBootApplication {  
  
    public static void main(String[] args) {  
        SpringApplication.run(MySpringBootApplication.class, args);  
    }  
  
}

在上面的示例中,@SpringBootApplication 注解将 MySpringBootApplication 类标记为一个 Spring Boot 应用程序的入口点。当运行该应用程序时,Spring Boot 会自动配置和启动应用程序。

你可以在 MySpringBootApplication 类中添加更多的组件和配置,以满足你的应用程序需求。例如,你可以添加控制器、服务、数据访问对象等,并使用 Spring Boot 的自动配置功能来简化配置过程。

1.2 @SpringBootConfiguration

@SpringBootConfiguration 是 Spring Boot 框架提供的注解,用于将普通的 Java 类标记为配置类。该注解的作用是将类作为一个 Spring 配置类,从而使其能够定义和注册 Spring Beans。

与传统的 XML 配置方式相比,使用 @SpringBootConfiguration 注解可以将配置信息直接写在 Java 类中,使得代码更加简洁、易于维护。同时,该注解还提供了自动配置和组件扫描等功能,进一步简化了 Spring Boot 应用的初始化和开发过程。

使用 @SpringBootConfiguration 注解的类通常包含一些用于定义 Spring Beans 的方法,这些方法上可以标注其他注解(如 @Bean、@Component、@Service 等),以便于创建和注册不同的 Spring 组件。通过在主类上使用 @SpringBootApplication 注解,可以将多个配置类组合在一起,从而实现更加灵活和复杂的配置功能。

它继承@Configuration注解,主要用于加载配置文件,二者功能一致,标注当前类为配置类, 将当前类内声明的一个或多个以@Bean注解标记的方法的实例纳入到spring容器中,且实例名为方法名。

1.3 @EnableAutoConfiguration

@EnableAutoConfiguration 是 Spring Boot 的一个核心特性,它根据项目中的依赖关系自动配置应用程序。通过 @EnableAutoConfiguration 注解,Spring Boot 能够根据添加的 jar 依赖自动配置 Spring 应用程序的 IOC 容器。

在 Spring Boot 项目中,只需要在主类上添加 @EnableAutoConfiguration 注解,就可以开启自动配置功能。Spring Boot 会根据项目中的依赖项,自动扫描并配置相应的 Bean。这个过程是自动完成的,不需要手动编写大量的配置文件和注解。

@EnableAutoConfiguration 通过读取 classpath 中的 jar 依赖,判断需要创建哪些 Bean,并自动注册到 Spring 容器中。这样可以大大简化 Spring 应用的初始化和配置过程,提高开发效率。

1.4 @ComponentScan

@ComponentScan 是 Spring 框架中的一个注解,用于指定 Spring 容器扫描组件的路径。通过使用 @ComponentScan,可以将 Spring 容器中的组件注册到指定的路径下。

具体来说,@ComponentScan 注解可以定义在类或接口上,用于指定扫描路径。Spring 容器会将指定路径下带有指定注解的类注册到 IOC 容器中。默认情况下,@ComponentScan 会扫描带有 @Component、@Service、@Repository 和 @Controller 等注解的类。

使用 @ComponentScan 可以简化 Spring 应用的初始化和配置过程。通过指定扫描路径,可以自动将相关的组件注册到 Spring 容器中,而不需要手动创建和配置每个 Bean。这使得代码更加简洁、易于维护,并且减少了出错的可能性。

需要注意的是,在使用 @ComponentScan 时,需要确保扫描路径的正确性。如果扫描路径不正确,可能会导致组件无法被注册到 Spring 容器中,从而导致异常或错误。因此,在实际开发中,需要根据具体情况选择合适的扫描路径,并进行充分的测试和验证。

2. 配置文件相关注解

2.1 @Configuration

@Configuration 是 Spring 框架中的一个注解,用于将普通的 Java 类标记为配置类。当一个类上标注了 @Configuration 注解时,这个类就被视为一个配置类,用于替代传统的 XML 配置方式。

在配置类中,可以使用 @Bean 注解来定义 Spring Beans。这些 Beans 可以是普通的 Java 类,也可以是其他配置类。通过使用 @Configuration 和 @Bean 注解,可以将配置信息直接写在 Java 类中,使得代码更加简洁、易于维护。

与传统的 XML 配置方式相比,使用 @Configuration 和 @Bean 注解可以提供更加灵活和强大的配置功能。例如,可以在配置类中使用 Java 表达式来定义 Beans 的属性和依赖关系,还可以通过继承和组合配置类来实现更加复杂的配置逻辑。

此外,@Configuration 注解的类本身也是一个普通的 Java 类,可以包含普通的属性和方法。这使得配置类更加易于测试和维护。

需要注意的是,虽然使用 @Configuration 和 @Bean 注解可以简化 Spring 的配置过程,但并不是所有的配置都需要使用这种方式。在一些简单的情况下,使用传统的 XML 配置方式可能更加方便和直观。因此,在实际开发中,需要根据具体情况选择合适的配置方式。

以下是一个使用 @Configuration 注解的示例:

import org.springframework.context.annotation.Bean;  
import org.springframework.context.annotation.Configuration;  
  
@Configuration  
public class AppConfig {  
  
    @Bean  
    public MyBean myBean() {  
        return new MyBean();  
    }  
  
}

在上面的示例中,@Configuration 注解将 AppConfig 类标记为一个 Spring 配置类。在该类中,我们使用 @Bean 注解定义了一个名为 myBean 的 Bean,该 Bean 返回一个 MyBean 实例。

通过在配置类中使用 @Bean 注解,我们可以将对象实例化并将其注册为 Spring 容器中的 Bean。这样,在应用程序的其他部分中,我们可以使用 @Autowired@Inject 注解来注入这些 Bean,以便使用它们的功能。

3. Controller 相关注解

3.1 @Controller

@Controller 是一个用于标识一个 Java 类为 Spring MVC 控制器的注解。使用 @Controller 注解的类将负责处理请求并返回响应。在 Spring MVC 中,控制器是与视图层进行交互的重要组件,负责处理用户请求并返回相应的视图或数据。

当一个类上标注了 @Controller 注解,Spring MVC 会自动扫描该类,并将其注册为一个控制器。这意味着该类的方法将用于处理请求,并返回响应。方法的返回值可以是一个视图页面、数据对象或模型。

@Controller 注解的作用是将一个类标记为控制器,使 Spring MVC 能够自动扫描和注册该类。与 @Component 注解类似,@Controller 注解也是将一个类标记为 Spring 的组件。但是,@Controller 注解还有以下特性:

  1. 自动映射 URL:@Controller 注解可以将请求映射到控制器的方法上。这意味着当用户访问特定的 URL 时,Spring MVC 会自动调用相应的控制器方法来处理请求。
  2. 解析返回值:@Controller 注解可以将方法的返回值解析为视图,并将其渲染到客户端。这意味着方法的返回值可以是一个视图页面的路径、一个模型对象或一个数据集合等。

需要注意的是,在实际开发中,使用 @Controller 注解时需要结合其他注解(如 @RequestMapping)来指定请求的 URL 映射和请求方法(如 GET、POST)。此外,根据实际需求选择合适的控制器注解(如 @Controller、@RestController)也是很重要的。

以下是一个使用 @Controller 注解的示例:

import org.springframework.stereotype.Controller;  
import org.springframework.web.bind.annotation.GetMapping;  
import org.springframework.web.bind.annotation.RequestMapping;  
  
@Controller  
@RequestMapping("/hello")  
public class HelloController {  
  
    @GetMapping  
    public String sayHello() {  
        return "Hello, World!";  
    }  
  
}

在上面的示例中,@Controller 注解将 HelloController 类标记为一个 Spring MVC 控制器。@RequestMapping("/hello") 注解指定了该控制器处理的基础 URL 路径为 /hello

在控制器类中,我们定义了一个名为 sayHello 的方法,该方法使用 @GetMapping 注解指定处理 GET 请求。当用户访问 /hello URL 时,Spring MVC 会自动调用 sayHello 方法,并返回一个名为 “Hello, World!” 的字符串作为响应。

注意,@Controller 注解通常与 @RequestMapping@GetMapping 等注解一起使用,以定义控制器类和控制器方法的映射关系。

3.2 @RestController

@RestController 是一个 Spring Framework 中的注解,用于标识一个类是一个控制器,并且该控制器中的方法返回的数据不是视图页面,而是直接作为响应内容发送到客户端,通常是以 JSON 格式返回数据。

与 @Controller 注解相比,@RestController 注解更加适合创建 RESTful 风格的控制器。使用 @RestController 注解的类通常处理 HTTP 请求并返回 JSON 或其他格式的响应数据,而不是视图页面。

@RestController 注解的主要特点包括:

  1. 自动转换为 JSON 或其他格式:使用 @RestController 注解的控制器方法可以直接返回数据对象,不需要手动将其转换为 JSON 或其他格式。Spring 会自动将返回值转换为相应的格式,并将其作为响应内容发送给客户端。
  2. 简化代码:使用 @RestController 注解可以大大简化 RESTful Web 服务的开发,减少代码量和冗余操作。开发者只需要关注数据模型和业务逻辑,而不需要关心请求映射和响应格式转换等细节。
  3. 自动映射 URL:与 @Controller 注解类似,@RestController 注解也可以将请求映射到控制器的方法上。开发者可以使用 @RequestMapping 或其他相关注解来指定请求的 URL 映射和请求方法。

需要注意的是,@RestController 注解通常用于创建 API 或 Web 服务,而不是用于构建完整的 Web 应用程序。在这些场景下,使用 @RestController 可以简化开发过程,提高开发效率。

以下是一个使用 @RestController 注解的示例:

import org.springframework.web.bind.annotation.GetMapping;  
import org.springframework.web.bind.annotation.RequestMapping;  
import org.springframework.web.bind.annotation.RestController;  
  
@RestController  
@RequestMapping("/api/users")  
public class UserController {  
  
    @GetMapping("/{id}")  
    public String getUserById(@PathVariable String id) {  
        // 在这里实现获取用户信息的逻辑...  
        return "User ID: " + id;  
    }  
  
}

在上面的示例中,@RestController 注解将 UserController 类标记为一个 RESTful 控制器。@RequestMapping("/api/users") 注解指定了该控制器处理的基础 URL 路径为 /api/users

在控制器类中,我们定义了一个名为 getUserById 的方法,该方法使用 @GetMapping("/{id}") 注解指定处理 GET 请求,并使用 @PathVariable 注解将 URL 中的 {id} 参数绑定到方法的参数上。当用户访问 /api/users/{id} URL 时,Spring MVC 会自动调用 getUserById 方法,并返回一个字符串作为响应。

由于 @RestController 注解会自动将方法的返回值转换为 JSON 或其他适当的响应格式,因此我们只需要返回一个简单的字符串作为响应。在这个示例中,我们返回了一个包含用户 ID 的字符串。

3.3 @RequestBody

@RequestBody 是 Spring 框架中的一个注解,主要用于将 HTTP 请求的内容(如 JSON、XML 等)绑定到方法的参数上。具体来说,当一个方法参数上标注了 @RequestBody 注解时,Spring 会自动将请求体中的数据解析为对应类型的对象,并将其传递给方法参数。这个过程是自动完成的,不需要手动解析请求体中的数据。

@RequestBody主要特点包括:

  1. 自动绑定请求体:@RequestBody 能够自动将 HTTP 请求体中的数据绑定到方法的参数上,简化了数据的解析过程。
  2. 数据格式化:@RequestBody 支持多种数据格式,如 JSON、XML 等,可以根据请求体的内容自动进行格式化。
  3. 数据校验:通过 @RequestBody 注解,Spring 会对绑定到参数的对象进行数据校验,确保数据的完整性和有效性。

假设我们有一个 RESTful API,用于接收用户信息并保存到数据库中。这里我们使用 JSON 作为请求体的格式。

  1. 首先,创建一个 User 类来表示用户信息:
public class User {  
    private String name;  
    private int age;  
    // getters and setters  
}
  1. 创建一个 UserController 类,使用 @RestController 注解标记为一个控制器:
import org.springframework.web.bind.annotation.*;  
import org.springframework.web.bind.annotation.RequestBody;  
import org.springframework.web.bind.annotation.RestController;  
  
@RestController  
public class UserController {  
    // ...其他代码...  
}
  1. UserController 类中创建一个处理 POST 请求的方法,使用 @RequestMapping 注解指定 URL 路径,并使用 @RequestBody 注解将请求体中的数据绑定到方法的参数上:
import org.springframework.web.bind.annotation.*;  
import org.springframework.web.bind.annotation.RequestBody;  
import org.springframework.web.bind.annotation.RestController;  
import org.springframework.web.bind.annotation.RequestMapping;  
import org.springframework.web.bind.annotation.RequestMethod;  
  
@RestController  
public class UserController {  
    @RequestMapping(value = "/user", method = RequestMethod.POST)  
    public void createUser(@RequestBody User user) {  
        // 在这里处理用户数据的保存逻辑...  
    }  
}

在这个示例中,当客户端发送一个 POST 请求到 /user URL 时,Spring 会自动将请求体中的 JSON 数据解析为 User 对象,并将其传递给 createUser 方法。这样,开发者就不需要手动解析请求体中的数据了。

3.4 @ResponseBody

@ResponseBody 是一个 Spring MVC 注解,用于指示控制器方法的返回值应该直接写入 HTTP 响应体中,而不是被视为视图名称。这通常用于返回 JSON、XML 或其他数据格式的响应。

使用 @ResponseBody 注解的方法可以返回任何对象,Spring MVC 会自动将其序列化为适当的格式,并将其写入 HTTP 响应体中。常用的序列化方式包括 JSON(通过 Jackson 库)和 XML(通过 JAXB 或 XStream)。

下面是一个使用 @ResponseBody 的示例:

import org.springframework.http.MediaType;  
import org.springframework.web.bind.annotation.GetMapping;  
import org.springframework.web.bind.annotation.RequestMapping;  
import org.springframework.web.bind.annotation.ResponseBody;  
import org.springframework.web.bind.annotation.RestController;  
  
@RestController  
@RequestMapping("/api/users")  
public class UserController {  
  
    @GetMapping("/{id}")  
    @ResponseBody  
    public User getUserById(@PathVariable String id) {  
        // 在这里实现获取用户信息的逻辑...  
        User user = new User();  
        user.setId(id);  
        user.setName("John Doe");  
        return user;  
    }  
  
}  
  
class User {  
    private String id;  
    private String name;  
    // getters and setters...  
}

在上面的示例中,getUserById 方法使用了 @ResponseBody 注解,表示该方法的返回值应该直接写入 HTTP 响应体中。返回的 User 对象会被自动序列化为 JSON 格式,并作为 HTTP 响应的主体返回给客户端。客户端可以通过 HTTP GET 请求访问 /api/users/{id} 来获取用户信息。

3.5 @RequestMapping

@RequestMapping 是一个 Spring MVC 注解,用于将 HTTP 请求映射到特定的控制器方法。它可以用于类级别和方法级别,用于指定请求的 URL 路径、HTTP 方法和其他属性。

在类级别上使用 @RequestMapping 注解时,它将应用于该类中的所有方法。在方法级别上使用时,它将只应用于该方法。

@RequestMapping 注解可以接受多个参数,例如 valuemethodconsumesproduces。其中:

  • value 指定请求的 URL 路径,可以包含路径变量。
  • method 指定请求的 HTTP 方法,例如 GETPOST 等。
  • consumes 指定请求的内容类型,例如 application/json
  • produces 指定响应的内容类型,例如 application/json

下面是一个使用 @RequestMapping 的示例:

import org.springframework.web.bind.annotation.RequestMapping;  
import org.springframework.web.bind.annotation.RequestMethod;  
import org.springframework.web.bind.annotation.RestController;  
  
@RestController  
@RequestMapping("/api/users")  
public class UserController {  
  
    @RequestMapping(value = "/{id}", method = RequestMethod.GET)  
    public User getUserById(@PathVariable String id) {  
        // 在这里实现获取用户信息的逻辑...  
        User user = new User();  
        user.setId(id);  
        user.setName("John Doe");  
        return user;  
    }  
  
}  
  
class User {  
    private String id;  
    private String name;  
    // getters and setters...  
}

在上面的示例中,UserController 类使用了 @RequestMapping("/api/users") 注解,将所有方法映射到 /api/users URL 路径下。然后,在 getUserById 方法上使用了 @RequestMapping(value = "/{id}", method = RequestMethod.GET) 注解,将该方法映射到 /api/users/{id} URL 路径下,并指定只处理 GET 请求。当客户端发送 GET 请求到 /api/users/{id} 时,Spring MVC 会自动调用 getUserById 方法,并返回一个 User 对象作为响应。

3.6 @GetMapping

@GetMapping 是 Spring 5 中引入的一个新注解,它是 @RequestMapping 的一个特化版本,专门用于处理 HTTP GET 请求。使用 @GetMapping 可以更简洁地指定处理 GET 请求的方法。

下面是一个使用 @GetMapping 的示例:

import org.springframework.web.bind.annotation.GetMapping;  
import org.springframework.web.bind.annotation.RestController;  
  
@RestController  
public class UserController {  
  
    @GetMapping("/users")  
    public List<User> getUsers() {  
        // 在这里实现获取用户列表的逻辑...  
        List<User> users = new ArrayList<>();  
        users.add(new User("1", "Alice"));  
        users.add(new User("2", "Bob"));  
        return users;  
    }  
  
}  
  
class User {  
    private String id;  
    private String name;  
    // getters and setters...  
}

在上面的示例中,UserController 类使用了 @RestController 注解,表示该类是一个 RESTful 控制器。然后,在 getUsers 方法上使用了 @GetMapping("/users") 注解,将该方法映射到 /users URL 路径下,并指定只处理 GET 请求。当客户端发送 GET 请求到 /users 时,Spring MVC 会自动调用 getUsers 方法,并返回一个 User 对象列表作为响应。

3.7 @PostMapping

@PostMapping 是 Spring 5 中引入的一个注解,它是 @RequestMapping 的特化版本,专门用于处理 POST 请求。由于它的用途更加明确,因此在大多数情况下,推荐使用 @PostMapping 代替 @RequestMapping 并指定 method = RequestMethod.POST

下面是一个使用 @PostMapping 的示例:

import org.springframework.web.bind.annotation.PostMapping;  
import org.springframework.web.bind.annotation.RequestBody;  
import org.springframework.web.bind.annotation.RestController;  
  
@RestController  
public class UserController {  
  
    @PostMapping("/api/users")  
    public User createUser(@RequestBody User user) {  
        // 在这里实现创建用户的逻辑...  
        user.setId(UUID.randomUUID().toString());  
        user.setName(user.getName().toUpperCase());  
        return user;  
    }  
  
}  
  
class User {  
    private String id;  
    private String name;  
    // getters and setters...  
}

在上面的示例中,UserController 类中的 createUser 方法使用了 @PostMapping("/api/users") 注解,将该方法映射到 /api/users URL 路径下,并指定只处理 POST 请求。该方法接受一个 User 类型的参数,通过 @RequestBody 注解将请求体中的 JSON 数据绑定到 User 对象上。当客户端发送 POST 请求到 /api/users 时,Spring MVC 会自动调用 createUser 方法,并返回一个 User 对象作为响应。

3.8 @RequestMapping 和 @GetMapping @PostMapping 区别

@GetMapping是组合注解,是@RequestMapping(method = RequestMethod.GET)的缩写。

@PostMapping是组合注解,是@RequestMapping(method = RequestMethod.POST)的缩写。

4. 取请求参数值

4.1 @PathVariable

@PathVariable是Spring框架中的一个注解,用于将URL路径中的参数绑定到控制器方法的参数上。它通常用于处理RESTful Web服务的请求。使用@PathVariable注解可以将URL路径中的参数值注入到方法的参数中,使得在处理请求时可以方便地获取这些参数值。

例如,假设有一个URL路径"/user/{userId}/profile",其中"{userId}"是一个路径参数。在控制器方法中,可以使用@PathVariable注解将这个参数值绑定到一个方法的参数上,如下所示:

@GetMapping("/user/{userId}/profile")  
public UserProfile getUserProfile(@PathVariable String userId) {  
    // 在这里可以使用userId参数值进行相应的处理  
    // ...  
}

在上面的例子中,@PathVariable注解将URL路径中的"{userId}“参数值绑定到了方法参数"userId"上。当用户访问一个特定的URL时,例如”/user/123/profile",Spring框架会自动将"123"作为"userId"参数的值注入到方法中。

除了将路径参数绑定到字符串类型的参数上,@PathVariable注解还可以用于绑定其他类型的参数,例如整数、自定义对象等。只需要在方法的参数上使用相应的类型声明即可。

需要注意的是,如果URL路径中的参数没有提供对应的值,或者提供的值无法匹配到方法的参数类型,那么Spring框架将会抛出一个异常。因此,在使用@PathVariable注解时,需要确保URL路径中的参数值能够正确地匹配到方法的参数类型。

4.2 @Value

@Value 是 Spring 框架中的一个注解,用于注入属性值。它通常用于将值注入到 JavaBean 属性、构造函数参数或方法参数中。

使用 @Value 注解时,需要指定要注入的值或表达式的占位符。占位符可以是 ${...}#{...},其中 ${...} 表示直接属性值,#{...} 表示 SpEL(Spring Expression Language)表达式。

示例1

下面是一个使用 @Value 的示例:

import org.springframework.beans.factory.annotation.Value;  
import org.springframework.stereotype.Component;  
  
@Component  
public class MyComponent {  
  
    @Value("Hello, World!")  
    private String message;  
  
    public String getMessage() {  
        return message;  
    }  
}

在上面的示例中,MyComponent 类使用 @Value("Hello, World!") 注解将字符串 “Hello, World!” 注入到 message 属性中。@Component 注解将该类标记为一个 Spring 组件,Spring 容器会自动扫描并实例化该类。然后,可以通过 getMessage() 方法获取注入的 message 属性的值。

除了在属性上使用 @Value 注解外,还可以在构造函数参数或方法参数上使用它,以注入值。例如:

import org.springframework.beans.factory.annotation.Value;  
import org.springframework.stereotype.Component;  
  
@Component  
public class MyComponent {  
  
    private String message;  
  
    public MyComponent(@Value("Hello, World!") String message) {  
        this.message = message;  
    }  
  
    public String getMessage() {  
        return message;  
    }  
}

在上面的示例中,MyComponent 类使用 @Value("Hello, World!") 注解在构造函数参数上注入字符串 “Hello, World!”。Spring 容器会自动调用构造函数,并将注入的值传递给 message 参数。

示例2

以下是一个使用 @Value 读取配置文件中数据的示例:

首先,在 Spring 的配置文件(例如 application.properties)中定义一个属性:

my.config.value=Hello, World!

然后,在 Java 类中使用 @Value 注解将该属性注入到字段或方法参数中:

import org.springframework.beans.factory.annotation.Value;  
import org.springframework.stereotype.Component;  
  
@Component  
public class MyComponent {  
  
    @Value("${my.config.value}")  
    private String myConfigValue;  
  
    public String getMyConfigValue() {  
        return myConfigValue;  
    }  
}

在上面的示例中,@Value("${my.config.value}") 注解将 my.config.value 属性的值注入到 myConfigValue 字段中。Spring 容器会自动扫描并实例化 MyComponent 类,并将 my.config.value 属性的值注入到 myConfigValue 字段中。然后,可以通过 getMyConfigValue() 方法获取注入的 myConfigValue 字段的值。

4.3 @RequestParam

@RequestParam 是 Spring MVC 框架中的一个注解,用于将请求参数绑定到控制器方法的参数上。它通常用于处理 HTTP GET 或 POST 请求中的参数。

使用 @RequestParam 注解时,需要指定参数的名称和可选的默认值。当请求中包含与参数名称匹配的参数时,该参数的值将被绑定到方法参数上。如果请求中没有该参数,方法参数将使用默认值(如果有提供的话)。

下面是一个使用 @RequestParam 的示例:

import org.springframework.web.bind.annotation.GetMapping;  
import org.springframework.web.bind.annotation.RequestParam;  
import org.springframework.web.bind.annotation.RestController;  
  
@RestController  
public class MyController {  
  
    @GetMapping("/greet")  
    public String greet(@RequestParam(value = "name", defaultValue = "World") String name) {  
        return "Hello, " + name + "!";  
    }  
}

在上面的示例中,greet 方法使用 @RequestParam 注解将请求参数 name 绑定到 name 方法参数上。如果请求中包含名为 name 的参数,其值将被传递给 name 参数。如果没有提供 name 参数,将使用默认值 World。方法返回一个简单的问候语字符串。

当客户端发送 GET 请求到 /greet?name=John 时,请求参数 name 的值为 John,因此方法将返回 Hello, John!。如果客户端发送 GET 请求到 /greet(没有 name 参数),方法将返回 Hello, World!,因为使用了默认值 World

4.4 @RequestHeader

@RequestHeader 是 Spring MVC 框架中的一个注解,用于将 HTTP 请求头中的值绑定到控制器方法的参数上。它通常用于处理带有请求头的 HTTP 请求。

使用 @RequestHeader 注解时,需要指定请求头的名称和可选的默认值。当请求中包含与请求头名称匹配的请求头时,该请求头的值将被绑定到方法参数上。如果请求中没有该请求头,方法参数将使用默认值(如果有提供的话)。

下面是一个使用 @RequestHeader 的示例:

import org.springframework.web.bind.annotation.GetMapping;  
import org.springframework.web.bind.annotation.RequestHeader;  
import org.springframework.web.bind.annotation.RestController;  
  
@RestController  
public class MyController {  
  
    @GetMapping("/header")  
    public String getHeaderValue(@RequestHeader(name = "User-Agent", defaultValue = "Unknown") String userAgent) {  
        return "User-Agent: " + userAgent;  
    }  
}

在上面的示例中,getHeaderValue 方法使用 @RequestHeader 注解将请求头 User-Agent 的值绑定到 userAgent 方法参数上。如果请求中包含名为 User-Agent 的请求头,其值将被传递给 userAgent 参数。如果没有提供 User-Agent 请求头,将使用默认值 Unknown。方法返回一个简单的字符串,其中包含请求头的值。

当客户端发送 GET 请求到 /header,并包含请求头 User-Agent,例如 GET /header HTTP/1.1\r\nUser-Agent: Chrome\r\n\r\n,方法将返回 User-Agent: Chrome。如果客户端发送 GET 请求到 /header(没有 User-Agent 请求头),方法将返回 User-Agent: Unknown,因为使用了默认值 Unknown

4.5 @CookieValue

@CookieValue 是 Spring MVC 框架中的一个注解,用于将 HTTP 请求中的 cookie 值绑定到控制器方法的参数上。它通常用于处理带有 cookie 的 HTTP 请求。

使用 @CookieValue 注解时,需要指定 cookie 的名称和可选的默认值。当请求中包含与 cookie 名称匹配的 cookie 时,该 cookie 的值将被绑定到方法参数上。如果请求中没有该 cookie,方法参数将使用默认值(如果有提供的话)。

下面是一个使用 @CookieValue 的示例:

import org.springframework.web.bind.annotation.GetMapping;  
import org.springframework.web.bind.annotation.CookieValue;  
import org.springframework.web.bind.annotation.RestController;  
  
@RestController  
public class MyController {  
  
    @GetMapping("/cookie")  
    public String getCookieValue(@CookieValue(name = "myCookie", defaultValue = "defaultValue") String cookieValue) {  
        return "Cookie Value: " + cookieValue;  
    }  
}

在上面的示例中,getCookieValue 方法使用 @CookieValue 注解将 cookie myCookie 的值绑定到 cookieValue 方法参数上。如果请求中包含名为 myCookie 的 cookie,其值将被传递给 cookieValue 参数。如果没有提供 myCookie cookie,将使用默认值 defaultValue。方法返回一个简单的字符串,其中包含 cookie 的值。

当客户端发送 GET 请求到 /cookie,并包含 cookie myCookie,例如 GET /cookie HTTP/1.1\r\nCookie: myCookie=cookieValue\r\n\r\n,方法将返回 Cookie Value: cookieValue。如果客户端发送 GET 请求到 /cookie(没有 myCookie cookie),方法将返回 Cookie Value: defaultValue,因为使用了默认值 defaultValue

5. 注入bean相关

5.1 @Bean

@Bean 是 Spring 框架中的一个注解,用于声明一个对象作为 Spring 容器中的 bean。使用 @Bean 注解的方法将由 Spring 容器自动实例化,并将其注册为 bean,以便在应用程序中使用。

下面是一个使用 @Bean 的示例:

import org.springframework.context.annotation.Bean;  
import org.springframework.context.annotation.Configuration;  
  
@Configuration  
public class AppConfig {  
  
    @Bean  
    public MyBean myBean() {  
        return new MyBean();  
    }  
}

在上面的示例中,我们定义了一个名为 AppConfig 的配置类,并使用 @Configuration 注解进行标记。在该类中,我们定义了一个名为 myBean 的方法,并使用 @Bean 注解进行标记。这个方法返回一个 MyBean 类型的实例,并将其注册为 Spring 容器中的 bean。

Spring 容器会自动扫描 AppConfig 类,并发现 myBean 方法上的 @Bean 注解。当应用程序启动时,Spring 容器将自动实例化 MyBean 类,并将其注册为一个 bean。然后,可以在应用程序中的其他地方注入这个 bean,例如:

import org.springframework.beans.factory.annotation.Autowired;  
import org.springframework.stereotype.Component;  
  
@Component  
public class SomeComponent {  
  
    private final MyBean myBean;  
  
    @Autowired  
    public SomeComponent(MyBean myBean) {  
        this.myBean = myBean;  
    }  
}

在上面的示例中,我们定义了一个名为 SomeComponent 的组件,并使用 @Component 注解进行标记。在该组件中,我们定义了一个私有的 myBean 字段,并通过构造函数注入了一个 MyBean 类型的 bean。由于使用了 @Autowired 注解,Spring 容器会自动将之前注册的 myBean bean 注入到这个组件中。

5.2 @Component

@Component 是 Spring 框架中的一个常用注解,用于将一个类标记为 Spring 容器管理的组件。当 Spring 容器启动时,会自动扫描带有 @Component 注解的类,并将其注册为 Spring 容器中的 bean。

使用 @Component 注解的类可以被其他组件自动装配,也可以通过 @Autowired 注解注入到其他组件中。

下面是一个使用 @Component 的示例:

import org.springframework.stereotype.Component;  
  
@Component  
public class MyComponent {  
  
    public void doSomething() {  
        // 实现业务逻辑  
    }  
}

在上面的示例中,我们定义了一个名为 MyComponent 的类,并使用 @Component 注解进行标记。这告诉 Spring 容器将该类作为一个组件进行管理,并注册为一个 bean。

然后,可以在其他组件中注入 MyComponent 的实例,例如:

import org.springframework.beans.factory.annotation.Autowired;  
import org.springframework.stereotype.Component;  
  
@Component  
public class SomeOtherComponent {  
  
    private final MyComponent myComponent;  
  
    @Autowired  
    public SomeOtherComponent(MyComponent myComponent) {  
        this.myComponent = myComponent;  
    }  
}

在上面的示例中,我们定义了一个名为 SomeOtherComponent 的类,并使用 @Component 注解进行标记。在该类中,我们定义了一个私有的 myComponent 字段,并通过构造函数注入了一个 MyComponent 类型的 bean。由于使用了 @Autowired 注解,Spring 容器会自动将之前注册的 myComponent bean 注入到这个组件中。

5.3 @Service

@Service 是 Spring 框架中的一个注解,用于将一个类标记为 Spring 容器管理的服务层组件。@Service 注解与 @Component 注解类似,都是用于将类标记为 Spring 容器中的 bean,但 @Service 注解通常用于表示服务层组件,如业务逻辑层。

使用 @Service 注解的类将由 Spring 容器自动实例化,并注册为 bean,可以在应用程序中被其他组件注入和使用。

下面是一个使用 @Service 的示例:

import org.springframework.stereotype.Service;  
  
@Service  
public class MyService {  
  
    public void doSomething() {  
        // 实现业务逻辑  
    }  
}

在上面的示例中,我们定义了一个名为 MyService 的类,并使用 @Service 注解进行标记。这告诉 Spring 容器将该类作为一个服务层组件进行管理,并注册为一个 bean。

然后,可以在其他组件中注入 MyService 的实例,例如:

import org.springframework.beans.factory.annotation.Autowired;  
import org.springframework.stereotype.Component;  
  
@Component  
public class SomeComponent {  
  
    private final MyService myService;  
  
    @Autowired  
    public SomeComponent(MyService myService) {  
        this.myService = myService;  
    }  
}

在上面的示例中,我们定义了一个名为 SomeComponent 的类,并使用 @Component 注解进行标记。在该类中,我们定义了一个私有的 myService 字段,并通过构造函数注入了一个 MyService 类型的 bean。由于使用了 @Autowired 注解,Spring 容器会自动将之前注册的 myService bean 注入到这个组件中。

5.4 @Repository

@Repository 是 Spring 框架中的一个注解,用于将一个类标记为数据访问对象(DAO)层组件,通常用于操作数据库。与 @Component@Service 类似,使用 @Repository 注解的类将被 Spring 容器自动管理并注册为 bean。

下面是一个使用 @Repository 的示例:

import org.springframework.stereotype.Repository;  
  
@Repository  
public class MyRepository {  
  
    public void save(Object entity) {  
        // 实现数据保存操作  
    }  
  
    public Object findById(Long id) {  
        // 实现根据ID查找数据操作  
        return null;  
    }  
}

在上面的示例中,我们定义了一个名为 MyRepository 的类,并使用 @Repository 注解进行标记。这告诉 Spring 容器将该类作为一个数据访问对象组件进行管理,并注册为一个 bean。

然后,可以在其他组件中注入 MyRepository 的实例,例如:

import org.springframework.beans.factory.annotation.Autowired;  
import org.springframework.stereotype.Component;  
  
@Component  
public class SomeComponent {  
  
    private final MyRepository myRepository;  
  
    @Autowired  
    public SomeComponent(MyRepository myRepository) {  
        this.myRepository = myRepository;  
    }  
}

在上面的示例中,我们定义了一个名为 SomeComponent 的类,并使用 @Component 注解进行标记。在该类中,我们定义了一个私有的 myRepository 字段,并通过构造函数注入了一个 MyRepository 类型的 bean。由于使用了 @Autowired 注解,Spring 容器会自动将之前注册的 myRepository bean 注入到这个组件中。

5.5 @Scope

@Scope 是 Spring 框架中的一个注解,用于指定 bean 的作用域。Spring 容器默认将 bean 实例化为单例(singleton),但在某些情况下,可能需要创建 bean 的原型(prototype)或请求(request)作用域的实例。

  • value

    • singleton 表示该bean是单例的。(默认)

    • prototype 表示该bean是多例的,即每次使用该bean时都会新建一个对象。

    • request 在一次http请求中,一个bean对应一个实例。

    • session 在一个httpSession中,一个bean对应一个实例。

  • proxyMode

    • DEFAULT 不使用代理。(默认)

    • NO 不使用代理,等价于DEFAULT。

    • INTERFACES 使用基于接口的代理(jdk dynamic proxy)。

    • TARGET_CLASS 使用基于类的代理(cglib)。

下面是一个使用 @Scope 的示例:

import org.springframework.context.annotation.Scope;  
import org.springframework.stereotype.Component;  
  
@Component  
@Scope("prototype")  
public class MyPrototypeBean {  
  
    public void doSomething() {  
        // 实现业务逻辑  
    }  
}

在上面的示例中,我们定义了一个名为 MyPrototypeBean 的类,并使用 @Component 注解进行标记。我们还使用 @Scope("prototype") 注解指定了该 bean 的作用域为原型(prototype)。这意味着每次请求时都会创建一个新的 MyPrototypeBean 实例。

要使用 @Scope 注解,需要将 Spring 配置文件中的 标签添加到 Spring 容器中,以便自动扫描带有 @Component@Service@Repository@Controller 等注解的类,并将其注册为 Spring 容器中的 bean。

5.6 @Autowired

@Autowired 是 Spring 框架中的一个注解,用于自动装配 bean。当 Spring 容器启动时,它会扫描带有 @Autowired 注解的字段、构造函数或方法,并自动注入相应的 bean。

使用 @Autowired 注解可以简化 bean 的装配过程,减少手动创建和注入依赖的代码量。

下面是一个使用 @Autowired 的示例:

import org.springframework.beans.factory.annotation.Autowired;  
import org.springframework.stereotype.Component;  
  
@Component  
public class SomeComponent {  
  
    private final MyService myService;  
  
    @Autowired  
    public SomeComponent(MyService myService) {  
        this.myService = myService;  
    }  
}

在上面的示例中,我们定义了一个名为 SomeComponent 的类,并使用 @Component 注解进行标记。在该类中,我们定义了一个 myService 字段,并使用 @Autowired 注解在构造函数中自动注入了一个 MyService 类型的 bean。由于使用了 @Autowired 注解,Spring 容器会自动将匹配的 bean 注入到 myService 字段中。

要使用 @Autowired 注解,需要确保 Spring 容器已经启动并扫描到了带有 @Autowired 注解的类。可以通过在配置文件中添加 标签来实现自动扫描。

5.7 @Qualifier

@Qualifier 是 Spring 框架中的一个注解,用于解决自动装配时的歧义问题。当有多个相同类型的 bean 存在于 Spring 容器中时,Spring 默认会选择一个进行注入,这可能导致一些问题。@Qualifier 注解可以指定注入哪个具体的 bean。

使用 @Qualifier 注解的示例:

假设有两个相同类型的 DataSource bean,如下所示:

@Bean  
public DataSource dataSource1() {  
    // 创建并返回第一个 DataSource bean  
}  
  
@Bean  
public DataSource dataSource2() {  
    // 创建并返回第二个 DataSource bean  
}

现在,我们需要将其中一个 DataSource bean 注入到一个组件中,但由于两个 bean 的类型相同,Spring 默认选择一个进行注入,这可能导致歧义。为了解决这个问题,我们可以在注入时使用 @Qualifier 注解来指定要注入的 bean:

@Autowired  
@Qualifier("dataSource1")  
private DataSource dataSource;

在上面的示例中,我们使用 @Autowired 注解来自动注入 DataSource bean,并通过 @Qualifier("dataSource1") 指定要注入的是名为 dataSource1 的 bean。这样,Spring 就会将正确的 DataSource bean 注入到该组件中。

6. 导入配置文件

6.1 @PropertySource

@PropertySource 是 Spring 框架中的一个注解,用于将外部属性文件加载到 Spring 容器中。通过使用 @PropertySource 注解,可以将外部的属性文件(如 .properties 文件)加载到 Spring 容器中,并使用这些属性值。

  • 引入单个properties文件:

    @PropertySource(value = {“classpath : xxxx/xxx.properties”})

  • 引入多个properties文件:

    @PropertySource(value = {“classpath : xxxx/xxx.properties”,“classpath : xxxx.properties”})

使用 @PropertySource 注解的示例:

假设我们有一个名为 application.properties 的属性文件,其中包含了一些属性值,如下所示:

# application.properties  
app.name=My App  
app.version=1.0

现在,我们希望将这些属性值加载到 Spring 容器中,并在其他组件中使用它们。为此,我们可以使用 @PropertySource 注解来加载属性文件,如下所示:

import org.springframework.context.annotation.Configuration;  
import org.springframework.context.annotation.PropertySource;  
  
@Configuration  
@PropertySource("classpath:application.properties")  
public class AppConfig {  
    // 配置类中的其他组件和属性  
}

在上面的示例中,我们使用了 @Configuration 注解来定义一个配置类,并使用 @PropertySource 注解来加载名为 application.properties 的属性文件。该属性文件将被加载到 Spring 容器中,并可以通过 Spring 的自动装配功能注入到其他组件中。

在配置类中,我们可以定义其他组件和属性,并使用 @Value 注解来注入属性值。例如:

import org.springframework.context.annotation.Bean;  
import org.springframework.context.annotation.Configuration;  
import org.springframework.context.annotation.PropertySource;  
  
@Configuration  
@PropertySource("classpath:application.properties")  
public class AppConfig {  
    @Value("${app.name}")  
    private String appName;  
    @Value("${app.version}")  
    private String appVersion;  
  
    @Bean  
    public MyComponent myComponent() {  
        MyComponent component = new MyComponent();  
        component.setName(appName);  
        component.setVersion(appVersion);  
        return component;  
    }  
}

在上面的示例中,我们使用了 @Value 注解来注入属性值,并使用这些属性值初始化了一个名为 myComponent 的组件。这样,我们就可以在其他组件中使用这些属性值了。

6.2 @ImportResource

@ImportResource 是 Spring 框架中的一个注解,用于导入 Spring 配置文件。它允许你将一个或多个 Spring 配置文件的内容导入到当前的应用程序上下文中。导入xml配置文件,可以额外分为两种模式:相对路径classpath、绝对路径(真实路径)file

注意:单文件可以不写value或locations,value和locations都可用相对路径(classpath)

  • 引入单个xml配置文件:@ImportSource(“classpath : xxx/xxxx.xml”)

  • 引入多个xml配置文件:@ImportSource(locations={“classpath : xxxx.xml” , “classpath : yyyy.xml”})

  • 绝对路径(file)

    • 引入单个xml配置文件:@ImportSource(locations= {“file : d:/hellxz/dubbo.xml”})

    • 引入多个xml配置文件:@ImportSource(locations= {“file : d:/hellxz/application.xml” , “file : d:/hellxz/dubbo.xml”})

使用 @ImportResource 注解的示例:

假设你有一个名为 applicationContext.xml 的 Spring 配置文件,其中定义了一些 bean 和其他配置信息。你可以使用 @ImportResource 注解将该文件导入到当前的应用程序上下文中。

@Configuration  
@ImportResource("applicationContext.xml")  
public class AppConfig {  
    // 配置类中的其他代码  
}

在上面的示例中,@ImportResource("applicationContext.xml")applicationContext.xml 文件中的内容导入到当前的应用程序上下文中。这样,你就可以在当前的应用程序中使用 applicationContext.xml 文件中定义的 bean 和其他配置信息。

注意,如果你使用了 @ComponentScan 注解来扫描组件,那么在 @ImportResource 中可以省略配置文件的路径。Spring 会自动查找并导入与当前包路径相关的配置文件。

例如,如果你的应用程序在 com.example.app 包下,并且你已经在配置类中使用了 @ComponentScan("com.example.app"),那么你可以直接使用 @ImportResource 注解导入名为 applicationContext.xml 的配置文件,而不需要指定路径。

@Configuration  
@ComponentScan("com.example.app")  
@ImportResource("applicationContext.xml")  
public class AppConfig {  
    // 配置类中的其他代码  
}

6.3 @Import

@Import 是 Spring 框架中的一个注解,用于将一个类导入到 Spring 容器中,作为 Spring 容器中的 bean。通常用于导入其他配置类或组件。

使用 @Import 注解的示例:

假设我们有一个名为 OtherConfiguration 的类,其中定义了一些其他的 bean 配置:

@Configuration  
public class OtherConfiguration {  
  
    @Bean  
    public SomeBean someBean() {  
        // 创建并返回 SomeBean bean  
    }  
}

现在,我们希望将 OtherConfiguration 类中的配置导入到当前的 Spring 容器中。为此,我们可以在当前配置类中添加 @Import 注解,如下所示:

@Configuration  
@Import(OtherConfiguration.class)  
public class MainConfiguration {  
    // 当前配置类的其他 bean 定义  
}

在上面的示例中,我们使用 @Import 注解将 OtherConfiguration 类导入到当前的 MainConfiguration 类中。这样,OtherConfiguration 类中定义的 someBean() 方法将作为 Spring 容器中的一个 bean 进行管理。

你可能感兴趣的:(知识库,spring,boot,java,spring,注解)