SpringMVC

SpringMVC框架第一天
第一章:三层架构和MVC 1. 三层架构
1. 咱们开发服务器端程序,一般都基于两种形式,一种C/S架构程序,一种B/S架构程序 2. 使用Java语言基本上都是开发B/S架构的程序,B/S架构又分成了三层架构 3. 三层架构
2. MVC模型
1. MVC全名是Model View Controller 模型视图控制器,每个部分各司其职。 2. Model:数据模型,JavaBean的类,用来进行数据封装。 3. View:指JSP、HTML用来展示数据给用户 4. Controller:用来接收用户的请求,整个流程的控制器。用来进行数据校验等。
  第二章:SpringMVC的入门案例 1.SpringMVC的概述(查看大纲文档)
三层架构中,每一层各司其职,接下来我们就说说每层都负责哪些方面: 表现层: 也就是我们常说的web层。它负责接收客户端请求,向客户端响应结果,通常客户端使用http协议请求web 层,web 需要接收 http 请求,完成 http 响应。表现层包括展示层和控制层:控制层负责接收请求,展示层 负责结果的展示。表现层依赖业务层,接收到客户端请求一般会调用业务层进行业务处理,并将处理结果响应给客 户端。表现层的设计一般都使用 MVC 模型。(MVC 是表现层的设计模型,和其他层没有关系) 业务层: 也就是我们常说的 service 层。它负责业务逻辑处理,和我们开发项目的需求息息相关。web 层依赖业务 层,但是业务层不依赖 web 层。业务层在业务处理时可能会依赖持久层,如果要对数据持久化需要保证事务一致 性。(也就是我们说的,事务应该放到业务层来控制) 持久层: 也就是我们是常说的 dao 层。负责数据持久化,包括数据层即数据库和数据访问层,数据库是对数据进行 持久化的载体,数据访问层是业务层和持久层交互的接口,业务层需要通过数据访问层将数据持久化到数据库中。 通俗的讲,持久层就是和数据库交互,对数据库表进行曾删改查的。
1 2 3
4 5
6 7
MVC 全名是 Model View Controller,是模型(model)-视图(view)-控制器(controller)的缩写,是 一种用于设计创建 Web 应用程序表现层的模式。MVC 中每个部分各司其职: Model(模型): 通常指的就是我们的数据模型。作用一般情况下用于封装数据。 View(视图): 通常指的就是我们的 jsp 或者 html。作用一般就是展示数据的。通常视图是依据模型数据创建的。 Controller(控制器): 是应用程序中处理用户交互的部分。作用一般就是处理程序逻辑的.

SpringMVC框架第二天

第一章:响应数据和结果视图

1.Map,Model,ModelMap 隐形参数的作用和关系(重点)

  • 使用Map传递页面数据

  • 使用Model传递页面数据

  • 使用ModelMap传递页面数据

    总结:以上三个隐形参数传过来的是同一个实现类对象:BindingAwareModelMap,底层都会把键值对数据放到request作用域中.

