Quelles sont les annotations couramment utilisées dans springmvc ?-javaDidacticiel-php.cn

Quelles sont les annotations couramment utilisées dans springmvc ?

Annotations communes SpringMVC

1. 🎜> @Controller est utilisé pour marquer une classe. La classe marquée avec est un objet SpringMVC Controller. Le processeur de répartition analysera la méthode de la classe annotée et détectera si la méthode est annotée avec @RequestMapping. @Controller définit simplement une classe de contrôleur et la méthode annotée avec @RequestMapping est le processeur qui gère réellement la requête.

La marque @Controller sur une classe ne peut pas vraiment dire qu'il s'agit d'une classe de contrôleur de SpringMVC, car Spring ne la reconnaît pas pour le moment. À l’heure actuelle, nous devons confier cette classe de contrôleur à Spring pour la gestion. Il existe deux manières de gérer :

<!--方式一-->
<bean class="com.cqvie.handler.HelloWorld"/>
<!--方式二-->
< context:component-scan base-package = "com.cqvie" /> <!-- 路径写到controller的上一层 -->

Copier après la connexion

De plus, le Controller ne dépend pas directement des objets HttpServlet tels que HttpServletRequest et HttpServletResponse. Ils peuvent être obtenus de manière flexible via les paramètres de méthode du Controller. Afin d'avoir une première impression du Controller, définissons un Controller simple :

package com.cqvie.handler;
import org.springframework.stereotype.Controller;
@Controller
public class HelloWorld {
    @RequestMapping("/helloworld")
    public String sayHello() {
        System.out.println("Hello World!");
        return "success";
    }
    
}

Copier après la connexion

2 @RequestMapping

RequestMapping est une annotation. utilisé pour gérer le mappage d’adresses de requête peut être utilisé sur des classes ou des méthodes. Utilisé sur une classe, cela signifie que toutes les méthodes de la classe qui répondent aux requêtes utilisent cette adresse comme chemin parent.

La valeur de retour sera analysée dans la vue physique réelle via l'analyseur de vue. Pour l'analyseur de vue InternalResourceViewResolver, l'analyse suivante sera effectuée :

La valeur réelle est obtenue via préfixe + returnVal. + suffixe. Vue physique, puis effectuez l'opération de transfert ;

<!-- 配置视图解析器：如何把 handler 方法返回值解析为实际的物理视图 -->
     <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
         <property name="prefix" value="/WEB-INF/views/"></property>
         <property name="suffix" value=".jsp"></property>
     </bean>

Copier après la connexion

L'annotation RequestMapping a six attributs :

1), valeur

valeur : spécifie l'adresse réelle de la demande. ;

2), méthode ;

méthode : Spécifiez le type de méthode de la requête, GET, POST, PUT, DELETE, etc., expliqué dans l'exemple suivant de @PathVariable :

/**
     * Rest 风格的 URL（以 CRUD 为例）：
     *         新增：/order POST
     *         修改：/order/1 PUT
     *         获取：/order/1 GET
     *         删除：/order/1 DELETE
     * @param id
     * @return
     */
    @RequestMapping(value = "/testRestPut/{id}", method = RequestMethod.PUT)
    public String testRestPut(@PathVariable int id) {
        System.out.println("testRestPut:" + id);
        return SUCCESS;
    }
    
    @RequestMapping(value = "/testRestDelete/{id}", method = RequestMethod.DELETE)
    public String testRestDelete(@PathVariable int id) {
        System.out.println("testRestDelete:" + id);
        return SUCCESS;
    }
    
    @RequestMapping(value = "/testRestPost/{id}", method = RequestMethod.POST)
    public String testRestPost(@PathVariable int id) {
        System.out.println("testRestPost:" + id);
        return SUCCESS;
    }
    
    @RequestMapping("/testRestGet")
    public String testRestGet() {
        System.out.println("testRestGet");
        return SUCCESS;
    }

Copier après la connexion

3), consomme

consume : Spécifiez le type de contenu de soumission (Content-Type) pour le traitement des demandes, telles que application/json, text/html ;

4), produit

produit : Spécifie le type de contenu à renvoyer. Il ne sera renvoyé que si le type (Accepter) dans l'en-tête de la requête contient le type spécifié ; 🎜>5), params

params : La requête spécifiée doit contenir certaines valeurs de paramètres avant que la méthode puisse la traiter.

6), en-têtes

en-têtes : la requête spécifiée doit contenir certaines valeurs d'en-tête spécifiées pour que cette méthode puisse traiter la requête.

@RequestMapping("/helloword/?/aa") Chemin de fourmi, caractère correspondant :

greep ? : Correspond à un caractère du nom de fichier

