SpringMVC（学习笔记）

01回顾MVC：

Model-View-Controller；降低视图与业务逻辑间的双向耦合；一种架构模式

Model：数据模型，提供要展示的数据，包含数据和行为，可以认为是领域模型或JavaBean组件，不过现在一般分开来看：Value Object（数据Dao）和服务层（行为Service）。模型提供了模型数据查询和模型数据的状态更新等功能

View：负责进行模型的展示，一般是我们见到的用户界面，客户想看到的东西。

Controller：接收用户请求，委托给模型进行处理，处理完毕后把返回的模型数据返回给视图，由视图负责展示，控制器做了个调度员工作

最典型MVC：JSP+servlet+javabean

Model1时代->Model2时代：

1.用户发请求；2.Servlet接收请求数据，并调用对应的业务逻辑方法；3.业务处理完毕，返回更新后的数据给servlet；4.servlet转向JSP，由JSP来渲染页面；5.响应给前端更新后的页面；

回顾Servlet

1.添加依赖


   
       junit
       junit
       4.13.1
   
   
       org.springframework
       spring-webmvc
       5.3.18
   
   
       javax.servlet
       servlet-api
       4.0.1
   
   
       javax.servlet.jsp
       jsp-api
       2.0
   
   
       javax.servlet
       jstl
       1.2

2.建立一个Moudle：添加web app支持

3.导入servlet和jsp依赖

    
        
            javax.servlet
            javax.servlet-api
            4.0.1
        
        
        
            javax.servlet
            jsp-api
            2.0

4.编写一个servelt类，用来处理用户请求

5.编写jsp，在WEB-INF目录下新建一个jsp文件夹

6.在web.xml中注册Servlet

7.配置Tomcat并启动测试

MVC框架要做哪些事情

将url映射到java类或java类的方法 .

封装用户提交的数据 .

处理请求--调用相关的业务处理--封装响应数据 .

将响应的数据进行渲染 . jsp / html 等表示层数据 .

02SpringMVC概述

Spring MVC是Spring Framework的一部分，是基于Java实现MVC的轻量级Web框架。

查看官方文档：https://docs.spring.io/spring/docs/5.2.0.RELEASE/spring-framework-reference/web.html#spring-web

SpringMVC执行原理：

中心控制器：

Spring的web框架围绕DispatcherServlet设计，其作用是将请求分发到不同处理器。

Spring MVC框架像许多其他MVC框架一样, 以请求为驱动 , 围绕一个中心Servlet分派请求及提供其他功能，DispatcherServlet是一个实际的Servlet (它继承自HttpServlet 基类)。

原理：当发起请求时被前置的控制器拦截到请求，根据请求参数生成代理请求，找到请求对应的实际控制器，控制器处理请求，创建数据模型，访问数据库，将模型响应给中心控制器，控制器使用模型与视图渲染视图结果，将结果返回给中心控制器，再将结果返回给请求者。

简要流程：

1.DispatcherServlet表示前置控制器，是整个SpringMVC的控制中心。用户发出请求，DispatcherServlet接受请求并拦截请求。假设url：http://localhost:8080/SpringMVC/hello

2.HandlerMapping为处理器映射。DispatcherServlet调用HandlerMapping，HandlerMapping根据请求url查找Handler

3.HandlerExecution表示具体的Handler，其主要作用是根据url查找控制器：hello

4.HandlerExecution将解析后的信息传递给DispatcherServlet，如解析控制器映射等

5.HandlerAdapter表示处理器适配器，其按照特定的规则去执行Handler

6.Handler让具体的Controller执行

7.Controller将具体的执行信息返回给HandlerAdapter，如ModelAndView

8.HandlerAdapter将视图逻辑名或模型传递给DispatcherServlet

9.DispatcherServlet调用视图解析器来解析HandlerAdapter传递的逻辑视图名

10.视图解析器将解析的逻辑视图名传给DispatcherServlet

