常用注解

@Test

@Test 是 Java 中 JUnit 测试框架中的一个注解，用于标记一个方法是一个测试方法。JUnit 是一个用于单元测试的框架，@Test 注解告诉 JUnit 这个方法是一个测试用例，JUnit 将会执行这个方法并检查它的行为是否符合预期。

使用 @Test 注解的方法必须满足以下条件：

  1. 方法必须是 public 的。
  2. 方法必须返回 void 类型。
  3. 方法不能接受任何参数。
  4. 方法上必须标记 @Test 注解。

@WebServlet

@WebServlet 是 Java EE 中用于定义 servlet 的注解。Servlet 是 Java 平台上用于处理 Web 请求的组件。

@WebServlet 注解用于将一个 Java 类声明为 servlet，并指定它处理的 URL 路径。这个注解提供了一种简单的方式来替代传统的在 web.xml 中配置 servlet 的方式。

使用 @WebServlet 注解时，你需要指定一些属性，其中最常见的是 value 或 urlPatterns 属性，用于指定 servlet 处理的 URL 路径。

1
2
3
4
5
6
7
8
@WebServlet("/hello")
public class HelloServlet extends HttpServlet {

    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws IOException {
        response.setContentType("text/html");
        response.getWriter().println("<h1>Hello, World!</h1>");
    }
}

@Component

@Component 是 Spring 框架中最基本的注解之一，用于标识一个类是 Spring 管理的组件。它通常作用在类上，告诉 Spring 在启动时扫描并实例化这些组件，并将其纳入 Spring 容器的管理之中。

@Controller

@Controller 注解用于标识一个类是 Spring MVC 中的控制器（controller）。控制器负责处理用户发起的 HTTP 请求，并返回相应的视图或数据。通常，它处理来自用户的 Web 请求，并根据业务逻辑调用适当的服务或数据访问对象来处理请求。

@Service

@Service 注解用于标识一个类是业务逻辑层（service）中的组件。服务层主要用于处理业务逻辑，通常包含了对数据的操作，如数据校验、数据转换、事务管理等。@Service 注解的类通常被用作其他组件的中介，调用它们来执行特定的业务逻辑。

@Repository

@Repository 注解用于标识一个类是数据访问层（repository）中的组件。数据访问层负责与数据库进行交互，执行数据库操作，并且提供数据持久化的功能。@Repository 注解的类通常处理数据库操作，如增删改查，并且捕获和处理数据访问相关的异常。

@AutoWired

@Autowired 是 Spring 框架中的一个注解，用于自动装配依赖关系。

在 Spring 中，通过依赖注入（Dependency Injection），对象之间的依赖关系由 Spring 容器负责管理和注入，@Autowired 注解可以自动完成这个过程，省去了手动注入的繁琐操作。

@Autowired 可以标注在字段、构造方法、setter 方法上，Spring 容器会在初始化 Bean 时自动查找匹配的依赖并注入。

规则说明：

  1. 在 IOC 容器中查找待装配的组件的类型，如果有唯一的 bean 匹配，则使用该 bean 装配
  2. 如待装配的类型对应的 bean 在 IOC 容器中有多个，则使用待装配的属性的属性名作为 id 值再进行查找, 找到就装配，找不到就抛异常
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
@Service
public class UserService {
	public void hi(){
		System.out.println("UserService hi()~");
	}
}

