Spring常用注解汇总

Spring常用注解汇总

• 一、Spring中的常用注解
• • 1.1 Java配置类相关注解
  • • 1.1.1 @Bean
    • 1.1.2 @Configuration
    • 1.1.3 @ComponentScan
    • 1.1.4 @WishlyConfiguration
  • 1.2 声明Bean相关注解
  • • 1.2.1 @Repository
    • 1.2.2 @Service
    • 1.2.3 @Controller
    • 1.2.4 @Component
  • 1.3 注入Bean相关注解
  • • 1.3.1 @Required (不属于Spring的注解)
    • 1.3.2 @Autowired
    • 1.3.3 @Inject
    • 1.3.4 @Resource
    • 1.3.5 @Qualifier
  • 1.4 切面(AOP)相关注解
  • • 1.4.1 @Aspect
    • 1.4.2 @After
    • 1.4.3 @Before
    • 1.4.4 @Around
    • 1.4.5 @PointCut
  • 1.5 Value注解
  • 1.6 @Scope注解——Bean的属性支持
  • 1.7 环境切换相关注解
  • • 17.1 @Profile
    • 1.7.2 @Conditional
  • 1.8 异步相关注解
  • • 1.8.1 @EnableAsync
    • 1.8.2 @Async
  • 1.9 测试相关注解
  • • 1.9.1 @RunWith
    • 1.9.2 @ContextConfiguration
  • 1.10 其他注解
  • • 1.10.1 @EqualsAndHashCode
    • 1.10.2 @SuppressWarnings
• 二、SpringMVC中的常用注解
• • 2.1 声明Bean相关注解
  • • @RestController
  • 2.2 Request请求相关注解
  • • 2.2.1 @RequestMapping
    • 2.2.2 @GetMapping
    • 2.2.3 @PostMapping
    • 2.2.4 @PutMapping
    • 2.2.5 @PatchMapping
    • 2.2.6 @DeleteMapping
    • 2.2.7 @RequestHeader
  • 2.3 参数相关注解
  • • 2.3.1 @RequestBody
    • 2.3.2 @PathVariable
    • 2.3.3 @RequestParam
  • 2.4 响应结果相关注解
  • • 2.4.1 @ResponseBody
    • 2.4.2 @ResponseStatus
  • 2.5 异常相关注解
  • • 2.5.1 @ExceptionHandler
    • 2.5.2 @ControllerAdvice
  • 2.6 其他注解
  • • 2.6.1 @EnableWebMvc
    • 2.6.2 @ModelAttribute
    • 2.6.3 @InitBinder
    • 2.6.4 @Transactional
• 三、SpringBoot中的常用注解
• • 3.1 启动类相关注解
  • • 3.1.1 @SpringBootApplication
    • 3.1.2 @SpringBootConfiguration
    • 3.1.3 @EnableAutoConfiguration
    • 3.1.4 @ComponentScan
  • 3.2 导入文件相关注解
  • • 3.2.1 @ImportAutoConfiguration
    • 3.2.2 @ImportResource
    • 3.2.3 @PropertySource 与 @PropertySources
  • 3.3 @AutoConfiguration相关注解
  • • 3.3.1 @AutoConfigurationPackage
    • 3.3.2 @AutoConfigureBefore
    • 3.3.3 @AutoConfigureAfter
    • 3.3.4 @AutoConfigureOrder
  • 3.4 其他注解
  • • 3.4.1 @Lookup
    • 3.4.2 @Role
    • 3.4.3 @Scope
    • 3.4.4 @Lazy
    • 3.4.5 @Primary
    • 3.4.6 @Profile
    • 3.4.7 @DependsOn
    • 3.4.8 @PostConstruct
    • 3.4.9 @Description
    • 3.4.10 @EnableAspectConfiguration
    • 3.4.11 EnableLoadTimeWeaving
