Introduction détaillée à la configuration de base de SpringMVC

Cet article vous apporte une introduction détaillée à la configuration de base de SpringMVC. Il a une certaine valeur de référence. Les amis dans le besoin peuvent s'y référer.

Aujourd'hui, nous allons parler de la configuration de base de SpringMVC. Actuellement, de plus en plus de frameworks grand public prennent en charge les annotations, et notre invincible Spring prend également en charge la « configuration zéro » basée sur les annotations.

Avantages des annotations par rapport à XML : Il peut utiliser pleinement le mécanisme de réflexion de Java pour obtenir des informations structurelles dans une classe. Ces informations peuvent réduire efficacement le travail de configuration. Les annotations et le code Java sont situés dans un seul fichier. plus pratique pour l'entretien.

Remarque : les annotations ne peuvent être utilisées qu'après la version Spring 2.5.

La méthode d'annotation combine les informations de définition du Bean et la classe d'implémentation du Bean. Les annotations fournies par Spring incluent.

@Component : Déclarer une classe Bean commune

@Repository : Déclarer une classe Dao de couche de persistance

@Service : Déclarer une classe de couche métier

@Controller : Déclarez une classe de contrôleur

Je pense que vous connaissez déjà très bien ces quatre annotations, donc pas besoin de dire des bêtises. Lorsque nous utilisons des annotations, n’oubliez pas de les scanner en classe ! ! !

@RequestMapping (une annotation très centrale), cette annotation est utilisée pour spécifier l'URL de requête du contrôleur.

Définition de la classe dans le contrôleur : fournissez des informations de mappage préliminaires et ajoutez un préfixe à toutes les méthodes de requête sous la classe.

Définition de la méthode dans la classe du contrôleur : fournissez des informations de mappage supplémentaires et fournissez le chemin de requête de la méthode

Une fois que DispacherServlet a intercepté la requête, confirmez le mode de traitement correspondant à la requête grâce aux informations de mappage fournies par @RequestMapping sur le contrôleur.

@Controller
@RequestMapping("user")
public class UserController {
    @RequestMapping("/hello")
    public String hello(){
        return "hello";
    }
}

À l'heure actuelle, le chemin que nous demandons est http://localhost:8080/SpringMvcDemo2/user/hello

@RequestMapping En plus des requêtes d'URL de demande de mappage, vous pouvez également utiliser la méthode requêtes, le paramètre de requête et l'en-tête de requête request, il y a plusieurs paramètres dans l'annotation :

1) valeur : indique l'URL demandée

2) méthode : indique la méthode de requête (GET/POST)

3) params : Représente les paramètres de la requête

4) heads : En-têtes de la requête

La relation entre eux est et L'utilisation conjointe de. plusieurs requêtes peuvent rendre la requête plus précise.

@RequestMapping(value="hello2",method=RequestMethod.POST,params={"username","userpass"},headers="contentType=text/*") 
   public String hello2(){
           return "hello";
    }

Ce code indique que l'adresse demandée est hello. La méthode de requête est Post et doit contenir deux paramètres : username et userpass. L'en-tête de requête contentType doit commencer par text/. Nous pouvons écrire deux URL avec la même méthode. La méthode de requête, une POST et l'autre GET, sera appelée strictement en fonction des paramètres

@RequestMapping prend également en charge les URL de style Ant et prend en charge 3 caractères génériques dans Ant. .

? : Indique la configuration d'un personnage.

* : faire correspondre n'importe quel caractère

** : faire correspondre les chemins multicouches

Traitement des paramètres dans SpringMVC :

@pathVariable : méthode de modèle d'URL

Utilisée pour mapper les espaces réservés dans les URL. Les noms des variables mappées doivent être cohérents avec les noms dans les espaces réservés, comme celui-ci. L'adresse de la requête sera http : //localhost:8080/SpringMvcDemo2/user/testPathVariable/Miya. Ce miya est le paramètre que nous avons passé dans l'URL traditionnelle, testPathVariable ? username=miya mais cela n'est pas propice à l'inclusion de Baidu.

