springmvc

SpringMVC

javase:認真學習
javaweb:認真學習
SSM框架：研究官方文檔，自學能力

回顧servlet

這個方法僅限于用maven后想加web后，就是這樣加，如果一開始就建立web-app模板的maven項目就不用
idea如何在maven模塊中加入webapp支持 [( https://blog.csdn.net/qq_33168558/article/details/136437505)]

1、pom.xml
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.cjj</groupId>
    <artifactId>SpringMVC</artifactId>
    <packaging>pom</packaging>
    <version>1.0-SNAPSHOT</version>
    <modules>
        <module>springmvc-01-serlvet</module>
        <module>springmvc-01-serlvet</module>
    </modules>

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
    </properties>

    <dependencies>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>5.1.9.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>servlet-api</artifactId>
            <version>2.5</version>
        </dependency>
        <dependency>
            <groupId>javax.servlet.jsp</groupId>
            <artifactId>jsp-api</artifactId>
            <version>2.2</version>
        </dependency>
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>jstl</artifactId>
            <version>1.2</version>
        </dependency>
    </dependencies>

</project>

2，加HelloServlet

package com.cjj.servlet;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

public class HelloServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        //取得參數
        String method = req.getParameter("method");
        if (method.equals("add")){
            req.getSession().setAttribute("msg","執行了add方法");
        }
        if (method.equals("delete")){
            req.getSession().setAttribute("msg","執行了delete方法");
        }
        //業務邏輯
        //視圖跳轉
        req.getRequestDispatcher("/WEB-INF/jsp/test.jsp").forward(req,resp);
    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        doGet(req,resp);
    }

}

3\test.jsp

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

${msg}

</body>
</html>

4\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>hello</servlet-name>
        <servlet-class>com.cjj.servlet.HelloServlet</servlet-class>
    </servlet>
    <servlet-mapping>
        <servlet-name>hello</servlet-name>
        <url-pattern>/hello</url-pattern>
    </servlet-mapping>

</web-app>

5\啟動

MVC框架要做哪些事情
將url映射到java類或java類的方法
封裝用戶提交的數據 .
處理請求–調用相關的業務處理–封裝響應數據
將響應的數據進行渲染 . jsp / html 等表示層數據

SpringMVC

如果啟動有問，看看是否這個位置沒有lib，可能是idea打包的時候有問題

