Spring & Spring Boot 常用注解整理收藏

目录

• 先理解核心概念：什么是注解（Annotation）？
• 第一部分：IOC（控制反转）和 DI（依赖注入）
• 1. @Component
• 2. @Service, @Repository, @Controller
• 3. @Autowired
• 4. @Qualifier
• 第二部分：Spring MVC（处理 HTTP 请求）
• 1. @RestController vs @Controller
• 2. @GetMapping / @PostMapping
• 3. @PathVariable 和 @RequestParam
• 第三部分：配置相关注解
• 1. @Configuration 和 @Bean
• 2. @Value
• 第四部分：Spring Boot 核心注解
• 第五部分：数据库和事务
• 1. @Entity 和 @Id
• 2. @Transactional
• 第六部分：AOP（面向切面编程）
• 1. @ASPect 和 @Before

先理解核心概念：什么是注解（Annotation）？

类比：注解就像代码里的“便利贴”，用来告诉 Spring 框架：“这个类/方法/变量有什么特殊用途”。

作用：简化配置，让框架自动帮你处理一些事情（比如创建对象、管理依赖、处理请求等）。

第一部分：IOC（控制反转）和 DI（依赖注入）

核心思想：把对象的创建和管理交给 Spring 容器，而不是自己手动 new 对象。

1. @Component

作用：告诉 Spring：“这个类交给你管理，我需要的时候找你要实例”。

代码示例：

@Component  // 贴上这个标签，Spring 就会自动创建 MyComponent 的实例（Bean）
public class MyComponent {
    public void hello() {
        System.out.println("Hello from MyComponent!");
    }
}

使用场景：通用的工具类、第三方库的适配类等。

2. @Service, @Repository, @Controller

本质：它们都是 @Component 的“马甲”，用途相同，只是名字不同，为了代码可读性。

• @Service：标记业务逻辑层（如处理用户注册、订单支付）。
• @Repository：标记数据访问层（如操作数据库）。
• @Controller：标记 Web 控制器（处理 HTTP 请求）。

代码对比：

@Service
public class UserService {  // 业务逻辑层
    public void registerUser(String name) { ... }
}
@Repository
public class UserDao {  // 数据访问层
    public User findUserById(Long id) { ... }
}
@Controller
public class UserController {  // 处理 HTTP 请求
    @GetMapping("/users")
    public String listUsers() { ... }
}

3. @Autowired

作用：让 Spring 自动帮你“注入”依赖的 Bean（类似找人借东西，不用自己造）。

代码示例：

@Service
public class UserService {
    @Autowired  // Spring 会自动找一个 UserDao 的 Bean 注入到这里
    private UserDao userDao;
    public User findUser(Long id) {
        return userDao.findUserById(id);  // 直接使用 userDao，不需要 new UserDao()
    }
}

原理：Spring 会在容器中查找匹配类型的 编程客栈Bean，自动赋值给 userDao。

4. @Qualifier

问题场景：如果有多个同类型的 Bean，Spring 不知道注入哪一个。

解决：用 @Qualifier 指定 Bean 的名字。

代码示例：

// 定义两个数据源
@Component("mysqlDataSource")
public class MySQLDataSource implements DataSource { ... }
@Component("postgresDataSource")
public class PostgresDataSource implements DataSource { ... }
// 使用时指定名称
@Service
public class DataService {
    @Autowired
    @Qualifier("mysqlDataSource")  // 明确告诉 Spring 注入名为 "mysqlDataSource" 的 Bean
    private DataSource dataSource;
}

第二部分：Spring MVC（处理 HTTP 请求）

1. @RestController vs @Controller

• @Controller：传统 MVC 控制器，返回视图（如 JSP 页面）。
• @RestController：专门用于 REST API，直接返回 JSON 数据（内部包含 @ResponseBody）。

代码对比：

// 传统 Controller（返回视图名，由模板引擎渲染）
@Controller
public class OldController {
    @GetMapping("/hello")
    public String hello() {
        return "hello-page";  // 对应 src/main/resources/templates/hello-page.html
    }
}
// REST Controller（返回 JSON）
@RestController
public class ApiController {
    @GetMapping("/user")
    public User getUser() {
        return new User(1, "Alice");  // 自动转换为 JSON：{ "id": 1, "name": "Alice" }
    }
}

