"wink

"wink

关注
发信
关注(28)粉丝(399)

SpringBoot 菜鸟必备常用注解（简单易懂）

1. @SpringBootApplication

  • @SpringBootApplication注解是 Spring Boot 应用的入口，它包含了 @Configuration、@EnableAutoConfiguration 和 @ComponentScan 三个注解。
@SpringBootApplication
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

2. @Configuration

  • @Configuration注解是Spring框架中的一个注解，用于标识一个类为配置类，相当于XML配置文件中的<beans>标签。在@Configuration注解的类中，可以使用@Bean注解来定义一个Bean，相当于XML配置文件中的<bean>标签。
@Configuration
public class AppConfig {
 
    @Bean
    public MyService myService() {
        return new MyServiceImpl();
    }
 
    @Bean
    public MyController myController() {
        return new MyController(myService());
    }
}

使用@Configuration注解的好处是可以将所有的配置信息集中在一个类中，方便管理和维护。同时，使用Java代码来配置Bean比使用XML配置文件更加直观和易于理解。

3. @EnableAutoConfiguration

  • @EnableAutoConfiguration是Spring Boot的核心注解之一，它的作用是开启Spring Boot的自动配置功能。在Spring Boot应用中，我们只需要添加这个注解，就可以让Spring Boot自动根据项目中的依赖关系来进行自动配置，无需手动编写大量的配置文件。
  • @EnableAutoConfiguration注解的实现原理是通过Spring Boot提供的SpringFactoriesLoader机制来实现的。SpringFactoriesLoader会扫描classpath下所有META-INF/spring.factories文件，然后根据文件中定义的配置类来进行自动配置。
@SpringBootApplication
@EnableAutoConfiguration
public class DemoApplication {
    public static void main(String[] args) {
        SpringApplication.run(DemoApplication.class, args);
    }
}

当我们启动这个应用时，Spring Boot会自动扫描项目中的依赖关系，并根据依赖关系自动配置应用程序。例如，如果我们在pom.xml文件中添加了Spring MVC依赖，Spring Boot会自动配置Spring MVC相关的组件，例如DispatcherServlet、ViewResolver等。

4. @ComponentScan

  • @ComponentScan注解用于自动扫描指定包及其子包下的所有类，并将其注册为Spring容器中的Bean。该注解可以用在@Configuration注解的类中，也可以用在普通的@Component注解的类中。
@Configuration
@ComponentScan(basePackages = "com.it")
public class AppConfig {
    // 配置其他Bean
}

5. @RequestMapping

  • @RequestMapping注解用于映射 HTTP 请求路径和方法到控制器的方法上。
@Controller
@RequestMapping("/hello")
public class HelloController {

    @RequestMapping(method = RequestMethod.GET)
    public String sayHello() {
        return "hello";
    }
}
  • @RequestMapping注解还可以用于指定请求参数、请求头、请求体等信息：
@Controller
@RequestMapping("/user")
public class UserController {

    @RequestMapping(value = "/{id}", method = RequestMethod.GET)
    public String getUser(@PathVariable("id") Long id, Model model) {
        User user = userService.getUserById(id);
        model.addAttribute("user", user);
        return "user";
    }

    @RequestMapping(value = "/add", method = RequestMethod.POST)
    public String addUser(@ModelAttribute("user") User user) {
        userService.addUser(user);
        return "redirect:/user/" + user.getId();
    }
}

6. @GetMapping

  • @GetMapping注解用于将HTTP GET请求映射到特定的处理程序方法上。
  • 它可以用于处理简单的HTTP GET请求，也可以用于处理带有路径变量的请求。
@RestController
@RequestMapping("/api")
public class MyController {
    
    @GetMapping("/hello")
    public String sayHello() {
        return "Hello, World!";
    }
    
    @GetMapping("/users/{id}")
    public User getUser(@PathVariable Long id) {
        // 根据id查询用户信息
        User user = userService.getUserById(id);
        return user;
    }
}

7. @PostMapping

  • @PostMapping注解用于将HTTP POST请求映射到特定的处理方法上。
  • 它是@RequestMapping注解的一个变体，用于简化处理POST请求的代码。
@RestController
@RequestMapping("/users")
public class UserController {

    @PostMapping
    public User createUser(@RequestBody User user) {
        // 处理创建用户的逻辑
        return user;
    }
}

