SpringMVC

​ SpringMVC也叫Spring web mvc。是Spring框架的一部分，是在Spring3.0后发布的。

1.基于MVC架构

​ 基于MVC架构，功能分工明确。解耦合。

2.容易理解，上手快；使用简单。

​ 就可以开发一个注解的SpringMVC项目，SpringMVC也是轻量级的，jar很小。不依赖的特定的接口和类。

3.作为Spring框架一部分，能够使用Spring的IoC和Aop。方便整合Strtus,MyBatis,Hiberate,JPA等其他框架。

4.SpringMVC强化注解的使用，在控制器，Service，Dao都可以使用注解。方便灵活。

​ 使用@Controller创建处理器对象,@Service创建业务对象，@Autowired或者@Resource在控制器类中注入Service, Service类中注入Dao。

​ 所谓SpringMVC的注解式开发是指，在代码中通过对类与方法的注解，便可完成处理器在springmvc容器的注册。注解式开发是重点。

1. 新建web maven工程

2. 加入依赖

  
    javax.servlet  
    javax.servlet-api  
    3.1.0  
    provided  
  
  
    org.springframework  
    spring-webmvc  
    5.2.5.RELEASE  

3. 重点： 在web.xml中注册springmvc框架的核心对象DispatcherServlet

    
    
        myweb
        org.springframework.web.servlet.DispatcherServlet

        
        
            
            contextConfigLocation
            
            classpath:springmvc.xml
        

        
        1
    

    
        myweb
        
        *.do
    

4. 创建一个发起请求的页面 index.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>


    


     
第一个springmvc项目
     
发起some.do的请求 
     
发起other.do的请求 

5. 创建控制器(处理器)类

@Controller
public class MyController {
    

    
    @RequestMapping(value = {"/some.do","/first.do"})
    public ModelAndView doSome(){  // doGet()--service请求处理
        //处理some.do请求了。 相当于service调用处理完成了。
        ModelAndView mv  = new ModelAndView();
        //添加数据， 框架在请求的最后把数据放入到request作用域。
        //request.setAttribute("msg","欢迎使用springmvc做web开发");
        mv.addObject("msg","欢迎使用springmvc做web开发");
        mv.addObject("fun","执行的是doSome方法");

        //指定视图, 指定视图的完整路径
        //框架对视图执行的forward *** 作， request.getRequestDispather("/show.jsp).forward(...)
        //mv.setViewName("/show.jsp");
        //mv.setViewName("/WEB-INF/view/show.jsp");
        //mv.setViewName("/WEB-INF/view/other.jsp");


        //当配置了视图解析器后，可以使用逻辑名称（文件名），指定视图
        //框架会使用视图解析器的前缀 + 逻辑名称 + 后缀 组成完成路径， 这里就是字符连接 *** 作
        ///WEB-INF/view/ + show + .jsp
        mv.setViewName("show");

        //mv.setView( new RedirectView("/a.jsp"));

        //返回mv
        return mv;
    }

    @RequestMapping(value = {"/other.do","/second.do"})
    public ModelAndView doOther(){
        ModelAndView mv  = new ModelAndView();
        mv.addObject("msg","====欢迎使用springmvc做web开发====");
        mv.addObject("fun","执行的是doOther方法");
        mv.setViewName("other");
        return mv;
    }
}

6. 创建一个作为结果的jsp，显示请求的处理结果。

<%@ page contentType="text/html;charset=UTF-8" language="java" %>


    


    /WEB-INF/view/show.jsp从request作用域获取数据

    msg数据：${msg}

    fun数据：${fun}

7. 创建springmvc的配置文件（spring的配置文件一样）
   1）声明组件扫描器， 指定@Contorller注解所在的包名
   2）声明视图解析器。帮助处理视图的。

​ SpringMVC框架为了避免对于请求资源路径与扩展名上的冗余，在视图解析器InternalResouceViewResolver中引入了请求的前辍与后辍。而ModelAndView中只需给出要跳转页面的文件名即可，对于具体的文件路径与文件扩展名，视图解析器会自动完成拼接。

（1）浏览器提交请求到中央调度器

（2）中央调度器直接将请求转给处理器映射器。

（3）处理器映射器会根据请求，找到处理该请求的处理器，并将其封装为处理器执行链后返回给中央调度器。

（4）中央调度器根据处理器执行链中的处理器，找到能够执行该处理器的处理器适配器。

（5）处理器适配器调用执行处理器。

