Framework SpringMVC (toutes les bases)

Language 2023-06-25 08:23:03 views: null

Table des matières

Qu'est-ce que MVC

Présentation de Spring MVC

Méthodes de développement courantes de SpringMVC

Processus d'exécution de SpringMVC

Introduction aux composants principaux de SpringMVC

Créez rapidement des programmes Spring MVC

Liaison de paramètre SpringMVC

Méthode de saut SpringMVC

SpringMVC gère les requêtes et les réponses json

Traitement des ressources statiques SpringMVC

SpringMVC exploite une session et un cookie

Intercepteur SpringMVC

Téléchargement de fichier SpringMVC

Traitement unifié des exceptions globales SpringMVC

Intégration du cadre SSM

1. Introduire les dépendances pom

2. Définissez le fichier de configuration

3. Structure du répertoire du projet

Qu'est-ce que MVC

Le modèle de conception MVC fait généralement référence au cadre MVC, M (Modèle) fait référence à la couche de modèle de données, la couche de modèle d'entreprise, V (Vue) fait référence à la couche de vue et C (Contrôleur) fait référence à la couche de contrôle. Le but de l'utilisation de MVC est de séparer les codes d'implémentation de M et V, de sorte qu'un même programme puisse avoir des expressions différentes.

MVC est une sorte de modèle architectural , la soi-disant architecture est la façon de concevoir la structure d'un programme. MVC divise la structure du programme en trois couches, et chaque couche fournit une interface pour la couche supérieure à appeler, qui peut non seulement maintenir la connexion entre les trois couches, mais également maintenir une relative indépendance.

Cette forme d'organisation du code qui sépare la logique métier, les données et les interfaces réduit le couplage entre les modules et est propice à la maintenance et à l'expansion futures.

Présentation de Spring MVC

springmvc est un framework mvc dérivé de spring Framwork. Il résout principalement le problème du contrôleur (Controller) dans l'architecture mvc d'origine. Les contrôleurs courants incluent servlet, struts2, etc. La fonction principale du contrôleur est d'appeler le contrôleur correspondant en fonction de la demande de l'utilisateur. Les fonctions commerciales, puis contrôlent le processus d'exécution du programme en fonction des résultats du traitement commercial.

Problèmes avec les contrôleurs d'implémentation de servlet :

1. Lors de la réception des paramètres de demande du client, il y a une redondance de code

2. Ne peut recevoir que des données de type chaîne, les autres types de données nécessitent une conversion manuelle

3. Impossible de recevoir les paramètres de type d'objet

4. Il y a couplage dans l'appel des objets métier (nouveau)

5. Il y a couplage dans le saut de processus (couplage de chemin, couplage de vue)

Méthodes de développement courantes de SpringMVC

1. Méthodes de développement traditionnelles

Réaliser le transfert de données via la portée (demande, session)

Afficher le rendu via la technologie d'affichage (jsp thymleaf freeMarker)

2. Méthodes de développement séparées front-end et back-end

Plusieurs nouvelles méthodes d'accès (get, post, put, delete)

Accès style reposant

Processus d'exécution de SpringMVC

Le framework Spring MVC est hautement configurable et comprend plusieurs technologies d'affichage telles que JSP, FreeMarke et POI. Le framework Spring MVC ne se soucie pas de la technologie d'affichage utilisée et n'oblige pas les développeurs à utiliser uniquement JSP.

Le flux d'exécution Spring MVC est illustré dans la figure :

 

Le flux d'exécution de SpringMVC est le suivant :

  1. L'utilisateur clique sur un chemin de requête pour lancer une requête HTTP, qui sera soumise à DispatcherServlet (contrôleur frontal) ;

  2. DispatcherServlet demande un ou plusieurs HandlerMapping (mappeur de processeur) et renvoie une chaîne d'exécution (HandlerExecutionChain).

  3. DispatcherServlet envoie les informations Handler renvoyées par la chaîne d'exécution à HandlerAdapter (adaptateur de processeur) ;

  4. HandlerAdapter trouve et exécute le gestionnaire correspondant (souvent appelé contrôleur) en fonction des informations du gestionnaire ;

  5. Une fois le gestionnaire exécuté, il renverra un objet ModelAndView au HandlerAdapter (l'objet sous-jacent de Spring MVC, y compris le modèle de données Model et les informations de vue View);

  6. Une fois que le HandlerAdapter a reçu l'objet ModelAndView, il le renvoie au DispatcherServlet ;

  7. Une fois que DispatcherServlet a reçu l'objet ModelAndView, il demande à ViewResolver (résolveur de vue) de résoudre la vue ;

  8. ViewResolver fait correspondre le résultat de la vue correspondante en fonction des informations de la vue et le renvoie à DispatcherServlet ;

  9. Après avoir reçu la vue de vue spécifique, DispatcherServlet rend la vue, remplit les données de modèle dans le modèle dans le champ de demande de la vue de vue et génère la vue finale (vue) ;

  10. La vue est responsable de l'affichage des résultats au navigateur (client)

Introduction aux composants principaux de SpringMVC

Les composants impliqués dans Spring MVC sont DispatcherServlet (contrôleur frontal), HandlerMapping (mapper de processeur), HandlerAdapter (adaptateur de processeur), Handler (processeur), ViewResolver (résolveur de vue) et View (vue). Les fonctions de chaque composant sont décrites ci-dessous.

1）DispatcherServlet

DispatcherServlet est le contrôleur frontal. Comme le montre la figure 1, toutes les requêtes de Spring MVC doivent être distribuées uniformément via DispatcherServlet. DispatcherServlet est l'équivalent d'un transitaire ou d'un processeur central, qui contrôle l'exécution de l'ensemble du processus et planifie uniformément chaque composant pour réduire le couplage entre les composants et faciliter l'expansion entre les composants.

2) Cartographie du gestionnaire

