SSM(Spring+SpringMVC+MyBatis)常用注解大全

提示

使用浏览器查找系统也快速查找，可避免漏看和疲劳

Win:Ctrl+F

Mac:Command+F

1. @Bean

   • 功能：用于在配置类中声明一个bean。
   • 用法：

     @Configuration
     public class AppConfig {
     
         @Bean
         public MyService myService() {
             return new MyServiceImpl();
         }
     }

2. @Component

   • 功能：用于标注一个类，表示这个类会作为组件类，并告知Spring要为这个类创建bean。
   • 用法：

     @Component
     public class MyComponent {
         // ...
     }

3. @Controller

   • 功能：用于标注控制层组件（如struts中的action），表示这个类属于Spring MVC Controller层。
   • 用法：

     @Controller
     public class MyController {
         // ...
     }

4. @Service

   • 功能：用于标注业务层组件，表示这个类属于业务逻辑层。
   • 用法：

     @Service
     public class MyService {
         // ...
     }

5. @Repository

   • 功能：用于标注数据访问组件，即DAO组件，表示这个类属于数据访问层。
   • 用法：

     @Service
     public class MyService {
         // ...
     }

6. @ComponentScan

   • 功能：让Spring扫描到Configuration类并把它加入到程序上下文。
   • 用法：

     @Configuration
     @ComponentScan("com.example.myapp")
     public class AppConfig {
         // ...
     }

7. @ResponseBody

   • 功能：表示该方法的返回的结果直接写入 HTTP response body 中，一般在异步获取数据时使用，与@RestController一起使用时，可以省略。
   • 用法：

     @RestController
     public class MyRestController {
     
         @RequestMapping("/hello")
         @ResponseBody
         public String helloWorld() {
             return "Hello, World!";
         }
     }

8. @RestController

   • 功能：标识一个类为SpringMVC的Rest风格的控制器，@RestController是一个用于标识Rest风格控制器的注解。与@Controller注解不同，@RestController注解的类中的所有方法都将以JSON或XML形式返回响应结果，类定义前加此注解，相当于@Controller和@ResponseBody的组合。
   • 用法：

     @RestController
     public class MyRestController {
         // ...
     }

9. Rest风格

   • 功能：REST风格是一种软件架构风格，或者说是一种规范，其强调HTTP应当以资源为中心，并且规范了URI的风格，规范了HTTP请求动作（GET/PUT/POST/DELETE/HEAD/OPTIONS）的使用，具有对应的语义
   • 用法：Rest风格使用Spring MVC提供的注解来规范HTTP的请求操作,以下是常用的请求类型的Spring MVC的注解
   • @PostMapping:是 Spring MVC 提供的一个注解，用于映射 HTTP POST 请求到特定的处理器方法。它是 @RequestMapping(method = RequestMethod.POST) 的简写，专门用于处理 POST 类型的 HTTP 请求。

     @PostMapping
         public Result save(@RequestBody Book book) {
             boolean flag = bookService.save(book);
     //        判断flag是否获取到了数据
             return new Result(book,flag ? Code.SAVE_OK : Code.SAVE_ORR);
         }

   • @PutMapping:是 Spring MVC 提供的一个注解,@PutMapping 注解用于映射 HTTP PUT 请求到特定的处理器方法。PUT 请求通常用于更新资源。

     @PutMapping
         public Result update(@RequestBody Book book) {
             boolean flag = bookService.update(book);
             return new Result(flag,flag ? Code.UPDATE_OK : Code.UPDATE_ORR);
         }

   • @DeleteMapping:是 Spring MVC 提供的一个注解,@DeleteMapping 注解用于映射 HTTP DELETE 请求到特定的处理器方法。DELETE 请求通常用于删除资源。

     @DeleteMapping("/{id}")
         public Result delete(@PathVariable Integer id) {
             boolean flag = bookService.delete(id);
             return new Result(flag,flag ? Code.DELETE_OK : Code.DELETE_ORR);
         }

   • @GetMapping:是 Spring MVC 提供的一个注解,@GetMapping 注解用于映射 HTTP GET 请求到特定的处理器方法。GET 请求通常用于检索资源。

     //@GetMapping（有参）
     @GetMapping("/{id}")
         public Result getById(@PathVariable Integer id) {
     
             Book book = bookService.getById(id);
             Integer code = book != null ? Code.GET_OK : Code.GET_ORR;
             String msg = code.equals(Code.GET_OK) ? "Code.GET_OK" : "Code.GET_ORR";
             return new Result(book,code,msg);
         }
     //@GetMapping（无参）
         @GetMapping
         public Result getAll() {
             List<Book> bookList = bookService.getAll();
             Integer code = bookList != null ? Code.GET_OK : Code.GET_ORR;
             String msg = code.equals(Code.GET_OK) ? "Code.GET_OK" : "Code.GET_ORR";
             return new Result(bookList,code,msg);
         }

