Résumer certaines des annotations les plus couramment utilisées en Java

Cet article présente principalement un résumé des annotations courantes utilisées dans Spring Boot. Les amis qui en ont besoin peuvent se référer aux annotations

@RestController et @RequestMapping

. 4.0 Important Une nouvelle amélioration est l'annotation @RestController, qui hérite de l'annotation @Controller. Avant la version 4.0, les composants Spring MVC utilisaient tous @Controller pour identifier la classe actuelle en tant que Controllerservlet. Grâce à cette fonctionnalité, nous pouvons développer des services REST sans utiliser @Controller mais un @RestController dédié.

Lorsque vous implémentez un service Web RESTful, la réponse sera toujours envoyée via le corps de la réponse. Pour simplifier le développement, Spring 4.0 fournit une version spécialisée du contrôleur. Jetons un coup d'œil à la définition de l'implémentation de @RestController :

@Target(value=TYPE)  
 @Retention(value=RUNTIME)  
 @Documented  
 @Controller  
 @ResponseBody  
public @interface RestController  
@Target(value=TYPE) 
 @Retention(value=RUNTIME) 
 @Documented 
 @Controller 
 @ResponseBody 
public @interface RestController

L'annotation @RequestMapping fournit des informations de routage . Il indique à Spring que toute requête HTTP provenant du chemin "/" doit être mappée à la méthode home. L'annotation @RestController indique à Spring de restituer le résultat sous la forme de string et de le renvoyer directement à l'appelant.

Remarque : les annotations @RestController et @RequestMapping sont des annotations Spring MVC (elles ne sont pas des parties spécifiques de Spring Boot)

Annotation @EnableAutoConfiguration

La deuxième annotation au niveau de la classe est @EnableAutoConfiguration. Cette annotation indique à Spring Boot de deviner comment vous souhaitez configurer Spring en fonction des dépendances jar ajoutées. Étant donné que spring-boot-starter-web ajoute Tomcat et Spring MVC, la configuration automatique supposera que vous développez une application Web et configurez Spring en conséquence. POM de démarrage et configuration automatique : le but de la conception de la configuration automatique est de mieux utiliser les "POM de démarrage", mais les deux concepts ne sont pas directement liés. Vous êtes libre de choisir les dépendances jar en dehors des POM de démarrage, et Spring Boot fera toujours de son mieux pour configurer automatiquement votre application.

Vous pouvez choisir la configuration automatique en ajoutant l'annotation @EnableAutoConfiguration ou @SpringBootApplication à une classe @Configuration.

Remarque : Il vous suffit d'ajouter une annotation @EnableAutoConfiguration. Nous vous recommandons de l’ajouter à la classe principale @Configuration.

Si vous constatez que des classes de configuration automatique spécifiques sont appliquées et que vous ne souhaitez pas, vous pouvez les désactiver à l'aide de l'attribut d'exclusion de l'annotation @EnableAutoConfiguration.

<pre name="code" class="java">import org.springframework.boot.autoconfigure.*; 
import org.springframework.boot.autoconfigure.jdbc.*; 
import org.springframework.context.annotation.*; 
@Configuration 
@EnableAutoConfiguration(exclude={DataSourceAutoConfiguration.class}) 
public class MyConfiguration { 
} 
<pre name="code" class="java">import org.springframework.boot.autoconfigure.*;
import org.springframework.boot.autoconfigure.jdbc.*;
import org.springframework.context.annotation.*;
@Configuration
@EnableAutoConfiguration(exclude={DataSourceAutoConfiguration.class})
public class MyConfiguration {
}
@Configuration

Spring Boot préconise une configuration basée sur Java. Bien que vous puissiez utiliser une source XML pour appeler SpringApplication.run() , nous vous recommandons généralement d'utiliser une classe @Configuration comme source principale. Les classes qui définissent généralement une méthode main sont également de bons candidats pour la @Configuration principale. Vous n'avez pas besoin de mettre tous les @Configuration dans une seule classe. L'annotation @Import peut être utilisée pour importer d'autres classes de configuration. Vous pouvez également utiliser l'annotation @ComponentScan pour collecter automatiquement tous les composants Spring, y compris les classes @Configuration.

