1.springMVC的基本概念

1.1三层架构

在这里插入图片描述

1.2MVC模型

2.springMVC的入门

2.1springmvc是什么？

是由java实现MVC设计模型的请求驱动类型的轻量级的web框架

2.2springMVC的优势

1.清晰的角色划分
1. 前端控制器
2. 请求到处理映射
3. 处理器适配器
4. 视图解析器
5. 处理器或页面控制器
6. 验证器
7. 命令对象
8. 表单对象
2.分工明确，扩展点相当灵活
3.和spring框架无缝集成
4.命令对象就是一个pojo，无需继承框架特定api，可以使用命令对象直接作为业务对象
5.强大的jsp标签库，使jsp编写更加容易
5.restful编程风格的支持

2.3springmvc和struts2的优略分析

共同点：
- 表现层框架，基于mvc设计模型编写
- 底层离不开servletAPI
- 处理请求的机制都是一个核心控制器
区别：
- springmvc的入口是servlet，struts的入口是filter
- springMVc是基于方法设计的（单例的），而struts2是基于类设计的（多利对象）
- springmvc的代码更加简洁，处理ajax的请求更加方便
- Struts2的OGNL表达式使页面的开发效率比springmvc高，但执行效率没有JSTL高

2.4springmvc的入门

需求：
在这里插入图片描述

2.4.1启动服务器，加载一些配置文件

创建DispatcherServlet对象
springmvcxml文件加载
创建表现层类的对象（单例）

2.4.2发送http请求，后台处理请求

创建具有超链接的页面

配置了

<mvc:annotstion-driven/>

注解之后就相当于配置了处理器适配器和处理器映射器组件

springmvc的三大组件：

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

2.5requestMapping注解

作用：用于建立请求url和处理请求方法之间的对应关系

属性：

value：映射路径
path：映射路径
method:方法的请求方式
params:用于指定限制请求参数的条件，指定参数名或者值必须相等
header:用于指定限制请求消息头的条件

2.6配置步骤：

第一步：添加坐标

<!--配置版本锁定-->
<properties>
	<spring-version>5.0.2.RELEASE</spring-version>
</properties>
<!--配置与spring和springmvc相关的坐标-->
<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>org.mortbay.jetty</groupId>
            <artifactId>servlet-api</artifactId>
            <version>2.5-20081211</version>
        </dependency>
        <dependency>
            <groupId>javax.servlet.jsp</groupId>
            <artifactId>jsp-api</artifactId>
            <version>2.0</version>
        </dependency>
    </dependencies>

第二步：添加index和success的jsp页面

第三步：在web.xml中配置前端控制器

    <!--配置前端控制器，也就是servlet-->
    <servlet>
        <servlet-name>dispatcherServlet</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    </servlet>
    <servlet-mapping>
        <servlet-name>dispatcherServlet</servlet-name>
        <!--    发送任何请求都会经过前端控制器-->
        <url-pattern>/</url-pattern>
    </servlet-mapping>

第四步：创建controller类

@Controller
public class HelloController {
    
    

    @RequestMapping(path = "/hello")
    public String sayHello() {
    
    
        System.out.println("入门成功！");
        //如果要默认返回success页面，还需要对视图解析器进行配置，视图解析器在springmvc自己的配置文件中
        return "success";
    }
}

第五步：继续配置web.xml中的前端控制器中的内容（向里面加）

<!DOCTYPE web-app PUBLIC
        "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
        "http://java.sun.com/dtd/web-app_2_3.dtd" >

<web-app>
    <display-name>Archetype Created Web Application</display-name>
    <!--配置前端控制器，也就是servlet-->
    <servlet>
        <servlet-name>dispatcherServlet</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <!--      配置初始化参数-->
        <init-param>
            <!--        加载springmvc的配置文件类路径-->
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:springmvc.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>
</web-app>

第六步：创建springmvc的配置文件

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

    <!--    1.配置要扫描的包-->
    <context:component-scan base-package="com.itblp"></context:component-scan>

    <!--    2.配置视图解析器-->
    <bean id="internalResourceViewResolver" class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <!--文件所在目录-->
        <property name="prefix" value="/WEB-INF/pages/"></property>
        <!--文件的后缀-->
        <property name="suffix" value=".jsp"></property>
    </bean>

    <!--springmvc的三大组件为：处理器映射器，处理器适配器，视图解析器-->
    <!--    开启springmvc注解的扫描:开启整个扫描就相当于已经配置了处理器映射器，处理器适配器-->
    <mvc:annotation-driven/>