10. @RequestMapping

    • 功能：用于映射请求路径到具体的类或方法上,可以标注在类或方法上，类上的@RequestMapping路径和方法上的路径会组合成完整的路径。
    • 用法：

      //方法使用
      @RestController
      public class MyRestController {
      
          @RequestMapping("/hello")
          public String helloWorld() {
              return "Hello, World!";
          }
      }
      /*配合Pest风格使用@RequestMapping（类使用）假设路径为:http://localhost:8080/books 使用post请求类型方法这个路径就可以实现这个save中的方法*/
      @RestController
      @RequestMapping("/books")
      public class BookController {
      
          @Autowired
          private BookService bookService;
      
          @PostMapping
          public Result save(@RequestBody Book book) {
              boolean flag = bookService.save(book);
      //        判断flag是否获取到了数据
              return new Result(book,flag ? Code.SAVE_OK : Code.SAVE_ORR);
          }

11. @RequestParam

    • 功能：将请求参数绑定到控制器方法的参数上。@RequestParam是一个用于获取HTTP请求参数的注解，在SpringMVC中非常常用。它可以用于方法参数级别，用于指定获取请求参数的方式和名称。
    • 用法：

      /*假设请求路径为:http:localhost/method?name=zhangsan，那么在@RequestParam("name"),就可以获取到值:"zhangsan"*/
      @RestController
      public class MyRestController {
      
          @RequestMapping("/greet")
          public String greet(@RequestParam String name) {
              return "Hello, " + name + "!";
          }
      }

12. @PathVariable

    • 功能：将URL中的一部分作为控制器方法的参数。@PathVariable是一个用于获取HTTP请求路径中的参数的注解，在SpringMVC中非常常用。它可以用于方法参数级别，用于指定获取请求路径参数的名称。
    • 用法：

      /*
      *一般都是配合Rest风格和Spring MVC的@GetMapping("/{id}")、*@DeleteMapping("/{id}")来使用:public void method(@PathVariable Integer *id)
      */
      @RestController
      public class MyRestController {
      
          @RequestMapping("/greet/{name}")
          public String greet(@PathVariable String name) {
              return "Hello, " + name + "!";
          }
      }

13. @RequestBody

    • 功能：将请求体的内容绑定到控制器方法的参数上。@RequestBody是一个用于获取HTTP请求体中的参数的注解，在SpringMVC中非常常用。它可以用于方法参数级别，用于指定获取请求体参数的方式。
    • 用法：

      @Controller
      @RequestMapping("/users")
      public class UserController {
      
          @GetMapping("/{id}")
          @ResponseBody
          public User getUser(@PathVariable Long id) {
              // ...
              return user;
          }
      }
      

14. @ModelAttribute

    • 功能：将请求参数绑定到一个对象上。@ModelAttribute是一个用于将HTTP请求参数绑定到方法参数或方法返回值上的注解，在SpringMVC中非常常用。它可以用于方法参数级别，用于指定使用HTTP请求参数来绑定方法参数上的属性值。
    • 用法：

      @Controller
      @RequestMapping("/users")
      public class UserController {
      
          @PostMapping
          public String createUser(@ModelAttribute User user) {
              // ...
          }
      }
      

15. @SessionAttribute

    • 功能：@SessionAttribute注解用于将模型属性绑定到HTTP会话中，以便在多个请求之间共享数据。
    • 用法：

      @Controller
      @SessionAttributes("user")
      public class UserController {
      
          @ModelAttribute
          public User getUser() {
              return new User();
          }
      
          @RequestMapping(value = "/login", method = RequestMethod.POST)
          public String login(@ModelAttribute User user) {
              // 登录逻辑
              // 用户登录成功后，user对象会被自动绑定到会话中
              return "redirect:/home";
          }
      
          @RequestMapping(value = "/home")
          public String home(@ModelAttribute User user) {
              // 在home视图中可以直接访问user对象，因为它是从会话中获取的
              return "home";
          }
      }

16. @Import

    • 功能：@Import 注解在Spring框架中用于导入其他的配置类，使得当前的配置类能够使用被导入配置类中定义的Bean。这允许你将配置逻辑分割到多个配置类中，并在需要的地方将它们组合在一起。
    • 用法：

      @Configuration
      @ComponentScan({"javax.Service"})//扫描bean
      @PropertySource("classpath:jdbc.properties")//加载jdbc.properties文件数据
      @Import({MyBatisConfig.class, JdbcConfig.class})//加载两个mybatis的核心配置类
      public class SpringConfig {
      //    该类为Spring的核心配置类
      }
      
      public class MyBatisConfig {
      //    该类和JdbcConfig类是Mybatis的核心配置类
      //    1.配置sql
          @Bean
          public SqlSessionFactoryBean sqlSessionFactory(DataSource dataSource){
             // 配置sql相关代码
          }
      
      //    2.扫描映射
          @Bean
          public MapperScannerConfigurer mapperScannerConfigurer(){
              // 配置扫描映射相关代码
          }
      
      }
      public class JdbcConfig {
          //该类和MyBatisConfig类是Mybatis的核心配置类
      
      //    创建一个数据源
          @Value("${jdbc.driver}")
          private String Driver;
          @Value("${jdbc.url}")
          private String url;
          @Value("${jdbc.username}")
          private String username;
          @Value("${jdbc.password}")
          private String password;
          @Bean
          public DataSource dataSource(){
              //    配置一个数据源
          }
      }
      
      

17. @PropertySource

    • 功能：@PropertySource 是 Spring 框架中用于加载属性文件（如 .properties 或 .yml）的注解。当你想在 Spring 应用中使用外部配置属性时，你可以使用这个注解来指定属性文件的位置。加载的属性可以通过 @Value 注解注入到 Spring 管理的 Bean 中。
    • 用法：

      在编号#16-@Import#SpringConfig和#JdbcConfig类中已说明

18. @EnableWebMvc

    • 功能：@EnableWebMvc 是一个 Spring MVC 注解，用于启用 Spring MVC 的配置。它通常用于 Java 配置类中，替代传统的 XML 配置方式。当在配置类上添加 @EnableWebMvc 注解时，Spring MVC 会开始配置一系列的组件，如 RequestMappingHandlerMapping、RequestMappingHandlerAdapter 等，以支持基于注解的控制器。
    • 用法：

      @Configuration // 让SpringMVC能扫描到这个类
      @EnableWebMvc  // 通过情况下@EnableWebMvc注解都是添加到SpringMVC核心配置文件中的，然后使用@ComponentScan注解将这个类扫描使用，此处单纯进行学习理解
      public class SpringMvcSupport extends WebMvcConfigurationSupport {
      //  因为我们在ServletContainersInitConfig类的getServletMappings方法中，定义了所有请求都归SpringMVC处理，但是网页要交给tomcat处理
          @Override
          protected void addResourceHandlers(ResourceHandlerRegistry registry) {
      //        当访问/网页资源/??时候，走/？？目录下的内容
              registry.addResourceHandler("/pages/**").addResourceLocations("/pages/");
              registry.addResourceHandler("/js/**").addResourceLocations("/js/");
              registry.addResourceHandler("/css/**").addResourceLocations("/css/");
              registry.addResourceHandler("/plugins/**").addResourceLocations("/plugins/");
          }
      }

19. @EnableTransactionManagement

    • 功能：启用Spring的事务管理功能。
    • 用法：

      @Configuration
      @EnableTransactionManagement
      public class TransactionConfig {
          @Bean
          public PlatformTransactionManager transactionManager(EntityManagerFactory entityManagerFactory) {
              JpaTransactionManager transactionManager = new JpaTransactionManager();
              transactionManager.setEntityManagerFactory(entityManagerFactory);
              return transactionManager;
          }
      }

20. @Transactional

    • 功能：标记方法或类，使其在事务上下文中执行。
    • 用法：

      @Service
      public class MyService {
          @Transactional
          public void transactionalMethod() {
              // Database operations
          }
      }

21. @TransactionalEvent

    • 功能：@TransactionalEvent 用于定义一个事件，该事件将在事务的不同阶段被发布。这个注解通常标记在一个普通的类上，该类将作为事件对象在事务的不同阶段被发布。------@TransactionalEventListener 和 @TransactionalEvent 是 Spring 框架中用于处理事务相关事件的注解。它们通常一起使用，以在事务的不同阶段执行特定的逻辑。
    • 用法：

      
      /*
      *在以下例子中，我们定义了两个监听器方法。第一个监听器 handleAfterCommit 在事务成功提交后执行，而第二个监听器 handleAfterRollback 在事务回滚后执行。TransactionalPhase 枚举提供了多个事件监听阶段，包括 BEFORE_COMMIT, AFTER_COMMIT, BEFORE_ROLLBACK, AFTER_ROLLBACK 等。
      *
      */
      
      //定义事务事件
      import org.springframework.context.ApplicationEvent;
      import org.springframework.transaction.event.TransactionalEvent;
      
      @TransactionalEvent
      public class MyCustomTransactionalEvent extends ApplicationEvent {
      
          private final String message;
      
          public MyCustomTransactionalEvent(Object source, String message) {
              super(source);
              this.message = message;
          }
      
          public String getMessage() {
              return message;
          }
      }
      
      
      //创建事件发布者
      import org.springframework.beans.factory.annotation.Autowired;
      import org.springframework.context.ApplicationEventPublisher;
      import org.springframework.stereotype.Service;
      import org.springframework.transaction.annotation.Transactional;
      
      @Service
      public class MyService {
      
          @Autowired
          private ApplicationEventPublisher eventPublisher;
      
          @Transactional
          public void performTransactionalTask(String message) {
              // ... 执行一些数据库操作 ...
      
              // 发布事件
              eventPublisher.publishEvent(new MyCustomTransactionalEvent(this, message));
          }
      }
      
      //创建事件监听器
      import org.springframework.context.event.EventListener;
      import org.springframework.stereotype.Component;
      import org.springframework.transaction.event.TransactionalEventListener;
      import org.springframework.transaction.event.TransactionalPhase;
      
      @Component
      public class MyTransactionalEventListener {
      
          // 监听事务提交后的事件
          @TransactionalEventListener(phase = TransactionalPhase.AFTER_COMMIT)
          public void handleAfterCommit(MyCustomTransactionalEvent event) {
              System.out.println("Received event with message: " + event.getMessage());
              // 在这里执行事务提交后的逻辑
          }
      
          // 监听事务回滚后的事件
          @TransactionalEventListener(phase = TransactionalPhase.AFTER_ROLLBACK)
          public void handleAfterRollback(MyCustomTransactionalEvent event) {
              System.out.println("Received event with message: " + event.getMessage());
              // 在这里执行事务回滚后的逻辑
          }
      }
      
      
      

22. @TransactionalEventListener

    • 功能：@TransactionalEventListener 用于监听由 @TransactionalEvent 发布的事件，并在事务的不同阶段执行相应的逻辑。这个注解通常标记在一个方法上，该方法将处理事件对象。------@TransactionalEventListener 和 @TransactionalEvent 是 Spring 框架中用于处理事务相关事件的注解。它们通常一起使用，以在事务的不同阶段执行特定的逻辑。
    • 用法：

      参考#21-@TransactionalEvent的用法

23. @InitBinder

    • 功能：@InitBinder注解通常应用于控制器类的方法上。这些方法接受一个WebDataBinder对象作为参数，你可以使用它来注册自定义的PropertyEditor，Converter，或者其他的数据绑定相关的回调,@InitBinder注解可以帮助你实现复杂的数据转换和验证逻辑，而无需在每个控制器方法中重复相同的代码。
    • 用法：

      @Controller
      @RequestMapping("/users")
      public class UserController {
      
          @InitBinder
          public void initBinder(WebDataBinder binder) {
              SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd");
              binder.registerCustomEditor(Date.class, new CustomDateEditor(dateFormat, true));
          }
      
          @PostMapping
          public String createUser(@ModelAttribute User user) {
              // ...
          }
      }

24. @RestControllerAdvice

    • 功能：@RestControllerAdvice 和 @ExceptionHandler 是 Spring Framework 中用于全局异常处理的注解。这些注解使得开发者能够在一个集中的位置定义如何处理应用程序中抛出的异常，而不需要在每个控制器方法中重复异常处理逻辑。
    • 用法：

      @RestControllerAdvice
      public class ProjectExceptionAdvice {
      //    @ExceptionHandler的参数是异常类的字节码，这边使用的是自定义异常类
          @ExceptionHandler(BusinessException.class)
          public Result doException(BusinessException ex){
              System.out.println("你小子乱搞是吧.....");
              return new Result(null,ex.getCode(),ex.getMessage());
          }
      }

25. @ExceptionHandler

    • 功能：用于标记一个方法，该方法将处理特定类型的异常。你可以为不同的异常类型定义不同的处理方法。(配合@RestControllerAdvice注解使用)
    • 用法：

      @RestControllerAdvice
      public class ProjectExceptionAdvice {
      // @ExceptionHandler的参数是异常类的字节码，这边使用的是Exception异常类
          @ExceptionHandler(Exception.class)
          public Result doException(Exception ex){
              System.out.println("异常.......");
              return new Result(null,500,"未知异常");
          }
      }

26. @ResponseStatus

    • 功能：@ResponseStatus 是 Spring Framework 中用于指定 HTTP 响应状态码的注解，它通常与 @ControllerAdvice 或 @ExceptionHandler 一起使用，以在异常处理时指定返回的 HTTP 状态码和消息。
    • 用法：指定 HTTP 状态码\自定义错误消息\异常映射

      @ControllerAdvice
      public class GlobalExceptionHandler {
      
          @ExceptionHandler(value = CustomException.class)
          @ResponseStatus(value = HttpStatus.BAD_REQUEST, reason = "自定义错误消息")
          public void handleCustomException() {
              // 异常处理逻辑
          }
      
          @ExceptionHandler(value = Exception.class)
          @ResponseStatus(value = HttpStatus.INTERNAL_SERVER_ERROR, reason = "服务器内部错误")
          public void handleGeneralException() {
              // 通用异常处理逻辑
          }
      }

27. @Autowired

    • 功能：自动装配，Spring会按照byType的方式实现依赖注入,可以用在字段、setter方法或构造函数上，表示自动装配Bean。
    • 用法：

      @Service
      public class MyService {
      
          private final AnotherService anotherService;
      
          @Autowired
          public MyService(AnotherService anotherService) {
              this.anotherService = anotherService

28. @Qualifier

    • 功能：当有多个同一类型的Bean时，可以用@Qualifier("name")来指定注入哪一个Bean,与@Autowired一起使用，指定需要注入的Bean的名称。
    • 用法：

      @Service
      public class MyService {
          // ...
      }
      
      @Service("anotherService")
      public class AnotherService {
          // ...
      }
      
      @Controller
      public class MyController {
          private final MyService myService;
          private final AnotherService anotherService;
      
          @Autowired
          public MyController(@Qualifier("myService") MyService myService,
                              @Qualifier("anotherService") AnotherService anotherService) {
              this.myService = myService;
              this.anotherService = anotherService;
          }
      }

29. @Resource

    • 功能：自动装配，可以按照byName或byType方式进行依赖注入，可以用在字段或setter方法上，如果指定了name属性，则按照byName方式装配，否则按照byType方式装配。
    • 用法：

      @Controller
      public class MyController {
          private final MyService myService;
      
          @Resource(name = "myService", type = "com.example.MyService")
          public MyController(MyService myService) {
              this.myService = myService;
          }
      }

30. @Configuration

    • 功能：声明当前类是一个配置类，用于定义Spring上下文中的bean，类定义前加此注解，通常与@ComponentScan、@Bean等注解一起使用。
    • 用法：

      @Configuration
      public class AppConfig {
          @Bean
          public MyService myService() {
              return new MyServiceImpl();
          }
      }

31. @Scope

    • 功能：定义bean的作用域，如singleton、prototype等，用于标注类或者方法，定义bean的作用域。
    • 用法：

      @Service
      @Scope("prototype")
      public class MyPrototypeService {
          // ...
      }

32. @Profile

    • 功能：根据指定的环境进行bean的创建和销毁,通常与Spring的profile功能结合使用，根据激活的profile来创建或销毁bean。
    • 用法：

      @Component
      @Profile("dev")
      public class DevOnlyBean {
          // ...
      }
      
      @Configuration
      public class AppConfig {
          @Autowired
          public AppConfig(@Profile("dev") DevOnlyBean devOnlyBean) {
              // ...
          }
      }

33. @EnableAsync

    • 功能：开启异步方法支持,通常放在配置类上，开启异步方法支持。
    • 用法：

      @Configuration
      @EnableAsync
      public class AsyncConfig {
          // ... 可以配置TaskExecutor等异步执行相关的Bean ...
      }