HandlerMapping est un mappeur de gestionnaire, sa fonction est de trouver des informations de gestionnaire (Handler) correspondantes via une annotation ou une configuration XML en fonction du chemin d'URL de la demande.

3) adaptateur de gestionnaire

HandlerAdapter est un adaptateur de processeur, dont la fonction est d'exécuter le processeur concerné (Handler) selon des règles spécifiques en fonction des informations de processeur (Handler) trouvées par le mappeur.

4）Gestionnaire

Handler est un processeur, ce qui est cohérent avec le rôle joué par Java Servlet. Sa fonction est d'exécuter la logique de traitement des requêtes associées, de renvoyer les données correspondantes et d'afficher les informations, et de les encapsuler dans l'objet ModelAndView.

5）Afficher le résolveur

View Resolver est un résolveur de vue, son rôle est d'effectuer des opérations d'analyse et de résoudre le nom de la vue logique en une vue réelle Afficher via les informations de vue dans l'objet ModelAndView (comme le retour d'une vraie page JSP via un chemin JSP)

6）Voir

View est une vue, qui est elle-même une interface, et la classe d'implémentation prend en charge différents types de vue (JSP, FreeMarker, Excel, etc.).

Parmi les composants ci-dessus, le processeur (Handler, souvent appelé Controller) et la vue (View) doivent être développés par les développeurs. En termes simples, il est nécessaire de développer la logique de code spécifique pour traiter la demande, et enfin afficher l'interface à l'utilisateur

Créez rapidement des programmes Spring MVC

Les étapes de construction sont les suivantes :

  1. Créer une application Web et importer le package JAR

    printemps-webmvc

  2. Configuration Spring MVC : configurez Servlet dans web.xml, créez le fichier de configuration Spring MVC

 <servlet> 
  <servlet-name>springmvc</servlet-name> 
  <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class> 
  <init-param> 
   <param-name>contextConfigLocation</param- name> 
   <param-value>classpath:springmvc-config.xml</param-value> 
  </init-param> 
  <load-on-startup>1</load-on-startup> 
 </servlet> 
 <servlet-mapping > 
  <servlet-name>springmvc</servlet-name> 
  <url-pattern>/</url-pattern> 
 </servlet-mapping>

fichier de configuration springmvc

<?xml version="1.0" encoding="UTF-8"?> 
<beans xmlns="http://www.springframework.org/schema/beans" 
    xmlns:xsi="http://www.w3.org /2001/XMLSchema-instance" 
    xmlns:context="http://www.springframework.org/schema/context" 
    xmlns:mvc="http://www.springframework.org/schema/mvc" 
    xsi:schemaLocation=" http://www.springframework.org/schema/beans 
         http://www.springframework.org/schema/beans/spring-beans.xsd 
        http://www.springframework.org/schema/context 
        http://www .springframework.org/schema/context/spring-context.xsd 
        http://www.springframework.org/schema/mvc 
        http://www.springframework.org/schema/mvc/spring-mvc.xsd"> xsd"> 
    <!--Annotation implémente mvc-->
    <!-- Analyse automatiquement les packages pour implémenter IOC qui prend en charge les annotations --> 
    <context:component-scan base-package="cn.kgc.spring" /> 
    <!-- Prend en charge le traitement d'enregistrement du mappeur de processeur d'enregistrement basé sur les annotations MVC Type traitement de réponse de saut de page de conversion pour les paramètres d'adaptateur --> 
    <mvc:annotation-driven /> 
    <!-- view resolver --> 
    <bean 
        class="org.springframework.web.servlet.view.InternalResourceViewResolver" 
        id ="internalResourceViewResolver" > 
        <!-- prefix--> 
        <property name="prefix" value="/view/" /> 
        <!-- suffix--> 
        <property name="suffix" value=".jsp" /> 
    </ haricot> 
</haricots>

Créer un contrôleur (le contrôleur qui gère la requête)

@Controller 
@RequestMapping("/Hello") 
public class HelloWorld { 
    @RequestMapping("/Say.do") 
    public String SayHi(Model model) { 
        return "index" ; 
    } 
}

Créer une vue (utiliser JSP comme vue)

<%@ page contentType="text/html;charset=UTF-8" language="java" %> 
<html> 
<head> 
    <title>Titre</title> 
</head> 
<body> 
    bonjour springmvc 
</body > 
</html>

Déployer et exécuter

Explication détaillée de @RequestMapping

1. Une méthode correspond à plusieurs chemins