@Controller("userAction01")
public class UserAction {
	@Autowired
	private UserService userService;
	public void sayOk(){
		System.out.println("UserAction.userService= " + userService);
		userService.hi();
}

@AutoWired可以搭配@Qualifier使用

1
2
3
4
@Autowired
@Qualifier(value = "userService02")
//指定 id=userService02 的 UserService 对象进行组装
//等价于@Resource(name = "userService")

@Resource

@Resource 是 Java EE 中的一个注解，用于实现依赖注入。

在 Java EE 中，@Resource 注解可以用于将一个 bean 注入到另一个 bean 中。它提供了一种简单的方式来实现依赖注入，类似于 Spring 框架中的 @Autowired 注解。

@Resource 可以标注在字段、方法或构造方法上，并且可以指定要注入的资源的名称。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
@Service
public class UserService {
	public void hi(){
		System.out.println("UserService hi()~");
	}
}

@Controller("userAction")
public class UserAction {

//通过name注入,name即为ioc容器中配置的id，注解方式配置的即为类名首字母小写
@Resource(name = "userService")
//通过type注入
//@Resource(type = UserService.class)
private UserService userService;

public void hello(){
    System.out.println("say  hello...");
    userService.hi();
}

}

@Before

前置通知：在目标方法执行之前执行的通知方法。前置通知通常用于执行一些预处理操作，例如权限检查、参数验证等。

@AfterReturning

返回通知：在目标方法执行成功后（没有抛出异常）执行的通知方法。后置通知通常用于执行一些清理操作，例如资源释放、日志记录等。

@AfterThrowing

异常通知：在目标方法抛出异常后执行的通知方法。异常通知通常用于处理异常情况，例如捕获异常并进行日志记录、异常处理等。

@After

后置通知：无论目标方法是否正常执行完成（包括抛出异常或正常返回），最终通知都会执行。最终通知通常用于执行一些必须在目标方法执行之后执行的清理操作，例如资源释放、日志记录等。

@Around

环绕通知： 环绕通知包围目标方法的执行。它提供了对目标方法的完全控制，可以在目标方法执行前后自定义处理逻辑。通常，环绕通知会在通知方法内部调用目标方法的执行，但也可以选择不调用目标方法，从而完全改变目标方法的行为。

@Aspect

@Aspect 是 Spring AOP 中的一个注解，用于定义切面（Aspect）。

在 Spring 中，切面是一个包含通知（Advice）和切点（Pointcut）的组件，通知定义了在目标方法执行前、执行后或抛出异常时要执行的逻辑，而切点则定义了哪些方法会受到通知的影响。

通过 @Aspect 注解，你可以将一个普通的 Java 类声明为切面，其中的方法可以作为通知。这些方法使用特定的注解来定义通知的类型（例如 @Before、@After、@Around 等）。

@Pointcut

@Pointcut 是 Spring AOP 中的一个注解，用于定义切点（Pointcut）。

在 Spring AOP 中，切点是一个或一组方法的集合，它们定义了在哪些方法中应用切面的通知。@Pointcut 注解用于定义这些方法的表达式，使得切面可以精确地选择要拦截的方法。

通常，@Pointcut 注解可以结合 @Aspect 注解一起使用，将一个方法定义为切点，然后在通知中引用该切点。

@PostConstruct

@PostConstruct 是 Java EE 中的一个注解，用于标记一个方法在对象创建后立即调用。

在 Java EE 中，@PostConstruct 注解可以用来在对象初始化之后执行某些操作，例如初始化资源、建立数据库连接、加载配置等。通常，被 @PostConstruct 注解标记的方法会在构造方法执行之后，所有的依赖注入完成之后，以及所有的初始化工作完成之后被调用。

@Scope

@Scope 是 Spring 框架中的一个注解，用于指定 Spring 容器如何创建和管理 bean 的作用域。

在 Spring 中，bean 的作用域决定了 bean 实例的生命周期和可见范围。Spring 提供了多种作用域，包括 Singleton、Prototype、Request、Session、Application 等

  • Singleton（默认）：每个 Spring 容器中只存在一个实例。
  • Prototype：每次从容器中获取 bean 时都会创建一个新的实例。
  • Request：每个 HTTP 请求都会创建一个新的实例。
  • Session：每个 HTTP 会话都会创建一个新的实例。
  • Application：每个 ServletContext 中只存在一个实例。

@Transactional

@Transactional 是 Spring 框架中的一个注解，用于声明一个方法需要在事务管理下执行。

在 Spring 中，事务管理是对数据库操作的一种控制机制，它确保一组操作要么全部成功提交，要么全部失败回滚，以保持数据的一致性和完整性。

@Transactional 注解可以应用在方法级别或类级别上。如果应用在类级别，它将影响整个类中的所有方法。

@Transactional 注解可以用来控制事务的传播行为、隔离级别、超时时间、只读属性等。通过在方法上添加 @Transactional 注解，可以简化事务管理的配置，并使代码更加清晰和易于维护。

需要注意的是，@Transactional 注解通常用于 Service 层，而不是 DAO 层，因为事务应该围绕着业务逻辑进行管理。

@RequestMapping

@RequestMapping 是 Spring MVC 中的一个注解，用于将 HTTP 请求映射到处理器（Controller）的方法上。

在 Spring MVC 中，@RequestMapping 可以用于处理不同类型的 HTTP 请求，包括 GET、POST、PUT、DELETE 等。通过指定请求的路径、请求方法、参数等信息，可以将特定的请求映射到相应的处理器方法上。

1
2
3
4
5
6
7
8
@RestController
public class MyController {

