Spring常用注解速查

本文整理了Spring、Spring MVC和Spring Boot中常用的注解，方便快速查阅和使用。

虽然我认为不是那么简洁明了，但是够用了不是吗？，如果要找具体的注解用法，建议去Spring官方文档查找。

以下内容基于Spring 5.3.20、Spring MVC 5.3.20和Spring Boot 2.6.7版本。

我只是个普通的学习者，但是也是尽可能的收集齐了，在初学者阶段完全够用的。

前置依赖

要使用Spring、Spring MVC和Spring Boot中的注解，需要在项目中添加相应的依赖。以下是常用的依赖配置：

Maven依赖

如果你要找到具体版本的依赖，建议去Maven仓库查找。

<!-- Spring Core -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>5.3.20</version>
</dependency>

<!-- Spring MVC -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-webmvc</artifactId>
    <version>5.3.20</version>
</dependency>

<!-- Spring Boot -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter</artifactId>
    <version>2.6.7</version>
</dependency>

<!-- Spring Boot Web -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
    <version>2.6.7</version>
</dependency>

Gradle依赖

// Spring Core
implementation 'org.springframework:spring-context:5.3.20'

// Spring MVC
implementation 'org.springframework:spring-webmvc:5.3.20'

// Spring Boot
implementation 'org.springframework.boot:spring-boot-starter:2.6.7'

// Spring Boot Web
implementation 'org.springframework.boot:spring-boot-starter-web:2.6.7'

文档导航

我也不知道这个导航能不能在我的站点正常的运行，但是我还是弄了，因为在一般的makedown上是可以正常使用的。

一、Spring核心注解
二、Spring MVC注解
三、Spring Boot注解
四、Spring事务注解
五、Spring安全注解
六、Spring数据访问注解
七、Spring缓存注解
八、Spring部署相关注解

一、Spring核心注解

Spring的核心注解主要包括@Component、@Service、@Repository和@Controller。
他们四个的作用分别是：

@Component：通用组件类，不属于特定层的组件。
@Service：业务逻辑层类，处理核心业务逻辑。
@Repository：数据访问层类，负责数据访问操作。
@Controller：控制层类，处理HTTP请求并返回视图。

但是我说实话，这四个的区别很小，基本上都是一样的，只是语义化不同。他们更大的用途是为了给代码划分标准结构，但是有一些细微的功能区别。

1. `@Component`

作用：标记一个类为Spring容器的组件，使其被自动扫描和管理。
使用场景：通用组件类，不属于特定层（如Service、Repository）的组件。
使用方法：直接标注在类上，无必需参数。
- value（可选）：指定组件的名称，默认为类名首字母小写。

示例：

// 基本使用
@Component
public class UserService {
    // ...
}

// 指定组件名称
@Component("myUserService")
public class UserService {
    // ...
}

2. `@Service`

作用：特殊的@Component，用于标记服务层组件，具有与@Component相同的功能，但更具语义性。
使用场景：业务逻辑层类，处理核心业务逻辑。
使用方法：直接标注在类上，无必需参数。
- value（可选）：指定服务的名称，默认为类名首字母小写。

示例：

// 基本使用
@Service
public class UserServiceImpl implements UserService {
    // ...
}

// 指定服务名称
@Service("userService")
public class UserServiceImpl implements UserService {
    // ...
}

3. `@Repository`

作用：特殊的@Component，用于标记数据访问层组件，除了组件扫描外，还提供了异常转换功能。
使用场景：DAO层或Repository层类，负责数据访问操作。
使用方法：直接标注在接口或类上，无必需参数。
- value（可选）：指定仓库的名称，默认为类名首字母小写。

示例：

// 基本使用（接口）
@Repository
public interface UserRepository extends JpaRepository<User, Long> {
    // ...
}

// 基本使用（类）
@Repository
public class UserDaoImpl implements UserDao {
    // ...
}

// 指定仓库名称
@Repository("userRepo")
public interface UserRepository extends JpaRepository<User, Long> {
    // ...
}

4. `@Controller`

作用：特殊的@Component，用于标记控制层组件，处理HTTP请求并返回视图。
使用场景：MVC模式中的控制器类，传统Web应用的请求处理。
使用方法：直接标注在类上，无必需参数。
- value（可选）：指定控制器的名称，默认为类名首字母小写。

示例：

// 基本使用
@Controller
public class UserController {
    // ...
}

// 指定控制器名称
@Controller("userCtrl")
public class UserController {
    // ...
}