</beans>

第七步：编写index.jsp中的内容：

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
    <h1>springmvc</h1>
    <a href="hello">入门咯</a>
</body>
</html>

第八步：配置tomcat

第九步：启动

3.请求参数的绑定（重要）

3.1参数绑定

3.1.1绑定url

*只要方法参数列表中的参数与请求参数的变量名是相同的，mvc框架就可以实现自动绑定

username=hehe&password=123

MVC框架： submit(String username,String password)  
    	只要方法参数列表中的参数与请求参数的变量名是相同的，mvc框架就可以实现自动绑定

第一步：创建param.jsp

<a href="login/logins?username=123&password=123"></a>

第二步：创建ParamController

//请求参数绑定
@Controller
@RequestMapping("/login")
public class ParamController{
    
    
    
    @RequestMapping("/logins")
    public String login(String username,String password){
    
    
        System.out.println(username+"---->"+password);
        renturn "success";
    }
}

3.1.2绑定javaBean

*表单中name和javabean中属性名相同

第一步：编写Account实体类

public class Account implements Serializable{
    
    
	private String usernam;
	private String password;
	private Double money;
	 public void setUsername(String username) {
    
    
        this.username = username;
    }

    public String getPassword() {
    
    
        return password;
    }

    public void setPassword(String password) {
    
    
        this.password = password;
    }

    public Double getMoney() {
    
    
        return money;
    }

    public void setMoney(Double money) {
    
    
        this.money = money;
    }
}

第二步：编写jsp：name标签的值要和javabean中的属性相同

javabean参数绑定
<form action="login/saveAccount" method="post">
    姓名：<input type="text" name="username"></br>
    密码：<input type="password" name="password"></br>
    金额：<input type="text" name="money"></br>
    <input type="submit" value="提交">
</form>

第三步：编写controller中的方法：

@RequestMapping(path = "/saveAccount")
public String saveAccount(Account account){
    
    
    System.out.println(account.toString());
    return "success";
}

如果javabean中包含引用类型

实体类简写

public class Account implements Serializable{
    
    
	private String usernam;
	private String password;
	private Double money;
    private User user;
    //……………所有属性的get和set方法

【注意】：引用类型要有get和set方法,因为springmvc是根据实体类中的set方法封装的

jsp:

<%--javabean中的引用类型参数绑定--%>
<form action="login/saveAccount" method="post">
    姓名：<input type="text" name="username"></br>
    密码：<input type="password" name="password"></br>
    金额：<input type="text" name="money"></br>
    用户名：<input type="text" name="user.uname"></br>
    年龄：<input type="text" name="user.age"></br>
    <input type="submit" value="提交">
</form>

使用属性打点调用属性名

3.2支持的数据类型

基本类型和字符串类型
实体类型（javabean）
集合数据类型（List,map集合等）

3.3配置解决乱码的过滤器

在web.xml中配置过滤器

<!--配置解决中文乱码的过滤器-->
    <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>

3.4封装集合类型

//实体类
public class Account {
    
    
    private Integer id;
    private String name;
    private String password;
//  绑定集合对象参数
    List<User> users;
    Map<String,User> userMap;
    //省略get和set方法
}

*jsp页面

<%--绑定集合类型的参数--%>
<form method="post" action="param/welcome">
    账户id：<input type="text" name="id"></br>
    账户名：<input type="text" name="name"></br>
    账户密码：<input type="password" name="password"></br>

	<!--将user对象存入list集合中-->
    用户姓名：<input type="text" name="users[0].username"></br>
    用户性别：<input type="text" name="users[0].usersex"></br>

	<!--将user对象存入map中-->
    用户姓名：<input type="text" name="userMap['one'].username"></br>
    用户性别：<input type="text" name="userMap['one'].usersex"></br>
    <input type="submit" value="提交">
</form>

controller

