SpringMVC学习笔记+整合SSM框架

已于 2022-09-19 22:27:48 修改
阅读量537 收藏
点赞数
分类专栏： 框架 文章标签： java intellij-idea maven springmvc ssm
于 2022-01-20 20:07:32 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/thinker627/article/details/122195759
版权

一、MVC

模型（dao、service）、视图（jsp）、控制器（servlet）

二、Servlet

1. 导入servlet 和 jsp 的 jar 依赖

<dependency>
   <groupId>javax.servlet</groupId>
   <artifactId>servlet-api</artifactId>
   <version>2.5</version>
</dependency>
<dependency>
   <groupId>javax.servlet.jsp</groupId>
   <artifactId>jsp-api</artifactId>
   <version>2.2</version>
</dependency>

2. 编写一个Servlet类，用来处理用户的请求，继承HttpServlet的Java类

public class HelloServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
//        super.doGet(req, resp);
        //1.获取前端参数
        String method = req.getParameter("method");
        if (method.equals("add")){
            req.getSession().setAttribute("msg","执行了add方法");
        }
        if (method.equals("delete")){
            req.getSession().setAttribute("msg","执行了delete方法");
        }
        //2.调用业务层
        //3.视图转发或重定向
        req.getRequestDispatcher("/WEB-INF/jsp/test.jsp").forward(req, resp);
    }

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

3. 在web.xml中注册servlet

    <servlet>
        <servlet-name>hello</servlet-name>
        <servlet-class>com.lzq.servlet.HelloServlet</servlet-class>
    </servlet>

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

4. 提交表单测试（url:http://localhost:8080/hello?method=add）

<body>
<form action="/hello" method="post">
    <input type="text" name="method">
    <input type="submit">
</form>
</body>

三、SpringMVC

SpringMVC围绕DispatcherServlet设计，DispatcherServlet的作用是将请求分发到不同的处理器。

3.1 SpringMVC原理

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

3.2 SpringMVC执行流程 

 

3.3 Hello SpringMVC

3.3.1 配置版

1. 配置web.xml，注册DispatcherServlet

    <!--1.注册DispatcherServlet-->
    <servlet>
        <servlet-name>springmvc</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <!--关联一个springmvc的配置文件:【servlet-name】-servlet.xml-->
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:springmvc-servlet.xml</param-value>
        </init-param>
        <!--启动级别-1-->
        <load-on-startup>1</load-on-startup>
    </servlet>

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

2. 在resource目录下编写SpringMVC的配置文件！名称：springmvc-servlet.xml  : [servletname]-servlet.xml

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

    <!--不写也可以？？？写为了了解底层原理-->
    <!--处理映射器-->
    <bean class="org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping"/>
    <!--处理器适配器-->
    <bean class="org.springframework.web.servlet.mvc.SimpleControllerHandlerAdapter"/>

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

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

</beans>

3. 编写要操作业务Controller ，要么实现Controller接口，要么增加注解@Controller；需要返回一个ModelAndView，装数据，封视图

//注意：这里我们先导入Controller接口
public class HelloController implements Controller {

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

        //业务代码
        String result = "HelloSpringMVC!";
        //封装对象，放在ModelAndView中。Model
        mv.addObject("msg",result);

        //封装要跳转的视图，放在ModelAndView中
        mv.setViewName("hello"); //: /WEB-INF/jsp/hello.jsp
        return mv;
    }

}

4. 将Controller类交给SpringIOC容器，注册bean

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

5. 写要跳转的jsp页面hello.jsp，显示ModelandView存放的数据

6. 配置Tomcat 启动测试，http://localhost:8080/hello

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

1. 查看控制台输出，看一下是不是缺少了什么jar包；

2.如果jar包存在，显示无法输出，就在IDEA的项目发布中，添加lib依赖！

 3.3.2 注解版

1. 配置web.xml，注册DispatcherServlet，同上

2. 添加Spring MVC配置文件，为了支持基于注解的IOC，设置了自动扫描包的功能

在视图解析器中我们把所有的视图都存放在/WEB-INF/目录下，这样可以保证视图安全，因为这个目录下的文件，客户端不能直接访问。

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

    <!-- 自动扫描包，让指定包下的注解生效,由IOC容器统一管理 -->
    <context:component-scan base-package="com.lzq.controller"/>
    <!-- 让Spring MVC不处理静态资源 如.css .html .mp3等 -->
    <mvc:default-servlet-handler />
    <!--
        支持mvc注解驱动
        在spring中一般采用@RequestMapping注解来完成映射关系
        要想使@RequestMapping注解生效
        必须向上下文中注册DefaultAnnotationHandlerMapping
        和一个AnnotationMethodHandlerAdapter实例
        这两个实例分别在类级别和方法级别处理。
        而annotation-driven配置帮助我们自动完成上述两个实例的注入。
        同样不写也可以！！！！为了了解底层原理
     -->
    <mvc:annotation-driven />

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

</beans>

3. 编写Controller类，增加注解@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";//视图解析器处理，跳转到hello.jsp
    }
}

@Controller，代表这个类会被Spring接管，让Spring IOC容器初始化时自动扫描到，被这个注解的类中的所有方法，如果返回值是string，并且有具体页面可以跳转，那么就会被视图解析器解析

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

4. 写要跳转的jsp页面hello.jsp，显示ModelandView存放的数据

5. 配置Tomcat 启动测试，http://localhost:8080/HelloController/hello

3.3.3 两种方法总结

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

注解版可以在一个控制器中实现多个方法，只要请求地址映射不一样即可。

@Controller注解类型用于声明Spring类的实例是一个控制器。

（另外3个注解：@Service、@Component、@Repository）

3.4 RestFul 风格

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

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

@Controller
@RequestMapping("/HelloController")
public class HelloController {
    //原来：http://localhost:8080/HelloController/add?a=1&b=2
    @RequestMapping("/add")
    public String add(int a, int b, Model model){
        int res = a+b;
        model.addAttribute("msg","a+b="+res);
        return "hello";//视图解析器处理，跳转到hello.jsp
    }

