Springboot常用注解总结

目录

启动类和配置类中注解 

@SpringBootApplication

@ComponentScan

 @MapperScan

@EnableCaching

持久层（Mapper）常用注解 

@Repository

@Param

实体类常用注解

引入注解所需要的依赖

@Data

@AllArgsConstructor

@NoArgsConstructor

@TableName

@TableId

@TableField

逻辑层（Service）常用注解

@Service

@Autowired

@Transactional

控制层（Controller）常用注解

@RestController

@Controller

@Responsebody

@RequestMapping

@PathVariable

@RequestParam

@RequestBody

 @RequestHeader

启动类和配置类中注解 

@SpringBootApplication

带@SpringBootApplication注解的类，我们一般定义为主程序。此注解默认扫描主程序所在包以及所有子包内的组件。

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

如果需要改变扫描路径，带上参数scanBasePackages就会扫描指定路径

例如：

@SpringBootApplication(scanBasePackages={"com.test"})
public class DemoApplication { 
     public static void main(String[] args) {
        SpringApplication.run(DemoApplication.class, args);
}}

@SpringBootApplication等同于@SpringBootConfiguration+@EnableAutoConfiguration+@ComponentScan(“需要扫描到的包路径”）

@SpringBootConfiguration	用来申明当前类是配置类
@EnableAutoConfiguration	SpringBoot实现自动化配置的核心注解，通过这个注解把Spring应用  所需要的bean注入容器
@ComponentScan	定义扫描的路径从中找出标识了需要装配的类自动装配到spring的      bean容器中

@ComponentScan

作用：@ComponentScan主要就是定义扫描的路径从中找出标识了需要装配的类自动装配到spring的bean容器中

配置扫描路径：既可以扫描包也可以扫描指定的类

配置扫描包路径：通过value属性设置需要扫描的包，例如：@ComponentScan(value = {"com.joinforwin","com.sie"})

配置扫描类路径：通过basePackageClasses属性指定需要扫描的类，例如：                                @ComponentScan(basePackageClasses = {"xxxservice.class","xxxservice.class"})

 @MapperScan

普通的 @Mapper注解：
       作用：在接口类上添加了@Mapper，在编译之后会生成相应的接口实现类
       添加位置：接口类上面

例如：

@Mapper
public interface DemoDAO {
   //代码
}

这时候如果我们想要将每个接口都变成实现类，按照之前的办法我们就需要在每个接口类上都加上@Mapper注解，比较麻烦，为了解决这个问题这时候我们就要用到@MapperScan注解

@MapperScan
     作用：指定要变成实现类的接口所在的包，然后包下面的所有接口在编译之后都会生成相应的实现类；

指定当前项目的mapper接口路径的位置，在项目启动的时候会自动加载所有的接口
     添加位置：是在Springboot启动类上面添加

@SpringBootApplication  
@MapperScan({basePackages = {"com.fan.*"}})  
public class App {  
    public static void main(String[] args) {  
       SpringApplication.run(App.class, args);  
    }  
} 

@EnableCaching

此注解是用来启动缓存功能，加了这个注解以后，Spring才知道我们需要使用缓存功能，相应的其他和缓存相关的注解才会有效，spring中主要是通过aop实现的，通过aop来拦截需要使用缓存的方法，实现缓存的功能。

当我们在配置类(@Configuration)上使用@EnableCaching注解时，会触发一个post processor，这会扫描每一个spring bean，查看是否已经存在注解对应的缓存。如果找到了，就会自动创建一个代理拦截方法调用，使用缓存的bean执行处理。

开启缓存注解的步骤：

1. 配置类上开启缓存注解支持：@EnableCaching
2. 向容器内至少放置一个CacheManager类型的Bean

@SpringBootApplication
@EnableCaching  
@MapperScan({basePackages = {"com.fan.*"}})  
public class App {  
    public static void main(String[] args) {  
       SpringApplication.run(App.class, args);  
    }  
} 

持久层（Mapper）常用注解 

@Repository

此注解和@Controller、@Service、@Component的作用差不多，都是用来把对象交给spring去管理。@Repository注解通常用在持久层的接口上，把接口的一个实现类交给Spring去管理。这是因为该注解的作用不只是将类识别为Bean，同时它还能将所标注的类中抛出的数据访问异常封装为 Spring 的数据访问异常类型。 Spring本身提供了一个丰富的并且是与具体的数据访问技术无关的数据访问异常结构，用于封装不同的持久层框架抛出的异常，使得异常独立于底层的框架。

例如：

@Repository
public interface DemoMapper extends BaseMapper<Demo> {
}

@Param

这个注解是为SQL语句中参数赋值而服务的。同时也是为了解决接口方法有多个参数时、xxMapper.xml文件绑定参数混淆问题

@Param的作用就是给参数命名，比如在mapper里面某方法A（int id），当添加注解后A（@Param("userId") int id），也就是说外部想要取出传入的id值，只需要取它的参数名userId就可以了。将参数值传如SQL语句中，通过#{userId}进行取值给SQL的参数赋值。

例一：@Param注解基本类型的参数

   mapper中的方法：

public User selectUser(@Param("username") String name,@Param("password") String pwd);

映射到xml当中的select标签

<select id = "selectUser" resultMap = "User">
    select * from user where user_name = #{userName} and user_password = #{password}
</select>

其中的where user_name = #{userName} and user_password = #{password}中的userName和password都是从注解@Param()里面取出来的，取出来的值就是方法中的形参String name以及String pwd的值 

例二：@Param注解JavaBean对象

  mapper中的方法：

public List<User> getAllUser(@Param("param") User user);

  映射到xml中的<select>标签

<select id = "getAllUser" parameterType = "com.sie.User">
        select
        from user u where u.user_name = #{param.userName}
             and u.user_Password = #{param.password}
</select>

实体类常用注解

引入注解所需要的依赖

<dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
    <version>1.18.4</version>
    <scope>provided</scope>
</dependency>

@Component

 将普通pojo实体类注入spring容器

@Data

相当于@setter+@getter+@EqualsAndHashCode

注在类上，提供类的get、set、equals、hashCode、toString等方法

• @Setter ：注在属性上，提供 set 方法
• @Getter ：注在属性上，提供 get 方法
• @EqualsAndHashCode ：注在类上，提供对应的 equals 和 hashCode 方法

@AllArgsConstructor

注在类上，提供类的全参构造

@NoArgsConstructor

注在类上，提供类的无参构造

@Data
@AllArgsConstructor
@NoArgsConstructor
public class Person {
    private String name;
    private String address;
    private Integer age;
}

@TableName

描述：表名注解

作用：指定当前实体类映射哪张数据库表， 默认是跟实体类名一致

错误提示：如果@TableName声明的表名跟数据库中的表名不一致会报错

@TableId

描述：主键注解

作用：标记当前属性映射表主键。

@TableField

描述：字段注解(非主键)

作用：指定当前属性映射数据库表哪一列， 默认是跟属性名一致

错误提示1：如果@TableField声明的属性名跟数据库中的字段名不一致会报错

/**
 * 用户测试类
 */

//指定数据库表名称 user_test1
@TableName(value = "user_test1")
public class UserTest {

    /**
     * 主键id 设置自增长策略
     */
    @TableId(value = "id",type = IdType.AUTO)
    private int id;

    /**
     * 用户名称
     */
    @TableField(value = "username")
    private String username;

    /**
     * 年龄
     */
    @TableField(value = "age")
    private int age;

    /**
     * 电话
     */
    @TableField(value = "tel")
    private int tel;

    /**
     * 创建时间
     */
    @TableField(value = "create_time")
    private Date create_time;

    /**
     * 最后修改时间
     */
    @TableField(value = "update_time")
    private Date update_time;

    /**
     * 版本号（用于乐观锁，默认为1）
     * @return
     */
    //@Version
    @TableField(value = "version")
    private int version;
    
    /**
     * 表示属性在表中是否真实存在
     */
    @TableField（exist = false） //不存在
        private int version；  
    
}

业务逻辑层（Service）常用注解

@Service

用来表示Service层（服务层），将业务逻辑层（server）注入spring容器

@Service
public class DemoService {...}

@Autowired

启动spring IoC时，容器自动装载了一个AutowiredAnnotationBeanPostProcessor后置处理器，当容器扫描到@Autowied、@Resource(是CommonAnnotationBeanPostProcessor后置处理器处理的)或@Inject时，就会在IoC容器自动查找需要的bean，并装配给该对象的属性

@Service
public class Hl7DataService {
    @Autowired
    private DemoMapper demoMapper;
}

@Transactional

@Transactional 是声明式事务管理编程中使用的注解

（1）添加位置：接口的实现类或者接口的实现方法上
（2）访问权限：public 的方法才起作用。@Transactional 注解应该只被应用到 public 方法上，这是由 Spring AOP 的本质决定的。
系统设计：将标签放置在需要进行事务管理的方法上，而不是放在所有接口实现类上：只读的接口就不需要事务管理，由于配置了@Transactional就需要AOP拦截及事务的处理，可能影响系统性能。

@Transactional注解的可用参数
readOnly
该属性用于设置当前事务是否为只读事务，设置为true表示只读，false则表示可读写，默认值为false

rollbackFor
该属性用于设置需要进行回滚的异常类数组，当方法中抛出指定异常数组中的异常时，则进行事务回滚。例如：
1. 指定单一异常类：@Transactional(rollbackFor=RuntimeException.class)
2. 指定多个异常类：@Transactional(rollbackFor={RuntimeException.class, BusnessException.class})

rollbackForClassName
该属性用于设置需要进行回滚的异常类名称数组，当方法中抛出指定异常名称数组中的异常时，则进行事务回滚。例如：
1. 指定单一异常类名称：@Transactional(rollbackForClassName=“RuntimeException”)
2. 指定多个异常类名称：@Transactional(rollbackForClassName={“RuntimeException”,“BusnessException”})

noRollbackFor
该属性用于设置不需要进行回滚的异常类数组，当方法中抛出指定异常数组中的异常时，不进行事务回滚

noRollbackForClassName
参照上方的例子

timeout
该属性用于设置事务的超时秒数，默认值为-1表示永不超时

propagation
该属性用于设置事务的传播行为
例如：@Transactional(propagation=Propagation.NOT_SUPPORTED)
事物传播行为介绍:

@Transactional(propagation=Propagation.REQUIRED) 如果有事务, 那么加入事务, 没有的话新建一个(默认)
@Transactional(propagation=Propagation.NOT_SUPPORTED) 容器不为这个方法开启事务
@Transactional(propagation=Propagation.REQUIRES_NEW) 不管是否存在事务,都创建一个新的事务,原来的挂起,新的执行完毕,继续执行老的事务
@Transactional(propagation=Propagation.MANDATORY) 必须在一个已有的事务中执行,否则抛出异常
@Transactional(propagation=Propagation.NEVER) 必须在一个没有的事务中执行,否则抛出异常(与Propagation.MANDATORY相反)
@Transactional(propagation=Propagation.SUPPORTS) 如果其他bean调用这个方法,在其他bean中声明事务,那就用事务.如果其他bean没有声明事务,那就不用事务
isolation
该属性用于设置底层数据库的事务隔离级别

事务隔离级别介绍:

@Transactional(isolation = Isolation.READ_UNCOMMITTED)读取未提交数据(会出现脏读, 不可重复读) 基本不使用
@Transactional(isolation = Isolation.READ_COMMITTED)读取已提交数据(会出现不可重复读和幻读)
@Transactional(isolation = Isolation.REPEATABLE_READ)可重复读(会出现幻读)
@Transactional(isolation = Isolation.SERIALIZABLE)串行化

控制层（Controller）常用注解

@RestController

相当于@Controller+@Responsebody

@Controller

告诉Spring这个类作为控制器，可以看做标记为暴露给前端的入口，将控制层(controller)注入Spring容器

@Responsebody

1.将java对象转为json格式的数据，控制层方法的返回值是如何转化为json格式的字符串的？其实是通过HttpMessageConverter中的方法实现的，它本是一个接口，在其实现类完成转换。如果是bean对象，会调用对象的getXXX（）方法获取属性值并且以键值对的形式进行封装，进而转化为json串。如果是map集合，采用get(key)方式获取value值，然后进行封装。

2.该注解用于将Controller中的方法返回的对象，通过适当的HttpMessageConverter转换为指定格式后写入到Response对象的body区；在使用此注解之后不会再走视图处理器而是直接将数据写入到数据流当中去，效果等同于通过response对象输出指定格式的数据，当方法上没有该注解的话，底层会把方法的返回值封装为一个ModelAndView对象

@RequestMapping

@RequestMapping 是一个用来处理请求地址映射的注解，它可以用于类上，也可以用于方法上。在类的级别上的注解会将一个特定请求或者请求模式映射到一个控制器之上，表示类中的所有响应请求的方法都是以该地址作为父路径；在方法的级别表示进一步指定到处理方法的映射关系。

该注解有6个属性，我们在项目中比较常用的有三个属性：value、method 和 produces。

  value 属性：指定请求的实际地址，value 可以省略不写

    注意：value属性是一个字符串类型的数组，表示请求映射能够匹配多个请求地址所对应的请求。

    例如：@RequestMapping(value={"/other","/other2","/other3"})

  method 属性：指定请求的类型，主要有 GET、PUT、POST、DELETE，默认为 GET

    例如：method = RequestMethod.POST

  produces属性：指定返回内容类型，如 produces = “application/json; charset=UTF-8”

 @GetMapping、@PostMapping、@PutMapping、@DeleteMapping

1、对于处理指定请求方式的控制器方法，SpringMVC中就提供了@RequestMapping的派生注解：

• 处理get请求的映射 —> @GetMapping
• 处理post请求的映射 —> @PostMapping
• 处理put请求的映射 —> @PutMapping
• 处理delete请求的映射 —> @DeleteMapping

例：

@RestController
@RequestMapping(value = "/test", produces = "application/json; charset=UTF-8")
public class TestController {
    @RequestMapping(value = "/get", method = RequestMethod.GET)
    public String testGet() {
        return "success";
    }
}

@PathVariable

@PathVariable 注解主要是用来获取 url 参数，Spring Boot 支持 restfull 风格的 url，比如一个 GET 请求携带一个参数 id 过来，我们将 id 作为参数接收，可以使用 @PathVariable 注解。如下：

@GetMapping("/user/{id}")
public String testPathVariable(@PathVariable("id") Integer id) {
	System.out.println("获取到的id为：" + id);
	return "success";
}

@GetMapping("/user/{idd}/{name}")
public String testPathVariable(@PathVariable("idd") Integer id, @PathVariable("name") String name) {
    System.out.println("获取到的id为：" + id);
    System.out.println("获取到的name为：" + name);
    return "success";
}

@RequestParam

此注解也是用来获取请求参数的，和上面提到的@PathVariable相比较，两者的区别主要在于：@PathValiable 是从 url 模板中获取参数值， 即这种风格的 url：http://localhost:8080/user/{id} ；而 @RequestParam 是从 request 里面获取参数值，即这种风格的 url：http://localhost:8080/user?id=1 。

我们使用该 url 带上参数 id 来测试一下如下代码：

     在url中输入:localhost:8080/**/?id=1

     请求中包含username参数（如/requestparam1?id=1），则自动传入。

@GetMapping("/user")
public String testRequestParam(@RequestParam Integer id) {
	System.out.println("获取到的id为：" + id);
	return "success";
}

@RequestBody

@RequestBody 注解用于接收前端传来的实体，接收参数也是对应的实体，比如前端通过 json 提交传来两个参数 username 和 password，此时我们需要在后端封装一个实体来接收。在传递的参数比较多的情况下，使用 @RequestBody 接收会非常方便。例如：

@PostMapping("/user")
public String testRequestBody(@RequestBody User user) {
	System.out.println("获取到的username为：" + user.getUsername());
	System.out.println("获取到的password为：" + user.getPassword());
	return "success";
}

 @RequestHeader

此注解是用来获取请求头

例如：@RequestHeader("User-Agent") String user-Agent  获取一个请求头

           @RequestHeader Map <String,String> header  获取本次事件所有的请求头

  @GetMapping("/user")
    public Map<String,Object> getUser3(@RequestHeader("Accept") String Accept,
                                       @RequestHeader Map<String,String> header){
        Map<String,Object> map=new HashMap<>();
        map.put("Accept",Accept);
        map.put("header",header);
        return map;