2、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">

    <!--1.注冊DispatcherServlet-->
    <servlet>
        <servlet-name>springmvc</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <!--關聯一個springmvc的配置文件:【servlet-name】-servlet.xml-->
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:springmvc-servlet.xml</param-value>
        </init-param>
        <!--啟動級別-1-->
        <load-on-startup>1</load-on-startup>
    </servlet>

    <!--/ 匹配所有的請求；（不包括.jsp）-->
    <!--/* 匹配所有的請求；（包括.jsp）-->
    <servlet-mapping>
        <servlet-name>springmvc</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>

</web-app>

3\springmvc-servlet.xml

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


    <bean class="org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping"/>
    <bean class="org.springframework.web.servlet.mvc.SimpleControllerHandlerAdapter"/>

    <!--視圖解析器:DispatcherServlet給他的ModelAndView-->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver" id="InternalResourceViewResolver">
        <!--前綴-->
        <property name="prefix" value="/WEB-INF/jsp/"/>
        <!--后綴-->
        <property name="suffix" value=".jsp"/>
    </bean>

    <!--Handler-->
    <bean id="/hello" class="com.blue.controller.HelloController"/>

</beans>

4\、HelloController.java

package com.blue.controller;

import org.springframework.web.servlet.ModelAndView;
import org.springframework.web.servlet.mvc.Controller;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

//注意：這里我們先導入Controller接口
public class HelloController implements Controller {
    @Override
    public ModelAndView handleRequest(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse) throws Exception {
        //ModelAndView 模型和視圖
        ModelAndView mv = new ModelAndView();

        //封裝對象，放在ModelAndView中。Model
        mv.addObject("msg","HelloSpringMVC!");
        //封裝要跳轉的視圖，放在ModelAndView中
        mv.setViewName("hello"); //: /WEB-INF/jsp/hello.jsp
        return mv;
    }
}

注意，如果訪問不了Index.jsp，放在web-inf同級目錄下才能自動默認訪問我首頁

SpringMVC執行原理

當發起請求時被前置的控制器攔截到請求，根據請求參數生成代理請求，找到請求對應的實際控制器，控制器處理請求，創建數據模型，訪問數據庫，將模型響應給中心控制器，控制器使用模型與視圖渲染視圖結果，將結果返回給中心控制器，再將結果返回給請求者。

HandlerMapping：處理器映射器

HandlerAdapter：處理器適配器

viewResolver：視圖解析器

圖為SpringMVC的一個較完整的流程圖，實線表示SpringMVC框架提供的技術，不需要開發者實現，虛線表示需要開發者實現。

深入學習springMVC

1，web.xml先要注冊DispatcherServlet，所有的請求都要走這個請求分發器,通過servlet指定DispatcherServlet路徑

<?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">

    <!--1.注冊DispatcherServlet,這個是springmvc的核心組件:請求分發器，前端控制器-->
    <servlet>
        <servlet-name>springmvc</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <!--關聯一個springmvc的配置文件:【servlet-name】-servlet.xml-->
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:springmvc-servlet.xml</param-value>
        </init-param>
        <!--啟動級別-1,服務器啟動時加載-->
        <load-on-startup>1</load-on-startup>
    </servlet>

    <!--/ 匹配所有的請求；（不包括.jsp）-->
    <!--/* 匹配所有的請求；（包括.jsp）-->
    <servlet-mapping>
        <servlet-name>springmvc</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>


</web-app>

2\通過上面的文件綁定了springmvc-servlet.xml的路徑，開始配置springmvc-servlet.xml的內容

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

<!--配置處理器映射器-->
    <bean class="org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping"/>
    <!--配置處理器適配器-->
    <bean class="org.springframework.web.servlet.mvc.SimpleControllerHandlerAdapter"/>

    <!--視圖解析器:模板引擎 Thymeleaf  FreeMarker  DispatcherServlet給他的ModelAndView-->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver" id="InternalResourceViewResolver">
       <!--拼接路徑-->
        <!--前綴-->
        <property name="prefix" value="/WEB-INF/jsp/"/>
        <!--后綴-->
        <property name="suffix" value=".jsp"/>
    </bean>

    <!--Handler-->
    <bean id="/hello" class="com.cjj.controller.HelloController"/>

</beans>

3、寫HelloController的代碼，專注寫業務代碼，給返回哪個頁面

package com.cjj.controller;

import org.springframework.web.servlet.ModelAndView;
import org.springframework.web.servlet.mvc.Controller;

public class HelloController implements Controller {
    public ModelAndView handleRequest(javax.servlet.http.HttpServletRequest request, javax.servlet.http.HttpServletResponse response) throws Exception {
        ModelAndView mv = new ModelAndView();
        //業務代碼
        String result = "Hello aha !";
        mv.addObject("msg", result);
        //視圖跳轉
        mv.setViewName("test");
        return mv;

    }
}

只是說springmvc的實現原理，實際開發不會這樣做，因為一個頁面還是要寫一個controller和注冊一個bean，實際還是很麻煩

使用注解開發springmvc

1\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">

    <!--1.注冊servlet-->
    <servlet>
        <servlet-name>SpringMVC</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <!--通過初始化參數指定SpringMVC配置文件的位置，進行關聯-->
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:springmvc-servlet.xml</param-value>
        </init-param>
        <!-- 啟動順序，數字越小，啟動越早 -->
        <load-on-startup>1</load-on-startup>
    </servlet>

    <!--所有請求都會被springmvc攔截 -->
    <servlet-mapping>
        <servlet-name>SpringMVC</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>


</web-app>

2、springmvc-servlet.xml

<?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
       https://www.springframework.org/schema/context/spring-context.xsd
       http://www.springframework.org/schema/mvc
       https://www.springframework.org/schema/mvc/spring-mvc.xsd">

    <!-- 自動掃描包，讓指定包下的注解生效,由IOC容器統一管理 -->
    <context:component-scan base-package="com.cjj.controller"/>
    <!-- 讓Spring MVC不處理靜態資源 .css .js .jpg .png .gif 等文件     -->
    <!--后期工作中后面這三個代碼都是固定的，開啟處理映射器，處理適配器，視圖解析器 -->
    <mvc:default-servlet-handler />
    <!--
    支持mvc注解驅動
        在spring中一般采用@RequestMapping注解來完成映射關系
        要想使@RequestMapping注解生效
        必須向上下文中注冊DefaultAnnotationHandlerMapping
        和一個AnnotationMethodHandlerAdapter實例
        這兩個實例分別在類級別和方法級別處理。
        而annotation-driven配置幫助我們自動完成上述兩個實例的注入。
     -->
    <mvc:annotation-driven />

    <!-- 視圖解析器 -->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver"
          id="internalResourceViewResolver">
        <!-- 前綴 -->
        <property name="prefix" value="/WEB-INF/jsp/" />
        <!-- 后綴 -->
        <property name="suffix" value=".jsp" />
    </bean>

</beans>

3、HelloController

package com.cjj.controller;

import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;

@Controller
//@RequestMapping("/HelloController")
public class HelloController {

    //真實訪問地址 : 項目名/HelloController/hello
    @RequestMapping("/h1")
    public String sayHello(Model model){
        //封裝數據
        //向模型中添加屬性msg與值，可以在JSP頁面中取出并渲染
        model.addAttribute("msg","hello,SpringMVCAnnotation!");
        return "hello";   //web-inf/jsp/hello.jsp  會被視圖解析器處理：
    }
}

Controller及RestFul

第一種方法——實現Controller接口

1\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>springmvc</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:springmvc-servlet.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>

</web-app>

2\2、springmvc-servlet.xml

<?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
       https://www.springframework.org/schema/context/spring-context.xsd
       http://www.springframework.org/schema/mvc
       https://www.springframework.org/schema/mvc/spring-mvc.xsd">

    <!--    &lt;!&ndash; 自動掃描包，讓指定包下的注解生效,由IOC容器統一管理 &ndash;&gt;-->
    <context:component-scan base-package="com.cjj.controller"/>

 <mvc:default-servlet-handler />
   <mvc:annotation-driven />

    <!-- 視圖解析器 -->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver"
          id="internalResourceViewResolver">
        <property name="prefix" value="/WEB-INF/jsp/" />
        <property name="suffix" value=".jsp" />
    </bean>

    <bean name="/t1" class="com.cjj.controller.ControllerTest1"/>

</beans>

3\3、ControllerTest1

package com.blue.controller;

import org.springframework.web.servlet.ModelAndView;
import org.springframework.web.servlet.mvc.Controller;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

//只要實現了ControlLer 接口的類。說明這就是一個控制器了
public class ControllerTest1 implements Controller {

    @Override
    public ModelAndView handleRequest(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse) throws Exception {
        ModelAndView mv = new ModelAndView();
        mv.addObject("msg","ControllerTest1");
        mv.setViewName("test");
        return mv;
    }
}

4\test.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>SpringMVC</title>
</head>
<body>
    ${msg}
</body>
</html>

缺點：一個controller寫一個類

第二種——使用注解@Controller

1\controllertest2

package com.cjj.controller;

import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.servlet.ModelAndView;




@Controller //代表這個類會被spring接管
// 被這個注解的類 中的所有方法，如果返回值是spring，并且有具體的頁面可以跳轉
// 那么就會被視圖解析器解析
public class ControllerTest2 {

    @RequestMapping("/t2")
    public String test1(Model model){
        model.addAttribute("msg","ControllerTest2");
        return "test";
    }
}

2、springmvc-servlet.xml

<?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
       https://www.springframework.org/schema/context/spring-context.xsd
       http://www.springframework.org/schema/mvc
       https://www.springframework.org/schema/mvc/spring-mvc.xsd">

    <!-- 自動掃描包，讓指定包下的注解生效,由IOC容器統一管理 -->
    <context:component-scan base-package="com.blue.controller"/>
    <!-- 讓Spring MVC不處理靜態資源 -->
<!--    <mvc:default-servlet-handler />-->
    <mvc:annotation-driven />

    <!-- 視圖解析器 -->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver"
          id="internalResourceViewResolver">
        <property name="prefix" value="/WEB-INF/jsp/" />
        <property name="suffix" value=".jsp" />
    </bean>

</beans>

requestmapping

@Controller //代表這個類會被spring接管
@RequestMapping("/c3")
// 被這個注解的類 中的所有方法，如果返回值是spring，并且有具體的頁面可以跳轉
// 那么就會被視圖解析器解析
public class ControllerTest2 {

    @RequestMapping("/t1")
    public String test1(Model model){
        model.addAttribute("msg","ControllerTest2");
        return "test";
    }
}

RestFul風格講解

Restful就是一個資源定位及資源操作的風格。不是標準也不是協議，只是一種風格。基于這個風格設計的軟件可以更簡潔，更有層次，更易于實現緩存等機制。

功能

資源：互聯網所有的事物都可以被抽象為資源
資源操作：使用POST、DELETE、PUT、GET，使用不同方法對資源進行操作。
分別對應添加、刪除、修改、查詢。

傳統方式操作資源：通過不同的參數來實現不同的效果！方法單一，post 和 get

import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;

@Controller
public class RestFulController {
    //http://localhost:8080/add?a=1&b=1  原來的方式
    //http://localhost:8080/add/1/1  RESTful方式
    @RequestMapping("/add/{a}/{b}")
    public String test1(@PathVariable int a, @PathVariable int b, Model model){
        int res=a+b;
        model.addAttribute("msg","結果為"+res);
        return "test";
    }
}

400的錯誤一般是你請求有問題，500的錯誤一般是你代碼有問題

可以通過不同的請求方式來實現不同的效果！如下：請求地址一樣，但是功能可以不同！
http://127.0.0.1/item/1 查詢,GET
http://127.0.0.1/item 新增,POST
http://127.0.0.1/item 更新,PUT
http://127.0.0.1/item/1 刪除,DELETE
為什么呢，和以下原理有關系

用注解就直接限定要用什么方法請求！！，下面的案例都是同樣的路徑，但是用get就是用下面的方法，用post就是用上面的方法，通常瀏覽器都是用get方法，post就是表單方式

@Controller
public class RestFulController {
    //http://localhost:8080/add?a=1&b=1  原來的方式
    //http://localhost:8080/add/1/1  RESTful方式
    @PostMapping("/add/{a}/{b}")
    public String test1(@PathVariable int a, @PathVariable int b, Model model){
        int res=a+b;
        model.addAttribute("msg","結果為"+res);
        return "test";
    }
    @GetMapping("/add/{a}/{b}")
    public String test2(@PathVariable int a, @PathVariable int b, Model model){
        int res=a+b;
        model.addAttribute("msg","結果為"+res);
        return "test";
    }

}


或者用@RequestMapping(path="/add/{a}/{b}",method=RequestMethod.GET)

Restful風格比以前的參數風格更安全，都不知道你是傳了什么類型參數進去
也更簡潔

重定向和轉發

package com.blue.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;

@Controller
public class ModelTest1 {

    @RequestMapping("m1/t1")
    public String test1(HttpServletRequest request, HttpServletResponse response){
        HttpSession session = request.getSession();
        System.out.println(session.getId());
        return "test";
    }
}

package com.blue.controller;

import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;

@Controller
public class ModelTest1 {

    @RequestMapping("m1/t1")
    public String test1(Model model){
    	//轉發
        model.addAttribute("msg","ModelTest1");
        return "forward:/WEB-INF/jsp/test.jsp";
    }
    
   @RequestMapping("/rsm/t3")
    public String test3(){
        //重定向
        return "redirect:/test.jsp";
    }
    
}

接收請求參數及數據回顯

package com.cjj.controller;

import com.cjj.pojo.User;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;

@Controller
@RequestMapping("/user")
public class UserController {
    //localhost:8080/user/test1?name=zhangsan
    @GetMapping("/test1")
    public String test1(@RequestParam( "username") String name, Model model) {
        //1，接收前端參數
        System.out.println(name);
        //2.將返回的結果傳遞給前端
        model.addAttribute("msg",name);
        //3.跳轉到test.jsp頁面
        return "test";
    }
    //   public String test1(@RequestParam( "username") String name, Model model)
    //傳入參數可以加上注解，規定參數名一定是username

    //前端接收的是一個對象：id,name,age
    /*
    1. 接收前端用戶傳遞的參數，判斷參數的名字，假設名字直接在方法上，可以直接使用
    2. 假設傳遞的是一個對象User,匹User對象中的字段名：如果名字一致則OK,否則，匹配不到
     */
    @GetMapping("/test2")
    public String test2(User user) {
        System.out.println(user);
        return "test";

    }
}

