当前位置：首页 > news >正文

注解（Annotation）

news 来源：原创 2025/5/14 7:44:19

注解（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 {@Idprivate 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
}