2. 返回值分类

  1. 返回字符串

    1. Controller方法返回字符串可以指定逻辑视图的名称,根据视图解析为物理视图的地址。(返回字符串都会交给视图解析器来进行解析)

      public String saveStudent(Student stu) {
      System.out.println(stu);
      // 编写控制逻辑
      return "success";
      }
  2. 返回值为void,也会经过视图解析器,只能逻辑视图名时url的名字

    @RequestMapping("/save2")
    public void saveStudent(Student stu) {
    System.out.println(stu);
    }

    物理视图名是save2.jsp

     

  3. 使用request转向页面

    @RequestMapping("/save2")
    public void saveStudent(Student stu,Map<String, Student> map,HttpServletRequest request,HttpServletResponse response) throws ServletException, IOException {
    System.out.println(stu);
    //map.put("stu", stu);
    request.setAttribute("stu", stu);
    request.getRequestDispatcher("/WEB-INF/pages/success.jsp").forward(request, response);
    }
    • 总结:使用request进行页面的转发是不会经过视图解析器的

  4. 使用response重定向页面

    @RequestMapping("/save2")
    public void saveStudent(Student stu,Map<String, Student> map,HttpServletRequest request,HttpServletResponse response) throws ServletException, IOException {
    System.out.println(stu);
    request.setAttribute("stu", stu);
    response.sendRedirect(request.getContextPath()+"/index.jsp");
    }

    总结:使用重定向进行页面的跳转是不会经过视图解析器的

  5. 使用response获得输出流输出页面内容

    @RequestMapping("/save3")
    public void saveStudent(Student stu,HttpServletRequest request,HttpServletResponse response) throws ServletException, IOException {
    System.out.println(stu);
    response.setCharacterEncoding("utf-8");
    response.setContentType("text/html;charset=utf-8");
    response.getWriter().println(stu);
    }

    总结:通过输出流进行页面内容输出是不会经过视图解析器的

  6. 返回值ModelAndView(重点)--即绑定数据模型,又绑定逻辑视图名

    @RequestMapping("/find")
    public ModelAndView findStudent(Student stu) throws ServletException, IOException {
    ModelAndView mv = new ModelAndView();
    mv.addObject("stu", stu);
    mv.setViewName("success");//绑定逻辑视图名
    return mv;
    }

     

3.重定向和转发

  • 转发

    @RequestMapping("/find2")
    public String findStudent2(Student stu,Model model) throws ServletException, IOException {
    model.addAttribute("stu", stu);
    return "forward:/WEB-INF/pages/success.jsp";
    }

    不经过视图解析器,使用的是同一个request对象
  • 重定向

    @RequestMapping("/find2")
    public String findStudent2(Student stu,Model model) throws ServletException, IOException {
    model.addAttribute("stu", stu);
    return "redirect:/index.jsp";
    }

     

4.ResponseBody响应json数据

  • DispatcherServlet会拦截到所有的资源,导致一个问题就是静态资源(img、css、js)也会被拦截到,从而 不能被使用。解决问题就是需要配置静态资源不进行拦截,在springmvc.xml配置文件添加如下配置

    • mvc:resources标签配置不过滤

      • location元素表示webapp目录下的包下的所有文件

      • mapping元素表示以/static开头的所有请求路径,如/static/a 或者/static/a/b

        <!-- 设置静态资源不过滤 -->
        <mvc:resources location="/css/" mapping="/css/**"/> <!-- 样式 -->
        <mvc:resources location="/images/" mapping="/images/**"/> <!-- 图片 -->
        <mvc:resources location="/js/" mapping="/js/**"/> <!-- javascript -->
  • 使用@RequestBody获取请求体数据

    $(function(){
    $("#btn_send").click(function(){
    $.ajax({
    "url":"student/show",
    "contentType":"application/json;charset=UTF-8",
    "data":JSON.stringify({"id":$("#id").val(),"name":$("#name").val(),"age":$("#age").val(),"address":$("#address").val()}),
    "dataType":"json",
    "type":"post",
    "success":function(data){
    alert(data);
    }

    });
    })
    })
       
       注意点: ajax发送过去的是json格式的字符串,不能直接json对象传递,可以使用JSON.stringify(json对象)来进行转换成字符串

     

  • 使用@RequestBody注解把json的字符串转换成JavaBean的对象

    @RequestMapping("/testJson")
    public void testJson(@RequestBody Student stu) {
    System.out.println(stu);
    }

    注意点:@RequestBody得到请求内容,也就是json字符串,把json类型的数据自动和body内的属性进行值绑定

     

  • 使用@ResponseBody注解把JavaBean对象转换成json字符串,直接响应

    @ResponseBody
    public  Student showStudent(@RequestBody Student stu) {
       return stu;
    }

    @ResponseBody 可以修饰类和修饰方法,修饰类,代表这个类的所有方法都会放回json字符串,全局设置

     