亂碼問題

傳中文時可能亂碼，但是也不一樣，有時候環境就是不會有亂碼問題，spring6以上就不會

1、form.jsp

<html>
<head>
    <title>Title</title>
</head>
<body>

  <form action="/e/t1" method="get">
    <input type="text" name="name">
      <input type="submit">
  </form>

</body>
</html>

2\EncodingController

package com.blue.controller;

import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.PostMapping;

@Controller
public class EncodingController {

    @GetMapping("/e/t1")
    public String test1(String name, Model model){
        System.out.println(name);
        model.addAttribute("msg",name);
        return "test";
    }

}

過濾器解決亂碼
加上過濾器

package com.blue.filter;


import javax.servlet.*;
import java.io.IOException;
import java.util.logging.LogRecord;

public class EncodingFilter implements Filter {

    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
        
    }

    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain filterChain) throws IOException, ServletException {
        request.setCharacterEncoding("utf-8");
        response.setCharacterEncoding("utf-8");
        
        filterChain.doFilter(request,response);
    }

    @Override
    public void destroy() {

    }
}

web.xml

   <filter>
        <filter-name>encoding</filter-name>
        <filter-class>com.blue.filter.EncodingFilter</filter-class>
    </filter>
    <filter-mapping>
        <filter-name>encoding</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>

