SpringMVC笔记

Spring是什么？

SpringMVC是基于Spring的一个框架，实际就是spring的一个专门做web开发的模块。
可以理解为servlet的一个升级

--web开发的底层就是servlet，框架是在servlet基础上加入一些功能，使开发更加方便

SpringMVC能干什么

SpringMVC能够创建对象，放入到容器中（SpringMVC容器），SpringMVC容器中放的是控制器对象（@Controller注解的类）

我们要做什么？

使用@Controller注解创建控制器对象，把对象放入mvc容器，将对象作为控制器使用
这个控制器对象可以接受用户的请求，显示处理结果，就当做serlvet使用
（创建的对象只是一个普通的对象，不是servlet，SpringMVC赋予控制器对象一些额外的功能）

DispatherServlet

SpringMVC中有一个对象是serlvet：DispatherServlet（中央调度器）
负责接受用户的所有请求，用户把请求给了DispatherServlet，之后它会把请求转发给Controller对象
最后Controller处理请求

过程

	index.jsp--->DispatherServlet(Servlet)--->转发，分配给--->Controller对象（@Controller注解创建的对象）

SpringMVC内部请求的处理流程

ApplicationContext ctx = new ClassPathXmlApplication("beans.xml");
studentService service = (studentService)ctx.getBean("service") ;

springmvc内部请求的处理流程:也就是springmvc接收请求，到处理完成的过程

1.用户发起请求some.do
—————————————————————————————————————————————————————
2.DispatcherServlet接收请求some.do，把请求转交给处理器映射器

	1)处理器映射器(HandlerMapping):
		springmvc框架中的一种对象，框架把实现了HandlerMapping接口的类都叫做映射器(多个)
	2)处理器映射器作用:
		1]根据请求，从springmve容器对象中获取处理器对象( MyController controller = ctx.getBean("some.do");
		2]框架把找到的处理器对象放到一个叫做处理器执行链(HandlerExecutionChain)的类保存
	3)处理器执行链(HandlerExecutionChain)类中保存着:
		1].处理器对象(MyController)
		2].项目中的所有的拦截器List<HandlerInterceptcor>
方法调用:
	HandlerExecutionChain mappedHandler = getHandler(processedRequest);

3.处理器映射器把处理器执行链返回给中央调度器
—————————————————————————————————————————————————————
4.中央调度器把3中的处理器执行链中的处理器对象交给了处理器适配器对象(多个)

	1)处理器适配器(HandlerAdaptor):
		springmvc框架中的对象，需要实现HandlerAdapter接口.
	2)处理器适配器作用:
		执行处理器方法(调用MyController.doSome()得到返回值ModelAndView
中央调度器中调用适配器: HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler());
执行处理器方法: mv = ha.handle(processedRequest,response,mappedHandler.getHandler());

5.处理器适配器把ModelAndView返回中央调度器
—————————————————————————————————————————————————————
6. DispatcherServlet把5中获取的ModelAndView交给了视图解析器对象。

1)视图解析器(ViewResoler):
	springmvc中的对象，需要实现ViewResoler接口(可以有多个)
2)视图解析器作用:
	组成视图完整路径，使用前缀，后缀。并创建View对象.
3)View是一个接口，表示视图的，在框架中jsp，html不是string表示的，而是使用View和他的实现类表示的。
	Interna IResourceView:
		视图类，表示jsp文件，视图解析器会创建InternalResourceView类对象。
		这个对象的里面，有一个属性url = /WEB-INE/view/show.jsp

7.视图解析器对象把ModelAndView返回中央调度器
—————————————————————————————————————————————————————
8. DispatoherServlet把7步骤中创建的View对象获取到，

调用View类自己的方法，把Model数据放入到request作用域。
执行对象视图的forward,请求结束。

第一个springmvc项目

