java常用注解

最新推荐文章于 2024-07-28 19:41:52 发布

敲厉害的燕宝

最新推荐文章于 2024-07-28 19:41:52 发布

阅读量1.1k

点赞数 12

分类专栏： java 文章标签： java spring java-ee spring boot 注解

本文链接：https://blog.csdn.net/m0_63456808/article/details/139702961

版权

java 专栏收录该内容

11 篇文章 0 订阅

订阅专栏

java常用注解

@Component-Spring 框架中的一个Bean组件

import org.springframework.stereotype.Component;
@Component
public class ExampleComponent {

    // 这里可以添加你的类实现代码

    // 例如一个简单的示例方法
    public String displayMessage() {
        return "这是一个@Component标注的Spring组件";
    }
}

在上述代码中：

@Component 注解标志着该类作为Spring框架中的一个Bean组件，Spring会自动扫描并管理这个类的实例。

import org.springframework.stereotype.Component; 引入了@Component注解的定义。

类名为 ExampleComponent，你可以根据实际功能需求命名。

示例方法 displayMessage() 返回一条字符串消息，展示了这个组件的基本用法。

此代码片段是一个基本的Spring组件定义，你可以在此基础上添加更多的业务逻辑方法。

@PostConstruct-执行一些初始化的操作

import javax.annotation.PostConstruct;

@Component
public class InitializationExample {

    @PostConstruct
    public void init() {
        // 这个方法会在所有依赖注入完成后，但在该bean被任何其他bean使用之前调用
        System.out.println("初始化方法执行");
        // 在这里执行一些初始化操作，比如数据源的建立、初始化配置等
    }

    // 其他方法和逻辑...
}

在上述代码中：

@PostConstruct 是一个用于标记在服务器加载Servlet的时候需要执行的方法的注解，通常用于执行一些初始化的操作。

方法 init() 被 @PostConstruct 注解，这意味着当Spring容器初始化这个Bean时，会自动调用这个方法。

该方法会在Bean的构造函数执行之后，依赖注入完成之前调用，适用于资源初始化、打开数据库连接、读取配置文件等场景。

@Configuration@Bean-配置类

import org.springframework.context.annotation.Configuration;
@Configuration
public class AppConfig {
    // 使用@Bean注解定义Spring Bean
    @Bean
    public MyService myService() {
        return new MyServiceImpl();
    }
    // 可以定义多个@Bean方法来配置多个Bean
    @Bean
    public AnotherService anotherService() {
        return new AnotherServiceImpl();
    }
    // 这里可以添加更多的配置类或Bean定义
}

在上述代码中：

@Configuration 注解表明该类是一个配置类，相当于XML配置文件，在Spring框架中用来提供Bean的定义和更多的配置信息。

@Bean 注解在方法上，表示该方法将返回一个对象，该对象将作为Bean注册到Spring应用程序上下文中。

myService() 和 anotherService() 方法分别定义了两个Bean，它们将在应用上下文中可用，可以通过依赖注入的方式被其他Bean使用。

配置类可以包含多个 @Bean 方法，每个方法定义了一个Bean的创建过程。

通过这样的配置类，你可以以Java代码的形式组织和管理Spring的配置，替代传统的XML配置，使得项目更加面向Java，并且支持IDE的代码补全和类型检查等功能。

@Controller（不常用，大多使用RestController）

@Controller 是Spring框架中的一个注解，主要用于标记一个Java类作为Spring MVC框架中的控制器（Controller）。控制器是MVC（模型-视图-控制器）架构模式的关键组成部分，负责处理进入的HTTP请求，执行业务逻辑，并最终决定响应给客户端的内容。

使用 @Controller 注解的类通常具有以下特点：

请求处理: 类中定义的方法被称为处理器方法（Handler Methods），这些方法会根据请求URL、HTTP方法等条件被Spring MVC的前端控制器（DispatcherServlet）调用。

视图解析: 默认情况下，@Controller 注解的类倾向于与视图技术（如JSP、Thymeleaf等）结合使用，用于渲染动态HTML页面给用户。处理器方法可以通过返回视图名称（String类型）来指定要呈现的视图。

模型数据: 处理器方法可以向模型（Model）中添加数据，这些数据随后可用于视图中展示。通常使用 Model 或 ModelAndView 对象来封装这些数据。