@RequestMapping(value={"hello1.do","hello2.do"}) 
    public String test01(){ 
​System.out.println
        ("hello"); 
​//
        Le chemin de saut utilise le transfert par défaut et sera analysé à travers la vue renvoie 
        "index" ; 
    }

2. Spécifiez la méthode de requête reçue par la méthode

@RequestMapping(value = "hello1.do",method = RequestMethod.GET) 
    public String test01(){ 
​System.out.println
        ("hello GET"); 
​//
        Le chemin de saut utilise le transfert par défaut et passe par le afficher l'analyseur 
        renvoie "index" ; 
    }

 

@RequestMapping(value = "hello1.do",method = RequestMethod.POST) public String test02(){ ​ System.out.println("hello POST"); ​ //Le chemin de saut par défaut est le transfert et passera par le afficher le résolveur renvoie "index" ; }

 

3. Une méthode spécifie plusieurs types de requêtes

@RequestMapping(value = "hello1.do", method = {RequestMethod.GET, RequestMethod.POST}) 
    public String test01(){ 
​System.out.println
        ("hello GET OR POST"); 
​//
        jump path By par défaut, le transfert passera par le résolveur de vue 
        return "index" ; 
    }

 

 

 

Liaison de paramètre SpringMVC

Passer les paramètres de la vue au contrôleur

1. Liaison de type de données de base

Le nom du paramètre formel est cohérent avec le nom du paramètre passé. Tous les paramètres doivent être passés, sinon une erreur 500 sera signalée. Afin de résoudre l'erreur de ne pas passer le paramètre, vous pouvez définir la valeur par défaut pour le type de paramètre de base

/** 
     * Définir la valeur par défaut du paramètre de base type @RequestParam(defaultValue = "xx") 
     * Si le paramètre est passé via l'url, le paramètre passé est le paramètre final 
     * @param age 
     * @param score 
     */ 
    @ RequestMapping(" /login2") 
    public void login2(@RequestParam(defaultValue = "20") int age , @RequestParam(defaultValue = "24.7") double score){ 
        System.out.println(age); 
        System.out.println (score) ; 
    }

Définir l'alias du paramètre

public void login3(@RequestParam(defaultValue = "20" ,name = "Age") int age , double score) 
 { 
        System.out.println(age); 
        System.out.println(score); 
 }

2. Transfert des types de données d'emballage

L'utilisation du type wrapper peut résoudre le problème selon lequel le type de base ne transmet pas de valeur et une erreur 500 se produit, mais il est toujours nécessaire de conserver la cohérence du nom du paramètre et du paramètre formel.

@RequestMapping("/login4") 
    public void login3(Integer age , Double score){ 
        System.out.println(age); 
        System.out.println(score); 
    }

3. Liaison des données de type chaîne

Reportez-vous simplement à la classe d'emballage

4. Type de tableau

public void login3(String[] ids){ 
        for (int i = 0; i < ids.length; i++) { 
            System.out.println(ids[i]); 
        } 
  }

5. type JavaBean

Le champ du nom du paramètre doit être cohérent avec la propriété dans le Javabean

public void login3(User user){ 
        System.out.println(user); 
    } 
URL : http://localhost:8080/user/login6?age=12&username=lisi&height=1.7

Renvoyer les données à la couche de vue

@RequestMapping(path = "/res1") 
    public ModelAndView test01(){ 

        ModelAndView modelAndView = new ModelAndView(); 
        modelAndView.setViewName("bonjour"); 
        modelAndView.addObject("msg", "ModelAndView"); 
        retourner modelAndView ; 
    } 

    @RequestMapping(path = "/res2") 
    public String test02(Model model){ 
        model.addAttribute("msg", "model"); 
        renvoie "bonjour" ; 
    } 

    @RequestMapping(path = "/res3") 
    public String test03(ModelMap map){ 
        map.addAttribute("msg", "ModèleCarte"); 
        renvoie "bonjour" ; 
    }

Méthode de saut SpringMVC

Par défaut, Spring MVC affiche les informations de page sous la forme de transfert interne du serveur et prend également en charge les pages de redirection

Redirection (code d'état 302 vers le navigateur)

@Controller 
public class HelloController3 { 

    @RequestMapping("/r1") 
    public void test01(demande HttpServletRequest, réponse HttpServletResponse) lance ServletException, IOException { 
        response.sendRedirect("redirect.jsp"); 
    } 

    @RequestMapping("/r2") 
    public String test02(){ 
        return "redirect:redirect.jsp" ; 
    } 

    @RequestMapping("/f1") 
    public void test03(demande HttpServletRequest, réponse HttpServletResponse) lance ServletException, IOException { 
        request.getRequestDispatcher("redirect.jsp").forward(request, réponse); 
    } 

    @RequestMapping("/f2")  
    chaîne publique test04(){
        return "forward:redirect.jsp" ;
    } 

    @RequestMapping("/f3") 
    public String test05(){ 
        return "redirect" ; 
    }

SpringMVC gère les requêtes et les réponses json

Répondre aux données au format json

public class JsonController { 

    @GetMapping("/login/{username}/{password}") 
    public void login(@PathVariable String username, @PathVariable String password, HttpServletResponse res) throws IOException { 
        System.out.println(username+":: "+mot de passe ); 
        //响应json格式的字符串
        res.setContentType("application/json;charset=utf-8"); 
        Résultat JsonResult = JsonResult.builder().code(200).count(100L).data(null).msg("ok").build(); 
        res.getWriter().write(result.toJSONString()); 
    } 

    @GetMapping("/login2/{nom d'utilisateur}/{mot de passe}") 
    @ResponseBody 
    public Object login2(@PathVariable String username, @PathVariable String password, HttpServletResponse res) throws IOException {
        System.out.println(username+"::"+password); 
        return JsonResult.builder().code(200).count(100L).data(null).msg("ok").build(); 
    } 

    @RequestMapping("/login3") 
    @ResponseBody 
    public Object login3(User user) { 
        System.out.println(user); 
        utilisateur de retour ; 
    }

Le type de données de la requête est JSON

/**
     * 接收json格式的参数
     * @param user
     * @return
     */
    @RequestMapping("/login4")
    @ResponseBody
    public Object login4(@RequestBody User user) {
        System.out.println(user);
        return user;
    }
}


前台ajax请求
<script type="text/javascript">
    $(function () {
        $("#jsbutton").click(function () {
            $.ajax({
                    url:'/login3',
                    type:'post',
                    data:{
                        username:"lisi",
                        age:20,
                        height:170,
                        birth:new Date()
                    },
                    dataType:'json',
                    success:function (result) {
                        console.log(result);
                    },
                    error:function () {
                         console.log("请求失败!")
                     }
            })
        })


        $("#jsbutton2").click(function () {
            var user = {
                username:"lisi",
                age:20,
                height:170,
                birth:'1999-9-9'
            }
            $.ajax({
                url:'/login4',
                type:'post',
                data:JSON.stringify(user),
                contentType:'application/json;charset=utf-8',
                dataType:'json',
                success:function (result) {
                    console.log(result);
                },
                error:function () {
                    console.log("请求失败!")
                }
            })
        })

    })

</script>

Style reposant

Un style d'architecture logicielle, un style de conception, plutôt qu'une norme, fournit simplement un ensemble de principes et de contraintes de conception. Il est principalement utilisé pour les logiciels d'interaction client et serveur. Les logiciels conçus sur la base de ce style peuvent être plus concis, plus multicouches et plus faciles à mettre en œuvre des mécanismes tels que la mise en cache

Définition d'URL

Ressources : tout ce qui se trouve sur Internet peut être résumé en tant que ressources. Opérations sur les ressources : utilisez POST, DELETE, PUT, GET et utilisez différentes méthodes pour opérer sur les ressources. Correspondant respectivement à ajouter, supprimer, modifier, interroger

Manipuler les ressources de manière traditionnelle

http://127.0.0.1/item/queryUser.action?id=1 Requête, GET 
http://127.0.0.1/item/saveUser.action Ajouter, POST 
http://127.0.0.1/item/updateUser.action mise à jour , POST 
http://127.0.0.1/item/deleteUser.action?id=1 supprimer, GET ou POST

Méthode de requête RestFul Vous pouvez utiliser des ressources côté serveur via GET, POST, PUT, PATCH, DELETE, etc. dans:

  • GET est utilisé pour interroger les ressources,

  • POST est utilisé pour créer des ressources,

  • PUT est utilisé pour mettre à jour toutes les informations des ressources côté serveur,

  • DELETE est utilisé pour supprimer des ressources côté serveur.

public class RestController {

    @GetMapping("/rest")
    public void test01(){
        System.out.println("test01: ");
    }  

    @PostMapping("/rest")
    public void test02(){
        System.out.println("test02: ");
    }

    @DeleteMapping("/rest")
    public void test03(){
        System.out.println("test03:");
    }

    @PutMapping("/rest")
    public void test04(){
        System.out.println("test04: ");
    }

    @PatchMapping("/rest")
    public void test05(){
        System.out.println("test05: ");
    }

}

Formulaire d'envoi de la méthode de configuration de la requête PUT

<form action="rest/r" method="post"> 
        <input type="hidden" name="_method" value="PUT"> 
        <p><input type="text" placeholder="请输入id" name="id"></p> 
        <p><input type="text" placeholder="请输入姓名" name="username"></p> <p> 
        <input type="date" placeholder="请输入生日" name="birth"></p> 
        <p><input type="submit"></p> 
 </form>

définir web.xml

<filter>
       <filter-name>Hidden</filter-name>
       <filter-class>org.springframework.web.filter.HiddenHttpMethodFilter</filter-class>
    </filter>

<filter-mapping>
    <filter-name>Hidden</filter-name>
    <url-pattern>/*</url-pattern>
</filter-mapping>

Problème de passage de paramètres de style REST

 @GetMapping("/login/{username}/{password}")
    public void login(@PathVariable String username, @PathVariable String password, HttpServletResponse res) throws IOException {
        System.out.println(username+"::"+password);
        //响应json格式的字符串
        res.setContentType("application/json;charset=utf-8");
        JsonResult result = JsonResult.builder().code(200).count(100L).data(null).msg("ok").build();
        res.getWriter().write(result.toJSONString());
    }

Traitement des caractères chinois brouillés dans la soumission des données

<!--解决中文乱码-->
    <filter>
        <filter-name>encoding</filter-name>
        <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
        <init-param>
            <param-name>encoding</param-name>
            <param-value>utf-8</param-value>
        </init-param>
    </filter>
    <filter-mapping>
        <filter-name>encoding</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>

Traitement des ressources statiques SpringMVC

1. Configurer le chemin des ressources statiques

<mvc:resources mapping="/static/**" location="/static/"/>

2. Configurer le processeur de servlet à l'aide de Tomcat

<mvc:default-servlet-handler/>

SpringMVC exploite une session et un cookie

@Controller
@SessionAttributes({"model1","model2"})
public class SessionController {

    @RequestMapping("/s1")
    public void test01(HttpSession session){
        session.setAttribute("msg", "session attribute");
    }

    @RequestMapping("/s2")
    public void test02(HttpSession session){
        System.out.println(session.getAttribute("msg"));
    }

    /**
     * 将model放入session作用域
     * @param model
     */
    @RequestMapping("/s3")
    public void test03(Model model){
        model.addAttribute("model1", "model1 attribute");
    }

    /**
     * 获取通过注解设置的session域中的值
     * @param session
     */
    @RequestMapping("/s5")
    public void test05(HttpSession session){
        System.out.println("msg: "+session.getAttribute("msg"));
        System.out.println("model1 :"+session.getAttribute("model1"));
        System.out.println("model2 :"+session.getAttribute("model2"));
    }

    /**
     * 通过注解获取session域中的值
     * @param
     */
    @RequestMapping("/s6")
    public void test05(@SessionAttribute(name = "msg") String session){
        System.out.println(session);
    }
   
操作cookie

public class CookieController {

    @RequestMapping("/c1")
    public void test01(HttpServletResponse response){
        Cookie ck = new Cookie("cookie","cookieValue");
        ck.setPath("/");
        ck.setMaxAge(60*60*24*7);
        response.addCookie(ck);
    }

    /**
     * 获取cookie中值的方式1
     * @param request
     */
    @RequestMapping("/c2")
    public void test02(HttpServletRequest request){
        Cookie[] cookies = request.getCookies();
        for (int i = 0; i < cookies.length; i++) {
            System.out.println(cookies[i].getName()+":"+cookies[i].getValue());
        }
    }

    /**
     * 获取cookie中值的方式2  注解方式
     * @param cookie
     */
    @RequestMapping("/c3")
    public void test03(@CookieValue("cookie") String cookie){
        System.out.println(cookie);
    }
}

Intercepteur SpringMVC

L'intercepteur Interceptor dans SpringMVC est également très important et utile.Sa fonction principale est d'intercepter les requêtes des utilisateurs et de les traiter en conséquence. Par exemple, utilisez-le pour vérifier les autorisations ou pour déterminer si un utilisateur est connecté ou non. Il existe deux façons de définir les intercepteurs SpringMVC

  • Interface d'implémentation : org.springframework.web.servlet.HandlerInterceptor

  • Adaptateur d'héritage : org.springframework.web.servethandler.HandlerInterceptorAdapter

1. Implémenter l'interface HandlerInterceptor

public class MyIntercepter01 implements HandlerInterceptor {

    /**
     * 目标方法执行前执行  返回false拦截   否则放行
     * @param request
     * @param response
     * @param handler
     * @return
     * @throws Exception
     */
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        System.out.println("MyIntercepter01 ->目标方法前->执行preHandle01 ");
        return true;
    }

    /**
     *
     * 目标方法执行后执行
     * @param request
     * @param response
     * @param handler
     * @param modelAndView
     * @throws Exception
     */
    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        System.out.println("MyIntercepter01 ->目标方法执行后->执行postHandle01 ");
    }

    /**
     * 视图响应完成后执行
     * @param request
     * @param response
     * @param handler
     * @param ex
     * @throws Exception
     */
    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        System.out.println("MyIntercepter01 ->视图渲染完成后->执行afterCompletion01 ");
    }
2.继承HandlerInterceptorAdapter（不建议使用）

public class MyInterceptor2  extends HandlerInterceptorAdapter {
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        return false;
    }
}
使用拦截器拦截非法请求

