• SpringMVC：处理器方法的返回值（动力）

    ModelAanView：即传递数据，又跳转页面

    返回String，只进行页面的跳转工作

    void:不能表示数据，也不能表示视图，在处理ajax的时候可以使用void返回值 

     

     web.xml:

    1. <?xml version="1.0" encoding="UTF-8"?>
    2. <web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
    3.          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    4.          xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
    5.          version="4.0">
    6.  
    7. <!--    声明，注册springmvc的核心对象DispatcherServlet-->
    8.     <servlet>
    9.         <servlet-name>myweb</servlet-name>
    10.         <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    11.  
    12. <!--        自定义springmvc读取的配置文件的位置-->
    13.         <init-param>
    14.             <!--springmvc的配置文件属性-->
    15.             <param-name>contextConfigLocation</param-name>
    16.             <!-- 指定自定义文件的位置-->
    17.             <param-value>classpath:springmvc.xml</param-value>
    18.         </init-param>
    19.  
    20. <!--        在tomcat启动后，创建Servlet对象
    21.                load-on-startup:表示tomcat启动后创建对象的顺序，它的值是正数，数值越小 tomacat创建对象越早
    22. -->
    23.         <load-on-startup>1</load-on-startup>
    24.  
    25.     </servlet>
    26.  
    27. <!--    所有的*..do请求交给myweb中央处理器处理-->
    28.     <servlet-mapping>
    29.         <servlet-name>myweb</servlet-name>
    30.         <url-pattern>*.do</url-pattern>
    31.     </servlet-mapping>
    32.  
    33.     <!--注册声明过滤器，解决post请求乱码问题-->
    34.     <filter>
    35.         <filter-name>characterEncodingFilter</filter-name>
    36.         <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
    37.  
    38.         <!--设置项目中使用的编码-->
    39.         <init-param>
    40.             <param-name>encoding</param-name>
    41.             <param-value>utf-8</param-value>
    42.         </init-param>
    43.         <!--强制请求对象（HttpServletRequest）使用encoding编码的值-->
    44.         <init-param>
    45.             <param-name>forceRequestEncoding</param-name>
    46.             <param-value>true</param-value>
    47.         </init-param>
    48.         <!--强制应答对象（HttpServletResponse）使用encoding编码的值-->
    49.         <init-param>
    50.             <param-name>forceReponsetEncoding</param-name>
    51.             <param-value>true</param-value>
    52.         </init-param>
    53.     </filter>
    54.     <filter-mapping>
    55.         <filter-name>characterEncodingFilter</filter-name>
    56.        <!--
    57.           /*:表示强制所有的请求先通过过滤器处理
    58.         -->
    59.         <url-pattern>/*</url-pattern>
    60.     </filter-mapping>
    61. </web-app>

    springmvc.xml:

    1. <?xml version="1.0" encoding="UTF-8"?>
    2. <beans xmlns="http://www.springframework.org/schema/beans"
    3.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    4.        xmlns:context="http://www.springframework.org/schema/context"
    5.        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">
    6.  
    7. <!-- 用了注解需要注解扫描器：声明组件扫描器：包扫描-->
    8.     <context:component-scan base-package="com.bjpowernode.controller"/>
    9.  
    10. <!--    声明springmvc框架中的视图解析器，帮助开发人员设置视图文件的路径-->
    11.     <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
    12.         <!-- 前缀：视图文件的路径-->
    13.         <property name="prefix" value="/WEB-INF/view/"/>
    14.         <!-- 后缀：视图文件的扩展名-->
    15.         <property name="suffix" value=".jsp"/>
    16.     </bean>
    17.  
    18. </beans>

    返回类型为String： 

    MyController:

    1. package com.bjpowernode.controller;
    2.  
    3. import com.bjpowernode.vo.Student;
    4. import org.springframework.stereotype.Controller;
    5. import org.springframework.web.bind.annotation.RequestMapping;
    6. import org.springframework.web.bind.annotation.RequestMethod;
    7. import org.springframework.web.bind.annotation.RequestParam;
    8. import org.springframework.web.servlet.ModelAndView;
    9.  
    10. import javax.servlet.http.HttpServletRequest;
    11. import javax.servlet.http.HttpServletResponse;
    12. import javax.servlet.http.HttpSession;
    13.  
    14. @Controller
    15. public class MyController {
    16.  
    17.     //处理器方法返回String
    18.     @RequestMapping(value ="/returnString-view.do")   //value里面可以写多个名字进行访问
    19.     public String doReturnView(HttpServletRequest request,String name,Integer age){ //doSome相当于doGet（）---调用Service请求处理
    20.         System.out.println("doReturnView，name="+name+"  age="+age);//这里先不调用，简化处理
    21.  
    22.         //如果还想存储数据，可以手工去做，我们可以使用request作用域手工添加到request作用域
    23.         request.setAttribute("myname",name);
    24.         request.setAttribute("myage",age);
    25.  
    26.         //show:逻辑视图名称，项目中配置了视图解析器
    27.         //框架对视图执行forword转发操作
    28.         return "show";
    29.         //还可以返回完整路径，不用视图解析器，在配置文件中把视图解析器注释
    30.         //return "/WEB-INF/view/show.jsp";
    31.  
    32.     }
    33. }

    index.xml:

    1. <%--
    2.   Created by IntelliJ IDEA.
    3.   User: DELL
    4.   Date: 2022/6/7
    5.   Time: 17:37
    6.   To change this template use File | Settings | File Templates.
    7. --%>
    8. <%@ page contentType="text/html;charset=UTF-8" language="java" %>
    9. <%
    10.     String path = request.getContextPath();
    11.     String basePath = request.getScheme() + "://" + request.getServerName() + ":" + request.getServerPort() + path + "/";
    12. %>
    13. <html>
    14. <head>
    15.     <title>Title</title>
    16.     <base href="<%=basePath%>">
    17. </head>
    18. <body>
    19.   <h1>处理器方法返回String表示视图名称</h1>
    20.  
    21.   <form action="returnString-view.do" method="post">
    22.       姓名：<input type="text" name="name"><br>
    23.       年龄：<input type="text" name="age"><br>
    24.       <input type="submit" value="提交参数">
    25.   </form>
    26. </body>
    27. </html>

    show.jsp:

    1. <%--
    2.   Created by IntelliJ IDEA.
    3.   User: DELL
    4.   Date: 2022/6/7
    5.   Time: 19:01
    6.   To change this template use File | Settings | File Templates.
    7. --%>
    8. <%@ page contentType="text/html;charset=UTF-8" language="java" %>
    9. <%
    10.     String path = request.getContextPath();
    11.     String basePath = request.getScheme() + "://" + request.getServerName() + ":" + request.getServerPort() + path + "/";
    12. %>
    13. <html>
    14. <head>
    15.     <title>Title</title>
    16.     <base href="<%=basePath%>">
    17. </head>
    18. <body>
    19.  <h3>/WEB-INF/view/show.jsp,从request作用域中获取数据</h3>
    20.   <h3>myname数据：${myname}</h3>
    21.   <h3>myage数据：${myage}</h3>
    22. </body>
    23. </html>

     

     返回值void：

    pom.xml:引入json依赖：

    1. <?xml version="1.0" encoding="UTF-8"?>
    2.  
    3. <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    4.   xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    5.   <modelVersion>4.0.0</modelVersion>
    6.  
    7.   <groupId>com.beijingnode</groupId>
    8.   <artifactId>ch04-return</artifactId>
    9.   <version>1.0-SNAPSHOT</version>
    10.   <packaging>war</packaging>
    11.  
    12.  
    13.   <properties>
    14.     <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    15.     <maven.compiler.source>1.8</maven.compiler.source>
    16.     <maven.compiler.target>1.8</maven.compiler.target>
    17.   </properties>
    18.  
    19.   <dependencies>
    20.     <dependency>
    21.       <groupId>junit</groupId>
    22.       <artifactId>junit</artifactId>
    23.       <version>4.11</version>
    24.       <scope>test</scope>
    25.     </dependency>
    26. <!--    servlet依赖-->
    27.     <dependency>
    28.       <groupId>javax.servlet</groupId>
    29.       <artifactId>javax.servlet-api</artifactId>
    30.       <version>3.1.0</version>
    31.       <scope>provided</scope>
    32.     </dependency>
    33.  
    34. <!--    springmvc依赖-->
    35.     <dependency>
    36.       <groupId>org.springframework</groupId>
    37.       <artifactId>spring-webmvc</artifactId>
    38.       <version>5.2.5.RELEASE</version>
    39.     </dependency>
    40.  
    41. <!--    Jackson依赖-->
    42.     <dependency>
    43.       <groupId>com.fasterxml.jackson.core</groupId>
    44.       <artifactId>jackson-core</artifactId>
    45.       <version>2.9.0</version>
    46.     </dependency>
    47.     <dependency>
    48.       <groupId>com.fasterxml.jackson.core</groupId>
    49.       <artifactId>jackson-databind</artifactId>
    50.       <version>2.9.0</version>
    51.     </dependency>
    52.   </dependencies>
    53.  
    54.   <build>
    55.     <plugins>
    56. <!--      编码和编译和JDK版本-->
    57.       <plugin>
    58.         <artifactId>maven-compiler-plugin</artifactId>
    59.         <version>3.1</version>
    60.         <configuration>
    61.           <source>1.8</source>
    62.           <target>1.8</target>
    63.         </configuration>
    64.       </plugin>
    65.     </plugins>
    66.   </build>
    67. </project>

    Student：

    1. package com.bjpowernode.vo;
    2. //保存请求参数的一个普通类
    3. public class Student {
    4.     //属性名和请求中的参数名一样
    5.     private String name;
    6.     private Integer age;
    7.  
    8.     public Student() {
    9.         System.out.println("===Student===的无参构造方法");
    10.     }
    11.  
    12.     public String getName() {
    13.         return name;
    14.     }
    15.  
    16.     public void setName(String name) {
    17.         System.out.println("SetName="+name);
    18.         this.name = name;
    19.     }
    20.  
    21.     public Integer getAge() {
    22.         return age;
    23.     }
    24.  
    25.     public void setAge(Integer age) {
    26.         System.out.println("SetAge="+age);
    27.         this.age = age;
    28.     }
    29.  
    30.     @Override
    31.     public String toString() {
    32.         return "Stuydent{" +
    33.                 "name='" + name + '\'' +
    34.                 ", age=" + age +
    35.                 '}';
    36.     }
    37. }

    MyController:

    1. package com.bjpowernode.controller;
    2.  
    3. import com.bjpowernode.vo.Student;
    4. import com.fasterxml.jackson.core.JsonProcessingException;
    5. import com.fasterxml.jackson.databind.ObjectMapper;
    6. import org.springframework.stereotype.Controller;
    7. import org.springframework.web.bind.annotation.RequestMapping;
    8. import org.springframework.web.bind.annotation.RequestMethod;
    9. import org.springframework.web.bind.annotation.RequestParam;
    10. import org.springframework.web.servlet.ModelAndView;
    11.  
    12. import javax.servlet.http.HttpServletRequest;
    13. import javax.servlet.http.HttpServletResponse;
    14. import javax.servlet.http.HttpSession;
    15. import java.io.IOException;
    16. import java.io.PrintWriter;
    17.  
    18. @Controller
    19. public class MyController {
    20.  
    21.  
    22.     //处理器方法返回String
    23.     @RequestMapping(value ="/returnString-view.do")   //value里面可以写多个名字进行访问
    24.     public String doReturnView(HttpServletRequest request,String name,Integer age){ //doSome相当于doGet（）---调用Service请求处理
    25.         System.out.println("doReturnView，name="+name+"  age="+age);//这里先不调用，简化处理
    26.  
    27.         //如果还想存储数据，可以手工去做，我们可以使用request作用域手工添加到request作用域
    28.         request.setAttribute("myname",name);
    29.         request.setAttribute("myage",age);
    30.  
    31.         //show:逻辑视图名称，项目中配置了视图解析器
    32.         //框架对视图执行forword转发操作
    33.         return "show";
    34.         //还可以返回完整路径，不用视图解析器，在配置文件中把视图解析器注释
    35.         //return "/WEB-INF/view/show.jsp";
    36.  
    37.     }
    38.  
    39.     //处理器方法返回void ，响应ajax请求
    40.     @RequestMapping(value ="/returnVoid-ajax.do")   //value里面可以写多个名字进行访问
    41.     public void doReturnVoidAjax(HttpServletResponse response,String name,Integer age) throws IOException { //doSome相当于doGet（）---调用Service请求处理
    42.         System.out.println("doReturnVoidAjax，name="+name+"  age="+age);//这里先不调用，简化处理
    43.  
    44.         //处理ajax，使用json做数据的格式
    45.         //Service调用完了，使用Student表示处理结果
    46.         Student student=new Student();
    47.         student.setName(name);
    48.         student.setAge(age);
    49.  
    50.         String json="";
    51.         //把结果的对象转为json格式的数据
    52.         if(student!=null){
    53.             ObjectMapper om=new ObjectMapper();
    54.            json= om.writeValueAsString(student);
    55.             System.out.println("Student转换为json=="+json);
    56.         }
    57.  
    58.         //输出数据，响应ajax的请求
    59.         response.setContentType("application/json;charset=utf-8");
    60.         PrintWriter pw=response.getWriter();
    61.         pw.println(json);
    62.         pw.flush();
    63.         pw.close();
    64.  
    65.  
    66.  
    67.     }
    68. }

    index.jsp:

    1. <%--
    2.   Created by IntelliJ IDEA.
    3.   User: DELL
    4.   Date: 2022/6/7
    5.   Time: 17:37
    6.   To change this template use File | Settings | File Templates.
    7. --%>
    8. <%@ page contentType="text/html;charset=UTF-8" language="java" %>
    9. <%
    10.     String path = request.getContextPath();
    11.     String basePath = request.getScheme() + "://" + request.getServerName() + ":" + request.getServerPort() + path + "/";
    12. %>
    13. <html>
    14. <head>
    15.     <title>Title</title>
    16.     <base href="<%=basePath%>">
    17.     <script type="text/javascript" src="js/jquery-3.3.1.js"></script>
    18.     <script type="text/javascript">
    19.         $(function(){
    20.             $("button").click(function(){
    21.                 //alert("button click");
    22.                 $.ajax({
    23.                     url:"returnVoid-ajax.do",
    24.                     data:{
    25.                         name:"zhangsan",
    26.                         age:20
    27.                     },
    28.                     type:"post",
    29.                     dataType:"json",
    30.                     success:function(resp){
    31.                         //resp从服务器返回的是json格式的字符串{"name":"zhangsan","age":20}
    32.                         //jquery会把字符串转换为json对象，赋值给resp形参
    33.                         alert(resp.name+"   "+resp.age);
    34.                     }
    35.                 })
    36.  
    37.             })
    38.         })
    39.     </script>
    40. </head>
    41. <body>
    42.   <h1>处理器方法返回String表示视图名称</h1>
    43.  
    44.   <form action="returnString-view.do" method="post">
    45.       姓名：<input type="text" name="name"><br>
    46.       年龄：<input type="text" name="age"><br>
    47.       <input type="submit" value="提交参数">
    48.   </form>
    49.   <br>
    50.   <br>
    51.   <button id="btn">发起ajax请求</button>
    52. </body>
    53. </html>

    点击发起ajax请求：

     

    Response Header：响应头：

    Content-Type：application/json;charset=utf-8 , 值得是我们的Controller向浏览器返回的数据说明，对应：

    //输出数据，响应ajax的请求
response.setContentType("application/json;charset=utf-8");

     Request Header：请求头：发请求给Controller，附带的一些参数，Controller需要用的话可以取出来的

    Accep：application/json,text/javascripot, */*;q=0.01 来自，jquery中：

    dataType:"json",//表示希望得到的数据时json格式

    在点击发送请求时把json转换为Accep的东西，把它Controller

     

    Response：响应 响应的是一个json

    服务器端输出的结果：

    PrintWriter pw=response.getWriter();
