首页 思维导图 详情

SpringMVC

2021-12-28 13:02:02 29 举报
AI智能生成
SpringMVC是一种基于Java的实现MVC设计模式的请求驱动类型的轻量级Web框架，通过一套注解，快速简单的实现了请求驱动模型。它是Spring框架的一部分，是一个非侵入式（non-invasive）框架，可以无缝地和Spring其他模块集成。SpringMVC提供了一种清晰的方法分离代码：控制器、模型、视图以及处理程序对象（handler objects）。Spring MVC具有松耦合、方便配置、代码分离等特点，从而使得开发者更加容易进行开发和维护。它适用于各种规模的应用程序，从小型到大型的企业级应用程序都可以使用。
springMVC
ssm
拦截器
作者其他创作
大纲/内容
概述
SpringMVC是什么
是一个基于mvc的web框架，
springMVC=struts2+spring，springMVC就相当于是Struts2加上sring的整合
springMVC和spring是什么样的关系
其实就是spring在原有基础上，又提供了web应用的MVC模块，可以简单的把springMVC理解为是spring的一个模块
(类似AOP，IOC这样的模块)，专门做web开发的，可理解为servlet的一个升级。
web开发底层也是servlet，框架是在servlet基础上面加入一些功能。
三层和框架的对应
SpringMVC--界面层：接受用户请求，显示处理结果的
Spring--业务层：处理业务逻辑的，spring创建Service，Dao，工具类等对象
MyBatis--持久层：访问数据库的，对数据库进行CRUD
SpringMVC底层访问依然是Servlet-DispatcherServlet(中央调度器)
web开发底层是servlet
1、创建WebApplicationContext对象，读取配置文件，进而创建控制器对象
2、它是一个Servlet，要接受用户的请求，显示处理结果
SpringMVC处理web请求
web.xml
<!--声明，注册springmvc的核心对象DispatcherServlet
        需要在tomcat服务器启动后，创建DispatcherServlet对象的实例，
        为什么要创建DispatcherServlet对象的实例呢？
        因为DispatcherServlet在它的创建过程中，会同时1、创建springmvc容器对象，
        读取springmvc的配置文件，把这个配置文件中的对象都创建好，当2、用户发起请求是就可以直接使用对象了，分配给自定义的Controller对象。

        servlet的初始化会执行init()方法，DispatcherServlet在init()中{
            //创建容器，读取配置文件
            WebApplicationContext ctx=new ClassPathXmlApplicationContext("springmvc.xml");
            //把容器对象放到ServletContext中
            getServletContext().setAttribute(key,ctx);
        }

        启动tomcat报错：Could not open ServletContext resource [/WEB-INF/springmvc-servlet.xml]
        springmvc容器创建容器对象时，默认读取的配置文件是/WEB-INF/<servlet-name>-servlet.xml
        所以此时得选择自定义springmvc读取的配置文件位置
    -->
    <servlet>
        <servlet-name>myweb</servlet-name>  <!--最好避免与xml文件重名-->
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>

        <!--自定义springmvc读取的配置文件的位置-->
        <init-param>
            <!--springmvc的配置文件的位置的属性-->
            <param-name>contextConfigLocation</param-name>
            <!--指定自定义文件的位置-->
            <param-value>classpath:springmvc.xml</param-value>
        </init-param>
        <!--在tomcat启动后，创建Servlet对象的顺序(整数>=0)-->
        <load-on-startup>1</load-on-startup>
    </servlet>
    <servlet-mapping>
        <servlet-name>myweb</servlet-name>
        <!--使用框架的时候，url-pattern可以使用两种值
            1、使用扩展名的方式，语法 *.xxx，xxx是自定义扩展名。常用方式有：*.do，*.action，*.mvc
                http://localhost:8080/myweb/some.do
            2、使用斜杠"/"
        -->
        <url-pattern>*.do</url-pattern>
    </servlet-mapping>