灵活性: 虽然主要与视图交互，但通过结合 @ResponseBody 注解，@Controller 也能返回JSON、XML等数据格式，适用于需要直接发送数据响应的场景。

示例代码：

import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;

@Controller
public class GreetingController {

    @GetMapping("/greeting")
    public String greeting(@RequestParam(name="name", required=false, defaultValue="World") String name, Model model) {
        model.addAttribute("name", name);
        return "greeting"; // 假设有一个名为greeting的视图（如JSP）
    }
}

在这个例子中，GreetingController 类被标记为控制器，其中的 greeting 方法处理 /greeting 的GET请求，并将接收到的参数添加到模型中，最后返回视图名称 "greeting" 供前端展示。

@RestController（常用）

@RestController 是 @Controller 和 @ResponseBody 的组合，专为创建RESTful Web服务而设计。它简化了API开发，因为每个方法默认都返回JSON或XML等数据格式，无需在每个方法上单独添加 @ResponseBody。

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class GreetingController {

    @GetMapping("/greet")
    public String greet() {
        return "Hello, Welcome to the RESTful world!";
    }
}

在上述代码示例中，@RestController 注解用于类级别，标志着 GreetingController 是一个REST风格的控制器，其中的所有请求处理方法都会直接返回响应体内容，而非视图名称。这意味着它默认对每个方法都加上了 @ResponseBody 的效果，使得返回的对象会自动转换为JSON、XML等格式并通过HTTP响应发送给客户端。

@GetMapping("/greet") 注解则指定了一个GET请求的处理方法，当访问 /greet 路径时，该方法会被调用，直接返回字符串消息 "Hello, Welcome to the RESTful world!" 作为HTTP响应的正文。这种设计非常适合构建API，特别是那些返回结构化数据给前端JavaScript应用、移动应用或其他客户端消费的场景。

@ResponseBody-返回JSON、XML等数据格式给前端

@ResponseBody 是Spring框架中的一个注解，用于指示一个控制器方法的返回值应该被直接写入HTTP响应体中，而不是像常规Spring MVC流程那样通过视图解析器来处理并渲染视图。这个注解常用于返回JSON、XML等数据格式给前端，非常适合构建API或者处理Ajax请求的场景。

基本用途:

当一个方法被 @ResponseBody 注解时，Spring会自动将该方法的返回对象转换成适合Web响应的格式（通常是JSON或XML，取决于配置和Accept头信息），然后发送给客户端。

它使得控制器方法能够直接参与HTTP响应内容的构建，绕过了视图技术（如JSP、Thymeleaf）的使用。

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.stereotype.Controller;

@Controller
public class GreetingController {

    @GetMapping("/welcome")
    @ResponseBody
    public String sayWelcome() {
        return "{'message': 'Welcome to our application!'}";
    }
}

在上面的示例中，sayWelcome 方法被 @ResponseBody 注解，这意味着当请求到达 /welcome 路径时，Spring会直接将返回的字符串（一个JSON格式的消息）写入HTTP响应体中，而不是去查找一个视图来渲染。

注意:

自 @RestController 注解引入后，对于专注于返回数据而非视图的控制器，通常推荐使用 @RestController 而不是单独使用 @Controller 加 @ResponseBody。@RestController 相当于为所有响应方法默认加上了 @ResponseBody 效果。

@RequestMapping-映射HTTP请求到处理方法上

@RequestMapping 是Spring框架中的一个注解，用于映射HTTP请求到处理方法上。它可以被应用于类或方法级别，以提供路由信息和处理请求的细节。下面通过一些示例来说明其用法：

类级别使用：

在类级别上使用 @RequestMapping 可以为该类中的所有处理器方法提供一个公共的路径前缀。

import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RequestMapping("/api/v1/users")
@RestController
public class UserController {

    // 类中所有方法的路径都将以此处定义的"/api/v1/users"作为前缀
}

方法级别使用：

在方法级别上，@RequestMapping 用于指定具体的HTTP请求方法（如GET、POST等）和路径，以精确映射到处理方法。

import org.springframework.web.bind.annotation.*;

@RestController
@RequestMapping("/api/v1/users")
public class UserController {

    @GetMapping("/{id}")
    public String getUserById(@PathVariable("id") Long id) {
        return "Getting user with id: " + id;
    }