    //RestFul：http://localhost:8080/HelloController/add2/1/2
    @RequestMapping("/add2/{a}/{b}")
    public String addRestFul(@PathVariable int a, @PathVariable int b, Model model){
        int res = a+b;
        model.addAttribute("msg","a+b="+res);
        return "hello";//视图解析器处理，跳转到hello.jsp
    }
}

2. 使用method属性指定请求类型，指定请求谓词的类型如GET, POST, HEAD, OPTIONS, PUT, PATCH, DELETE, TRACE等。

请求地址映射一样，但请求方法不同会调用相对应请求方法的请求，例如表单中method=post，则会调用method = RequestMethod.POST的请求。

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

    @RequestMapping(value = "/add2/{a}/{b}", method = RequestMethod.GET)
    //@GetMapping("/add2/{a}/{b}")  //等价于上面
    //还有PostMapping等
    public String add3(@PathVariable int a, @PathVariable int b, Model model){
        int res = a+b;
        model.addAttribute("msg","a+b="+res);
        return "hello";//视图解析器处理，跳转到hello.jsp
    }

3.5 SpringMVC中转发和重定向

    //转发，无需视图解析器，有的话无视
    @RequestMapping("/test2")
    public String test2(Model model){
        model.addAttribute("msg","test2");
        return "forward:/WEB-INF/jsp/hello.jsp";//视图解析器处理，跳转到hello.jsp
    }

    //重定向，无需视图解析器，有的话无视
    @RequestMapping("/test3")
    public String test3(Model model){
        return "redirect:/index.jsp";
    }

ps:普通方式

转发：request.getRequestDispatcher("/test.jsp").forword(request,response);

重定向：response.sendRedirect("/test.jsp");

3.6 数据处理

3.6.1处理提交数据

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

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

处理方法 :

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

ps:username为表单中的name属性！！！不是id属性！！！ 

2. 提交的是一个对象 

要求提交的表单域和对象的属性名一致  , 参数使用对象即可

提交数据 : http://localhost:8080/user?name=lzq&id=1

处理方法 :

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

3.6.2数据显示到前端

1. ModelAndView        mv.addObject("msg","ControllerTest1");

2. Model        model.addAttribute("msg",name);

3. ModelMap        model.addAttribute("msg",name);

3.7 Json交互处理

  • JSON(JavaScript Object Notation, JS 对象标记) 是一种轻量级的数据交换格式。

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

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

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

JSON 键值对是用来保存 JavaScript 对象的一种方式

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

json解析工具：jackson、fastjson

3.7.1 jackson

依赖包

<dependency>
   <groupId>com.fasterxml.jackson.core</groupId>
   <artifactId>jackson-databind</artifactId>
   <version>2.9.8</version>
</dependency>

测试，两个新东西，一个是@ResponseBody，一个是ObjectMapper对象

    //jackson
    @RequestMapping(value = "/json1")  //解决json乱码：produces = "application/json;charset=utf-8"
    @ResponseBody   //不会返回给视图解析器，直接返回String
    public String json1() throws JsonProcessingException {
        //创建一个jackson的对象映射器，用来解析数据
        ObjectMapper mapper = new ObjectMapper();
        //创建一个对象
        User user = new User(1, "刘zq");
        //将我们的对象解析成为json格式
        String str = mapper.writeValueAsString(user);
        //由于@ResponseBody注解，这里会将str转成json格式返回
        return str;
    }

    //jackson
    @RequestMapping(value = "/json2")  //解决json乱码：produces = "application/json;charset=utf-8"
    @ResponseBody   //不会返回给视图解析器，直接返回String
    public String json2() throws JsonProcessingException {
        //创建一个jackson的对象映射器，用来解析数据
        ObjectMapper mapper = new ObjectMapper();
        Date date = new Date();
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyy-mm-dd HH:mm:ss");
        return mapper.writeValueAsString(simpleDateFormat.format(date));
    }

json乱码问题，设置编码格式为utf-8，以及返回的类型； 

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

或者在springmvc的配置文件上添加一段消息StringHttpMessageConverter转换配置。

    <!--解决json乱码-->
    <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>

3.7.2 fastjson

依赖包

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

测试

    //fastjson
    @RequestMapping(value = "/json3")  //解决json乱码：produces = "application/json;charset=utf-8"
    @ResponseBody   //不会返回给视图解析器，直接返回String
    public String json3(){
        //创建一个对象
        User user = new User(1, "刘zq");
        return JSON.toJSONString(user);
    }
@RestController//不会被视图解析器解析，直接返回String，常用在类上，同@ResponseBody（常用在方法上）

3.8 Ajax

AJAX = Asynchronous JavaScript and XML（异步的 JavaScript 和 XML），是一种在无需重新加载整个网页的情况下，能够更新部分网页的技术。

Ajax的核心是XMLHttpRequest对象(XHR)。XHR为向服务器发送请求和解析服务器响应提供了接口。能够以异步方式从服务器获取新数据。

jQuery 是一个js库，提供多个与 AJAX 有关的方法。jQuery Ajax本质就是 XMLHttpRequest，对他进行了封装，方便调用。

Ajax实现 登录提示效果：

1. 编写一个AjaxController

@RestController
public class AjaxController {
    @RequestMapping("/a3")
    public String ajax3(String name,String pwd){
        String msg = "";
        //模拟数据库中存在数据
        if (name!=null){
            if ("admin".equals(name)){
                msg = "OK";
            }else {
                msg = "用户名输入错误";
            }
        }
        if (pwd!=null){
            if ("123456".equals(pwd)){
                msg = "OK";
            }else {
                msg = "密码输入有误";
            }
        }
        return msg; //由于@RestController注解，将msg转成json格式返回
    }
}

