Spring Boot + MyBatis常用注解下面的文章根据Spring Boot + MyBatis常用注解（万字

下面的文章根据Spring Boot + MyBatis常用注解（万字解析）来总结的

SpringBoot注解

核心注解

@SpringBootApplication

含义与作用：@SpringBootApplication 是一个复合注解，包含了 @Configuration、@EnableAutoConfiguration 和 @ComponentScan。用于标注主类，启用Spring Boot的自动配置和组件扫描功能。

示例：

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

组件标识注解

这些注解用于标识不同层次的组件，便于Spring进行自动扫描和管理。

@Component 含义与作用：@Component 是一个通用的Spring管理的组件注解，用于标识任何Spring管理的Bean。其他注解（如 @Service、@Repository、@Controller）都是 @Component 的特化。

示例：

@Component
public class Utility {

    public void performTask() {
        // 执行任务
    }
}

@RestController

含义与作用：@RestController 是 @Controller 和 @ResponseBody 的组合注解，用于标识控制器类，适用于构建RESTful Web服务。所有方法返回的对象会自动序列化为JSON或XML。

示例：

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

    @GetMapping("/users")
    public List<User> getAllUsers() {
        // 返回用户列表
    }
}

@Controller

含义与作用：@Controller 用于标识控制器类，通常与视图解析器（如Thymeleaf）配合使用，适用于传统的MVC模式。

示例：

@Controller
public class HomeController {

    @GetMapping("/")
    public String home(Model model) {
        model.addAttribute("message", "Hello World");
        return "home";
    }
}

@Service

含义与作用：@Service 用于标识业务逻辑层的组件，增强代码的可读性和可维护性。它也是一个 @Component，因此会被Spring扫描和管理。

示例：

@Service
public class UserService {

    @Autowired
    private UserRepository userRepository;

    public List<User> getAllUsers() {
        return userRepository.findAll();
    }
}

@Repository

含义与作用：@Repository 用于标识数据访问层的组件，通常与持久化技术（如JPA、MyBatis）结合使用。它还提供了异常转换功能，将持久层异常转换为Spring的统一异常。

在MyBatis中，@Repository用@Mapper代替

示例：

@Repository
public class UserRepository {

    @Autowired
    private JdbcTemplate jdbcTemplate;

    public List<User> findAll() {
        // 查询数据库
    }
}

依赖注入注解

这些注解用于实现Spring的依赖注入机制，简化Bean的管理和使用。

@Autowired

含义与作用：@Autowired 用于自动装配Bean，可以应用于构造函数、字段或Setter方法。Spring会根据类型自动注入匹配的Bean。默认是byType注入的。

@Resource

与上面那个@Autowired类似，但是默认是byName注入的。同时@Resource还有两个重要的属性：name和type，用来显式指定byName和byType方式注入。

// 1. 默认方式：byName
@Resource  
private UserService userDao; 

// 2. 指定byName
@Resource(name="userService")  
private UserService userService; 

// 3. 指定byType
@Resource(type=UserService.class)  
private UserService userService; 

// 4. 指定byName和byType
@Resource(name="userService",type=UserService.class)  
private UserService userService;

示例：

@Service
public class OrderService {

    @Autowired
    private OrderRepository orderRepository;

    // 或者通过构造函数注入
    // private final OrderRepository orderRepository;
    //
    // @Autowired
    // public OrderService(OrderRepository orderRepository) {
    //     this.orderRepository = orderRepository;
    // }
}

@Qualifier

含义与作用：@Qualifier 与 @Autowired 一起使用，用于在多个Bean候选者中指定要注入的具体Bean。

示例：

    @Component("fooFormatter")
    public class FooFormatter implements Formatter {
        public String format() {
            return "foo";
        }
    }

    @Component("barFormatter")
    public class BarFormatter implements Formatter {
        public String format() {
            return "bar";
        }
    }

    @Component
    public class FooService {
        @Autowired
        @Qualifier("fooFormatter")
        private Formatter formatter;
        
        //todo 
    }