（6）处理器将处理结果及要跳转的视图封装到一个对象ModelAndView中，并将其返回给处理器适配器。

（7）处理器适配器直接将结果返回给中央调度器。

（8）中央调度器调用视图解析器，将ModelAndView中的视图名称封装为视图对象。

（9）视图解析器将封装了的视图对象返回给中央调度器

（10）中央调度器调用视图对象，让其自己进行渲染，即进行数据填充，形成响应对象。

（11）中央调度器响应浏览器。

​ 通过@RequestMapping注解可以定义处理器对于请求的映射规则。该注解可以注解在方法上，也可以注解在类上，但意义是不同的。value属性值常以“/”开始。

​ @RequestMapping的value属性用于定义所匹配请求的URI。但对于注解在方法上与类上，其value属性所指定的URI，意义是不同的。 一个@Controller所注解的类中，可以定义多个处理器方法。当然，不同的处理器方法所匹配的URI是不同的。这些不同的URI被指定在注解于方法之上的@RequestMapping的value属性中。但若这些请求具有相同的URI部分，则这些相同的URI，可以被抽取到注解在类之上的@RequestMapping的value属性中。此时的这个URI表示模块的名称。URI的请求是相对于Web的根目录。

@Controller
@RequestMapping("/user")
public class MyController {

    
    //指定some.do使用get请求方式
    @RequestMapping(value = "/some.do",method = RequestMethod.GET)
    public ModelAndView doSome(){  // doGet()--service请求处理
        //处理some.do请求了。 相当于service调用处理完成了。
        ModelAndView mv  = new ModelAndView();
        mv.addObject("msg","欢迎使用springmvc做web开发");
        mv.addObject("fun","执行的是doSome方法");
        mv.setViewName("show");
        return mv;
    }

    //指定other.do是post请求方式
    @RequestMapping(value = "/other.do",method = RequestMethod.POST)
    public ModelAndView doOther(){
        ModelAndView mv  = new ModelAndView();
        mv.addObject("msg","====欢迎使用springmvc做web开发====");
        mv.addObject("fun","执行的是doOther方法");
        mv.setViewName("other");
        return mv;
    }

    //不指定请求方式，没有限制
    @RequestMapping(value = "/first.do")
    public ModelAndView doFirst(HttpServletRequest request,
                                HttpServletResponse response,
                                HttpSession session){
        ModelAndView mv  = new ModelAndView();
        mv.addObject("msg","====欢迎使用springmvc做web开发====" + 			       request.getParameter("name"));
        mv.addObject("fun","执行的是doFirst方法");
        mv.setViewName("other");
        return mv;
    }
}

​ 对于@RequestMapping，其有一个属性method，用于对被注解方法所处理请求的提交方式进行限制，即只有满足该method属性指定的提交方式的请求，才会执行该被注解方法。

​ Method属性的取值为RequestMethod枚举常量。常用的为RequestMethod.GET与RequestMethod.POST，分别表示提交方式的匹配规则为GET与POST提交。

​ 客户端浏览器常用的请求方式，及其提交方式有以下几种：

​ 也就是说，只要指定了处理器方法匹配的请求提交方式为POST，则相当于指定了请求发送的方式：要么使用表单请求，要么使用AJAX请求。其它请求方式被禁用。

​ 当然，若不指定method属性，则无论是GET还是POST提交方式，均可匹配。即对于请求的提交方式无要求。

​ 处理器方法可以包含以下四类参数，这些参数会在系统调用时由系统自动赋值，即程序员可在方法内直接使用。

➢ HttpServletRequest

➢ HttpServletResponse

➢ HttpSession

➢ 请求中所携带的请求参数

​ 只要保证请求参数名与该请求处理方法的参数名相同即可。

    @RequestMapping(value = "/receiveproperty.do")
    public ModelAndView doSome(String name, Integer age){
        System.out.println("doSome, name="+name+"   age="+age);
        //可以在方法中直接使用 name ， age
        //处理some.do请求了。 相当于service调用处理完成了。
        ModelAndView mv  = new ModelAndView();
        mv.addObject("myname",name);
        mv.addObject("myage",Integer.valueOf(age));
        //show是视图文件的逻辑名称（文件名称）
        mv.setViewName("show");
        return mv;
    }

​ 对于所接收的请求参数，若含有中文，则会出现中文乱码问题。Spring对于请求参数中的中文乱码问题，给出了专门的字符集过滤器：spring-web-5.2.5.RELEASE.jar的org.springframework.web.filter包下的CharacterEncodingFilter类。

解决方案

