SpringBoot常用注解及使用方法2

2.3、JPA 相关注解

• @Entity和@Table

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

• @Id

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

• @Column

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

• @GeneratedValue

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

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

用来定义一个生成主键的序列，它需要与@GeneratedValue联合使用才有效，以TB_ROLE表为例，对应的注解配置如下：

@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;
 
 //...get、set
}

• @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;
 
  //...get、set
}

2.4、配置相关注解

• @Configuration

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

@Configuration
public class AppConfig {

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

}

• @EnableAutoConfiguration

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

某些场景下，如果我们想要避开某些配置类的扫描（包括避开一些第三方jar包下面的配置，可以这样处理。

@Configuration
@EnableAutoConfiguration(exclude = { org.springframework.boot.autoconfigure.security.servlet.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);
    }
}

把@SpringBootApplication换成@Configuration、@EnableAutoConfiguration、@ComponentScan这三个注解，一样可以启动成功，@SpringBootApplication只是将这三个注解进行了简化！

• @EnableTransactionManagement

表示开启事务支持，等同于 xml 配置方式的

@SpringBootApplication
@EnableTransactionManagement`
public class PropertyApplication {

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

• @Conditional

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

• @ConditionalOnBean：当某个特定的Bean存在时，配置生效
• @ConditionalOnMissingBean：当某个特定的Bean不存在时，配置生效
• @ConditionalOnClass：当Classpath里存在指定的类，配置生效
• @ConditionalOnMissingClass：当Classpath里不存在指定的类，配置生效
• @ConditionalOnExpression：当给定的SpEL表达式计算结果为true，配置生效
• @ConditionalOnProperty：当指定的配置属性有一个明确的值并匹配，配置生效

具体的应用案例如下：

@Configuration
public class ConditionalConfig {


    /**
     * 当AppConfig对象存在时，创建一个A对象
     * @return
     */
    @ConditionalOnBean(AppConfig.class)
    @Bean
    public A createA(){
        return new A();
    }

    /**
     * 当AppConfig对象不存在时，创建一个B对象
     * @return
     */
    @ConditionalOnMissingBean(AppConfig.class)
    @Bean
    public B createB(){
        return new B();
    }


    /**
     * 当KafkaTemplate类存在时，创建一个C对象
     * @return
     */
    @ConditionalOnClass(KafkaTemplate.class)
    @Bean
    public C createC(){
        return new C();
    }

    /**
     * 当KafkaTemplate类不存在时，创建一个D对象
     * @return
     */
    @ConditionalOnMissingClass(KafkaTemplate.class)
    @Bean
    public D createD(){
        return new D();
    }


    /**
     * 当enableConfig的配置为true，创建一个E对象
     * @return
     */
    @ConditionalOnExpression("${enableConfig:false}")
    @Bean
    public E createE(){
        return new E();
    }


    /**
     * 当filter.loginFilter的配置为true，创建一个F对象
     * @return
     */
    @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

上面@Value在每个类中获取属性配置值的做法，其实是不推荐的。

一般在企业项目开发中，不会使用那么杂乱无章的写法而且维护也麻烦，通常会一次性读取一个 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;

    //...get、set
}

最后，在需要使用的地方，通过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);
    }
}

2.5、异常处理相关注解

• @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 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);
    }
 
 
}

2.6、测试相关注解
@ActiveProfiles
一般作用于测试类上， 用于声明生效的 Spring 配置文件，比如指定application-dev.properties配置文件。
@RunWith和@SpringBootTest
一般作用于测试类上， 用于单元测试用，示例如下：
@ActiveProfiles("dev")
@RunWith(SpringRunner.class)
@SpringBootTest
public class TestJunit {

    @Test
    public void executeTask() {
        //测试...
    }
}

三、小结
整个篇幅内容比较多，比较干，大家在看的过程中，也没有必要去记住，可以先收藏起来，等到需要用到的时候，再把它拿出来看看！