    @RequestMapping(value = "/hello", method = RequestMethod.GET)
    public String sayHello() {
        return "Hello, World!";
    }
}

@RequestMapping(value = “/buy”,method = RequestMethod.POST) 等 价
@PostMapping(value = “/buy”)

@GetMapping

@PostMapping

@PutMapping

@DeleteMapping

@RequestParam

@RequestParam 是 Spring MVC 中的一个注解，用于从请求中获取参数值并传递给方法的参数。

在 Spring MVC 中，@RequestParam 注解可以用于处理 HTTP 请求中的查询参数（query parameters）或表单参数（form parameters），将参数的值绑定到方法的参数上。

@RequestParam String name 相当于 @RequestParam("name") String name。

当客户端发起 /hello?name=John 的 GET 请求时，Spring MVC 将会将 name 参数的值绑定到方法的 name 参数上，并执行相应的逻辑。

@RequestHeader

@RequestHeader 是 Spring MVC 中的一个注解，用于从 HTTP 请求头中获取值并传递给方法的参数。

在 Spring MVC 中，@RequestHeader 注解可以用于获取请求头中的特定信息，如 User-Agent、Content-Type 等，并将其绑定到方法的参数上。

@ResponseBody

@ResponseBody 是 Spring MVC 中的一个注解，用于指示方法的返回值直接作为 HTTP 响应的主体内容返回给客户端，而不是返回一个视图。

在 Spring MVC 中，当一个方法被标记了 @ResponseBody 注解后，Spring MVC 将会将方法的返回值转换为指定的格式（如 JSON、XML 等）并将其写入 HTTP 响应中。

@ResponseBody 注解默认会将方法的返回值转换为 JSON 格式返回给客户端。

@ResponseBody 可以直接写在 controller 上，这样对所有方法生效

@RestController

@ResponseBody + @Controller 可以直接写成 @RestController

@Conditional

@Conditional 是 Spring 框架中的一个注解，用于在满足特定条件时，决定是否创建某个 Bean 或激活某些配置。通过使用这个注解，可以实现有条件的 Bean 注册，增强应用程序的灵活性和适应性。

@Conditional 通常与实现 Condition 接口的类一起使用，这些类定义了评估条件的逻辑。如果条件满足，Bean 会被注册，否则不会。

下面是使用 @Conditional 注解的几个常见示例：

1. 基本使用示例

首先，定义一个实现 Condition 接口的类：

1
2
3
4
5
6
7
8
9
10
11
import org.springframework.context.annotation.Condition;
import org.springframework.context.annotation.ConditionContext;
import org.springframework.core.type.AnnotatedTypeMetadata;

public class MyCondition implements Condition {
    @Override
    public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) {
        // 实现你的条件逻辑
        return context.getEnvironment().containsProperty("my.condition.property");
    }
}

然后，在配置类或 Bean 定义中使用 @Conditional 注解：

1
2
3
4
5
6
7
8
9
10
11
12
13
java复制代码import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Conditional;
import org.springframework.context.annotation.Configuration;

@Configuration
public class MyConfig {

    @Bean
    @Conditional(MyCondition.class)
    public MyBean myBean() {
        return new MyBean();
    }
}

在这个例子中，如果应用程序上下文的环境中包含 my.condition.property 属性，那么 myBean 会被创建并注册到 Spring 容器中。

2. 与其他条件注解结合使用

Spring Boot 提供了一些常用的条件注解，它们是 @Conditional 注解的具体实现，例如：

  • @ConditionalOnProperty: 当特定的配置属性存在时激活。
  • @ConditionalOnClass: 当特定的类存在于类路径中时激活。
  • @ConditionalOnMissingBean: 当指定的 Bean 不存在时激活。

使用 @ConditionalOnProperty 示例

1
2
3
4
5
6
7
8
9
10
11
12
13
java复制代码import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class MyConfig {

    @Bean
    @ConditionalOnProperty(name = "feature.enabled", havingValue = "true")
    public MyBean myBean() {
        return new MyBean();
    }
}

在这个例子中，只有当配置属性 feature.enabled 设置为 true 时，myBean 才会被创建。

3. 综合示例

结合多个条件注解，可以实现更复杂的条件逻辑：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
java复制代码import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class MyConfig {

    @Bean
    @ConditionalOnClass(name = "com.example.SomeClass")
    @ConditionalOnMissingBean(MyBean.class)
    public MyBean myBean() {
        return new MyBean();
    }
}

在这个例子中，myBean 只有在类路径中存在 com.example.SomeClass 并且 Spring 容器中没有其他 MyBean 实例时才会被创建。

通过使用 @Conditional 及其具体实现注解，可以灵活地控制 Spring Bean 的创建和配置，适应不同的应用场景和需求。