需求：发起请求，交给控制器对象，并显示请求的处理结果
步骤：
	1、新建一个web maven工程
	2、加入依赖
			spring-webmvc依赖，间接把spring的依赖都加入项目
			jsp，servlet依赖
   *3、在web.xml文件中，注册springmvc框架的核心对象，DispatherServlet
		1）中央调度器
		2）前端控制器（front controller)
		3）负责接收用户提交的请求，调用其他的控制器对象，并把请求的处理结果显示给用户
    4、创建发起请求页面，index.jsp
    5、创建控制器类，
		1）在类上加入@Controller注解，创建对象并放入SpringMVC容器中
		2）在类的方法上面加入@RequestMapping注解
    6、创建一个作为结果的jsp，显示请求的处理结果
    7、创建SpringMVC的配置文件（与spring的一样）
  		1）声明组件扫描器，指定@Controller所在包名
  		2）声明视图解析器，帮助处理视图

web.xml

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee
         http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
         version="4.0">
    <!--创建中央调度器/前端控制器-->
    <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:springmvc.xml</param-value>
        </init-param>
        <!--tomcat启动时创建servlet对象，越小创建的越早-->
        <load-on-startup>1</load-on-startup>
    </servlet>
    <servlet-mapping>
        <servlet-name>myweb</servlet-name>
        <!--
            *.do、*.mvc=====请求以.do\.mvc结尾，就会交给这个servlet来处理
            使用斜杠"/"
        -->
        <url-pattern>*.do</url-pattern>
    </servlet-mapping>
</web-app>

设置中央调度器的url-pattern是"/"

导致静态资源访问失败都是404，动态代理可以正常访问

第1种解决静态资源访问的方案:
	在springmvc的配置文件中1) <mvc:default-serlet-handler> 
						  2) <mvc:annotation-driven>
	原理:给程序内存中增加一个处理器对象, DefautHttpRequestServlet
	-----------------------------------------------------------------------------------------------
第二种处理静态资源
	使用的框架中的mvc:resources标签，由框架白2处理静态资源的访问

springmvc.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:mvc="http://www.springframework.org/schema/mvc"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/mvc https://www.springframework.org/schema/mvc/spring-mvc.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">
    <mvc:annotation-driven />
    <!--组件扫描器，扫描所有的Controller注解-->
    <context:component-scan base-package="com.qzj.controller"/>
    <!--视图解析器-->
    <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
        <!--视图文件的路径-->
        <property name="prefix" value="WEB-INF/view/" />
        <!--后缀-->
        <property name="suffix" value=".jsp" />
    </bean>
</beans>

MyController

@Controller
public class MyController {
    @RequestMapping(value = "/some.do",method = "RequestMethod.GET")
    public ModelAndView dosome(){
        ModelAndView mv = new ModelAndView();
        //request.setAttribute("","");
        mv.addObject("name","张三");
        //request.getRequestDispather("/show.jsp").forward();
        mv.setViewName("show");
        return mv;
    }
}

逐个接收用户提交的参数

@RequestMapping(value = "/some.do",method = "RequestMethod.GET")
//参数名称与传来的参数名称一致
public ModelAndView receive01(String name){}
//传来参数不一致(传参为myName),required == true 表示参数必须有，false表示可以为null
public ModelAndView receive02(@RequestParam(value="myName",required = false) String name){}

