• SpringMVC汇总


    什么是MVC？

    • MVC是模型(Model)、视图(View)、控制器(Controller)的简写，是一种软件设计规范。
    • 是将业务逻辑、数据、显示分离的方法来组织代码。
    • MVC主要作用是降低了视图与业务逻辑间的双向偶合。
    • MVC不是一种设计模式，MVC是一种架构模式。当然不同的MVC存在差异。

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

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

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

    最典型的MVC就是JSP + servlet + javabean的模式。

    Model1时代

    • 在web早期的开发中，通常采用的都是Model1。
    • Model1中，主要分为两层，视图层和模型层。

    Model1优点：架构简单，比较适合小型项目开发；

    Model1缺点：JSP职责不单一，职责过重，不便于维护；


    Model2时代

    Model2把一个项目分成三部分，包括视图、控制、模型。

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

    职责分析：

    Controller：控制器

    1. 取得表单数据
    2. 调用业务逻辑
    3. 转向指定的页面

    Model：模型

    1. 业务逻辑
    2. 保存数据的状态

    View：视图

    1. 显示页面

    Model2这样不仅提高的代码的复用率与项目的扩展性，且大大降低了项目的维护成本。Model 1模式的实现比较简单，适用于快速开发小规模项目，Model1中JSP页面身兼View和Controller两种角色，将控制逻辑和表现逻辑混杂在一起，从而导致代码的重用性非常低，增加了应用的扩展性和维护的难度。Model2消除了Model1的缺点。


    回顾Servlet

    1. 新建一个Maven工程当做父工程！pom依赖！

      <dependencies>
   <dependency>
       <groupId>junitgroupId>
       <artifactId>junitartifactId>
       <version>4.12version>
   dependency>
   <dependency>
       <groupId>org.springframeworkgroupId>
       <artifactId>spring-webmvcartifactId>
       <version>5.1.9.RELEASEversion>
   dependency>
   <dependency>
       <groupId>javax.servletgroupId>
       <artifactId>servlet-apiartifactId>
       <version>2.5version>
   dependency>
   <dependency>
       <groupId>javax.servlet.jspgroupId>
       <artifactId>jsp-apiartifactId>
       <version>2.2version>
   dependency>
   <dependency>
       <groupId>javax.servletgroupId>
       <artifactId>jstlartifactId>
       <version>1.2version>
   dependency>
dependencies>

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      • 11
      • 12
      • 13
      • 14
      • 15
      • 16
      • 17
      • 18
      • 19
      • 20
      • 21
      • 22
      • 23
      • 24
      • 25
      • 26
      • 27

    2. 建立一个Moudle：springmvc-01-servlet ， 添加Web app的支持！（选中module，点击鼠标右键，选择“Add Framework Support…”，再选择“Web Application”，确认即可）

    3. 编写一个Servlet类，用来处理用户的请求

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

//实现Servlet接口
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);//转发
//        resp.sendRedirect();//重定向
    }

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

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      • 11
      • 12
      • 13
      • 14
      • 15
      • 16
      • 17
      • 18
      • 19
      • 20
      • 21
      • 22
      • 23
      • 24
      • 25
      • 26
      • 27
      • 28
      • 29
      • 30

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

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


   Title


${msg}



      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9

    5. 在web.xml中注册Servlet

      
<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>helloservlet-name>
        <servlet-class>com.kuang.servlet.HelloServletservlet-class>
    servlet>
    <servlet-mapping>
        <servlet-name>helloservlet-name>
        <url-pattern>/hellourl-pattern>
    servlet-mapping>
    
web-app>

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      • 11
      • 12
      • 13
      • 14
      • 15
      • 16

    6. 配置Tomcat，并启动测试

    7. 测试

      • localhost:8080/hello?method=add

      • localhost:8080/hello?method=delete

    MVC框架要做哪些事情

    1. 将url映射到java类或java类的方法 .
    2. 封装用户提交的数据 .
    3. 处理请求–调用相关的业务处理–封装响应数据 .
    4. 将响应的数据进行渲染 . jsp / html 等表示层数据 .

    说明：

    常见的服务器端MVC框架有：Struts、Spring MVC、ASP.NET MVC、Zend Framework、JSF；常见前端MVC框架：vue、angularjs、react、backbone；由MVC演化出了另外一些模式如：MVP、MVVM 等等…



    什么是SpringMVC

    概述

    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 MVC的特点：

    1. 轻量级，简单易学
    2. 高效 , 基于请求响应的MVC框架
    3. 与Spring兼容性好，无缝结合
    4. 约定优于配置
    5. 功能强大：RESTful、数据验证、格式化、本地化、主题等
    6. 简洁灵活

    Spring的web框架围绕DispatcherServlet [ 调度Servlet ] 设计。

    DispatcherServlet的作用是将请求分发到不同的处理器。从Spring 2.5开始，使用Java 5或者以上版本的用户可以采用基于注解形式进行开发，十分简洁；

    正因为SpringMVC好 , 简单 , 便捷 , 易学 , 天生和Spring无缝集成(使用SpringIoC和Aop) , 使用约定优于配置 . 能够进行简单的junit测试 . 支持Restful风格 .异常处理 , 本地化 , 国际化 , 数据验证 , 类型转换 , 拦截器 等等…所以我们要学习 .

    最重要的一点还是用的人多 , 使用的公司多 .


    中心控制器

    Spring的web框架围绕DispatcherServlet设计。DispatcherServlet的作用是将请求分发到不同的处理器。从Spring 2.5开始，使用Java 5或者以上版本的用户可以采用基于注解的controller声明方式。

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

    SpringMVC的原理如下图所示：

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


    SpringMVC执行原理

    图为SpringMVC的一个较完整的流程图，实线表示SpringMVC框架提供的技术，不需要开发者实现，虚线表示需要开发者实现。

    简要分析执行流程

    1. DispatcherServlet表示前置控制器，是整个SpringMVC的控制中心。用户发出请求，DispatcherServlet接收请求并拦截请求。

      我们假设请求的url为 : http://localhost:8080/SpringMVC/hello

      如上url拆分成三部分：

      • http://localhost:8080服务器域名

      • SpringMVC部署在服务器上的web站点

      • hello表示控制器

      通过分析，如上url表示为：请求位于服务器localhost:8080上的SpringMVC站点的hello控制器。

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

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

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

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

    6. Handler让具体的Controller执行。

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

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

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

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

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

    12. 最终视图呈现给用户。

    在这里先听一遍原理，不理解没有关系，我们马上来写一个对应的代码实现大家就明白了，如果不明白，那就写10遍，没有笨人，只有懒人！



    创建springmvc程序

    控制器Controller

    • 控制器负责提供访问应用程序的行为，通常通过接口定义或注解定义两种方法实现。
    • 控制器负责解析用户的请求并将其转换为一个模型。
    • 在Spring MVC中一个控制器类可以包含多个方法
    • 在Spring MVC中，对于Controller的配置方式有很多种

    实现Controller接口

    Controller是一个接口，在org.springframework.web.servlet.mvc包下，接口中只有一个方法；

    //实现该接口的类获得控制器功能
public interface Controller {
   //处理请求且返回一个模型与视图对象
   ModelAndView handleRequest(HttpServletRequest var1, HttpServletResponsevar2) throws Exception;
}

    • 1
    • 2
    • 3
    • 4
    • 5

    案例：见下边的SpringMVC“配置版”例子。


    小结：

    • 实现接口Controller定义控制器是较老的办法
    • 缺点是：一个控制器中只有一个方法，如果要多个方法则需要定义多个Controller；定义的方式比较麻烦；

    使用注解@Controller

    • @Controller注解用于声明当前类是一个控制器。

    • @RequestMapping注解用于映射url到控制器类或一个特定的处理程序方法。可用于类或方法上。用于类上，表示类中的所有响应请求的方法都是以该地址作为父路径。

    案例：见下边的SpringMVC“注解版”例子。


    小结：注解方式是平时使用的最多的方式！



    配置版

    创建项目

    1、新建一个Moudle名为“springmvc-02-hellomvc”（普通maven项目） ， 添加web的支持！（选中module，点击鼠标右键，选择“Add Framework Support…”，再选择“Web Application”，确认即可）

    依赖

    2、确定导入了SpringMVC 的依赖！（我们在父工程中已经导入需要的依赖）

    <dependency>
    <groupId>org.springframeworkgroupId>
    <artifactId>spring-webmvcartifactId>
    <version>5.1.9.RELEASEversion>