从这里开始往下的就是功能性注解，是非常常用的注解，也是超级重要的注解。

5. `@Autowired`

作用：自动注入依赖对象，Spring会根据类型匹配最合适的Bean进行注入。
使用场景：需要注入其他Spring管理的Bean时，可用于字段、构造函数或setter方法。
使用方法：
- 标注在字段上：直接在需要注入的字段前添加注解
- 标注在构造函数上：在构造函数前添加注解，适合强制依赖
- 标注在setter方法上：在setter方法前添加注解
- required（可选）：是否必须注入，默认为true，若为false且无匹配Bean则注入null

示例：

// 字段注入
@Service
public class UserServiceImpl implements UserService {
    @Autowired
    private UserRepository userRepository;
    // ...
}

// 构造函数注入（推荐）
@Service
public class UserServiceImpl implements UserService {
    private final UserRepository userRepository;

    @Autowired
    public UserServiceImpl(UserRepository userRepository) {
        this.userRepository = userRepository;
    }
    // ...
}

// 可选注入
@Service
public class UserServiceImpl implements UserService {
    @Autowired(required = false)
    private UserRepository userRepository;
    // ...
}

6. `@Qualifier`

作用：当存在多个同类型的Bean时，指定要注入的Bean名称，解决依赖注入的歧义性。
使用场景：与@Autowired配合使用，当一个接口有多个实现类时。
使用方法：
- 必须与@Autowired一起使用
- value（必需）：指定要注入的Bean的名称

示例：

// 基本使用
@Service
public class UserServiceImpl implements UserService {
    @Autowired
    @Qualifier("userRepositoryImpl")
    private UserRepository userRepository;
    // ...
}

// 构造函数注入
@Service
public class UserServiceImpl implements UserService {
    private final UserRepository userRepository;

    @Autowired
    public UserServiceImpl(@Qualifier("userRepositoryImpl") UserRepository userRepository) {
        this.userRepository = userRepository;
    }
    // ...
}

7. `@Value`

作用：注入配置文件中的属性值或SpEL表达式计算结果。
使用场景：需要读取配置文件中的值或使用SpEL表达式时。
使用方法：
- value（必需）：配置属性键（如”${app.name}”）或SpEL表达式（如”#{systemProperties[‘user.name’]}”）

示例：

// 注入配置属性
@Component
public class AppConfig {
    @Value("${app.name}")
    private String appName;

    @Value("${app.version:1.0.0}")  // 带默认值
    private String appVersion;
    // ...
}

// 注入SpEL表达式结果
@Component
public class SystemInfo {
    @Value("#{systemProperties['user.name']}")
    private String currentUser;

    @Value("#{T(java.lang.Math).random() * 100}")
    private double randomNumber;
    // ...
}

8. `@Configuration`

作用：标记一个类为配置类，替代XML配置文件。
使用场景：Spring配置类。

示例：

@Configuration
public class AppConfig {
    // ...
}

9. `@Bean`

作用：在配置类中定义一个Bean，Spring会将返回的对象纳入容器管理。
使用场景：需要显式配置Bean时，尤其是第三方库的类或需要复杂初始化的Bean。
使用方法：
- 标注在配置类的方法上
- name/value（可选）：指定Bean的名称，默认为方法名
- initMethod（可选）：指定Bean初始化后调用的方法
- destroyMethod（可选）：指定Bean销毁前调用的方法
- autowire（可选）：指定自动装配模式

示例：

// 基本使用
@Configuration
public class AppConfig {
    @Bean
    public UserService userService() {
        return new UserServiceImpl();
    }
}

// 指定Bean名称和生命周期方法
@Configuration
public class AppConfig {
    @Bean(name = "myUserService", initMethod = "init", destroyMethod = "destroy")
    public UserService userService() {
        return new UserServiceImpl();
    }
}

// 依赖其他Bean
@Configuration
public class AppConfig {
    @Bean
    public UserService userService(UserRepository userRepository) {
        UserServiceImpl service = new UserServiceImpl();
        service.setUserRepository(userRepository);
        return service;
    }
}

二、Spring MVC注解

1. `@RestController`

作用：组合@Controller和@ResponseBody，标记一个类为RESTful控制器，所有方法的返回值都会自动转换为JSON/XML响应体。
使用场景：RESTful API的控制器类，不需要返回视图的情况。
使用方法：直接标注在类上，无必需参数。
- value（可选）：指定控制器的名称，默认为类名首字母小写。

示例：

// 基本使用
@RestController
@RequestMapping("/api/users")
public class UserRestController {
    @GetMapping
    public List<User> getAllUsers() {
        // ...
    }
}