/**
 *用户操作模拟实现
 * 用户的登录(无需登录)
 * 用户的添加(登录)
 * 用户修改(登录)
 * 用户删除(登录)
 *
 * @author mosin
 * date 2021/8/22
 * @version 1.0
 */
@Controller
@RequestMapping("/user")
@SessionAttributes("action")
public class UserInfoController {
    /**
     * 用户登录
     */
    @RequestMapping("/login")
    public ModelAndView login(HttpSession session){
        ModelAndView modelAndView = new ModelAndView();
        modelAndView.setViewName("success");

        User user = User.builder().password("123456").username("lisi").build();
        session.setAttribute("user", user);
        modelAndView.addObject("user", user);
        return modelAndView;
    }

    /**
     * 用户添加
     */
    @RequestMapping("/add")
    public String add(Model model){
        model.addAttribute("action", "用户添加成功");
        System.out.println("用户的添加方法");

        return "success";
    }

    /**
     * 用户修改
     */
    @RequestMapping("/update")
    public String update(Model model){
        System.out.println("用户的更新方法");
        model.addAttribute("action", "用户更新成功");
        return "success";
    }

    /**
     * 用户修改
     */
    @RequestMapping("/delete")
    public String delete(Model model){
        System.out.println("用户的删除方法");
        model.addAttribute("action", "用户删除成功");
        return "success";
    }

}