Si vous devez absolument utiliser une configuration basée sur XML, nous vous recommandons de toujours commencer par une classe @Configuration. Vous pouvez charger des fichiers de configuration XML à l'aide de l'annotation supplémentaire @ImportResource.

L'annotation @Configuration de cette classe équivaut à configurer des beans en XML ; l'utilisation de la méthode d'annotation @Bean équivaut à configurer des beans en XML

@ComponentScan(basePackages = "com.hyxt",includeFilters = {@ComponentScan.Filter(Aspect.class)}) 
@ComponentScan(basePackages = "com.hyxt",includeFilters = {@ComponentScan.Filter(Aspect.class)})
@SpringBootApplication

De nombreux développeurs Spring Boot utilisent toujours @ Configuration, @EnableAutoConfiguration et @ComponentScan annotent leurs classes principales. Étant donné que ces annotations sont très fréquemment utilisées ensemble (surtout si vous suivez les meilleures pratiques ci-dessus), Spring Boot fournit une alternative pratique à @SpringBootApplication.

L'annotation @SpringBootApplication équivaut à utiliser @Configuration , @EnableAutoConfiguration et @ComponentScan avec les propriétés par défaut.

package com.example.myproject; 
import org.springframework.boot.SpringApplication; 
import org.springframework.boot.autoconfigure.SpringBootApplication; 
@SpringBootApplication // same as @Configuration @EnableAutoConfiguration @ComponentScan  
public class Application { 
  public static void main(String[] args) { 
    SpringApplication.run(Application.class, args); 
  } 
} 
package com.example.myproject;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication // same as @Configuration @EnableAutoConfiguration @ComponentScan
public class Application {
  public static void main(String[] args) {
    SpringApplication.run(Application.class, args);
  }
}

Spring Boot tentera de vérifier la configuration externe, en utilisant JSR-303 par défaut (si elle se trouve dans le chemin de classe). Vous pouvez facilement ajouter l'annotation JSR-303 javax.validationconstraints à votre classe @ConfigurationProperties :

@Component 
@ConfigurationProperties(prefix="connection") 
public class ConnectionSettings { 
@NotNull 
private InetAddress remoteAddress; 
// ... getters and setters  
} 
@Component
@ConfigurationProperties(prefix="connection")
public class ConnectionSettings {
@NotNull
private InetAddress remoteAddress;
// ... getters and setters
}
@Profiles
Spring Profiles提供了一种隔离应用程序配置的方式，并让这些配置只能在特定的环境下生效。任何@Component或@Configuration都能被@Profile标记，从而限制加载它的时机。
[java] view plain copy print?在CODE上查看代码片派生到我的代码片
@Configuration 
@Profile("production") 
public class ProductionConfiguration { 
// ...  
} 
@Configuration
@Profile("production")
public class ProductionConfiguration {
// ...
}@ResponseBody

signifie que le résultat de retour de cette méthode est écrit directement dans le corps de la réponse HTTP

est généralement utilisé lors de l'obtention de données de manière asynchrone. Après avoir utilisé @RequestMapping, la valeur de retour est généralement analysée comme un chemin de saut. Après avoir ajouté

@responsebody, le résultat renvoyé ne sera pas analysé comme un saut. chemin. Il est écrit directement dans le corps de la réponse HTTP. Par exemple,
obtient les données json de manière asynchrone, et après avoir ajouté @responsebody, les données json seront renvoyées directement.

@Composant :

泛指组件，当组件不好归类的时候，我们可以使用这个注解进行标注。一般公共的方法我会用上这个注解

@AutoWired

byType方式。把配置好的Bean拿来用，完成属性、方法的组装，它可以对类成员变量、方法及构
造函数进行标注，完成自动装配的工作。

当加上（required=false）时，就算找不到bean也不报错。

@RequestParam：

用在方法的参数前面。

@RequestParam String a =request.getParameter("a")。 
@RequestParam String a =request.getParameter("a")。

@PathVariable:

路径变量。

RequestMapping("user/get/mac/{macAddress}") 
public String getByMacAddress(@PathVariable String macAddress){ 
//do something;  
} 
RequestMapping("user/get/mac/{macAddress}")
public String getByMacAddress(@PathVariable String macAddress){
//do something;
}