@Inject

含义与作用：@Inject 是JSR-330规范的注解，与 @Autowired 类似，用于实现依赖注入。功能上与 @Autowired 基本相同，但不支持 required 属性。

示例：

@Service
public class NotificationService {

    @Inject
    private EmailService emailService;
}

配置注解

用于定义和管理应用的配置和Bean。

@Configuration

含义与作用：@Configuration 用于标识配置类，类似于传统的XML配置文件。可以在配置类中定义Bean，并进行依赖注入的配置。

示例：

@Configuration
public class AppConfig {

    @Bean
    public RestTemplate restTemplate() {
        return new RestTemplate();
    }
}

@Bean

含义与作用：@Bean 用于在 @Configuration 类中定义Bean，Spring会管理这些Bean的生命周期和依赖。

示例：

@Configuration
public class DataSourceConfig {

    @Bean
    public DataSource dataSource() {
        // 配置数据源
    }
}

@Value

含义与作用：@Value 用于注入配置文件中的属性值，可以注入到字段、方法参数或构造函数参数中。

示例：

@Component
public class AppProperties {

    @Value("${app.name}")
    private String appName;

    @Value("${app.version}")
    private String appVersion;
}

@ConfigurationProperties

含义与作用：@ConfigurationProperties 用于将配置文件中的属性映射到一个Java对象中，适用于大量相关属性的绑定。

示例：

@Component
@ConfigurationProperties(prefix = "app")
public class AppProperties {

    private String name;
    private String version;

    // getters and setters
}

通过 @Configuration 注解，Spring 会在 Application Context 中创建一个 Spring Bean。

@ConfigurationProperties 最适合具有相同前缀的分层属性，这里添加了一个名为 app 的前缀。

Spring 框架使用标准的 Java Bean Setter，因此必须为每个属性声明 Setter 方法。

注：如果不在 POJO 中使用 @Configuration，则需要在 Spring Application main 类中添加 @EnableConfigurationProperties(ConfigProperties.class) 以将属性绑定到 POJO 中：

@SpringBootApplication
@EnableConfigurationProperties(ConfigProperties.class)
public class EnableConfigurationDemoApplication {
    public static void main(String[] args) {
        SpringApplication.run(EnableConfigurationDemoApplication.class, args);
    }
}

如上！Spring 会自动绑定属性文件中定义的、前缀为 app 且名称与 ConfigProperties 类中某个字段相同的任何属性。

Spring 对绑定属性使用了一些宽松的规则。因此，以下各种变体都可以绑定到属性 hostName：

mail.hostName
mail.hostname
mail.host_name
mail.host-name
mail.HOST_NAME

可以使用下面的 properties 文件来设置所有字段：

# 示例 properties
mail.hostname=host@mail.com
mail.port=9000
mail.from=mailer@mail.com

Spring2.2之后

从 Spring Boot 2.2 开始，Spring 通过 classpath 扫描查找并注册 @ConfigurationProperties 类。对 @ConfigurationProperties 的扫描需要通过添加 @ConfigurationPropertiesScan 注解来明确选择。因此，不必用 @Component（以及 @Configuration 等其他元注解）注解此类类，甚至也不必使用 @EnableConfigurationProperties：

@ConfigurationProperties(prefix = "mail") 
@ConfigurationPropertiesScan 
public class ConfigProperties { 

    private String hostName; 
    private int port; 
    private String from; 

    // 标准的 Get、Set 
}

@SpringBootApplication 启用的 classpath Scanner 找到了 ConfigProperties 类，尽管我们没有用 @Component 对该类进行注解。

此外，还可以使用 @ConfigurationPropertiesScan 注解来扫描自定义位置的配置属性类：