    @PostMapping("/")
    public String createUser(@RequestBody User user) {
        // 创建用户逻辑
        return "User created successfully";
    }

    // 更多方法...
}

属性说明：

value 或者 path: 指定请求的实际路径。

method: 限定请求的HTTP方法（GET、POST等）。

params、headers: 基于请求参数或头部信息进一步过滤请求。

consumes、produces: 指定请求的消费内容类型（Content-Type）和响应的内容类型

@GetMapping(value = "/search", params = "q")
public List<User> searchUsers(@RequestParam("q") String query) {
    // 根据查询参数搜索用户
}

在这个例子中，@GetMapping 是 @RequestMapping(method = RequestMethod.GET) 的简写形式，它指定了一个GET请求，且请求中必须包含名为 "q" 的查询参数。这展示了 @RequestMapping 及其变体如何灵活地定义请求处理逻辑。

@GetMapping

组合其他注解: 可以与其他注解如 @PathVariable, @RequestParam, @ResponseBody 等一起使用，以提供更复杂的功能,下同 ~

@PostMapping

@PutMapping

@DeleteMapping

@PatchMapping（没见过）

@ResponseBody-将java对象转为json格式

@ResponseBody+@Controller=@RestController

几乎不用@ResponseBody,使用@RestController

@RequestBody-接收前端传给后台的json字符串

@RequestBody 是Spring框架中的一个注解，通常用于处理HTTP请求的请求体（Body）部分。当你希望直接从请求的输入流中读取数据并将其绑定到方法的参数上时，@RequestBody 就显得尤为重要。这个注解主要用于接收和处理非URL编码的数据，比如JSON、XML等格式的数据。

基本用途：

数据绑定：它将HTTP请求的主体内容与控制器方法的参数直接关联，允许你直接操作请求中的数据。这对于接收和处理POST、PUT等HTTP方法发送的复杂数据非常有用。

特点：

数据绑定: 自动将请求体内容转换为Java对象，支持JSON、XML等多种格式

内容类型: 需要与请求的Content-Type头匹配，例如application/json

对象映射: 利用Jackson、Gson等库将JSON等格式转换为Java对象

与其他注解结合: 常与 @PostMapping, @PutMapping 等结合使用

示例：

考虑一个创建新用户的API接口，客户端通过发送包含用户信息的JSON对象到服务器：

import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;
import com.example.model.User; // 假设的User类

@RestController
public class UserController {

    @PostMapping("/users")
    public ResponseEntity<String> createUser(@RequestBody User user) {
        // user对象现在包含了请求体中的JSON数据
        // 你可以进行如保存到数据库等操作
        return ResponseEntity.ok("User created successfully");
    }
}

在这个例子中，当客户端发送一个POST请求到 /users 路径，请求体携带了一个JSON对象表示用户信息，@RequestBody 注解会自动将这个JSON转换成 User 类的一个实例。

@RequestParam-将HTTP请求中的查询参数绑定到控制器方法的参数上

@RequestParam 是Spring框架中的一个注解，用于将HTTP请求中的查询参数绑定到控制器方法的参数上。它让你能够方便地从URL的查询字符串中获取参数值，并直接在方法签名中使用这些值。下面是一些基本用法和示例：

基本用途:

获取查询参数：从HTTP请求的URL查询字符串中提取参数值。

非必填与默认值：支持设置参数为非必需，并可以指定默认值。

数据类型转换：自动将请求中的字符串参数转换为指定的方法参数类型。

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class UserController {

    @GetMapping("/users")
    public String getUserInfo(@RequestParam("username") String username) {
        // 使用username查询用户信息
        return "User info for: " + username;
    }
    //数组和列表：可以用来收集同名的多个参数值，形成数组或集合
      @GetMapping("/filter")
  public String filterItems(@RequestParam List<String> categories) {
      // categories将包含所有categories参数的值
  }
    //是否必需：通过 required 属性指定参数是否必须存在，默认为 true。
      @GetMapping("/search")
  public String search(@RequestParam(required = false) String keyword) {
      // 如果没有提供keyword，也可以处理
  }
    //默认值：如果请求中没有提供参数，可以设置默认值。
      @GetMapping("/welcome")
  public String welcomeMessage(@RequestParam(value = "name", defaultValue = "Guest") String name) {
      return "Welcome, " + name + "!";
  }
  
}