2. 前端页面 login.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
   <title>ajax</title>
   <%--导入jquery ， 可以使用在线的CDN ， 也可以下载导入--%>
   <script src="https://code.jquery.com/jquery-3.1.1.min.js"></script>
   <%--<script src="${pageContext.request.contextPath}/statics/js/jquery-3.1.1.min.js"></script>--%>
   <script>
       function a1(){
           $.post({
               url:"${pageContext.request.contextPath}/a3",
               data:{'name':$("#name").val()},
               success:function (data) {
                   if (data.toString()=='OK'){
                       $("#userInfo").css("color","green");
                  }else {
                       $("#userInfo").css("color","red");
                  }
                   $("#userInfo").html(data);
              }
          });
      }
       function a2(){
           $.post({
               url:"${pageContext.request.contextPath}/a3",
               data:{'pwd':$("#pwd").val()},
               success:function (data) {
                   if (data.toString()=='OK'){
                       $("#pwdInfo").css("color","green");
                  }else {
                       $("#pwdInfo").css("color","red");
                  }
                   $("#pwdInfo").html(data);
              }
          });
      }

   </script>
</head>
<body>
<p>
  用户名:<input type="text" id="name" onblur="a1()"/>
   <span id="userInfo"></span>
</p>
<p>
  密码:<input type="text" id="pwd" onblur="a2()"/>
   <span id="pwdInfo"></span>
</p>
</body>
</html>

3. 效果

3.9 拦截器

过滤器与拦截器的区别：拦截器是AOP思想的具体应用。

过滤器

  • servlet规范中的一部分，任何java web工程都可以使用

  • 在url-pattern中配置了/*之后，可以对所有要访问的资源进行拦截

拦截器

  • 拦截器是SpringMVC框架自己的，只有使用了SpringMVC框架的工程才能使用

  • 拦截器只会拦截访问的控制器方法， 如果访问的是jsp/html/css/image/js是不会进行拦截的

想要自定义拦截器，必须实现 HandlerInterceptor 接口

实现验证用户是否登录 (认证用户)，如果用户已经登陆，放行， 如果用户未登陆，跳转到登陆页面：

1. 编写用户拦截请求类

@Controller
@RequestMapping("/user")
public class UserInterceptorController {

    //跳转到登陆页面
    @RequestMapping("/toLogin")
    public String toLogin(){
        return "/login";
    }

    //跳转到成功页面
    @RequestMapping("/toSuccess")
    public String toSuccess(){
        return "success";
    }

    //登陆提交，跳转到成功页面
    @RequestMapping("login")
    public String login(String username, HttpSession session){
        // 向session记录用户身份信息
        System.out.println("接收前端==="+username);
        session.setAttribute("user", username);
        return "success";
    }

    //退出登陆
    @RequestMapping("logout")
    public String logout(HttpSession session){
        // session 过期
        session.removeAttribute("user");
        return "redirect:/index.jsp";
    }
}

2. 首页 index.jsp

<a href="${pageContext.request.contextPath}/user/toLogin">登录页面</a>
<a href="${pageContext.request.contextPath}/user/toSuccess">登录成功页面</a>

3. 登陆页面提交表单 login.jsp

<form action="/user/login" method="post">
    <p>
        用户名:<input type="text" id="username" name="username" onblur="a1()" value="admin"/>
        <span id="userInfo"></span>
    </p>
    <p>
        密 码:<input type="text" id="pwd" name="pwd" onblur="a2()" value="123456"/>
        <span id="pwdInfo"></span>
    </p>
    <p>
        <input type="submit" value="登陆">
    </p>
</form>

4. 登陆成功页面 success.jsp

<h1>登录成功页面</h1>
<hr>
<P>${user}</P>
<a href="${pageContext.request.contextPath}/user/logout">注销</a>

5. 自定义拦截器类

public class LoginInterceptor implements HandlerInterceptor {

    //在请求处理的方法之前执行
    //如果返回true执行下一个拦截器
    //如果返回false就不执行下一个拦截器
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        System.out.println("------------处理前------------");

        // 如果是登陆页面则放行
        System.out.println("url: " + request.getRequestURI());
        if (request.getRequestURI().contains("login")) {
            System.out.println("登陆页面放行");
            return true;
        }

        // 如果用户已登陆也放行
        HttpSession session = request.getSession();
        if(session.getAttribute("user") != null) {
            System.out.println("用户已登陆放行");
            return true;
        }

        // 用户没有登陆跳转到登陆页面
        request.getRequestDispatcher("/WEB-INF/jsp/login.jsp").forward(request, response);
        System.out.println("拦截");
        return false;
    }

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

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

6. 在Springmvc的配置文件中注册拦截器

    <!--关于拦截器的配置-->
    <!--/** 包括路径及其子路径-->
    <!--/admin/* 拦截的是/admin/add等等这种 , /admin/add/user不会被拦截-->
    <!--/admin/** 拦截的是/admin/下的所有-->
    <mvc:interceptors>
        <mvc:interceptor>
            <mvc:mapping path="/user/**"/>
            <bean id="loginInterceptor" class="com.lzq.LoginInterceptor"/>
        </mvc:interceptor>
    </mvc:interceptors>

3.10 文件上传下载

 3.10.1 文件上传

1. 导入文件上传的jar包 commons-fileupload ， Maven会自动导入他的依赖包 commons-io包，文件上传时request.getServletContext()方法要求servlet3.0+

<!--文件上传-->
<dependency>
   <groupId>commons-fileupload</groupId>
   <artifactId>commons-fileupload</artifactId>
   <version>1.4</version>
</dependency>

<!--文件上传时request.getServletContext()方法要求servlet3.0+-->
<!-- https://mvnrepository.com/artifact/javax.servlet/javax.servlet-api -->
<dependency>
    <groupId>javax.servlet</groupId>
    <artifactId>javax.servlet-api</artifactId>
    <version>4.0.1</version>
    <scope>provided</scope>
</dependency>

2. 配置bean：multipartResolver

<!--文件上传配置-->
<bean id="multipartResolver"  class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
   <!-- 请求的编码格式，必须和jSP的pageEncoding属性一致，以便正确读取表单的内容，默认为ISO-8859-1 -->
   <property name="defaultEncoding" value="utf-8"/>
   <!-- 上传文件大小上限，单位为字节（10485760=10M） -->
   <property name="maxUploadSize" value="10485760"/>
   <property name="maxInMemorySize" value="40960"/>
</bean>

3. 前端页面 index.jsp 

为了能上传文件，必须将表单的method设置为POST，并将enctype设置为multipart/form-data。只有在这样的情况下，浏览器才会把用户选择的文件以二进制数据发送给服务器。

<form action="/upload" enctype="multipart/form-data" method="post">
 <input type="file" name="file"/>
 <input type="submit" value="上传">
</form>

4. FileController

@Controller
public class FileController {
   //法一
   //@RequestParam("file") 将name=file控件得到的文件封装成CommonsMultipartFile 对象
   //批量上传CommonsMultipartFile则为数组即可
   @RequestMapping("/upload")
   public String fileUpload(@RequestParam("file") CommonsMultipartFile file , HttpServletRequest request) throws IOException {

       //获取文件名 : file.getOriginalFilename();
       String uploadFileName = file.getOriginalFilename();

       //如果文件名为空，直接回到首页！
       if ("".equals(uploadFileName)){
           return "redirect:/index.jsp";
      }
       System.out.println("上传文件名 : "+uploadFileName);

       //上传路径保存设置
       String path = request.getServletContext().getRealPath("/upload");
       //如果路径不存在，创建一个
       File realPath = new File(path);
       if (!realPath.exists()){
           realPath.mkdir();
      }
       System.out.println("上传文件保存地址："+realPath);

       InputStream is = file.getInputStream(); //文件输入流
       OutputStream os = new FileOutputStream(new File(realPath,uploadFileName)); //文件输出流

       //读取写出
       int len=0;
       byte[] buffer = new byte[1024];
       while ((len=is.read(buffer))!=-1){
           os.write(buffer,0,len);
           os.flush();
      }
       os.close();
       is.close();
       return "redirect:/index.jsp";
  }


    //法二
    /*
    * 采用file.Transto 来保存上传的文件
    */
    @RequestMapping("/upload2")
    public String  fileUpload2(@RequestParam("file") CommonsMultipartFile file, HttpServletRequest request) throws IOException {

       //上传路径保存设置
       String path = request.getServletContext().getRealPath("/upload");
       File realPath = new File(path);
       if (!realPath.exists()){
           realPath.mkdir();
      }
       //上传文件地址
       System.out.println("上传文件保存地址："+realPath);

       //通过CommonsMultipartFile的方法直接写文件
       file.transferTo(new File(realPath +"/"+ file.getOriginalFilename()));

       return "redirect:/index.jsp";
    }
}