@SpringBootApplication
@ConfigurationPropertiesScan("com.baeldung.configurationproperties")
public class EnableConfigurationDemoApplication { 

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

如上，Spring 将只在 com.baeldung.properties 包中查找配置属性类。

Lombok

Lombok的核心作用是通过注解自动生成Java类中重复、模板化的代码，减少冗余代码量，提高开发效率。它主要解决了Java开发中频繁编写 getter/setter、构造方法、toString() 等重复代码的痛点，让开发者专注于核心业务逻辑。

Lombok的核心功能（常用注解）

通过在类或字段上添加注解，Lombok会在编译阶段自动生成对应的代码，无需手动编写：

@Data：最常用注解，组合了@Getter、@Setter、@ToString、@EqualsAndHashCode、@RequiredArgsConstructor的功能，一键生成完整的基础代码。
@Getter / @Setter：为类的所有字段（或指定字段）自动生成 getter（取值）和 setter（赋值）方法。 - @NoArgsConstructor：自动生成无参构造方法。
@AllArgsConstructor：自动生成包含所有字段的全参构造方法。
@ToString：自动生成 toString() 方法，包含类名和所有字段的信息。
@EqualsAndHashCode：自动生成 equals() 和 hashCode() 方法，用于对象的比较。
@Slf4j：自动生成日志对象（private static final Logger log = LoggerFactory.getLogger(类名.class);），直接使用 log.info() 等方法打印日志。
@Builder：为类生成“建造者模式”代码，支持链式调用创建对象（如 User.builder().name("张三").age(20).build()）。

示例：

Lombok简化代码的对比

1. 未使用Lombok（冗余代码）

public class User { private String name; private Integer age; // 手动写无参构造 public User() {} // 手动写全参构造 public User(String name, Integer age) { this.name = name; this.age = age; } // 手动写getter/setter public String getName() { return name; } public void setName(String name) { this.name = name; } public Integer getAge() { return age; } public void setAge(Integer age) { this.age = age; } // 手动写toString @Override public String toString() { return "User{name='" + name + "', age=" + age + "}"; } }

2. 使用Lombok（简洁代码）

import lombok.Data; 
@Data // 一个注解替代所有重复代码 
public class User { private String name; private Integer age; }

编译后，Lombok会自动生成上述所有的构造方法、getter/setter、toString等代码，效果与手动编写完全一致。

注意事项

使用前需在项目中引入Lombok依赖（Maven/Gradle），并在IDE（如IDEA）中安装Lombok插件（否则IDE可能报“方法不存在”的错误，但编译运行正常）。
避免过度依赖：对于简单类（如POJO）非常适用，但复杂类（如包含特殊逻辑的getter/setter）建议手动编写，避免注解隐藏业务逻辑。

事务管理注解

用于声明事务管理，确保数据一致性和完整性。

@Transactional

含义与作用：@Transactional 用于声明事务管理，适用于需要事务控制的方法或类。可以指定事务的传播行为、隔离级别、回滚规则等。

示例：

@Service
public class PaymentService {

    @Transactional
    public void processPayment(Order order) {
        // 执行支付逻辑
    }
}

在使用 Spring 的 @Transactional 注解时，是否需要指定 rollbackFor = Exception.class 取决于你希望事务在哪些异常情况下回滚。

✅ 仅需 `@Transactional` 的情况：

抛出的是运行时异常（RuntimeException）或 Error：
- 默认情况下，Spring 会自动回滚事务。
- 示例：NullPointerException, IllegalArgumentException, 自定义的 RuntimeException 子类等。

@Transactional
public void deleteData(Long id) {
    if (id == null) {
        throw new IllegalArgumentException("ID 不能为空");
    }
    // 数据库操作
}

此例中抛出 IllegalArgumentException，属于 RuntimeException，事务会自动回滚。

✅ 需要加 `@Transactional(rollbackFor = Exception.class)` 的情况：

抛出的是检查型异常（Checked Exception），且你希望事务回滚：
- 比如：IOException, SQLException, ParseException, 或自定义的 Exception 子类。
- 如果不指定 rollbackFor = Exception.class，Spring 不会自动回滚这类异常。

@Transactional(rollbackFor = Exception.class)
public void processData() throws IOException {
    // 可能抛出 IOException
}

在此例中，如果不加 rollbackFor = Exception.class，即使抛出 IOException，事务也不会回滚。

🧠 总结对比：

异常类型	默认是否会回滚	是否需要 `rollbackFor = Exception.class`	说明
RuntimeException	✅ 是	❌ 否	如 NullPointerException
Error	✅ 是	❌ 否	如 OutOfMemoryError
Checked Exception（如 IOException）	❌ 否	✅ 是	必须显式配置才会回滚

🔍 常见误区提醒：

不是所有异常都需要回滚，应根据业务逻辑判断是否需要事务回滚。
使用 rollbackFor = Exception.class 会扩大回滚范围，可能影响性能和事务一致性，建议只在必要时使用。

Web层注解

用于处理Web请求和响应，简化控制器的开发。

请求映射注解

这些注解用于定义HTTP请求的路径和方法，简化路由配置。

@RequestMapping

含义与作用：@RequestMapping 用于定义请求的URL路径和HTTP方法，适用于类级别和方法级别。它是一个通用的映射注解，可以通过 method 属性指定具体的HTTP方法。

示例：

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