pw.println(json);

    Preview：参数：对应：

    data:{
    name:"zhangsan",
    age:20
},

     返回对象：

    返回对象可以用来响应ajax请求的

     不用在做将结果对象转换为json和输出数据，响应ajax，交给框架来处理

    springmvc.xml:

    1. <?xml version="1.0" encoding="UTF-8"?>
    2. <beans xmlns="http://www.springframework.org/schema/beans"
    3.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    4.        xmlns:context="http://www.springframework.org/schema/context"
    5.        xmlns:mvc="http://www.springframework.org/schema/mvc"
    6.        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">
    7.  
    8. <!-- 用了注解需要注解扫描器：声明组件扫描器：包扫描-->
    9.     <context:component-scan base-package="com.bjpowernode.controller"/>
    10.  
    11. <!--    声明springmvc框架中的视图解析器，帮助开发人员设置视图文件的路径-->
    12.     <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
    13.         <!-- 前缀：视图文件的路径-->
    14.         <property name="prefix" value="/WEB-INF/view/"/>
    15.         <!-- 后缀：视图文件的扩展名-->
    16.         <property name="suffix" value=".jsp"/>
    17.     </bean>
    18.  
    19. <!--    加上注解驱动-->
    20.     <mvc:annotation-driven/>
    21. </beans>

     

     MyController：

    1. package com.bjpowernode.controller;
    2.  
    3. import com.bjpowernode.vo.Student;
    4. import com.fasterxml.jackson.core.JsonProcessingException;
    5. import com.fasterxml.jackson.databind.ObjectMapper;
    6. import org.springframework.stereotype.Controller;
    7. import org.springframework.web.bind.annotation.RequestMapping;
    8. import org.springframework.web.bind.annotation.RequestMethod;
    9. import org.springframework.web.bind.annotation.RequestParam;
    10. import org.springframework.web.bind.annotation.ResponseBody;
    11. import org.springframework.web.servlet.ModelAndView;
    12.  
    13. import javax.servlet.http.HttpServletRequest;
    14. import javax.servlet.http.HttpServletResponse;
    15. import javax.servlet.http.HttpSession;
    16. import java.io.IOException;
    17. import java.io.PrintWriter;
    18.  
    19. @Controller
    20. public class MyController {
    21.  
    22.  
    23.     //处理器方法返回String
    24.     @RequestMapping(value ="/returnString-view.do")   //value里面可以写多个名字进行访问
    25.     public String doReturnView(HttpServletRequest request,String name,Integer age){ //doSome相当于doGet（）---调用Service请求处理
    26.         System.out.println("doReturnView，name="+name+"  age="+age);//这里先不调用，简化处理
    27.  
    28.         //如果还想存储数据，可以手工去做，我们可以使用request作用域手工添加到request作用域
    29.         request.setAttribute("myname",name);
    30.         request.setAttribute("myage",age);
    31.  
    32.         //show:逻辑视图名称，项目中配置了视图解析器
    33.         //框架对视图执行forword转发操作
    34.         return "show";
    35.         //还可以返回完整路径，不用视图解析器，在配置文件中把视图解析器注释
    36.         //return "/WEB-INF/view/show.jsp";
    37.  
    38.     }
    39.  
    40.     //处理器方法返回void ，响应ajax请求
    41.     //手工实现ajax，json数据：代码存在重复：java对象转换为json；通过HttpServletResponse输出json数据
    42.     @RequestMapping(value ="/returnVoid-ajax.do")   //value里面可以写多个名字进行访问
    43.     public void doReturnVoidAjax(HttpServletResponse response,String name,Integer age) throws IOException { //doSome相当于doGet（）---调用Service请求处理
    44.         System.out.println("doReturnVoidAjax，name="+name+"  age="+age);//这里先不调用，简化处理
    45.  
    46.         //处理ajax，使用json做数据的格式
    47.         //Service调用完了，使用Student表示处理结果
    48.         Student student=new Student();
    49.         student.setName(name);
    50.         student.setAge(age);
    51.  
    52.         String json="";
    53.         //把结果的对象转为json格式的数据
    54.         if(student!=null){
    55.             ObjectMapper om=new ObjectMapper();
    56.            json= om.writeValueAsString(student);
    57.             System.out.println("Student转换为json=="+json);
    58.         }
    59.  
    60.         //输出数据，响应ajax的请求
    61.         response.setContentType("application/json;charset=utf-8");
    62.         PrintWriter pw=response.getWriter();
    63.         pw.println(json);
    64.         pw.flush();
    65.         pw.close();
    66.     }
    67.  
    68.  
    69.     //处理器方法返回一个Student，通过框架转为json，响应ajax请求
    70.     //@ResponseBody注解作用：把处理器方法返回的对象转为json后，通过HttpServletResponse输出给浏览器。
    71.     @RequestMapping(value ="/returnStudentJson.do")
    72.     @ResponseBody
    73.     public Student doStudentJsonObject(String name,Integer age){
    74.         //调用Service，获取请求结果数据，Student对象表示结果数据
    75.         Student student=new Student();
    76.         student.setName("李四");
    77.         student.setAge(20);
    78.         return student;//会被框架转换为json
    79.     }
    80. }

    index.jsp:更换访问的url：

    1. <%--
    2.   Created by IntelliJ IDEA.
    3.   User: DELL
    4.   Date: 2022/6/7
    5.   Time: 17:37
    6.   To change this template use File | Settings | File Templates.
    7. --%>
    8. <%@ page contentType="text/html;charset=UTF-8" language="java" %>
    9. <%
    10.     String path = request.getContextPath();
    11.     String basePath = request.getScheme() + "://" + request.getServerName() + ":" + request.getServerPort() + path + "/";
    12. %>
    13. <html>
    14. <head>
    15.     <title>Title</title>
    16.     <base href="<%=basePath%>">
    17.     <script type="text/javascript" src="js/jquery-3.3.1.js"></script>
    18.     <script type="text/javascript">
    19.         $(function(){
    20.             $("button").click(function(){
    21.                 //alert("button click");
    22.                 $.ajax({
    23.                     //url:"returnVoid-ajax.do",
    24.                     url:"returnStudentJson.do",
    25.                     data:{
    26.                         name:"zhangsan",
    27.                         age:20
    28.                     },
    29.                     type:"post",
    30.                     dataType:"json",
    31.                     success:function(resp){
    32.                         //resp从服务器返回的是json格式的字符串{"name":"zhangsan","age":20}
    33.                         //jquery会把字符串转换为json对象，赋值给resp形参
    34.                         alert(resp.name+"   "+resp.age);
    35.                     }
    36.                 })
    37.  
    38.             })
    39.         })
    40.     </script>
    41. </head>
    42. <body>
    43.   <h1>处理器方法返回String表示视图名称</h1>
    44.  
    45.   <form action="returnString-view.do" method="post">
    46.       姓名：<input type="text" name="name"><br>
    47.       年龄：<input type="text" name="age"><br>
    48.       <input type="submit" value="提交参数">
    49.   </form>
    50.   <br>
    51.   <br>
    52.   <button id="btn">发起ajax请求</button>
    53. </body>
    54. </html>

     返回json对象数组：返回List集合

    MyController：

    1. package com.bjpowernode.controller;
    2.  
    3. import com.bjpowernode.vo.Student;
    4. import com.fasterxml.jackson.core.JsonProcessingException;
    5. import com.fasterxml.jackson.databind.ObjectMapper;
    6. import org.springframework.stereotype.Controller;
    7. import org.springframework.web.bind.annotation.RequestMapping;
    8. import org.springframework.web.bind.annotation.RequestMethod;
    9. import org.springframework.web.bind.annotation.RequestParam;
    10. import org.springframework.web.bind.annotation.ResponseBody;
    11. import org.springframework.web.servlet.ModelAndView;
    12.  
    13. import javax.servlet.http.HttpServletRequest;
    14. import javax.servlet.http.HttpServletResponse;
    15. import javax.servlet.http.HttpSession;
    16. import java.io.IOException;
    17. import java.io.PrintWriter;
    18. import java.util.ArrayList;
    19. import java.util.List;
    20.  
    21. @Controller
    22. public class MyController {
    23.  
    24.  
    25.     //处理器方法返回String
    26.     @RequestMapping(value ="/returnString-view.do")   //value里面可以写多个名字进行访问
    27.     public String doReturnView(HttpServletRequest request,String name,Integer age){ //doSome相当于doGet（）---调用Service请求处理
    28.         System.out.println("doReturnView，name="+name+"  age="+age);//这里先不调用，简化处理
    29.  
    30.         //如果还想存储数据，可以手工去做，我们可以使用request作用域手工添加到request作用域
    31.         request.setAttribute("myname",name);
    32.         request.setAttribute("myage",age);
    33.  
    34.         //show:逻辑视图名称，项目中配置了视图解析器
    35.         //框架对视图执行forword转发操作
    36.         return "show";
    37.         //还可以返回完整路径，不用视图解析器，在配置文件中把视图解析器注释
    38.         //return "/WEB-INF/view/show.jsp";
    39.  
    40.     }
    41.  
    42.     //处理器方法返回void ，响应ajax请求
    43.     //手工实现ajax，json数据：代码存在重复：java对象转换为json；通过HttpServletResponse输出json数据
    44.     @RequestMapping(value ="/returnVoid-ajax.do")   //value里面可以写多个名字进行访问
    45.     public void doReturnVoidAjax(HttpServletResponse response,String name,Integer age) throws IOException { //doSome相当于doGet（）---调用Service请求处理
    46.         System.out.println("doReturnVoidAjax，name="+name+"  age="+age);//这里先不调用，简化处理
    47.  
    48.         //处理ajax，使用json做数据的格式
    49.         //Service调用完了，使用Student表示处理结果
    50.         Student student=new Student();
    51.         student.setName(name);
    52.         student.setAge(age);
    53.  
    54.         String json="";
    55.         //把结果的对象转为json格式的数据
    56.         if(student!=null){
    57.             ObjectMapper om=new ObjectMapper();
    58.            json= om.writeValueAsString(student);
    59.             System.out.println("Student转换为json=="+json);
    60.         }
    61.  
    62.         //输出数据，响应ajax的请求
    63.         response.setContentType("application/json;charset=utf-8");
    64.         PrintWriter pw=response.getWriter();
    65.         pw.println(json);
    66.         pw.flush();
    67.         pw.close();
    68.     }
    69.  
    70.  
    71.     //处理器方法返回一个Student，通过框架转为json，响应ajax请求
    72.     //@ResponseBody注解作用：把处理器方法返回的对象转为json后，通过HttpServletResponse输出给浏览器。
    73.     /*
    74.     返回对象框架的处理流程：
    75.       1.框架会把返回Student类型，调用框架中的ArrayList<HttpMeaasgeConverter>中的每个类的canwrite（）方法
    76.        检查哪个HttpMessageConverter接口的实现类能处理Student类型的数据-->MappingJackson2HttpMessageConverter
    77.       2.框架会调用实现类的write（）方法，把李四的Student对象转为json，调用Jackon的ObjectMapper实现转换json
    78.       3.框架会电泳@ResponseBody把2的结果输出到浏览器，ajax请求处理完成
    79.     */
    80.     @RequestMapping(value ="/returnStudentJson.do")
    81.     @ResponseBody
    82.     public Student doStudentJsonObject(String name,Integer age){
    83.         //调用Service，获取请求结果数据，Student对象表示结果数据
    84.         Student student=new Student();
    85.         student.setName("李四");
    86.         student.setAge(20);
    87.         return student;//会被框架转换为json
    88.     }
    89.  
    90.  
    91.     /*处理器方法返回一个List集合，通过框架转为json，响应ajax请求
    92.     @ResponseBody注解作用：把处理器方法返回的对象转为json后，通过HttpServletResponse输出给浏览器。
    93.     */
    94.      /*
    95.     返回对象框架的处理流程：
    96.       1.框架会把返回List<Student>类型，调用框架中的ArrayList<HttpMeaasgeConverter>中的每个类的canwrite（）方法
    97.        检查哪个HttpMessageConverter接口的实现类能处理Student类型的数据-->MappingJackson2HttpMessageConverter
    98.       2.框架会调用实现类的write（）方法，把李四的Student对象转为json，调用Jackon的ObjectMapper实现转换json array
    99.       3.框架会电泳@ResponseBody把2的结果输出到浏览器，ajax请求处理完成
    100.     */
    101.     @RequestMapping(value ="/returnStudentJsonArray.do")
    102.     @ResponseBody
    103.     public List<Student> doStudentJsonObjectArray(String name, Integer age){
    104.  
    105.         List<Student> list=new ArrayList<>();
    106.         //调用Service，获取请求结果数据，Student对象表示结果数据
    107.         Student student=new Student();
    108.         student.setName("李四");
    109.         student.setAge(20);
    110.  
    111.         list.add(student);
    112.  
    113.         student=new Student();
    114.         student.setName("张三");
    115.         student.setAge(28);
    116.         list.add(student);
    117.  
    118.         return list;//会被框架转换为json数组
    119.     }
    120. }

    index.jsp:更换url

    1. <%--
    2.   Created by IntelliJ IDEA.
    3.   User: DELL
    4.   Date: 2022/6/7
    5.   Time: 17:37
    6.   To change this template use File | Settings | File Templates.
    7. --%>
    8. <%@ page contentType="text/html;charset=UTF-8" language="java" %>
    9. <%
    10.     String path = request.getContextPath();
    11.     String basePath = request.getScheme() + "://" + request.getServerName() + ":" + request.getServerPort() + path + "/";
    12. %>
    13. <html>
    14. <head>
    15.     <title>Title</title>
    16.     <base href="<%=basePath%>">
    17.     <script type="text/javascript" src="js/jquery-3.3.1.js"></script>
    18.     <script type="text/javascript">
    19.         $(function(){
    20.             $("button").click(function(){
    21.                 //alert("button click");
    22.                 $.ajax({
    23.                     //url:"returnVoid-ajax.do",
    24.                     //url:"returnStudentJson.do",
    25.                     url:"returnStudentJsonArray.do",
    26.                     data:{
    27.                         name:"zhangsan",
    28.                         age:20
    29.                     },
    30.                     type:"post",
    31.                     dataType:"json",
    32.                     success:function(resp){
    33.                         //resp从服务器返回的是json格式的字符串{"name":"zhangsan","age":20}
    34.                         //jquery会把字符串转换为json对象，赋值给resp形参
    35.                         //alert(resp.name+"   "+resp.age);
    36.  
    37.                         //返回的是json数组
    38.                         $.each(resp,function (i,n) {
    39.                             alert(n.name+"  "+n.age);
    40.                         })
    41.                     }
    42.                 })
    43.  
    44.             })
    45.         })
    46.     </script>
    47. </head>
    48. <body>
    49.   <h1>处理器方法返回String表示视图名称</h1>
    50.  
    51.   <form action="returnString-view.do" method="post">
    52.       姓名：<input type="text" name="name"><br>
    53.       年龄：<input type="text" name="age"><br>
    54.       <input type="submit" value="提交参数">
    55.   </form>
    56.   <br>
    57.   <br>
    58.   <button id="btn">发起ajax请求</button>
    59. </body>
    60. </html>

    响应ajax，处理器返回的是String

    My Controller：

    1. package com.bjpowernode.controller;
    2.  
    3. import com.bjpowernode.vo.Student;
    4. import com.fasterxml.jackson.core.JsonProcessingException;
    5. import com.fasterxml.jackson.databind.ObjectMapper;
    6. import org.springframework.stereotype.Controller;
    7. import org.springframework.web.bind.annotation.RequestMapping;
    8. import org.springframework.web.bind.annotation.RequestMethod;
    9. import org.springframework.web.bind.annotation.RequestParam;
    10. import org.springframework.web.bind.annotation.ResponseBody;
    11. import org.springframework.web.servlet.ModelAndView;
    12.  
    13. import javax.servlet.http.HttpServletRequest;
    14. import javax.servlet.http.HttpServletResponse;
    15. import javax.servlet.http.HttpSession;
    16. import java.io.IOException;
    17. import java.io.PrintWriter;
    18. import java.util.ArrayList;
    19. import java.util.List;
    20.  
    21. @Controller
    22. public class MyController {
    23.  
    24.  
    25.     //处理器方法返回String
    26.     @RequestMapping(value ="/returnString-view.do")   //value里面可以写多个名字进行访问
    27.     public String doReturnView(HttpServletRequest request,String name,Integer age){ //doSome相当于doGet（）---调用Service请求处理
    28.         System.out.println("doReturnView，name="+name+"  age="+age);//这里先不调用，简化处理
    29.  
    30.         //如果还想存储数据，可以手工去做，我们可以使用request作用域手工添加到request作用域
    31.         request.setAttribute("myname",name);
    32.         request.setAttribute("myage",age);
    33.  
    34.         //show:逻辑视图名称，项目中配置了视图解析器
    35.         //框架对视图执行forword转发操作
    36.         return "show";
    37.         //还可以返回完整路径，不用视图解析器，在配置文件中把视图解析器注释
    38.         //return "/WEB-INF/view/show.jsp";
    39.  
    40.     }
    41.  
    42.     //处理器方法返回void ，响应ajax请求
    43.     //手工实现ajax，json数据：代码存在重复：java对象转换为json；通过HttpServletResponse输出json数据
    44.     @RequestMapping(value ="/returnVoid-ajax.do")   //value里面可以写多个名字进行访问
    45.     public void doReturnVoidAjax(HttpServletResponse response,String name,Integer age) throws IOException { //doSome相当于doGet（）---调用Service请求处理
    46.         System.out.println("doReturnVoidAjax，name="+name+"  age="+age);//这里先不调用，简化处理
    47.  
    48.         //处理ajax，使用json做数据的格式
    49.         //Service调用完了，使用Student表示处理结果
    50.         Student student=new Student();
    51.         student.setName(name);
    52.         student.setAge(age);
    53.  
    54.         String json="";
    55.         
    56.         //把结果的对象转为json格式的数据
    57.         if(student!=null){
    58.             ObjectMapper om=new ObjectMapper();
    59.            json= om.writeValueAsString(student);
    60.             System.out.println("Student转换为json=="+json);
    61.         }
    62.  
    63.         //输出数据，响应ajax的请求
    64.         response.setContentType("application/json;charset=utf-8");
    65.         PrintWriter pw=response.getWriter();
    66.         pw.println(json);
    67.         pw.flush();
    68.         pw.close();
    69.     }
    70.  
    71.  
    72.     //处理器方法返回一个Student，通过框架转为json，响应ajax请求
    73.     //@ResponseBody注解作用：把处理器方法返回的对象转为json后，通过HttpServletResponse输出给浏览器。
    74.     /*
    75.     返回对象框架的处理流程：
    76.       1.框架会把返回Student类型，调用框架中的ArrayList<HttpMeaasgeConverter>中的每个类的canwrite（）方法
    77.        检查哪个HttpMessageConverter接口的实现类能处理Student类型的数据-->MappingJackson2HttpMessageConverter
    78.       2.框架会调用实现类的write（）方法，把李四的Student对象转为json，调用Jackon的ObjectMapper实现转换json
    79.           contentType：application/json;charset=utf-8
    80.       3.框架会电泳@ResponseBody把2的结果输出到浏览器，ajax请求处理完成
    81.     */
    82.     @RequestMapping(value ="/returnStudentJson.do")
    83.     @ResponseBody
    84.     public Student doStudentJsonObject(String name,Integer age){
    85.         //调用Service，获取请求结果数据，Student对象表示结果数据
    86.         Student student=new Student();
    87.         student.setName("李四");
    88.         student.setAge(20);
    89.         return student;//会被框架转换为json
    90.     }
    91.  
    92.  
    93.     /*处理器方法返回一个List集合，通过框架转为json，响应ajax请求
    94.     @ResponseBody注解作用：把处理器方法返回的对象转为json后，通过HttpServletResponse输出给浏览器。
    95.     */
    96.      /*
    97.     返回对象框架的处理流程：
    98.       1.框架会把返回List<Student>类型，调用框架中的ArrayList<HttpMeaasgeConverter>中的每个类的canwrite（）方法
    99.        检查哪个HttpMessageConverter接口的实现类能处理Student类型的数据-->MappingJackson2HttpMessageConverter
    100.       2.框架会调用实现类的write（）方法，把李四的Student对象转为json，调用Jackon的ObjectMapper实现转换json array
    101.          contentType：application/json;charset=utf-8
    102.       3.框架会电泳@ResponseBody把2的结果输出到浏览器，ajax请求处理完成
    103.     */
    104.     @RequestMapping(value ="/returnStudentJsonArray.do")
    105.     @ResponseBody
    106.     public List<Student> doStudentJsonObjectArray(String name, Integer age){
    107.  
    108.         List<Student> list=new ArrayList<>();
    109.         //调用Service，获取请求结果数据，Student对象表示结果数据
    110.         Student student=new Student();
    111.         student.setName("李四");
    112.         student.setAge(20);
    113.  
    114.         list.add(student);
    115.  
    116.         student=new Student();
    117.         student.setName("张三");
    118.         student.setAge(28);
    119.         list.add(student);
    120.  
    121.         return list;//会被框架转换为json数组
    122.     }
    123.  
    124.     /*
    125.     * 处理器方法返回的是String，String表示数据，不是视图
    126.     *   区分返回值是String 是数据，还是视图，看有没有@ResponseBody注解
    127.     *    如果有@ResponseBody注解，返回String就是数据，反之就是视图
    128.     * 默认使用“text/plain;charset=IOS-8859-1”作为contentType，导致中文乱码
    129.     * 解决：
    130.     *   给@ResponseMapping增加一个属性produces，使用这个属性指定的新的contentType
    131.     * */
    132.     /*
    133.     返回对象框架的处理流程：
    134.       1.框架会把返回String类型，调用框架中的ArrayList<HttpMeaasgeConverter>中的每个类的canwrite（）方法
    135.        检查哪个HttpMessageConverter接口的实现类能处理String类型的数据-->StringHttpMessageConverter
    136.       2.框架会调用实现类StringHttpMessageConverter的write（）方法
    137.          把字符串按照指定的编码处理，text/plain;charset=IOS-8859-1
    138.       3.框架会电泳@ResponseBody把2的结果输出到浏览器，ajax请求处理完成
    139.     */
    140.     @RequestMapping(value = "/returnStringData.do",produces = "text/plain;charset=utf-8")
    141.     @ResponseBody
    142.     public String doStringData(String  name,Integer age){
    143.         return "Hellow SpringMVC 返回对象，表示数据";
    144.     }
    145.  
    146. }

    index.jsp:更换url和dataType

    1. <%--
    2.   Created by IntelliJ IDEA.
    3.   User: DELL
    4.   Date: 2022/6/7
    5.   Time: 17:37
    6.   To change this template use File | Settings | File Templates.
    7. --%>
    8. <%@ page contentType="text/html;charset=UTF-8" language="java" %>
    9. <%
    10.     String path = request.getContextPath();
    11.     String basePath = request.getScheme() + "://" + request.getServerName() + ":" + request.getServerPort() + path + "/";
    12. %>
    13. <html>
    14. <head>
    15.     <title>Title</title>
    16.     <base href="<%=basePath%>">
    17.     <script type="text/javascript" src="js/jquery-3.3.1.js"></script>
    18.     <script type="text/javascript">
    19.         $(function(){
    20.             $("button").click(function(){
    21.                 //alert("button click");
    22.                 $.ajax({
    23.                     //url:"returnVoid-ajax.do",
    24.                     //url:"returnStudentJson.do",
    25.                     //url:"returnStudentJsonArray.do",
    26.                     url:"returnStringData.do",
    27.                     data:{
    28.                         name:"zhangsan",
    29.                         age:20
    30.                     },
    31.                     type:"post",
    32.                     //dataType:"json",
    33.                     dataType:"text",
    34.                     success:function(resp){
    35.                         //resp从服务器返回的是json格式的字符串{"name":"zhangsan","age":20}
    36.                         //jquery会把字符串转换为json对象，赋值给resp形参
    37.                         //alert(resp.name+"   "+resp.age);
    38.  
    39.                         //返回的是json数组
    40.                         /*$.each(resp,function (i,n) {
    41.                             alert(n.name+"  "+n.age);
    42.                         })*/
    43.  
    44.                         //返回的数据,字符串
    45.                         alert("返回文本数据："+resp);
    46.                     }
    47.                 })
    48.  
    49.             })
    50.         })
    51.     </script>
    52. </head>
    53. <body>
    54.   <h1>处理器方法返回String表示视图名称</h1>
    55.  
    56.   <form action="returnString-view.do" method="post">
    57.       姓名：<input type="text" name="name"><br>
    58.       年龄：<input type="text" name="age"><br>
    59.       <input type="submit" value="提交参数">
    60.   </form>
    61.   <br>
    62.   <br>
    63.   <button id="btn">发起ajax请求</button>
    64. </body>
    65. </html>

  • 相关阅读:
    Linux开发——Linux 文件系统简介（四）
    C# 中，使用 LINQ 示例 备忘
    Java统计指定目录下文件夹数量和内部文件的数量并导出
    伦敦银延时一定存在吗？
    前端开发（上篇）
    charles + postern 抓包教程
    MySQL--创建，删除，查找，案例
    第 2 章 线性表 （ 具有实用意义的线性链表（带头结点）实现）
    使用Selenium-PO设计模式提高Web自动化测试效率
    2022阿里云金秋上云双十一轻量服务器2核2G 2核4G
  • 原文地址：https://blog.csdn.net/dengfengling999/article/details/125403243