在上面例子，@PostMapping用于将HTTP POST请求映射到createUser方法上。@RequestBody用于将请求体中的JSON数据转换为User对象。

8. @Autowired

  • @Autowired是Spring框架中的一个注解，用于自动装配Bean。它可以自动将一个Bean注入到另一个Bean中，无需手动编写代码进行依赖注入。
  • 使用@Autowired注解时，Spring会根据类型进行自动装配，如果有多个类型相同的Bean，可以使用@Qualifier注解指定具体的Bean。如果无法找到匹配的Bean，则会抛出异常。
@Service
public class UserServiceImpl implements UserService {

    @Autowired
    private UserDao userDao;

    @Override
    public User getUserById(int id) {
        return userDao.getUserById(id);
    }
}

@Repository
public class UserDaoImpl implements UserDao {

    @Override
    public User getUserById(int id) {
        // 查询数据库获取用户信息
        return user;
    }
}

9. @Resource

  • @Resource注解是Java EE标准中提供的一种注入依赖对象的方式，它可以自动装配一个指定的bean，从而避免手动实例化对象的繁琐和容易出错。
  • 在需要注入依赖的类中声明@Resource注解，并指定要注入的bean的名称或类型：
public class MyClass {
    
    @Resource(name = "myBean")
    private MyBean myBean;
    
    // 或者
    
    @Resource
    private OtherBean otherBean;
}
  • 在Spring配置文件中定义要注入的bean：
<bean id="myBean" class="com.example.MyBean">
    <property name="name" value="example" />
</bean>

<bean id="otherBean" class="com.example.OtherBean">
    <!-- ... -->
</bean>

另外，@Resource注解还可以用于注入JNDI资源、EJB等，具体用法与上述相似。

10.@Qualifier

  • @Qualifier是根据Bean的名称或者ID进行装配的。
  • 在Spring框架中，当存在多个同类型的Bean时，可以使用@Qualifier注解来指定具体要使用哪一个Bean。
  • 在需要注入依赖的类中声明@Autowired注解，并结合@Qualifier注解指定要注入哪个Bean：
public class MyClass {
    
    @Autowired
    @Qualifier("myBean")
    private MyBean myBean;
    
    // 或者
    
    @Autowired
    @Qualifier("otherBean")
    private OtherBean otherBean;
}
  • 在Spring配置文件中定义要注入的Bean，并指定对应的名称或ID：
<bean id="myBean" class="com.example.MyBean">
    <property name="name" value="example" />
</bean>

<bean id="otherBean" class="com.example.OtherBean">
    <!-- ... -->
</bean>

另外，@Qualifier注解也可以和@Primary注解结合使用，以提供默认的Bean选择方案。如果没有指定@Qualifier注解，则会自动选择标记了@Primary注解的Bean。

11. @Component

  • @Component注解用于标记一个类是 Spring Bean，它会被自动扫描并注册到 Spring 容器中。
@Component
public class MyComponent {
    // ...
}

12. @Service

  • @Service注解用于标识一个类为服务层组件。在Spring中，服务层组件通常用于处理业务逻辑，调用数据访问层组件进行数据操作，并将处理结果返回给控制层组件。
  • 该注解可以让Spring自动扫描并创建服务层组件的实例，同时也可以通过依赖注入的方式将服务层组件注入到其他组件中使用。
@Service
public class UserServiceImpl implements UserService {
    // ...
}

13. @Controller

  • @Controller注解用于标识一个类是控制器（Controller）。
  • 控制器是处理用户请求的组件，它接收用户请求，调用业务逻辑处理，最终返回视图给用户。
@Controller
@RequestMapping("/hello")
public class HelloController {
    
    @RequestMapping("/world")
    public String helloWorld() {
        return "helloWorld";
    }
}

14. @Repository

  • @Repository用于标识一个类为数据访问层（DAO）的组件，通常与@Autowired注解一起使用，实现依赖注入。
  • @Repository注解的作用是Spring框架中用于标识数据访问层（DAO）实现类的注解，它可以将这些实现类标识为Spring容器中的Bean，并提供异常转换功能，方便上层调用者处理异常。
@Repository
public class UserDaoImpl implements UserDao {
    // ...
}