gird * : faire correspondre tous les caractères du nom de fichier

léger ** : faire correspondre les chemins multicouches

@RequestMapping("/testPojo") Utilisation de la classe POJO :

@RequestMapping("/testPojo")
    public String testPojo(User user) {
        System.out.println("testPojo:" + user);
        return "success";
    }
　　@RequestMapping("/testPojo") Map用法：
　　@RequestMapping("/testMap")
    public String testMap(Map<String, Object> map) {
        map.put("names", Arrays.asList("Tomcat", "Eclipse", "JavaEE"));
        return "success";
    }
　　@RequestMapping("/testPojo") ModelAndView用法：
　　@RequestMapping("/testModelAndView")
    public ModelAndView testModelAndView() {
        String viewName = SUCCESS;
        ModelAndView modelAndView = new ModelAndView(viewName);
        modelAndView.addObject("time", new Date());
        return modelAndView;
    }

Copier après la connexion

3. @Resource et @Autowired

@Resource et @Autowired sont tous deux utilisés pour l'injection de beans. En fait, @Resource n'est pas une annotation de Spring. . Le package est javax.annotation.Resource et doit être importé, mais Spring prend en charge l'injection de cette annotation. 1), points communs

Les deux peuvent être écrits sur des champs et des méthodes de définition. Si les deux sont écrits dans les champs, il n'est pas nécessaire d'écrire des méthodes de définition.

2) Différences

(1) @Autowired

@Autowired est une annotation fournie par Spring et doit importer le package org.springframework.beans.factory . annotation.Autowired ; injecté uniquement en fonction de byType.

public class HelloWorld{
    // 下面两种@Autowired只要使用一种即可
    @Autowired
    private UserDao userDao; // 用于字段上
    
    @Autowired
    public void setUserDao(UserDao userDao) { // 用于属性的方法上
        this.userDao = userDao;
    }
}

Copier après la connexion

L'annotation @Autowired assemble les objets dépendants selon le type (byType). Par défaut, elle nécessite que l'objet dépendant existe. Si les valeurs nulles sont autorisées, son attribut obligatoire peut être défini sur false. Si nous voulons assembler par nom (byName), nous pouvons l'utiliser en conjonction avec l'annotation @Qualifier. Comme suit :

public class HelloWorld{ 
　　@Autowired 
　　@Qualifier("userDao") 
　　private UserDao userDao; 
}

Copier après la connexion

(2) @Resource

@Resource est automatiquement injecté par ByName par défaut, fourni par J2EE, et nécessite d'importer le package javax.annotation.Resource. @Resource a deux attributs importants : name et type, et Spring résout l'attribut name de l'annotation @Resource en nom du bean, et l'attribut type se résout en type du bean. Par conséquent, si l'attribut name est utilisé, la stratégie d'injection automatique byName est utilisée, et lorsque l'attribut type est utilisé, la stratégie d'injection automatique byType est utilisée. Si ni l'attribut name ni l'attribut type ne sont spécifiés, la stratégie d'injection automatique byName sera utilisée via le mécanisme de réflexion.

public class HelloWorld{
    // 下面两种@Resource只要使用一种即可
    @Resource(name="userDao")
    private UserDao userDao; // 用于字段上
    
    @Resource(name="userDao")
    public void setUserDao(UserDao userDao) { // 用于属性的setter方法上
        this.userDao = userDao;
    }
}

Copier après la connexion

Remarque : Il est préférable de mettre @Resource sur la méthode setter, car elle est plus conforme à la pensée orientée objet et exploite les attributs via set et get au lieu d'exploiter directement les attributs.

4. @PathVariable

est utilisé pour mapper les variables de modèle dans l'URL de la requête aux paramètres de la méthode de traitement de la fonction, c'est-à-dire , supprimez les variables du modèle uri comme paramètres. Par exemple :

@Controller  
public class TestController {  
     @RequestMapping(value="/user/{userId}/roles/{roleId}",method = RequestMethod.GET)  
     public String getLogin(@PathVariable("userId") String userId,  
         @PathVariable("roleId") String roleId){  
         System.out.println("User Id : " + userId);  
         System.out.println("Role Id : " + roleId);  
         return "hello";  
     }  
     @RequestMapping(value="/product/{productId}",method = RequestMethod.GET)  
     public String getProduct(@PathVariable("productId") String productId){  
           System.out.println("Product Id : " + productId);  
           return "hello";  
     }  
     @RequestMapping(value="/javabeat/{regexp1:[a-z-]+}",  
           method = RequestMethod.GET)  
     public String getRegExp(@PathVariable("regexp1") String regexp1){  
           System.out.println("URI Part 1 : " + regexp1);  
           return "hello";  
     }  
}