注解
1、@Controller：创建控制器类的对象，接受请求，处理请求
2、@RequestMapping：请求映射
作用
是把一个请求地址和一个方法绑定在一起。 一个请求指定一个方法处理。
说明：使用RequestMapping修饰的方法叫做处理器方法或控制器方法
使用RequestMapping修饰的方法可以处理请求的，类似Servlet中的doGet和doPost
属性
1、value：是一个String，唯一，表示请求的url(some.do)地址
2、method：表请求方式get、post、put、delete等
接受用户提交的参数
1、HttpServletRequest，HttpServletResponse，HttpSession
2、逐个接收参数：要求控制器方法的形参名和请求中的参数名一致，按名称对应赋值
3、解决请求中post方式由中文乱码，使用过滤器问题。CharacterEncodingFilter
<!--注册声明过滤器，解决post乱码问题-->
    <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>
        <!--强制请求对象（HttpServletRequest）使用encoding编码的值-->
        <init-param>
            <param-name>forceRequestEncoding</param-name>
            <param-value>true</param-value>
        </init-param>
        <!--强制应答对象（HttpServletResponse）使用encoding编码的值-->
        <init-param>
            <param-name>forceResponseEncoding</param-name>
            <param-value>true</param-value>
        </init-param>
    </filter>
    <filter-mapping>
        <filter-name>characterEncodingFilter</filter-name>
        <!--
            /*：表示强制所有的请求先通过过滤器处理。
        -->
        <url-pattern>/*</url-pattern>
    </filter-mapping>
4、逐个接收中，请求中参数名和处理器方法的形参名不一样，使用@RequestParam解决问题
属性
1、value请求中的参数名称
2、requered是一个boolean，默认是true
     true：表示请求中必须包含此参数，否则报400
位置
在处理器方法的形参定义的前面
注：占位符的形式，那么可以使用注解@pathvariable取出。
5、使用java对象接受请求的参数，要求请求中参数名和属性名一样
框架会创建形参的java对象，给属性赋值，请求中的参数是name，框架会调用setName()
6、springmvc处理器方法的形参还可以Map、List等集合类型,数组
7、框架接收参数
1、使用request对象接受请求参数
     * String strName=request.getParameter("name");
     * String strPassword=request.getParameter("password");
2、springmvc框架DispatcherServlet 调用MyController的doSome()方法
     * 调用方法时，按名称对应，把接收的参数赋给形参
     * doSome(strName,Integer.valueOf(strPassword));
     * 框架会提供类型自动转换功能
注：
400状态码错误：是客户端错误，表示提交请求参数过程中，发生了问题
     * 例：前端form中age未填写，传给后端框架自动转换int类型转换报400，把后端doSome形参int age改为Integer age
     * 但像double等类型输入后端转换依旧报400
处理器方法的返回值：表示请求的处理结果
1、ModelAndView：表示数据和视图，对视图执行forward
2、String：表示视图的，可以逻辑名称（要配置视图解析器），完整视图路径，对视图执行forward
<!--声明springmvc框架中的视图解析器，帮助开发人员设置视图文件的路径-->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <!--前缀：视图文件的路径-->
        <property name="prefix" value="/WEB-INF/view/"/>
        <!--后缀：视图文件的扩展名-->
        <property name="suffix" value=".jsp"/>
    </bean>
3、void：返回值本身不能表示数据和视图，可以响应ajax请求
不能表示数据和视图，处理ajax时可以使用void返回值。
    通过HttpServletResponse输出数据，响应ajax请求。
    ajax请求服务器端返回的就是数据，和视图无关。
4、Object对象：表示数据的，响应ajax请求
例如String，Integer，Map，List，Student等都是对象
    对象有属性，属性就是数据。所以返回Object表示数据，和视图无关。
    可以使用对象表示的数据，响应ajax请求。
5、springmvc处理器方法返回对象，转为json响应ajax步骤
1、加入处理java到json转换的工具库：jackson
<!--servlet依赖-->
<!-- 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>

       <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-core</artifactId>
            <version>2.13.0</version>
        </dependency>
        <!--Jackson依赖，实现基本的序列化和反序列化-->
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-databind</artifactId>
            <version>2.13.0</version>
        </dependency>
2、springmvc配置文件加入注解驱动<mvc:annotation-driven>
<!--注解驱动，注意是mvc的注解驱动，别导错驱动-->
    <mvc:annotation-driven/>
3、在处理器方法的上面加入@ResponseBody
url-pattern
设置中央调度器的url-pattern是"/"：导致静态资源访问失败都是404，动态代理可以正常访问
第一种解决静态资源访问的方案：
在springmvc配置文件中
1）<mvc:default-servlet-handler>
2）<mvc:annotation-driven/>
例：
<!--注解驱动，注意是mvc的注解驱动，别导错驱动-->
    <!--default-servlet-handler和@RequestMapping有冲突，需要加入annotation-driven解决问题-->
    <mvc:annotation-driven/>
    <!--第一种处理静态资源的方式
        需要在springmvc配置文件加入<mvc:default-servlet-handler>
        原理是：加入此标签后，框架会创建控制器对象DefaultServletHttpRequestHandler(类似自定义创建的MyController)，
        DefaultServletHttpRequestHandler这个对象可以把接受的请求转发给tomcat的default这个servlet。
    -->
    <mvc:default-servlet-handler/>
第二种解决静态资源访问的方案：
使用的框架中的mvc:resources标签，由框架自己处理静态资源的访问
<!--第二种处理静态资源的方式
       mvc:resources 加入后框架会创建ResourceHttpRequestHandler这个处理器对象
       让这个对象处理静态资源的访问，不依赖tomcat服务器
       mapping：访问静态资源的url地址，使用通配符 **
       location：静态资源在你的项目中的目录位置
       
       images/**：表示images/p1.jpg，images/user/logo.jpg，images/order/list.png
    -->
    <mvc:resources mapping="/images/**" location="/images/"/>
    <mvc:resources mapping="/html/**" location="/html/"/>
    <mvc:resources mapping="/jquery3.5.1/**" location="/jquery3.5.1/"/>
    <!--将所有静态资源文件放到static目录下，指定多种资源访问-->
<!--    <mvc:resources mapping="/static/**" location="/static/"/>-->

    <!--mvc:resources和@RequestMapping有一定的冲突-->
    <mvc:annotation-driven/>
SSM整合开发
ssm整合有两个容器
1）springmvc的容器：
管理controller，视图等对象
2）spring的容器：
service，dao等对象
创建容器的方式
1、创建springmvc的容器对象：使用的中央调度器DispatcherServlet
2、创建spring容器：使用监听器ContextLoaderListener
配置文件
1、springmvc的配置文件
<!--springmvc配置文件，声明controller和其它web相关的对象-->
    <context:component-scan base-package="com.kx.controller"/>
    <!--视图解析器-->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <property name="prefix" value="/WEB-INF/jsp/" />
        <property name="suffix" value=".jsp" />
    </bean>
    <!--
        1、响应ajax请求，返回json
        2、解决静态资源访问资源
    -->
    <mvc:annotation-driven/>
2、spring配置文件
<!--SqlSessionFactoryBean创建SqlSessionFactory-->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="datasource"/>
        <property name="configLocation" value="classpath:conf/mybatis.xml"/>
    </bean>

    <!--声明mapper的扫描器，创建dao对象-->
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"/>
        <property name="basePackage" value="com.kx.dao"/>
    </bean>

    <!--声明service的注解@Service所在的包名位置-->
    <context:component-scan base-package="com.kx.service"/>
3、mybatis配置文件
<settings>
        <setting name="logImpl" value="STDOUT_LOGGING"/>
</settings>
<typeAliases>
        <package name="com.kx.bean"/>
    </typeAliases>
    <mappers>
        <mapper resource="com/kx/dao/StudentDao.xml"/>
    </mappers>
4、数据库的属性配置文件
<context:property-placeholder location="classpath:conf/jdbc.properties"/>
    <!--声明数据源，连接数据库-->
    <bean id="datasource" class="com.alibaba.druid.pool.DruidDataSource" init-method="init" destroy-method="close">
        <property name="url" value="${jdbc.url}"/>
        <property name="username" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.password}"/>
    </bean>
5、web.xml
<!--注册中央调度器-->
    <servlet>
        <servlet-name>myweb</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:conf/springmvc.xml</param-value>
        </init-param>
        <load-on-startup>1</load-on-startup>
    </servlet>
    <servlet-mapping>
        <servlet-name>myweb</servlet-name>
        <url-pattern>*.do</url-pattern>
    </servlet-mapping>
    
    <!--注册spring的监听器-->
    <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>classpath:conf/applicationContext.xml</param-value>
    </context-param>
    <listener>
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    </listener>
    <!--注册字符集过滤器-->
    <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>forceRequestEncoding</param-name>
            <param-value>true</param-value>
        </init-param>
        <init-param>
            <param-name>forceResponseEncoding</param-name>
            <param-value>true</param-value>
        </init-param>
    </filter>
    <filter-mapping>
        <filter-name>characterEncodingFilter</filter-name>
        <url-pattern>/*</url-pattern>
    </filter-mapping>
pom文件
        <resources>
            <resource>
                <directory>src/main/webapp</directory>
                <targetPath>/resources</targetPath>
            </resource>
            <resource>
                <directory>src/main/resources</directory>
            </resource>
        </resources>
SpringMVC核心技术
1、请求重定向和转发
转发：forward
能访问WEB-INF下资源
mv.setViewName("forward:/hello.jsp");
重定向：redirect
框架对重定向的操作
1、框架会把Model中的简单类型的数据，转为String使用，作为hello.jsp的get请求参数使用
      目的是在doRedirect.do和hello.jsp两次请求之间传递数据
2、在目标hello.jsp页面可以使用参数集合对象${param}获取请求参数值
      ${param.myname}
不能访问WEB-INF下资源
//404
mv.setViewName("redirect:/hello.jsp");
特点：都不和视图解析器InternalResourceViewResolver一同工作
2、异常处理
springmvc框架采用的是统一，全局的异常处理。
把controller中的所有异常处理都集中到一个地方。
采用的是aop的思想。把业务逻辑和异常处理代码分开，解耦合。
使用两个注解
1、@ExceptionHandler
2、@ControllerAdvice
自定义的异常类
public class MyUserException extends Exception{
    public MyUserException() {
        super();
    }

    public MyUserException(String message) {
        super(message);
    }
}
<!--处理异常需要的两步-->
    <context:component-scan base-package="com.kx.handel"/>
    <mvc:annotation-driven/>
@ControllerAdvice
public class GlobalExceptionHandler {
    //定义方法，处理异常的方法
    /**
     * 处理异常的方法和控制器方法的定义一样，可以有多个参数，可以有ModelAndView
     * String，void，对象等类型的返回值
     *
     * 形参：Exception，表示Controller中抛出的异常对象。
     * 通过形参可以获取发生的异常信息。
     *
     * @ExceptionHanlder（异常的class）：表示异常的类型，当发生此类型异常是，由当前方法处理
     */
    @ExceptionHandler(value = NameException.class)
    public ModelAndView doNameException(Exception ex){
        //处理NameException异常
        /*
            异常发生处理逻辑：
            1、需要把异常记录下来，记录到数据库，日志文件
                记录日志发生的时间，哪个方法发生的，异常错误内容。
            2、发送通知，把异常信息通过邮件、短信、微信发送给相关人员
            3、给用户友好的提示。

         */
        ModelAndView mv=new ModelAndView();
        mv.addObject("msg","项目必须是zs，其他用户不能访问");
        mv.addObject("ex",ex);
        mv.setViewName("nameError");
        return mv;
    }
    @ExceptionHandler(value = AgeException.class)
    public ModelAndView doAgeException(Exception ex){
        //处理NameException异常
        /*
            异常发生处理逻辑：
            1、需要把异常记录下来，记录到数据库，日志文件
                记录日志发生的时间，哪个方法发生的，异常错误内容。
            2、发送通知，把异常信息通过邮件、短信、微信发送给相关人员
            3、给用户友好的提示。

         */
        ModelAndView mv=new ModelAndView();
        mv.addObject("msg","年龄必须大于80");
        mv.addObject("ex",ex);
        mv.setViewName("ageError");
        return mv;
    }
    //处理除nameException、ageException其他未知异常
    @ExceptionHandler
    public ModelAndView doOtherException(Exception ex){
        ModelAndView mv=new ModelAndView();
        mv.addObject("msg","年龄必须大于80");
        mv.addObject("ex",ex);
        mv.setViewName("defaultError");
        return mv;
    }
}
3、拦截器
1、拦截器是springmvc中的一种，需要实现HandlerInterceptor
2、拦截器和过滤器类似，功能方向侧重点不同。
 过滤器：是用来过滤请求参数，设置编码字符集等工作。
 拦截器：是拦截用户的请求，对请求做判断处理的。