11.DispatcherServlet根据视图解析器解析的视图结果，调用具体的视图

12.最终视图呈现给用户

02配置流程——配置版

1.新建Moudle，添加web支持

2.确定导入了SpringMVC依赖

3.配置web.xml，注册DispatcherServlet




   
   
       springmvc
       org.springframework.web.servlet.DispatcherServlet
       
       
           contextConfigLocation
           classpath:springmvc-servlet.xml
       
       
       1
   

   
   
   
       springmvc
       /

注意点：url-pattern：/和/*区别

4.编写SpringMVC配置文件，名称：[servletname]-servlet.xml

5.添加处理器映射器

6.添加处理器适配器

7.添加视图解析器

8.编写要操作业务的Controller，实现Controller接口或增加注解，返回一个ModelAndView，装数据，封视图

public class HelloController implements Controller {

   public ModelAndView handleRequest(HttpServletRequest request, HttpServletResponse response) throws Exception {
       //ModelAndView 模型和视图
       ModelAndView mv = new ModelAndView();

       //封装对象，放在ModelAndView中。Model
       mv.addObject("msg","HelloSpringMVC!");
       //封装要跳转的视图，放在ModelAndView中
       mv.setViewName("hello"); //: /WEB-INF/jsp/hello.jsp
       return mv;
  }
   
}

9.将自己的类交给SpringIOC容器，注册bean

10.写要跳转的jsp，显示ModelAndView存放的数据，以及正常页面

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


   Kuangshen


${msg}

11.配置Tomacat启动测试

03配置流程——注解版

1.新建一个Moudle，添加web支持

2.配置web.xml

3.添加SpringMVC配置文件：[Servletname]-servlet.xml

4.创建Controller

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

   //真实访问地址 : 项目名/HelloController/hello
   @RequestMapping("/hello")
   public String sayHello(Model model){
       //向模型中添加属性msg与值，可以在JSP页面中取出并渲染
       model.addAttribute("msg","hello,SpringMVC");
       //web-inf/jsp/hello.jsp
       return "hello";
  }
}

@Controller是为了让Spring IOC容器初始化时自动扫描到；

@RequestMapping是为了映射请求路径，这里因为类与方法上都有映射所以访问时应该是/HelloController/hello；

方法中声明Model类型的参数是为了把Action中的数据带到视图中；

方法返回的结果是视图的名称hello，加上配置文件中的前后缀变成WEB-INF/jsp/hello.jsp。

5.创建视图层

6.运行

注意点：

如果有两个请求指向一个视图，但页面上的结果是不一样的，可以看出视图是被复用的，而控制器与视图之间是弱耦合关系。

RestFul风格：

概念：一个资源定位及资源操作的风格。不是标准，也不是协议。

传统方式操作资源（post、get）：

http://127.0.0.1/item/queryItem.action?id=1 查询,GET

http://127.0.0.1/item/saveItem.action 新增,POST

http://127.0.0.1/item/updateItem.action 更新,POST

http://127.0.0.1/item/deleteItem.action?id=1 删除,GET或POST

使用RestFul操作资源：

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

步骤：

1.新建类RestFulController

2. 在SpringMVC中使用@PathVariable注解，让方法参数的值对应绑定到一个URI模板变量上

@Controller
public class RestFulController {

   //映射访问路径
   @RequestMapping("/commit/{p1}/{p2}")
   public String index(@PathVariable int p1, @PathVariable int p2, Model model){
       
       int result = p1+p2;
       //Spring MVC会自动实例化一个Model对象用于向视图中传值
       model.addAttribute("msg", "结果："+result);
       //返回视图位置
       return "test";
       
  }
   
}

注意点：

使用method设置post、get方式

@RequestMapping(value = "/hello",method = {RequestMethod.GET})

使用注解设置post、get方式

@GetMapping
@PostMapping
@PutMapping
@DeleteMapping
@PatchMapping

3.测试

04结果跳转方式

1.ModelAndView

设置ModelAndView对象，根据view名称和视图解析器跳到指定页面

public class ControllerTest1 implements Controller {

   public ModelAndView handleRequest(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse) throws Exception {
       //返回一个模型视图对象
       ModelAndView mv = new ModelAndView();
       mv.addObject("msg","ControllerTest1");
       mv.setViewName("test");
       return mv;
  }
}

2.Servlet API

通过设置Servlet API，不需要视图解析器

1.通过HttpServletResponse进行输出

2.通过HttpServletResponse进行重定向

3. 通过HttpServletResponse实现转发

@Controller
public class ResultGo {

   @RequestMapping("/result/t1")
   public void test1(HttpServletRequest req, HttpServletResponse rsp) throws IOException {
       rsp.getWriter().println("Hello,Spring BY servlet API");
  }

   @RequestMapping("/result/t2")
   public void test2(HttpServletRequest req, HttpServletResponse rsp) throws IOException {
       rsp.sendRedirect("/index.jsp");
  }

   @RequestMapping("/result/t3")
   public void test3(HttpServletRequest req, HttpServletResponse rsp) throws Exception {
       //转发
       req.setAttribute("msg","/result/t3");
       req.getRequestDispatcher("/WEB-INF/jsp/test.jsp").forward(req,rsp);
  }

}

3.SpringMVC

实现转发重定向，无需解析器：

@Controller
public class ResultSpringMVC {
   @RequestMapping("/rsm/t1")
   public String test1(){
       //转发
       return "/WEB-INF/jsp/test.jsp";
  }

   @RequestMapping("/rsm/t2")
   public String test2(){
       //转发二
       return "forward:/WEB-INF/jsp/test.jsp";
  }

   @RequestMapping("/rsm/t3")
   public String test3(){
       //重定向
       return "redirect:/index.jsp";
  }
}

实现转发重定向，需要解析器

@Controller
public class ResultSpringMVC2 {
   @RequestMapping("/rsm2/t1")
   public String test1(){
       //转发
       return "test";
  }

   @RequestMapping("/rsm2/t2")
   public String test2(){
       //重定向
       return "redirect:/index.jsp";
       //return "redirect:/hello"; //hello为另一个请求
  }

}

数据处理

处理提交数据

1.提交的域名城和处理方法的参数名一致

提交数据： /hello?name=ccc

@RequestMapping("/hello")
public String hello(String name){
   System.out.println(name);
   return "hello";
}

2. 提交的域名城和处理方法参数名不一致

提交数据： /hello?username=ccc

//@RequestParam("username") : username提交的域的名称 .
@RequestMapping("/hello")
public String hello(@RequestParam("username") String name){
   System.out.println(name);
   return "hello";
}

注意：一般前端需要的参数都要加上@RequestParam

3.提交的是一个对象（User：id/name/age）

提交数据： /user?id=1&name=ccc&age=22

@RequestMapping("/user")
public String user(User user){
   System.out.println(user);
   return "hello";
}

数据显示到前端

1.ModelAndView：在存储数据同时进行设置返回逻辑视图，进行控制展示层跳转

public class ControllerTest1 implements Controller {

   public ModelAndView handleRequest(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse) throws Exception {
       //返回一个模型视图对象
       ModelAndView mv = new ModelAndView();
       mv.addObject("msg","ControllerTest1");
       mv.setViewName("test");
       return mv;
  }
}

2.ModelMap：继承了LinkedMap，比Model功能多

@RequestMapping("/hello")
public String hello(@RequestParam("username") String name, ModelMap model){
   //封装要显示到视图中的数据
   //相当于req.setAttribute("name",name);
   model.addAttribute("name",name);
   System.out.println(name);
   return "hello";
}

3.Model：简洁版，只适合于储存数据

@RequestMapping("/ct2/hello")
public String hello(@RequestParam("username") String name, Model model){
   //封装要显示到视图中的数据
   //相当于req.setAttribute("name",name);
   model.addAttribute("msg",name);
   System.out.println(name);
   return "test";
}

乱码问题

法一：自己设置过滤器

package com.cyl.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 {
        Filter.super.init(filterConfig);
    }

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

        filterChain.doFilter(servletRequest,servletResponse);
    }

    @Override
    public void destroy() {
        Filter.super.destroy();
    }
}

    
        encoding
        com.cyl.filter.EncodingFilter
    
    
        encoding
        /*

法二：使用Spring的过滤器


        encoding
        org.springframework.web.filter.CharacterEncodingFilter
        
            encoding
            utf-8
        
    
    
        encoding
        /*

05JSON

JSON(JavaScript Object Notation, JS 对象标记) 是一种轻量级的数据交换格式，目前使用特别广泛。

采用完全独立于编程语言的文本格式来存储和表示数据。

简洁和清晰的层次结构使得 JSON 成为理想的数据交换语言。

易于人阅读和编写，同时也易于机器解析和生成，并有效地提升网络传输效率。

JSON和JavaScript对象互转：

var obj = JSON.parse('{"a": "Hello", "b": "World"}'); //结果是 {a: 'Hello', b: 'World'}

var json = JSON.stringify({a: 'Hello', b: 'World'}); //结果是 '{"a": "Hello", "b": "World"}'

JSON解析工具——Jackson

1.导包


   com.fasterxml.jackson.core
   jackson-databind
   2.9.8

2.配置web.xml、springmvc-servlet.xml

3.编写一个实体类，编写测试Controller

1）一个对象

@Controller
public class UserController {

   @RequestMapping("/json1")
   @ResponseBody
   public String json1() throws JsonProcessingException {
       //创建一个jackson的对象映射器，用来解析数据
       ObjectMapper mapper = new ObjectMapper();
       //创建一个对象
       User user = new User("秦疆1号", 3, "男");
       //将我们的对象解析成为json格式
       String str = mapper.writeValueAsString(user);
       //由于@ResponseBody注解，这里会将str转成json格式返回；十分方便
       return str;
  }

}

注意：解决乱码问题

在springmvc配置文件填上：

2）多个对象

3）时间，使用timeStamps形式，自定义时间格式

@RequestMapping("/json4")
public String json4() throws JsonProcessingException {

   ObjectMapper mapper = new ObjectMapper();

   //不使用时间戳的方式
   mapper.configure(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS, false);
   //自定义日期格式对象
   SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
   //指定日期格式
   mapper.setDateFormat(sdf);

   Date date = new Date();
   String str = mapper.writeValueAsString(date);

   return str;
}

优化：抽取工具类

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;
  }
}

@RequestMapping("/json5")
public String json5() throws JsonProcessingException {
   Date date = new Date();
   String json = JsonUtils.getJson(date);
   return json;
}

JSON解析工具——FastJson

阿里巴巴开发的一款专门用于Java开发的包，方便实现json对象与JavaBean对象的转换

1.添加依赖

        
            com.alibaba
            fastjson
            1.2.80

三个主要的类：

1）JSONObject代表json对象

2）JSONArray代表json对象数组

3）JSON代表JSONObject和JSONArray的转化

System.out.println("*******Java对象 转 JSON字符串*******");
String str1 = JSON.toJSONString(list);

System.out.println("n****** JSON字符串 转 Java对象*******");
User jp_user1=JSON.parseObject(str2,User.class);

System.out.println("n****** Java对象 转 JSON对象 ******");
JSONObject jsonObject1 = (JSONObject) JSON.toJSON(user2); 

System.out.println("n****** JSON对象 转 Java对象 ******");
User to_java_user = JSON.toJavaObject(jsonObject1, User.class);

SpringMVC（学习笔记）

Java相关栏目本月热门文章