参数与大括号里的名字一样要相同。

以上注解的示范

/** 
 * 用户进行评论及对评论进行管理的 Controller 类； 
 */ 
@Controller 
@RequestMapping("/msgCenter") 
public class MyCommentController extends BaseController { 
  @Autowired 
  CommentService commentService; 
  @Autowired 
  OperatorService operatorService; 
  /** 
   * 添加活动评论； 
   * 
   * @param applyId 活动 ID； 
   * @param content 评论内容； 
   * @return 
   */ 
  @ResponseBody 
  @RequestMapping("/addComment") 
  public Map<String, Object> addComment(@RequestParam("applyId") Integer applyId, @RequestParam("content") String content) { 
    .... 
    return result; 
  } 
} 
/**
 * 用户进行评论及对评论进行管理的 Controller 类；
 */
@Controller
@RequestMapping("/msgCenter")
public class MyCommentController extends BaseController {
  @Autowired
  CommentService commentService;
  @Autowired
  OperatorService operatorService;
  /**
   * 添加活动评论；
   *
   * @param applyId 活动 ID；
   * @param content 评论内容；
   * @return
   */
  @ResponseBody
  @RequestMapping("/addComment")
  public Map<String, Object> addComment(@RequestParam("applyId") Integer applyId, @RequestParam("content") String content) {
    ....
    return result;
  }
}
@RequestMapping("/list/{applyId}") 
  public String list(@PathVariable Long applyId, HttpServletRequest request, ModelMap modelMap) { 
} 
 @RequestMapping("/list/{applyId}")
  public String list(@PathVariable Long applyId, HttpServletRequest request, ModelMap modelMap) {
}

全局处理异常的：

@ControllerAdvice：

包含@Component。可以被扫描到。

统一处理异常。

@ExceptionHandler（Exception.class）：

用在方法上面表示遇到这个异常就执行以下方法。

/** 
 * 全局异常处理 
 */ 
@ControllerAdvice 
class GlobalDefaultExceptionHandler { 
  public static final String DEFAULT_ERROR_VIEW = "error"; 
  @ExceptionHandler({TypeMismatchException.class,NumberFormatException.class}) 
  public ModelAndView formatErrorHandler(HttpServletRequest req, Exception e) throws Exception { 
    ModelAndView mav = new ModelAndView(); 
    mav.addObject("error","参数类型错误"); 
    mav.addObject("exception", e); 
    mav.addObject("url", RequestUtils.getCompleteRequestUrl(req)); 
    mav.addObject("timestamp", new Date()); 
    mav.setViewName(DEFAULT_ERROR_VIEW); 
    return mav; 
  }} 
/**
 * 全局异常处理
 */
@ControllerAdvice
class GlobalDefaultExceptionHandler {
  public static final String DEFAULT_ERROR_VIEW = "error";
  @ExceptionHandler({TypeMismatchException.class,NumberFormatException.class})
  public ModelAndView formatErrorHandler(HttpServletRequest req, Exception e) throws Exception {
    ModelAndView mav = new ModelAndView();
    mav.addObject("error","参数类型错误");
    mav.addObject("exception", e);
    mav.addObject("url", RequestUtils.getCompleteRequestUrl(req));
    mav.addObject("timestamp", new Date());
    mav.setViewName(DEFAULT_ERROR_VIEW);
    return mav;
  }}

通过@value注解来读取application.properties里面的配置

# face++ key 
face_api_key = R9Z3Vxc7ZcxfewgVrjOyrvu1d-qR**** 
face_api_secret =D9WUQGCYLvOCIdsbX35uTH******** 
# face++ key
face_api_key = R9Z3Vxc7ZcxfewgVrjOyrvu1d-qR****
face_api_secret =D9WUQGCYLvOCIdsbX35uTH********
@Value("${face_api_key}") 
  private String API_KEY; 
  @Value("${face_api_secret}") 
  private String API_SECRET; 
 @Value("${face_api_key}")
  private String API_KEY;
  @Value("${face_api_secret}")
  private String API_SECRET;所以一般常用的配置都是配置在application.properties文件的

【相关推荐】

1. 特别推荐：“php程序员工具箱”V0.1版本下载

2. Java免费视频教程

3. JAVA教程手册

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!