大佬寫的過濾器，如果spirng提供的過濾器都沒用的話

package com.kuang.filter;

import javax.servlet.*;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletRequestWrapper;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.util.Map;

/**
* 解決get和post請求 全部亂碼的過濾器
*/
public class GenericEncodingFilter implements Filter {

   @Override
   public void destroy() {
  }

   @Override
   public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
       //處理response的字符編碼
       HttpServletResponse myResponse=(HttpServletResponse) response;
       myResponse.setContentType("text/html;charset=UTF-8");

       // 轉型為與協議相關對象
       HttpServletRequest httpServletRequest = (HttpServletRequest) request;
       // 對request包裝增強
       HttpServletRequest myrequest = new MyRequest(httpServletRequest);
       chain.doFilter(myrequest, response);
  }

   @Override
   public void init(FilterConfig filterConfig) throws ServletException {
  }

}

//自定義request對象，HttpServletRequest的包裝類
class MyRequest extends HttpServletRequestWrapper {

   private HttpServletRequest request;
   //是否編碼的標記
   private boolean hasEncode;
   //定義一個可以傳入HttpServletRequest對象的構造函數，以便對其進行裝飾
   public MyRequest(HttpServletRequest request) {
       super(request);// super必須寫
       this.request = request;
  }

   // 對需要增強方法 進行覆蓋
   @Override
   public Map getParameterMap() {
       // 先獲得請求方式
       String method = request.getMethod();
       if (method.equalsIgnoreCase("post")) {
           // post請求
           try {
               // 處理post亂碼
               request.setCharacterEncoding("utf-8");
               return request.getParameterMap();
          } catch (UnsupportedEncodingException e) {
               e.printStackTrace();
          }
      } else if (method.equalsIgnoreCase("get")) {
           // get請求
           Map<String, String[]> parameterMap = request.getParameterMap();
           if (!hasEncode) { // 確保get手動編碼邏輯只運行一次
               for (String parameterName : parameterMap.keySet()) {
                   String[] values = parameterMap.get(parameterName);
                   if (values != null) {
                       for (int i = 0; i < values.length; i++) {
                           try {
                               // 處理get亂碼
                               values[i] = new String(values[i]
                                      .getBytes("ISO-8859-1"), "utf-8");
                          } catch (UnsupportedEncodingException e) {
                               e.printStackTrace();
                          }
                      }
                  }
              }
               hasEncode = true;
          }
           return parameterMap;
      }
       return super.getParameterMap();
  }