@PathVariable-路径变量

@PathVariable 是Spring框架中的一个注解，用于从URL路径中提取变量值，并将这些值绑定到控制器方法的参数上。这对于构建RESTful风格的Web服务尤其有用，其中资源的标识经常作为URL的一部分出现。

基本用途：

提取URL路径段：从请求URL的路径段中提取动态值。

绑定到方法参数：将提取的值自动绑定到控制器方法的相应参数上。

定义RESTful URL：支持创建更加语义化的、面向资源的URL模式。

其他特性：

路径变量命名：路径中的变量名需要与@PathVariable注解中的名称一致。

路径模式：可以在定义路由时使用通配符和正则表达式来匹配复杂的URL模式。

类型转换：Spring尝试将路径变量转换为指定的方法参数类型，转换失败将异常

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class BlogController {

    @GetMapping("/articles/{articleId}")
    public String getArticleDetails(@PathVariable Long articleId) {
        // 使用articleId查询并返回文章详情
        return "Details of Article with ID: " + articleId;
    }

    //多个路径变量
    @GetMapping("/users/{userId}/articles/{articleId}")
public String getUserArticle(@PathVariable Long userId, @PathVariable Long articleId) {
    // 获取指定用户下的某篇文章详情
}
}

总之，@PathVariable 注解使你能够轻松地从URL路径中捕获动态值，这对于构建灵活、可读性强的RESTful API至关重要。

@ResponseStatus-返回HTTP状态码

@ResponseStatus 是Spring框架中的一个注解，用于指示一个控制器方法应该返回的HTTP状态码。这在需要自定义响应状态，或者直接通过方法逻辑控制HTTP响应状态时非常有用。

基本用途：

自定义状态码：允许你为特定的控制器方法指定HTTP响应状态码。

简化响应构建：配合其他逻辑，可以简化返回特定状态码及响应体的流程。

import org.springframework.http.HttpStatus;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseStatus;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/users")
public class UserController {

    @PostMapping
    @ResponseStatus(HttpStatus.CREATED)
    public User registerUser(@RequestBody UserRegistrationRequest request) {
        // 注册逻辑...
        return newUser; // 假设成功创建用户后返回User对象
    }

    @PostMapping("/check-username")
    @ResponseStatus(HttpStatus.CONFLICT)
    public void checkUsernameAvailability(@RequestBody String username) {
        // 检查用户名是否已存在，如果存在，则此方法会被调用
        // 无需返回体，仅通过状态码表明冲突
    }
}

如果注册成功，你可能希望返回一个 201 Created 状态码；如果注册的用户名已存在，则返回 409 Conflict 状态码。

@ControllerAdvice-全局异常处理器/全局模型属性添加器

@ControllerAdvice 是Spring框架提供的一个注解，用于定义全局的异常处理器或者全局的模型属性添加器。这个注解能够影响应用中所有的 @RequestMapping 方法，使得你能够在一个地方集中处理整个应用程序中控制器层可能抛出的异常，或者向所有控制器添加共有的数据。

主要用途：

全局异常处理：通过定义一个或多个带有 @ExceptionHandler 注解的方法来集中处理特定类型的异常，这些异常可能由任何控制器方法抛出。

全局数据绑定：使用 @ModelAttribute 注解的方法可以在每个控制器方法调用前执行，用于向所有视图模型中添加共享数据。

全局模型属性添加：类似地，可以添加全局的模型属性，这些属性对所有视图都可用。

请求响应处理：可以通过实现 HandlerInterceptor 接口或使用 @ModelAttribute、@InitBinder 等注解来影响请求处理的前后过程。

注意事项：

作用域：@ControllerAdvice 定义的类会影响所有带有 @RequestMapping 的控制器，除非使用 basePackages 或 basePackageClasses 属性限制其作用范围。

优先级：如果有多个 @ControllerAdvice 类同时定义了处理同一异常类型的处理器，那么最近（按照类路径顺序）定义的处理器将会优先执行。

灵活性：通过精确控制异常处理逻辑和模型属性的添加，可以提高代码的可维护性和一致性。