解决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>
	<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>
	<!--强制所有请求和接收编码方式全部为utf-8-->
	<url-pattern>/*</url-pattern>
</filter-mapping>

使用对象赋值

//创建一个普通对象类来存储数据，vo.Student
public ModelAndView receiveObj(Student student){
	ModelAndView mv = new ModelAndView();
	mv.addObject("name",student.getName);
	mv.addObject("student",student);
}

返回值1 – ModelAndView

包含Model（数据）和View（视图）
Model会放到request的作用域中
View会进行转发操作，forword

返回值2 – String

@RequestMapping("returnString.do")
public String returnStr(){
	return "show";
}

返回值3 – void

不能表示数据和视图
在处理ajax的时候，可以使用void返回值，	ajax请求服务器端返回的就是数据，和视图无关
通过HttpServletResponse输出数据，响应ajax请求

返回值4 – Object

Object：例如String，Integer，Map，List，Student等都是对象
对象有属性，属性就是数据，所以返回Object表示数据，和视图无关
可以使用对象表示的数据，响应ajax请求

使用jackson处理ajax请求

1.加入处理json的工具库的依赖，springmvc默认使用的jackson。
2.在sprigmvc配置文件之间加入<mvc:annotation-driven>注解驱动。
	json = om. writeValueAsString(student); 
3.在处理器方法的上面加入@ResponseBody注解
	response.setContentType(”application/json;charset=utf-8");
	PrintWriter pw = response.getWriter();
	pw.println(json) ;|

注解驱动

springmvc处理器方法返回object，可以转为json输出到浏览器，响应ajax的内部原理

<mvc:annotation- driven>注解驱动。

注解驱动实现的功能是完成java对象到json ，xml，text ，二进制等数据格式的转换。
HttpMessageConveter接口 : 消息转换器。
功能 : 定义了java对象转为json、xml等数据格式的方法，这个接口有很多的实现类。
这些实现类完成java对象到json，java对象到xml，java对象到二进制数据的转换

canwrite 和 write方法

下面的两个方法是控制器类把结果输出给浏览器时使用的:
boolean canWrite(Class<?> var1, @Nullable MediaType var2);
void write(T var1, @Nullable MediaType var2, HttpoutputMessage var3)

例如处理器方法
@RequestMapping(value ="/returnstring.do" )
public student doReturnView2 (HttpServletRequest request, string name, Integer age ){
	student student = new Student();
	student.setName(" lisi");
	student.setAge(20);
	return student;
}

1 ) canWrite作用:
	检查处理器方法的返回值，能不能转为var2表示的数据格式。
	检查student(lisi20)能不能转为var2表示的数据格式。
		如果检查能转为json，canWrite返回true
	MediaType :表示数格式的，例如json,xml等等
2 )write:把处理器方法的返回值对象，调用jackson中的objectMapper转为json字符串。
json = om. writeValueAsstring(student);

forward（请求转发）

语法: setViewName( "forward:视图完整路径" )

forward特点:不和视图解析器一 同使用 ,就当项目中没有视图解析器,
					相当于一次请求

redirect（重定向）

语法: setViewName( "redirect:视图完整路径" )
redirect特点:
不和视图解析器一 同使用 ,就当项目中没有视图解析器
框架对重定向的操作:

1.框架会把Model中的简单类型的数据，转为string使用，作为hello.jsp的get请求参数使用。
目的是在doRedirect.do和hello.jsp两次请求之间传递数据
2.在目标hello.jsp页面可以使用参数集合对象${param}获取请求参数值
${ param.myname}, 
3.重定向不能访问/WEB-INF资源

异常处理

把所有controller中的所有异常处理全部集中到一起=====全局异常处理。

采用的是AOP思想，把业务逻辑和异常处理分开（解耦合）。

用到两个注解：
		1、@ExceptionHandler（方法上。value="异常类名.class"）
		2、@ControllerAdvice（类上。控制器增强）
还有两个配置
	   <context:component-scan base-package="com.bjpowernode.handler" />
	    <mvc:annotation-driven />

/**
 * @ControllerAdvice : 控制器增强（也就是说给控制器类增加功能--异常处理功能）
 *           位置：在类的上面。
 *  特点：必须让框架知道这个注解所在的包名，需要在springmvc配置文件声明组件扫描器。
 *  指定@ControllerAdvice所在的包名
 */