	@RequestMapping("/welcome")
    public String welcome(Account account) {
    
    
        System.out.println(account);
        return "welcome";
    }

3.5特殊情况：自定义类型转换器

第一步.创建类实现converter接口

public class StringToDateConverter implements Converter<String,Date>{
    
    
    @Override
    public Date convert(String s) {
    
    
        //判断字符串是否有效
        if(s == null){
    
    
            throw new RunTimeException("字符串有误");
        }
        try{
    
    
            DateFormate df = new SimpleDateFormate("yyyy-MM-dd");
            return df.parse(s);
        }catch(Exctption e){
    
    
            throw new RunTimeException("转换异常");
        }        
    }
}

第二步：配置springmvc文件

<!--自定义类型转换器-->
<bean id="conversionServiceFactoryBean" class="org.springframework.context.support.ConversionServiceFactoryBean">
        <property name="converters">
            <set>
                <bean class="com.itblp.utils.StringToDateConverter"></bean>
            </set>
        </property>
    </bean>

<!--在driven中注册自定义类型转换器-->
<mvc:annotation-driven conversion-service="conversionServiceFactoryBean"/>

3.6获取原生的servletAPI

直接在controller层中调用变量即可

@RequestMapping("/welcome")
public String welcome(HttpServletRequest request,HttpServletResponse response){
    
    
     System.out.println(request);
        HttpSession session = request.getSession();
        System.out.println(session);

        ServletContext servletContext = session.getServletContext();
        System.out.println(servletContext);

        System.out.println(response);
        return "welcome";
}

4.常用注解

4.1RequestParam

解决前端与controller层中传的参数名不一致问题

<a href="anno/testRequestParam?name=哈哈">RequestParam</a>//controller层使用了@RequestParam之后，此处前端必须传的参数名叫name并且必须有参数名

@Controller
@RequestMapping("/anno")
public class AnnoController {
    
    
    @RequestMapping("/testRequestParam")
    public String testRequestParam(@RequestParam("name") String username){
    
    
        System.out.println("开始执行");
        System.out.println(username);
        return "welcome";
    }
}

4.2RequestBody

获取请求体内容

<form method="post" action="anno/saveUser">--%>
    用户姓名：<input type="text" name="username"></br>
    用户性别：<input type="text" name="usersex"></br>
    <input type="submit" value="提交">
</form>

   @RequestMapping("/saveUser")
    public String saveUser(@RequestBody String body){
    
    
        System.out.println(body);//username=31&usersex=ni
        return "welcome";
    }

4.3PathVariable

4.3.1restful风格

便于缓存管理使用相同的映射路径，而通过请求类型和请求参数的不同来区分执行哪个方法

在这里插入图片描述

4.3.2PathVariable注解的使用

<%--PathVariable注解--%>
<a href="anno/testPathVaribale/哈哈">PathVariable</a>

  @RequestMapping("/testPathVaribale/{name}")
    public String testPathVaribale(@PathVariable("name") String username){
    
    
        System.out.println(username);//哈哈
        return "welcome";
    }

4.4RequestHeader

获取请求头

4.5CookieValue

获取cookie中的值

4.6ModelAttribute

作用：放在方法上优先执行

使用场景：表单不完整，可以获取表单中的参数去数据库中查询后再进行封装

如果有返回值，就直接封装，如果没有，就用map集合来接收，@ModelAttribute注解封装

<form method="post" action="anno/testModelAttribute">&ndash;%&gt;--%>
    用户姓名：<input type="text" name="username"></br>
    用户性别：<input type="text" name="usersex"></br>
    <input type="submit" value="提交">
</form>

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

    @ModelAttribute
    public User getUser(String username,String usersex){
    
    
        System.out.println(username+"-->"+usersex);
        //模拟通过用户名查询用户生日
        User user = new User();
        user.setUsername(username);
        user.setUsersex(usersex);
        user.setBirthday(new Date());
        return user;
    }

    @RequestMapping("/testModelAttribute")
    public String testPathVaribale(@ModelAttribute("abc") User user){
    
    
        System.out.println(user);
        return "welcome";
    }

    @ModelAttribute
    public void getUser(String username, Map<String,User> map){
    
    
        System.out.println(username);
        //模拟通过用户名查询用户生日
        User user = new User();
        user.setUsername(username);
        user.setBirthday(new Date());
        map.put("abc",user);
    }

4.7SessionAttribute

多次执行控制器之间的参数共享

作用在类上，向session域中存值和取值，删除

5.响应数据与结果视图

5.1字符串

控制层使用model类来将获取到的对象传到前端