总之，@ControllerAdvice 是Spring MVC中一个强大的特性，它允许开发者以声明式的方式集中管理控制器层的异常处理和全局配置，从而提升应用的健壮性和开发效率。

import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.ModelAttribute;
import org.springframework.web.bind.annotation.InitBinder;
import org.springframework.web.bind.MethodArgumentNotValidException;

@ControllerAdvice
public class GlobalExceptionHandler {

    // 全局异常处理
    @ExceptionHandler(MethodArgumentNotValidException.class)
    public ResponseEntity<String> handleValidationException(MethodArgumentNotValidException ex) {
        // 处理参数验证失败的异常
        String errorMessage = "Validation failed: " + ex.getMessage();
        return ResponseEntity.badRequest().body(errorMessage);
    }

    // 添加全局模型属性
    @ModelAttribute("globalData")
    public String addGlobalData() {
        return "This is a global data added to every view.";
    }

    // 初始化数据绑定
    @InitBinder
    public void initBinder(WebDataBinder binder) {
        // 可以在这里注册自定义的编辑器或配置数据绑定规则
    }
}

@Data-简化JavaBean的编写

@Data 是Lombok库中的一个注解，它是一个便利的功能性注解，用于简化JavaBean的编写。

当你在类上使用 @Data 注解时，Lombok会自动为该类生成以下几种方法：

Getter and Setter：为所有非final字段生成getter和setter方法。

equals() and hashCode()：基于所有非transient和非static字段生成equals()和hashCode()方法，遵循equals和hashCode的通用约定。

toString()：生成一个包含所有字段信息的toString()方法。

RequiredArgsConstructor：生成一个包含所有标注为@NonNull的字段的构造器。如果没有@NonNull字段，则不生成构造器。

import lombok.Data;

@Data
public class User {
    private Long id;
    private String name;
    private String email;
    // 不会为final字段生成setter
    private final String role = "USER";
    // 只有这个字段会被包含在equals/hashCode中，因为其他字段是final或static
    private transient String temporaryData;
    private static int counter;
}

在这个例子中，Lombok会为 id, name, 和 email 字段自动生成getter和setter方法，同时也会生成 equals(), hashCode(), 和 toString() 方法。

注意:

(1) role 字段因为是final的，所以不会生成setter；

(2) temporaryData 字段因为被标记为 transient，所以在 equals() 和 hashCode() 中会被忽略；

(3) counter 字段因为是静态的，所以也不会参与到这些方法中。

使用时需要添加依赖：

<dependencies>
    <!-- Lombok Dependency -->
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <version>1.18.22</version> <!-- 请检查是否有更新的版本 -->
        <scope>provided</scope> <!-- 或者 compile，取决于你的使用场景 -->
    </dependency>
</dependencies>

@NoArgsConstructor-无参构造函数

@NoArgsConstructor 是Lombok库中的一个注解，用于自动为类生成一个无参的构造器。当你在类上使用这个注解时，即使类中有带有初始化值的字段，Lombok也会确保生成一个不带参数的公共构造方法。这对于需要无参构造器来进行反射操作（如Java序列化、框架中的某些自动实例化场景）非常有用。

import lombok.NoArgsConstructor;
@NoArgsConstructor
public class User {
    private String name;
    private int age;
    private String role = "USER"; // 即便有默认值，@NoArgsConstructor也会生成无参构造器
}

在这个例子中，即使 User 类中包含有默认值的字段 role，Lombok的 @NoArgsConstructor 依然会为 User 类生成一个无参数的构造方法。

注意事项：

与其它构造器注解共存：如果类中同时定义了有参构造器或者使用了 @AllArgsConstructor, @RequiredArgsConstructor 等其他构造器相关的Lombok注解，@NoArgsConstructor 仍会生成无参构造器，除非使用了 @NoArgsConstructor(access = AccessLevel.PRIVATE) 将其设置为私有，或因其他原因导致冲突（比如使用了 @Value 注解，它隐含了不可变性，通常不生成无参构造器）。

编译时处理：如同Lombok的所有特性一样，@NoArgsConstructor 在编译时生效，因此在IDE中可能需要安装Lombok插件才能正确识别和处理这些注解。

代码简洁性：此注解极大地简化了需要显式编写无参构造函数的场景，特别是在实体类较多的情况下，减少了大量的模板代码。