2. @GetMapping / @PostMapping

作用：简化 HTTP 请求映射，替代 @RequestMapping(method=RequestMethod.GET)。

代码示例：

@RestController
public class UserController {
    // 处理 GET 请求：http://localhost:8080/users
    @GetMapping("/users")
    public List<User> listUsers() {
        return userService.getAllUsers();
    }
    // 处理 POST 请求：http://localhost:8080/users
    @PostMapping("/users")
    public User createUser(@RequestBody User user) {  // @RequestBody 表示接收 JSON 数据
        return userService.saveUser(user);
    }
}

3. @PathVariable 和 @RequestParam

• @PathVariable：从 URL 路径中获取变量（如 /users/123 中的 123）。
• @RequestParam：从 URL 参数中获取值（如 /search?keyword=java 中的 keyword）。

代码示例：

@GetMapping("/users/{id}")  // URL 模板：{id} 是占位符
public User getUserById(@PathVariable Long id) {  // 获取路径中的 id
    return userService.findById(id);
}
@GetMapping("/search")
public List<User> searchUsers(@RequestParam String keyword) {  // 获取参数 ?keyword=xxx
    return userService.search(keyword);
}

第三部分：配置相关注解

1. @Configuration 和 @Bean

作用：替代 XML 配置文件，手动定义 Bean。

代码示例：

@Configuration  // 告诉 Spring：“这是一个配置类”
public class AppConfig {
    @Bean  // 这个方法返回的对象会被 Spring 管理
    public DataSource dataSource() {
        return new HikariDataSource();  // 手动创建一个数据源
    }
}

2. @Value

作用：从配置文件（如 application.properties）中读取值。

示例：

# application.properties
app.name=My Awesome App
database.url=jdbc:mysql://localhost:3306/mydb

@Component
public class AppConfig {
    @Value("${app.name}")  // 注入 app.name 的值
    private String appName;
    @Value("${database.url}")  // 注入数据库 URL
    private String dbUrl;
}

第四部分：Spring Boot 核心注解

作用：标记启动类，包含三个核心功能：

• @Configuration：这是一个配置类。
• @EnableAutoConfiguration：开启自动配置（如自动配置数据库连接池）。
• @ComponentScan：自动扫描当前包及子包下的组件（@Component, @Service 等）。

代码示例：

@SpringBootApplication  // 一切从这里开始
public class MyApplication {
    public static void main(String[] args) {
        SpringApplication.run(MyApplication.class, args);  // 启动 Spring Boot 应用
    }
}

第五部分：数据库和事务

1. @Entity 和 @Id

作用：标记 JPA 实体类（对应数据库表）和主键字段。

代码示例：

@Entity  // 告诉 Spring：“这是一个数据库表对应的实体类”
public class User {
    @Id  // 标记为主键
    private Long id;
    private String name;
    // 省略 getter/setter
}

2. @Transactional

作用：声明事务，确保方法内的数据库操作要么全部成功，要么全部回滚。

代码示例：

@Service
public class OrderService {
    @Autowired
    private OrderRepository orderRepository;
    @Transactional  // 开启事务
    public void placeOrder(Order order) {
        orderRepository.save(order);  // 保存订单
        // 如果这里抛出异常（如库存不足），整个事务会回滚，订单不会被保存
    }
}

第六部分：AOP（面向切面编程）

核心思想：在不修改原有代码的情况下，统一处www.devze.com理日志、权限、事务等横切关注点。

1. @Aspect 和 @Before

代码示例：

@Aspect   // 告诉 Spring：“这是一个切面类”
@Component
public class LoggingAspect {
    // 定义切入点：拦截所有 Service 层的方法
    @Pointcut("execution(* com.example.service.*.*(..))")
    public void serviceMethods() {}
    // 前置通知：在方法执行前打印日志
    @Before("serviceMethods()")
    public void logBefore(JoinPoint joinPoint) {
        String methodName = joinPoint.getSignature().getName();
        System.out.println("准备执行方法：" + methodName);
    }
}

总结：注解的核心作用

到此这篇关于Spring & Spring Boot 常用注解整理的文章就介绍到这了,更多相关Spring Boot 常用注解内容请搜索编程客栈(www.devze.com)以前的文章或继续浏览php下面的相关文章希望大家以后多多支持编程客栈(www.devze.com)！