@ControllerAdvice
public class GlobalExceptionHandler {
    //定义方法，处理发生的异常
    /*
        处理异常的方法和控制器方法的定义一样， 可以有多个参数，可以有ModelAndView,
        String, void,对象类型的返回值

        形参：Exception，表示Controller中抛出的异常对象。
        通过形参可以获取发生的异常信息。

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

拦截器

1、拦截器是什么？
	1）拦截器是springmvc中的一种， 需要实现HandlerInterceptor接口.
	2）拦截器和过滤器类似，功能方向侧重点不同。
		过滤器是用来过滤器请求参数，设置编码字符集等工作.
		拦截器是拦截用户的请求，做请求做判断处理的.
	3）拦截器是全局的，可以对多个Controller做拦截。
	一个项目中可以有0个或多个拦截器，他们在一起拦截用户的请求.
	
2、拦截器常用在:用户登录处理，权限检查，记录日志.

3、拦截器的使用步骤:
	1）定义类实现HandlerInterceptor接口
	2）在springnva配文件中，声明拦截器，让框架知道拦截器的存在.
4、拦截器的执行时间:
	1)在请求处理之前，也 就是controller类中的方法执行之前先被拦截.
	2)在控制器方法执行之后也会执行拦截器。
	3)在诸求处理完成后也会执行拦截器。

拦截器

handler.MyHandlerInterceptor

//拦截器类：拦截用户的请求。
public class MyInterceptor implements HandlerInterceptor {

    private long btime = 0;
    /*
     * preHandle叫做预处理方法。
     *   重要：是整个项目的入口，门户。 当preHandle返回true 请求可以被处理。
     *        preHandle返回false，请求到此方法就截止。
     *
     * 参数：
     *  Object handler ： 被拦截的控制器对象
     * 返回值boolean
     *   true：请求是通过了拦截器的验证，可以执行处理器方法。
         *   拦截器的MyInterceptor的preHandle()
             =====执行MyController中的doSome方法=====
             拦截器的MyInterceptor的postHandle()
             拦截器的MyInterceptor的afterCompletion()
         *
     *   false：请求没有通过拦截器的验证，请求到达拦截器就截止了。 请求没有被处理
     *      拦截器的MyInterceptor的preHandle()
     *
     *
     *  特点：
     *   1.方法在控制器方法（MyController的doSome）之前先执行的。
     *     用户的请求首先到达此方法
     *
     *   2.在这个 方法中可以获取请求的信息， 验证请求是否符合要求。
     *     可以验证用户是否登录， 验证用户是否有权限访问某个连接地址（url）。
     *      如果验证失败，可以截断请求，请求不能被处理。
     *      如果验证成功，可以放行请求，此时控制器方法才能执行。
     */
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        btime = System.currentTimeMillis();
        System.out.println("拦截器的MyInterceptor的preHandle()");
        //计算的业务逻辑，根据计算结果，返回true或者false
        //给浏览器一个返回结果
        //request.getRequestDispatcher("/tips.jsp").forward(request,response);
        return true;
    }

    /*
       postHandle:后处理方法。
       参数：
        Object handler：被拦截的处理器对象MyController
        ModelAndView mv:处理器方法的返回值

        特点：
         1.在处理器方法之后执行的（MyController.doSome()）
         2.能够获取到处理器方法的返回值ModelAndView,可以修改ModelAndView中的
         数据和视图，可以影响到最后的执行结果。
         3.主要是对原来的执行结果做二次修正，

         ModelAndView mv = MyController.doSome();
         postHandle(request,response,handler,mv);
     */
    @Override
    public void postHandle(HttpServletRequest request,
                           HttpServletResponse response,
                           Object handler, ModelAndView mv) throws Exception {
        System.out.println("拦截器的MyInterceptor的postHandle()");
        //对原来的doSome执行结果，需要调整。
        if( mv != null){
            //修改数据
            mv.addObject("mydate",new Date());
            //修改视图
            mv.setViewName("other");
        }
    }

    /*
      afterCompletion:最后执行的方法
      参数
        Object handler:被拦截器的处理器对象
        Exception ex：程序中发生的异常
      特点:
       1.在请求处理完成后执行的。框架中规定是当你的视图处理完成后，对视图执行了forward。就认为请求处理完成。
       2.一般做资源回收工作的， 程序请求过程中创建了一些对象，在这里可以删除，把占用的内存回收。
     */
    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response,
                                Object handler, Exception ex) throws Exception {
        System.out.println("拦截器的MyInterceptor的afterCompletion()");

        long etime = System.currentTimeMillis();
        System.out.println("计算从preHandle到请求处理完成的时间："+(etime - btime ));
    }
}