@AllArgsConstructor-全参构造器

@EqualsAndHashCode-自动生成equals()和hashCode()

@EqualsAndHashCode 是Lombok库中的一个注解，用于自动为类生成 equals() 和 hashCode() 方法的实现。这两个方法对于正确地比较对象的相等性和使用对象作为哈希表（如Java集合框架中的HashSet、HashMap等）的键非常重要。（不包括静态字段、瞬态字段以及父类的字段）

@Service -标记业务层处理数据的类

@Service 是Spring框架中的一个注解，主要用于标记业务层处理数据的类它是Spring组件模型(@Component)的一个特化注解，专门用于标识业务服务层的类。在Spring应用上下文中，被 @Service 注解的类会自动被Spring容器扫描并管理，成为Spring管理的bean，可以进行依赖注入(DI)和面向切面编程(AOP)等操作。

主要用途：

自动检测和装配：Spring会自动发现应用上下文中标记了 @Service 的类，并将其作为bean进行管理，无需手动配置bean定义。

业务逻辑处理：通常用于实现业务逻辑，处理数据的增删改查操作，以及业务规则的校验等。

依赖注入：被 @Service 标注的类可以方便地注入其他Spring管理的bean，如数据访问对象(DAO)、其他服务等。

事务管理：结合Spring的事务管理功能，可以在服务层方法上使用事务控制，确保数据的一致性和完整性。

@Slf4j-日志

@Slf4j 是Lombok库中的一个注解，用于自动为类添加一个静态的、最终的（final）日志对象。这个日志对象通常使用SLF4J（Simple Logging Facade for Java）接口，允许开发者在类中轻松地进行日志记录，而无需手动创建日志实例。

import lombok.extern.slf4j.Slf4j;

@Slf4j
public class UserService {

    public void addUser(User user) {
        log.info("Adding user: {}", user.getName());
        // ...业务逻辑...
    }
}

在这个例子中，通过在类级别上添加 @Slf4j 注解，Lombok会在编译时为 UserService 类自动生成一个名为 log 的日志对象。然后在类的方法内部，可以直接使用 log.info, log.error, log.debug 等方法进行日志输出，无需手动实例化Logger对象。

注意事项：

依赖管理：使用 @Slf4j 前，确保项目中已经引入了SLF4J的API以及一个具体的日志实现（如Logback、Log4j2等）作为依赖。否则，编译时或运行时可能会遇到类找不到的错误。

日志级别和配置：尽管Lombok帮助简化了日志记录的代码，日志的输出格式、级别等仍然需要通过SLF4J的实现框架的配置文件来设定。

IDE支持：由于Lombok是通过编译时注解处理器工作的，确保IDE安装了Lombok插件，这样IDE才能正确识别 log 变量并提供代码补全等功能。

@SpringBootApplication-启动初始设置

@SpringBootApplication是Spring Boot框架中的一个复合注解，它主要用来简化Spring应用的初始配置。这个注解实际上是一个组合了多个其他Spring注解的便捷注解，旨在快速搭建一个“约定优于配置”(convention over configuration)的Spring应用程序。

主要注解及其功能概述：

@SpringBootConfiguration: 这个注解表明该类使用Spring的Java配置方式进行配置，等同于使用 @Configuration 注解。这意味着该类可以包含用于定义bean的 @Bean 方法。

@EnableAutoConfiguration: 启动自动配置机制。Spring Boot会根据项目中添加的jar依赖自动配置Spring应用上下文。例如，如果项目中包含了Spring Data JPA和一个数据库驱动，Spring Boot会自动配置JPA的相关设置，包括数据库连接等。

@ComponentScan: 默认情况下，Spring Boot会自动扫描与主配置类（即带有 @SpringBootApplication 的类）位于同一包及其子包下的组件（如使用 @Component, @Service, @Repository, @Controller 等注解的类），并注册为Spring管理的bean。这意味着你无需手动配置包扫描路径。

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class MyApplication {

    public static void main(String[] args) {
        SpringApplication.run(MyApplication.class, args);
    }
}

@SpringBootConfiguration-加载Spring 配置

@EnableAutoConfiguration-启动自动配置

@ComponentScan-扫描组件

@Excel-Java的Excel处理框架