@RequestMapping("/testPathVariable/{username}")
    public String hello3(@PathVariable("username")String username){
        System.out.println("username :  " + username);        
        return "hello";
    }

@RequestParam : Récupère les paramètres de la requête. Si le nom du paramètre de la requête est cohérent avec le nom du type, nous pouvons omettre cette annotation et la valeur peut toujours. être reçu.

@RequestMapping("/textParam")
    public String hello4(@RequestParam("username")String username,@RequestParam("userpass")String userpass){
        System.out.println("userpass :  " + userpass);        
        return "hello";
    }

@RequestHeader : Récupère les paramètres de l'en-tête de la requête

Il y a trois paramètres ici, valeur : le nom du spécifié paramètre, obligatoire : Spécifie si le paramètre est obligatoire, defaultValue : spécifie la valeur par défaut du paramètre.

@RequestMapping("/testRequestHeader")
    public String hello5(@RequestHeader("Accept-Language") String language){
        System.out.println("language=" + language);       
        return "hello";
    }

@CookieValue : utilisé pour obtenir des informations sur les cookies du client.

@RequestMapping("/testCookieValue")    
public String hello6(@CookieValue("JSESSIONID")String sessionid){
        System.out.println("sessionid=" + sessionid);        
        return "hello";
    }

SpringMVC peut utiliser ServletAPI comme paramètre de la méthode de requête

@RequestMapping("/testServletAPI")    
public String hello7(HttpServletRequest request,HttpServletResponse response,HttpSession session){        
//我们可以在这里使用
        return "hello";
    }

SpringMVC fournit les modèles de traitement suivants moyen de données.

1) ModelAndView : définissez le type de retour de la méthode de traitement sur le corps de la méthode ModelAndView pour ajouter des données de modèle via l'objet de modèle. Contient à la fois des vues et des informations sur le modèle

@RequestMapping("/testModelAndView")
    public ModelAndView hello8(){
        ModelAndView modelAndView = new ModelAndView("hello");
        //添加单个值
        modelAndView.addObject("h","Hello Spring MVC");        
        return modelAndView;
    }

2) Carte et paramètres formels : lorsque les paramètres formels sont Map, Model et ModelMap, la méthode de traitement renvoie , les données de la carte seront automatiquement ajoutées au modèle.

Spring MVC utilise en interne une interface de modèle pour stocker les données et crée un objet modèle implicite qui sert de conteneur de stockage. pour le modèle de données. Si les paramètres transmis sont Map, Model, ModelMap, SpringMVC l'enregistrera automatiquement dans le conteneur

@RequestMapping("/testMap")    
public String hello9(Map<String,Object> map){
        map.put("mapdata", "map data");       
        return "hello";
    }

3）@SessionAttributes：将这个模型中的某个属性存储到Session中，以便多个请求之间共享这个属性，只能用来修饰类。在里面的方法如果参数容器中如map里卖弄保存一个与定义的属性名字相同会保存到容器中共享

4）@ModelAttribute：方法形参标记该注解后，形参对象就会放到模型中。

　　SpringMVC在调用方法之前会逐个调用方法上标注了这个注解的方法。将@ModelAttribute中的属性保存到map中，可在执行表单提交生成对象之前，替换执行方法名相同的参数。

@ModelAttribute
public User getUser(){
    User user = new User();
    System.out.println("调用 getUser 方法");
    //默认保存名字为类名首字母小写的user对象到Request中
    return user;
}
@ModelAttribute
public void getUserById(Integer id,Map<String,Object> map){
    User myuser = new User();
    map.put("myuser", myuser);
    //手动指定user对象的名称，到Request中
    System.out.println("调用 getUser 方法");
}

由@SessionAttributs会引发一个很容易轻视的错误当类使用@SessionAttributes修饰，而方法中使用了和SessionAttributes修饰同名的映射参数，确没有添加@ModelAttribute修饰时，则会报错。

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!