3、拦截器是全局的，可以对多个Controller做拦截。
（看做多个Controller中公用的功能，集中到拦截器统一处理，使用的aop的思想）
 一个项目中可以有多个拦截器，他们在一起拦截用户的请求。
 拦截器常用在：用户登录处理，权限检查，记录日志。
拦截器的使用步骤
1、定义类实现HandlerInterceptor接口
接口中有三个方法：
preHandle、postHandle、afterCompletion
//拦截器类：拦截用户的请求
public class MyInterceptor implements HandlerInterceptor {

    //验证登录的用户信息，正确return true，其它return false
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
//        return HandlerInterceptor.super.preHandle(request, response, handler);
        System.out.println("拦截器的MyInterceptor的preHandler()");
        String loginName="";
        //从session中获取name的值
        Object attr = request.getSession().getAttribute("name");
        if (attr != null){
            loginName= (String) attr;
        }
        //判断登录的账户，是否符合要求
        if (!"zs".equals(loginName)){
            //给用户提示
            request.getRequestDispatcher("/tips.jsp").forward(request,response);
            return false;
        }
        return true;
    }

}
2、在springmvc配置文件中，声明拦截器，让框架知道拦截器的存在。
<!--声明拦截器：可以多个
        在框架中保存多个拦截器ArrayList，
        按照声明的先后顺序放入到ArrayList
    -->
    <mvc:interceptors>
        <!--声明第一个拦截器-->
        <mvc:interceptor>
            <mvc:mapping path="/**"/>
            <!--声明拦截器对象-->
            <bean class="com.kx.handler.MyInterceptor"/>
        </mvc:interceptor>
    </mvc:interceptors>
