SpringMVC入门篇

SpringMVC入门篇

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Etu6SuMp-1634306503064)(http://blog.strivesong.cn/blogsrc=http%253A%252F%252Foscimg.oschina.net%252Foscnet%252F2bcbb8972c60e42cabed82ec5c134df19cf.png&refer=http%253A%252F%252Foscimg.oschina.net&app=2002&size=f9999,10000&q=a80&n=0&g=0n&fmt=jpeg)]

第一章

1. 三层架构

   1. 我们开发服务端程序，一般基于两种形式，一种C/S架构，一种B/S架构程序
      • C/S架构：客服端和服务器结构
      • B/S架构：浏览器和服务器结构
      • 区别：Client/Server一般是建立在局域网的基础上的。Browser/Server是建立在广域网的基础上的。
   2. 使用Java语言基本上都是开发B/S架构程序，
   3. 三层架构
      • 表现层：web层，用来和客服端进行数据交互的，表现层一般会采用MVC的设计模型
      • 业务层：处理系统具体的业务逻辑
      • 持久层：用来操作数据库的

2. MVC模型

   • MVC全称Model View Controller模型视图控制器，每部分各司其职。
   • Model:数据模型，JavaBean类，用来进行数据封装。
   • View：指JSP、HTML用来展示数据给用户。
   • Controller:用来接收用户的请求，整个流程的控制器，用来进行数据校验等。

   第二章 SpringMVC入门案例

3. SpringMVC的概述

   1. 是一种基于Java实现MVC设计模型的请求驱动类型的轻量机WEB框架。
   2. SpringMVC属于SpringFrameWork的后续产品，已经融合在Spring Web Flow里面。Spring框架提供了构建web应用程序的全功能MVC模块。
   3. 使用Spring可插入的MVC架构，从而在使用Spring进行Web开发时，可以选择Spring的SpringMVC框架或集成其他的MVC开发框架，如Struts2等。

4. SpringMVC在三层架构中的位置

   1. 表现层框架
   2. SpringMVC的优势
   3. SpringMVC和Struts2框架对比

5. SpringMVC的入门程序

   1. 创建Web工程，引入jar包

      

   2. 具体如下：

      <!-- 版本锁定 --> 
      <properties> 
          <spring.version>5.0.2.RELEASE</spring.version> 
      </properties> 
      <dependencies> 
          <dependency> 
              <groupId>org.springframework</groupId> 
              <artifactId>spring-context</artifactId> 
              <version>${spring.version}</version> 
          </dependency> 
          <dependency> 
              <groupId>org.springframework</groupId> 
              <artifactId>spring-web</artifactId> 
              <version>${spring.version}</version> 
          </dependency> 
          <dependency> 
              <groupId>org.springframework</groupId> 
              <artifactId>spring-webmvc</artifactId> 
              <version>${spring.version}</version> 
          </dependency> 
          <dependency> 
              <groupId>javax.servlet</groupId> 
              <artifactId>servlet-api</artifactId> 
              <version>2.5</version> 
              <scope>provided</scope> 
          </dependency> 
          <dependency> 
              <groupId>javax.servlet.jsp</groupId> 
              <artifactId>jsp-api</artifactId> 
              <version>2.0</version> 
              <scope>provided</scope> 
          </dependency> 
      </dependencies>
      

      3. 配置核心的控制器（配置DispatcherServlet）

         1. 在web.xml配置文件中核心控制器DispatcherServlet

            <!-- SpringMVC的核心控制器 --> 
            <servlet> 
                <servlet-name>dispatcherServlet</servlet-name> 
                <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet- class> 
                <!-- 配置Servlet的初始化参数，读取springmvc的配置文件，创建spring容器 --> 
                <init-param>
                    <param-name>contextConfigLocation</param-name> 
                    <param-value>classpath:springmvc.xml</param-value> 
                </init-param> 
                <!-- 配置servlet启动时加载对象 --> 
                <load-on-startup>1</load-on-startup> 
            </servlet> 
            <servlet-mapping> 
                <servlet-name>dispatcherServlet</servlet-name> 
                <url-pattern>/</url-pattern> 
            </servlet-mapping>
            

         2. 编写springmvc.xml的配置文件

            <?xml version="1.0" encoding="UTF-8"?> 
            <beans xmlns="http://www.springframework.org/schema/beans" 		 
                   xmlns:mvc="http://www.springframework.org/schema/mvc" 
                   xmlns:context="http://www.springframework.org/schema/context" 
                   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 
                                       http://www.springframework.org/schema/mvc 
                                       http://www.springframework.org/schema/mvc/spring-mvc.xsd 
                                       http://www.springframework.org/schema/context 
                                       http://www.springframework.org/schema/context/spring-context.xsd"> <!-- 配置spring创建容器时要扫描的包 --> 
                <context:component-scan base-package="com.itheima"></context:component-scan> 
                <!-- 配置视图解析器 --> 
                <bean id="viewResolver"
                      class="org.springframework.web.servlet.view.InternalResourceViewResolver"> 
                    <property name="prefix" value="/WEB-INF/pages/"></property> 
                    <property name="suffix" value=".jsp"></property> 
                </bean> 
                <!-- 配置spring开启注解mvc的支持 <mvc:annotation-driven></mvc:annotation-driven>--> 
            </beans>	
            

6. 编写index.jsp和HelloController控制器类

   1. index.jsp

      <body>
          <h3>入门案例</h3> 
          <a href="${ pageContext.request.contextPath }/hello">入门案例</a> 
      </body>
      

   2. HelloController

      package cn.itcast.controller; 
      import org.springframework.stereotype.Controller; 
      import org.springframework.web.bind.annotation.RequestMapping; 
      /**
      * 控制器 
      * @author rt 
      */ 
      @Controller 
      public class HelloController { 
          /**
          * 接收请求 
          * @return 
          */ 
          @RequestMapping(path="/hello") 
          public String sayHello() { 
              System.out.println("Hello SpringMVC!!"); 
              return "success"; 
          } 
      }
      

7. 在WEB-INF目录下创建pages文件夹，编写success.jsp的成功页面

   <body>
       <h3>入门成功！！</h3> 
   </body>
   

8. 启动Tomcat服务器，进行测试

第三章

1. 入门案例的执行流程

   1. 当启动Tomcat服务器的时候，因为配置了load-on-startup标签，所以会创建DispatcherServlet对象，就会加载springmvc.xml配置文件

   2. 开启了注解扫描，那么HelloController对象就会被创建

   3. 从index.jsp发送请求，请求会先到达DispatcherServlet核心控制器，根据配置@RequestMapping注解找到执行的具体方法。

   4. 根据执行方法的返回值，再根据配置的视图解析器，去指定的目录下查找指定名称的JSP文件。

   5. Tomcat服务器渲染页面，做出响应

2. SpringMVC官方提供图形

3. 入门案例中的组件分析

   1. 前端控制器（DispatcherServlet）

   2. 处理器映射器（HandlerMapping）

   3. 处理器（Handler）

   4. 处理器适配器（HandlAdapter）

   5. 视图解析器（View Resolver）

   6. 视图（View）

4. RequestMapping注解

   1. RequestMapping注解的作用是建立请求URL和处理方法之间的对应关系
   2. RequestMapping注解可以作用在方法和类上
      • 作用在类上：第一级访问目录
      • 作用在方法上：第二级的访问目录
      • 细节：路径可以不编写/表示应用的根目录开始
      • 细节：${pageContext.request.contextPath}也可以省略不写，但是路径不能写 /
   3. RequestMapping的属性
      • path 指定请求路径的URL
      • value value属性和path的属性是一样的
      • mthod 指定该方法的请求方式
      • params 指定限定请求参数条件
      • headers 发送请求中必须包含的请求头

   第三章 请求参数的绑定

   1. 请求参数的绑定说明

      • 绑定机制
        1. 表单提交的数据都是key=value格式式 username=haha&password=123
        2. SpringMVC的参数绑定过程是把表单提交的请求参数，作为控制器中方法的参数进行绑定的
        3. 要求：提交表单的name和参数的名称是相同的
      • 支持的数据类型
        1. 基本数据类型和字符串的类型
        2. 实体类型（JavaBean）
        3. 集合数据类型（List、Map集合等）

   2. 基本数据类型和字符类型

      • 提交表单name和参数的名称是相同的
      • 区分大小写

   3. 实体类型（JavaBean）

      • 提交表单name和JavaBean中的属性需要一致

      • 如果一个JavaBean类中包含其他的引用类型，那么表单的name属于需要编写成：对象、属性。例如：

        address.name
        

   4. 给属性集合数据封装

      • JSP页面编写方式：list[0].属性

   5. 请求参数中中文乱码的解决

      • 在web.xml中配置Spring提供的过滤类

        <!-- 配置过滤器，解决中文乱码的问题 --> 
        <filter> 
            <filter-name>characterEncodingFilter</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>characterEncodingFilter</filter-name> 
            <url-pattern>/*</url-pattern> 
        </filter-mapping>
        

   6. 自定义类型的转换器

      • 表单提交的任何数据类型全部都是字符串类型，但是后台定义integer类型，数据也可以封装上，说明Spring框架内部会默认进行数据类型转换

      • 如果想自定义数据类型转换，可以实现Converter的接口

        1. 自定义类型转换

           package cn.itcast.utils; 
           import java.text.DateFormat; 
           import java.text.SimpleDateFormat; 
           import java.util.Date; 
           import org.springframework.core.convert.converter.Converter; 
           /**
           * 把字符串转换成日期的转换器 
           * @author rt 
           */ 
           public class StringToDateConverter implements Converter<String, Date>{ 
               /**
               * 进行类型转换的方法 
               */ 
               public Date convert(String source) { 
                   // 判断 
                   if(source == null) { 
                       throw new RuntimeException("参数不能为空"); 
                   }
           		try {
                       DateFormat df = new SimpleDateFormat("yyyy-MM-dd"); 
                       // 解析字符串 
                       Date date = df.parse(source); 
                       return date; 
                   } catch (Exception e) { 
                       throw new RuntimeException("类型转换错误"); 
                   } 
               } 
           }
           

        2. 注册自定义类型转换器，在springmvc.xml配置文件中编写配置

           <!-- 注册自定义类型转换器 --> 
           <bean id="conversionService" class="org.springframework.context.support.ConversionServiceFactoryBean"> 
               <property name="converters"> 
                   <set>
                       <bean class="cn.itcast.utils.StringToDateConverter"/> 
                   </set> 
               </property> 
           </bean> 
           <!-- 开启Spring对MVC注解的支持 --> 
           <mvc:annotation-driven conversion-service="conversionService"/>
           

5. 在控制器中使用原生的ServletAPI对象

   • 只需要在控制器的方法参数定义HttpServletRequest和HttpServletResponse对象

第四章

1. RequestParam注解

   • 作用：把请求中的指定名称的参数传递给控制器中的形参赋值

   • 属性

     1. value :请求参数中的名称

     2. required：请求参数中必须提供此参数，默认值是true。必须提供

     3. 代码如下

        /**
        * 接收请求 
        * @return 
        */ 
        @RequestMapping(path="/hello") 
        public String sayHello(@RequestParam(value="username",required=false)String name) { 
            System.out.println("aaaa"); 
            System.out.println(name); 
            return "success"; 
        }
        

2. RequestBody注解

   • 作用：用于获取请求的内容（注意：get方式不可以）

   • 属性:required:是否必须有请求，默认值是true

   • 代码如下：

     /**
     * 接收请求 
     * @return 
     */ 
     @RequestMapping(path="/hello") 
     public String sayHello(@RequestBody String body) { 
         System.out.println("aaaa"); 
         System.out.println(body);
         return "success"; 
     }
     

3. PathVariable注解

   • 作用：拥有绑定url中的占位符的。例如：url中有/delete/{id}，{id}就是占位符

   • 属性：value指定url中的占我符名称

   • Restful风格的URL

     1. 请求路径一样，可以格局不同请求方式去执行后台的不同方法

     2. Restful风格的URL特点

        • 结构清晰
        • 符合标准
        • 易于理解
        • 扩展方便

     3. 代码如下

        	<a href="user/hello/1">入门案例</a> 
            /**
            * 接收请求 
            * @return 
            */ 
            @RequestMapping(path="/hello/{id}") 
            public String sayHello(@PathVariable(value="id") String id) { 
            System.out.println(id); 
            return "success"; 
        	}
        

4. SessionAttributes注解

   • 作用：用于多次执行控制器方法间的参数共享

   • 属性： value指定存入属性的名称

   • 代码如下：

     @Controller 
     @RequestMapping(path="/user") 
     @SessionAttributes(value= {"username","password","age"},types= {String.class,Integer.class}) 
     // 把数据存入到session域对象中 
     public class HelloController { 
         /**
         * 向session中存入值 
         * @return 
         */ 
         @RequestMapping(path="/save") 
         public String save(Model model) { 
             System.out.println("向session域中保存数据"); 
             model.addAttribute("username", "root"); 
             model.addAttribute("password", "123"); 
             model.addAttribute("age", 20); 
             return "success"; }
         /**
         * 从session中获取值
         * @return
         */ 
         @RequestMapping(path="/find") 
         public String find(ModelMap modelMap) { 
             String username = (String) modelMap.get("username"); 
             String password = (String) modelMap.get("password"); 
             Integer age = (Integer) modelMap.get("age"); 
             System.out.println(username + " : "+password +" : "+age); 
             return "success"; 
         }
         /**
         * 清除值 
         * @return 
         */ 
         @RequestMapping(path="/delete") 
         public String delete(SessionStatus status) {
             status.setComplete(); 
             return "success"; 
         } 
     }
     
     

总结

1. SpringMVC的概述

2. 入门

   • 创建工程，导入坐标
   • 在web.xml中配置前端控制器（启动服务器，加载springmvc.xml配置文件）
   • 编写springmvc.xml配置文件
   • 编写index.jsp的页面，发送请求
   • 编写Controller类，编写方法（@RequestMapping(path="/hello")），处理请求
   • 编写配置文件（开启注解扫描），配置视图解析器
   • 执行的流程
   • @RequestMapping注解
     1. path
     2. value
     3. method
     4. …

3. 参数绑定

   • 参数绑定必须会
   • 解决中文乱码，配置过滤器
   • 自定义数据类型转换器