SpringBoot注解

文章参考补充：SpringBoot 注解最全详解，建议收藏！

SpringMVC 相关注解

• @Controller
  通常用于修饰controller层的组件，由控制器负责将用户发来的URL请求转发到对应的服务接口，通常还需要配合注解@RequestMapping使用。

• @RequestMapping
  提供路由信息，负责URL到Controller中具体函数的映射，当用于方法上时，可以指定请求协议，比如GET、POST、PUT、DELETE等。

• @RequestBody
  表示请求体的Content-Type必须为application/json格式的数据，接收到数据之后会自动将数据绑定到Java对象上去。

• @ResponseBody
  表示该方法的返回结果直接写入HTTP response body中，返回数据的格式为application/json。

  比如，请求参数为json格式，返回参数也为json格式，示例代码如下：

  /**
   * 登录服务
   */
  @Controller
  @RequestMapping("api")
  public class LoginController {
    
      /**
       * 登录请求，post请求协议，请求参数数据格式为json
       * @param request
       */    
      @RequestMapping(value = "login", method = RequestMethod.POST)    
      @ResponseBody    
      public ResponseEntity login(@RequestBody UserLoginDTO request){        
          //...业务处理        
          return new ResponseEntity(HttpStatus.OK);
      }
  }
  

@RestController

和@Controller一样，用于标注控制层组件，不同的地方在于：它是@ResponseBody和@Controller的合集，也就是说，当@RestController用在类上时，表示当前类里面所有对外暴露的接口方法，返回数据的格式都为application/json。

示范代码如下：

@RestController
@RequestMapping("api")
public class LoginController {
  
    /**
     * 登录请求，post请求协议，请求参数数据格式为json
     * @param request
     */    
    @RequestMapping(value = "login", method = RequestMethod.POST)    
    public ResponseEntity login(@RequestBody UserLoginDTO request){        
        //...业务处理        
        return new ResponseEntity(HttpStatus.OK);
    }
}

@RequestParam

用于接收请求参数为表单类型的数据，通常用在方法的参数前面，示范代码如下：

/**
 * 登录请求，post请求协议，请求参数数据格式为表单
 */
@RequestMapping(value = "login", method = RequestMethod.POST)
@ResponseBody
public ResponseEntity login(@RequestParam(value = "userName",required = true) String userName,
                            @RequestParam(value = "userPwd",required = true) String userPwd){    
    //...业务处理    
    return new ResponseEntity(HttpStatus.OK);
}

• @PathVariable
  用于获取请求路径中的参数，通常用于RESTful风格的api上，示范代码如下：

  /**
   * restful风格的参数请求
   * @param id
   */
  @RequestMapping(value = "queryProduct/{id}", method = RequestMethod.POST)
  @ResponseBody
  public ResponseEntity queryProduct(@PathVariable("id") String id){    
      //...业务处理    
      return new ResponseEntity(HttpStatus.OK);
  }
  

@GetMapping

除了@RequestMapping可以指定请求方式之外，还有一些其他的注解，可以用于标注接口路径请求，比如GetMapping用在方法上时，表示只支持get请求方法，等价于@RequestMapping(value="/get",method=RequestMethod.GET)。

@GetMapping("get")
public ResponseEntity get(){    
    return new ResponseEntity(HttpStatus.OK);
}

@PostMapping

用在方法上，表示只支持post方式的请求。

@PostMapping("post")
public ResponseEntity post(){    
    return new ResponseEntity(HttpStatus.OK);
}

@PutMapping

用在方法上，表示只支持put方式的请求，通常表示更新某些资源的意思。

@PutMapping("put")
public ResponseEntity put(){    
    return new ResponseEntity(HttpStatus.OK);
}

@DeleteMapping

用在方法上，表示只支持delete方式的请求，通常表示删除某些资源的意思。

@DeleteMapping("delete")
public ResponseEntity delete(){    
    return new ResponseEntity(HttpStatus.OK);
}

Bean 相关注解

@Service

通常用于修饰service层的组件，声明一个对象，会将类对象实例化并注入到bean容器里面。

@Service
public class DeptService {
    // 具体的方法
}

@Component

泛指组件，当组件不好归类的时候，可以使用这个注解进行标注，功能类似于@Service。

@Component
public class DeptService {
    // 具体的方法
}

@Repository

通常用于修饰dao层的组件，@Repository注解属于Spring里面最先引入的一批注解，它用于将数据访问层 (DAO层) 的类标识为Spring Bean，具体只需将该注解标注在DAO类上即可。

示例代码如下：

@Repository
public interface RoleRepository extends JpaRepository<Role, Long> {
    // 具体的方法
}

@Bean

相当于xml中配置Bean，意思是产生一个bean对象，并交给Spring管理，示例代码如下：

@Configuration
public class AppConfig {
    @Bean
    public Uploader initFileUploader() {
        return new FileUploader();
    }
}

@Autowired

自动导入依赖的bean对象，默认时按照byType方式导入对象，而且导入的对象必须存在。当需要导入的对象并不存在时，我们可以通过配置required = false来关闭强制验证。