@Excel 注解主要用于Java的Excel处理框架中，如Apache POI、EasyExcel等，以简化Excel文件的读写操作。

通过在实体类的字段上使用此注解，可以方便地定义字段与Excel表格中列的映射关系，包括列名、排序、数据格式等。下面是一些常见的属性和用法示例：

常见属性:

name：指定Excel列的标题名称。例:@Excel(name = "姓名") 指定该字段对应Excel中的列名为“姓名”。

order：定义该字段在Excel中的排序顺序。例如，@Excel(order = 1) 表示该字段排在第1列。

width：设置列宽。例如，@Excel(width = "20") 设置列宽为20字符宽度。

exportConvert 和 importConvert：用于指定导出和导入时的转换器类，可以自定义数据转换逻辑。

type：指定数据类型，如日期、数字等，有助于正确读写数据。

dateFormat：仅对日期类型有效，指定日期格式，如 @Excel(dateFormat = "yyyy-MM-dd")。

import com.alibaba.excel.annotation.Excel; // 假设使用的是EasyExcel框架

public class User {

    @Excel(name = "用户ID", order = 1)
    private Long userId;
    
    @Excel(name = "用户名", order = 2)
    private String userName;
    
    @Excel(name = "出生日期", order = 3, dateFormat = "yyyy年MM月dd日")
    private LocalDate birthday;
    
    // 省略getter和setter
}

User 类的属性通过 @Excel 注解与Excel列进行了绑定，指定了列的标题名、排序和日期格式等信息。

注意事项:

确保使用的Excel处理框架支持 @Excel 注解，并正确引入相关依赖。

在实际应用中，根据所选框架的文档调整注解的使用细节，因为不同的框架可能有不同的属性和命名约定。

考虑到性能和内存占用，特别是在处理大数据量的Excel文件时，合理配置和使用这些注解属性是非常重要的。

@Mapper-标记接口

@Mapper 是MyBatis框架中的一个注解，通常用于接口上，用来标记这是一个MyBatis的Mapper接口。当使用此注解时，开发人员不需要为该接口编写映射XML文件，MyBatis会自动为接口中的方法生成SQL语句执行的代理对象。这对于喜欢使用纯Java方式配置和管理SQL映射的项目非常有用，减少了XML配置文件的维护工作。

@Autowired-实现依赖注入

@Autowired 是Spring框架提供的一个注解，用于实现依赖注入（Dependency Injection, DI）。当一个字段、构造器或方法被标注为 @Autowired 时，Spring容器会在运行时自动为该成员提供所需的bean。这个过程是基于类型匹配（Type-based autowiring）进行的，Spring会查找应用上下文中匹配该注解字段或参数类型的一个bean，并将其注入。

@Service
public class UserService {
    @Autowired
    private UserRepository userRepository;
    // ...
}

@PreDestroy-bean实例被销毁之前执行方法

@PreDestroy 是Java EE和Spring框架中用于生命周期管理的注解，它标记在方法上，表示该方法将在所属的bean实例被销毁之前执行。这个注解主要用于执行清理操作，释放资源，如关闭文件流、数据库连接、线程池等。它遵循Java的JSR-250规范（Java EE 6中引入），同样也被Spring框架广泛支持。

public class SomeService {
    // ...其他代码...
    @PreDestroy
    public void cleanup() {
        // 执行清理操作，如关闭资源
        System.out.println("执行清理工作");
    }
}

@Transactional-事务管理注解

@Transactional 是Spring框架提供的一个用于声明式事务管理的注解，它可以被应用于类或方法上，用来控制数据库事务的边界。通过使用此注解，开发人员可以避免在代码中显式地管理事务的开始、提交或回滚，从而简化了事务处理逻辑，并增强了代码的可读性和可维护性。

@Service
public class UserService {
    @Transactional
    public User createUser(User user) {
        // 该方法在一个事务中执行
        // ...数据库操作...
    }
    public User getUserById(int id) {
        // 该方法不涉及事务
        // ...查询操作...
    }
}

Java内置注解（java7添加了后面三个注解）

Java 注解_百度百科

@Override-重写方法

@Override 是一个Java注解，用于指示某个方法正在重写（Override）其父类或实现的接口中的方法。这个注解是非功能性注解，它不会改变程序的行为，但可以帮助编译器进行检查，确保你正确地重写了方法。