Téléchargement de fichier SpringMVC

添加坐标依赖

<dependency>
      <groupId>commons-fileupload</groupId>
      <artifactId>commons-fileupload</artifactId>
      <version>1.4</version>
 </dependency>
配置解析器

<!--    文件上传配置文件解析器-->
    <bean id="multipartResolver" class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
<!--       允许上传的最大文件  单位字节-->
        <property name="maxUploadSize" >
            <value>104857600</value>
        </property>
<!--        内存中的最大缓存超出写出临时文件到硬盘-->
        <property name="maxInMemorySize" >
            <value>4096</value>
        </property>
        <property name="defaultEncoding">
            <value>utf-8</value>
        </property>
    </bean>
后台代码


@Controller
@RequestMapping("/upload")
public class UPloadController {

    @RequestMapping("/file")
    public String upload(@RequestParam("file") MultipartFile file, HttpServletRequest request){

        //获取项目的真实路径
        String realPath = request.getSession().getServletContext().getRealPath("/");
        System.out.println(realPath);
        //创建文件上传的目录
        File dir = new File(realPath, "/upload");
        System.out.println(dir);
        //判定文件夹是否存在 不存在创建
        if(!dir.exists()){
            dir.mkdir();
        }

        if(!file.isEmpty()){
            //获取文件的名字
            String fileName = file.getOriginalFilename();
            //截取文件的后缀 生成新的文件名 避免文件名字重复
            String suffix= fileName.substring(fileName.lastIndexOf("."));
            //获取当前系统时间
            String fileLastName = System.currentTimeMillis()+suffix;
            System.out.println(fileLastName);
            //将文件写入目标文件夹
            try {
                file.transferTo(new File(dir,fileLastName));
                request.setAttribute("msg", "文件上传成功");
            } catch (IOException e) {
                e.printStackTrace();
                request.setAttribute("msg", "文件上传失败");
            }
        }else{
            request.setAttribute("msg", "未选择文件");
        }

        return "success";
    }