// 指定控制器名称
@RestController("userApiController")
@RequestMapping("/api/users")
public class UserRestController {
    // ...
}

2. `@RequestMapping`

作用：映射HTTP请求到控制器方法，可指定URL、HTTP方法、请求参数等条件。
使用场景：定义控制器方法的请求路径和HTTP方法，适用于各种HTTP请求类型。
使用方法：
- value/path（可选）：指定请求的URL路径，支持数组形式多个路径
- method（可选）：指定HTTP请求方法，如GET、POST、PUT、DELETE等
- params（可选）：指定请求必须包含的参数
- headers（可选）：指定请求必须包含的头信息
- consumes（可选）：指定请求体的媒体类型，如”application/json”
- produces（可选）：指定响应体的媒体类型

示例：

// 基本使用
@RequestMapping(value = "/users", method = RequestMethod.GET)
public List<User> getAllUsers() {
    // ...
}

// 多个路径
@RequestMapping(value = {"/users", "/api/users"}, method = RequestMethod.GET)
public List<User> getAllUsers() {
    // ...
}

// 指定参数和头信息
@RequestMapping(value = "/users", method = RequestMethod.GET,
    params = {"page", "size"}, headers = "Accept=application/json")
public List<User> getUsersByPage(@RequestParam int page, @RequestParam int size) {
    // ...
}

3. `@GetMapping`, `@PostMapping`, `@PutMapping`, `@DeleteMapping`

作用：分别对应HTTP的GET、POST、PUT、DELETE方法的快捷注解。
使用场景：替代@RequestMapping并指定HTTP方法。

示例：

@GetMapping("/users/{id}")
public User getUserById(@PathVariable Long id) {
    // ...
}

4. `@PathVariable`

作用：获取URL路径中的参数值，将路径中的占位符映射到方法参数。
使用场景：RESTful API中获取路径参数，如/users/{id}中的id。
使用方法：
- 标注在方法参数上
- value/name（可选）：指定路径中占位符的名称，若参数名与占位符名一致可省略
- required（可选）：是否必须，默认为true

示例：

// 基本使用
@GetMapping("/users/{id}")
public User getUserById(@PathVariable Long id) {
    // ...
}

// 指定参数名
@GetMapping("/users/{userId}")
public User getUserById(@PathVariable("userId") Long id) {
    // ...
}

// 可选参数
@GetMapping("/users/{id:\d+}?")
public User getUserById(@PathVariable(required = false) Long id) {
    // ...
}

// 多个参数
@GetMapping("/users/{id}/posts/{postId}")
public Post getUserPost(@PathVariable Long id, @PathVariable Long postId) {
    // ...
}

5. `@RequestParam`

作用：获取HTTP请求参数的值，包括查询参数和表单参数。
使用场景：获取查询参数或表单参数，如/users?page=0&size=10中的page和size。
使用方法：
- 标注在方法参数上
- value/name（可选）：指定请求参数的名称，若参数名与请求参数名一致可省略
- required（可选）：是否必须，默认为true
- defaultValue（可选）：默认值，当参数不存在时使用

示例：

// 基本使用
@GetMapping("/users")
public List<User> getUsersByPage(@RequestParam int page, @RequestParam int size) {
    // ...
}

// 指定参数名和默认值
@GetMapping("/users")
public List<User> getUsersByPage(@RequestParam(name = "page", defaultValue = "0") int page, 
                               @RequestParam(name = "size", defaultValue = "10") int size) {
    // ...
}

// 可选参数
@GetMapping("/search")
public List<User> searchUsers(@RequestParam(required = false) String keyword) {
    // ...
}

// 数组参数
@GetMapping("/users")
public List<User> getUsersByIds(@RequestParam List<Long> ids) {
    // ...
}

6. `@RequestBody`

作用：将HTTP请求体转换为Java对象，通常用于处理JSON或XML格式的数据。
使用场景：处理POST、PUT等请求中的JSON或XML数据，如创建或更新资源。
使用方法：
- 标注在方法参数上
- required（可选）：是否必须有请求体，默认为true

示例：

// 基本使用
@PostMapping("/users")
public User createUser(@RequestBody User user) {
    // ...
}

// 可选请求体
@PostMapping("/users")
public User createUser(@RequestBody(required = false) User user) {
    // ...
}

// 处理特定媒体类型
@PostMapping(value = "/users", consumes = "application/json")
public User createUser(@RequestBody User user) {
    // ...
}