   //取一個值
   @Override
   public String getParameter(String name) {
       Map<String, String[]> parameterMap = getParameterMap();
       String[] values = parameterMap.get(name);
       if (values == null) {
           return null;
      }
       return values[0]; // 取回參數的第一個值
  }

   //取所有值
   @Override
   public String[] getParameterValues(String name) {
       Map<String, String[]> parameterMap = getParameterMap();
       String[] values = parameterMap.get(name);
       return values;
  }
}

JSON

前后端分享的時代
后端部署后端，提供接口，提供數據
前端獨立部署，負責渲染后端的數據

Jackson使用

導入依賴

<!-- https://mvnrepository.com/artifact/com.fasterxml.jackson.core/jackson-databind -->
<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
    <version>2.13.1</version>
</dependency>

2、配置springmvc.xml

<?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
       https://www.springframework.org/schema/context/spring-context.xsd
       http://www.springframework.org/schema/mvc
       https://www.springframework.org/schema/mvc/spring-mvc.xsd">

    <!-- 自動掃描指定的包，下面所有注解類交給IOC容器管理 -->
    <context:component-scan base-package="com.blue.controller"/>

    <!-- 視圖解析器 -->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver"
          id="internalResourceViewResolver">
        <!-- 前綴 -->
        <property name="prefix" value="/WEB-INF/jsp/" />
        <!-- 后綴 -->
        <property name="suffix" value=".jsp" />
    </bean>