• 四、SpringCloud相关注解
• • 4.1 @EnableEurekaServer
  • 4.2 @EnableDiscoveryClient
  • 4.3 @LoadBalanced
  • 4.4 @EnableCircuitBreaker
  • 4.5 @HystrixCommand(fallbackMethod=”backMethod”)
  • 4.6 @EnableConfigServer
  • 4.7 @EnableZuulProxy
  • 4.8@SpringCloudApplication
  • 4.9 @ConfigurationProperties
• 五、JSON常用注解
• • 5.1 @JsonIgnoreProperties
  • 5.2 @JsonIgnore
  • 5.3 @JsonFormat
  • 5.4 @JsonSerialize
  • 5.5 @JsonDeserialize
  • 5.6 @Transient
  • 5.7 @JsonIgnoreType
  • 5.8 @JsonProperty
  • 5.9 只在序列化情况下生效的注解
  • • 5.9.1 @JsonPropertyOrder
    • 5.9.2 @JsonInclude
    • 5.9.3 @JsonInclude(JsonInclude.Include.NON_NULL)
  • 5.10 在反序列化情况下生效的注解
  • • @JsonSetter
• 六、JPA相关注解
• • 6.1 @Entity ，@Table(name="")
  • 6.2 @MappedSuperClass
  • 6.3 @NoRepositoryBean
  • 6.4 @Column
  • 6.5 @Id
  • 6.6 @Transient
  • • 6.7 @Basic
  • 6.8 @JsonIgnore
  • 6.9 @JoinColumn、@OneToOne、@OneToMany、@ManyToOne
  • • @OneToOne
    • @ManyToOne 与@OneToMany

一、Spring中的常用注解 1.1 Java配置类相关注解 1.1.1 @Bean

此注解是导入第三方包里面的注解，作用在方法上，声明当前方法的返回值为一个 bean。

@Bean注解用于告诉方法，产生了一个 Bean 对象，然后这个 Bean 对象会交由 Spring 管理。产生这个 Bean 对象的方法 Spring 只会调用一次，随后这个 Spring 会将这个 Bean 对象放在自己的 IOC 容器中。

public class test{

    // 使用 @Bean 注解作用在方法上，表明 myBean 需要交由 Spring 进行管理
    // 未指定 bean 名称，默认采用的是 "方法名" + "首字母小写" 的配置方式
    @Bean
    public MyBean myBean(){
        return null;
    }
}

1.1.2 @Configuration

此注解作用在类上，声明当前类为配置类，被注解的类内部包含有一个或多个被@Bean注解的方法。

@Configuration
public class MyConfiguration{

    @Bean
    public MyBean myBean1(){
        return null;
    }
    
	@Bean
    public MyBean myBean2(){
        return null;
    }

	@Bean
    public MyBean myBean3(){
        return null;
    }
    ...
}

注意：
@Configuration注解的配置类有如下要求：

1. @Configuration不可以是final类型；
2. @Configuration不可以是匿名类；
3. 嵌套的configuration必须是静态类。

1.1.3 @ComponentScan

此注解作用在类上，一般和 @Configuration 注解一起使用，用于根据定义的扫描路径对 Component 进行扫描，把符合扫描规则的类装配到 Spring 容器中。如果没有指定扫描包，那么默认会扫描此配置类所在的 package。

@Configuration
@ComponentScan(value = "com.work.service",useDefaultFilters = true)
public class MyComponentScan {
}

1.1.4 @WishlyConfiguration

此注解作用在类上，为 @Configuration 注解和 @ComponentScan 注解的组合注解，可以代替这两个注解使用。

@WishlyConfiguration
public class MyWishlyConfiguration {
}

1.2 声明Bean相关注解 1.2.1 @Repository

此注解作用在类上，在数据访问层使用（dao层），则表明该类具有对对象进行 CRUD 的功能。

@Repository
public interface UserMapper {
	
    public UserInfo login(UserInfo userInfo);
}

1.2.2 @Service

此注解作用在类上，在业务逻辑层使用（service层）。

@Service
public class MyServiceImpl implements MyService {
    @Autowired
    UserMapper userMapper ;

    @Override
    public UserInfo login(UserInfo userInfo) {
        return userInfoMapper.login(userInfo);
    }
}