   @RequestMapping("/testString")
    public String testString(Model model){
    
    
        //模拟从数据库中将user对象取出来
        User user = new User();
        user.setUsername("你好");
        user.setAge(12);
        user.setPassword("1324324");
        model.addAttribute("user",user);
        return "hello";
    }

jsp中不忽略EL表达式
<%@ page contentType="text/html;charset=UTF-8" language="java"  isELIgnored="false" %> 
<html>
<head>
    <title>Title</title>
</head>
<body>
<h1>欢迎${user.age}岁的${user.username}</h1>
</body>
</html>

5.2void

默认跳转到requestMapping的jsp下

//默认跳转到webinfo下的pages/test/testVoid.jsp中，没有就404
@RequestMapping("test/testVoid")
public void testVoid(){
    
    
    System.out.println("hello");
}

分为转发，重定向，直接响应三种

@RequestMapping("test/testVoid")
public void testVoid(HttpServletRequest request,HttpServletResponse response){
    
    
	 System.out.println("void方法执行");
        //编写请求转发的程序
        try {
    
    
            //不会创建视图解析器对象，因此需要自己些完整的路径名称
//            request.getRequestDispatcher("/WEB-INF/pages/hello.jsp").forward(request,response);
//            return;

            //编写重定向的程序,重定向向服务器请求两次，需要通过项目名访问，并且不能访问web-info下的文件
//            response.sendRedirect(request.getContextPath()+"/response.jsp");

            //直接响应需要配置解决中文乱码
            response.setCharacterEncoding("UTF-8");
            response.setContentType("text/html;charset=UTF-8");
            //直接响应
            response.getWriter().print("你好");
        } catch (Exception e) {
    
    
            e.printStackTrace();
        }
}

5.3ModelAndView

不仅可以跳转页面，还可以将对象返回

@RequestMapping("testModelAndView")
public ModelAndView testModelAndView(){
    
    
    //创建modelandview对象
    ModelAndView modelAndView = new ModelAndView();
    User user = new User();
    user.setUsername("每天");
    user.setAge(12);
    modelAndView.addObject("user",user);
    modelAndView.setViewName("hello");
    return modelAndView;
}

5.4转发和重定向

不能使用视图解析器，需要写正确路径

@RequestMapping("testForwardOrReDirect")
public void testForwardOrReDirect(){
    
    
    //请求转发使用forward关键字
    //return "forward:/WEB-INF/pages/hello.jsp";
    //重定向使用redirect关键字
    return "redirect:/hello.jsp";
}

5.5ResponseBody响应json数据

前端控制器默认拦截所有的资源，必须在springmvc配置文件中设置对静态资源不进行拦截才可以实现js效果的实现

<!--配置前端控制器不会拦截静态资源
js文件夹下的文件都不会拦截-->
<mvc:resource mapping="/js/**" location="/js/**"/>
<mvc:resource mapping="/images/**" location="/images/**"/>
<mvc:resource mapping="/css/**" location="/css/**"/>

web.xml中还要配置才可以调用js

  <servlet-mapping>
    <servlet-name>default</servlet-name>
    <url-pattern>*.js</url-pattern>
  </servlet-mapping>
  <servlet-mapping>
    <servlet-name>default</servlet-name>
    <url-pattern>*.png</url-pattern>
  </servlet-mapping>

ajax传值，并响应json

需要使用jacksonjar包来实现对象和json字符串之间的转换

pom.xml

<!--帮我们把json字符串转为对象，或者将对象转为json字符串-->
            <dependency>
                <groupId>com.fasterxml.jackson.core</groupId>
                <artifactId>jackson-databind</artifactId>
                <version>2.9.4</version>
            </dependency>
            <dependency>
                <groupId>com.fasterxml.jackson.core</groupId>
                <artifactId>jackson-core</artifactId>
                <version>2.9.4</version>
            </dependency>
            <dependency>
                <groupId>com.fasterxml.jackson.core</groupId>
                <artifactId>jackson-annotations</artifactId>
                <version>2.9.0</version>
            </dependency>