Copier après la connexion

5, @CookieValue

Fonction : utilisée pour obtenir la valeur dans le paramètre : value : Nom du paramètre requis : S'il est requis defaultValue : Valeur par défaut Cas d'utilisation :

/**
     * 获取 Session
     * JSESSIONID=411A032E02A2594698F6E3F4458B9CE4
     */
    @RequestMapping("/testCookieValue")
    public String testCookieValue(@CookieValue("JSESSIONID") String sessionId) {
        System.out.println("JSESSIONID = " + sessionId);
        return "success";
    }

Copier après la connexion

6、@RequestParam

@RequestParam用于将请求参数区数据映射到功能处理方法的参数上，用例：

/**
     * @RequestParam("id") 带参映射
     * @param id
     * @return
     */
    @RequestMapping("/testRequestParam")
    public String testRequestParam(@RequestParam("id") int id) {
        System.out.println("testRequestParam  " + id);
        return "success";
    }

Copier après la connexion

7、@SessionAttributes

@SessionAttributes即将值放到session作用域中，写在class上面。　　

@SessionAttributes 除了可以通过属性名指定需要放到会话中的属性外（value 属性值），

还可以通过模型属性的对象类型指定哪些模型属性需要放到会话中（types 属性值）,用例：

package com.cqvie.yjq;
import java.util.Map;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.SessionAttributes;
import com.cqvie.model.User;
@SessionAttributes(value = {"user"}, types = {String.class})
@RequestMapping("/springmvc")
@Controller
public class SessionAttributesTest {
    
    /**
     * @SessionAttributes
     *         除了可以通过属性名指定需要放到会话中的属性外（value 属性值），
     *         还可以通过模型属性的对象类型指定哪些模型属性需要放到会话中（types 属性值）。
     * 注意： 该注解只能放在类的上面，不能放在方法上面
     * 
     * @return
     */
    @RequestMapping("/testSessionAttributes")
    public String testSessionAttributes(Map<String, Object> map) {
        User user = new User(1, "刘邦", "qwe", "123", "辽宁");
        map.put("user", user);
        map.put("school", "重庆");
        return "success";
    }
}

Copier après la connexion

8、@ModelAttribute

代表的是：该Controller的所有方法在调用前，先执行此@ModelAttribute方法，可用于注解和方法参数中，可以把这个@ModelAttribute特性，应用在BaseController当中，所有的Controller继承BaseController，即可实现在调用Controller时，先执行@ModelAttribute方法。

package com.cqvie.yjq;
import java.util.Map;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.ModelAttribute;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import com.cqvie.model.User;
@Controller
@RequestMapping("/springmvc")
public class ModelAttributeTest {
    private static final String SUCCESS = "success";
    
    /**
     * 1.有 @ModelAttribute 标记的方法，会在每个目标方法执行之前被 SpringMVC 调用
     * 2.@ModelAttribute注解也可以修饰目标方法POJO类形的入参，其value的属性值有如下作用：
     *     1）SpringMVC会使用value属性值在implicitModel中查找对应的对象，若存在则直接传入到目标方法的入参中
     *     2）SpringMVC会以value为key,POJO类型的对象为value，存入的request中
     * 
     * @param id
     * @param map
     */
    @ModelAttribute
    public void getUser(@RequestParam(value = "id", required = false) int id,
            Map<String, Object> map) {
        //模拟数据库中获取对象
        User user = new User(1, "刘邦", "123", "023", "重庆");
        System.out.println("从数据库中获取一个对象：" + user);
        map.put("abc", user);
    }
    
    /**
     * 运行流程：
     *         1.执行@ModelAttribute注解修饰的方法，从数据库中取出对象，把对象放入Map中，键为：user；
     *         2.SpringMVC从Map中取出User对象，并把表单的请求参数赋值给该User对象的对应属性；
     *         3.SpringMVC把上述对象传入目标方法的参数。
     * 
     * 注意：在@ModelAttribute修饰的方法中，放入到Map时的键需要和目标方法入参类型的第一个字母小写的字符串一致
     * 
     * @param user
     * @return
     */
    @RequestMapping("/testModelAttribute")
    public String testModelAttribute(@ModelAttribute("abc") User user) {
        System.out.println("修改：" + user);
        return SUCCESS;
    }
}

Copier après la connexion

9、@ResponseBody　

作用：该注解用于将Controller的方法返回的对象，通过适当的HttpMessageConverter转换为指定格式后，写入到Response对象的body数据区。

使用时机：返回的数据不是html标签的页面，而是其他某种格式的数据时（如json、xml等）使用；

本文来自php中文网，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!