@Autowired
private DeptService deptService;

@Resource

也是自动导入依赖的bean对象，由JDK提供，默认是按照byName方式导入依赖的对象；而@Autowired默认时按照byType方式导入对象，当然@Resource还可以配置成通过byType方式导入对象。

示例代码：

// 通过名称导入（默认通过名称导入依赖对象）
@Resource(name = "deptService")
private DeptService deptService;

// 通过类型导入
@Resource(type = RoleRepository.class)
private DeptService deptService;

@Qualifier

当有多个同一类型的bean时，使用@Autowired导入会报错，提示当前对象并不是唯一，Spring不知道导入哪个依赖，这个时候，我们可以使用@Qualifier进行更细粒度的控制，选择其中一个候选者，一般于@Autowired搭配使用。

示例代码：

@Autowired
@Qualifier("deptService")
private DeptService deptService;

@Scope

用于声明一个spring bean的作用域，作用的范围一共有以下几种：

• singleton：唯一bean实例，Spring中的bean默认都是单例的。
• prototype：每次请求都会创建一个新的bean实例，对象多例。
• request：每一次HTTP请求都会产生一个新的bean，该bean仅在当前HTTP request内有效。
• session：每一次HTTP请求都会产生一个新的bean，该bean仅在当前HTTP session内有效。

示例代码：

@RestController
@Scope("singleton")
public class HelloController {
    // Controller methods
}

JPA 相关注解

@Entity 和 @Table

表明这是一个实体类，这两个注解一般一块使用，但是如果表名和实体类名相同的话，@Table可以省略。

@Id

表示该属性字段对应数据库表中的主键字段。

@Column

表示该属性字段对应的数据库表中的列名，如果字段名与列名相同，则可以省略。

@GeneratedValue

表示主键的生成策略，有四个选项，分别如下：

• AUTO：表示由程序控制，是默认选项，不设置就是这个。
• IDENTITY：表示由数据库生成，采用数据库自增长，Oracle不支持这种方式。
• SEQUENCE：表示通过数据库的序列生成主键ID，MYSQL不支持。
• Table：表示由特

定的数据库产生主键，该方式有利于数据库的移植。

@SequenceGenerator

用来定义一个生成主键的序列，它需要与@GeneratedValue联合使用才有效。

示例代码：

@Entity
@Table(name = "TB_ROLE")
@SequenceGenerator(name = "id_seq", sequenceName = "seq_repair", allocationSize = 1)
public class Role implements Serializable {
    private static final long serialVersionUID = 1L;

    /**
     * 主键ID，采用【id_seq】序列函数自增长
     */    
    @Id
    @GeneratedValue(strategy = GenerationType.SEQUENCE, generator = "id_seq")
    private Long id;

    /**
     * 角色名称
     */    
    @Column(nullable = false)
    private String roleName;

    /**
     * 角色类型
     */    
    @Column(nullable = false)
    private String roleType;
}

@Transient

表示该属性并非与数据库表的字段进行映射，ORM框架会将忽略该属性。

示例代码：

@Column(nullable = false)
@Transient
private String lastTime;

@Basic(fetch=FetchType.LAZY)

用在某些属性上，可以实现懒加载的效果，也就是当用到这个字段的时候，才会装载这个属性。如果配置成fetch=FetchType.EAGER，表示即时加载，也是默认的加载方式！

示例代码：

@Column(nullable = false)
@Basic(fetch = FetchType.LAZY)
private String roleType;

@JoinColumn

用于标注表与表之间关系的字段，通常与@OneToOne、@OneToMany搭配使用。

示例代码：

@Entity
@Table(name = "tb_login_log")
public class LoginLog implements Serializable {

    /**
     * 查询登录的用户信息
     */    
    @OneToOne    
    @JoinColumn(name = "user_id")
    private User user;
}

@OneToOne、@OneToMany 和 @ManyToOne

这三个注解，相当于hibernate配置文件中的一对一、一对多、多对一配置，比如下面的客户地址表，通过客户ID实现客户信息的查询。

示例代码：

@Entity
@Table(name = "address")
public class AddressEO implements java.io.Serializable {

    @ManyToOne(cascade = { CascadeType.ALL })
    @JoinColumn(name = "customer_id")
    private CustomerEO customer;
}

配置相关注解

@Configuration

表示声明一个Java形式的配置类，Spring Boot提倡基于Java的配置，相当于你之前在xml中配置bean，比如声明一个配置类AppConfig，然后初始化一个Uploader对象。

示例代码：

@Configuration
public class AppConfig {

    @Bean
    public Uploader initOSSUploader() {
        return new OSSUploader();
    }
}

@EnableAutoConfiguration

@EnableAutoConfiguration可以帮助Spring Boot应用将所有符合条件的@Configuration配置类，全部都加载到当前Spring Boot里，并创建对应配置类的Bean，并把该Bean实体交给IoC容器进行管理。

示例代码：

