Java-Spring Boot 常用开发注解
1. 组件相关注解
- @Controller：用于修饰 MVC 中控制器层的组件。Spring Boot 中的组件扫描功能会识别此注解，并为被修饰的类实例化一个对象。它通常与@RequestMapping 一起使用。当 Spring MVC 收到请求时，会将其转发到指定路径的方法进行处理。
@Controller
@RequestMapping("/user/admin")
public class UserAdminController {}
- @Service：通常用于修饰服务层的组件。声明一个对象时，会实例化该类对象并将其注入到 bean 容器中。
@Service
public class UserService {}
- @Repository：用于修饰数据访问对象（DAO）层的组件。DAO 层的组件专注于系统数据的处理，例如数据库中的数据。它们也会被组件扫描并生成实例化对象。
@Repository
public interface RoleRepository extends JpaRepository<Role, Long> {}
- @Component：一般指代组件。当组件难以分类时，可以使用此注解进行标记。其功能与@Service 类似。
@Component
public class DemoHandler {}
2. 与 Bean 实例和生命周期相关的注解
- @Bean：用于修饰方法，表示该方法将创建一个 Bean 实例，并由 Spring 容器进行管理。示例代码如下：
@Configuration
public class AppConfig {
// 相当于在 XML 中配置一个 Bean
@Bean
public Uploader initFileUploader() {
return new FileUploader();
}
}
-
@Scope：用于声明 Spring Bean 实例的作用域。作用域如下：
-
singleton：单例模式。在 Spring 容器中实例是唯一的，这是 Spring 的默认实例作用域类型。
-
prototype：原型模式。每次使用时都会重新创建实例。
-
request：在同一请求中使用相同的实例，不同请求创建新的实例。
-
session：在同一会话中使用相同的实例，不同会话创建新的实例。
-
@Configuration
public class RestTemplateConfig {
@Bean
@Scope("singleton")
public RestTemplate restTemplate() {
return new RestTemplate();
}
}
- @Primary：当存在同一对象的多个实例时，优先选择此实例。
@Configuration
@ComponentScan
public class JavaConfig {
// 首选
@Bean("b1")
@Primary
B b1() {
return new B();
}
@Bean("b2")
B b2() {
return new B();
}
}
-
@PostConstruct：用于修饰方法，在对象实例创建和依赖注入完成后执行，可用于初始化对象实例。
-
@PreDestroy：用于修饰方法，在对象实例即将被 Spring 容器移除时执行，可用于释放对象实例持有的资源。
public class Demo {
public Demo() {
System.out.println("构造方法...");
}
public void init() {
System.out.println("init...");
}
}
@PostConstruct
public void postConstruct() {
System.out.println("postConstruct...");
}
@PreDestroy
public void preDestroy() {
System.out.println("preDestroy...");
}
public void destroy() {
System.out.println("destroy...");
}
输出：
构造方法...
postConstruct...
init...
preDestroy...
destroy...
3. 依赖注入注解
- @Autowired：根据对象的类型自动注入依赖对象。默认情况下，它要求注入的对象实例必须存在。可以配置 required = false 来注入可能不存在的对象。
@Controller
@RequestMapping("/user")
public class UserController {
@Autowired
private UserService userService;
@Autowired(required = false)
private UserConfig userConfig;
}
- @Resource：默认情况下，根据对象的名称自动注入依赖对象。如果要根据类型注入，可以设置属性 type = UmsAdminService.class。
@Controller
@RequestMapping("/user")
public class UserController {
@Resource(name = "userServiceImpl")
private UserService userService;
}
- @Qualifier：当存在同一类型的多个 bean 时，使用@Autowired 导入会导致错误，表示当前对象不唯一，Spring 不知道要导入哪个依赖。此时，我们可以使用@Qualifier 进行更细粒度的控制并选择其中一个实例。它通常与@Autowired 一起使用。示例如下：
@Autowired
@Qualifier("deptService")
private DeptService deptService; `
4. SpringMVC 相关注解
-
@RequestMapping：提供路由信息，负责将 URL 映射到 Controller 中的指定函数。当用于方法上时，可以指定请求协议，如 GET、POST、PUT、DELETE 等。
-
@RequestBody：表示请求体的 Content - Type 必须是 application/json 格式的数据。接收到数据后，会自动将数据绑定到 Java 对象。
-
@ResponseBody：表示此方法的返回结果直接写入 HTTP 响应体。返回数据的格式为 application/json。 例如，如果请求参数是 json 格式，返回参数也是 json 格式，示例代码如下：
@Controller
@RequestMapping("api")
public class LoginController {
@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 {
@RequestMapping(value = "/login", method = RequestMethod.POST)
public ResponseEntity login(@RequestBody UserLoginDTO request) { //... return new ResponseEntity(HttpStatus.OK);
}
}
- @RequestParam：用于接收请求参数为表单类型的数据。通常用于方法的参数前面。示例代码如下：
@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。示例代码如下：
@RequestMapping(value = "queryProduct/{id}", method = RequestMethod.POST)
@ResponseBody
public ResponseEntity queryProduct(@PathVariable("id") String id) {
//... return new ResponseEntity(HttpStatus.OK);
}
- @GetMapping、@PostMapping、@PutMapping、@DeleteMapping：除了@RequestMapping 能够指定请求方法外，还有一些其他注解可以用于注释接口路径请求。例如，当@GetMapping 用于方法上时，表示仅支持 get 请求方法。它等同于@RequestMapping(value = "/get", method = RequestMethod.GET)。
@GetMapping("get")
public ResponseEntity get() {
return new ResponseEntity(HttpStatus.OK);
}
@PostMapping("post")
public ResponseEntity post() {
return new ResponseEntity(HttpStatus.OK);
}
@PutMapping("put")
public ResponseEntity put() {
return new ResponseEntity(HttpStatus.OK);
}
@DeleteMapping("delete")
public ResponseEntity delete() {
return new ResponseEntity(HttpStatus.OK);
}
5. 配置相关注解
- @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 中，创建与配置类对应的 Beans，并将 Bean 实体交给 IoC 容器管理。在某些场景下，如果我们想要避免某些配置类的扫描（包括避免一些第三方 jar 下的配置），可以这样处理。
@Configuration
@EnableAutoConfiguration(exclude = {org.springframework.boot.autoconfigure.security.servlet.SecurityAutoConfiguration.class})
public class AppConfig {
//...todo
}
- @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);
}
}
用这三个注解@configuration、@EnableAutoConfiguration 和@ComponentScan 替换@springBootApplication 也可以成功启动，@springBootApplication 只是简化了这三个注解。
- @EnableTransactionManagement：表示启用事务支持，相当于 xml 配置方式中的 tx:annotation - driven/>。
@SpringBootApplication
@EnableTransactionManagement
public class PropertyApplication {
public static void main(String[] args) {
SpringApplication.run(PropertyApplication.class, args);
}
}
- @ConfigurationProperties：用于批量注入外部配置，并以对象的形式导入具有指定前缀的配置。例如，这里我们在 application.yml 中指定前缀为 secure.ignored 的属性：
secure:
ignored:
urls: # 安全路径白名单
- /swagger-ui/
- /swagger-resources/**
- / **/*.htm1
- / **/*.js
- / **/*.css
- / **/*.png
- /favicon.ico
- /actuator/**
然后，在 Java 类中定义一个 urls 属性，就可以导入配置文件中的属性。
@Getter
@Setter
@Configuration
@ConfigurationProperties(prefix = "secure.ignored")
public class IgnoreUrlsConfig {
private List<String> urls = new ArrayList<>();
}
-
@Conditional：从 Spring 4 开始，@Conditional 注解可以用于有条件地加载 bean 对象。目前，在 Spring Boot 源代码中，@Condition 注解已经得到了广泛的扩展，用于实现智能自动配置，以满足各种使用场景。以下是一些常用的注解：
-
@ConditionalOnBean：当指定的 Bean 存在时，配置生效。
-
@ConditionalOnMissingBean：当指定的 Bean 不存在时，配置生效。
-
@ConditionalOnClass：当指定的类在类路径中存在时，配置生效。@ConditionalOnMissingClass：当指定的类在类路径中不存在时，配置生效。
-
@ConditionalOnExpression：当给定的 SpEL 表达式的计算结果为 true 时，配置生效。
-
@ConditionalOnProperty：当指定的配置属性具有确定的值且匹配时，配置生效。 具体应用案例如下：
-
@Configuration
public class ConditionalConfig {
/** * 当 Test 对象存在时，创建一个对象 A
*@return
*/
@ConditionalOnBean(Test.class)
@Bean
public A createA() {
return new A();
}
/** * 当 Test 对象不存在时，创建一个对象 B
*@return
*/
@Conditional0nMissingBean(Test.class)
@Bean
public B createB() {
return new B();
}
/** * 当 Test 类存在时，创建一个对象 C
*@return
*/
@Conditional0nclass(Test.class)
@Bean
public C createC() {
return new C();
}
/** * 当 Test 类不存在时，创建一个对象 D
*@return
*/
@Conditional0nMissingClass(Test.class)
@Bean
public D createD() {
return new D();
}
/** * 当 enableConfig 的配置为 true 时，创建一个对象 E
*@return
*/
@Conditiona10nExpression("$ {enableConfig:false}")
@Bean
public E createE() {
return new E();
}
/** * 当 filter.loginFilter 的配置为 true 时，创建一个对象 F
*@return
*/
@Conditiona10nProperty(prefix = "filter", name = "loginilter", havingalue = "true")
@Bean
public F createF() {
return new F();
}
}
- @Value：在任何 Spring 管理的 Bean 中，可以通过此注解获取从任何源配置的属性值。例如，在 application.properties 文件中，定义一个参数变量：
config.name=Dylan
在任何 bean 实例内，可以通过@Value 注解注入参数并获取参数变量的值。
@RestController
public class HelloController {
@Value("${config.name}")
private String configName;
@GetMapping("config")
public String config() {
return JSON.toJSONString(configName);
}
}
- @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);
}
}
6. JPA 相关注解
-
@Entity 和@Table：表示这是一个实体类。这两个注解通常一起使用。但是，如果表名与实体类名相同，@Table 可以省略。
-
@Id：表示此属性字段对应数据库表中的主键字段。
-
@Column：表示此属性字段对应的数据库表中的列名。如果字段名与列名相同，可以省略。
-
@GeneratedValue：表示主键的生成策略。有以下四个选项：
-
AUTO：表示由程序控制，是默认选项。如果未设置，则为该选项。
-
IDENTITY：表示由数据库生成，使用数据库自动递增。Oracle 不支持此方法。
-
SEQUENCE：表示主键 ID 通过数据库序列生成。MySQL 不支持此方法。
-
TABLE：表示主键由指定数据库生成。此方法有利于数据库迁移。
-
-
@SequenceGenerator：用于定义生成主键的序列。需要与@GeneratedValue 一起使用才能生效。以 role 表为例，相应的注解配置如下：
@Entity
@Table(name = "role")
@SequenceGenerator(name = "id_seq", sequenceName = "seq_repair", allocationSize = 1)
public class Role implements Serializable {
private static final long serialVersionUID = 1L;
@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
}
7. 异常处理相关注解
- @ControllerAdvice 和@ExceptionHandler：它们通常一起使用来处理全局异常。示例代码如下：
@Slf4j
@Configuration
@ControllerAdvice
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);
}
}
8. AOP 相关注解
-
@Aspect：用于定义一个切面。切面是通知和切入点的组合，它定义了在何时何地应用通知功能。
-
@Before：表示前置通知。通知方法将在目标方法调用之前执行。通知描述了切面要执行的工作以及执行的时间。
-
@After：表示后置通知。通知方法将在目标方法返回或抛出异常后执行。
-
@AfterReturning：表示返回通知。通知方法将在目标方法返回后执行。
-
@AfterThrowing：表示异常通知。通知方法将在目标方法抛出异常后执行。
-
@Around：表示环绕通知。通知方法将包装目标方法，并在目标方法调用前后执行自定义行为。
-
@Pointcut：定义切入点表达式，它定义了应用通知功能的范围。
-
@Order：用于定义组件的执行顺序。在 AOP 中，它指的是切面的执行顺序。value 属性的值越小，表示优先级越高。 示例：
/** * 统一日志处理切面 */
@Aspect
@Component
@Order(1)
public class WebLogAspect {
private static final Logger LOGGER = LoggerFactory.getLogger(WebLogAspect.class);
@Pointcut("execution(public * com.dylan.smith.web.controller.*.*(..))")
public void webLog() {
}
@Before("webLog()")
public void doBefore(JoinPoint joinPoint) throws Throwable {
}
@AfterReturning(value = "webLog()", returning = "ret")
public void doAfterReturning(Object ret) throws Throwable {
}
@Around("webLog()")
public Object doAround(ProceedingJoinPoint joinPoint) throws Throwable {
WebLog webLog = new WebLog();
//...TODO
Object result = joinPoint.proceed();
LOGGER.info("{}", JSONUtil.parse(webLog));
return result;
}
}
9. 测试相关注解
-
@Test：指定一个方法为测试方法。
-
@ActiveProfiles：一般应用于测试类，用于声明活动的 Spring 配置文件。例如，指定 application - dev.properties 配置文件。
-
@RunWith 和@SpringBootTest：一般应用于测试类，用于单元测试。示例如下：
@ActiveProfiles("dev")
@RunWith(SpringRunner.class)
@SpringBootTest
public class TestJunit {
@Test
public void executeTask() {
//...todo
}
}
本文是原创文章，采用 CC BY-NC-ND 4.0 协议，完整转载请注明来自 枫月Blog
阅读建议
评论
匿名评论
隐私政策
你无需删除空行，直接评论以获取最佳展示效果