1.2.3 @Controller

此注解作用在类上，在表示层使用，代表该类是控制器类。

控制层里面的每个方法都可以调用 @Service 标识的类，也就是可以调用业务逻辑层的方法。

@Controller
public class UserInfoController {

    @Autowired
    UserInfoService userInfoService;
    
    
    @RequestMapping("/Login")
    public UserInfo login(UserInfo userInfo)
    {
        return userInfoService.login(userInfo);
    }
}

1.2.4 @Component

此注解泛指各种组件，没有明确的角色。当组件不好归类的时候，我们可以使用这个注解进行标注，标识为一个 Bean。

@Controller、@Service、@Repository 都可以称为 @Component。

1.3 注入Bean相关注解 1.3.1 @Required (不属于Spring的注解)

此注解作用在 bean 的 setter 方法上，用来标识此属性是必须的，必须在配置阶段注入。

public class User {
 
 	private String username;

	@Required
	public void setUserame(String username){
		this.username = username;
	}
}

注意：

1. 这里只能在 setter 方法上家 @Required ；
2. 如果任何带有 @Required 的属性未设值的话，将会抛出BeanInitializationException异常。

1.3.2 @Autowired

此注解由 Spring 提供，可以作用在变量上、setter方法上、构造函数上，显式地声明依赖。

@Controller
public class UserController {
    @Autowired                               
    private UserInfoService userInfoService;                   
}


 public class User {
 
 	private String username;
	private Integer age;

	@Autowired 
	public void setUserame(String username){
		this.username = username;
	}
	
	@Autowired 
	public void setAge(Integer age){
		this.age= age;
	}
 }


 public class User {
 
 	private String username;
	private Integer age;

	@Autowired 
	public User(String username, Integer age){
		this.username = username;
		this.age= age;
	}
 }

1.3.3 @Inject

此注解由 JSR-330 提供，用法和 @Autowired 一样。

1.3.4 @Resource

此注解是Java自己的注解，作用与 @Autowired 相同，但是 @Resource 是按照名称匹配的。

@Service("service1")
public class UserSeviceImpl implement UserService {                
}
@Service("service2")
public class UserSeviceImpl implement UserService {                
}


@Controller
public class UserController {
	// 当有两个名字相同的 service 时，必须要明确指出注入 bean 的名称
    @Resource(name = "service1")                             
    private UserService service1;     

	@Resource(name = "service2")                             
    private UserService service2;                  
}

小贴士：
@Resource 有两个属性是比较重要的：name 和 type。Spring 会将 @Resource 注解的 name 属性解析为 bean 的名字，而 type 属性则解析为 bean 的类型。
如果使用 name 属性，则使用 byName 的自动注入策略；如果使用 type 属性则使用 byType 自动注入策略。如果既不指定 name 也不指定 type 属性，则按照 type 进行注入的自动注入策略进行注入。

1.3.5 @Qualifier

此注解与 @Autowired 一起使用，可以让我们对注入的过程有更多的控制。

@Qualifier 可以被用在单个构造器或者方法的参数桑，当上下文中有几个相同类型的 bean 时，使用 @Autowired 则无法区分要绑定的 bean，此时可以使用 @Qualifier 来指定名称。

@Service("service1")
public class UserSeviceImpl implement UserService {                
}
@Service("service2")
public class UserSeviceImpl implement UserService {                
}


@Controller
public class UserController {
	// 当有两个名字相同的 service 时，必须要明确指出注入 bean 的名称
    @Autowired   
    @Qualifier("service1")                         
    private UserService service1;     

	@Autowired   
    @Qualifier("service2")                           
    private UserService service2;                  
}

1.4 切面(AOP)相关注解

Spring 支持 AspectJ 的注解式切面编程。

1.4.1 @Aspect

此注解作用在类上，用于声明一个切面，使用 @After、@Before、@Aroud 做增强处理，可直接将拦截规则（切点）作为参数。