3.10.2 文件下载

1. Controller

@RequestMapping(value="/download")
public String downloads(HttpServletResponse response ,HttpServletRequest request) throws Exception{
   //要下载的图片地址
   String  path = request.getServletContext().getRealPath("/upload");
   String  fileName = "1.jpg";

   //1、设置response 响应头
   response.reset(); //设置页面不缓存,清空buffer
   response.setCharacterEncoding("UTF-8"); //字符编码 utf-8
   response.setContentType("multipart/form-data"); //二进制传输数据
   //设置响应头
   response.setHeader("Content-Disposition",
           "attachment;fileName="+URLEncoder.encode(fileName, "UTF-8"));

   File file = new File(path,fileName);
   //2、 读取文件--输入流
   InputStream input=new FileInputStream(file);
   //3、 写出文件--输出流
   OutputStream out = response.getOutputStream();

   byte[] buff =new byte[1024];
   int index=0;
   //4、执行 写出操作
   while((index= input.read(buff))!= -1){
       out.write(buff, 0, index);
       out.flush();
  }
   out.close();
   input.close();
   return null;
}

2. 前端 index.jsp 

<a href="/download">请求下载</a>
<a href="/upload/1.png">直接下载</a>

ps 上传下载地址如下：

  

 四、整合SSM

1. 新建Maven项目，添加web的支持

2. 导入相关的pom依赖

    <dependencies>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.11</version>
            <scope>test</scope>
        </dependency>

        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.44</version>
        </dependency>
        <!-- 数据库连接池 -->
        <dependency>
            <groupId>com.mchange</groupId>
            <artifactId>c3p0</artifactId>
            <version>0.9.5.2</version>
        </dependency>

        <!--Mybatis-->
        <!-- https://mvnrepository.com/artifact/org.mybatis/mybatis -->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.5.7</version>
        </dependency>

        <!--在实体类上自动生成get set等方法-->
        <!-- https://mvnrepository.com/artifact/org.projectlombok/lombok -->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.22</version>
            <!--<scope>provided</scope>-->
        </dependency>

        <!--Spring的包-->
        <!-- https://mvnrepository.com/artifact/org.springframework/spring-webmvc -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>5.3.14</version>
        </dependency>

        <!--AOP要用-->
        <!-- https://mvnrepository.com/artifact/org.aspectj/aspectjweaver -->
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.9.7</version>
        </dependency>

        <!--Spring连接数据库要用-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>5.3.14</version>
        </dependency>

        <!--整合用到-->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis-spring</artifactId>
            <version>2.0.6</version>
        </dependency>

        <!--SpringMVC-->
        <!--servlet-->
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>servlet-api</artifactId>
            <version>2.5</version>
        </dependency>

        <!--jsp-->
        <!-- https://mvnrepository.com/artifact/javax.servlet.jsp/jsp-api -->
        <dependency>
            <groupId>javax.servlet.jsp</groupId>
            <artifactId>jsp-api</artifactId>
            <version>2.2</version>
            <!--<scope>provided</scope>-->
        </dependency>

        <!--jstl  el表达式-->
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>jstl</artifactId>
            <version>1.2</version>
        </dependency>

        <!--json解析工具，选一个-->
        <!-- https://mvnrepository.com/artifact/com.fasterxml.jackson.core/jackson-databind -->
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-databind</artifactId>
            <version>2.13.1</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/com.alibaba/fastjson -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.79</version>
        </dependency>
    </dependencies>