<!--    <bean name="/t1" class="com.blue.controller.ControllerTest1"/>-->

</beans>

3\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">

    <!--1.注冊servlet-->
    <servlet>
        <servlet-name>SpringMVC</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <!--通過初始化參數指定SpringMVC配置文件的位置，進行關聯-->
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:springmvc-servlet.xml</param-value>
        </init-param>
        <!-- 啟動順序，數字越小，啟動越早 -->
        <load-on-startup>1</load-on-startup>
    </servlet>

    <!--所有請求都會被springmvc攔截 -->
    <servlet-mapping>
        <servlet-name>SpringMVC</servlet-name>
        <url-pattern>/</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>

4\pojo

package com.blue.pojo;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@AllArgsConstructor
@NoArgsConstructor
public class User {
    private String name;
    private int age;
    private String sex;
}

5\UserController

package com.cjj.controller;

import com.cjj.pojo.User;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

@Controller
public class UserController {
    @RequestMapping("/j1")
    @ResponseBody//它就不會走page的jsp頁面，而是直接返回j一個字符串
            public String json1() throws JsonProcessingException {
        //創建一個jackson的對象映射器，用來解析數據
        ObjectMapper mapper = new ObjectMapper();
        //創建一個對象
        User user = new User("Tom", 20, "male");
        //將我們的對象解析成為json格式
        String str = mapper.writeValueAsString(user);
        return str;
    }
}

頁面返回：{"name":"Tom","age":20,"sex":"male"}

解決json亂碼問題

方法一

//produces:指定響應體返回類型和編碼
@RequestMapping(value = "/json1",produces = "application/json;charset=utf-8")

方法二
在springmvc-servlet.xml中添加下面代碼