Spring AOP 面向切面编程，可以用来配置事务、做日志、权限验证、在用户请求时做一些处理等等，使用 @Aspect做一个切面就可以直接实现。

1.4.2 @After

此注解作用在方法上，在方法执行之后执行。

1.4.3 @Before

此注解作用在方法上，在方法执行之前执行。

1.4.4 @Around

此注解作用在方法上，在方法执行之前与之后执行。

1.4.5 @PointCut

此注解作用在类上，声明切点在 java 配置类中使用 @EnableAspectJAutoProxy 注解开启 Spring 对 AspectJ 代理的支持。

1.5 Value注解

• 支持如下方式的注入：

  注入普通字符
  注入操作系统属性
  注入表达式结果
  注入其它bean属性
  注入文件资源
  注入网站资源
  注入配置文件

• @Value 注解三种情况的用法。

  ${} 是去找外部配置的参数，将值赋过来；
  #{} 是 SpEL 表达式，去寻找对应变量的内容；
  #{} 直接写字符串就是将字符串的值注入进去。

1.6 @Scope注解——Bean的属性支持

此注解作用在方法上（得有@Bean），设置Spring容器如何新建Bean实例。、

@Scope设置类型包括5种：

• Singleton

  单例，一个Spring容器中只有一个bean实例，默认模式。

• Protetype

  每次调用新建一个bean。

• Request

  在web项目中，给每个 http request 新建一个 bean。

• Session

  在web项目中，给每个 http session 新建一个 bean。

• GlobalSession

  给每一个 global http session 新建一个 Bean 实例。

1.7 环境切换相关注解 17.1 @Profile

指定组件在哪个环境的情况下才能被注册到容器中，不指定的情况下任何环境下都能注册这个组件。

@Configuration
public class ProfileTest{
	
	@Profile("default")
	@Bean("test")
	public String default{
		return "default";
	}
	
	@Profile("dev")
	@Bean("dev")
	public String dev{
		return "dev";
	}

	@Profile("master")
	@Bean("master")
	public String master{
		return "master";
	}
}

1.7.2 @Conditional

通过实现 Condition 接口，并重写 matches 方法，从而决定该 bean 是否被实例化。

public class Animal {
}


public class Conditional implements Condition {
    @Override
    public boolean matches(ConditionContext context, AnnotatedTypeMetadata annotatedTypeMetadata) {
        // context 代表Ioc容器  context.getBeanFactory 从Ioc容器里获取容器工厂  
　　　　 // 调用该容器工厂，判断是否包含该bean名为animal
        if(context.getBeanFactory().containsBean("animal")){
            return true;
        }
        return false;
    }
}


@Configuration
public class ConditionTest {
    @Bean
    public Animal animal() {
        return new Animal();
    }
}


public class ConditionTest {
    public static void main(String[] args) {
        AnnotationConfigApplicationContext ctx=new AnnotationConfigApplicationContext(com.configuration.ConditionTest.class);
        String[] beans=ctx.getBeanDefinitionNames();
        for(String str:beans){
            System.out.println("bean信息："+str);
        }
    }
}

1.8 异步相关注解 1.8.1 @EnableAsync

此注解作用在类上，配置类中通过此注解开启对异步任务的支持。

1.8.2 @Async

在实际执行的 bean 方法中使用该注解来声明其是一个异步任务（方法上或类上所有的方法都将异步，需要 @EnableAsync 开启异步任务）。

1.9 测试相关注解 1.9.1 @RunWith

运行器，Spring 中通常用于对 JUnit 的支持。

1.9.2 @ContextConfiguration

用来加载配置配置文件，其中classes属性用来加载配置类。