    @RequestMapping(value = "/users", method = RequestMethod.GET)
    public List<User> getAllUsers() {
        // 返回用户列表
    }
}

@GetMapping

含义与作用：@GetMapping 是 @RequestMapping 的快捷方式，用于处理HTTP GET请求。适用于方法级别，简化代码。

示例：

@GetMapping("/users")
public List<User> getAllUsers() {
    // 返回用户列表
}

@PostMapping

含义与作用：@PostMapping 是 @RequestMapping 的快捷方式，用于处理HTTP POST请求。适用于方法级别，简化代码。

示例：

@PostMapping("/users")
public ResponseEntity<Void> createUser(@RequestBody User user) {
    // 创建用户
}

@PutMapping

含义与作用：@PutMapping 是 @RequestMapping 的快捷方式，用于处理HTTP PUT请求。适用于方法级别，简化代码。

示例：

@PutMapping("/users/{id}")
public ResponseEntity<Void> updateUser(@PathVariable Long id, @RequestBody User user) {
    // 更新用户
}

@DeleteMapping

含义与作用：@DeleteMapping 是 @RequestMapping 的快捷方式，用于处理HTTP DELETE请求。适用于方法级别，简化代码。

示例：

@DeleteMapping("/users/{id}")
public ResponseEntity<Void> deleteUser(@PathVariable Long id) {
    // 删除用户
}

参数绑定注解

这些注解用于将HTTP请求中的参数绑定到控制器方法的参数上。

@PathVariable

含义与作用：@PathVariable 用于绑定URL路径中的变量到方法参数，常用于RESTful API中的资源标识。

示例：

@GetMapping("/users/{id}")
public User getUser(@PathVariable Long id) {
    // 根据ID获取用户
}

@RequestParam

含义与作用：@RequestParam 用于绑定HTTP请求中的参数到方法参数，适用于查询参数或表单参数。

示例：

@GetMapping("/search")
public List<User> searchUsers(@RequestParam String name, @RequestParam int age) {
    // 根据姓名和年龄搜索用户
}

@RequestBody

含义与作用：@RequestBody 用于将HTTP请求体中的JSON或XML数据绑定到方法参数，常用于处理POST和PUT请求中的数据。

示例：

@PostMapping("/users")
public ResponseEntity<Void> createUser(@RequestBody User user) {
    // 创建用户
}

user相当于一个封装好的类的实例化(虽然他本来就是)

当方法有两个参数时，并且两个参数都是封装好的类时，不能为这两个参数都加上 @RequestBody 注解，因为 HTTP 请求体只能被读取一次，Spring 无法处理多个 @RequestBody 参数。

比如：

在 Spring MVC 中，如果你在一个方法的参数中只给其中一个参数加上了 @RequestBody 注解，Spring 会尝试从请求体中解析该参数的数据（通常用于处理 JSON 或 XML 格式数据），而其他未加 @RequestBody 的参数则会从请求的查询参数（Query Parameters）或表单数据（Form Data）中获取值

public void export(HttpServletResponse response, Item item)
{
    List<Item> list = itemService.selectItemList(item);
    ExcelUtil<Item> util = new ExcelUtil<Item>(Item.class);
    util.exportEasyExcel(response, list, "商品管理数据");
}

item 参数使用 @RequestBody，表示它将从请求体中反序列化为 Item 对象。 name 参数没有 @RequestBody，因此 Spring 会尝试从查询参数或表单字段中获取 name 的值。注意事项：请求体只能被读取一次：因为 HTTP 请求的输入流只能被读取一次，所以多个参数不能同时使用 @RequestBody。否则会抛出异常或者无法正确绑定参数。如果你需要传递多个参数，可以通过以下方式：将多个参数封装到一个对象中，并通过 @RequestBody 接收。使用 @RequestParam、@PathVariable 或 @RequestHeader 来接收其他参数。总结： ✅ 可以只为一个参数添加 @RequestBody ❌ 不可以为多个参数添加 @RequestBody 💡 其他参数可以从 URL 查询参数、路径变量或请求头中获取

@ResponseBody

含义与作用：@ResponseBody 用于将方法返回的对象序列化为JSON或XML并写入HTTP响应体，通常与 @Controller 一起使用。@RestController 已经包含了 @ResponseBody 的功能。

示例：

@Controller
public class UserController {