<mvc:annotation-driven>
   <mvc:message-converters register-defaults="true">
       <bean class="org.springframework.http.converter.StringHttpMessageConverter">
           <constructor-arg value="UTF-8"/>
       </bean>
       <bean class="org.springframework.http.converter.json.MappingJackson2HttpMessageConverter">
           <property name="objectMapper">
               <bean class="org.springframework.http.converter.json.Jackson2ObjectMapperFactoryBean">
                   <property name="failOnEmptyBeans" value="false"/>
               </bean>
           </property>
       </bean>
   </mvc:message-converters>
</mvc:annotation-driven>

用注解restcontrolller會統一返回json

@RestController
public class UserController {
    @RequestMapping("/j1")
    @ResponseBody//它就不會走page的jsp頁面，而是直接返回j一個字符串
            public String json1() throws JsonProcessingException {
        //創建一個jackson的對象映射器，用來解析數據
        ObjectMapper mapper = new ObjectMapper();
        //創建一個對象
        User user = new User("Tom", 20, "male");
        //將我們的對象解析成為json格式
        String str = mapper.writeValueAsString(user);
        return str;
    }
}

返回json字符串統一解決,當需要返回多個對象時，放到一個集合中

@RequestMapping("/j2")

    public String json2() throws JsonProcessingException {
        //創建一個jackson的對象映射器，用來解析數據
        ObjectMapper mapper = new ObjectMapper();
        List<User> users = new ArrayList<User>();
        //創建多個對象
        User user = new User("Tom", 20, "male");
        User user2 = new User("Jerry", 25, "male");
        User user3 = new User("Lily", 30, "female");
        users.add(user);
        users.add(user2);
        users.add(user3);
        //將我們的對象解析成為json格式
        String str = mapper.writeValueAsString(users);
        return str;
    }

返回時間

 @RequestMapping("/j3")
    public String json3() throws JsonProcessingException {

        ObjectMapper mapper = new ObjectMapper();

        Date date = new Date();


        return mapper.writeValueAsString(date);
    }
只是返回時間戳

純java解決—時間戳

  @RequestMapping("/j3")
   public String json3() throws JsonProcessingException {

       ObjectMapper mapper = new ObjectMapper();
       Date date = new Date();

       // 自定義日期的格式
       SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

       // ObjectMapper,時間解析后的默認格式為：Timestamp,時間戳
       return mapper.writeValueAsString(sdf.format(date));
   }

把上面做成一個工具類

package com.blue.utils;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.SerializationFeature;

import java.text.SimpleDateFormat;

public class JsonUtils {
    public static String getJson(Object object) {
        return getJson(object,"yyyy-MM-dd HH:mm:ss");
    }

    public static String getJson(Object object,String dateFormat) {
        ObjectMapper mapper = new ObjectMapper();
        //不使用時間差的方式
        mapper.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS, false);
        //自定義日期格式對象
        SimpleDateFormat sdf = new SimpleDateFormat(dateFormat);
        //指定日期格式
        mapper.setDateFormat(sdf);
        try {
            return mapper.writeValueAsString(object);
        } catch (JsonProcessingException e) {
            e.printStackTrace();
        }
        return null;
    }

}

FastJson

fastjson.jar是阿里開發的一款專門用于Java開發的包，可以方便的實現json對象與JavaBean對象的轉換，實現JavaBean對象與json字符串的轉換，實現json對象與json字符串的轉換。實現json的轉換方法很多，最后的實現結果都是一樣的。
導包

    <dependency>
                <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.78</version>
        </dependency>

 @RequestMapping("/j6")
    public String json6() throws JsonProcessingException {

        List<User> userList = new ArrayList<User>();

        User user1 = new User("blue1", 3, "女");
        User user2 = new User("blue1", 3, "女");
        User user3 = new User("blue1", 3, "女");
        User user4 = new User("blue1", 3, "女");

        userList.add(user1);
        userList.add(user2);
        userList.add(user3);
        userList.add(user4);

        String str = JSON.toJSONString(userList);
        return str;
    }

package com.blue.controller;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.blue.pojo.User;

import java.util.ArrayList;
import java.util.List;