5.json字符串和JavaBean对象互相转换的过程中,需要使用jackson的jar包

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

6.SpringMVC实现文件上传

  1. 导入jar包

    <dependency>
    <groupId>commons-fileupload</groupId>
    <artifactId>commons-fileupload</artifactId>
    <version>1.3.1</version>
    </dependency>
  2. 编写页面

    <form action="user/upload" method="post" enctype="multipart/form-data">
    <input type="file" name="upload">
    <button type="submit" id="btn_send">上传</button>
    </form>
  3. 控制器方法的实现

    package com.hwua.controller;

    import java.io.File;
    import java.io.IOException;
    import java.util.List;
    import java.util.UUID;

    import javax.servlet.http.HttpServletRequest;

    import org.apache.commons.fileupload.FileItem;
    import org.apache.commons.fileupload.FileUploadException;
    import org.apache.commons.fileupload.disk.DiskFileItemFactory;
    import org.apache.commons.fileupload.servlet.ServletFileUpload;
    import org.springframework.stereotype.Controller;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.multipart.MultipartFile;
    import org.springframework.web.servlet.ModelAndView;

    @RequestMapping("/user")
    @Controller

    public class FileController {
    @RequestMapping("/upload")
    public  ModelAndView fileUpload(HttpServletRequest request,MultipartFile upload) {
    ModelAndView mv = new ModelAndView();
    //设置要上传文件的目录
    String path = request.getServletContext().getRealPath("/upload");
    //假如目录不存在,先创建要保存上传文件的目录
    File file = new File(path);
    if(!file.exists()) {
    file.mkdirs();//创建目录
    }
    String fileName = upload.getOriginalFilename();//得到上传文件的名字
    String uuid = UUID.randomUUID().toString().toUpperCase();//得到唯一的一串字符串
    fileName = uuid+"_"+fileName;//拼成唯一的文件名
    try {
    upload.transferTo(new File(file,fileName));
    } catch (IllegalStateException | IOException e) {
    e.printStackTrace();
    mv.addObject("info", "上传失败!");

    }//上传文件
    mv.addObject("info", "上传成功!");
    mv.setViewName("success");
    return mv;
    }
    }

    7.SpringMVC异常处理

    1. 当异常一级级往上抛,到前端控制器DispatcherServlet都不处理的话,那么错误信息就会提交给用户界面,这种界面是不友好的.

    2. 解决方案,一级级往上抛,抛到DispatcherServlet的时候,交给异常处理器对象来统一进行异常处理.最后把异常信息页面转发给用户.

      操作流程:

      1. 自定义一个异常类,用来处理所有抛出的异常

        package com.hwua.exception;

        public class SysErrorException extends Exception {
        private String message;// 保存自定义的异常信息

        public String getMessage() {
        return message;
        }

        public void setMessage(String message) {
        this.message = message;
        }

        public SysErrorException(String message) {
        super();
        this.message = message;
        }
        }
        1. 定义一个异常处理器类

        package com.hwua.exceptionhandler;

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

        import org.springframework.web.servlet.HandlerExceptionResolver;
        import org.springframework.web.servlet.ModelAndView;

        import com.hwua.exception.SysErrorException;

        public class SysErrorExceptionHandler implements HandlerExceptionResolver {

        @Override
        public ModelAndView resolveException(HttpServletRequest request, HttpServletResponse response, Object handler,
        Exception ex) {
        SysErrorException se =null;
        //获取异常类对象
        if(se instanceof SysErrorException) {
        se=(SysErrorException)ex;
        }else {
        se = new SysErrorException("错误,请联系管理员"+ex.getMessage());
        }
        ModelAndView mv = new ModelAndView();
        mv.addObject("msg", se.getMessage());
        mv.setViewName("error");
        return mv;
        }
        }
        1. 配置异常处理器类,只要配置了,那么当前端控制接收到控制层抛出的异常,它就会交给异常处理器来进行统一处理.

        <!--配置一个异常处理器对象  -->
        <bean id="sysErrorExceptionHandler" class="com.hwua.exceptionhandler.SysErrorExceptionHandler"></bean>

        8.SpringMVC拦截器

        1. 什么是拦截器?

          • 就是在调用控制器方法的前后进行预处理的技术.

          • 可以设置多个拦截器,称之为"拦截器链"

        2. 拦截器和过滤器的区别?

          • 过滤器是ServletAPI规范的一部分,没有Servlet规范就不能使用过滤器,web框架底层都依赖Servlet规范,所以都可以使用过滤器

          • 拦截器是SpringMVC框架所独有的.

          • 过滤器可以设置拦截任何请求资源(/*),而拦截器只能拦截控制器方法.

        3. SpringMVC创建拦截器的步骤?

          • 创建一个类去实现HandlerInterceptor接口,并实现接口中的方法

            package com.hwua.interceptor;

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

            import org.springframework.web.servlet.HandlerInterceptor;
            import org.springframework.web.servlet.ModelAndView;

            public class MyInterceptor implements HandlerInterceptor {

            //在控制器方法执行前执行
            @Override
            public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler)
            throws Exception {
            System.out.println("拦截器前置处理....");
            return true;//返回true代表放行,交给控制器方法或后面的拦截器来处理

            }

            //在控制器方法执行后执行
            @Override
            public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler,
            ModelAndView modelAndView) throws Exception {
            System.out.println("拦截器后置处理....");
            }

            //当视图页面最终渲染好以后再执行
            @Override
            public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex)
            throws Exception {
            System.out.println("拦截器最终处理....");
            }
             
            }
          • 在配置文件中进行拦截器的配置

             <!--配置拦截器  -->
               <mvc:interceptors>
                  <mvc:interceptor>
                      <!--设置拦截的请求映射路径  -->
                      <mvc:mapping path="/student/*"/>
                     <!--  <mvc:exclude-mapping path=""/> --><!--设置哪些请求映射路径不拦截  -->
                     <!--注册拦截器对象  -->
                     <bean class="com.hwua.interceptor.MyInterceptor"></bean>
                  </mvc:interceptor>
                 
                  <mvc:interceptor>
                      <!--设置拦截的请求映射路径  -->
                      <mvc:mapping path="/student/*"/>
                     <!--  <mvc:exclude-mapping path=""/> --><!--设置哪些请求映射路径不拦截  -->
                     <!--注册拦截器对象  -->
                     <bean class="com.hwua.interceptor.MyInterceptor2"></bean>
                  </mvc:interceptor>
               </mvc:interceptors>
          • 配置多个拦截器,那么拦截器链中方法的执行顺序是什么样的?

            preHandle: 顺序执行
            postHandle: 逆序执行
            afterCompletion: 逆序执行

             

        //作业,图书增删改查的案例改成SSM整合完成.

        9.SSM整合(MAVEN多模块整合)

        1. 创建一个父项目(pom)用来管理多个子模块,右击父项目创建多个子模块

          <modules>
          <module>Account_domain</module>
          <module>Account_utils</module>
          <module>Account_Dao</module>
          <module>Account_Service</module>
          <module>Account_web</module>
          </modules>

           

           

      2. 父项目统一管理jar包

        <project xmlns="http://maven.apache.org/POM/4.0.0"
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
        <modelVersion>4.0.0</modelVersion>
        <groupId>com.hwua</groupId>
        <artifactId>Account_parent</artifactId>
        <version>0.0.1-SNAPSHOT</version>
        <packaging>pom</packaging>

        <properties>
        <!--版本锁定 -->
        <spring-version>5.1.5.RELEASE</spring-version>
        <mysql-version>8.0.15</mysql-version>
        <c3p0-version>0.9.5.2</c3p0-version>
        <mybatis-version>3.4.6</mybatis-version>
        <slf4j-version>1.7.25</slf4j-version>
        <junit-version>4.12</junit-version>
        <mybatis-spring-version>2.0.0</mybatis-spring-version>
        <aspectJ-version>1.9.4</aspectJ-version>
        <servlet-api-version>3.1.0</servlet-api-version>
        <jsp-version>2.2</jsp-version>
        <jstl-version>1.2</jstl-version>
        <standard-version>1.1.2</standard-version>
        </properties>
        <dependencyManagement>
        <!--管理项目中用到的所有jar包,让子项目去继承,统一项目中使用jar的版本 -->
        <dependencies>
        <!-- https://mvnrepository.com/artifact/mysql/mysql-connector-java -->
        <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>${mysql-version}</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/com.mchange/c3p0 -->
        <dependency>
        <groupId>com.mchange</groupId>
        <artifactId>c3p0</artifactId>
        <version>${c3p0-version}</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.mybatis/mybatis -->
        <dependency>
        <groupId>org.mybatis</groupId>
        <artifactId>mybatis</artifactId>
        <version>${mybatis-version}</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.slf4j/slf4j-log4j12 -->
        <dependency>
        <groupId>org.slf4j</groupId>
        <artifactId>slf4j-log4j12</artifactId>
        <version>${slf4j-version}</version>
        <scope>test</scope>
        </dependency>
        <!-- https://mvnrepository.com/artifact/junit/junit -->
        <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>${junit-version}</version>
        <scope>test</scope>
        </dependency>

        <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>${spring-version}</version>
        </dependency>
        <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-jdbc</artifactId>
        <version>${spring-version}</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.springframework/spring-test -->
        <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-test</artifactId>
        <version>${spring-version}</version>
        <scope>test</scope>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.mybatis/mybatis-spring -->
        <dependency>
        <groupId>org.mybatis</groupId>
        <artifactId>mybatis-spring</artifactId>
        <version>${mybatis-spring-version}</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.springframework/spring-web -->
        <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-web</artifactId>
        <version>${spring-version}</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/org.springframework/spring-webmvc -->
        <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-webmvc</artifactId>
        <version>${spring-version}</version>
        </dependency>

        <!-- https://mvnrepository.com/artifact/org.aspectj/aspectjweaver -->
        <dependency>
        <groupId>org.aspectj</groupId>
        <artifactId>aspectjweaver</artifactId>
        <version>${aspectJ-version}</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/javax.servlet/javax.servlet-api -->
        <dependency>
        <groupId>javax.servlet</groupId>
        <artifactId>javax.servlet-api</artifactId>
        <version>${servlet-api-version}</version>
        <scope>provided</scope>
        </dependency>
        <!-- https://mvnrepository.com/artifact/javax.servlet.jsp/jsp-api -->
        <dependency>
        <groupId>javax.servlet.jsp</groupId>
        <artifactId>jsp-api</artifactId>
        <version>${jsp-version}</version>
        <scope>provided</scope>
        </dependency>

        <!-- https://mvnrepository.com/artifact/javax.servlet/jstl -->
        <dependency>
        <groupId>javax.servlet</groupId>
        <artifactId>jstl</artifactId>
        <version>${jstl-version}</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/taglibs/standard -->
        <dependency>
        <groupId>taglibs</groupId>
        <artifactId>standard</artifactId>
        <version>${standard-version}</version>
        </dependency>
        </dependencies>
        </dependencyManagement>
        <modules>
        <module>Account_domain</module>
        <module>Account_utils</module>
        <module>Account_Dao</module>
        <module>Account_Service</module>
        <module>Account_web</module>
        </modules>
        </project>

         

      3. Spring整合SpringMVC

posted on 2019-07-28 10:13  Pinghu_gary  阅读(100)  评论(0)    收藏  举报

导航