目录
简介：Annotation(注解)
一、Spring核心注解：
@Component注解
@Autowired注解
1. 字段注入
2. 构造方法注入
3. Setter方法注入
@Qualifier注解
1. 字段注入
2. 构造方法注入
3. Setter方法注入
@Primary注解
@Bean注解
@Lazy 注解
@Scope注解
@Value注解
@PropertySource注解
二、Spring MVC Web 注解 ：
@Controller注解
@ResponseBody注解
@RestController注解
@RequestMapping注解
@GetMapping注解
@PostMapping注解
@PutMapping注解
@DeleteMapping注解
@PatchMapping注解
@PathVariable注解
@ResponseStatus注解
@Service注解
@Repository注解
@Controller注解
三、Spring Boot注解：
@SpringBootApplication注解
@EnableAutoConfiguration注解
@Async注解
四、Spring Data JPA 注解：
@Query注解
1. 使用JPQL查询语句：
2. 使用本地SQL查询语句：
五、Spring Boot测试注解：
@SpringBootTest注解
@DataJpaTest注解
@WebMvcTest注解
六、JPA 和 Hibernate 注解：
@Id
@GeneratedValue
@Entity
@Table
@Column注解
JPA(Java Persistence API) @Transient 注解
JPA(Java Persistence API) @OneToOne 注解
JPA(Java Persistence API) @OneToMany 注解
JPA(Java Persistence API) @ManyToOne 注解
JPA(Java Persistence API) @ManyToMany 注解
JPA (Java Persistence API) @JoinTable 注解
Hibernate @PrimaryKeyJoinColumn 注解
Hibernate @Embeddable 和 @Embedded 注解
七、Servlet注解：
@WebServlet注解
@WebInitParam注解
@WebListener 注解
@WebFilter注解
@MultipartConfig注解
八、Java注解：
@Deprecated注解
@Override注解
@FunctionalInterface注解
@SafeVarargs注解
@SuppressWarnings注解
简介：Annotation(注解)
1、Annotation(注解)是JDK1.5及以后版本引入的。它可以用于创建文档，跟踪代码中的依赖性，甚至执行基本编译时检查。注解是以‘@注解名’在代码中存在的，根据注解参数的个数，我们可以将注解分为：标记注解、单值注解、完整注解三类。它们都不会直接影响到程序的语义，只是作为注解（标识）存在，我们可以通过反射机制编程实现对这些元数据（用来描述数据的数据）的访问。另外，你可以在编译时选择代码里的注解是否只存在于源代码级，或者它也能在class文件、或者运行时中出现（SOURCE/CLASS/RUNTIME）。
2、注解是一种用于对代码进行标记和说明的元数据，它能够提供有关代码的信息，但本身并不直接参与代码的运行。在Java开发中，注解可以用来描述类、方法、变量等元素的特性，从而可以在编译、运行时期获取这些注解的信息，进行相应的处理。通过合理地使用注解，我们可以简化开发工作，提高代码的可读性和可维护性。在接下来的文章中，我们将逐一介绍Java、Java EE、Spring、Spring Boot、JPA等框架中常用注解的具体作用和用法。
一、Spring核心注解：
@Component注解
@Component 注解表明被注解的类是一个“spring bean/组件”。@Component注解告诉Spring容器自动创建Spring bean。
@Component注解是Spring框架中的一个核心注解之一，是Spring框架中用来标识一个类作为Spring容器中托管的Bean的注解。Spring框架是一个用于构建企业级Java应用程序的开源框架，它提供了依赖注入和面向切面编程等功能，使得开发者能够更轻松地开发和管理复杂的应用程序。
在Spring应用程序中，组件是指那些由Spring容器管理的对象，它们通常包含了应用程序中的业务逻辑、数据访问逻辑或者其他功能性代码。使用@Component注解可以告诉Spring容器将一个类实例化为一个组件，并且可以通过依赖注入的方式在其他地方使用该组件。
除了@Component注解之外，Spring框架还提供了一系列其他的注解，用于标识不同类型的组件，例如`@Controller`、`@Service`、`@Repository`等。这些注解都是基于@Component注解的衍生，它们在功能上有一些差异，但都表示着被Spring容器管理的组件。
使用@Component注解非常简单，只需要将它放置在一个类的声明上即可：
@Component
public class MyComponent {
// 类的实现代码
}
在这个例子中，`MyComponent`类被标记为一个Spring组件，Spring容器会在启动时扫描并实例化这个类，并将其纳入管理范围。
除了标识组件之外，@Component注解还可以与自动装配（Autowired）一起使用，以便让Spring容器自动将依赖注入到组件中。例如，可以在另一个组件中使用@Autowired注解来注入`MyComponent`：
@Component
public class AnotherComponent {
@Autowired
private MyComponent myComponent;
// 其他代码
}
在这个例子中，`AnotherComponent`中的`myComponent`属性会被Spring容器自动注入为`MyComponent`类的实例。
@Component注解是Spring框架中用于标识组件的重要注解之一。它使得开发者能够方便地创建和管理Spring容器中的组件，并且能够与依赖注入等功能结合使用，实现更加灵活和模块化的应用程序开发。
@Autowired注解
@Autowired 注解用于自动注入 bean。@Autowired 注解用于构造函数注入、setter 注入和字段注入
@Autowired注解是Spring框架中用来自动装配Bean的注解。通过@Autowired注解，我们可以自动注入一个Bean，避免手动编写繁琐的代码进行依赖注入。当Spring容器通过类型匹配找到多个Bean时，我们可以通过@Qualifier注解指定具体的Bean名称进行注入。@Autowired注解可以用在构造方法、setter方法、字段和配置方法上，提供了非常灵活的注入方式。使用@Autowired注解能够让我们的代码更简洁、更易于维护，是Spring框架中非常常用的注解之一。
@Autowired注解可以应用于字段、构造方法、Setter方法或者一般方法上，以实现自动装配。当Spring容器扫描到一个被`@Autowired`注解标记的字段或方法时，它会尝试在容器中查找匹配的bean，并将其注入到被标记的位置。
1. 字段注入
@Component
public class MyComponent {
@Autowired
private AnotherComponent anotherComponent;
// 其他代码
}
在这个例子中，`MyComponent`类中的`anotherComponent`字段被@Autowired注解标记，Spring容器会自动将`AnotherComponent`类型的bean注入到这个字段中。
2. 构造方法注入
@Component
public class MyComponent {
private AnotherComponent anotherComponent;
@Autowired
public MyComponent(AnotherComponent anotherComponent) {
this.anotherComponent = anotherComponent;
}
// 其他代码
}
在这个例子中，`MyComponent`类的构造方法被@Autowired注解标记，Spring容器会在实例化`MyComponent`时自动注入一个`AnotherComponent`类型的bean。
3. Setter方法注入
@Component
public class MyComponent {
private AnotherComponent anotherComponent;
@Autowired
public void setAnotherComponent(AnotherComponent anotherComponent) {
this.anotherComponent = anotherComponent;
}
// 其他代码
}
在这个例子中，`MyComponent`类的Setter方法被@Autowired注解标记，Spring容器会在实例化`MyComponent`后自动调用这个Setter方法，并注入一个`AnotherComponent`类型的bean。
### 自动装配的类型
@Autowired注解默认按照类型（byType）进行自动装配，即根据被注入的字段或方法的类型来寻找匹配的bean进行注入。如果容器中存在多个符合类型的bean，Spring会尝试根据名称（byName）进行匹配。如果还是无法确定要注入的bean，Spring会抛出异常。
@Qualifier注解
@Qualifier 注解与 Autowired 结合使用，以避免当我们为同一类型配置两个或多个 bean 时发生混淆。在Spring容器中，如果存在多个候选的bean可以满足依赖注入的要求，那么Spring会无法确定要注入哪一个bean，从而导致装配失败。为了解决这种歧义性，可以配合@Qualifier注解指定具体要注入的bean。
@Qualifier注解是Spring框架中配合@Autowired注解使用的注解。当一个接口有多个实现类时，Spring容器无法确定要注入哪个Bean，这时我们可以在@Autowired注解中结合@Qualifier注解指定具体的Bean名称进行注入。@Qualifier注解配合@Autowired注解使用，可以解决因为多个实现类而导致的自动装配失败的问题。通过@Qualifier注解，我们可以明确指定要注入的Bean名称，确保程序的正确性。@Qualifier注解的值通常是对应Bean定义的名称或者其他标识符。在遇到多个候选Bean进行自动装配时，@Qualifier的使用能够帮助Spring容器选择正确的Bean进行注入。
1. 字段注入
@Component
public class MyComponent {
@Autowired
@Qualifier("specificBean")
private AnotherComponent anotherComponent;
// 其他代码
}
在这个例子中，`@Autowired`和`@Qualifier`注解一起应用于`anotherComponent`字段，指定了要注入的bean的名称为"specificBean"。
2. 构造方法注入
@Component
public class MyComponent {
private AnotherComponent anotherComponent;
@Autowired
public MyComponent(@Qualifier("specificBean") AnotherComponent anotherComponent) {
this.anotherComponent = anotherComponent;
}
// 其他代码
}
在这个例子中，`@Autowired`和`@Qualifier`注解一起应用于构造方法的参数，指定了要注入的bean的名称为"specificBean"。
3. Setter方法注入
@Component
public class MyComponent {
private AnotherComponent anotherComponent;
@Autowired
public void setAnotherComponent(@Qualifier("specificBean") AnotherComponent anotherComponent) {
this.anotherComponent = anotherComponent;
}
// 其他代码
}
在这个例子中，`@Autowired`和`@Qualifier`注解一起应用于Setter方法的参数，指定了要注入的bean的名称为"specificBean"。
### 注意事项
-使用`@Qualifier`注解时，需要确保指定的bean名称在Spring容器中是唯一的，否则会抛出NoSuchBeanDefinitionException异常。 - 如果没有指定`@Qualifier`注解，Spring会根据类型进行自动装配。只有当存在多个类型匹配的bean时，才需要使用`@Qualifier`注解进行进一步的指定。
@Primary注解
当存在多个相同类型的 bean 时，我们使用 @Primary 注解来对某个 bean 给予更高的优先级。
@Primary注解是Spring框架中用来指定首选Bean的注解。当一个接口存在多个实现类时，通过@Primary注解可以指定一个主要的实现类作为首选Bean，优先被注入。当Spring容器通过类型匹配找到多个候选Bean时，默认会选择带有@Primary注解的Bean进行注入。通过@Primary注解，我们可以明确指定默认的Bean，避免因为多个实现类导致的自动装配失败。@Primary注解的使用可以简化配置，让程序更加清晰明了。通常情况下，@Primary注解会和@Autowired注解一起使用，确保首选的Bean被正确注入。
#### 示例
@Component
@Primary
public class PrimaryComponent implements SomeInterface {
// 类的实现代码
}
@Component
public class SecondaryComponent implements SomeInterface {
// 类的实现代码
}
在这个例子中，`PrimaryComponent`类被`@Primary`注解标记，因此在自动装配时会优先选择注入`PrimaryComponent`而不是`SecondaryComponent`。
### 注意事项
- 使用`@Primary`注解时，需要确保在Spring容器中只有一个bean被标记为主要bean，否则可能会引发歧义性问题。 - 如果没有使用`@Qualifier`指定具体要注入的bean，并且存在多个候选的bean，则Spring会优先选择被`@Primary`注解标记的bean进行注入。
@Bean注解
@Bean注解表示一个方法产生一个由Spring容器管理的bean。@Bean 注解通常在 Configuration 类中声明以创建 Spring Bean 定义。
@Bean注解是Spring框架中用来定义Bean的注解。通过在一个方法上使用@Bean注解，我们可以将该方法返回的对象注册为Spring容器中的Bean，然后可以在其他组件中通过@Autowired注解进行注入。@Bean注解通常用于配置类中，用来定义一些特殊对象的创建方式或者对第三方库中的对象进行包装，使其成为Spring管理的Bean。@Bean注解可以指定Bean的名称、作用域、是否懒加载等属性，非常灵活。使用@Bean注解可以让我们将任意一个Java对象交给Spring容器进行管理，实现了Spring的控制反转和依赖注入功能。
@Bean注解通常用于Java配置类中的方法上，这些方法将返回一个对象，Spring容器将这个对象注册为一个bean。
@Configuration
public class AppConfig {
@Bean
public MyBean myBean() {
return new MyBean();
}
// 其他@Bean方法
}
在这个例子中，`myBean()`方法用@Bean注解标记，它将返回一个`MyBean`对象，并由Spring容器管理。
@Bean注解还可以指定bean的名称。
@Configuration
public class AppConfig {
@Bean(name = "myBean")
public MyBean createMyBean() {
return new MyBean();
}
// 其他@Bean方法
}
在这个例子中，@Bean注解的`name`属性指定了bean的名称为"myBean"。
@Bean注解还可以指定bean的初始化方法和销毁方法。
@Configuration
public class AppConfig {
@Bean(initMethod = "init", destroyMethod = "cleanup")
public MyBean myBean() {
return new MyBean();
}
// 其他@Bean方法
}
在这个例子中，@Bean注解的`initMethod`属性指定了初始化方法为`init()`，`destroyMethod`属性指定了销毁方法为`cleanup()`。
### 注意事项
使用@Bean注解的方法可以在同一个配置类中定义多个bean。 @Bean注解通常与@Configuration注解一起使用，用于标识配置类。
@Lazy 注解
默认情况下，Spring 在应用程序上下文的启动/引导时急切地创建所有单例 bean。您可以使用 @Lazy 注解延迟（按需）加载 Spring beans。
@Lazy注解是Spring框架中用来指定Bean的延迟加载方式的注解。通常情况下，Spring容器在启动时会一次性创建并初始化所有的Bean，即采用立即加载的方式。但是通过@Lazy注解，我们可以将Bean的初始化延迟到第一次被使用时再进行，即采用延迟加载的方式。这样可以提高程序的性能和资源利用率，特别是对于一些资源消耗较大的Bean来说，延迟加载可以避免不必要的开销。@Lazy注解通常和@Bean注解一起使用，用来指定某个Bean是否需要延迟加载。使用@Lazy注解可以根据需求灵活调整Bean的初始化时机，实现更加高效的资源管理。
@Scope注解
@Scope 注解用于定义 bean 的范围。我们使用@Scope来定义@Component类或@Bean定义的范围。
@Scope注解是Spring框架中用来指定Bean的作用域的注解。通过@Scope注解，我们可以指定一个Bean的生命周期范围，即在容器中的存活时间。Spring框架中提供了多种作用域，包括Singleton（单例）、Prototype（原型）、Request（请求）、Session（会话）等，可以根据不同的需求选择合适的作用域。默认情况下，Bean的作用域是Singleton，即在整个容器中只有一个实例。通过@Scope注解，我们可以自定义Bean的作用域，灵活控制Bean的创建和销毁时机。使用@Scope注解可以解决多线程并发访问的问题，提高系统的健壮性和性能表现。
@Value注解
Spring @Value 注解用于为变量和方法参数分配默认值。
@Value 注解主要用于从属性文件中获取特定属性键的值。我们可以使用@Value注解读取spring环境变量以及系统变量。
@Value注解是Spring框架中用来注入外部属性值到Bean中的注解。通过@Value注解，我们可以将配置文件中的属性值注入到Bean的字段或方法参数中，以实现配置和代码的分离。@Value注解支持基本类型、String类型以及Spring表达式语言（SpEL），可以方便地注入各种类型的值，如基本类型、引用类型、List、Map等。@Value注解通常用于将外部配置文件中的属性值注入到Bean中，例如数据库连接信息、文件路径、版本号等。使用@Value注解可以实现配置的统一管理，方便后续修改和维护，提高系统的可配置性和可维护性。
@PropertySource注解
Spring @PropertySource 注解用于向 Spring 环境提供属性文件。Spring PropertySource 注解是可重复的，这意味着一个 Configuration 类上可以有多个 PropertySource。
@PropertySource注解是Spring框架中用来加载外部属性文件的注解。通过@PropertySource注解，我们可以指定要加载的外部属性文件，并将其中的属性值注入到Spring环境中，供Bean进行引用。通常情况下，我们将项目中的配置信息（如数据库连接信息、服务端口号、缓存策略等）保存在外部的属性文件中，通过@PropertySource注解将这些属性文件加载到Spring容器中，然后使用@Value注解将属性值注入到Bean中。这样可以实现配置与代码的分离，并提高系统的灵活性和可维护性。@PropertySource注解通常和@Value注解一起使用，用来加载外部属性文件，并将其中的属性值注入到Bean中，以实现灵活的配置管理。
二、Spring MVC Web 注解 ：
@Controller注解
Spring提供了@Controller注解来使Java类作为Spring MVC控制器。@Controller 注解指示特定类充当控制器的角色。
@Controller注解是Spring框架中用来标识控制器的注解。通过@Controller注解，我们可以将一个类标识为Spring MVC框架中的控制器，用来处理用户的请求并返回相应的视图。在Spring MVC中，控制器负责接收请求、调用适当的业务逻辑处理请求，并返回视图或数据。通过@Controller注解，我们可以将一个普通的Java类转换为Spring MVC的控制器，使其具有处理请求的能力。@Controller注解通常和@RequestMapping注解一起使用，用来指定处理请求的URL映射关系。使用@Controller注解可以实现请求的分发和处理，实现用户与系统之间的交互。
@ResponseBody注解
@ResponseBody 注解告诉控制器返回的对象会自动序列化为 JSON 并传回 HttpResponse 对象。
@ResponseBody注解是Spring框架中用来标识方法返回的结果直接写入HTTP响应体中的注解。通过@ResponseBody注解，我们可以将方法返回的数据直接返回给客户端，而不是通过视图解析器来解析视图。这样可以实现RESTful风格的接口，直接返回JSON/XML等格式的数据给客户端，而不是将数据渲染成视图。@ResponseBody注解通常和@Controller注解一起使用，用来标识某个方法的返回结果需要直接写入响应体中。使用@ResponseBody注解可以简化开发，减少代码量，提高接口的响应速度和灵活性。
@RestController注解
Spring 4.0 引入了 @RestController，@Controller 的一个专门版本，它是一个方便的注解，除了添加 @Controller 和 @ResponseBody 注解之外什么也不做。
@RestController注解是Spring框架中的一个组合注解，相当于@Controller和@ResponseBody注解的结合体。通过@RestController注解，我们可以将一个类标识为Spring MVC框架中的RESTful风格的控制器。与@Controller注解不同的是，@RestController注解的所有方法都默认返回数据，而不是视图。这意味着@RestController注解下的方法返回的数据会直接写入HTTP响应体中，而不会经过视图解析器。@RestController注解通常用于编写RESTful风格的接口，返回JSON/XML等数据给客户端。使用@RestController注解可以简化开发，提高接口的响应速度和灵活性，是开发RESTful风格接口的首选注解。
@RequestMapping注解
@RequestMapping是Spring MVC中最常见、使用最广泛的注解。它用于将 Web 请求映射到特定的处理程序类和/或处理程序方法。
@RequestMapping注解是Spring框架中用来映射URL路径和请求方法的注解。通过@RequestMapping注解，我们可以将一个方法映射到指定的URL路径上，并指定请求的方法类型（GET、POST、PUT、DELETE等）。这样当客户端发送请求时，Spring MVC框架会根据@RequestMapping注解中指定的路径和方法来匹配相应的方法进行处理。@RequestMapping注解可以用在类级别上，表示该类中的所有方法都映射到指定路径上；也可以用在方法级别上，表示该方法映射到指定路径和请求方法上。通过@RequestMapping注解，我们可以实现请求的分发和处理，实现灵活的URL映射关系，是Spring MVC中常用的注解之一。
@GetMapping注解
GET HTTP 请求用于获取单个或多个资源，@GetMapping注解用于将 HTTP GET 请求映射到特定的处理程序方法。
@GetMapping注解是Spring框架中的一个组合注解，相当于@RequestMapping注解中指定method为GET请求的简化写法。通过@GetMapping注解，我们可以将一个方法映射到指定的URL路径上，并指定请求的方法类型为GET请求。这样当客户端发送GET请求时，Spring MVC框架会根据@GetMapping注解中指定的路径来匹配相应的方法进行处理。@GetMapping注解可以用在类级别上或方法级别上，用来简化@RequestMapping注解中指定GET请求的操作。使用@GetMapping注解可以使代码更加清晰简洁，提高开发效率，是Spring MVC中常用的注解之一。
@PostMapping注解
POST HTTP 方法用于创建资源和@PostMapping注解，用于将 HTTP POST 请求映射到特定处理程序方法。
@PostMapping注解是Spring框架中的一个组合注解，相当于@RequestMapping注解中指定method为POST请求的简化写法。通过@PostMapping注解，我们可以将一个方法映射到指定的URL路径上，并指定请求的方法类型为POST请求。这样当客户端发送POST请求时，Spring MVC框架会根据@PostMapping注解中指定的路径来匹配相应的方法进行处理。@PostMapping注解可以用在类级别上或方法级别上，用来简化@RequestMapping注解中指定POST请求的操作。使用@PostMapping注解可以使代码更加清晰简洁，提高开发效率，是Spring MVC中常用的注解之一。
@PutMapping注解
PUT HTTP 方法用于更新资源和@PutMapping注解，用于将 HTTP PUT 请求映射到特定处理程序方法。
@PutMapping注解是Spring框架中的一个组合注解，相当于@RequestMapping注解中指定method为PUT请求的简化写法。通过@PutMapping注解，我们可以将一个方法映射到指定的URL路径上，并指定请求的方法类型为PUT请求。这样当客户端发送PUT请求时，Spring MVC框架会根据@PutMapping注解中指定的路径来匹配相应的方法进行处理。@PutMapping注解可以用在类级别上或方法级别上，用来简化@RequestMapping注解中指定PUT请求的操作。使用@PutMapping注解可以使代码更加清晰简洁，提高开发效率，是Spring MVC中常用的注解之一。
@DeleteMapping注解
DELETE HTTP 方法用于删除资源，@DeleteMapping注解用于将 HTTP DELETE 请求映射到特定处理程序方法。
@DeleteMapping注解是Spring框架中的一个组合注解，相当于@RequestMapping注解中指定method为DELETE请求的简化写法。通过@DeleteMapping注解，我们可以将一个方法映射到指定的URL路径上，并指定请求的方法类型为DELETE请求。这样当客户端发送DELETE请求时，Spring MVC框架会根据@DeleteMapping注解中指定的路径来匹配相应的方法进行处理。@DeleteMapping注解可以用在类级别上或方法级别上，用来简化@RequestMapping注解中指定DELETE请求的操作。使用@DeleteMapping注解可以使代码更加清晰简洁，提高开发效率，是Spring MVC中常用的注解之一。
@PatchMapping注解
PATCH HTTP 方法用于部分更新资源，@PatchMapping注解用于将 HTTP PATCH 请求映射到特定处理程序方法。
@PatchMapping注解是Spring框架中的一个组合注解，类似于其他HTTP方法的注解，用于将一个方法映射到指定的URL路径上，并指定请求的方法类型为PATCH请求。当客户端发送PATCH请求时，Spring MVC框架会根据@PatchMapping注解中指定的路径来匹配相应的方法进行处理。与其他HTTP方法的注解类似，@PatchMapping注解可以用在类级别上或方法级别上，用来简化@RequestMapping注解中指定PATCH请求的操作。使用@PatchMapping注解可以使代码更加清晰简洁，提高开发效率，是Spring MVC中常用的注解之一。
@PathVariable注解
Spring boot @PathVariable 注解用于方法参数，将其绑定到 URI 模板变量的值。
@PathVariable注解是Spring框架中用于接收请求路径中的参数的注解。通常情况下，我们在Spring MVC中使用@RequestMapping注解来映射URL路径到Controller中的方法上。而当URL路径中包含变量部分时，我们可以使用@PathVariable注解将这些变量绑定到方法的参数上。
举个例子，假设我们有一个URL路径为/user/{userId}，其中{userId}是一个变量部分，表示用户的ID。我们可以在Controller的方法参数上使用@PathVariable注解来获取这个参数，如下所示：
@GetMapping("/user/{userId}")
public String getUser(@PathVariable Long userId) {
// 在这里可以使用userId来处理业务逻辑
return "User ID: " + userId;
}
在这个例子中，当请求路径为/user/123时，Spring MVC框架会将123这个值绑定到userId参数上，并调用getUser方法。@PathVariable注解可以接收多种类型的参数，包括基本数据类型、String、甚至自定义对象类型。通过@PathVariable注解，我们可以方便地获取URL路径中的参数，实现更灵活的请求处理逻辑。
@ResponseStatus注解
@ResponseStatus 注解是一个 Spring 框架注解，用于自定义 Spring MVC 或 Spring Boot 应用程序中控制器方法返回的 HTTP 响应状态代码。
@ResponseStatus注解是Spring框架中的一个注解，用于指定处理器方法的响应状态码。通常情况下，当处理器方法执行完毕后，Spring MVC框架会返回一个HTTP响应给客户端，而@ResponseStatus注解可以用来指定这个响应的状态码。
举个例子，假设我们有一个处理器方法，用于处理用户提交的表单：
@PostMapping("/submitForm")
@ResponseStatus(HttpStatus.CREATED)
public String submitForm(@RequestBody FormData formData) {
// 处理表单数据的逻辑
return "Form submitted successfully!";
}
在这个例子中，@ResponseStatus(HttpStatus.CREATED)注解指定了当处理器方法成功执行时返回的状态码为201 Created。这样，当客户端提交表单并处理成功时，服务器会返回状态码201给客户端，表示资源已经被成功创建。
@ResponseStatus注解可以用在处理器方法上，也可以用在异常类上。当用在异常类上时，它可以指定当抛出特定异常时返回的状态码，例如：
@ResponseStatus(HttpStatus.NOT_FOUND)
public class ResourceNotFoundException extends RuntimeException {
// 异常类的定义
}
在这个例子中，当抛出ResourceNotFoundException异常时，Spring MVC框架会返回状态码404给客户端，表示请求的资源未找到。
总之，@ResponseStatus注解可以方便地指定处理器方法或异常类的响应状态码，让代码更加清晰明了。
@Service注解
@Service注解用于在Service层创建Spring bean。
@Service注解是Spring框架中的一个注解，用于标识一个类为服务（Service）。在Spring中，服务层通常用来处理业务逻辑，与数据访问层（DAO层）和表示层（Controller层）相分离，使代码更加清晰、模块化和可维护。
当一个类被标记为@Service时，Spring会自动将其识别为一个Bean（即组件），并将其纳入Spring容器的管理范围之内，可以通过依赖注入等方式在其他组件中使用。
举个例子，假设我们有一个UserService用来处理用户相关的业务逻辑：
@Service
public class UserService {
@Autowired
private UserRepository userRepository;
public User getUserById(Long userId) {
return userRepository.findById(userId);
}
public void saveUser(User user) {
userRepository.save(user);
}
// 其他业务方法
}
在这个例子中，UserService被标记为@Service，表示它是一个服务类。它可以通过@Autowired注解注入其他组件，比如UserRepository，用来访问数据库。这样，我们可以在UserService中实现用户相关的业务逻辑，而不需要在Controller中处理太多的业务逻辑，实现了业务逻辑与表示层的分离。
总之，@Service注解是Spring框架中用来标识服务层组件的注解，能够帮助实现业务逻辑的模块化和可维护性。
@Repository注解
@Repository 用于为 DAO 层的存储库创建 Spring bean。
@Repository注解是Spring框架中的一个注解，用于标识一个类为数据访问层（Repository）。在Spring中，数据访问层主要负责与数据库进行交互，包括数据的存储、检索、更新和删除等操作。
当一个类被标记为@Repository时，Spring会自动将其识别为一个Bean，并将其纳入Spring容器的管理范围之内，可以通过依赖注入等方式在其他组件中使用。
举个例子，假设我们有一个UserRepository用来操作用户相关的数据：
@Repository
public class UserRepository {
@Autowired
private JdbcTemplate jdbcTemplate;
public User findById(Long userId) {
String sql = "SELECT * FROM users WHERE id = ?";
return jdbcTemplate.queryForObject(sql, new Object[]{userId}, new UserRowMapper());
}
public void save(User user) {
String sql = "INSERT INTO users (id, username, email) VALUES (?, ?, ?)";
jdbcTemplate.update(sql, user.getId(), user.getUsername(), user.getEmail());
}
// 其他数据访问方法
}
在这个例子中，UserRepository被标记为@Repository，表示它是一个数据访问层组件。它可以通过@Autowired注解注入其他组件，比如JdbcTemplate，用来执行SQL语句并与数据库进行交互。这样，我们可以在UserRepository中封装对数据库的访问操作，而不需要在业务逻辑中直接操作数据库，实现了数据访问逻辑与业务逻辑的分离。
总之，@Repository注解是Spring框架中用来标识数据访问层组件的注解，能够帮助实现数据访问逻辑的模块化和可维护性。
@Controller注解
@Controller用于在控制器层创建Spring bean。
@Controller注解是Spring框架中的一个注解，用于标识一个类为控制器（Controller）。在Spring MVC中，控制器负责接收用户的HTTP请求，并根据请求调用相应的业务逻辑进行处理，然后将处理结果返回给客户端。
当一个类被标记为@Controller时，Spring会自动将其识别为一个控制器Bean，并将其纳入Spring容器的管理范围之内，可以通过依赖注入等方式在其他组件中使用。
举个例子，假设我们有一个UserController用来处理用户相关的HTTP请求：
@Controller
@RequestMapping("/users")
public class UserController {
@Autowired
private UserService userService;
@GetMapping("/{userId}")
public ResponseEntity
User user = userService.getUserById(userId);
if (user != null) {
return ResponseEntity.ok(user);
} else {
return ResponseEntity.notFound().build();
}
}
@PostMapping("/")
public ResponseEntity
userService.saveUser(user);
return ResponseEntity.status(HttpStatus.CREATED).body("User created successfully!");
}
// 其他处理HTTP请求的方法
}
在这个例子中，UserController被标记为@Controller，表示它是一个控制器类。它通过@RequestMapping注解指定了处理的URL路径"/users"，并通过@Autowired注解注入了UserService，用来处理用户相关的业务逻辑。
@Controller注解的方法通常使用@RequestMapping、@GetMapping、@PostMapping等注解来指定处理的HTTP请求方法和路径。这样，当客户端发送对应路径的HTTP请求时，Spring MVC框架会自动调用相应的方法进行处理，并返回处理结果给客户端。
总之，@Controller注解是Spring框架中用来标识控制器组件的注解，能够帮助实现请求处理逻辑的模块化和可维护性。
三、Spring Boot注解：
@SpringBootApplication注解
@SpringBootApplication注解是Spring Boot框架中的核心注解。它用于标记 Spring Boot 应用程序的主类。该注解是其他三个注解的组合：@Configuration、@EnableAutoConfiguration 和@ComponentScan。
@SpringBootApplication注解是Spring Boot框架中的一个注解，用于标识一个类为Spring Boot应用的主类。在Spring Boot中，主类通常是应用程序的入口点，其中包含了main方法，用于启动Spring Boot应用。
当一个类被标记为@SpringBootApplication时，Spring Boot会自动将其识别为主类，并启动Spring应用程序上下文。它会扫描当前包及其子包中的组件，并根据各种注解配置Spring应用程序上下文，包括自动配置、组件扫描和属性配置等。
举个例子，一个简单的Spring Boot应用的主类可能如下所示：
@SpringBootApplication
public class MyApplication {
public static void main(String[] args) {
SpringApplication.run(MyApplication.class, args);
}
}
在这个例子中，MyApplication类被标记为@SpringBootApplication，表示它是Spring Boot应用的主类。它包含了main方法，通过调用SpringApplication.run方法启动Spring Boot应用程序。
@SpringBootApplication注解实际上是一个组合注解，包含了@SpringBootConfiguration、@EnableAutoConfiguration和@ComponentScan三个注解的功能。其中：
@SpringBootConfiguration：标识该类为Spring Boot的配置类，通常与@Configuration注解功能相同。@EnableAutoConfiguration：启用Spring Boot的自动配置机制，根据类路径下的jar包和配置文件，自动配置Spring应用程序上下文的Bean。@ComponentScan：启用组件扫描，自动扫描当前包及其子包中的组件，包括@Service、@Repository、@Controller等组件。
总之，@SpringBootApplication注解是Spring Boot应用程序的入口点，用于标识主类并启动Spring应用程序上下文，简化了Spring应用程序的配置和启动过程。
@EnableAutoConfiguration注解
@EnableAutoConfiguration 注解启用 Spring Boot 的自动配置功能，该功能根据类路径依赖项和环境自动配置应用程序。
@EnableAutoConfiguration注解是Spring Boot框架中的一个注解，用于启用Spring Boot的自动配置功能。在Spring Boot中，自动配置能够根据应用程序的类路径、依赖关系和其他配置，自动配置Spring应用程序上下文的Bean，从而简化了应用程序的配置和启动过程。
当一个类被标记为@EnableAutoConfiguration时，Spring Boot会在应用程序启动时自动加载并执行自动配置过程。它会根据类路径下的jar包、依赖关系和配置文件，自动配置Spring应用程序上下文所需的Bean，包括数据源、JPA、消息队列、缓存、Web等。这样，开发者无需手动配置大量的Bean，而是可以依赖于Spring Boot的自动配置机制来简化应用程序的搭建和部署。
举个例子，假设我们有一个简单的Spring Boot应用：
@EnableAutoConfiguration
public class MyApplication {
public static void main(String[] args) {
SpringApplication.run(MyApplication.class, args);
}
}
在这个例子中，MyApplication类被标记为@EnableAutoConfiguration，表示启用了Spring Boot的自动配置功能。在应用程序启动时，Spring Boot会根据类路径下的jar包、依赖关系和配置文件，自动配置所需的Bean，从而简化了应用程序的配置和启动过程。
@EnableAutoConfiguration注解实际上是Spring Boot的核心注解之一，它通过扫描classpath下的META-INF/spring.factories文件中的配置，加载并执行各种自动配置类，从而实现自动配置的功能。
总之，@EnableAutoConfiguration注解是Spring Boot框架中用于启用自动配置功能的注解，能够帮助简化Spring应用程序的配置和启动过程。
@Async注解
可以在方法上提供 @Async 注解，以便异步调用该方法。
@Async注解是Spring框架中的一个注解，用于标识一个方法是异步执行的。在Java应用程序中，通常情况下方法是同步执行的，即按照代码顺序逐行执行，直到方法执行完成。但有时候某些方法可能会花费较长时间执行，如果在等待这些方法执行完成的过程中阻塞主线程，可能会导致应用程序响应变慢或不可用。
@Async注解的作用就是告诉Spring框架将被注解的方法放在一个单独的线程中异步执行，而不会阻塞主线程。这样可以提高应用程序的并发性和性能，特别是在处理一些耗时的任务时，如文件上传、邮件发送、数据处理等。
使用@Async注解需要满足以下条件：
1. 该注解必须放在方法上。2. 被注解的方法必须返回void、Future或ListenableFuture类型。3. 在Spring配置类中通过@EnableAsync注解启用异步执行功能。
举个例子，假设我们有一个异步任务处理类AsyncTask：
@Service
public class AsyncTask {
@Async
public void processTask() {
// 模拟耗时任务
try {
Thread.sleep(5000); // 5秒钟
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("异步任务处理完成");
}
}
在这个例子中，processTask()方法被@Async注解标记，表示该方法是异步执行的。当调用该方法时，Spring框架会将其放在一个单独的线程中执行，不会阻塞主线程。
需要注意的是，为了使@Async注解生效，还需要在Spring的配置类中使用@EnableAsync注解启用异步执行功能。
总之，@Async注解是Spring框架中用于标识方法异步执行的注解，能够提高应用程序的并发性和性能。
四、Spring Data JPA 注解：
@Query注解
在 Spring Data JPA 中，@Query注解用于定义自定义查询。它允许开发人员执行 JPQL（Java 持久性查询语言）和本机 SQL 查询。
@Query注解是Spring Data JPA中的一个注解，用于在Repository接口的方法上声明查询语句。Spring Data JPA是Spring框架对JPA规范的封装和简化，提供了一种更简单、更高效的数据访问方式。
通过@Query注解，开发者可以在Repository接口的方法上直接声明JPQL（Java Persistence Query Language）或本地SQL查询语句，而不需要编写实际的SQL语句。这样可以提高代码的可读性和可维护性，并且可以利用Spring Data JPA的特性，如方法名解析、动态查询等。
@Query注解有两种使用方式：
1. 使用JPQL查询语句：
@Repository
public interface UserRepository extends JpaRepository
@Query("SELECT u FROM User u WHERE u.username = ?1")
User findByUsername(String username);
}
在这个例子中，@Query注解标记的方法findByUsername使用了JPQL查询语句，根据用户名查询用户信息。
2. 使用本地SQL查询语句：
@Repository
public interface UserRepository extends JpaRepository
@Query(value = "SELECT * FROM users WHERE username = ?1", nativeQuery = true)
User findByUsername(String username);
}
在这个例子中，@Query注解的nativeQuery属性设置为true，表示使用本地SQL查询语句，而不是JPQL。这样可以直接编写SQL语句，执行更复杂的查询操作。
需要注意的是，@Query注解还支持命名参数、排序、分页等功能，可以根据具体的需求进行配置。
总之，@Query注解是Spring Data JPA中用于声明查询语句的注解，可以在Repository接口的方法上使用，提供了一种简单、高效的数据访问方式。
五、Spring Boot测试注解：
@SpringBootTest注解
Spring Boot 为集成测试提供了 @SpringBootTest 注解。此注解创建应用程序上下文并加载完整的应用程序上下文。
@SpringBootTest注解是Spring Boot框架中的一个注解，用于在集成测试中加载整个Spring应用程序上下文。在进行集成测试时，通常需要加载应用程序的所有Bean，并模拟真实环境下的应用程序行为，以确保各个组件能够正确地协同工作。
通过在测试类上添加@SpringBootTest注解，开发者可以告诉Spring Boot在测试期间加载整个应用程序上下文，并创建应用程序中的所有Bean，包括控制器、服务、存储库等。这样可以模拟出一个完整的运行环境，进行更全面的集成测试。
@SpringBootTest注解提供了多种配置选项，以便满足不同测试场景的需求：
1. classes：指定要加载的配置类。可以通过classes属性指定一个或多个配置类，Spring Boot将加载这些配置类来创建应用程序上下文。如果不指定classes属性，则默认加载主配置类（通常是带有@SpringBootApplication注解的类）。
2. properties：指定要加载的属性文件。可以通过properties属性指定一个或多个属性文件，Spring Boot将加载这些属性文件中的配置信息。
3. webEnvironment：指定Web环境的类型。可以通过webEnvironment属性指定测试运行在什么样的Web环境下，包括MOCK、RANDOM_PORT和DEFINED_PORT等选项。
4. randomPorts：指定是否随机分配端口号。当webEnvironment属性设置为RANDOM_PORT时，可以通过randomPorts属性指定是否随机分配端口号。
举个例子，假设我们有一个简单的集成测试类：
@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
public class MyIntegrationTest {
@Autowired
private MyService myService;
@Test
public void testService() {
String result = myService.doSomething();
assertEquals("Expected result", result);
}
}
在这个例子中，@SpringBootTest注解指定了测试运行在随机端口的Web环境下，并加载了整个应用程序上下文。测试方法testService()可以通过@Autowired注解注入MyService bean，并对其进行测试。
总之，@SpringBootTest注解是Spring Boot框架中用于进行集成测试的注解，能够加载整个应用程序上下文，并模拟真实环境下的应用程序行为，是编写高质量、健壮性强的集成测试的重要工具。
@DataJpaTest注解
Spring Boot 提供了 @DataJpaTest 注解来测试持久层组件，这些组件将自动配置内存嵌入式数据库以进行测试。
@DataJpaTest注解是Spring Boot框架中用于进行JPA持久层测试的注解。它专门用于测试JPA相关的组件，例如Repository层的数据访问逻辑，而不需要加载整个应用程序上下文。
通过在测试类上添加@DataJpaTest注解，开发者可以告诉Spring Boot仅加载JPA相关的组件，如实体类和Repository接口，而不加载其他不必要的组件，比如控制器或服务层。
@DataJpaTest注解提供了一些配置选项，以便满足不同测试场景的需求：
1. showSql：指定是否显示SQL语句。可以通过设置showSql属性为true或false来控制是否在测试期间打印SQL语句到控制台。
2. properties：指定要加载的属性文件。可以通过properties属性指定一个或多个属性文件，Spring Boot将加载这些属性文件中的配置信息。
举个例子，假设我们有一个简单的JPA持久层测试类：
@DataJpaTest
public class UserRepositoryIntegrationTest {
@Autowired
private TestEntityManager entityManager;
@Autowired
private UserRepository userRepository;
@Test
public void whenFindByUsername_thenReturnUser() {
// given
User user = new User("john.doe@example.com");
entityManager.persist(user);
entityManager.flush();
// when
User found = userRepository.findByUsername("john.doe@example.com");
// then
assertThat(found.getUsername())
.isEqualTo(user.getUsername());
}
}
在这个例子中，@DataJpaTest注解指定了该测试类是一个JPA持久层测试，Spring Boot会加载相关的JPA组件。测试方法whenFindByUsername_thenReturnUser()测试了通过用户名查询用户信息的方法。
总之，@DataJpaTest注解是Spring Boot框架中用于进行JPA持久层测试的注解，能够专注于测试JPA相关的组件，是编写高质量、高效的JPA持久层测试的重要工具。
@WebMvcTest注解
@WebMvcTest 注解用于在 Spring MVC 控制器上执行单元测试。它允许您在受控和隔离的环境中测试控制器的行为、请求映射和 HTTP 响应。
@WebMvcTest注解是Spring Boot框架中用于进行Web层单元测试的注解。它专门用于测试Web层的组件，如控制器（Controller），而不需要加载整个应用程序上下文。
通过在测试类上添加@WebMvcTest注解，开发者可以告诉Spring Boot仅加载与Web层相关的组件，如控制器、异常处理器、过滤器等，而不加载其他不必要的组件，比如持久层或服务层。
@WebMvcTest注解提供了一些配置选项，以便满足不同测试场景的需求：
1. controllers：指定要测试的控制器类。可以通过controllers属性指定一个或多个要测试的控制器类，Spring Boot将仅加载这些控制器类。
2. showPrint：指定是否打印MVC请求和响应的详细信息。可以通过设置showPrint属性为true或false来控制是否在测试期间打印请求和响应的详细信息到控制台。
3. properties：指定要加载的属性文件。可以通过properties属性指定一个或多个属性文件，Spring Boot将加载这些属性文件中的配置信息。
举个例子，假设我们有一个简单的控制器类：
@RestController
public class HelloController {
@GetMapping("/hello")
public String hello() {
return "Hello, World!";
}
}
我们可以编写一个对该控制器类的单元测试：
@WebMvcTest(HelloController.class)
public class HelloControllerTest {
@Autowired
private MockMvc mockMvc;
@Test
public void testHello() throws Exception {
mockMvc.perform(get("/hello"))
.andExpect(status().isOk())
.andExpect(content().string("Hello, World!"));
}
}
在这个例子中，@WebMvcTest注解指定了该测试类是一个Web层单元测试，Spring Boot会加载相关的Web层组件。测试方法testHello()测试了控制器中的hello()方法是否返回了"Hello, World!"。
总之，@WebMvcTest注解是Spring Boot框架中用于进行Web层单元测试的注解，能够专注于测试Web层相关的组件，是编写高质量、高效的Web层单元测试的重要工具。
六、JPA 和 Hibernate 注解：
@Id
将字段标记为实体的主键。
@Id注解是Java持久化API（JPA）中的一个注解，用于标识实体类的主键属性。在JPA中，每个实体类都必须有一个主键属性，@Id注解用来指定该属性。
通常情况下，@Id注解与@GeneratedValue注解一起使用，@GeneratedValue用于指定主键的生成策略，如自增、UUID等。当主键属性的值由数据库自动生成时，通常会与@GeneratedValue注解一起使用。
举个例子，假设我们有一个简单的User实体类：
@Entity
public class User {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
private String username;
private String email;
// 省略构造方法、getter和setter等
}
（大家应该会getter、setter构造方法吧，不会的话百度一下吧，下文还会出现使用该方法，这里不详细展开哈哈哈~）
在这个例子中，@Id注解标识了id属性作为User实体类的主键。而@GeneratedValue注解指定了该主键的生成策略为自增（IDENTITY），即由数据库自动生成主键值。
总之，@Id注解是JPA中用于标识实体类主键属性的注解，用来指定实体类的主键。
@GeneratedValue
指定生成主键值的策略。
@GeneratedValue注解是Java持久化API（JPA）中的一个注解，用于指定实体类主键的生成策略。它通常与@Id注解一起使用，@Id用于标识实体类的主键属性，而@GeneratedValue用于指定主键的值如何生成。
@GeneratedValue注解提供了多种生成策略，常见的包括：
1. GenerationType.IDENTITY：使用数据库的自增列来生成主键值。 2. GenerationType.SEQUENCE：使用数据库的序列来生成主键值。 3. GenerationType.TABLE：使用一个特定的数据库表来存储主键值。 4. GenerationType.AUTO：由持久化提供程序自动选择合适的生成策略，通常是IDENTITY或SEQUENCE中的一种。
举个例子，假设我们有一个简单的User实体类：
@Entity
public class User {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
private String username;
private String email;
// 省略构造方法、getter和setter等
}
在这个例子中，@GeneratedValue注解指定了主键的生成策略为IDENTITY，即使用数据库的自增列来生成主键值。
总之，@GeneratedValue注解是JPA中用于指定实体类主键生成策略的注解，用来控制主键值的生成方式。
@Entity
指定类是一个实体，并映射到数据库表。
@Entity注解是Java持久化API（JPA）中的一个注解，用于标识一个类为实体类。在JPA中，实体类对应数据库中的表，每个实体类的对象对应数据库表中的一条记录。
使用@Entity注解标注的类必须包含一个无参构造方法，并且必须是可访问的（通常是public）。实体类中通常包含了类属性与数据库表中的列的映射关系，以及与数据库表的关联关系等信息。
举个例子，假设我们有一个简单的User实体类：
@Entity
public class User {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
private String username;
private String email;
// 省略构造方法、getter和setter等
}
在这个例子中，@Entity注解标识了User类为一个实体类，它将被映射到数据库中的一个表。类中的属性id、username、email将与数据库表中的对应列建立映射关系。
总之，@Entity注解是JPA中用于标识实体类的注解，用来指示一个类是一个实体类，需要进行持久化操作。
@Table
指定与实体关联的表名。
@Table注解是Java持久化API（JPA）中的一个注解，用于指定实体类与数据库表之间的映射关系。当实体类的类名与数据库表名不一致，或者需要指定特定的数据库表名、schema等信息时，可以使用@Table注解来进行配置。
@Table注解提供了一系列属性用于配置数据库表的各种信息，常见的属性包括：
1. name：指定数据库表的表名。 2. schema：指定数据库表所属的schema名称。 3. catalog：指定数据库表所属的catalog名称。 4. uniqueConstraints：指定数据库表的唯一约束。 5. indexes：指定数据库表的索引。
举个例子，假设我们有一个简单的User实体类，但是希望它与数据库中的表名不同：
@Entity
@Table(name = "app_user")
public class User {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
private String username;
private String email;
// 省略构造方法、getter和setter等
}
在这个例子中，@Table注解指定了数据库表的表名为"app_user"，而不是默认的类名"User"。
总之，@Table注解是JPA中用于指定实体类与数据库表映射关系的注解，用来配置数据库表的各种信息。
@Column注解
@Column： 指定数据库列的映射。
@Column注解是Java持久化API（JPA）中的一个注解，用于指定实体类属性与数据库表中列的映射关系。当实体类的属性名与数据库表中的列名不一致，或者需要指定特定的列信息时，可以使用@Column注解进行配置。
@Column注解提供了一系列属性用于配置列的各种信息，常见的属性包括：
1. name：指定数据库表中列的列名。 2. nullable：指定列是否允许为null，默认为true。 3. unique：指定列是否唯一，默认为false。 4. length：指定列的长度，适用于字符型列。 5. precision：指定列的精度，适用于数值型列。 6. scale：指定列的小数点后的位数，适用于数值型列。 7. columnDefinition：指定列的特定数据库类型，通常用于DDL语句生成。
举个例子，假设我们有一个简单的User实体类，但是希望username属性对应的数据库列名为"user_name"，并且email属性不允许为null：
@Entity
public class User {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
@Column(name = "user_name")
private String username;
@Column(nullable = false)
private String email;
// 省略构造方法、getter和setter等
}
在这个例子中，@Column注解分别指定了username属性对应数据库表中的列名为"user_name"，以及email属性不允许为null。
总之，@Column注解是JPA中用于指定实体类属性与数据库表列映射关系的注解，用来配置列的各种信息。
JPA(Java Persistence API) @Transient 注解
@Transient： 排除某个字段被持久保存在数据库中。
JPA(Java Persistence API) @OneToOne 注解
@OneToOne： 定义两个实体之间的一对一关系。
JPA(Java Persistence API) @OneToMany 注解
@OneToMany： 定义两个实体之间的一对多关系。
JPA(Java Persistence API) @ManyToOne 注解
@ManyToOne： 定义两个实体之间的多对一关系。
JPA(Java Persistence API) @ManyToMany 注解
@ManyToMany： 定义两个实体之间的多对多关系。
JPA (Java Persistence API) @JoinTable 注解
@JoinTable： JPA中的@JoinTable注解用于自定义关联表，该关联表保存多对多关系中两个实体之间的关系。
Hibernate @PrimaryKeyJoinColumn 注解
JPA（Java Persistence API）和 Hibernate 中的@PrimaryKeyJoinColumn注解用于继承关系和表映射的上下文中，特别是在连接策略中 。
Hibernate @Embeddable 和 @Embedded 注解
@Embeddable：该注解用于将一个类声明为Embeddable类。@Embedded：该注解用在实体类中，指定将要嵌入的字段。
Hibernate中的`@Embeddable`和`@Embedded`注解用于处理实体类中嵌入（Embeddable）其他实体类或值对象（Value Object）的情况。
- `@Embeddable`注解标注在一个类上，表示这个类是一个可嵌入的类，即它的实例可以作为另一个实体类的属性被嵌入到数据库表中，而不需要为它创建一个单独的数据库表。通常，`@Embeddable`注解与`@Embedded`注解配合使用。
- `@Embedded`注解标注在实体类的属性上，用于指定一个嵌入的实体类或值对象。这个嵌入的实体类或值对象会被作为当前实体类的属性，其属性会被映射到数据库表中。
举个例子，假设我们有一个Address类作为User的嵌入对象：
@Embeddable
public class Address {
private String street;
private String city;
private String zipCode;
// 省略构造方法、getter和setter等
}
@Entity
public class User {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
private String username;
@Embedded
private Address address;
// 省略构造方法、getter和setter等
}
在这个例子中，Address类被标注为`@Embeddable`，表示它可以被嵌入到其他实体类中。User实体类中的address属性被标注为`@Embedded`，表示它是一个嵌入的实体类，其属性会与User实体类一起映射到数据库表中。
总之，`@Embeddable`和`@Embedded`注解是Hibernate中用于处理实体类中嵌入其他实体类或值对象的情况的注解。
七、Servlet注解：
@WebServlet注解
@WebServlet 注解用于定义 Web 应用程序中的 Servlet 组件。
@WebServlet注解是Java Servlet规范中的一个注解，用于定义一个Servlet组件，它可以处理HTTP请求并生成HTTP响应。
通常情况下，使用`@WebServlet`注解可以替代在web.xml文件中配置Servlet的方式，使得Servlet的配置更加简洁和灵活。
`@WebServlet`注解提供了一系列属性来配置Servlet的各种信息，常见的属性包括：
1. `name`：Servlet的名称。 2. `value`或`urlPatterns`：Servlet的URL模式，用于指定哪些URL请求会被该Servlet处理。 3. `description`：Servlet的描述信息。 4. `initParams`：Servlet的初始化参数。 5. `asyncSupported`：是否支持异步Servlet。 6. `loadOnStartup`：Servlet的启动顺序。 7. `displayName`：Servlet的显示名称。
举个例子，假设我们有一个简单的Servlet来处理用户登录：
@WebServlet(name = "LoginServlet", urlPatterns = "/login")
public class LoginServlet extends HttpServlet {
protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
// 处理登录逻辑
}
protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
// 处理GET请求
}
}
在这个例子中，`@WebServlet`注解指定了Servlet的名称为"LoginServlet"，并且定义了它处理的URL模式为"/login"，即所有以"/login"开头的HTTP请求都会由这个Servlet来处理。
总之，`@WebServlet`注解是用于定义Servlet组件的注解，它可以简化Servlet的配置，并提供了丰富的属性来配置Servlet的各种信息。
@WebInitParam注解
@WebInitParam 注解用于指定必须传递给 Servlet 或 Filter 的任何初始化参数。
@WebInitParam注解是用于在`@WebServlet`注解中指定Servlet的初始化参数的注解。通过@WebInitParam注解，可以在Servlet的注解配置中指定一些初始化参数，这些参数将在Servlet初始化时被传递给Servlet。
常见的使用场景是，当Servlet需要一些配置参数时，可以通过`@WebInitParam`注解来指定这些参数，使得Servlet在初始化时可以根据这些参数进行相应的初始化操作。
`@WebInitParam`注解提供了两个属性：
1. `name`：参数的名称。 2. `value`：参数的值。
举个例子，假设我们的登录Servlet需要一个配置参数来指定登录页面的标题，我们可以这样配置：
@WebServlet(
name = "LoginServlet",
urlPatterns = "/login",
initParams = {
@WebInitParam(name = "pageTitle", value = "Login Page")
}
)
public class LoginServlet extends HttpServlet {
// Servlet的逻辑代码
}
在这个例子中，`@WebInitParam`注解指定了一个初始化参数，名称为"pageTitle"，值为"Login Page"，这个参数将在Servlet初始化时被传递给Servlet。
总之，`@WebInitParam`注解是用于在`@WebServlet`注解中指定Servlet的初始化参数的注解，可以用于指定Servlet在初始化时所需的一些配置参数。
@WebListener 注解
@WebListener 注解用于注解侦听器以获取特定 Web 应用程序上下文上的各种操作的事件。
`@WebListener`注解是Servlet 3.0规范中的一个注解，用于标识一个类为Web应用程序的监听器（Listener）。监听器用于监听Web应用程序中的事件，并在事件发生时执行相应的逻辑。
常见的Web应用程序事件包括ServletContext的初始化和销毁、Session的创建和销毁、ServletRequest的创建和销毁等。
通过`@WebListener`注解标注的类可以实现ServletContextListener、HttpSessionListener、ServletRequestListener等接口，从而监听相应的事件并进行处理。
举个例子，假设我们需要监听ServletContext的初始化和销毁事件，可以创建一个ServletContextListener的实现类，并使用`@WebListener`注解进行标注：
@WebListener
public class MyServletContextListener implements ServletContextListener {
public void contextInitialized(ServletContextEvent sce) {
// ServletContext初始化时执行的逻辑
}
public void contextDestroyed(ServletContextEvent sce) {
// ServletContext销毁时执行的逻辑
}
}
在这个例子中，`MyServletContextListener`类实现了ServletContextListener接口，并通过`@WebListener`注解标注，表示它是一个ServletContext的监听器。
总之，`@WebListener`注解用于标识一个类为Web应用程序的监听器，可以监听并处理Web应用程序中的各种事件。
@WebFilter注解
@WebFilter 注解用于在 Web 应用程序中定义过滤器。
`@WebFilter`注解是Java Servlet规范中的一个注解，用于定义一个过滤器（Filter）组件，它可以拦截HTTP请求和响应，并对它们进行处理或修改。
过滤器通常用于在请求到达Servlet之前或响应返回给客户端之前对请求或响应进行预处理或后处理操作，例如身份验证、日志记录、字符编码转换等。
使用`@WebFilter`注解可以替代在web.xml文件中配置过滤器的方式，使得过滤器的配置更加简洁和灵活。
`@WebFilter`注解提供了一系列属性来配置过滤器的各种信息，常见的属性包括：
1. `filterName`：过滤器的名称。 2. `urlPatterns`：过滤器拦截的URL模式，用于指定哪些URL请求会被该过滤器拦截。 3. `servletNames`：过滤器拦截的Servlet名称，用于指定哪些Servlet的请求会被该过滤器拦截。 4. `dispatcherTypes`：过滤器拦截的请求分发类型，包括REQUEST、FORWARD、INCLUDE、ERROR等。 5. `initParams`：过滤器的初始化参数。 6. `asyncSupported`：是否支持异步操作。
举个例子，假设我们有一个过滤器用于记录所有请求的访问日志：
@WebFilter(filterName = "LoggingFilter", urlPatterns = "/*")
public class LoggingFilter implements Filter {
public void init(FilterConfig filterConfig) throws ServletException {
// 过滤器初始化操作
}
public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
// 记录日志
System.out.println("Logging request: " + ((HttpServletRequest) request).getRequestURI());
// 继续执行过滤器链
chain.doFilter(request, response);
}
public void destroy() {
// 过滤器销毁操作
}
}
在这个例子中，`@WebFilter`注解指定了过滤器的名称为"LoggingFilter"，并且定义了它拦截的URL模式为"/*"，即所有的HTTP请求都会被该过滤器拦截并记录日志。
总之，`@WebFilter`注解是用于定义过滤器组件的注解，它可以简化过滤器的配置，并提供了丰富的属性来配置过滤器的各种信息。
@MultipartConfig注解
当在 Servlet 上指定时，@MultipartConfig 注解表明它期望的请求是 multipart/form-data 类型。
`@MultipartConfig`注解是Java Servlet规范中的一个注解，用于配置Servlet对multipart/form-data类型的HTTP请求进行处理，通常用于处理文件上传。
当Servlet需要接收通过HTML表单提交的文件时，可以使用`@MultipartConfig`注解来配置Servlet以支持文件上传功能。该注解可以放置在Servlet类或Servlet方法上。
`@MultipartConfig`注解提供了一系列属性来配置文件上传的相关参数，常见的属性包括：
1. `location`：指定上传文件的存储路径，可以是一个相对路径或绝对路径。 2. `maxFileSize`：指定上传文件的最大大小，超过该大小的文件将被拒绝上传。 3. `maxRequestSize`：指定HTTP请求的最大大小，包括所有上传文件和其他数据，超过该大小的请求将被拒绝。 4. `fileSizeThreshold`：指定上传文件在内存中的临界值，超过该大小的文件将被写入到磁盘而不是内存中。 5. `fileSizeThreshold`：指定上传文件在内存中的临界值，超过该大小的文件将被写入到磁盘而不是内存中。 6. `maxRequestSize`：指定HTTP请求的最大大小，包括所有上传文件和其他数据，超过该大小的请求将被拒绝。 7. `fileSizeThreshold`：指定上传文件在内存中的临界值，超过该大小的文件将被写入到磁盘而不是内存中。
举个例子，假设我们有一个Servlet用于处理文件上传，我们可以使用`@MultipartConfig`注解来配置该Servlet以支持文件上传：
@WebServlet("/upload")
@MultipartConfig(
fileSizeThreshold = 1024 * 1024, // 1MB
maxFileSize = 1024 * 1024 * 10, // 10MB
maxRequestSize = 1024 * 1024 * 50 // 50MB
)
public class FileUploadServlet extends HttpServlet {
protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
// 获取上传文件
Part filePart = request.getPart("file");
// 保存上传文件到服务器
String fileName = filePart.getSubmittedFileName();
filePart.write("uploads/" + fileName);
// 返回上传成功的响应
response.getWriter().println("File uploaded successfully: " + fileName);
}
}
在这个例子中，`@MultipartConfig`注解配置了文件上传的相关参数，包括文件大小阈值、最大文件大小和最大请求大小。这些参数将被Servlet容器用来限制文件上传的大小并确保系统安全。
总之，`@MultipartConfig`注解用于配置Servlet以支持文件上传功能，并提供了一系列属性来配置文件上传的相关参数。
八、Java注解：
@Deprecated注解
程序员不鼓励使用带有 @Deprecated 注解的程序元素，通常是因为它很危险，或者因为存在更好的替代方案。
`@Deprecated`注解是Java中的一个元注解，用于标记某个程序元素（如类、方法、字段等）已经被废弃，不推荐继续使用。当使用被`@Deprecated`注解标记的程序元素时，编译器会发出警告，提醒开发者该元素已经不建议使用，并且可能会在未来的版本中被移除。
使用`@Deprecated`注解的主要目的是为了向开发者传达一条信息：该程序元素在当前版本中仍然可用，但在未来的版本中可能会被移除或替换，因此开发者应该尽量避免使用这些被标记为废弃的元素，而是转而使用新的替代方法或程序元素。
通常情况下，当一个类、方法或字段被`@Deprecated`注解标记时，开发者应该查看相关文档，了解废弃元素的替代方案，并尽快将代码迁移到新的替代方案上，以确保代码的可维护性和兼容性。
举个例子，假设我们有一个Java类中的某个方法已经不推荐使用，可以使用`@Deprecated`注解标记该方法：
public class DeprecatedExample {
/**
* @deprecated 此方法已弃用, 请使用 {@link #newMethod()} 替代.
*/
@Deprecated
public void oldMethod() {
// 不推荐的方法实现
}
public void newMethod() {
// 新方法实现
}
}
在这个例子中，`oldMethod()`方法被`@Deprecated`注解标记，开发者在使用该方法时会收到编译器发出的警告，提示他们应该使用`newMethod()`方法来替代。
总之，`@Deprecated`注解用于标记程序元素已经被废弃，不推荐继续使用，开发者在使用被标记为废弃的元素时应该尽快迁移到新的替代方案上。
@Override注解
指示方法声明旨在覆盖超类型中的方法声明。
`@Override`注解是Java中的一个注解，用于标识方法重写（override）父类或接口中的方法。当一个方法被`@Override`注解标记时，编译器会检查该方法是否确实重写了父类或接口中的方法，如果没有正确重写，则会产生编译错误。
使用`@Override`注解的主要目的是提高代码的可读性和可维护性，同时帮助开发者避免一些常见的错误，例如拼写错误或意外地创建了一个新方法而不是重写父类方法。
通常情况下，当我们重写父类或接口中的方法时，应该添加`@Override`注解，这样可以让代码更加清晰地表明我们是有意地重写了某个方法，而不是意外地创建了一个同名方法。
举个例子，假设我们有一个父类`Animal`，其中定义了一个`makeSound()`方法，我们希望在子类`Dog`中重写这个方法，可以使用`@Override`注解标记重写的方法：
class Animal {
public void makeSound() {
System.out.println("Animal makes a sound");
}
}
class Dog extends Animal {
@Override
public void makeSound() {
System.out.println("Dog barks");
}
}
在这个例子中，`Dog`类重写了`Animal`类中的`makeSound()`方法，并使用了`@Override`注解来标识这一重写操作。如果我们的`makeSound()`方法拼写错误或者没有正确地重写父类方法，编译器会在编译时报错，提醒我们修正错误。
总之，`@Override`注解用于标识方法重写，帮助开发者避免一些常见的错误，并提高代码的可读性和可维护性。
@FunctionalInterface注解
一种信息注解类型，用于指示接口类型声明旨在成为 Java 语言规范定义的函数接口。表明一个接口是一个函数式接口并且只包含一个抽象方法。
`@FunctionalInterface`注解是Java中的一个注解，用于标识接口是一个函数式接口。函数式接口是指只包含一个抽象方法的接口，它可以被Lambda表达式所实现。
在Java 8及以后的版本中，引入了Lambda表达式和函数式接口的概念，使得编写函数式风格的代码更加方便和简洁。通过`@FunctionalInterface`注解，可以明确地表明一个接口是函数式接口，从而提供了编译时的检查和更清晰的语义。
当一个接口被`@FunctionalInterface`注解标记时，编译器会检查该接口是否满足函数式接口的要求，即是否只包含一个抽象方法。如果接口包含多个抽象方法或者没有抽象方法，则编译器会产生编译错误。
举个例子，假设我们定义了一个函数式接口`Calculator`，其中只包含一个抽象方法`calculate()`，我们可以使用`@FunctionalInterface`注解标记该接口：
@FunctionalInterface
interface Calculator {
int calculate(int x, int y);
}
在这个例子中，`Calculator`接口被`@FunctionalInterface`注解标记，因为它只包含一个抽象方法`calculate()`。如果我们尝试添加另一个抽象方法到该接口，编译器会产生错误，因为函数式接口只能包含一个抽象方法。
总之，`@FunctionalInterface`注解用于标识函数式接口，它帮助开发者明确地表明接口的设计意图，并提供编译时的检查，确保接口符合函数式接口的要求。
@SafeVarargs注解
程序员断言带注解的方法或构造函数的主体不会对其varargs参数执行潜在的不安全操作。
`@SafeVarargs`注解是Java中的一个注解，用于标识一个方法是安全的可变参数方法。可变参数方法是指那些可以接受数量可变的参数的方法，例如使用了`...`语法的方法参数。在Java 5及以后的版本中引入了可变参数的特性。
当一个方法使用了可变参数，并且被`@SafeVarargs`注解标记时，编译器会对该方法的调用进行一些类型安全的检查，以确保不会发生类型不安全的操作。这个注解主要用于防止在使用泛型可变参数方法时产生的类型不安全警告。
使用`@SafeVarargs`注解的方法应该满足以下条件： 1. 方法必须是可变参数方法，即使用了`...`语法的方法参数。 2. 方法必须是`static`或`final`修饰的（或者是构造方法），并且不会被重写或继承。 3. 方法的实现中不应该对可变参数进行任何不安全的操作，例如将可变参数转换为数组后进行修改。
举个例子，假设我们有一个使用可变参数的方法`printValues`，我们可以使用`@SafeVarargs`注解来标记该方法，以确保在使用泛型时不会产生类型不安全的警告：
class VarargsExample {
@SafeVarargs
static
for (T value : values) {
System.out.println(value);
}
}
public static void main(String[] args) {
printValues(1, 2, 3); // 调用printValues方法
}
}
在这个例子中，`printValues`方法被`@SafeVarargs`注解标记，因此在调用该方法时不会出现类型不安全的警告。
总之，`@SafeVarargs`注解用于标识安全的可变参数方法，以确保在使用泛型可变参数时不会产生类型不安全的警告。
@SuppressWarnings注解
指示应在带注解的元素（以及带注解的元素中包含的所有程序元素）中抑制指定的编译器警告。
`@SuppressWarnings`注解是Java中用于指示编译器忽略特定警告的注解。这个注解帮助开发者控制编译时输出的警告信息，使得他们可以专注于更重要的问题。通常情况下，开发者应当尽可能解决所有编译器警告，但在某些情况下，一些警告可能是不可避免或无法修复的，这时候使用`@SuppressWarnings`注解可以有效地抑制这些不需要的警告。
### 使用方式
`@SuppressWarnings`注解可以应用于类、方法或变量，以抑制特定类型的警告。它接受一个字符串数组作为参数，每个字符串指定一种要抑制的警告类型。常见的警告类型包括：
- `"unchecked"`：用于抑制未经检查的操作警告，通常与泛型相关。 - `"deprecation"`：用于抑制使用已被弃用的类或方法时的警告。 - `"rawtypes"`：用于抑制使用原始类型的警告。 - `"serial"`：用于抑制可序列化的类缺少`serialVersionUID`字段的警告。 - `"fallthrough"`：用于抑制在`switch`语句中可能意外跳过`case`的警告。 - `"unused"`：用于抑制声明但未使用的代码的警告。
下面是一个使用`@SuppressWarnings`注解的示例，该示例抑制了一些常见的警告：
@SuppressWarnings({"unchecked", "deprecation"})
public class WarningSuppressor {
@Deprecated
public void useDeprecatedMethod() {
System.out.println("This method is deprecated.");
}
public void genericMethod() {
List rawList = new ArrayList(); // 使用了原始类型
List
}
}
public class Main {
public static void main(String[] args) {
WarningSuppressor suppressor = new WarningSuppressor();
suppressor.useDeprecatedMethod();
suppressor.genericMethod();
}
}
在这个例子中，`@SuppressWarnings({"unchecked", "deprecation"})`注解被应用于`WarningSuppressor`类。这意味着所有在此类中可能产生的关于未检查操作和使用已废弃方法的警告都将被抑制。
虽然`@SuppressWarnings`注解是一个有用的工具，但它应该谨慎使用，因为过度使用可能会隐藏真正的问题。最佳实践是尽量解决警告，只有在确实无法解决或解决警告会导致更多问题时才考虑使用此注解。此外，作用范围应尽可能地小，例如应用于具体的方法或变量，而不是整个类。
-------本文就到此为止吧，实在是写不动了，希望能够帮助到您！--------
本文作者:@小二来碗醋
版权声明:本博客所有文章除特别声明外，均采用 BY-NC-SA 许可协议。转载请注明出处！
相关链接
您阅读本篇文章共花了：
发表评论