    @RequestMapping("/files")
    public String uploads(@RequestParam("files") List<MultipartFile> files, HttpServletRequest request){

        //遍历集合
       files.forEach(multipartFile -> {
           FileUploadUtil.upload(multipartFile, request);
       });
        return "success";
    }
}

Traitement unifié des exceptions globales SpringMVC

1. Méthode de traitement 1 Utilisez @ExceptionHandler(Exception.class) pour définir une méthode d'exception dans la classe pour gérer l'exception spécifiée dans cette classe

@RestController
@RequestMapping("/exception")
public class ExceptionController01 {

    @ExceptionHandler(Exception.class)
    public Object handlerException(Exception e){
        return JsonResult.builder().msg("出现"+"异常").code(1).data(e.getMessage()).build();
    }

    @RequestMapping("/e1")
    public Object ex1(){
        int a  = 1/0;
        return null;
    }

    @RequestMapping("/e2")
    public Object ex2() throws FileNotFoundException {
        new FileInputStream("ab");
        return null;
    }
}
2.处理的方式2 全局处理模式 定义ExceptionAdvice类

@RestControllerAdvice
public class ExceptionAdvice {

    @ExceptionHandler(value ={Exception.class})
    public Object handlerException(Exception e){
        return JsonResult.builder().msg("出现"+"异常").code(1).data(e.getMessage()).build();
    }
}

Intégration du cadre SSM

1. Introduire les dépendances pom

1. Introduire la dépendance mybatis

<!--    mybatis依赖-->
    <dependency>
      <groupId>org.mybatis</groupId>
      <artifactId>mybatis</artifactId>
      <version>3.5.7</version>
    </dependency>
<!--    分页pagehelper-->
    <dependency>
      <groupId>com.github.pagehelper</groupId>
      <artifactId>pagehelper</artifactId>
      <version>5.2.1</version>
    </dependency>
<!--    mybatis-spring-->
    <dependency>
      <groupId>org.mybatis</groupId>
      <artifactId>mybatis-spring</artifactId>
      <version>2.0.5</version>
    </dependency>
2.引入spring依赖

<!--    spring-context-->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-context</artifactId>
      <version>5.3.9</version>
    </dependency>
<!--    spring-aspects-->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-aspects</artifactId>
      <version>5.3.9</version>
    </dependency>
<!--      spring-jdbc-->
      <dependency>
          <groupId>org.springframework</groupId>
          <artifactId>spring-jdbc</artifactId>
          <version>5.3.9</version>
      </dependency>
3.springmvc依赖

<!--    spring-webmvc-->
    <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-webmvc</artifactId>
      <version>5.3.9</version>
    </dependency>