    @GetMapping("/users")
    @ResponseBody
    public List<User> getAllUsers() {
        // 返回用户列表
    }
}

MyBatis 常用注解

MyBatis 是一个优秀的持久层框架，通过映射语句将数据库操作与Java方法关联。MyBatis提供了一系列注解，简化了XML映射文件的使用。

Mapper接口注解

@Mapper

含义与作用：@Mapper 用于标识MyBatis的Mapper接口，Spring会自动扫描并生成代理对象。通常与 @MapperScan 配合使用。

示例：

@Mapper
public interface UserMapper {

    @Select("SELECT * FROM users WHERE id = #{id}")
    User getUserById(@Param("id") Long id);
}

SQL操作注解

这些注解用于定义具体的SQL语句，关联到Mapper接口的方法上，实现数据库的CRUD操作。

@Select

含义与作用：@Select 用于标注查询语句，关联到接口的方法上，实现数据库的查询操作。

示例：

@Mapper
public interface UserMapper {

    @Select("SELECT * FROM users")
    List<User> getAllUsers();
}

@Insert

含义与作用：@Insert 用于标注插入语句，关联到接口的方法上，实现数据库的插入操作。

示例：

@Mapper
public interface UserMapper {

    @Insert("INSERT INTO users(name, email) VALUES(#{name}, #{email})")
    @Options(useGeneratedKeys = true, keyProperty = "id")
    void insertUser(User user);
}

@Update

含义与作用：@Update 用于标注更新语句，关联到接口的方法上，实现数据库的更新操作。

示例：

@Mapper
public interface UserMapper {

    @Update("UPDATE users SET name = #{name}, email = #{email} WHERE id = #{id}")
    void updateUser(User user);
}

@Delete

含义与作用：@Delete 用于标注删除语句，关联到接口的方法上，实现数据库的删除操作。

示例：

@Mapper
public interface UserMapper {

    @Delete("DELETE FROM users WHERE id = #{id}")
    void deleteUser(@Param("id") Long id);
}

参数绑定注解

@Param

含义与作用：@Param 用于给方法参数命名，以便在SQL语句中引用。特别适用于有多个参数的方法。

示例：

@Mapper
public interface UserMapper {

    @Select("SELECT * FROM users WHERE name = #{name} AND age = #{age}")
    List<User> getUsersByNameAndAge(@Param("name") String name, @Param("age") int age);
}

结果映射注解

这些注解用于定义查询结果与Java对象属性的映射关系，适用于字段名与属性名不一致的情况。

@Results 和 @Result

含义与作用：@Results 和 @Result 用于定义查询结果与Java对象属性的映射关系，适用于字段名与属性名不一致的情况。

示例：

@Mapper
public interface UserMapper {