dependency>

    • 1
    • 2
    • 3
    • 4
    • 5

    web.xml

    3、在web.xml文件中（Javaweb的配置文件） ， 配置DispatcherServlet。这个是SpringMVC的核心：请求分发器，前端控制器

    
<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>springmvcservlet-name>
       <servlet-class>org.springframework.web.servlet.DispatcherServletservlet-class>
       
     	 
       <init-param>
           <param-name>contextConfigLocationparam-name>
           <param-value>classpath:springmvc-servlet.xmlparam-value>
       init-param>
       
       <load-on-startup>1load-on-startup>
   servlet>

   
   
   
   <servlet-mapping>
       <servlet-name>springmvcservlet-name>
       <url-pattern>/url-pattern>
   servlet-mapping>

web-app>

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29

    / 和 /* 的区别：

    • < url-pattern > / 不会匹配到.jsp， 只针对我们编写的请求；即：.jsp 不会进入spring的 DispatcherServlet类 。
    • < url-pattern > /* 会匹配 *.jsp，会出现返回 jsp视图 时再次进入spring的DispatcherServlet 类，导致找不到对应的controller所以报404错。

    注意web.xml版本问题，要最新版！（当前项目使用的是4.0）

    • 注册DispatcherServlet
    • 关联SpringMVC的配置文件
    • 启动级别为1
    • 映射路径为 / 【不要用/*，会404】

    SpringMVC配置文件

    4、编写SpringMVC的配置文件！名称为springmvc-servlet.xml，放在resources文件夹下（名字可以任意起，但最好还是照着命名规范来好一点）

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

beans>

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7

    5、添加 处理器映射器（HandlerMapping）。处理器映射器，根据URL查找处理器（Controller）。URL对应处理器注册到Spring的IOC容器时设置的标识符（id、name）。

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

    • 1

    6、添加 处理器适配器（HandlerAdapter）。查找到处理器后交由处理器适配器处理。

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

    • 1

    7、添加 视图解析器（ViewResolver）。调用处理器Controller后返回的数据交由视图解析器处理。

    
<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver" id="InternalResourceViewResolver">
    
    <property name="prefix" value="/WEB-INF/jsp/"/>
    
    <property name="suffix" value=".jsp"/>
bean>

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7

    注意，这里的5、6、7步甚至都可以不配置，因为SpringMVC已经配置好了，这里只是为了更好的理解SpringMVC的执行原理才重复进行配置。（若不要第7步，则返回的视图名要填完整的路径。例如：/WEB-INF/jsp/hello.jsp）


    Controller

    8、编写Controller，要么实现Controller接口，要么增加注解；需要返回一个ModelAndView，封装数据和视图；

    我们要实现的业务是：当用户访问路径“/hello"后返回字符串“HelloSpringMVC”（模型-数据）和页面“hello.jsp“（视图-页面），字符串将被渲染到hello.jsp中，然后将该页面返回给用户。（ModelAndView实现页面转发）

    package com.kuang.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 {

    public ModelAndView handleRequest(HttpServletRequest request, HttpServletResponse response) throws Exception {

        ModelAndView mv = new ModelAndView();//ModelAndView 模型和视图

        //业务代码：
        String msg = "HelloSpringMVC!";
        mv.addObject("msg",msg);//封装数据，放在ModelAndView中。Model
        //视图跳转：
        mv.setViewName("hello");//封装要跳转的视图，放在ModelAndView中
        //SpringMVC的配置文件中 配置了前缀和后缀，所以这里只需要写视图（页面）名字即可。最终会被恢复成/WEB-INF/jsp/hello.jsp

        return mv;
    }

}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24

    9、将自己的类交给SpringIOC容器，在SpringMVC的配置文件中注册bean，标识符（name/id）对应请求路径，class对应处理请求的类（也可以理解为配置Controller的请求路径）。

    
<bean id="/hello" class="com.kuang.controller.HelloController"/>

    • 1
    • 2

    页面

    10、写要跳转的jsp页面，显示ModelandView存放的数据，以及我们的正常页面；文件名为hello，对应上Controller中写的视图名。

    在WEB-INF/jsp目录中创建hello.jsp ， 视图可以直接取出并展示从Controller带回的信息；可以通过EL表示取出Model中存放的值，或者对象；

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


    Kuangshen


${msg}



    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9

    测试

    11、配置Tomcat 启动测试！这里没有配置项目发布名，就是一个 / ，所以请求不用加项目名。


    小结：看到这里估计大部分同学都能理解其中的原理了，但是我们实际开发才不会这么写，不然就疯了，还学这个玩意干嘛！我们来看个注解版实现，这才是SpringMVC的精髓。


    注解版

    创建项目

    1、新建一个Moudle，springmvc-03-annotation 。添加web支持！（由于Maven可能存在资源过滤的问题，若有遇到资源无法导出可点这里查看解决方法。）

    依赖

    2、在pom.xml文件引入相关的依赖。（我们在父工程中已经导入需要的依赖）


    web.xml

    3、配置web.xml，同上。


    SpringMVC配置文件

    4、添加Spring MVC配置文件，注意与上边的区别。

    在resources目录下添加springmvc-servlet.xml配置文件，配置的形式与Spring容器配置基本类似，为了支持基于注解的IOC，设置了自动扫描包的功能（将bean注册到Spring容器），具体配置信息如下：

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

  
  <context:component-scan base-package="com.kuang.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>

beans>

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • context:component-scan - 让IOC的注解生效（自动扫描包将bean注册到Spring容器）
    • mvc:default-servlet-handler - 静态资源过滤 ：HTML . JS . CSS . 图片 ， 视频 …（可省略）
    • mvc:annotation-driven - MVC的注解驱动（可省略）
    • ViewResolver - 配置视图解析器（可省略）
      • 在视图解析器中我们把所有的视图都存放在/WEB-INF/目录下，这样可以保证视图安全，因为这个目录下的文件，客户端不能直接访问。

    Controller

    5、创建Controller，注意与上边的区别。

    编写一个Java控制类：com.kuang.controller.HelloController , 注意编码规范

    package com.kuang.controller;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;

@Controller//声明当前类为一个控制器（本质是一个@Component）
// 使用@Controller注解的类中的所有方法，如果返回值是String，并且有具体页面可以跳转，那么就会被视图解析器解析（将model中的数据渲染到页面中）
@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";
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 点这里复习注解。
    • @Controller是为了让Spring IOC容器初始化时自动扫描到。（@Controller本质是一个@Component，通过该注解可将bean注册到Spring容器中）
    • @RequestMapping是为了映射请求路径，这里因为类与方法上都有映射所以访问时应该是/HelloController/hello；
    • 方法中声明Model类型的参数是为了把Action中的数据带到视图中；
    • 方法返回的结果是视图的名称hello，加上配置文件中的前后缀变成WEB-INF/jsp/hello.jsp。（SpringMVC实现页面转发）
    • 如果不想使用视图解析器，只是想返回json类型的数据（返回字符串）。@Controller改为 @RestController ，去掉参数model即可。

    页面

    6、创建视图层，同上。


    测试

    7、配置Tomcat运行

    配置Tomcat ，开启服务器，访问对应的请求路径！


    小结

    实现步骤其实非常的简单：

    1. 新建一个web项目
    2. 导入相关jar包
    3. 编写web.xml , 注册DispatcherServlet
    4. 编写springmvc配置文件
    5. 接下来就是去创建对应的控制类 , controller
    6. 最后完善前端视图和controller之间的对应
    7. 测试运行调试.

    使用springMVC必须配置的三大件：

    处理器映射器、处理器适配器、视图解析器

    通常，我们只需要手动配置视图解析器，而处理器映射器和处理器适配器只需要开启注解驱动即可，而省去了大段的xml配置

    再来回顾下原理吧~


    问题

    可能遇到的问题：访问出现404，排查步骤：

    1. 查看控制台输出，看一下是不是缺少了什么jar包。
    2. 如果jar包存在，显示无法输出（依赖jar包没有添加到打包后的项目文件中），就在IDEA的项目发布中，添加lib依赖！
      1. 点击工具栏的“File” --> Project Structure（项目结构） --> Artifacts（可理解为项目打包后的文件，对其进行设置）
      2. 选择我们的项目 --> 打开""下的“WEB-INF”文件夹，若其中没有“lib“文件夹则新建一个并点击”+“号将“Library Files“中的所有jar包添加进去
    3. 重启Tomcat 即可解决！


    RestFul风格

    概念

    Restful就是一个资源定位及资源操作的风格。不是标准也不是协议，只是一种风格。基于这个风格设计的软件可以更简洁，更有层次，更易于实现缓存等机制。

    功能

    资源：互联网所有的事物都可以被抽象为资源

    资源操作：使用POST、DELETE、PUT、GET，使用不同方法对资源进行操作。

    分别对应 添加、 删除、修改、查询。

    传统方式操作资源 ：通过不同的参数来实现不同的效果！方法单一，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

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7

    使用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
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7

    使用method属性指定请求类型

    用于约束请求的类型，可以收窄请求范围。指定请求谓词的类型如GET, POST, HEAD, OPTIONS, PUT, PATCH, DELETE, TRACE等。


    测试

    1. 在新建一个类 RestFulController

      @Controller
public class RestFulController {
}

      • 1
      • 2
      • 3

    2. 两种风格对比

      在Spring MVC中可以使用 @PathVariable 注解，让方法参数绑定URI上的路径。

      @Controller
public class RestFulController {
    //RestFul风格
    @RequestMapping("/commit/{p1}/{p2}")
    public String test(@PathVariable int p1, @PathVariable int p2, Model model){
        int result = p1+p2;
        //Spring MVC会自动实例化一个Model对象用于向视图中传值
        model.addAttribute("msg", p1+"+"+p2+"="+result);
        //返回视图位置
        return "hello";
    }
    //传统方式
    @RequestMapping("/commit")
    public String test0(int p1, int p2, Model model){
        int result = p1+p2;
        //Spring MVC会自动实例化一个Model对象用于向视图中传值
        model.addAttribute("msg", p1+"+"+p2+"="+result);
        //返回视图位置
        return "hello";
    }
    //扩展：一样的请求路径，不同的请求方式（get、post、put...），实现不同效果（对应不同方法）
  	@RequestMapping(path = "/hello",method = RequestMethod.GET)//GetMapping
    public String test1(){
        return "hello";
    }
    @PostMapping(path = "/hello")
    public String test2(){
        return "hello";
    }
    @PutMapping(path = "/hello")
    public String test3(){
        return "hello";
    }
    @PatchMapping(path = "/hello")
    public String test4(){
        return "hello";
    }
}

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      • 11
      • 12
      • 13
      • 14
      • 15
      • 16
      • 17
      • 18
      • 19
      • 20
      • 21
      • 22
      • 23
      • 24
      • 25
      • 26
      • 27
      • 28
      • 29
      • 30
      • 31
      • 32
      • 33
      • 34
      • 35
      • 36
      • 37
      • 38

    3. 测试

      RestFul风格的请求方式，要传递的参数值直接作为请求路径的一部分。

      传统方式（get请求），要将参数拼接在请求路径后。

    思考：使用路径变量的好处？

    • 使路径变得更加简洁。

    • 获得参数更加方便，框架会自动进行类型转换。

    • 通过路径变量的类型可以约束访问参数，如果类型不一样，则访问不到对应的请求方法，如这里访问是的路径是/commit/1/“1”，则路径与方法不匹配，而不会是参数转换失败。

    小结

    Spring MVC的 @RequestMapping 注解能够处理 HTTP 请求的方法, 比如 GET, PUT, POST, DELETE 以及 PATCH。

    所有的地址栏请求默认都会是 HTTP GET 类型的。

    方法级别的注解变体有如下几个：组合注解

    @GetMapping
@PostMapping
@PutMapping
@DeleteMapping
@PatchMapping

    • 1
    • 2
    • 3
    • 4
    • 5

    @GetMapping 是一个组合注解，平时使用的会比较多！

    它所扮演的是 @RequestMapping(method =RequestMethod.GET) 的一个快捷方式。


    扩展：小黄鸭调试法

    场景一：我们都有过向别人（甚至可能向完全不会编程的人）提问及解释编程问题的经历，但是很多时候就在我们解释的过程中自己却想到了问题的解决方案，然后对方却一脸茫然。

    场景二：你的同行跑来问你一个问题，但是当他自己把问题说完，或说到一半的时候就想出答案走了，留下一脸茫然的你。

    其实上面两种场景现象就是所谓的小黄鸭调试法（Rubber Duck Debuging），又称橡皮鸭调试法，它是我们软件工程中最常使用调试方法之一。

    此概念据说来自《程序员修炼之道》书中的一个故事，传说程序大师随身携带一只小黄鸭，在调试代码的时候会在桌上放上这只小黄鸭，然后详细地向鸭子解释每行代码，然后很快就将问题定位修复了。



    数据处理及跳转

    结果跳转方式

    ModelAndView

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

    页面 : {视图解析器前缀} + viewName +{视图解析器后缀}

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

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8

    对应的controller类。（前边的SpringMVC“配置版”例子中就是使用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;
  }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10

    ServletAPI

    通过设置ServletAPI , 不需要视图解析器。

    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);//转发
  }

}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21

    SpringMVC

    通过SpringMVC来实现转发和重定向 - 无需视图解析器；

    测试前，需要将视图解析器注释掉

    @Controller
public class ResultSpringMVC {
   @RequestMapping("/rsm/t1")
   public String test1(){
       //转发
       return "/index.jsp";//页面的路径不要写错
  }

   @RequestMapping("/rsm/t2")
   public String test2(){
       //转发二
       return "forward:/index.jsp";//加“forward:”前缀（页面的路径不要写错）
  }

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

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20

    通过SpringMVC来实现转发和重定向 - 有视图解析器；

    重定向 , 不需要视图解析器 , 本质就是重新请求一个新地方嘛 , 所以注意路径问题。

    可以重定向到另外一个请求实现。（前边的SpringMVC“注解版”例子中就是使用SpringMVC实现转发）

    @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.do"; //hello.do为另一个请求/
  }

}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16

    数据处理

    处理提交数据

    1、提交的参数名称和处理方法的形参名称一致

    提交数据 : http://localhost:8080/hello?name=kuangshen

    处理方法 :

    @RequestMapping("/hello")
public String hello(String name){//即使名称一致，也建议使用注解@RequestParam，使用方法见下边
   System.out.println(name);
   return "hello";
}

    • 1
    • 2
    • 3
    • 4
    • 5

    后台输出 : kuangshen

    2、提交的参数名称和处理方法的形参名称不一致

    提交数据 : http://localhost:8080/hello?username=kuangshen

    处理方法 :

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

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6

    后台输出 : kuangshen

    3、提交的是一个对象

    要求提交的各个参数名和对象的属性名一致 , 形参使用对象即可

    1、实体类

    public class User {
   private int id;
   private String name;
   private int age;
   //构造
   //get/set
   //tostring()
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8

    2、提交数据 : http://localhost:8080/mvc04/user?name=kuangshen&id=1&age=15

    3、处理方法 :

    @RequestMapping("/user")
public String user(User user){//形参使用对象
   System.out.println(user);
   return "hello";
}

    • 1
    • 2
    • 3
    • 4
    • 5

    后台输出 : User { id=1, name=‘kuangshen’, age=15 }

    说明：如果使用对象的话，前端传递的参数名和对象属性名必须一致，否则就是null。


    数据显示到前端

    第一种 : 通过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;
  }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10

    第二种 : 通过ModelMap

    ModelMap

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

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8

    第三种 : 通过Model

    Model（前边的SpringMVC“注解版”例子中就是使用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";
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    对比

    对于新手而言使用区别就是：

    Model 只有寥寥几个方法只适合用于储存数据，简化了新手对于Model对象的操作和理解；

ModelMap 继承了 LinkedMap ，除了实现了自身的一些方法，同样的继承 LinkedMap 的方法和特性；

ModelAndView 可以在储存数据的同时，可以进行设置返回的逻辑视图，进行控制展示层的跳转。

    • 1
    • 2
    • 3
    • 4
    • 5

    当然以后开发考虑的更多的是性能和优化，就不能单单仅限于此的了解。

    请使用80%的时间打好扎实的基础，剩下18%的时间研究框架，2%的时间去学点英文，框架的官方文档永远是最好的教程。


    乱码问题

    测试步骤：

    1、我们可以在首页编写一个提交的表单

    <form action="/e/t" method="post">
 <input type="text" name="name">
 <input type="submit">
form>

    • 1
    • 2
    • 3
    • 4

    2、后台编写对应的处理类

    @Controller
public class Encoding {
   @RequestMapping("/e/t")
   public String test(Model model,String name){
       model.addAttribute("msg",name); //获取表单提交的值
       return "test"; //跳转到test页面显示输入的值
  }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8

    3、输入中文测试，发现乱码

    不得不说，乱码问题是在我们开发中十分常见的问题，也是让我们程序猿比较头大的问题！


    解决方法

    以前遇到乱码问题可以自己写过滤器解决 , 但是SpringMVC给我们提供了一个过滤器 , 我们可以直接使用，在web.xml中进行如下配置：

    
<filter>
   <filter-name>encodingfilter-name>
   <filter-class>org.springframework.web.filter.CharacterEncodingFilterfilter-class>
   <init-param>
       <param-name>encodingparam-name>
       <param-value>utf-8param-value>
   init-param>
filter>
<filter-mapping>
   <filter-name>encodingfilter-name>
   <url-pattern>/*url-pattern>
filter-mapping>

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13

    拓展

    如果还是出现乱码的情况，可以进行如下配置。

    方法1：修改tomcat配置文件 ：设置编码！（conf文件夹下的server.xml文件）

    
<Connector URIEncoding="utf-8" port="8080" protocol="HTTP/1.1"
          connectionTimeout="20000"
          redirectPort="8443" />

    • 1
    • 2
    • 3
    • 4

    方法2：自定义过滤器（网上大神写的）。在web.xml中配置这个过滤器即可！

    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, FilterChainchain) 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;
  }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71
    • 72
    • 73
    • 74
    • 75
    • 76
    • 77
    • 78
    • 79
    • 80
    • 81
    • 82
    • 83
    • 84
    • 85
    • 86
    • 87
    • 88
    • 89
    • 90
    • 91
    • 92
    • 93
    • 94
    • 95
    • 96
    • 97
    • 98
    • 99
    • 100
    • 101
    • 102
    • 103
    • 104
    • 105
    • 106
    • 107
    • 108

    JSON交互处理

    什么是JSON？

    • JSON(JavaScript Object Notation, JS 对象标记) 是一种轻量级的数据交换格式，目前使用特别广泛。
    • 采用完全独立于编程语言的文本格式来存储和表示数据。
    • 简洁和清晰的层次结构使得 JSON 成为理想的数据交换语言。
    • 易于人阅读和编写，同时也易于机器解析和生成，并有效地提升网络传输效率。

    在 JavaScript 语言中，一切都是对象。因此，任何JavaScript 支持的类型都可以通过 JSON 来表示，例如字符串、数字、对象、数组等。看看他的要求和语法格式：

    • 对象表示为键值对，数据由逗号分隔
    • 花括号保存对象
    • 方括号保存数组

    JSON 键值对是用来保存 JavaScript 对象的一种方式，和 JavaScript 对象的写法也大同小异，键/值对组合中的键名写在前面并用双引号 “” 包裹，使用冒号 : 分隔，然后紧接着值：

    {"name": "QinJiang"}
{"age": "3"}
{"sex": "男"}

    • 1
    • 2
    • 3

    很多人搞不清楚 JSON 和 JavaScript 对象的关系，甚至连谁是谁都不清楚。其实，可以这么理解：

    JSON 是 JavaScript 对象的字符串表示法，它使用文本表示一个 JS 对象的信息，本质是一个字符串。

    var obj = {a: 'Hello', b: 'World'}; //这是一个对象，注意键名也是可以使用引号包裹的
var json = '{"a": "Hello", "b": "World"}'; //这是一个 JSON 字符串，本质是一个字符串

    • 1
    • 2

    JSON字符串和JS对象互转

    要实现从JSON字符串转换为JavaScript 对象，使用 JSON.==parse()==方法：

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

    • 1
    • 2

    要实现从JavaScript 对象转换为JSON字符串，使用 JSON.stringify() 方法：

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

    • 1
    • 2

    代码测试

    1、新建一个module ，springmvc-05-json ， 添加web的支持

    2、在web目录下新建一个 json-1.html ， 编写测试内容

    <!DOCTYPE html>
<html lang="en">
<head>
   <meta charset="UTF-8">
   <title>JSON_秦疆</title>
</head>
<body>

<script type="text/javascript">
   //编写一个js的对象
   var user = {
       name:"秦疆",
       age:3,
       sex:"男"
  };
   //将js对象转换成json字符串
   var str = JSON.stringify(user);
   console.log(str);
   
   //将json字符串转换为js对象
   var user2 = JSON.parse(str);
   console.log(user2.age,user2.name,user2.sex);

</script>

</body>
</html>

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27

    3、在IDEA中使用浏览器打开，查看控制台输出！


    返回JSON

    Jackson应该是目前比较好的json解析工具了。当然工具不止这一个，比如还有阿里巴巴的 fastjson 等等。

    Jackson

    我们这里使用Jackson，使用它需要导入它的jar包；

    
<dependency>
   <groupId>com.fasterxml.jackson.coregroupId>
   <artifactId>jackson-databindartifactId>
   <version>2.9.8version>
dependency>

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6

    web.xml的配置：

    
<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>SpringMVCservlet-name>
       <servlet-class>org.springframework.web.servlet.DispatcherServletservlet-class>
       
       <init-param>
           <param-name>contextConfigLocationparam-name>
           <param-value>classpath:springmvc-servlet.xmlparam-value>
       init-param>
       
       <load-on-startup>1load-on-startup>
   servlet>

   
   <servlet-mapping>
       <servlet-name>SpringMVCservlet-name>
       <url-pattern>/url-pattern>
   servlet-mapping>

   <filter>
       <filter-name>encodingfilter-name>
       <filter-class>org.springframework.web.filter.CharacterEncodingFilterfilter-class>
       <init-param>
           <param-name>encodingparam-name>
           <param-value>utf-8param-value>
       init-param>
   filter>
   <filter-mapping>
       <filter-name>encodingfilter-name>
       <url-pattern>/*url-pattern>
   filter-mapping>

web-app>

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39

    SpringMVC配置：

    springmvc-servlet.xml

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

   
   <context:component-scan base-package="com.kuang.controller"/>

   
   
       
       <property name="prefix" value="/WEB-INF/jsp/" />
       
       <property name="suffix" value=".jsp" />
   bean>

beans>

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25

    我们随便编写一个User的实体类，然后我们去编写我们的测试Controller；

    package com.kuang.pojo;

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

//需要导入lombok
@Data
@AllArgsConstructor
@NoArgsConstructor
public class User {

   private String name;
   private int age;
   private String sex;
   
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17

    这里我们需要两个新东西，一个是@ResponseBody，一个是ObjectMapper对象，我们看下具体的用法。

    • @ResponseBody的作用其实是将java对象转为json格式的数据并返回
      • @ResponseBody注解的作用是将controller的方法返回的对象通过适当的转换器转换为指定的格式之后，写入到response对象的body区，通常用来返回JSON数据或者是XML数据。
      • 注意：在使用此注解之后不会再走视图处理器，而是直接将数据写入到输入流中，他的效果等同于通过response对象输出指定格式的数据。
      • @ResponseBody是作用在方法上的，@ResponseBody 表示该方法的返回结果直接写入 HTTP response body 中，一般在异步获取数据时使用【也就是AJAX】。
      • 更多介绍，点这里。
    • Object Mapper，Jackson对象映射器，可以把JSON解析为用户自定义类对象, 或者解析为JSON内置的树模型的对象（可以实现Java对象与JSON字符串的相互转换）
      • ObjectMapper可以从字符串、流或文件解析JSON，并创建Java对象或对象图来表示已解析的JSON。将JSON解析为Java对象也称为从JSON反序列化Java对象。
      • ObjectMapper也可以从Java对象创建JSON。 从Java对象生成JSON的过程也被称为序列化Java对象到JSON。
      • 更多介绍，点这里。

    编写一个Controller；

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

}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17

    配置Tomcat ， 启动测试一下！

    http://localhost:8080/json1

    发现出现了乱码问题，我们需要设置一下他的编码格式为utf-8，以及它返回的类型。（返回的json数据出现乱码，前边配置的过滤器也没有无法解决）

    通过@RequestMaping的produces属性来实现，修改代码如下：（可以在SpringMVC配置文件中进行统一配置）

    //produces:指定响应体返回类型和编码
@RequestMapping(value = "/json1",produces = "application/json;charset=utf-8")

    • 1
    • 2

    再次测试， http://localhost:8080/json1 ， 乱码问题OK！

    在这里插入图片描述

    【注意：使用json记得处理乱码问题】


    拓展

    前边jackson演示了将普通java对象转化为json字符串返回到前端，下边演示返回其他类型的数据。

    返回集合

    增加一个新的方法

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

   //创建一个jackson的对象映射器，用来解析数据
   ObjectMapper mapper = new ObjectMapper();
   //创建一个对象
   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);

   //将我们的对象解析成为json格式
   String str = mapper.writeValueAsString(list);
   return str;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20

    运行结果 : 十分完美，没有任何问题！（ArrayList集合被转化为一个数组）

    返回时间对象

    增加一个新的方法

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

   ObjectMapper mapper = new ObjectMapper();

   //创建时间一个对象，java.util.Date
   Date date = new Date();
   //将我们的对象解析成为json格式
   String str = mapper.writeValueAsString(date);
   return str;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11

    运行结果 :

    • 默认日期格式会变成一个数字，是1970年1月1日到当前日期的毫秒数！
    • Jackson默认是会把时间转成timestamps形式（时间戳）

    解决方案：取消timestamps形式 ， 自定义时间格式

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

   ObjectMapper mapper = new ObjectMapper();//Jackson工具

   //不使用时间戳的方式
   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;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17

    运行结果 : 成功的输出了时间！


    抽取为工具类

    如果要经常使用的话，这样是比较麻烦的，我们可以将这些代码封装到一个工具类中

    package com.kuang.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);//object，任何要转换的数据
      } catch (JsonProcessingException e) {
           e.printStackTrace();
      }
       return null;
  }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28

    我们使用工具类，代码就更加简洁了！

    @RequestMapping("/json5")
public String json5() throws JsonProcessingException {
   Date date = new Date();
   String json = JsonUtils.getJson(date);//只需要提供要转换的数据即可，其他操作都封装在类工具类中
   return json;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6

    Fastjson

    更多详细介绍，见Fastjson 简明教程。

    fastjson.jar是阿里开发的一款专门用于Java开发的包，可以方便的实现json对象与JavaBean对象的转换，实现JavaBean对象与json字符串的转换，实现json对象与json字符串的转换。实现json的转换方法很多，最后的实现结果都是一样的。

    fastjson的pom依赖！

    <dependency>
   <groupId>com.alibabagroupId>
   <artifactId>fastjsonartifactId>
   <version>1.2.60version>
dependency>


<dependency>
    <groupId>com.alibabagroupId>
    <artifactId>fastjsonartifactId>
    <version>2.0.2version>
dependency>

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12

    2022-5，fastjson被曝出存在“反序列化漏洞”。受影响范围小于等于1.2.80，修复版本为1.2.83或者使用2.x版本。


    三个主要的类
    JSONObject

    JSONObject代表json对

    • JSONObject实现了Map接口, 猜想 JSONObject底层操作是由Map实现的。
    • JSONObject对应json对象，通过各种形式的get()方法可以获取json对象中的数据，也可利用诸如size()，isEmpty()等方法获取"键：值"对的个数和判断是否为空。其本质是通过实现Map接口并调用接口中的方法完成的。
    JSONArray

    JSONArray代表json对象数组

    • 内部是有List接口中的方法来完成操作的。
    JSON

    JSON代表JSONObject和JSONArray的转化

    • JSON类源码分析与使用
    • 仔细观察这些方法，主要是实现json对象，json对象数组，javabean对象，json字符串之间的相互转化。

    代码测试，我们新建一个FastJsonDemo类：

    package com.kuang.controller;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.kuang.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);
  }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39

    这种工具类，我们只需要掌握使用就好了，在使用的时候在根据具体的业务去找对应的实现。和以前的commons-io那种工具包一样，拿来用就好了！


    解析JSON

    Gson

    Google Gson是一个简单的基于Java的库，用于将Java对象序列化为JSON，也可以把JSON转换为Java对象。与上边的Jackson、Fastjson相似。更多详细介绍，见Github。

    pom依赖：

    <dependency>
  <groupId>com.google.code.gsongroupId>
  <artifactId>gsonartifactId>
  <version>2.9.0version>
dependency>

    • 1
    • 2
    • 3
    • 4
    • 5
    案例

    JSON对象转换（解析）为Java对象。

    对象转换

    java实体类：

    package com.jxstar.store;
public class RepoBean {
    String store_house__house_code;
    String store_house__house_desc;
    String store_house__house_id;
    String store_house__house_name;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7

    转换：

    String repo = req.getRequestValue("repo");//获取json字符串
//创建gson
Gson gson = new GsonBuilder().create();
//将获取到的json数据 填充到 实体类RepoBean中
RepoBean repoBean = gson.fromJson(repo, RepoBean.class);

    • 1
    • 2
    • 3
    • 4
    • 5
    数组转换

    java实体类：

    package com.jxstar.store;
public class MatBean {//物资
    String count;//物资数量
    MatData data;//物资信息
}


package com.jxstar.store;
public class MatData {//物资信息
    String store_mat__mat_code;
    String store_mat__mat_desc;
    String store_mat__mat_id;
    String store_mat__mat_name;
    String store_mat__mat_price;
    String store_mat__mat_size;
    String store_mat__mat_unit;
    String store_mat__type_code;
    String store_mat__type_id;
    String store_mat__type_name;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20

    转换和应用：

    String dataList = req.getRequestValue("dataList");//获取json字符串
//创建gson
Gson gson = new GsonBuilder().create();
//创建jsonArray（使用获取到的json数据）
JsonArray jsonArray = new JsonParser().parse(dataList).getAsJsonArray();

//遍历数组
for (int i2 = 0; i2 < jsonArray.size(); i2++) {
  JsonElement jsonElement = jsonArray.get(i2);
  MatBean matBean = gson.fromJson(jsonElement, MatBean.class);//物资
  MatData data = matBean.data;//data为物资信息，count为物资数量
  String count = matBean.count;
  。。。
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14

    问题

    乱码优化

    在@RequestMapping中配置比较麻烦，如果项目中有许多请求则每一个都要添加，可以通过Spring配置统一指定，这样就不用每次都去处理了！

    我们可以在springmvc的配置文件上添加一段消息StringHttpMessageConverter转换配置！

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

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16

    @ResponseBody优化

    在类上直接使用 @RestController ，这样子，里面所有的方法都只会返回 json 字符串了，不用再每一个都添加@ResponseBody！我们在前后端分离开发中，一般都使用@RestController ，十分便捷！

    @RestController
public class UserController {

   //produces:指定响应体返回类型和编码
   @RequestMapping(value = "/json1")
   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;
  }

}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17

    启动tomcat测试，结果都正常输出！



    整合SSM

    环境要求

    环境：

    • IDEA
    • MySQL 5.7.19
    • Tomcat 9
    • Maven 3.6

    要求：

    • 需要熟练掌握MySQL数据库，Spring，JavaWeb及MyBatis知识，简单的前端知识；

    数据库环境

    创建一个存放书籍数据的数据库表

    CREATE DATABASE `ssmbuild`;

USE `ssmbuild`;

DROP TABLE IF EXISTS `books`;

CREATE TABLE `books` (
`bookID` INT(10) NOT NULL AUTO_INCREMENT COMMENT '书id',
`bookName` VARCHAR(100) NOT NULL COMMENT '书名',
`bookCounts` INT(11) NOT NULL COMMENT '数量',
`detail` VARCHAR(200) NOT NULL COMMENT '描述',
KEY `bookID` (`bookID`)
) ENGINE=INNODB DEFAULT CHARSET=utf8;

INSERT  INTO `books`(`bookID`,`bookName`,`bookCounts`,`detail`)VALUES 
(1,'Java',1,'从入门到放弃'),
(2,'MySQL',10,'从删库到跑路'),
(3,'Linux',5,'从进门到进牢');

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18

    基本环境搭建

    1、新建Maven项目！ssmbuild ， 添加web的支持

    2、导入相关的pom依赖！

    <dependencies>
   
   <dependency>
       <groupId>junitgroupId>
       <artifactId>junitartifactId>
       <version>4.12version>
   dependency>
   
   <dependency>
       <groupId>mysqlgroupId>
       <artifactId>mysql-connector-javaartifactId>
       <version>5.1.47version>
   dependency>
   
   <dependency>
       <groupId>com.mchangegroupId>
       <artifactId>c3p0artifactId>
       <version>0.9.5.5version>
   dependency>

   
   <dependency>
       <groupId>javax.servletgroupId>
       <artifactId>servlet-apiartifactId>
       <version>2.5version>
   dependency>
   <dependency>
       <groupId>javax.servlet.jspgroupId>
       <artifactId>jsp-apiartifactId>
       <version>2.2version>
   dependency>
   <dependency>
       <groupId>javax.servletgroupId>
       <artifactId>jstlartifactId>
       <version>1.2version>
   dependency>

   
   <dependency>
       <groupId>org.mybatisgroupId>
       <artifactId>mybatisartifactId>
       <version>3.5.2version>
   dependency>
   <dependency>
       <groupId>org.mybatisgroupId>
       <artifactId>mybatis-springartifactId>
       <version>2.0.4version>
   dependency>

   
   <dependency>
       <groupId>org.springframeworkgroupId>
       <artifactId>spring-webmvcartifactId>
       <version>5.1.9.RELEASEversion>
   dependency>
   <dependency>
       <groupId>org.springframeworkgroupId>
       <artifactId>spring-jdbcartifactId>
       <version>5.1.9.RELEASEversion>
   dependency>
   
   <dependency>
       <groupId>org.projectlombokgroupId>
       <artifactId>lombokartifactId>
       <version>1.18.16version>
       <scope>providedscope>
   dependency>
   
   <dependency>
       <groupId>org.aspectjgroupId>
       <artifactId>aspectjweaverartifactId>
       <version>1.9.4version>
   dependency>
   
   <dependency>
       <groupId>com.fasterxml.jackson.coregroupId>
       <artifactId>jackson-databindartifactId>
       <version>2.9.8version>
   dependency>
dependencies>

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71
    • 72
    • 73
    • 74
    • 75
    • 76
    • 77
    • 78
    • 79
    • 80

    3、Maven资源过滤设置

    <build>
   <resources>
       <resource>
           <directory>src/main/javadirectory>
           <includes>
               <include>**/*.propertiesinclude>
               <include>**/*.xmlinclude>
           includes>
           <filtering>falsefiltering>
       resource>
       <resource>
           <directory>src/main/resourcesdirectory>
           <includes>
               <include>**/*.propertiesinclude>
               <include>**/*.xmlinclude>
           includes>
           <filtering>falsefiltering>
       resource>
   resources>
build>

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20

    4、建立基本结构和配置框架！

    • com.kuang.pojo

    • com.kuang.dao

    • com.kuang.service

    • com.kuang.controller

    • mybatis-config.xml（MyBatis配置文件）

      
DOCTYPE configuration
       PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
       "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>

configuration>

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • database.properties（数据库配置文件）

    • applicationContext.xml（Spring配置文件 – 主）

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

beans>

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • spring-dao.xml（Spring整合MyBatis）
      • spring-service.xml（Spring整合service层）

    • spring-mvc.xml（SpringMVC配置文件）


    Mybatis层编写

    1、数据库配置文件 database.properties

    jdbc.driver=com.mysql.jdbc.Driver
#如果使用的是mysql8.0+，增加一个时区设置。serverTimezone=Asia/Shanghai
jdbc.url=jdbc:mysql://localhost:3306/ssmbuild?useSSL=true&useUnicode=false&characterEncoding=utf8
jdbc.username=root
jdbc.password=123456

    • 1
    • 2
    • 3
    • 4
    • 5

    2、IDEA关联数据库（非必须）

    3、编写MyBatis的核心配置文件，mybatis-config.xml

    
DOCTYPE configuration
       PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
       "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>


   <typeAliases>
       <package name="com.kuang.pojo"/>
   typeAliases>

configuration>

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12

    4、编写数据库对应的实体类 com.kuang.pojo.Books

    使用lombok插件！

    package com.kuang.pojo;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@AllArgsConstructor
@NoArgsConstructor
public class Books {
   
   private int bookID;
   private String bookName;
   private int bookCounts;
   private String detail;
   
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16

    5、编写Dao层的 Mapper接口！

    package com.kuang.dao;
import com.kuang.pojo.Books;
import java.util.List;

public interface BookMapper {

   //增加一个Book
   int addBook(Books book);

   //根据id删除一个Book
   int deleteBookById(@Param("bookId") int id);

   //更新Book
   int updateBook(Books books);

   //根据id查询,返回一个Book
   Books queryBookById(@Param("bookId") int id);

   //查询全部Book,返回list集合
   List<Books> queryAllBook();

}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22

    6、编写接口对应的 Mapper.xml 文件（前边进行了资源导出配置，这里mapper配置文件放在与接口相同的包下即可）。需要导入MyBatis的包；（不想写mapper配置文件可以使用注解，一般复杂查询注解就无能为力了还是得使用mapper配置文件）

    
DOCTYPE mapper
       PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
       "http://mybatis.org/dtd/mybatis-3-mapper.dtd">

<mapper namespace="com.kuang.dao.BookMapper">

   
   <insert id="addBook" parameterType="Books">
      insert into ssmbuild.books(bookName,bookCounts,detail)
      values (#{bookName}, #{bookCounts}, #{detail})
   insert>

   
   <delete id="deleteBookById" parameterType="int">
      delete from ssmbuild.books where bookID=#{bookID}
   delete>

   
   <update id="updateBook" parameterType="Books">
      update ssmbuild.books
      set bookName = #{bookName},bookCounts = #{bookCounts},detail = #{detail}
      where bookID = #{bookID}
   update>

   
   <select id="queryBookById" resultType="Books">
      select * from ssmbuild.books
      where bookID = #{bookID}
   select>

   
   <select id="queryAllBook" resultType="Books">
      SELECT * from ssmbuild.books
   select>

mapper>

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37

    编写好mapper配置文件后，要到MyBatis配置文件中注册（注册映射器）。我们使用包扫描自动注册的方式，这样就不需要每个mapper配置文件都手动注册。

    
<mappers>
    <package name="com.kuang.dao"/>
mappers>

    • 1
    • 2
    • 3
    • 4

    7、编写Service层的接口和实现类

    接口：

    package com.kuang.service;
import com.kuang.pojo.Books;
import java.util.List;

//BookService:底下需要去实现,调用dao层
public interface BookService {
   //增加一个Book
   int addBook(Books book);
   //根据id删除一个Book
   int deleteBookById(int id);
   //更新Book
   int updateBook(Books books);
   //根据id查询,返回一个Book
   Books queryBookById(int id);
   //查询全部Book,返回list集合
   List<Books> queryAllBook();
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17

    实现类：

    package com.kuang.service;
import com.kuang.dao.BookMapper;
import com.kuang.pojo.Books;
import org.springframework.beans.factory.annotation.Autowired;

import java.util.List;

public class BookServiceImpl implements BookService {

    //调用dao层的操作，组合dao
    private BookMapper bookMapper;
    //设置一个set接口，注册bean到Spring容器时使用set注入依赖（可以使用注解@Autowired）
    public void setBookMapper(BookMapper bookMapper) {
        this.bookMapper = bookMapper;
    }

    public int addBook(Books book) {
        return bookMapper.addBook(book);
    }

    public int deleteBookById(int id) {
        return bookMapper.deleteBookById(id);
    }

    public int updateBook(Books books) {
        return bookMapper.updateBook(books);
    }

    public Books queryBookById(int id) {
        return bookMapper.queryBookById(id);
    }

    public List<Books> queryAllBook() {
        return bookMapper.queryAllBook();
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36

    OK，到此，底层需求操作编写完毕！


    Spring层

    1、配置Spring整合MyBatis，我们这里数据源使用c3p0连接池；

    2、我们去编写Spring整合Mybatis（dao）的相关的配置文件：spring-dao.xml

    • 可以将数据库配置直接写在下边的dataSource中，也可以通过关联数据库文件的形式进行配置，下边的配置就是在Spring的配置文件中通过关联数据库文件database.properties配置datasource。
    • 这里的dataSource使用c3p0而不是Spring提供的。
    • 可以手动将DAO接口注册到Spring中，也可以跟下边一样通过扫描Dao接口包动态注册到spring容器中
    
<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"
       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">

    
    
    <context:property-placeholder location="classpath:database.properties"/>

    
    
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        
        <property name="driverClass" value="${jdbc.driver}"/>
        <property name="jdbcUrl" value="${jdbc.url}"/>
        <property name="user" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.password}"/>

        
        <property name="maxPoolSize" value="30"/>
        <property name="minPoolSize" value="10"/>
        <property name="initialPoolSize" value="10"/>
        
        <property name="autoCommitOnClose" value="false"/>
        
        <property name="checkoutTimeout" value="10000"/>
        
        <property name="acquireRetryAttempts" value="2"/>
    bean>

    
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        
        <property name="dataSource" ref="dataSource"/>
        
        <property name="configLocation" value="classpath:mybatis-config.xml"/>
        
    bean>

    
    
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        
        <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"/>
        
        <property name="basePackage" value="com.kuang.dao"/>
    bean>

beans>

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57

    3、Spring整合service层

    我们去编写Spring整合service层的相关的配置文件：spring-service.xml。如果出现红色提示，是因为各个配置文件还没整合在一起，可以提前看看后边的整合设置，将xml文件整合在一起。（事务管理器的使用可以参考这里，下边还没有配置完全。注意：前边的service模块中并未使用到注解，所以下边的方式一并未起作用。）

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


    
    <context:component-scan base-package="com.kuang.service" />

    
    <bean id="BookServiceImpl" class="com.kuang.service.BookServiceImpl">
        <property name="bookMapper" ref="bookMapper"/>
    bean>

    
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        
        <property name="dataSource" ref="dataSource" />
    bean>

beans>

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25

    Spring层搞定！再次理解一下，Spring就是一个大杂烩，一个容器！对吧！


    SpringMVC层

    1、添加web的支持！（选中module，点击鼠标右键，选择“Add Framework Support…”，再选择“Web Application”，确认即可）

    2、web.xml

    
<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>DispatcherServletservlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServletservlet-class>
        <init-param>
            <param-name>contextConfigLocationparam-name>
            
            <param-value>classpath:applicationContext.xmlparam-value>
        init-param>
        <load-on-startup>1load-on-startup>
    servlet>
    <servlet-mapping>
        <servlet-name>DispatcherServletservlet-name>
        <url-pattern>/url-pattern>
    servlet-mapping>

    
    <filter>
        <filter-name>encodingFilterfilter-name>
        <filter-class>
            org.springframework.web.filter.CharacterEncodingFilter
        filter-class>
        <init-param>
            <param-name>encodingparam-name>
            <param-value>utf-8param-value>
        init-param>
    filter>
    <filter-mapping>
        <filter-name>encodingFilterfilter-name>
        <url-pattern>/*url-pattern>
    filter-mapping>

    
    <session-config>
        <session-timeout>15session-timeout>
    session-config>

web-app>

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44

    3、SpringMVC的配置文件：spring-mvc.xml

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

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

    
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="viewClass" value="org.springframework.web.servlet.view.JstlView" />
        <property name="prefix" value="/WEB-INF/jsp/" />
        <property name="suffix" value=".jsp" />
    bean>

    
    <context:component-scan base-package="com.kuang.controller" />

beans>

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29

    4、Spring配置整合文件，applicationContext.xml

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

   <import resource="spring-dao.xml"/>
   <import resource="spring-service.xml"/>
   <import resource="spring-mvc.xml"/>
   
beans>

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11

    SSM框架整合基本环境搭建备份：https://cloud.189.cn/t/bEFjA3YnEv2u（访问码：sfw9）


    Controller和视图层

    配置文件，暂时结束！Controller和视图层编写

    1、BookController 类编写 ， 方法一：查询全部书籍（使用fastjson进行json数据转换）

    @Controller
@RequestMapping("/book")
public class BookController {

    @Autowired
    @Qualifier("BookServiceImpl")//指定@Autowired自动装配，具体使用bookService接口的哪个实现类
    //只有一个实现类可忽略。实现类名是spring-service.xml中注入到Spring容器配置中所定义的id或name。
    private BookService bookService;

    //查询全部的书籍，并且返回到一个书籍展示页面
    @RequestMapping("/allBook")
    public String list(Model model){
        List<Books> list = bookService.queryAllBook();//查询数据（调用service模块）
        String str = JSON.toJSONString(list);//将我们的集合对象解析成为json格式
        model.addAttribute("list", str);//添加数据到model中
        return "allBook";//视图名称
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18

    2、编写首页 index.jsp（web文件夹下，与WEB-INF文件夹同级）

    <%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8" %>
<!DOCTYPE HTML>
<html>
<head>
  <title>首页</title>
  <style type="text/css">
    a {
      text-decoration: none;
      color: black;
      font-size: 18px;
    }
    h3 {
      width: 180px;
      height: 38px;
      margin: 100px auto;
      text-align: center;
      line-height: 38px;
      background: deepskyblue;
      border-radius: 4px;
    }
  </style>
</head>
<body>

<h3>
  <a href="${pageContext.request.contextPath}/book/allBook">点击进入书籍页面</a>
</h3>
</body>
</html>

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29

    效果：

    3、书籍列表页面 allbook.jsp（WEB-INF文件夹下，新建jsp文件夹存放该jsp页面）。（使用Element-UI组件库来搭建页面，使用Vue进行数据绑定。也使用了jsp。）

    <%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <!--vue-->
    <script src="https://cdn.jsdelivr.net/npm/vue/dist/vue.js"></script>
    <!-- 引入样式 -->
    <link rel="stylesheet" href="https://unpkg.com/element-ui/lib/theme-chalk/index.css">
    <!-- 引入组件库 -->
    <script src="https://unpkg.com/element-ui/lib/index.js"></script>
    <title>书籍展示</title>
</head>
<body>
<div id="app">
    <h2 style="color:#409EFF">书籍列表 —— 显示所有书籍</h2>
    <template>
        <el-table
                :data="tableData"
                style="width: 100%">
            <el-table-column
                    prop="bookID"
                    label="ID"
                    width="180">
            </el-table-column>
            <el-table-column
                    prop="bookName"
                    label="书名"
                    width="180">
            </el-table-column>
            <el-table-column
                    prop="detail"
                    label="简介"
                    width="180">
            </el-table-column>
            <el-table-column
                    prop="bookCounts"
                    label="数量">
            </el-table-column>
        </el-table>
        <div style="margin-top: 20px">
            <el-button type="primary" @click="onSubmit">增加</el-button>
        </div>
    </template>
</div>
<script>
    var vue = new Vue({
        el:'#app',
        data:{
            tableData:${list}
        },
        methods:{
            onSubmit(){
                window.location.href = "${pageContext.request.contextPath}/book/toAddBook";
            }
        }
    });
</script>
</body>
</html>

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59

    效果：

    4、BookController 类中继续编写 ， 方法二：添加书籍

    @RequestMapping("/toAddBook")//实际路径为“/book/toAddBook"，别忘记了类上配置的路径。
public String toAddPaper() {
    return "addBook";//返回的视图名（对应addBook.jsp页面）
}

@RequestMapping("/addBook")
public String addPaper(Books books) {
    bookService.addBook(books);
    return "redirect:/book/allBook";//重定向到allBook请求，可以防止重复提交
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10

    5、添加书籍页面：addBook.jsp

    • vue-axios，get方式提交数据给服务器
    <%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>

<html>
<head>
    <title>新增书籍</title>
    <!--vue-->
    <script src="https://cdn.jsdelivr.net/npm/vue/dist/vue.js"></script>
    <!--axios-->
    <script src="https://unpkg.com/axios/dist/axios.min.js"></script>
    <!-- 引入样式 -->
    <link rel="stylesheet" href="https://unpkg.com/element-ui/lib/theme-chalk/index.css">
    <!-- 引入组件库 -->
    <script src="https://unpkg.com/element-ui/lib/index.js"></script>
</head>
<body>
<div id="app">
    <el-form :model="formInline" class="demo-form-inline" style="width: 50%">
        <el-form-item label="书名">
            <el-input v-model="formInline.bookName" placeholder="书籍名称"></el-input>
        </el-form-item>
        <el-form-item label="简介">
            <el-input v-model="formInline.detail" placeholder="简介"></el-input>
        </el-form-item>
        <el-form-item label="数量">
            <el-input v-model="formInline.bookCounts" placeholder="数量"></el-input>
        </el-form-item>
        <el-form-item>
            <el-button type="primary" @click="onSubmit">增加</el-button>
        </el-form-item>
    </el-form>
</div>
<script>
    var vue = new Vue({
        el:'#app',
        data:{
            formInline: {
                bookName: '',
                detail: '',
                bookCounts:''
            }
        },
        methods: {
            onSubmit() {
                if (this.formInline.bookName!="" &&this.formInline.detail!="" &&this.formInline.bookCounts!=""){
                    axios.get('${pageContext.request.contextPath}/book/addBook', {
                        params: {
                            bookName: this.formInline.bookName,
                            detail: this.formInline.detail,
                            bookCounts: this.formInline.bookCounts
                        }
                    })
                    .then(function (response) {
                        window.location.href = "${pageContext.request.contextPath}/book/allBook";//展示书籍页面
                    })
                }
            }
        }
    });

</script>
</body>
</html>

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63

    效果：

    6、BookController 类编写 ， 方法三：修改书籍

    @RequestMapping("/toUpdateBook")
public String toUpdateBook(Model model, int id) {
   Books books = bookService.queryBookById(id);
   System.out.println(books);
   model.addAttribute("book",books );
   return "updateBook";
}

@RequestMapping("/updateBook")
public String updateBook(Model model, Books book) {
   System.out.println(book);
   bookService.updateBook(book);
   Books books = bookService.queryBookById(book.getBookID());
   model.addAttribute("books", books);
   return "redirect:/book/allBook";
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16

    7、修改书籍页面 updateBook.jsp

    <%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
   <title>修改信息</title>
   <meta name="viewport" content="width=device-width, initial-scale=1.0">
   <!-- 引入 Bootstrap -->
   <link href="https://cdn.bootcss.com/bootstrap/3.3.7/css/bootstrap.min.css"rel="stylesheet">
</head>
<body>
<div class="container">

   <div class="row clearfix">
       <div class="col-md-12 column">
           <div class="page-header">
               <h1>
                   <small>修改信息</small>
               </h1>
           </div>
       </div>
   </div>

   <form action="${pageContext.request.contextPath}/book/updateBook"method="post">
       <input type="hidden" name="bookID" value="${book.getBookID()}"/>
      书籍名称：<input type="text" name="bookName"value="${book.getBookName()}"/>
      书籍数量：<input type="text" name="bookCounts"value="${book.getBookCounts()}"/>
      书籍详情：<input type="text" name="detail" value="${book.getDetail() }"/>
       <input type="submit" value="提交"/>
   </form>

</div>

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31

    8、BookController 类编写 ， 方法四：删除书籍

    @RequestMapping("/del/{bookId}")
public String deleteBook(@PathVariable("bookId") int id) {
   bookService.deleteBookById(id);
   return "redirect:/book/allBook";
}

    • 1
    • 2
    • 3
    • 4
    • 5

    配置Tomcat，进行运行！

    到目前为止，这个SSM项目整合已经完全的OK了，可以直接运行进行测试！这个练习十分的重要，大家需要保证，不看任何东西，自己也可以完整的实现出来！


    项目结构图：



    注解

    Controller

    RestFul

    接收参数：

    返回数据：

    • @ResponseBody - 将java对象转为json格式的数据并返回（不会走视图解析器）

    • @RestController - 对@ResponseBody的使用优化

    • package org.springframework.web.bind.annotation;

import java.lang.annotation.Documented;
...
import org.springframework.stereotype.Controller;

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Controller
@ResponseBody
public @interface RestController {
    @AliasFor(
        annotation = Controller.class
    )
    String value() default "";
}

      • 1
      • 2
      • 3
      • 4
      • 5
      • 6
      • 7
      • 8
      • 9
      • 10
      • 11
      • 12
      • 13
      • 14
      • 15
      • 16
      • 17

    小技巧

    解决乱码:

    Json工具类，使用到json解析工具Jackson



    课程学习自：遇见狂神说

  • 相关阅读:
    Linux之iptables及firewall超详解
    JShaman JavaScript混淆加密工具，中英版本区别
    【三维重建-PatchMatchNet复现笔记】
    .Net6 已知问题总结
    日志框架知识 commons-logging log4j slf4j logback java.util.logging
    如何安装 Wnmp 并结合内网穿透实现外网访问内网Wnmp 服务
    利用 Rainbond 云原生平台简化 Kubernetes 业务问题排查
    【云原生之Docker实战】使用Docker部署Navidrome家庭个人音乐库
    C++ Reference: Standard C++ Library reference: Others: iterator: begin
    基于NCF的多模块协同实例
  • 原文地址：https://blog.csdn.net/weixin_44773109/article/details/127646371