​ 在web.xml中注册字符集过滤器，即可解决Spring的请求参数的中文乱码问题。不过，最好将该过滤器注册在其它过滤器之前。因为过滤器的执行是按照其注册顺序进行的。

    characterEncodingFilter
    org.springframework.web.filter.CharacterEncodingFilter
    
    
        encoding
        utf-8
    
    
    
        forceRequestEncoding
        true
    
    
    
        forceResponseEncoding
        true
    


    characterEncodingFilter
    
    System.out.println("doSome, name="+name+"   age="+age);
    //可以在方法中直接使用 name ， age
    //处理some.do请求了。 相当于service调用处理完成了。
    ModelAndView mv  = new ModelAndView();
    mv.addObject("myname",name);
    mv.addObject("myage",age);
    //show是视图文件的逻辑名称（文件名称）
    mv.setViewName("show");
    return mv;
}

​ 将处理器方法的参数定义为一个对象，只要保证请求参数名与这个对象的属性同名即可。

@RequestMapping(value = "/receiveobject.do")
public ModelAndView receiveParam( Student myStudent){
    System.out.println("receiveParam, name="+myStudent.getName()+"   age="+myStudent.getAge());
    //可以在方法中直接使用 name ， age
    //处理some.do请求了。 相当于service调用处理完成了。
    ModelAndView mv  = new ModelAndView();
    mv.addObject("myname",myStudent.getName());
    mv.addObject("myage",myStudent.getAge());
    mv.addObject("mystudent",myStudent);
    //show是视图文件的逻辑名称（文件名称）
    mv.setViewName("show");
    return mv;
}

使用@Controller注解的处理器的处理器方法，其返回值常用的有四种类型：

➢ 第一种：ModelAndView

➢ 第二种：String

➢ 第三种：无返回值void

➢ 第四种：返回自定义类型对象

​ 若处理器方法处理完后，需要跳转到其它资源，且又要在跳转的资源间传递数据，此时处理器方法返回ModelAndView比较好。当然，若要返回ModelAndView，则处理器方法中需要定义ModelAndView对象。

​ 在使用时，若该处理器方法只是进行跳转而不传递数据，或只是传递数据而并不向任何资源跳转（如对页面的Ajax异步响应），此时若返回ModelAndView，则将总是有一部分多余：要么Model多余，要么View多余。即此时返回ModelAndView将不合适。

​ 处理器方法返回的字符串可以指定逻辑视图名，通过视图解析器解析可以将其转换为物理视图地址 。

@RequestMapping(value = "/returnString-view.do")
public String doReturnView(HttpServletRequest request,String name, Integer age){
    System.out.println("doReturnView, name="+name+"   age="+age);
    //可以自己手工添加数据到request作用域
    request.setAttribute("myname",name);
    request.setAttribute("myage",age);
    // show : 逻辑视图名称，项目中配置了视图解析器
    // 框架对视图执行forward转发 *** 作
    return "show";
}

//处理器方法返回String,表示完整视图路径， 此时不能配置视图解析器
    @RequestMapping(value = "/returnString-view2.do")
    public String doReturnView2(HttpServletRequest request,String name, Integer age){
        System.out.println("===doReturnView2====, name="+name+"   age="+age);
        //可以自己手工添加数据到request作用域
        request.setAttribute("myname",name);
        request.setAttribute("myage",age);
        // 完整视图路径，项目中不能配置视图解析器
        // 框架对视图执行forward转发 *** 作
        // /WEB-INF/view//WEB-INF/view/show.jsp.jsp
        // /WEB-INF/view/WEB-INF/view/show.jsp.jsp
        return "/WEB-INF/view/show.jsp";
    }

​ 对于处理器方法返回void的应用场景，AJAX响应.

​ 若处理器对请求处理后，无需跳转到其它任何资源，此时可以让处理器方法返回void。

<%@ page contentType="text/html;charset=UTF-8" language="java" %>


    
     
     


     
处理器方法返回String表示视图名称
     
     

     
处理器方法返回String表示视图完整路径
     
    

    

    发起ajax请求