3. Maven资源过滤设置

<build>
   <resources>
       <resource>
           <directory>src/main/java</directory>
           <includes>
               <include>**/*.properties</include>
               <include>**/*.xml</include>
           </includes>
       </resource>
   </resources>
</build>

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

  • com.lzq.pojo（M）

  • com.lzq.dao（M）

  • com.lzq.service（M）

  • com.lzq.controller（C）

  • /WEB-INF/jsp（V）

  • Mybatis配置文件，mybatis-config.xml
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
       PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
       "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>

</configuration>
  • Spring配置文件，applicationContext.xml 
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
      xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
      xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd">

</beans>

4.1 Mybatis层

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

jdbc.driver=com.mysql.jdbc.Driver
#mysql8.0+ url需要配置时区 &serverTimezone=Aisa/Shanghai
jdbc.url=jdbc:mysql://localhost:3306/ssmbuild?useSSL=true&useUnicode=true&characterEncoding=utf8
jdbc.username=root
jdbc.password=root

2. 编写MyBatis的核心配置文件 mybatis-config.xml

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>

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

</configuration>

3. 编写数据库对应的实体类 com.lzq.pojo.Books 

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

4. 编写Dao层的Mapper接口 

public interface BookMapper {
    //增加一本书
    int addBook(Books book);

    //根据id删除一本书
    int deleteBookById(@Param("bookID") int id);

    //修改一本书
    int updateBook(Books book);

    //根据id查询一本书
    Books queryBookById(@Param("bookID") int id);

    //查询全部书
    List<Books> queryAllBook();
    
    //模糊查询
    //@Select("select * from ssmbuild.books where bookName like '%${bookName}%'")
    //@Select("select * from ssmbuild.books where bookName like concat('%',#{bookName},'%')")
    List<Books> queryLikeBook(@Param("bookName") String name);
}

5. 编写接口对应的 BookMapper.xml 文件，需要导入MyBatis的包

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.lzq.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.book where bookID=#{bookID}
    </delete>

    <!--修改一本书-->
    <update id="updateBook" parameterType="BookID">
        update ssmbuild.book
        set bookName=#{bookName}, bookCounts=#{bookCounts}, detail=#{detail}
        where bookID=#{bookID}
    </update>

    <!--查询一本书-->
    <select id="queryBookById" resultType="Books">
        select *
        from ssmbuild.book alias
        where alias.bookID=#{bookID};
    </select>

    <!--查询全部书-->
    <select id="queryAllBook" resultType="Books">
        select *
        from ssmbuild.book;
    </select>

    <!--书名模糊查询-->
    <select id="queryLikeBook" resultType="Books">
        select *
        from ssmbuild.books
        where bookName like "%"#{bookName}"%";
    </select>
</mapper>

6. 编写Service层的接口

//BookService:底下需要去实现,调用dao层
public interface BookService {

    //增加一本书
    int addBook(Books book);

    //根据id删除一本书
    int deleteBookById(int id);

    //修改一本书
    int updateBook(Books book);

    //根据id查询一本书
    Books queryBookById(int id);

    //查询全部书
    List<Books> queryAllBook();
}

7. 编写Service层接口的实现类，调用Dao层

public class BookServiceImpl implements BookService{

    //调用dao层的操作，设置一个set接口，方便Spring管理
    private BookMapper bookMapper;

    public void setBookMapper(BookMapper bookMapper) {
        this.bookMapper = bookMapper;
    }

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

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

    @Override
    public int updateBook(Books book) {
        return bookMapper.updateBook(book);
    }

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

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

4.2 Spring层

1. 编写Spring整合Mybatis的配置文件 spring-dao.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
      xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
      xmlns:context="http://www.springframework.org/schema/context"
      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">

   <!-- 配置整合mybatis -->
   <!-- 1.关联数据库文件 -->
   <context:property-placeholder location="classpath:database.properties"/>

   <!-- 2.数据库连接池 -->
   <!--数据库连接池
       dbcp 半自动化操作 不能自动连接
       c3p0 自动化操作（自动的加载配置文件 并且设置到对象里面）
   -->
   <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}"/>

       <!-- c3p0连接池的私有属性 -->
       <property name="maxPoolSize" value="30"/>
       <property name="minPoolSize" value="10"/>
       <!-- 关闭连接后不自动commit -->
       <property name="autoCommitOnClose" value="false"/>
       <!-- 获取连接超时时间 -->
       <property name="checkoutTimeout" value="10000"/>
       <!-- 当获取连接失败重试次数 -->
       <property name="acquireRetryAttempts" value="2"/>
   </bean>

   <!-- 3.配置SqlSessionFactory对象 -->
   <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
       <!-- 注入数据库连接池 -->
       <property name="dataSource" ref="dataSource"/>
       <!-- 配置MyBaties全局配置文件:mybatis-config.xml -->
       <property name="configLocation" value="classpath:mybatis-config.xml"/>
   </bean>

   <!-- 4.配置扫描Dao接口包，动态实现Dao接口注入到spring容器中 -->
   <!--解释 ：https://www.cnblogs.com/jpfss/p/7799806.html-->
   <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
       <!-- 注入sqlSessionFactory -->
       <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"/>
       <!-- 给出需要扫描Dao接口包 -->
       <property name="basePackage" value="com.lzq.dao"/>
   </bean>

</beans>

2. Spring整合Service层的配置文件 spring-service.xml 

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
      xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
      xmlns:context="http://www.springframework.org/schema/context"
      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">

   <!-- 扫描service相关的bean -->
   <context:component-scan base-package="com.lzq.service" />

   <!--BookServiceImpl注入到IOC容器中-->
   <bean id="BookServiceImpl" class="com.lzq.service.BookServiceImpl">
       <property name="bookMapper" ref="bookMapper"/>
   </bean>

   <!-- 配置事务管理器 -->
   <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
       <!-- 注入数据库连接池 -->
       <property name="dataSource" ref="dataSource" />
   </bean>

</beans>