如果使用了 @Override 注解但实际上并没有重写任何方法，编译器会报错。

使用场景:

子类重写父类方法：当子类中的方法名称、返回类型、参数列表与父类中的某个方法完全相同时，可以使用 @Override 注解。

实现接口方法：如果一个类实现了某个接口，那么该类必须实现接口中所有的抽象方法。在实现这些方法时，也可以使用 @Override 注解。

class Animal {
    void eat() {
        System.out.println("Animal is eating");
    }
}

class Dog extends Animal {
    @Override
    void eat() {
        System.out.println("Dog is eating");
    }
}

@Deprecatd-过时方法使用会编译警告

@Deprecated 是一个Java注解，用于表示某个类、方法或字段已不推荐使用，可能在未来版本中被移除。

这个注解提醒开发者应该避免使用被标注的元素，寻找替代方案。它不会影响到现有代码的编译或运行，但大多数IDE（集成开发环境）会在使用了被 @Deprecated 标注的元素时给出警告，帮助开发者意识到这一情况。

使用场景:

当一个方法、类或字段因为有更好的替代方案或者设计变更不再适合继续使用时，可以使用此注解。

有助于在升级库或框架时，平滑地过渡到新API，同时保留旧API一段时间以兼容旧代码。

public class OldClass {

    @Deprecated
    public void oldMethod() {
        System.out.println("This method is deprecated. Use newMethod() instead.");
    }

    public void newMethod() {
        System.out.println("Use this method instead of oldMethod().");
    }
}

在上面的例子中，oldMethod() 方法被 @Deprecated 注解，提示用户应改用 newMethod()。开发者在调用 oldMethod() 时，IDE通常会显示警告信息。

@SuppessWarnings 忽略声明警告

@SuppressWarnings 是一个Java注解，用于抑制编译器发出的特定类型的警告信息。

这在你明确知道某些代码会引发编译警告，但出于某种原因（如代码的特殊需求、第三方库的限制等）仍然需要保留这些代码时非常有用。通过使用 @SuppressWarnings，可以让编译器忽略指定类型的警告，从而保持编译输出的清洁。

使用场景:

当你确定某段代码虽然触发警告，但实际上在你的上下文中是安全或可接受的。

对于第三方库的使用导致的无法控制的警告。

特定情况下的类型转换、未使用的变量、过时的方法调用等。

@SuppressWarnings("unused")
public class Example {

    private int unusedVariable = 10; // 这个变量未被使用，但有时可能因为设计需要而暂时保留

    public void someMethod() {
        List<String> list = new ArrayList<>();
        // 假设我们清楚这个操作是安全的，但仍会引发未检查的转换警告
        @SuppressWarnings("unchecked")
        List<Object> objects = (List<Object>) list;
    }
}

在上面的示例中：

类级别的 @SuppressWarnings("unused") 抑制了关于未使用变量的警告。

方法内的 @SuppressWarnings("unchecked") 局部抑制了关于未检查类型转换的警告。

@Target --标记注解为哪个java成员

@Target 是Java注解的一个元注解，用于指定被标注的注解可以在哪些类型的程序元素（如类、方法、字段等）上使用。

它通过限制注解的应用范围，帮助确保注解被正确且有意义地使用。@Target 的参数是一个 ElementType 枚举值数组，可以指定一个或多个允许的元素类型。

@Inherited 标记注解继承哪个注解

@SafeVarargs 忽略任何参数关于泛型变量的方法和构造函数产生的警告

@FunctionalInterface 标识一个匿名函数或函数式接口

@Repeatable 标识某注解可以在同一个声明上使用多次

小白一枚~

后续会持续更新~

学习使用到新注解后会继续添加~

敲厉害的燕宝

关注

12
点赞
踩
11

收藏

觉得还不错? 一键收藏
0
评论
java常用注解

myService() 和 anotherService() 方法分别定义了两个Bean，它们将在应用上下文中可用，可以通过依赖注入的方式被其他Bean使用。配置类可以包含多个 @Bean 方法，每个方法定义了一个Bean的创建过程。通过这样的配置类，你可以以Java代码的形式组织和管理Spring的配置，替代传统的XML配置，使得项目更加面向Java，并且支持IDE的代码补全和类型检查等功能。
复制链接

扫一扫