//处理器方法返回void， 响应ajax请求
    //手工实现ajax，json数据： 代码有重复的 1. java对象转为json； 2. 通过HttpServletResponse输出json数据
    @RequestMapping(value = "/returnVoid-ajax.do")
    public void doReturnVoidAjax(HttpServletResponse response, String name, Integer age) throws IOException {
        System.out.println("===doReturnVoidAjax====, name="+name+"   age="+age);
       //处理ajax， 使用json做数据的格式
       //service调用完成了， 使用Student表示处理结果
        Student student  = new Student();
        student.setName("张飞同学");
        student.setAge(28);

        String json = "";
        //把结果的对象转为json格式的数据
        if( student != null){
            ObjectMapper om  = new ObjectMapper();
            json  = om.writevalueAsString(student);
            System.out.println("student转换的json===="+json);
        }

        //输出数据，响应ajax的请求
        response.setContentType("application/json;charset=utf-8");
        PrintWriter pw  = response.getWriter();
        pw.println(json);
        pw.flush();
        pw.close();

    }

​ 处理器方法也可以返回Object对象。这个Object可以是Integer，String，自定义对象，Map，List等。但返回的对象不是作为逻辑视图出现的，而是作为直接在页面显示的数据出现的。

​ 返回对象，需要使用@ResponseBody注解，将转换后的JSON数据放入到响应体中。

maven pom.xml

​ 由于返回Object数据，一般都是将数据转化为了JSON对象后传递给浏览器页面的。而这个由Object转换为JSON，是由Jackson工具完成的。所以需要导入Jackson的相关Jar包。

  com.fasterxml.jackson.core
  jackson-core
  2.9.0


  com.fasterxml.jackson.core
  jackson-databind
  2.9.0

声明注解驱动

​ 将Object数据转化为JSON数据，需要由消息转换器HttpMessageConverter完成。而转换器的开启，需要由来完成。 SpringMVC使用消息转换器实现请求数据和对象，处理器方法返回对象和响应输出之间的自动转换 当Spring容器进行初始化过程中，在处创建注解驱动时，默认创建了七个HttpMessageConverter对象。也就是说，我们注册，就是为了让容器为我们创建HttpMessageConverter对象。

HttpMessageConverter接口 : HttpMessageConverter是Spring3.0 新添加的一个接口，负责将请求信息转换为一个对象（类型为T），将对象（类型为T）输出为响应信息

HttpMessageConverter接口定义的方法：  
    boolean canRead(Class clazz,MediaType mediaType): 指定转换器可以读取的对象类型，即转换器是否可将请求信息转换为clazz 类型的对象，同时指定支持MIME 类型(text/html,applaiction/json等)  
    boolean canWrite(Class clazz,MediaType mediaType):指定转换器是否可将clazz 类型的对象写到响应流中，响应流支持的媒体类型在MediaType 中定义。 
    LIst getSupportMediaTypes()：该转换器支持的媒体类 型。  
    T read(Class clazz,HttpInputMessage inputMessage)：将请求信息流转换为T 类型的对象。  
    void write(T t,MediaType contnetType,HttpOutputMessgae outputMessage):将T类型的对象写到响应流中，同时指定相应的媒体类型为contentType 

​ 返回自定义类型对象时，不能以对象的形式直接返回给客户端浏览器，而是将对象转换为JSON格式的数据发送给浏览器的。

​ 由于转换器底层使用了Jackson转换方式将对象转换为JSON数据，所以需要导入Jackson的相关Jar包。

现在做ajax， 主要使用json的数据格式。 实现步骤：
 1.加入处理json的工具库的依赖， springmvc默认使用的jackson。
 2.在sprigmvc配置文件之间加入  注解驱动。
   json  = om.writevalueAsString(student);
 3.在处理器方法的上面加入@ResponseBody注解
     response.setContentType("application/json;charset=utf-8");
     PrintWriter pw  = response.getWriter();
     pw.println(json);

    @RequestMapping(value = "/returnStudentJson.do")
    @ResponseBody
    public Student doStudentJsonObject(String name, Integer age) {
        //调用service，获取请求结果数据 ， Student对象表示结果数据
        Student student = new Student();
        student.setName("李四同学");
        student.setAge(20);
        return student; // 会被框架转为json

    }

@RequestMapping(value = "/returnStudentJsonArray.do")
@ResponseBody
public List doStudentJsonObjectArray(String name, Integer age) {

    List list = new ArrayList<>();
    //调用service，获取请求结果数据 ， Student对象表示结果数据
    Student student = new Student();
    student.setName("李四同学");
    student.setAge(20);
    list.add(student);

    student = new Student();
    student.setName("张三");
    student.setAge(28);
    list.add(student);


    return list;

}

