注解（Annotation）

注解（Annotation）在 Java 中可以用来简化类的使用，使得被注解的类能够被自动发现、自动创建并在需要的地方直接调用，而不需要手动创建实例。具体来说，注解是用来标识类、方法、字段等的，它们通常与一些框架或工具结合使用（如 Spring、MyBatis 等），让程序更加简洁和灵活。

1. 注解的作用：

注解本身不会改变程序的执行逻辑，但它们提供了一种元数据，使得框架或工具能够根据这些元数据做出不同的处理。例如，Spring 使用注解来标识 Spring 管理的 Bean、自动注入依赖、定义事务等。

2. Spring 框架中的注解：

在 Spring 中，注解的使用使得类可以自动被扫描和管理，避免了我们手动创建对象。例如，使用 @Service、@Component、@Repository 和 @Controller 注解时，Spring 会自动将这些类注册为 Spring 容器中的 Bean，后续可以通过依赖注入的方式直接使用这些类。

示例：使用注解自动注入 Bean

import org.springframework.stereotype.Service;

@Service // 让 Spring 自动管理这个类的实例
public class MyService {

    public void performAction() {
        System.out.println("Action performed!");
    }
}

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

@Component
public class MyController {

    @Autowired // 自动注入 MyService 的实例
    private MyService myService;

    public void executeAction() {
        myService.performAction(); // 使用自动注入的 MyService 实例
    }
}

3. 解释：

• @Service 注解：告诉 Spring 该类是一个服务类，Spring 会自动将其注册为一个 Bean。这样你不需要手动创建 MyService 类的实例，Spring 会自动管理它的生命周期。

• @Autowired 注解：告诉 Spring 自动注入 MyService 的实例到 MyController 类中。Spring 会根据类型自动找到合适的 Bean（即 MyService）并将其注入到 myService 字段中。

通过这种方式，你不需要手动创建 MyService 和 MyController 实例，Spring 会自动完成这项工作。

4. 依赖注入（DI）：

Spring 使用注解来实现 依赖注入，即通过注解标记的类和字段，Spring 会自动进行类的实例化和注入。通过 @Autowired 注解，Spring 自动将相关依赖注入到目标类中，消除了手动创建和传递对象的繁琐步骤。

5. MyBatis 中的注解：

在 MyBatis 中，注解也用于简化 SQL 映射过程。例如，使用 @Select、@Insert 等注解，可以直接在接口方法中执行 SQL，而不需要写 XML 文件。

示例：MyBatis 中使用注解

import org.apache.ibatis.annotations.Select;

public interface UserMapper {

    @Select("SELECT * FROM user WHERE id = #{id}")
    User getUserById(Long id);
}

在上面的例子中，@Select 注解使得 getUserById 方法不需要在 XML 映射文件中定义 SQL，直接通过注解执行 SQL。

在 Java 和常见的框架（如 Spring、MyBatis 等）中，注解是用来提供元数据并使得框架能够执行相应操作的。以下是一些常用的注解，按框架和用途分类。

1. Java 常用注解

这些是 Java 核心库中提供的常见注解。

• @Override：用于标识方法重写。编译器会检查方法是否正确地重写了父类的方法。

  @Override
  public String toString() {
      return "Custom String";
  }
  

• @Deprecated：标记已废弃的类或方法，表示该类或方法不再推荐使用，并可能在将来版本中删除。

  @Deprecated
  public void oldMethod() {
      // 不推荐使用
  }
  

• @SuppressWarnings：用于抑制编译器警告。

  @SuppressWarnings("unchecked")
  public void someMethod() {
      List<String> list = new ArrayList();
  }
  

• @FunctionalInterface：用于标识接口是一个函数式接口，即只包含一个抽象方法的接口。

  @FunctionalInterface
  public interface MyFunctionalInterface {
      void performAction();
  }
  

2. Spring 常用注解

Spring 框架提供了大量注解，用于依赖注入、声明式事务、事件监听等。

• @Component：将类标记为 Spring 的 Bean，Spring 会自动扫描并创建该类的实例。所有的组件（@Controller、@Service、@Repository）本质上都是 @Component。

  @Component
  public class MyComponent {
      // Class implementation
  }
  