- @Repository注解还可以指定一个value属性，用于指定Bean的名称。

@Repository("userDao")
public class UserDaoImpl implements UserDao {
    // ...
}

15. @ResponseBody

  • @ResponseBody是Spring MVC框架中的一个注解，用于将Controller方法返回的对象转换为指定格式的数据，比如JSON、XML等格式，然后将其写入HTTP响应中。
  • 然后通过HTTP响应返回给客户端。这样客户端就可以直接解析这些数据，而不需要再进行额外的处理。
@RestController
@RequestMapping("/users")
public class UserController {
    
    @Autowired
    private UserService userService;
    
    @GetMapping("/{id}")
    public ResponseEntity<User> getUserById(@PathVariable Long id) {
        User user = userService.getUserById(id);
        if (user == null) {
            return ResponseEntity.notFound().build();
        }
        return ResponseEntity.ok(user);
    }
    
    @PostMapping
    public ResponseEntity<User> createUser(@RequestBody User user) {
        User savedUser = userService.createUser(user);
        return ResponseEntity.ok(savedUser);
    }
    
    @PutMapping("/{id}")
    public ResponseEntity<User> updateUser(@PathVariable Long id, @RequestBody User user) {
        User updatedUser = userService.updateUser(id, user);
        if (updatedUser == null) {
            return ResponseEntity.notFound().build();
        }
        return ResponseEntity.ok(updatedUser);
    }
    
    @DeleteMapping("/{id}")
    public ResponseEntity<Void> deleteUser(@PathVariable Long id) {
        boolean deleted = userService.deleteUser(id);
        if (!deleted) {
            return ResponseEntity.notFound().build();
        }
        return ResponseEntity.noContent().build();
    }
}
  • 注意：如果使用@RestController注解来标识Controller类，那么所有的方法都会默认使用@ResponseBody注解，因此在方法上使用@ResponseBody注解是可选的。

16.@RequestParam

  • @RequestParam注解是Spring MVC框架中用于绑定请求参数的注解，它可以将请求参数绑定到方法的参数上。

  • @RequestParam注解有以下属性：

  • value：请求参数的名称。

  • required：是否必须，默认为true。

  • defaultValue：请求参数的默认值。

在这里插入代码片@Controller
@RequestMapping("/user")
public class UserController {

    @GetMapping("/info")
    public String getUserInfo(@RequestParam("id") Long userId, Model model) {
        // 根据用户ID查询用户信息
        User user = userService.getUserById(userId);
        // 将用户信息添加到模型中
        model.addAttribute("user", user);
        // 返回用户信息页面
        return "user/info";
    }
}

17. @PathVariable

  • @PathVariable注解是Spring MVC框架中用于获取请求路径中的参数值的注解。
  • 它可以将请求路径中的占位符参数绑定到方法的参数上，从而方便地获取请求参数。
@RestController
@RequestMapping("/users")
public class UserController {

    @GetMapping("/{id}")
    public User getUserById(@PathVariable Long id) {
        // 根据id查询用户信息
        User user = userService.getUserById(id);
        return user;
    }
}

18. @RequestHeader

  • @RequestHeader注解用于获取HTTP请求头中的值。
  • 它可以用在Controller的方法参数上，表示将请求头中指定名称的值注入到方法参数中。
@GetMapping("/user-agent")
public String getUserAgent(@RequestHeader("User-Agent") String userAgent) {
    return "User-Agent: " + userAgent;
}
  • @RequestHeader注解还可以指定一些可选属性，例如required、defaultValue等。
  • required属性表示该请求头是否必须存在，默认为true；
  • defaultValue属性表示当请求头不存在时，使用的默认值。
@GetMapping("/user-info")
public String getUserInfo(@RequestHeader("User-Agent") String userAgent,
                           @RequestHeader(value = "Accept-Language", defaultValue = "en-US") String acceptLanguage) {
    return "User-Agent: " + userAgent + "\nAccept-Language: " + acceptLanguage;
}

20. @CookieValue

  • @CookieValue注解是Spring MVC中的一个注解，用于将指定的cookie值绑定到方法的参数上。
  • 使用@CookieValue注解需要指定两个参数，分别是cookie的名称和默认值。如果指定的cookie不存在，则使用默认值。