    @Select("SELECT id, user_name, email_address FROM users WHERE id = #{id}")
    @Results({
        @Result(property = "id", column = "id"),
        @Result(property = "name", column = "user_name"),
        @Result(property = "email", column = "email_address")
    })
    User getUserById(@Param("id") Long id);
}

property是程序中定义的属性，column是数据库中定义的字段，将column映射到property中，能够被程序识别出来

关联映射注解

用于定义对象之间的一对一或一对多关系，适用于复杂的对象关系映射。

@One 和 @Many 含义与作用：@One 和 @Many 用于定义一对一和一对多的关联关系，适用于复杂的对象关系映射。

示例：

@Mapper
public interface OrderMapper {

    @Select("SELECT * FROM orders WHERE id = #{id}")
    @Results({
        @Result(property = "id", column = "id"),
        @Result(property = "user", column = "user_id", 
                one = @One(select = "com.example.mapper.UserMapper.getUserById"))
    })
    Order getOrderById(@Param("id") Long id);
}

综合示例

为了更好地理解上述注解的应用，下面通过一个简单的用户管理系统示例，展示Spring Boot与MyBatis如何协同工作。

项目结构

src
├── main
│   ├── java
│   │   └── com.example.demo
│   │       ├── DemoApplication.java
│   │       ├── controller
│   │       │   └── UserController.java
│   │       ├── service
│   │       │   └── UserService.java
│   │       ├── mapper
│   │       │   └── UserMapper.java
│   │       └── model
│   │           └── User.java
│   └── resources
│       └── application.properties

主类

@SpringBootApplication
@MapperScan("com.example.demo.mapper")
public class DemoApplication {
    public static void main(String[] args) {
        SpringApplication.run(DemoApplication.class, args);
    }
}

说明：@MapperScan 指定MyBatis的Mapper接口扫描路径，确保@Mapper接口能够被正确识别和代理。

实体类(POJO)

public class User {
    private Long id;
    private String name;
    private String email;

    // getters and setters
}

Mapper 接口

@Mapper
public interface UserMapper {

    @Select("SELECT * FROM users")
    List<User> getAllUsers();

    @Select("SELECT * FROM users WHERE id = #{id}")
    User getUserById(@Param("id") Long id);

    @Insert("INSERT INTO users(name, email) VALUES(#{name}, #{email})")
    @Options(useGeneratedKeys = true, keyProperty = "id")
    void insertUser(User user);

    @Update("UPDATE users SET name = #{name}, email = #{email} WHERE id = #{id}")
    void updateUser(User user);

    @Delete("DELETE FROM users WHERE id = #{id}")
    void deleteUser(@Param("id") Long id);
}

服务类

@Service
public class UserService {

    @Autowired
    private UserMapper userMapper;

    public List<User> getAllUsers() {
        return userMapper.getAllUsers();
    }

    public User getUserById(Long id) {
        return userMapper.getUserById(id);
    }

    public void createUser(User user) {
        userMapper.insertUser(user);
    }

    public void updateUser(User user) {
        userMapper.updateUser(user);
    }

    public void deleteUser(Long id) {
        userMapper.deleteUser(id);
    }
}

控制器类

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

    @Autowired
    private UserService userService;

    // 获取所有用户
    @GetMapping
    public List<User> listUsers() {
        return userService.getAllUsers();
    }

    // 根据ID获取用户
    @GetMapping("/{id}")
    public ResponseEntity<User> getUser(@PathVariable Long id) {
        User user = userService.getUserById(id);
        if(user != null){
            return ResponseEntity.ok(user);
        } else {
            return ResponseEntity.notFound().build();
        }
    }

    // 创建用户
    @PostMapping
    public ResponseEntity<Void> createUser(@RequestBody User user) {
        userService.createUser(user);
        return ResponseEntity.status(HttpStatus.CREATED).build();
    }