public class FastJsonDemo {
    public static void main(String[] args) {
        //創建一個對象
        User user1 = new User("秦疆1號", 3, "男");
        User user2 = new User("秦疆2號", 3, "男");
        User user3 = new User("秦疆3號", 3, "男");
        User user4 = new User("秦疆4號", 3, "男");
        List<User> list = new ArrayList<User>();
        list.add(user1);
        list.add(user2);
        list.add(user3);
        list.add(user4);

        System.out.println("*******Java對象 轉 JSON字符串*******");
        String str1 = JSON.toJSONString(list);
        System.out.println("JSON.toJSONString(list)==>"+str1);
        String str2 = JSON.toJSONString(user1);
        System.out.println("JSON.toJSONString(user1)==>"+str2);

        System.out.println("\n****** JSON字符串 轉 Java對象*******");
        User jp_user1=JSON.parseObject(str2,User.class);
        System.out.println("JSON.parseObject(str2,User.class)==>"+jp_user1);

        System.out.println("\n****** Java對象 轉 JSON對象 ******");
        JSONObject jsonObject1 = (JSONObject) JSON.toJSON(user2);
        System.out.println("(JSONObject) JSON.toJSON(user2)==>"+jsonObject1.getString("name"));

        System.out.println("\n****** JSON對象 轉 Java對象 ******");
        User to_java_user = JSON.toJavaObject(jsonObject1, User.class);
        System.out.println("JSON.toJavaObject(jsonObject1, User.class)==>"+to_java_user);
    }
}

SSM整合

Mybatis層

直接看第六節的整合

Ajax

模擬Ajax的原理，寫一個iframe請求，然后用JS把內容寫到本網頁框中，沒有整個網頁進行刷新

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>iframe測試體驗頁面無刷新</title>

    <script>
        function go(){
            var url = document.getElementById("url").value;
            document.getElementById("iframe1").src=url;

        }
    </script>

</head>
<body>

<div>
    <p>請輸入地址：</p>
    <p>
        <input type="text" id="url" value="https://www.bilibili.com/">
        <input type="button" value="提交" onclick="go()">
    </p>
</div>

<div>
    <iframe id="iframe1" style="width: 100%;height: 500px"></iframe>
</div>

</body>
</html>

前端請求到這，一般會給json數據

前端通過事件點擊觸發ajax請求后端地址，然后通過返回的數據通過js將數據顯示到網頁

攔截器

攔截器是springmvc框架自己的，只有用這個框架工程才有
攔截器只會攔截訪問控制器方法，如果訪問jsp,html,css,image,js是不會攔截

寫一個MyInterceptor類

package com.cjj.config;

import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;

public class MyInterceptor implements HandlerInterceptor {
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        System.out.println("處理前");
        return true;
    }
    //當上面是true時，才會執行下面方法，但是會先執行controller方法，然后再執行postHandle方法
    //如果上面是false，則執行上面方法后，就不會再執行controller方法
    //下面一般是拿來打印日記

    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        System.out.println("處理后");
        
    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        System.out.println("清理資源");
    }
}

2、在springmvc.xml配置

   <!--攔截器配置-->
    <mvc:interceptors>
        <mvc:interceptor>
            <mvc:mapping path="/**"/>
            <mvc:exclude-mapping path="/login"/>
            <bean class="com.cjj.config.MyInterceptor"/>
        </mvc:interceptor>
    </mvc:interceptors>

登錄判斷驗證

在web-INF下的頁面只能通過servlet或conrtollor請求，不能直接通過路徑+jsp來訪問

posted @ 2025-06-28 09:22 乘加法閱讀(7) 評論(0) 收藏舉報

刷新頁面返回頂部

Newlife666

springmvc

SpringMVC

回顧servlet

SpringMVC

SpringMVC執行原理

深入學習springMVC

使用注解開發springmvc

Controller及RestFul

第一種方法——實現Controller接口

第二種——使用注解@Controller

requestmapping

RestFul風格講解

重定向和轉發

接收請求參數及數據回顯

亂碼問題

JSON

Jackson使用

解決json亂碼問題

返回json字符串統一解決,當需要返回多個對象時，放到一個集合中

返回時間

FastJson

SSM整合

Mybatis層

Ajax

攔截器

登錄判斷驗證

公告