拦截器的执行时间
1、在请求处理之前，也就是controller类中的方法执行之前先被拦截。
2、在控制器方法执行之后也会执行拦截器。
3、在请求处理完成后也会执行拦截器。
多个拦截器
第一个拦截器preHandle=true，第二个拦截器preHandle=true，执行结果：
 拦截器的MyInterceptor的preHandler()
 拦截器的MyInterceptor2的preHandler()
 ===执行MyController中的doSome方法===
 拦截器的MyInterceptor2的postHandle()
 拦截器的MyInterceptor的postHandle()
 //postHandle将处理器执行链返回给DispatcherServlet
 拦截器的MyInterceptor2的afterCompletion()
 拦截器的MyInterceptor的afterCompletion()
第一个拦截器preHandle=true，第二个拦截器preHandle=false，执行结果：
 拦截器的MyInterceptor的preHandler()
 拦截器的MyInterceptor2的preHandler()
 拦截器的MyInterceptor的afterCompletion()
第一个拦截器preHandle=false，第二个拦截器preHandle=true|false，执行结果：
 拦截器的MyInterceptor的preHandler()
拦截器和过滤器的区别
1、过滤器是servlet中的对象，拦截器是框架中的对象
2、过滤器实现Filter接口的对象，拦截器是实现HandlerInterceptor
3、过滤器：是用来设置request，response的参数，属性的，侧重对数据过滤的
      拦截器：是用来验证请求的，能截断请求。
4、过滤器是在拦截器前先执行。
5、过滤器是tomcat服务器创建的对象
      拦截器是springmvc容器中创建的对象
6、过滤器是一个执行时间点
      拦截器有三个执行时间点
7、过滤器可以处理jsp、js、html等等
      拦截器侧重拦截对Controller的对象，如果请求不能被DispatcherServlet接收，这个请求不会执行拦截器内容
8、过滤器过滤servlet请求响应，拦截器拦截普通类方法执行
评论
0 条评论
下一页
为你推荐
查看更多
SpringMVC
SpringMVC
SpringMVC
SpringMVC
SpringMVC
SpringMVC
SpringMVC
SpringMVC
Java相关知识整理
Java相关知识整理
SpringMVC
SpringMVC
SpringMVC
SpringMVC
SSM框架---SpringMVC
SSM框架---SpringMVC
SpringMVC 流程
SpringMVC 流程
SpringMVC
SpringMVC