@ContextConfiguration 注解通常与 @RunWith(SpringJUnit4ClassRunner.class) 联合使用用来测试。

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = {"classpath*:
@SpringBootApplication
@ImportResource(locations = {"classpath:beans.xml"})
public class BootApplication {

    public static void main(String[] args) {
        // Spring应用启动        
        SpringApplication.run(BootApplication.class,args);
    }
}

3.2.3 @PropertySource 与 @PropertySources

@PropertySource 用于引入单个配置文件，@PropertySources 用于引入多个配置文件。

// 引入单个properties文件
@PropertySource(value = {"classpath:xxxx/xxxx.properties"})
// 引入多个properties文件
@PropertySource(value = {"classpath:xxxx/xxxx.properties","classpath:xxxx/xxxx.properties"})

@PropertySource 或者 @PropertySources 引入的数据都是存在环境变量ConfigurableEnvironment中的。

// cat.properties内容
parent=tiger

// 类Cat
public class Cat {
  @Value("猫") //直接注入字符串
  private String name;
  @Value("#{12+2}") //支持EL表达式
  private int age;
  @Value("${parent}") //支持配置文件读取
  private String parent;
  public Cat() {
    System.out.println("猫被初始化");
  }
  @Override
  public String toString() {
    return "Cat{" +
        "name='" + name + ''' +
        ", age=" + age +
        ", parent='" + parent + ''' +
        '}';
  }
}

// 配置
@Import({Cat.class})
@PropertySources({@PropertySource(value ="cat.properties")})
public class Appconfig {
}

// 测试
public class Demo {
  public static void main(String[] args) {

    AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(Appconfig.class);
    Cat bean = context.getBean(Cat.class);
    System.out.println(bean); //Cat{name='猫', age=14, parent='tiger'}
    ConfigurableEnvironment environment = context.getEnvironment();
    System.out.println(environment.getProperty("parent")); //tiger
  }
}

3.3 @AutoConfiguration相关注解 3.3.1 @AutoConfigurationPackage

此注解的作用是将添加该注解的类所在的 package 作为 自动配置package 进行管理。

包含该注解的 package 会被 AutoConfigurationPackages 注册。

可以通过 AutoConfigurationPackages 工具类获取自动配置package列表。当通过注解@SpringBootApplication 标注启动类时，已经为启动类添加了 @AutoConfigurationPackage 注解。路径为 @SpringBootApplication -> @EnableAutoConfiguration -> @AutoConfigurationPackage。
也就是说当 SpringBoot 应用启动时默认会将启动类所在的 package 作为自动配置的 package。

3.3.2 @AutoConfigureBefore

在指定配置类初始化前加载。

// 说明 User将会在 Person 之前加载
@AutoConfigureBefore(Person.class)
public class User{
}

3.3.3 @AutoConfigureAfter

在指定配置类初始化后加载。

3.3.4 @AutoConfigureOrder

指定配置类初始化顺序，越小初始化越早。

注意：SpringBoot 只会对从 spring.factories 文件读取到的配置类进行排序。

3.4 其他注解 3.4.1 @Lookup

此注解作用在方法行，根据方法返回的类型，去容器中捞出对应的实例。

举例：如果有一个类C，需要用到类B，如果使用 @Autowired 注解注入B，那么B每次调用都是同一个对象，即使B不是单例的。而 @Lookup 提供了一种方式以抽象方法的方式来获取Bean。

@Component
@Scope(scopeName= ConfigurableBeanFactory.SCOPE_PROTOTYPE) //原型 也就是非单例
public class B {
    public  void sayHi(){
        System.out.println("hi");
    }
}

@Component
public abstract class C {

    public void hello(){
        B b = getB();
        b.sayHi();
    }
    
    @Lookup
    public abstract B getB(); //一般都是抽象方法
}

3.4.2 @Role

bean角色定义为ROLE_APPLICATION(默认值)、ROLE_SUPPORT(辅助角色)、ROLE_INFRASTRUCTURE(后台角色，用户无感)。

3.4.3 @Scope

指定bean的作用域，默认singleton，其它包括prototype、request、session、globalSession等。

3.4.4 @Lazy

使bean懒加载，取消bean预初始化。

3.4.5 @Primary

自动装配时当出现多个Bean候选者时，被注解为 @Primary 的 Bean 将作为首选者，否者将抛出异常。

3.4.6 @Profile

指定Bean在哪个环境下被激活。

3.4.7 @DependsOn

依赖的 bean 注册完成，才注册当前类，依赖 bean 不存在会报错。用于控制bean加载顺序。

3.4.8 @PostConstruct

bean 的属性都注入完毕后，执行注解标注的方式进行初始化工作。

3.4.9 @Description

添加 bean 的文字描述。

3.4.10 @EnableAspectConfiguration

启动 AspectJ 自动配置。

3.4.11 EnableLoadTimeWeaving

启动类加载器动态增强功能，使用 instrumentation 实现。

四、SpringCloud相关注解 4.1 @EnableEurekaServer

用在 springboot 启动类上，表示这是一个 eureka 服务注册中心。

4.2 @EnableDiscoveryClient

用在 springboot 启动类上，表示这是一个服务，可以被注册中心找到.

4.3 @LoadBalanced

此注解作用在方法上，用于开启负载均衡能力。

//  @LoadBalanced这个注解是让 RestTemplate 开启负载均衡的能力
@LoadBalanced
public RestTemplate getRestTemplate() {
    return new RestTem plate();
}

4.4 @EnableCircuitBreaker

用在启动类上，开启断路器功能。

4.5 @HystrixCommand(fallbackMethod=”backMethod”)

用在方法上，fallbackMethod 指定断路回调方法。

4.6 @EnableConfigServer

用在启动类上，表示这是一个配置中心，开启 Config Server。

4.7 @EnableZuulProxy

开启 zuul 路由，用在启动类上。

4.8@SpringCloudApplication

@SpringBootApplication、@EnableDiscovertyClient、@EnableCircuitBreaker分别是 SpringBoot 注解、注册服务中心Eureka注解、断路器注解。

对于 SpringCloud 来说，这是每一微服务必须应有的三个注解，所以 @SpringCloudApplication 这一注解就是以上三个注解的集合。

4.9 @ConfigurationProperties

此注解作用在类或方法上，该注解有一个 prefix 属性，通过指定的前缀，绑定配置文件中的配置。

Spring 源码中大量使用了 ConfigurationProperties 注解，比如 server.por t就是由该注解获取到的，通过与其他注解配合使用，能够实现 Bean 的按需配置。

spring.datasource.url=jdbc:mysql://127.0.0.1:8888/test?useUnicode=false&autoReconnect=true&characterEncoding=utf-8
spring.datasource.username=root
spring.datasource.password=root
spring.datasource.driver-class-name=com.mysql.jdbc.Driver
spring.datasource.type=com.alibaba.druid.pool.DruidDataSource

@ConfigurationProperties(prefix = "spring.datasource")
@Component
public class DatasourcePro {
    private String url;
    private String username;
    private String password;
    // 配置文件中是driver-class-name, 转驼峰命名便可以绑定成功
    private String driverClassName;
    private String type;
 
    ...
}

注意：

1. @ConfigurationProperties 和 @value 有着相同的功能，但是 @ConfigurationProperties的写法更为方便；
2. @ConfigurationProperties 的 POJO类的命名比较严格，因为它必须和 prefix 的后缀名要一致，不然值会绑定不上，特殊的后缀名是“driver-class-name”这种带横杠的情况，在POJO里面的命名规则是 下划线转驼峰 就可以绑定成功，所以就是 “driverClassName”。

五、JSON常用注解 5.1 @JsonIgnoreProperties

此注解作用在类上，作用是 json 序列化时将 java bean 中的一些属性忽略掉，序列化和反序列化都受影响。

写法将此标签加在类的类名上 ，可以多个属性也可以单个属性。

// 生成 json 时将 name 和 age 属性过滤掉
@JsonIgnoreProperties({"name"},{"age"})
public class User{ 
    private  String name;
    private int age;
}

5.2 @JsonIgnore

此注解作用在属性或者方法上（最好是属性上），作用和 @JsonIgnoreProperties 一样。

// 生成json 时不生成age 属性
public class User{
    private String name;
    @JsonIgnore
    private int age;
}

5.3 @JsonFormat

此注解作用在属性或者方法上（最好是属性上），可以方便的把 Date 类型数据直接转化为我们想要的模式。

public class User{
    @JsonFormat(pattern = “yyyy-MM-dd HH-mm-ss”)
    private Date date;
}

5.4 @JsonSerialize

此注解作用在属性或者 getter 方法上，主要用于数据转换(将 java 对象序列化为 json 数据)，在序列化时嵌入我们自定义的代码。

// 自定义序列化代码
public class MySerializerUtils extends JsonSerializer {
    @Override
    public void serialize(Integer status, JsonGenerator jsonGenerator, SerializerProvider serializerProvider) throws IOException, JsonProcessingException {
        String statusStr = "";
        switch (status) {
            case 0:
                statusStr = "未激活";
                break;
            case 1:
                statusStr = "已激活";
                break;
            default:
                statusStr = "未知";
        }
        jsonGenerator.writeString(statusStr);
    }
}



@JsonSerialize(using = MySerializerUtils.class)
private int statusStr;

5.5 @JsonDeserialize

此注解作用在属性或者 setter 方法上，主要用于数据转换(将 json 数据反序列化为 java 对象),用于在反序列化时可以嵌入我们自定义的代码，类似于 @JsonSerialize 注解。

@JsonDeserialize(using = MySerializerUtils.class)
private int statusStr;

5.6 @Transient

java 的 transient 关键字的作用是需要实现 Serilizable 接口，将不需要序列化的属性前添加关键字transient，序列化对象的时候，这个属性就不会序列化到指定的目的地中。

如果一个属性并非数据库表的字段映射（不存到数据库中，只是做一个临时变量），就务必将其标示为 @Transient，否则ORM框架默认其注解为@Basic。

public class User implements Serializable,Cloneable {
    private static final long serialVersionUID = 1L;
    @Transient
    private boolean enabled = false;
}

5.7 @JsonIgnoreType

此注解作用在类上，使用该注解的类作为其他类的属性时，在序列化和反序列化期间将忽略该属性。即只有在该类作为其他类的属性时才会被忽略，直接序列化、反序列化该类是正常的。

// 该类自己序列化和反序列化是正常的
@JsonIgnoreType
public class Address {
    private String street;
    private String city;
}    

public class Employee {
    private String name;
    private String dept;
    // 在序列化和反序列化时忽略该属性
    private Address address;
}    

5.8 @JsonProperty

此注解作用在属性上，可以指定某个属性和 json 映射的名称，将该属性的名称序列化为另一份自己想要的名称。

。这个注解也比较常用。

public class SomeEntity {
	// java中命名要遵循驼峰规则，则为userName，这时通过该注解来指定两者的映射规则即可
    @JsonProperty("user_name")
    private String userName;

	// // 假如 trueName 最后为"小明"，转化为 json 后: {"name":"小明"}
	@JsonProperty("name") 
	private String trueName;	 
}

5.9 只在序列化情况下生效的注解 5.9.1 @JsonPropertyOrder

此注解作用在类上，在将 java pojo 对象序列化成为 json 字符串时，使用 @JsonPropertyOrder 可以指定属性在 json 字符串中的顺序。

@AllArgsConstructor
@JsonPropertyOrder(alphabetic = true)//按字母排序
@JsonPropertyOrder({ "name", "id" })//自定义排序
public class OrderTestBean {
    public int id;
    public String name;
}

5.9.2 @JsonInclude

此注解作用在类上，在将 java pojo 对象序列化成为 json 字符串时，使用 @JsonInclude 注解可以控制在哪些情况下才将被注解的属性转换成 json。

例如只有属性不为 null 时。

@JsonInclude(JsonInclude.Include.NON_NULL)
public class Student
{
    private int id;
    private String username;
    private String sex;
    private String address;
    ...
}

5.9.3 @JsonInclude(JsonInclude.Include.NON_NULL)

此注解作用在类上，返给前端的 json 里就没有 null 类型的字段，即实体类与 json 互转的时候属性值为null的不参与序列化。

另外还有很多其它的范围，例如 NON_EMPTY、NON_DEFAULT等。

5.10 在反序列化情况下生效的注解 @JsonSetter

标注于 setter 方法上，类似 @JsonProperty ，也可以解决 json 键名称和 java pojo 字段名称不匹配的问题。

除了重命名之外，@JsonSetter 还可以指定如何处理 JSON 中的 ‘null’。

private static class Person {
    private String name;

	// 结果：Person{name=''}
    @JsonSetter(nulls = Nulls.AS_EMPTY)
    public void setName(String name) {
        this.name = name;
    }
}

Nulls 的可能取值： SET、 SKIP、 FAIL、 AS_EMPTY 和 DEFAULT。

六、JPA相关注解 6.1 @Entity ，@Table(name=“”)

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

6.2 @MappedSuperClass

基于代码复用和模型分离的思想，在项目开发中使用 jpa 的 @MappedSuperClass 注解，将实体类的多个属性分别封装到不同的非实体类中。

例如，数据库表中都需要 id 来表示编号，id 是这些映射实体类的通用属性，交给 jpa 统一生产主键id 编号，那么使用一个父类来封装这些通用属性，并用 @MappedSuperClass 标识。

注意：

1. 标注为 @MappedSuperClass 的类将不是一个完整的实体类，它将不会映射到数据库表，但是它的属性都映射到其子类的数据库字段中。
2. 标注 @MappedSuperClass 的类不能再标注 @Entity 或 @Table 注解，也无需实现序列化接口。

6.3 @NoRepositoryBean

一般用做父类的 repository，有这个注解，spring 不会去实例化该 repository。

6.4 @Column

如果字段名和列名相同，则可以省略。

6.5 @Id

表示该属性为主键。

6.6 @Transient

表示该属性并非一个到数据库表的字段的映射，ORM 框架将忽略该属性。

如果一个属性并非数据库表的字段映射，就务必将其标注为 @Transient，否则，ORM框架默认将其注解为@Basic。

6.7 @Basic

@Basic 是实体类与数据库字段映射时最简单的类型。

类型支持Java基本类型（byte、short、int、long、float、double、char、boolean），包装类，枚举类，以及实现了serializable接口的类型。

@basic注解有两个属性：

1. fetch用来指定属性的加载机制

   有两个选项：EAGER（即时加载，默认值）和LAZY（懒加载），即时加载意味着当实例化对象的时候必须加载该属性值，懒加载是指当实例化对象时不加载该对象，只有当调用该属性时才加载。

2. optional用来指定属性是否可空

   有两个选项：true（可空，默认值）和false

   如果实体类上不加 @Basic 注解，它也会自动加上@Basic，并使用默认值。

6.8 @JsonIgnore

在实体类向前台返回数据时用来忽略不想传递给前台的属性或接口。

Bean实体中会有某些运维字段，返回信息给前台的时候，不希望将对应值一并返回。此时可以在对应属性上加上 @JsonIgnore，或者可以在User类上加上注解 @JsonIgnoreProperties(value=“{password}”)。

6.9 @JoinColumn、@OneToOne、@OneToMany、@ManyToOne

@JoinColumn 与 @Column 注解一样，是用于注释表中的字段的。

@OneToOne

一对一 关联关系。

在数据库中之标示两张表之间的一对一关系，这是 hibernate 与 jpa 之中实体关系最简单的一种，一对一时只需要在两个关联实体的任意一个中，将关联的另一个实体，当做其一个属性，并在该属性上使用 @OneToOne 注解即可。

@ManyToOne 与@OneToMany

一对多关联关系与多对一关联关系。

一对多与多对一，是各种物理数据模型中最常见的关联关系，绝大多数的项目开发中都不可避免。

而 @ManyToOne 与@ OneToMany 的最大区别就是在于标注使用的一方是多的一方还是一的一方，简单的区分就是当前 Class 的实体在这个关联关子中扮演的是多的一方就是用 @ManyToOne,反之一的一方则使用 @OneToMany。