<!--    jackson-core-->
    <dependency>
      <groupId>com.fasterxml.jackson.core</groupId>
      <artifactId>jackson-core</artifactId>
      <version>2.11.3</version>
    </dependency>
<!--    jackson-databind-->
    <dependency>
      <groupId>com.fasterxml.jackson.core</groupId>
      <artifactId>jackson-databind</artifactId>
      <version>2.11.3</version>
    </dependency>
<!--    jackson-annotations-->
    <dependency>
      <groupId>com.fasterxml.jackson.core</groupId>
      <artifactId>jackson-annotations</artifactId>
      <version>2.11.3</version>
    </dependency>

<!--    文件上传-->
    <dependency>
      <groupId>commons-fileupload</groupId>
      <artifactId>commons-fileupload</artifactId>
      <version>1.4</version>
    </dependency>
4.log4j依赖

<dependency>
      <groupId>log4j</groupId>
      <artifactId>log4j</artifactId>
      <version>1.2.17</version>
    </dependency>
 <dependency>
       <groupId>org.apache.logging.log4j</groupId>
       <artifactId>log4j-api</artifactId>
       <version>2.13.3</version>
 </dependency>
  <dependency>
       <groupId>org.apache.logging.log4j</groupId>
       <artifactId>log4j-core</artifactId>
       <version>2.13.1</version>
  </dependency>
5.数据库驱动和连接池

<!--    mysql-connector-->
    <dependency>
      <groupId>mysql</groupId>
      <artifactId>mysql-connector-java</artifactId>
      <version>5.1.44</version>
    </dependency>
   
<!--    druid连接池-->
    <dependency>
      <groupId>com.alibaba</groupId>
      <artifactId>druid</artifactId>
      <version>1.1.10</version>
    </dependency>
6.servlet+jsp依赖

<!--servlet-->
    <dependency>
      <groupId>javax.servlet</groupId>
      <artifactId>javax.servlet-api</artifactId>
      <version>4.0.1</version>
    </dependency>
<!--    jsp-->
    <dependency>
      <groupId>javax.servlet.jsp</groupId>
      <artifactId>jsp-api</artifactId>
      <version>2.2</version>
    </dependency>
7.jstl依赖

<!--jstl-->
    <dependency>
      <groupId>javax.servlet</groupId>
      <artifactId>jstl</artifactId>
      <version>1.2</version>
    </dependency>
    <dependency>
      <groupId>taglibs</groupId>
      <artifactId>standard</artifactId>
      <version>1.1.2</version>
    </dependency>
8.其它依赖

<!--    lombok-->
    <dependency>
      <groupId>org.projectlombok</groupId>
      <artifactId>lombok</artifactId>
      <version>1.18.16</version>
    </dependency>
<!--    junit-->
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.11</version>
      <scope>test</scope>
    </dependency>

2. Définissez le fichier de configuration

1.db.properties

jdbc.driver=com.mysql.jdbc.Driver 
jdbc.url=jdbc:mysql:///mybatis?useSSL=true&serverTimezone=GMT%2B8 
jdbc.username=root 
jdbc.password=root 

#Le nombre de connexions établies dans le pool lors de l'initialisation. 
jdbc.initialSize=2 
#Le nombre maximum de pools de connexions actives 
jdbc.maxActive=300 
#Temps d'attente maximum 
jdbc.maxWait=60000

2.log4j.propriétés

log4j.rootLogger=DEBUG,Console 

#Console 
log4j.appender.Console=org.apache.log4j.ConsoleAppender 
log4j.appender.console.Target=System.out 
log4j.appender.Console.layout=org.apache.log4j.PatternLayout 
log4j. appender.Console.layout.ConversionPattern=%d [%t] %-5p [%c] - %m%n 

log4j.logger.org.apache=ERREUR 
log4j.logger.org.mybatis=ERREUR 
log4j.logger.org. springframework=ERREUR 

#这个需要
log4j.logger.log4jdbc.debug=ERREUR 
log4j.logger.com.gk.mapper=ERREUR 
log4j.logger.jdbc.audit=ERREUR 
log4j.logger.jdbc.resultset=ERREUR 
#这个打印SQL语句非常重要
log4j.logger.jdbc.sqlonly=DEBUG 
log4j.logger.jdbc.sqltiming=ERROR 
log4j.logger.jdbc.connection=FATAL