​ 若要返回非中文字符串，将前面返回数值型数据的返回值直接修改为字符串即可。但若返回的字符串中带有中文字符，则接收方页面将会出现乱码。此时需要使用@RequestMapping的produces属性指定字符集。 produces，产品，结果，即该属性用于设置输出结果类型。

    @RequestMapping(value = "/returnStringData.do",produces = "text/plain;charset=utf-8")
    @ResponseBody
    public String doStringData(String name,Integer age){
        return "Hello SpringMVC 返回对象，表示数据";
    }

        myweb
        
        /
    

    default
    org.apache.catalina.servlets.DefaultServlet
    
        debug
        0
    
    
        listings
        false
    
    1


        default
        /
    

    //处理some.do请求了。 相当于service调用处理完成了。
    ModelAndView mv  = new ModelAndView();
    mv.addObject("msg","欢迎使用springmvc做web开发");
    mv.addObject("fun","执行的是doSome方法");
    //显示转发
    //mv.setViewName("forward:/WEB-INF/view/show.jsp");

    mv.setViewName("forward:/hello.jsp");
    return mv;
}

@RequestMapping(value = "/doRedirect.do")
public ModelAndView doWithRedirect(String name,Integer age){
    //处理some.do请求了。 相当于service调用处理完成了。
    ModelAndView mv  = new ModelAndView();
    //数据放入到 request作用域
    mv.addObject("myname",name);
    mv.addObject("myage",age);
    //重定向
    //mv.setViewName("redirect:/hello.jsp");
    //http://localhost:8080/ch08_forard_redirect/hello.jsp?myname=lisi&myage=22

    //重定向不能访问/WEB-INF资源
    mv.setViewName("redirect:/WEB-INF/view/show.jsp");
    return mv;
}

@RequestMapping(value = "/some.do")
public ModelAndView doSome(String name,Integer age) throws MyUserException {
    //处理some.do请求了。 相当于service调用处理完成了。
    ModelAndView mv  = new ModelAndView();

    //try {
        //根据请求参数抛出异常
        if (!"zs".equals(name)) {
            throw new NameException("姓名不正确！！！");
        }

        if (age == null || age > 80) {
            throw new AgeException("年龄比较大！！！");
        }

    //}catch(Exception e){
    //   e.printStackTrace();
    //}

    mv.addObject("myname",name);
    mv.addObject("myage",age);
    mv.setViewName("show");
    return mv;
}

@ControllerAdvice
public class GlobalExceptionHandler {
    //定义方法，处理发生的异常
    

    @ExceptionHandler(value = NameException.class)
    public ModelAndView doNameException(Exception exception){
        //处理NameException的异常。
        
        ModelAndView mv = new ModelAndView();
        mv.addObject("msg","姓名必须是zs，其它用户不能访问");
        mv.addObject("ex",exception);
        mv.setViewName("nameError");
        return mv;
    }


    //处理AgeException
    @ExceptionHandler(value = AgeException.class)
    public ModelAndView doAgeException(Exception exception){
        //处理AgeException的异常。
        
        ModelAndView mv = new ModelAndView();
        mv.addObject("msg","你的年龄不能大于80");
        mv.addObject("ex",exception);
        mv.setViewName("ageError");
        return mv;
    }

    //处理其它异常， NameException, AgeException以外，不知类型的异常
    @ExceptionHandler
    public ModelAndView doOtherException(Exception exception){
        //处理其它异常
        ModelAndView mv = new ModelAndView();
        mv.addObject("msg","你的年龄不能大于80");
        mv.addObject("ex",exception);
        mv.setViewName("defaultError");
        return mv;
    }
}

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

    private long btime = 0;
    
    @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;
    }

    
    @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");
        }
    }

    
    @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 ));
    }
}

111111-拦截器的MyInterceptor的preHandle()
22222-拦截器的MyInterceptor的preHandle()
=====执行MyController中的doSome方法=====
22222-拦截器的MyInterceptor的postHandle()
111111-拦截器的MyInterceptor的postHandle()
22222-拦截器的MyInterceptor的afterCompletion()
111111-拦截器的MyInterceptor的afterCompletion()

111111-拦截器的MyInterceptor的preHandle()
22222-拦截器的MyInterceptor的preHandle()
111111-拦截器的MyInterceptor的afterCompletion()

111111-拦截器的MyInterceptor的preHandle()

public class HandlerExecutionChain {

	private static final Log logger = LogFactory.getLog(HandlerExecutionChain.class);

	private final Object handler; //存放控制器对象，MyController

	@Nullable
	private HandlerInterceptor[] interceptors;//存放多个拦截器对象。MyInterceptor1,2

	@Nullable
	private List interceptorList;
}