springMVC基础01

1.SpringMVC的基本概念

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

1.SpringMVC 的优势

1、清晰的角色划分：

• 前端控制器（DispatcherServlet）
• 请求到处理器映射（HandlerMapping）
• 处理器适配器（HandlerAdapter）
• 视图解析器（ViewResolver）
• 处理器或页面控制器（Controller）
• 验证器（ Validator）
• 命令对象（Command 请求参数绑定到的对象就叫命令对象）
• 表单对象（Form Object 提供给表单展示和提交到的对象就叫表单对象）。

2.SpringMVC 和 Struts2 的优略分析

共同点：

• 它们都是表现层框架，都是基于 MVC 模型编写的。
• 它们的底层都离不开原始 ServletAPI。
• 它们处理请求的机制都是一个核心控制器。

区别：

• Spring MVC 的入口是 Servlet, 而 Struts2 是 Filter
• Spring MVC 是基于方法设计的，而 Struts2 是基于类，Struts2 每次执行都会创建一个动作类。所以 Spring MVC 会稍微比 Struts2 快些。
• Spring MVC 使用更加简洁,同时还支持 JSR303, 处理 ajax 的请求更方便((JSR303 是一套 JavaBean 参数校验的标准，它定义了很多常用的校验注解，我们可以直接将这些注解加在我们 JavaBean 的属性上面，就可以在需要校验的时候进行校验了。)
• Struts2 的 OGNL 表达式使页面的开发效率相比 Spring MVC 更高些，但执行效率并没有比 JSTL 提升，尤其是 struts2 的表单标签，远没有 html 执行效率高。

3.SpringMVC的前期准备

在SpringMVC需要安装服务器软件Tomcat

在idea中添加Tomcat服务器软件

部署到项目上去

2.SpringMVC入门案例

1.创建工程

2.添加依赖

  <!-- 版本锁定 -->
    <properties>
    <spring.version>5.0.2.RELEASE</spring.version>
</properties>

    <dependencies>

        <!--Spring坐标-->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>${spring.version}</version>
    </dependency>

        <!--Spring的web坐标-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-web</artifactId>
            <version>${spring.version}</version>
        </dependency>

        <!--SpringMVC坐标-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>${spring.version}</version>
        </dependency>

        <!--Servlet坐标-->
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>servlet-api</artifactId>
            <version>2.5</version>
            <scope>provided</scope>
        </dependency>
        
        <!--Jsp坐标-->
        <dependency>
            <groupId>javax.servlet.jsp</groupId>
            <artifactId>jsp-api</artifactId>
            <version>2.0</version>
            <scope>provided</scope>
        </dependency>

    </dependencies>

可能没有src文件，需要等待下载完成
当我们初次创建完工程后，在pom.xml中会出现很多奇怪的东西，暂时不要去管这些
依旧在添加如上依赖

3.在web.xml配置SpringMVC的核心控制器

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>

    <load-on-startup>1</load-on-startup>
    <!-- 配置servlet启动时加载对象 -->
  </servlet>
<!--启动 SpringMVC的核心控制器-->
  <servlet-mapping>
    <servlet-name>dispatcherServlet</servlet-name>
    <!--扫描所有目录-->
    <url-pattern>/</url-pattern>
  </servlet-mapping>

3.编写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="it.cost"></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>

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

• 1.index.jsp

<body>
<h3>入门案例</h3> 
<a href="hello">入门案例</a> 
</body>

• 2.HelloController

/*** 控制器 * @author rt */
@Controller
public class HelloController {
    /*** 接收请求 * @return */
    @RequestMapping(path="/hello")
    public String sayHello() {
        System.out.println("Hello SpringMVC!!");
        return "success";
    }
}

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

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

6.目录结构

6.最终结果

注意：如果我们之间点击下面进行流浏览jsp的话，会直接出现源码

源码：这是因为我们直接通过文件路径访问，而没有通过Tomcat服务器访问所造成的

解决办法：见后面

3.入门案例分析

1.启动服务器时

servlet配置load-on-startup的作用
在servlet的配置当中，1的含义是: 标记容器是否在启动的时候就加载这个servlet。
当值为0或者大于0时，表示容器在应用启动时就加载这个servlet；
当是一个负数时或者没有指定时，则指示容器在该servlet被选择时才加载。
正数的值越小，启动该servlet的优先级越高。

如果我们在web.xml中设置了多个servlet的时候，可以使用load-on-startup来指定servlet的加载顺序，服务器会根据load-on-startup的大小依次对servlet进行初始化。不过即使我们将load-on-startup设置重复也不会出现异常，服务器会自己决定初始化顺序。

2.发送请求，后台处理请求时

全部原理

入门案例中的组件分析

1. 前端控制器（DispatcherServlet）
2. 处理器映射器（HandlerMapping）
3. 处理器（Handler）
4. 处理器适配器（HandlAdapter）
5. 视图解析器（View Resolver）
6. 视图（View）

3. RequestMapping注解

RequestMapping注解可以作用在方法和类上

写在类上，相当于文件夹

写在方法上，相当于文件夹下的文件

所以当我们访问时，如果类上有这一个注解，那么，那么必须加上这个路径

如果
那么

细节：路径可以不编写 / 表示应用的根目录开始
细节：${ pageContext.request.contextPath }也可以省略不写，但是路径上不能写 /

RequestMapping的属性

1. path 指定请求路径的url

2. value value属性和path属性是一样的
   

3. mthod 指定该方法的请求方式
   

当使用的请求方式与设定请求方式不一致时，会报错405

4. params 指定限制请求参数的条件
   

由于params是数组，所以可以要求传递多个参数

5. headers 发送的请求中必须包含的请求头
   

4.请求参数的绑定

1.入门案例

执行的方法

    /*** 绑定参数的方法
     * * @return
     * */
    @RequestMapping(path="/getId")
    public String getUserID(Integer id) {
        System.out.println(id);
        return "success";
    }

提交的表单

<form action="user/getId" method="post">
    <input type="text" name="id" /> <br>
    <input type="submit" value="提交" />
</form>

实现原理

2.基本类型参数

基本类型参数：包括基本类型和 String 类型

实现方法

 /**
     * 基本类型参数：包括基本类型和 String 类型
     *
     * @param name
     * @return
     */
    @RequestMapping(path = "/getId")
    public String getName(String name) {
        System.out.println(name);
        return "success";
    }

提交表单

<form action="user/getId" method="post">
    <input type="text" name="name" /> <br>
    <input type="submit" value="提交" />
</form>

提交结果

上面我们发现使用汉字就乱码

请求参数乱码问题

post 请求方式：

在 web.xml 中配置一个过滤器

<!-- 配置 springMVC 编码过滤器 -->
<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>

<!-- 启动过滤器 --> 
<init-param> 
<param-name>forceEncoding</param-name> 
 <param-value>true</param-value> 
</init-param> 
</filter>

<!-- 过滤所有请求 --> 
<filter-mapping> 
<filter-name>CharacterEncodingFilter</filter-name> 
<url-pattern>/*</url-pattern> 
</filter-mapping>

成功传递汉字参数

get 请求方式：
tomacat 对 GET 和 POST 请求处理方式是不同的，GET 请求的编码问题，要改Tomcat 服务器的 server.xml配置文件，如下：

<Connector connectionTimeout="20000" port="8080"
protocol="HTTP/1.1" redirectPort="8443"/>

改为：

<Connector connectionTimeout="20000" port="8080"
protocol="HTTP/1.1" redirectPort="8443" useBodyEncodingForURI="true"/>

如果遇到 ajax 请求仍然乱码，请把：

useBodyEncodingForURI="true"改为 URIEncoding="UTF-8"

3.自定义类型参数

自定义一个user类(一定要添加get和set方法)

通过get和set方法绑定参数

万一传递的是一个类中类怎么办呢？

实现代码

被绑定对象

public class user {

    private String name;
    private Integer age;
    private String sex;

    private Account account;
    一定要添加set方法
    .........略

控制器

@Controller
public class testController {

    @RequestMapping(value = {"/getuser"})
    public String getUser(user user){
        System.out.println(user);
        return "success";
    }
}

表单

<form action="getuser" method="post">
    姓名： <input type="text" name="name" /> <br>
    年龄： <input type="text" name="age" /> <br>
    性别： <input type="text" name="sex" /> <br>
    ID： <input type="text" name="account.id" /> <br>
    称谓： <input type="text" name="account.name" /> <br>
    <input type="submit" value="提交" />
</form>

实现结果

4.数组和集合类型参数

我们用的实体对象已经写好了

关键是jsp页面该怎么传递参数

public class user {

    private List<String> names;

    private List<Account> users;

    private Map<String,Account> map;
    .............

jsp页面

 List< String >： <input type="text" name="names[0]" /> <br>

    List< Account >: <input type="text" name="users[0].id" /> <br>
    List< Account >: <input type="text" name="users[0].name" /> <br>

    Map< String,Account>01: <input type="text" name="map['one'].id" /> <br>
    Map< String,Account>01: <input type="text" name="map['one'].name" /> <br>

    Map< String,Account>02: <input type="text" name="map['two'].id" /> <br>
    Map< String,Account>02: <input type="text" name="map['two'].name" /> <br>

页面分析

其实观察上面，还是在通过打. 的方式往下一层一层找元素，只不过集合多了个索引而已

详细查看之前的mybatis框架中的OGNL表达式

5.自定义类型转换器

在前面的代码中，我们从jsp网页获取的都是字符串类型，但是，当我们封装到实体对象时，却是Integer类型，这是因为SpringMVC框架已经帮我们转换好了。

在SpringMVC框架，已经把我们常用的一些自动转换了，但是偶尔需要我们自己定义一些类型转换

SpringMVC自动转换

向上面这个日期格式，SpringMVC已经帮我们转换好了，那要是输入格式为2020-12-21这种格式该怎么办呢？

这就需要我们定义一个自定义转换器(类)，该类需要去实现Converter<S, T>怎么一个接口，K代表要转换的string类型，V代表转换出的类型结果

实现步骤
第一步：定义一个类，实现Converter接口

/**
 * 自定义类型转换器
 */
public class testCon implements Converter<String, Date> {
    /**
     * 用于把 String 类型转成日期类型
     * @param s
     * @return
     */
    @Override
    public Date convert(String s) {
        DateFormat format = null;
        try {
            if(StringUtils.isEmpty(s)) {
                throw new NullPointerException("请输入要转换的日期");
            }
            format = new SimpleDateFormat("yyyy-MM-dd");
            Date date = format.parse(s);
            return date;
        } catch (Exception e) {
            throw new RuntimeException("输入日期有误");
        }
    }
}

第二步：在 spring 配置文件中配置类型转换器

 <!-- 配置类型转换器工厂 -->
    <bean id="converterService" class="org.springframework.context.support.ConversionServiceFactoryBean">
    <!-- 给工厂注入一个新的类型转换器 -->
    <property name="converters">
        <array>
            <!-- 配置自定义类型转换器 -->
            <bean class="it.rose.testCon"></bean>
        </array>
    </property>
</bean>

第三步：在 annotation-driven 标签中引用配置的类型转换服务

<!-- 引用自定义类型转换器 --> 
<mvc:annotation-driven conversion-service="converterService"></mvc:annotation-driven>

6.获得ServletAPI参数

在前面的Javaweb中，我们学习了HttpServletRequest ，HttpServletResponse，HttpSession等一系列参数，那么在框架中，我们怎么获取呢？

要获取谁，就在请求方法的参数中，定义谁

 /**
     * 测试访问 testServletAPI
     * @param request
     * @param response
     * @param session
     * @return
     */
    @RequestMapping("/testServletAPI")
    public String testServletAPI(HttpServletRequest request,
                                 HttpServletResponse response,
                                 HttpSession session) {
        System.out.println(request);
        System.out.println(response);
        System.out.println(session);
        return "success"; }

测试结果

5. 常用注解

1.RequestParam

使用说明

• 作用：
  把请求中指定名称的参数给控制器中的形参赋值()
• 属性：
  value：请求参数中的名称。
  required：请求参数中是否必须提供此参数。默认值：true。表示必须提供，如果不提供将报错。

说人话：就是当提交的参数名称与请求的参数名称不一致时，在中间取个名字

一般情况
当我们使用RequestParam注解

2.RequestBody

使用说明

• 作用：
  用于获取请求体内容。直接使用得到是 key=value&key=value…结构的数据。
  get 请求方式不适用。
• 属性：
  required：是否必须有请求体。默认值是:true。当取值为 true 时,get 请求方式会报错。如果取值为 false，get 请求得到是 null。

这个注解，就是获取一段key=value&key=value…结构的字符串数据(中文不行)

RequestBody注解

 /**
     * RequestBody 注解
     * @param body
     * @return
     */
    @RequestMapping("/useRequestBody")
    public String useRequestBody(@RequestBody(required=false) String body){
        System.out.println(body);
        return "success"; 
    }

from表单

<form action="U1/useRequestBody" method="post">
    用户名称：<input type="text" name="username" ><br/>
    用户密码：<input type="password" name="password" ><br/>
    用户年龄：<input type="text" name="age" ><br/>
    <input type="submit" value="保存">
</form>

3.PathVaribale

使用说明

• 作用：
  用于绑定 url 中的占位符。例如：请求 url 中 /delete/{id}，这个{id}就是 url 占位符。
  url 支持占位符是 spring3.0 之后加入的。是 springmvc 支持 rest 风格 URL 的一个重要标志。
• 属性：
  value：用于指定 url 中占位符名称。
  required：是否必须提供占位符。

jsp代码

<!-- PathVariable 注解 -->
<a href="U1/usePathVariable/100">pathVariable 注解</a>
</body>

控制器代码

@RequestMapping("/usePathVariable/{id}")
    public String usePathVariable(@PathVariable("id") Integer id){
        System.out.println(id);
        return "success"; 
    }

代码分析

4.RequestHeader

使用说明

• 作用：
  用于获取请求消息头。
• 属性：
  value：提供消息头名称
  required：是否必须有此消息头

注：在实际开发中一般不怎么用。

jsp 中代码

<!-- RequestHeader 注解 -->
 <a href="U1/useRequestHeader">获取请求消息头</a>

控制器中代码

/**
* RequestHeader 注解
* @param user
* @return
*/
@RequestMapping("/useRequestHeader")
public String useRequestHeader(@RequestHeader(value="Accept-Language",required=false)String requestHeader){
System.out.println(requestHeader);
return "success"; 
}

5.CookieValue

使用说明

• 作用：
  用于把指定 cookie 名称的值传入控制器方法参数。
• 属性：
  value：指定 cookie 的名称。
  required：是否必须有此 cookie，没有的话不让执行该方法

jsp 中的代码

<!-- CookieValue 注解 --> 
<a href="U1/useCookieValue">绑定 cookie 的值</a>

控制器中的代码

/**
* Cookie 注解注解
* @param user
* @return
*/
@RequestMapping("/useCookieValue")
public String useCookieValue(@CookieValue(value="JSESSIONID",required=false) String cookieValue){
System.out.println(cookieValue);
return "success"; }

测试结果

6.ModelAttribute

使用说明

• 作用：
  该注解是 SpringMVC4.3 版本以后新加入的。它可以用于修饰方法和参数。
  出现在方法上：表示当前方法会在控制器的方法执行之前，先执行。它可以修饰没有返回值的方法，也可以修饰有具体返回值的方法。
  出现在参数：上获取指定的数据给参数赋值。
• 属性：
  value：用于获取数据的 key。key 可以是 POJO 的属性名称，也可以是 map 结构的 key。
• 应用场景：
  当表单提交数据不是完整的实体类数据时，保证没有提交数据的字段使用数据库对象原来的数据。
  例如：我们在编辑一个用户时，用户有一个创建信息字段，该字段的值是不允许被修改的。在提交表单数据是肯定没有此字段的内容，一旦更新会把该字段内容置为null，此时就可以使用此注解解决问题。

ModelAttribute 修饰方法带返回值

需求：
修改用户信息，要求用户的密码不能修改

jsp 的代码

<!-- 修改用户信息 --> 
<form action="U1/testModelAttribute" method="post">
    用户名称：<input type="text" name="name" ><br/>
    用户年龄：<input type="text" name="id" ><br/>
    <input type="submit" value="保存">
</form>

控制的代码

 /**
     * 表示当前方法会在控制器的方法执行之前，先执行。
      * @param
     * @return
     */
    @ModelAttribute
    public User showModel(String name) {
        User user = new User();
        user.setName("小明");
        user.setId(12);
        user.setBirthday(new Date());
        //模拟去数据库查询
        if(user.getName().equals(name)){
            return user;
        }
        else {
            System.out.println("查询数据不存在");
            return null;
        }
    }

 /**
     * 接收请求的方法
     * @param user
     * @return
     */
    @RequestMapping("/testModelAttribute")
    public String testModelAttribute(User user) {
        System.out.println(user);
        return "success"; 
        }

被ModelAttribute注解修饰的方法，会先于控制器执行，相当于预处理，过滤器等功能

当表单提交数据不是完整的实体类数据时，保证没有提交数据的字段使用数据库对象原来的数据。

ModelAttribute 修饰方法不带返回值

jsp 的代码不变
控制的代码

    /**
     * 接收请求的方法
     * @param user
     * @return
     */
    @RequestMapping("/testModelAttribute")
    public String testModelAttribute(@ModelAttribute("abc")User user) {
        System.out.println(user);
        return "success";
    }

    @ModelAttribute
    public void showModel(String name, Map<String,User> map) {
        User user = new User();
        user.setName("小明");
        user.setId(12);
        user.setBirthday(new Date());
        //模拟去数据库查询
        if(user.getName().equals(name)){
            map.put("abc",user);
        }
        else {
            System.out.println("查询数据不存在");
        }
    }

7.SessionAttribute

使用说明

• 作用：
  用于把指定 cookie 名称的值传入控制器方法参数。
• 属性：
  value：指定 cookie 的名称。
  required：是否必须有此 cookie，没有的话不让执行该方法

jsp 中的代码

<!-- SessionAttribute 注解的使用 -->
<a href="U1/testPut">存入 SessionAttribute</a> <hr/>
<a href="U1/testGet">取出 SessionAttribute</a> <hr/>
<a href="U1/testClean">清除 SessionAttribute</a>

控制器中的代码

@Controller
@RequestMapping(value = {"/U1"})
@SessionAttributes(value ={"username","password"},types={Integer.class})
public class testConverter {

    /**
     * 把数据存入 SessionAttribute
     *
     * @param model
     * @return Model 是 spring 提供的一个接口，该接口有一个实现类 ExtendedModelMap
     * 该类继承了 ModelMap，而 ModelMap 就是 LinkedHashMap 子类
     * 往该类中存东西，底层会往request域对象中存数据
     */
    @RequestMapping("/testPut")
    public String testPut(Model model) {
        //往集合中储存元素
        //往该类中存东西，底层会往request域对象中存数据
        model.addAttribute("username", "泰斯特");
        model.addAttribute("password", "123456");
        model.addAttribute("age", 31);
        return "success";
    }

    /**
     *ModelMap对象，是Model接口的实现类
     *
     * @param model
     * @return
     */
    @RequestMapping("/testGet")
    public String testGet(ModelMap model){
        //在控制台中打印数据
        //从Model集合中取东西，底层会从request域对象中取出数据
        System.out.println(model.get("username")+";"+model.get("password")+";"+model.get("age"));
        return "success";
        //我们通过添加SessionAttributes注解，会往Session域中添加数据
    }

    /**
     * SessionStatus对象，表示当前Session状态的一个对象
     *通过setComplete方法，关闭Session域
     * @param sessionStatus
     * @return
     */
    @RequestMapping("/testClean")
    public String complete(SessionStatus sessionStatus){
        sessionStatus.setComplete();
        return "success";
    }
}

Model接口：Model 是 spring 提供的一个接口，这个接口的实现类可以往request请求中存入我们要存入的数据

ModelMap类：ModelMap类也是Model接口的一个实现类

代码分析