@GetMapping("/user")
public String getUserInfo(@CookieValue(value = "token", defaultValue = "") String token) {
    // do something with token
    return "user";
}
  • @CookieValue注解还支持使用SpEL表达式来动态获取cookie的名称和默认值。
@GetMapping("/user")
public String getUserInfo(@CookieValue("#{cookieNameResolver.resolve('token')}") String token) {
    // do something with token
    return "user";
}

21. @RestController

  • @RestController是@Controller和@ResponseBody的结合体，用于标记一个类是 RESTful 风格的控制器，它的方法返回的数据会直接写入 HTTP 响应体中。
@RestController
public class HelloController {
    @GetMapping("/hello")
    public String hello() {
        return "Hello, World!";
    }
}

22. @Bean

  • @Bean注解用于将一个方法返回的对象注册为一个Bean，使其可以被Spring容器管理和使用。
  • 该注解通常与@Configuration注解一起使用，用于声明一个配置类，并在其中定义多个@Bean方法，每个方法返回一个对象，这些对象都将被注册为Spring容器中的Bean。
@Configuration
public class AppConfig {
    
    @Bean
    public UserService userService() {
        return new UserServiceImpl();
    }
    
    @Bean
    public UserDao userDao() {
        return new UserDaoImpl();
    }
}

23. @Value

  • 在Spring框架中，@Value注解可以用来注入外部配置文件或者动态生成的值，例如数据库连接地址、用户名密码。
  • 在需要注入依赖的类中声明@Value注解，并指定要注入的值：
public class MyClass {
    
    @Value("${database.url}")
    private String dbUrl;
    
    // 或者
    
    @Value("#{systemProperties['user.home']}")
    private String userHome;
}
  • 在Spring配置文件中定义要注入的值：
<context:property-placeholder location="classpath:config.properties" />

<!-- ... -->

<bean id="myBean" class="com.example.MyBean">
    <property name="dbUrl" value="${database.url}" />
</bean>

另外，@Value注解还可以和@PropertySource注解结合使用，以指定要读取的配置文件。

24. @ConfigurationProperties

  • @ConfigurationProperties可以将配置文件中的属性值自动绑定到Java Bean中。
  • 在需要注入配置属性的Java Bean中声明@ConfigurationProperties注解，并指定要绑定的属性前缀：
@ConfigurationProperties(prefix = "database")
public class DatabaseConfiguration {
    
    private String url;
    
    private String username;
    
    private String password;
    
    // getter和setter
}
  • 在配置文件中定义要绑定的属性：
database.url=jdbc:mysql://localhost:3306/test

database.username=root

database.password=123456
  • 注意：当属性名和Java Bean中的属性名不完全一致时，可以通过在Java Bean的属性上使用@Value注解来进行映射：
@ConfigurationProperties(prefix = "database")
public class DatabaseConfiguration {
    
    @Value("${database.jdbc-url}")
    private String url;
    
    @Value("${database.user-name}")
    private String username;
    
    @Value("${database.password}")
    private String password;
    
    // getter和setter
}
  • 另外，@ConfigurationProperties注解还可以结合@EnableConfigurationProperties注解一起使用，在应用启动时自动扫描并注入Java Bean：
@Configuration
@EnableConfigurationProperties(DatabaseConfiguration.class)
public class MyAppConfiguration {
    
    // ...
}

25. @PropertySource

  • @PropertySource注解是Spring框架中的一个注解，用于指定一个或多个属性文件的位置，以便在应用程序中使用这些属性。
  • 创建一个属性文件，例如application.properties，其中包含一些属性值：
db.username=root
db.password=123456
db.url=jdbc:mysql://localhost:3306/test
  • 在Spring配置类中使用@PropertySource注解指定属性文件的位置：
@Configuration
@PropertySource("classpath:application.properties")
public class AppConfig {
    // ...
}
  • 在需要使用属性值的地方，使用@Value注解注入属性值：
@Service
public class UserServiceImpl implements UserService {
    @Value("${db.username}")
    private String username;
    
    @Value("${db.password}")
    private String password;
    
    @Value("${db.url}")
    private String url;
    
    // ...
}

@PropertySource注解可以帮助我们在Spring应用程序中轻松地管理属性文件，使得我们可以更方便地配置应用程序。

05-24 04:40
Powered by LMLPHP ©2024 "wink 0.002174