@Configuration
@EnableAutoConfiguration(exclude = { SecurityAutoConfiguration.class })
public class AppConfig {
    // 业务方法
}

@ComponentScan

标注哪些路径下的类需要被Spring扫描，用于自动发现和装配一些Bean对象，默认配置是扫描当前文件夹下和子目录下的所有类。如果我们想指定扫描某些包路径，可以这样处理。

示例代码：

@ComponentScan(basePackages = {"com.xxx.a", "com.xxx.b", "com.xxx.c"})

@SpringBootApplication

等价于使用@Configuration、@EnableAutoConfiguration、@ComponentScan这三个注解，通常用于全局启动类上。

示例代码：

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

@EnableTransactionManagement

表示开启事务支持，等同于xml配置方式的<tx:annotation-driven />。

示例代码：

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

@Conditional

从Spring4开始，可以通过@Conditional注解实现按条件装载bean对象。目前Spring Boot源码中大量扩展了@Condition注解，用于实现智能的自动化配置，满足各种使用场景。

示例代码：

@Configuration
public class ConditionalConfig {

    @ConditionalOnBean(AppConfig.class)
    @Bean
    public A createA() {
        return new A();
    }

    @ConditionalOnMissingBean(AppConfig.class)
    @Bean
    public B createB() {
        return new B();
    }

    @ConditionalOnClass(KafkaTemplate.class)
    @Bean
    public C createC() {
        return new C();
    }

    @ConditionalOnMissingClass(KafkaTemplate.class)
    @Bean
    public D createD() {
        return new D();
    }

    @ConditionalOnExpression("${enableConfig:false}")
    @Bean
    public E createE() {
        return new E();
    }

    @ConditionalOnProperty(prefix = "filter", name = "loginFilter", havingValue = "true")
    @Bean
    public F createF() {
        return new F();
    }
}

@Value

可以在任意Spring管理的Bean中通过这个注解获取任何来源配置的属性值，比如你在application.properties文件里定义了一个参数变量。

示例代码：

config.name=zhangsan

在任意的bean容器里面，可以通过@Value注解注入参数，获取参数变量值。

示例代码：

@RestController
public class HelloController {

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

    @GetMapping("config")
    public String config() {
        return JSON.toJSONString(config);
    }
}

@ConfigurationProperties

一般在企业项目开发中，不会使用杂乱无章的写法，而是一次性读取一个Java配置类，然后在需要使用的地方直接引用这个类就可以多次访问了，方便维护。

示例代码： 首先，在application.properties文件里定义好参数变量。

config.name=demo_1
config.value=demo_value_1

然后，创建一个Java配置类，将参数变量注入即可。

@Component
@ConfigurationProperties(prefix = "config")
public class Config {
    public String name;
    public String value;

    // Getter and Setter
}

最后，在需要使用的地方，通过IoC注入Config对象即可。

@PropertySource

这个注解是用来读取我们自定义的配置文件的，比如导入test.properties和bussiness.properties两个配置文件。

示例代码：

@SpringBootApplication
@PropertySource(value = {"test.properties", "bussiness.properties"})
public class PropertyApplication {
    public static void main(String[] args) {
        SpringApplication.run(PropertyApplication.class, args);
    }
}

@ImportResource

用来加载xml配置文件，比如导入自定义的aaa.xml文件。

示例代码：

@ImportResource(locations = "classpath:aaa.xml")
@SpringBootApplication
public class PropertyApplication {
    public static void main(String[] args) {
        SpringApplication.run(PropertyApplication.class, args);
    }
}

异常处理相关注解

@ControllerAdvice 和 @ExceptionHandler

通常组合使用，用于处理全局异常。

示例代码：

@ControllerAdvice
@Configuration
@Slf4j
public class GlobalExceptionConfig {
    private static final Integer GLOBAL_ERROR_CODE = 500;

    @ExceptionHandler(value = Exception.class)
    @ResponseBody
    public void exceptionHandler(HttpServletRequest request, HttpServletResponse response, Exception e) throws Exception {
        log.error("【统一异常处理器】", e);
        ResultMsg<Object> resultMsg = new ResultMsg<>();
        resultMsg.setCode(GLOBAL_ERROR_CODE);

        if (e instanceof CommonException) {


            CommonException ex = (CommonException) e;
            if (ex.getErrCode() != 0) {
                resultMsg.setCode(ex.getErrCode());
            }
            resultMsg.setMsg(ex.getErrMsg());
        } else {
            resultMsg.setMsg(CommonErrorMsg.SYSTEM_ERROR.getMessage());
        }
        WebUtil.buildPrintWriter(response, resultMsg);
    }
}

测试相关注解

@ActiveProfiles

一般作用于测试类上，用于声明生效的Spring配置文件，比如指定application-dev.properties配置文件。

@RunWith 和 @SpringBootTest

一般作用于测试类上，用于单元测试用。

示例代码：

@ActiveProfiles("dev")
@RunWith(SpringRunner.class)
@SpringBootTest
public class TestJunit {
    @Test
    public void executeTask() {
        // 测试...
    }
}