7. `@ResponseBody`

作用：将控制器方法的返回值转换为HTTP响应体。
使用场景：返回JSON或XML数据。

示例：

@Controller
public class UserController {
    @GetMapping("/users/{id}")
    @ResponseBody
    public User getUserById(@PathVariable Long id) {
        // ...
    }
}

三、Spring Boot注解

1. `@SpringBootApplication`

作用：组合@Configuration、@EnableAutoConfiguration和@ComponentScan三个注解，标记Spring Boot应用的主类。
使用场景：Spring Boot应用的入口类，通常包含main方法。
使用方法：
- scanBasePackages（可选）：指定组件扫描的基础包路径
- scanBasePackageClasses（可选）：指定组件扫描的基础类
- exclude（可选）：排除特定的自动配置类
- excludeName（可选）：排除特定名称的自动配置类

示例：

// 基本使用
@SpringBootApplication
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

// 自定义扫描路径
@SpringBootApplication(scanBasePackages = "com.example.app")
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

// 排除特定自动配置
@SpringBootApplication(exclude = {DataSourceAutoConfiguration.class})
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

2. `@EnableAutoConfiguration`

作用：启用Spring Boot的自动配置机制。
使用场景：通常与@Configuration一起使用。

示例：

@Configuration
@EnableAutoConfiguration
public class AppConfig {
    // ...
}

3. `@ComponentScan`

作用：指定Spring扫描组件的包路径。
使用场景：需要自定义组件扫描范围时。

示例：

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

4. `@ConfigurationProperties`

作用：将配置文件中的属性绑定到Java对象。
使用场景：读取复杂的配置信息。

示例：

@Component
@ConfigurationProperties(prefix = "app")
public class AppProperties {
    private String name;
    private String version;
    // getters and setters
}

5. `@EnableConfigurationProperties`

作用：启用@ConfigurationProperties注解的类。
使用场景：当@ConfigurationProperties标注的类没有被@Component标注时。

示例：

@Configuration
@EnableConfigurationProperties(AppProperties.class)
public class AppConfig {
    // ...
}

6. `@Profile`

作用：指定Bean在特定环境下才会被创建。
使用场景：多环境配置。

示例：

@Configuration
@Profile("dev")
public class DevConfig {
    // ...
}

7. `@Conditional`

作用：根据条件决定是否创建Bean。
使用场景：需要根据特定条件动态创建Bean时。

示例：

@Configuration
public class AppConfig {
    @Bean
    @ConditionalOnProperty(name = "app.feature.enabled", havingValue = "true")
    public FeatureService featureService() {
        return new FeatureServiceImpl();
    }
}

8. `@EnableAsync`

作用：启用Spring的异步方法执行功能。
使用场景：需要执行异步任务时。

示例：

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

@Service
public class AsyncService {
    @Async
    public CompletableFuture<String> doAsyncTask() {
        // 异步执行的任务
        return CompletableFuture.completedFuture("任务完成");
    }
}

9. `@EnableScheduling`

作用：启用Spring的任务调度功能。
使用场景：需要执行定时任务时。

示例：

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

@Service
public class ScheduledService {
    @Scheduled(cron = "0 0 12 * * ?") // 每天中午12点执行
    public void scheduledTask() {
        // 定时执行的任务
    }
}

10. `@SpringBootTest`

作用：用于Spring Boot应用的测试，提供Spring Boot特性的支持。
使用场景：Spring Boot应用的集成测试。

示例：

@SpringBootTest
public class ApplicationTests {
    @Autowired
    private UserService userService;

    @Test
    public void testUserService() {
        // 测试代码
    }
}

四、Spring事务注解

1. `@Transactional`

作用：标记方法或类需要在事务中执行，保证数据库操作的原子性、一致性、隔离性和持久性。
使用场景：需要保证数据一致性的操作，如数据库更新、插入、删除等。
使用方法：
- value（可选）：指定事务管理器的名称
- propagation（可选）：指定事务传播行为，如REQUIRED、SUPPORTS、MANDATORY等
- isolation（可选）：指定事务隔离级别，如DEFAULT、READ_UNCOMMITTED、READ_COMMITTED等
- timeout（可选）：指定事务超时时间（秒）
- readOnly（可选）：指定事务是否为只读
- rollbackFor（可选）：指定触发回滚的异常类型
- noRollbackFor（可选）：指定不触发回滚的异常类型

示例：

// 基本使用
@Service
public class UserServiceImpl implements UserService {
    @Autowired
    private UserRepository userRepository;