• @Service：标记一个服务类，通常用于标记业务层的类。

  @Service
  public class MyService {
      // Service implementation
  }
  

• @Controller：标记控制器类，通常用于 Web 层，处理请求和响应。

  @Controller
  public class MyController {
      // Controller implementation
  }
  

• @RestController：是 @Controller 和 @ResponseBody 的组合，表示这是一个 RESTful 风格的控制器，直接返回 JSON 数据。

  @RestController
  public class MyRestController {
      @GetMapping("/data")
      public Map<String, String> getData() {
          return Collections.singletonMap("message", "Hello, world!");
      }
  }
  

• @Autowired：自动注入 Bean，用于在类的字段、构造函数或方法中自动注入所需的依赖。

  @Autowired
  private MyService myService;
  

• @Value：注入外部配置文件中的值，如 application.properties 或 application.yml 中的配置。

  @Value("${app.name}")
  private String appName;
  

• @RequestMapping：定义 HTTP 请求与控制器方法的映射，通常用于定义 RESTful API 的 URL 路径。

  @RequestMapping("/home")
  public String home() {
      return "Welcome Home!";
  }
  

• @PostMapping, @GetMapping, @PutMapping, @DeleteMapping：用于简化 HTTP 请求方法的映射。

  @PostMapping("/submit")
  public ResponseEntity<String> submitData(@RequestBody MyData data) {
      return ResponseEntity.ok("Data submitted successfully!");
  }
  

• @Transactional：声明事务管理，确保操作的一致性。常用于数据库操作。

  @Transactional
  public void performTransaction() {
      // Transactional operations
  }
  

3. MyBatis 常用注解

MyBatis 提供了一些注解，用于替代 XML 映射文件来执行 SQL 操作。

• @Mapper：标记一个接口为 MyBatis 的 Mapper 接口，Spring Boot 会自动扫描并注册该接口。

  @Mapper
  public interface UserMapper {
      User getUserById(Long id);
  }
  

• @Select：指定查询 SQL，通常用于单一查询操作。

  @Select("SELECT * FROM users WHERE id = #{id}")
  User getUserById(Long id);
  

• @Insert：指定插入操作。

  @Insert("INSERT INTO users (name, age) VALUES (#{name}, #{age})")
  void insertUser(User user);
  

• @Update：指定更新操作。

  @Update("UPDATE users SET name = #{name} WHERE id = #{id}")
  void updateUser(User user);
  

• @Delete：指定删除操作。

  @Delete("DELETE FROM users WHERE id = #{id}")
  void deleteUser(Long id);
  

• @Results：用于指定复杂查询时的映射结果。

  @Select("SELECT * FROM user WHERE id = #{id}")
  @Results({
      @Result(property = "name", column = "username"),
      @Result(property = "age", column = "user_age")
  })
  User getUserById(Long id);
  

4. JavaEE 常用注解

• @Entity：标记一个类为实体类，用于 ORM 映射。

  @Entity
  @Table(name = "users")
  public class User {
      @Id
      private Long id;
      private String name;
  }
  

• @Id：标记主键字段。

  @Id
  private Long id;
  

• @GeneratedValue：用于标记主键的生成策略。

  @GeneratedValue(strategy = GenerationType.IDENTITY)
  private Long id;
  

• @Column：用于指定实体类属性与数据库列的映射关系。

  @Column(name = "username")
  private String name;
  

5. JUnit 常用注解

JUnit 是 Java 的单元测试框架，常用注解如下：

• @Test：标记一个方法为测试方法。

  @Test
  public void testAddition() {
      assertEquals(5, 2 + 3);
  }
  

• @Before 和 @After：在每个测试方法执行前后执行的操作。

  @Before
  public void setUp() {
      // setup code before each test
  }
  
  @After
  public void tearDown() {
      // cleanup code after each test
  }
  

• @BeforeClass 和 @AfterClass：在所有测试方法执行前后执行的操作（静态方法）。

  @BeforeClass
  public static void setUpBeforeClass() {
      // setup code before all tests
  }
  
  @AfterClass
  public static void tearDownAfterClass() {
      // cleanup code after all tests
  }