    // 更新用户
    @PutMapping("/{id}")
    public ResponseEntity<Void> updateUser(@PathVariable Long id, @RequestBody User user) {
        user.setId(id);
        userService.updateUser(user);
        return ResponseEntity.ok().build();
    }

    // 删除用户
    @DeleteMapping("/{id}")
    public ResponseEntity<Void> deleteUser(@PathVariable Long id) {
        userService.deleteUser(id);
        return ResponseEntity.noContent().build();
    }
}

配置文件

spring.datasource.url=jdbc:mysql://localhost:3306/[mydb]
spring.datasource.username=root
spring.datasource.password=[secret]
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver

mybatis.configuration.map-underscore-to-camel-case=true

# 显示SQL语句
mybatis.configuration.log-impl=org.apache.ibatis.logging.stdout.StdOutImpl

说明：

map-underscore-to-camel-case=true：自动将数据库下划线命名转换为Java的驼峰命名。

log-impl：设置MyBatis的日志实现，这里使用标准输出日志。

typeAliasesPackage: 配置 MyBatis 的类型别名包路径，用于自动扫描和注册实体类别名,有了这个可以不用写包全名

总结

在Spring Boot + MyBatis项目中，注解的使用极大地简化了配置和开发流程。通过合理运用各种注解，可以实现代码的高内聚低耦合，提升项目的可维护性和扩展性。本文按照功能对Spring Boot和MyBatis中的常用注解进行了分类讲解，并通过一个综合示例展示了它们的实际应用。希望能帮助开发者在实际项目中更好地理解和运用这些注解，构建高效、稳定的应用系统。

附录：常用注解对照表

注解类别	注解名称	作用
核心注解	@SpringBootApplication	标注主类，启用自动配置和组件扫描
组件标识注解	@RestController	标识REST控制器，返回JSON/XML数据
	@Controller	标识MVC控制器，返回视图
	@Service	标识业务逻辑层组件
	@Repository	标识数据访问层组件，提供异常转换
	@Component	通用组件注解
依赖注入注解	@Autowired	自动装配Bean
	@Qualifier	指定注入的具体Bean
	@Inject	实现依赖注入（JSR-330规范）
配置注解	@Configuration	标识配置类
	@Bean	定义Bean
	@Value	注入配置属性值
	@ConfigurationProperties	绑定配置属性到Java对象
事务管理注解	@Transactional	声明事务管理
Web层注解	@RequestMapping	定义请求路径和方法
	@GetMapping	处理GET请求
	@PostMapping	处理POST请求
	@PutMapping	处理PUT请求
	@DeleteMapping	处理DELETE请求
@PathVariable 绑定URL路径变量到方法参数
@RequestParam 绑定请求参数到方法参数
@RequestBody 绑定请求体到方法参数
@ResponseBody 将方法返回值序列化到响应体
MyBatis注解 @Mapper 标识Mapper接口
@Select 定义SELECT语句
@Insert 定义INSERT语句
@Update 定义UPDATE语句
@Delete 定义DELETE语句
@Param 命名方法参数
@Results 定义结果集映射
@Result 定义单个结果映射
@One 定义一对一关联
@Many 定义一对多关联

Spring Boot + MyBatis常用注解

SpringBoot注解

核心注解

组件标识注解

依赖注入注解

配置注解

Spring2.2之后

Lombok

Lombok的核心功能（常用注解）

示例：

1. 未使用Lombok（冗余代码）

2. 使用Lombok（简洁代码）

注意事项

事务管理注解

✅ 仅需 @Transactional 的情况：

✅ 需要加 @Transactional(rollbackFor = Exception.class) 的情况：

🧠 总结对比：

🔍 常见误区提醒：

Web层注解

请求映射注解

参数绑定注解

MyBatis 常用注解

Mapper接口注解

SQL操作注解

参数绑定注解

结果映射注解

关联映射注解

综合示例

总结

✅ 仅需 `@Transactional` 的情况：

✅ 需要加 `@Transactional(rollbackFor = Exception.class)` 的情况：