3.fichier de configuration de base Spring

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
         http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd
        http://www.springframework.org/schema/mvc
        http://www.springframework.org/schema/mvc/spring-mvc.xsd
        http://www.springframework.org/schema/tx
        http://www.springframework.org/schema/tx/spring-tx.xsd">
    <!-- 读取db.properties -->
    <context:property-placeholder location="classpath:db.properties" />

    <!-- 配置数据源 -->
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <!-- 数据库驱动 -->
        <property name="driverClassName" value="${jdbc.driver}" />
        <property name="url" value="${jdbc.url}" />
        <property name="username" value="${jdbc.username}" />
        <property name="password" value="${jdbc.password}" />
        <property name="initialSize" value="${jdbc.initialSize}" />
        <property name="maxActive" value="${jdbc.maxActive}" />
        <property name="maxWait" value="${jdbc.maxWait}" />
    </bean>

    <!-- 事务管理器，依赖于数据源 -->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource" />
    </bean>

    <!-- 开启事务注解 -->
    <tx:annotation-driven transaction-manager="transactionManager"  />

    <!-- 配置MyBatis工厂 SqlSessionFactory -->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <!-- 注入数据源 -->
        <property name="dataSource" ref="dataSource" />
        <!-- 指定Mybatis核心配置文件位置 -->
        <property name="configLocation" value="classpath:config/mybatis-config.xml" />
        <!-- 扫描模块配置文件:mapper需要的xml文件（如果mapper.xml和接口在一个包下，可以不配置） -->
        <property name="mapperLocations" value="classpath:mapper/*.xml" />
    </bean>

    <!-- 配置mapper扫描器 -->
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <property name="basePackage" value="cn.kgc.ssm.dao" />
    </bean>

    <!-- 扫描包-->
    <context:component-scan base-package="cn.kgc.ssm" />
    <!--    开启spring注解支持-->
    <context:annotation-config/>
</beans>

4. fichier de configuration spring-mvc

<?xml version="1.0" encoding="UTF-8"?> 
<beans xmlns="http://www.springframework.org/schema/beans" 
       xmlns:xsi="http://www.w3.org /2001/XMLSchema-instance" 
       xmlns:context="http://www.springframework.org/schema/context" 
       xmlns:mvc="http://www.springframework.org/schema/mvc" 
       xmlns:tx=" http://www.springframework.org/schema/tx" 
       xsi:schemaLocation="http://www.springframework.org/schema/beans 
         http://www.springframework.org/schema/beans/spring-beans. xsd 
        http://www.springframework.org/schema/context 
        http://www.springframework.org/schema/context/spring-context.xsd 
        http://www.springframework.org/schéma/mvc
        http://www.springframework.org/schema/mvc/spring-mvc.xsd
        http://www.springframework.org/schema/tx 
        http://www.springframework.org/schema/tx/spring-tx.xsd">


    <!-- 加载注解驱动 -->
    <mvc:annotation-driven />
    <!-- 配置视图解析器 -->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="prefix" value="/WEB-INF/pages/" />
        <property name="suffix" value=".jsp" />
    </bean>
    <!--释放静态资源-->
    <mvc:default-servlet-handler/>
    <!--    文件上传配置文件解析器-->
    <bean id="multipartResolver" class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
        <!--       允许上传的最大文件-->
        <property name="maxUploadSize" >
            <value>104857600</value>
        </property>
        <!--        内存中的最大缓存超出写出临时文件到硬盘-->
        <property name="maxInMemorySize" >
            <value>4096</value>
        </property>
        <property name="defaultEncoding">
            <value>utf-8</value>
        </property>
    </bean>
</beans>

5. fichier de configuration mybatis

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
    <!-- mybatis运行时设置 -->
    <settings>
        <!-- 启用log4j日志 -->
        <setting name="logImpl" value="LOG4J"></setting>
        <setting name="mapUnderscoreToCamelCase" value="true"/>
    </settings>
    <!-- 别名定义 -->
    <typeAliases>
        <package name="cn.kgc.ssm.entity" />
    </typeAliases>

    <!-- mybatis插件 -->
    <plugins>
        <plugin interceptor="com.github.pagehelper.PageInterceptor">
            <!-- 配置mysql方言 -->
            <property name="helperDialect" value="mysql" />
            <!-- 设置为true时，如果pageSize=0就会查询出全部的结果 -->
            <property name="pageSizeZero" value="true" />
            <!-- 3.3.0版本可用，分页参数合理化，默认false禁用 -->
            <!-- 启用合理化时，如果pageNum<1会查询第一页，如果pageNum>pages会查询最后一页 -->
            <!-- 禁用合理化时，如果pageNum<1或pageNum>pages会返回空数据 -->
            <property name="reasonable" value="true" />
        </plugin>
    </plugins>
</configuration>

6.web.xml

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
         version="4.0">
<!--    前端控制器-->
    <servlet>
        <servlet-name>ssm</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:config/spring-*.xml</param-value>
        </init-param>
        <load-on-startup>1</load-on-startup>
    </servlet>
    <servlet-mapping>
        <servlet-name>ssm</servlet-name>
        <url-pattern>*.do</url-pattern>
    </servlet-mapping>

<!--    过滤器解决中文乱码-->
    <filter>
        <filter-name>encoding</filter-name>
        <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
        <init-param>
            <param-name>encoding</param-name>
            <param-value>utf-8</param-value>
         </init-param>
    </filter>
    <filter-mapping>
        <filter-name>encoding</filter-name>
        <url-pattern>/</url-pattern>
    </filter-mapping>
</web-app>

3. Structure du répertoire du projet

 

Je suppose que tu aimes

Origine blog.csdn.net/m0_67979925/article/details/129747743
conseillé
Classement
du quotidien
Plus
2024-06-09(0)
2024-06-08(0)
2024-06-07(0)
2024-06-06(0)
2024-06-05(0)
2024-06-04(2)
2024-06-03(0)
2024-06-02(1)
2024-06-01(0)
2024-05-31(0)

Code World

© 2018 codetd.com