4.3 SpringMVC层

1. 配置 web.xml

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
        version="4.0">

   <!--DispatcherServlet-->
   <servlet>
       <servlet-name>DispatcherServlet</servlet-name>
       <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
       <init-param>
           <param-name>contextConfigLocation</param-name>
           <!--一定要注意:我们这里加载的是Spring总的配置文件，之前被这里坑了！-->  
           <param-value>classpath:applicationContext.xml</param-value>
       </init-param>
       <load-on-startup>1</load-on-startup>
   </servlet>
   <servlet-mapping>
       <servlet-name>DispatcherServlet</servlet-name>
       <url-pattern>/</url-pattern>
   </servlet-mapping>

   <!--encodingFilter-->
   <filter>
       <filter-name>encodingFilter</filter-name>
       <filter-class>
          org.springframework.web.filter.CharacterEncodingFilter
       </filter-class>
       <init-param>
           <param-name>encoding</param-name>
           <param-value>utf-8</param-value>
       </init-param>
   </filter>
   <filter-mapping>
       <filter-name>encodingFilter</filter-name>
       <url-pattern>/*</url-pattern>
   </filter-mapping>
   
   <!--Session过期时间-->
   <session-config>
       <session-timeout>15</session-timeout>
   </session-config>
   
</web-app>

2. 配置 spring-mvc.xml

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

   <!-- 配置SpringMVC -->
   <!-- 1.开启SpringMVC注解驱动 -->
   <mvc:annotation-driven />
   <!-- 2.静态资源默认servlet配置-->
   <mvc:default-servlet-handler/>

   <!-- 3.配置jsp 显示ViewResolver视图解析器 -->
   <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>

   <!-- 4.扫描web相关的bean -->
   <context:component-scan base-package="com.lzq.controller" />

</beans>

3. Spring配置整合文件 applicationContext.xml

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

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

4.4 Controller层 & 视图层

1.  编写请求控制类BookController

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

    @Autowired
//    或者
//    private BookServiceImpl bookServiceImpl = new BookServiceImpl();
    @Qualifier("bookServiceImpl")
    private BookServiceImpl bookServiceImpl;

    //查询全部书
    @RequestMapping("/allBook")
    public String allBook(Model model) {
        List<Books> booksList = bookServiceImpl.queryAllBook();
        model.addAttribute("booksList", booksList);
        return "/allBook";
    }

    //增加一本书
    @RequestMapping("/toAddBook")
    public String toAddBook() {
        return "addBook";
    }

    @RequestMapping("/addBook")
    public String addBook(Books book) {
        bookServiceImpl.addBook(book);
        return "redirect:/book/allBook";
    }

    //修改一本书
    @RequestMapping("/toUpdateBook")
    public String toUpdateBook(Model model, int id) {
        Books books = bookServiceImpl.queryBookById(id);
        model.addAttribute("book", books);
        return "updateBook";
    }

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

    //删除一本书
    @RequestMapping("/delete/{bookId}")
    public String deleteBook(@PathVariable("bookId") int id) {
        bookServiceImpl.deleteBookById(id);
        return "redirect:/book/allBook";
    }

    //书名模糊查询
    @RequestMapping("/queryLikeBook")
    public String queryLikeBook(Model model, String bookName){
        List<Books> booksList = bookServiceImpl.queryLikeBook(bookName);
        model.addAttribute("booksList", booksList);
        return "/allBook";
    }
}

2. 编写首页 index.jsp，跳转到显示全部书籍页面

<a href="${pageContext.request.contextPath}/book/allBook">点击进入图书列表页</a>

3. 显示全部书籍页面 allBook.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 ="text-center">
                <div class="page-header">
                    <h1>
                        <small>书籍列表</small>
                    </h1>
                </div>
            </div>
        </div>
    </div>

    <div class="row">
        <div class="col-md-4 column">
            <a class="btn btn-primary" href="${pageContext.request.contextPath}/book/allBook">显示所有书籍</a>
        </div>

        <div class="col-md-4 column">
            <a class="btn btn-primary" href="${pageContext.request.contextPath}/book/toAddBook">新增</a>
        </div>

        <div class="col-md-4 column">
            <form class="form-inline" action="${pageContext.request.contextPath}/book/queryLikeBook" method="post">
                <input class="form-control" type="text" name="bookName" placeholder="书籍名称">
                <input class="btn btn-primary" type="submit" value="查询">
            </form>
        </div>
    </div>

    <div class="row clearfix">
        <div class="col-md-12 column">
            <table class="table table-hover table-striped">
                <thead>
                <tr>
                    <th>书籍编号</th>
                    <th>书籍名字</th>
                    <th>书籍数量</th>
                    <th>书籍详情</th>
                    <th>操作</th>
                </tr>
                </thead>

                <tbody>
                <c:forEach var="book" items="${booksList}">
                    <tr>
                        <td>${book.bookID}</td>
                        <td>${book.bookName}</td>
                        <td>${book.getBookCounts()}</td>
                        <td>${book.getDetail()}</td>
                        <td>
                            <a href="${pageContext.request.contextPath}/book/toUpdateBook?id=${book.getBookID()}">修改</a>
                            |
                            <a href="${pageContext.request.contextPath}/book/delete/${book.getBookID()}">删除</a>
                        </td>
                    </tr>
                </c:forEach>
                </tbody>
            </table>
        </div>
    </div>
</div>

4. 添加书籍页面 addBook.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/addBook" method="post">
        书籍名称：<input type="text" name="bookName" required><br><br><br>
        书籍数量：<input type="text" name="bookCounts" required><br><br><br>
        书籍详情：<input type="text" name="detail"><br><br><br>
        <input type="submit" value="添加">
    </form>

</div>

5.  修改书籍页面  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">
        书籍编号：${book.getBookID()}
        <input type="hidden" name="bookID" value="${book.getBookID()}"/>
        书籍名称：<input type="text" name="bookName" value="${book.getBookName()}" required/>
        书籍数量：<input type="text" name="bookCounts" value="${book.getBookCounts()}" required/>
        书籍详情：<input type="text" name="detail" value="${book.getDetail() }"/>
        <input type="submit" value="修改"/>
    </form>

</div>

依赖

        <!--SpringMVC-->
        <!--servlet-->
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>servlet-api</artifactId>
            <version>2.5</version>
        </dependency>

        <!--jsp-->
        <!-- https://mvnrepository.com/artifact/javax.servlet.jsp/jsp-api -->
        <dependency>
            <groupId>javax.servlet.jsp</groupId>
            <artifactId>jsp-api</artifactId>
            <version>2.2</version>
            <!--<scope>provided</scope>-->
        </dependency>

        <!--jstl  el表达式-->
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>jstl</artifactId>
            <version>1.2</version>
        </dependency>

        <!--json解析工具，选一个-->
        <!-- https://mvnrepository.com/artifact/com.fasterxml.jackson.core/jackson-databind -->
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-databind</artifactId>
            <version>2.13.1</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/com.alibaba/fastjson -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.79</version>
        </dependency>

其他

1.项目发布名

http://localhost:8080/"项目名"/"请求requsestmapping"

2. GET和POST区别

一个重大区别：对于GET方式的请求，浏览器会把http header和data一并发送出去，服务器响应200（返回数据）；而对于POST，浏览器先发送header，服务器响应100 continue，浏览器再发送data，服务器响应200（返回数据）。在网络环境好的情况下，发一次包的时间和发两次包的时间差别基本可以无视；而在网络环境差的情况下，两次包的TCP在验证数据包完整性上，有非常大的优点。

3. 转发和重定向的区别

转发：

request.getRequestDispatcher("/test.jsp").forword(request,response);

客户首先发送一个请求到服务器端，服务器端发现匹配的servlet，并指定它去执行，当这个servlet执行完之后，它要调用getRequestDispacther()方法，把请求转发给指定的student_list.jsp,整个流程都是在服务器端完成的，而且是在同一个请求里面完成的，因此servlet和jsp共享的是同一个request，在servlet里面放的所有东西，在student_list中都能取出来，因此，student_list能把结果getAttribute()出来，getAttribute()出来后执行完把结果返回给客户端。整个过程是一个请求，一个响应。

重定向：

response.sendRedirect("/test.jsp");

客户发送一个请求到服务器，服务器匹配servlet，servlet处理完之后调用了sendRedirect()方法，立即向客户端返回这个响应，响应行告诉客户端你必须要再发送一个请求，去访问student_list.jsp，紧接着客户端收到这个请求后，立刻发出一个新的请求，去请求student_list.jsp,这里两个请求互不干扰，相互独立，在前面request里面setAttribute()的任何东西，在后面的request里面都获得不了。可见，在sendRedirect()里面是两个请求，两个响应。

区别：

1、请求次数：重定向是浏览器向服务器发送一个请求并收到响应后再次向一个新地址发出请求，转发是服务器收到请求后为了完成响应跳转到一个新的地址；重定向至少请求两次，转发请求一次；

2、地址栏不同：重定向地址栏会发生变化，转发地址栏不会发生变化；

3、是否共享数据：重定向两次请求不共享数据，转发一次请求共享数据（在request级别使用信息共享，使用重定向必然出错）；

4、跳转限制：重定向可以跳转到任意URL，转发只能跳转本站点资源；

5、发生行为不同：重定向是客户端行为，转发是服务器端行为；

 4. 好用推荐

bootstarp可视化布局系统

thinker627
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
SSM—2.SpringMVC
不放手，不错过的博客
09-22 572
1.springMVC介绍 Spring MVC属于SpringFrameWork的后续产品，已经融合在Spring Web Flow里面。Spring 框架提供了构建 Web 应用程序的全功能 MVC 模块。 使用 Spring 可插入的 MVC 架构，可以选择是使用内置的 Spring Web 框架还 是 Struts 这样的 Web 框架。通过策略接口，Spring 框架是高度可配置的，而且包含多种视图技术，例如 JavaServer Pages（JSP）技术、Velocity...
Spring+SpringMVC+Mybatis SSM框架小项目
01-28
SSM框架，即Spring、SpringMVC和Mybatis的整合，是Java开发中常见的Web应用程序框架。这个开源小项目提供了一种便捷的方式，帮助初学者和有经验的开发者理解和实践这三个核心组件的集成。 首先，Spring框架是Java...
Spring MVC——整合SSM框架
一心同学的博客
12-14 686
保姆级别整合SSM框架，清晰给出每一个步骤。
SpringMVC入门以及SSM整合
去创造
06-11 180
1. SpringMVC简介 1.1 MVC模式 MVC是软件工程中的一种软件架构模式，它是一种分离业务逻辑与显示界面的开发思想。 M（model）模型：处理业务逻辑，封装实体 V（view） 视图：展示内容 C（controller）控制器：负责调度分发（1.接收请求、2.调用模型、3.转发到视图） 1.2 SpringMVC概述 SpringMVC 是一种基于 Java 的实现 MVC 设计模式的轻量级（启动时消耗资源少） Web 框架，它通过一套注解，让一个简单的 Java 类成为处理请求的控制
SpringMVC和SSM整合步骤（最详细）
MXDMAX的博客
01-07 1081
文章目录一、MVC架构1、概念2、好处二、SpringMVC的具体实现步骤1、xml配置版1.1 在pom.xml文件中添加依赖1.2 配置web.xml1.3 配置springmvc.xml1.4 编写控制层类和方法2、注解开发版2.1 在pom.xml文件中添加依赖2.2 配置web.xml2.3 配置springmvc.xml2.4 编写控制层类和方法3、可能遇到的问题三、接收请求参数1、基本类型参数2、实体接收参数【重点】3、数组接收参数4、集合接收参数错误解决办法：5、路径携带参数6、中文乱码解决
【SpringMVC学习笔记】整合SSM框架
Stay Hungry, Stay Foolish!
09-18 135
文章目录整合SSM框架一. 搭建整合环境1.整合的思路2.创建数据库和表结构3.创建maven的工程4.pom.xml引入坐标依赖5. 编写实体类6. 编写dao接口7. 编写service接口和实现类二、Spring框架代码的编写1. applicationContext.xml配置文件2. 编写测试方法SpringTest三、SpringMVC框架编写1. 配置DispatcherServlet前端控制器2. 配置DispatcherServlet过滤器解决中文乱码3. 创建springmvc.xml的
SpringMVC学习笔记16-SSM框架整合
White
01-09 224
1 SSM框架整合介绍 1.1整合步骤 创建项目，添加jar包（核心是哪几个） 创建包，创建实体与Mapper（mybatise生成器使用，mybatise流程） 添加连接数据库的properties文件 添加log4j配置文件 添加spring配置文件（重点是配置的内容有哪些） 添加springmvc配置文件（内容） 修改web.xml文件（tomcat执行流程，启动spring流程，启动springmvc流程） ...
手把手教你整合最优雅SSM框架：SpringMVC + Spring + MyBatis
2401_84411822的博客
04-21 276
这份面试题几乎包含了他在一年内遇到的所有面试题以及答案，甚至包括面试中的细节对话以及语录，可谓是细节到极致，甚至简历优化和怎么投简历更容易得到面试机会也包括在内！也包括教你怎么去获得一些大厂，比如阿里，腾讯的内推名额！某位名人说过成功是靠99%的汗水和1%的机遇得到的，而你想获得那1%的机遇你首先就得付出99%的汗水！你只有朝着你的目标一步一步坚持不懈的走下去你才能有机会获得成功！成功只会留给那些有准备的人！
SpringMVC学习笔记-08 SSM框架整合开发
The Shawshank Redemption
01-22 141
SSM就是将SpringMVC+Spring+MyBatis整合在一起进行开发，最主要的其实是将MyBatis整合到Spring中，因为SpringMVC其实本来就是Spring的一部分。有两种整合方式，一种是基于XML配置文件，一种是基于注解。 整合思路梳理： SSM框架搭建后，整个项目按照如下结构执行： SSM最核心的就是两个容器的管理，SpringMVC中管理了Controller，Spring容器中管理了Service和Dao(有可能还有工具...
【狂神说】SpringMVC笔记整理 | SSM框架整合
小七自学博客
12-21 1392
SpringMVC 目录SpringMVC1.MVC1.1 MVC是什么1.2 Model时代1.3 Model2时代1.4 回顾ServletMVC框架要做哪些事情2. 什么是SpringMVC2.1 概述2.2 中心控制器2.3 SpringMVC执行原理3. HelloSpeingMVC配置版注解版小结4. RestFul和控制器4.1 控制器Controller实现Controller接口使用注解@Controller4.2 @RequestMapping4.3 RestFul 风格概念学习测试使用
SpringBoot+SpringMVC+SrpingSecurity+SSM整合.zip
02-13
在"SpringBoot+SpringMVC+SpringSecurity+SSM整合.zip"的学习笔记中，你可能会涉及以下几个关键知识点： 1. SpringBoot的起步依赖和自动配置：理解如何通过添加不同模块的starter依赖来引入所需的Spring功能，以及...
SpringMVC学习笔记整合搭建框架
11-16
4、SpringMVC整合MyBatis 5、参数绑定 a)SpringMVC默认支持的类型 b)简单数据类型 c)Pojo类型 d)Pojo包装类型 e)自定义参数绑定 6、SpringMVC和Struts2的区别 第二天 1、高级参数绑定 a)数组类型的参数绑定 b)List...
SSM 框架整合教程-尚硅谷学习笔记 2022 年
08-17
通过阅读"SSM框架整合教程——尚硅谷学习笔记 2022 年.md"或"SSM框架整合教程——尚硅谷学习笔记 2022 年.pdf"，你可以深入学习如何配置SSM环境，创建基本的CRUD操作，以及如何优化和扩展SSM应用。这些知识点不仅...
SSM 框架整合教程：三、SpringMVC-尚硅谷学习笔记 2022 年
09-08
### 整合SSM框架 1. **Spring框架**：作为基础，Spring提供了依赖注入（DI）和面向切面编程（AOP），管理着整个应用的bean。 2. **SpringMVC**：作为Web层，处理HTTP请求，转发到对应的处理器（Controller），然后...
在eclipse中导入本地的jar包配置Junit环境步骤（包含Junit中的方法一直标红的解决方法）
最新发布
weixin_70987470的博客
07-20 216
从本地导入Junit
Promise 详解（原理篇）
山重水复疑无路，柳暗花明又一村。
07-20 470
Promise 是一种异步编程的解决方案。在异步操作中，callback 会导致回调地狱的问题，Promise 解决了这个问题。一个 Promise对象有以下三种状态:pending：初始状态，既不是成功，也不是失败状态。：意味着操作成功完成。rejected：意味着操作失败。当 new Promise() 被实例化后，即表示 Promise 进入 pending 初始化状态，准备就绪，等待运行。
Java内存模型
weixin_44267758的博客
07-19 549
此处的变量不是指java编程中的变量，它包括了实例字段，静态字段和构成数值对象的元素，但不包括局部变量和方法参数。JMM规定所有变量都存储在主内存中。每条线程有自己的工作内存，工作内存中保留了该线程使用到变量的主内存的副本。线程对变量的所有操作都必须在工作内存中进行，不能直接读写主内存的变量，不同的线程间也无法直接访问对方工作内存的变量，线程之间的变量值传递需要通过主内存来完成。
JVM-垃圾回收与内存分配
m0_50846237的博客
07-19 741
JVM-垃圾回收与内存分配
SpringMVC入门：SSM整合全解析与环境搭建
在SpringMVC第三天的学习笔记中，主要内容围绕着SSM（Spring、SpringMVC和MyBatis）框架的整合。首先，我们讨论了如何搭建整合环境，强调了使用XML+注解的方式，因为这种方式相对直观且适合初学者。整合过程分为四个...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值