    @Transactional
    public void createUser(User user) {
        userRepository.save(user);
        // 其他数据库操作
    }
}

// 自定义事务属性
@Service
public class UserServiceImpl implements UserService {
    @Autowired
    private UserRepository userRepository;

    @Transactional(propagation = Propagation.REQUIRED,
                   isolation = Isolation.READ_COMMITTED,
                   timeout = 30,
                   readOnly = false,
                   rollbackFor = Exception.class)
    public void createUser(User user) {
        userRepository.save(user);
        // 其他数据库操作
    }
}

五、Spring安全注解

1. `@EnableWebSecurity`

作用：启用Spring Security的Web安全支持。
使用场景：Web应用的安全配置。

示例：

@Configuration
@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {
    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http
            .authorizeRequests()
                .antMatchers("/public/**").permitAll()
                .anyRequest().authenticated()
            .and()
            .formLogin();
    }
}

2. `@PreAuthorize`, `@PostAuthorize`

作用：方法执行前/后进行权限检查。
使用场景：需要细粒度权限控制的方法。

示例：

@Service
public class UserServiceImpl implements UserService {
    @PreAuthorize("hasRole('ADMIN')")
    public void deleteUser(Long id) {
        // 删除用户操作
    }
}

六、Spring数据访问注解

1. `@Entity`, `@Table`

作用：@Entity标记一个类为JPA实体；@Table指定实体对应的数据库表。
使用场景：JPA实体类定义。

示例：

@Entity
@Table(name = "users")
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String username;
    private String email;
    // getters and setters
}

2. `@Id`, `@GeneratedValue`

作用：@Id标记实体的主键；@GeneratedValue指定主键生成策略。
使用场景：定义实体主键。

示例：

1
2
3

@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;

七、Spring缓存注解

1. `@EnableCaching`

作用：启用Spring的缓存机制。
使用场景：需要使用缓存提升性能时。

示例：

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

2. `@Cacheable`, `@CacheEvict`, `@CachePut`

作用：
- @Cacheable：方法结果存入缓存
- @CacheEvict：清除缓存
- @CachePut：更新缓存
使用场景：缓存频繁访问的数据。

示例：

@Service
public class UserServiceImpl implements UserService {
    @Cacheable(value = "users", key = "#id")
    public User getUserById(Long id) {
        // 从数据库获取用户
        return userRepository.findById(id).orElse(null);
    }

    @CacheEvict(value = "users", key = "#id")
    public void deleteUser(Long id) {
        userRepository.deleteById(id);
    }
}

八、Spring部署相关注解

1. `@ConditionalOnClass`, `@ConditionalOnMissingClass`

作用：根据类是否存在决定是否创建Bean。
使用场景：根据依赖库动态配置Bean。

示例：

@Configuration
public class AppConfig {
    @Bean
    @ConditionalOnClass(name = "com.example.Feature")
    public FeatureService featureService() {
        return new FeatureServiceImpl();
    }
}

2. `@ConditionalOnWebApplication`, `@ConditionalOnNotWebApplication`

作用：根据是否是Web应用决定是否创建Bean。
使用场景：区分Web和非Web环境的配置。

示例：

@Configuration
public class AppConfig {
    @Bean
    @ConditionalOnWebApplication
    public WebService webService() {
        return new WebServiceImpl();
    }
}

以上是Spring生态系统中常用的注解，涵盖了核心功能、MVC、Boot、事务、安全、数据访问、缓存和部署等各个方面。每个注解都提供了详细的作用说明、使用场景和完整的代码示例，帮助您更好地理解和使用Spring框架。后续会持续更新和补充更多实用注解。，我觉得是不用再补充了QAQ，看官方文档去吧。

Spring常用注解速查

前置依赖

Maven依赖

Gradle依赖

文档导航

一、Spring核心注解

1. @Component

2. @Service

3. @Repository

4. @Controller

5. @Autowired

6. @Qualifier

7. @Value

8. @Configuration

9. @Bean

二、Spring MVC注解

1. @RestController

2. @RequestMapping

3. @GetMapping, @PostMapping, @PutMapping, @DeleteMapping

4. @PathVariable

5. @RequestParam

6. @RequestBody

7. @ResponseBody

三、Spring Boot注解

1. @SpringBootApplication

2. @EnableAutoConfiguration

3. @ComponentScan

4. @ConfigurationProperties

5. @EnableConfigurationProperties

6. @Profile

7. @Conditional

8. @EnableAsync

9. @EnableScheduling

10. @SpringBootTest