Springmvc总结

1、springmvc是什么?

springmvc全称是spring web mvc,是spring框架一部分,是一个mvc的框架,和struts2一样是一个表现层框架。

2、springmvc架构原理原理要理解

 

 

 原理简写:DispatcherServlet-->映射器-->适配器-->视图解析器-->页面

3、springmvc入门

新建一个java的web项目,在web目录下新建一个lib目录,存在jar包

3.1:导入jar

 

 

 3.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>springmvc</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>
</servlet>
<servlet-mapping>
    <servlet-name>springmvc</servlet-name>
    <url-pattern>*.action</url-pattern>
</servlet-mapping>
</web-app>

其中servlet是用来拦截请求,交给spring管理;init-param来加载配置文件;url-pattern常用*.do或*.action

 

src目录下或者自己创建一个config资源目录下创建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"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
      http://www.springframework.org/schema/beans/spring-beans-3.2.xsd
      http://www.springframework.org/schema/mvc
      http://www.springframework.org/schema/mvc/spring-mvc-3.2.xsd
      http://www.springframework.org/schema/context
      http://www.springframework.org/schema/context/spring-context-3.2.xsd
      http://www.springframework.org/schema/aop
      http://www.springframework.org/schema/aop/spring-aop-3.2.xsd
      http://www.springframework.org/schema/tx
      http://www.springframework.org/schema/tx/spring-tx-3.2.xsd ">
<beans>

3.3开发Handler

创建一个springmvchandler类,来处理请求,相当于servlet

package com.controller;

import org.springframework.web.servlet.ModelAndView;
import org.springframework.web.servlet.mvc.Controller;

public class SpringMvc implements Controller{
    @Override
    public ModelAndView handleRequest(javax.servlet.http.HttpServletRequest httpServletRequest, javax.servlet.http.HttpServletResponse httpServletResponse) throws Exception {
        ModelAndView modelAndView=new ModelAndView();
        modelAndView.setViewName("index.jsp");//设定视图,相对的是web
        return modelAndView;
    }
}

3.4使用xml方式配置

springmvc.xml中配置:

<!-- 把SpringMvc类交给springmvc管理 -->
<bean id="springmvc" class="com.controller.SpringMvc"></bean>
<!-- 配置适配器 -->
<bean class="org.springframework.web.servlet.mvc.SimpleControllerHandlerAdapter" />
<!-- 配置处理器映射器 -->
<bean class="org.springframework.web.servlet.handler.SimpleUrlHandlerMapping">
    <property name="mappings">
        <props>
            <!--key表示的是访问的路径-->
            <prop key="/springmvc.action">springmvc</prop>
        </props>
    </property>
</bean>

3.5使用注解方式配置

使用注解就不需要说明那么麻烦,也是在springmvc.xml中配置。

注解的处理器映射器:

spring3.1版本之前使用org.springframework.web.servlet.mvc.annotation.DefaultAnnotationHandlerMapping

3.1版本之后使用org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping

注解的处理器适配器:

spring3.1之前使用org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerAdapter

3.1之后使用org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter

<!-- 注解处理器映射器 -->
<bean class="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping"/>
<!-- 注解处理器适配器 -->
<bean class="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter"/>

以上代码可以简写为两行:

<!--配置注解处理器映射器和适配器-->
<mvc:annotation-driven></mvc:annotation-driven>

注意,还要进行包扫描:

<!--包扫描-->
<context:component-scan base-package="com.controller"/>

然后新建一个handler类:

package com.controller;

import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.servlet.ModelAndView;
@Controller
public class SpringMvc2{
    //配置注解映射,一定要加/
    @RequestMapping("/show.action")
    public ModelAndView show(){
        ModelAndView modelAndView=new ModelAndView();
        modelAndView.setViewName("index2.jsp");
        return modelAndView;
    }
}

3.6 运行测试:

新建一个index.jsp,在里面写入内容,然后去访问springmvc.action,效果如下:

 

 

 

 两种方式配置的效果是一样的,常用注解配置。

3.7其他配置

一个类中可以有多个映射,可以有多个方法。

ModelAndView主要是为了跳转页面,因此这个方法也可以简写。

1.直接返回一个路径字符串

@RequestMapping("/show2.action")
public String show2(){
    return  "index2.jsp";
}

2.访问内部私有的资源,外部不能访问

//使用程序访问私有的资源
@RequestMapping("/show3.action")
public String show3(){
    return  "WEB-INF/index3.jsp";
}

3.在springmvc.xml中配置前缀和后缀

<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
    <!-- 指定视图路径前缀 -->
    <property name="prefix" value="/view/" />
    <!-- 指定视图路径后缀 -->
    <property name="suffix" value=".jsp" />
</bean>

配置了前缀和后缀之后,返回的路径就很简单,不需要前缀和后缀,但是有局限性,不经常使用。

4.编码处理:设置一个编码过滤器,参数等不在乱码。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> <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>

4、参数绑定

1什么是参数绑定

springmvc接收请求的key/value串(比如:id=2&type=101),经过类型转换,将转换后的值赋值给controller方法的形参,这个过程就叫参数绑定。

2默认支持的类型

controller方法形参中如下类型是可以直接绑定成功,springmvc框架给以下类型的参数直接赋值:

HttpServletRequest:通过request对象获取请求信息

HttpServletResponse:通过response处理响应信息

HttpSession:通过session对象得到session中存放的对象

Model/ModelMap:ModelMapModel接口的实现类,通过ModelModelMap向页面传递数据

@RequestMapping("/login4.action")
public void login4(HttpServletRequest request, HttpServletResponse response) throws IOException {
    String username = request.getParameter("username");
    String password = request.getParameter("password");
    response.sendRedirect("loginSuccess.jsp");
}

 

其他都雷同,比较麻烦,不推荐使用

3简单数据类型

Integerstringbooleanfloat。。。

绑定规则:对于基本类型参数绑定,当请求的参数的名称和controller方法的形参名一致时可以绑定成功。针对当前类型做类转换,当类型明确时使用明确的类型,当类型不明确时,可以使用string类型,需要时再强转。

@RequestParam:取别名

@RequestBody:把请求体中的数据封装到对象中,请求体中的内容必须是json格式

如果请求的参数的名称和controller方法的形参名不一致时,如何绑定?

就要使用@RequestParam进行绑定:@RequestParam(value="ids") Integer id ,将请求的参数名为ids的值绑定方法形参的id上,Value可以省略.

@RequestMapping("/login4.action")
public void login4(@RequestParam(value="id") int id2) {
    System.out.println(id2);

多个参数

@RequestMapping("/login2.action")
public void login(String username,String password){
    System.out.println(username+" "+password);
}

4简单pojo参数绑定

简单pojopojo中都基本类型

Login.jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
<form method="get" action="login.action">
    <input type="text" name="username">
    <input type="text" name="password">
    <input type="submit">
</form>
</body>
</html>

User

package com.entity;

public class User {
    private String username;
    private String password;
    public String getUsername() {
        return username;
    }
    public void setUsername(String username) {
        this.username = username;
    }
    public String getPassword() {
        return password;
    }
    public void setPassword(String password) {
        this.password = password;
    }
    @Override
    public String toString() {
        return "User{" +
                "username='" + username + '\'' +
                ", password='" + password + '\'' +
                '}';
    }
}

获取内容

@RequestMapping("/login3.action")
public void login2(User user){
    System.out.println(user);
}

5、包装pojo类型

一个类中不仅有简单数据类型,还有对象属性。那么页面需要使用相应的类标识属性名,如下:

<form method="get" action="login.action">
    <input type="text" name="name">
    <input type="text" name="user.username">
    <input type="text" name="user.password">
 <input type="submit">
</form>

实体类

package com.entity;

public class OtherUser {
    private String name;
    private User user;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public User getUser() {
        return user;
    }
    public void setUser(User user) {
        this.user = user;
    }
    @Override
    public String toString() {
        return "OtherUser{" +
                "name='" + name + '\'' +
                ", user=" + user +
                '}';
    }
}

获取内容

@RequestMapping("/login5.action")
public void login5(OtherUser otherUser){
    System.out.println(otherUser);
}

6、数组类型参数绑定

<form method="get" action="login.action">
 <input type="checkbox" name="hobby" value="篮球">篮球
    <input type="checkbox" name="hobby" value="足球">足球
    <input type="checkbox" name="hobby" value="羽毛球">羽毛球
    <input type="submit">
</form>

获取选中的内容

@RequestMapping("/login.action")
public void login3(String[] hobby){
    for (String s : hobby) {
        System.out.println(s);
    }
}

5RequestMapping的设置

requestMapping注解的作用:对controller方法进行映射。

 URL路径映射:requestMapping指定url,对controller方法进行映射。

@RequestMapping("/login.action")  

化请求映射:为了更好的管理url,为了避免url冲突,可以在class上使用requestMapping指定根url

@Controller
@RequestMapping("/user")
public class UserController {
@RequestMapping("/login3.action")
public void login2(User user){
    System.out.println(user);
}}

访问时使用user/login3.action。在开发时候,需要提前进行url规划,以避免后期修改url后,需要大量修改页面上的url地址。

 请求方法限定:通过requestMapping限制http的请求方法,可以提高系统安全性。

@RequestMapping(value="/login2.action",method = RequestMethod.GET)
public void login(String username,String password){
    System.out.println(username+" "+password);
}

如果没有通过指定的方式来访问该请求就会出现如下错误

 

 

 6Controller方法返回值

6.1返回ModelAndView

controller方法中定义ModelAndView对象并返回,对象中可添加model数据、指定逻辑视图名。

@Override
public ModelAndView handleRequest(javax.servlet.http.HttpServletRequest httpServletRequest, javax.servlet.http.HttpServletResponse httpServletResponse) throws Exception {
    ModelAndView modelAndView=new ModelAndView();
    modelAndView.setViewName("index.jsp");
    return modelAndView;
}

6.2返回Void

类似原始serlvet 的开发。

响应结果的三种方法:

1、使用request转发页面,如下:

request.getRequestDispatcher("页面路径").forward(request, response);

2、也可以通过response页面重定向:

response.sendRedirect("url")

3、也可以通过response指定响应结果,例如响应json数据如下:

response.setCharacterEncoding("utf-8");

response.setContentType("application/json;charset=utf-8");

response.getWriter().write("json串");

6.3返回String(推荐使用)

1.页面转发方式

  格式是:forward:转发地址(不能写http://,只能写action的地址)

  特点:转发的上一个请求request和要转发的地址共用request,转发后浏览器的地址是不变化。

@RequestMapping("/login2.action")
public String login2(){
    return "forward:index.jsp";
}

2.页面重定向方式

  格式是:redirect:重定向地址(比如:http://.....)

  特点:重定的上一个请求request和要重定的地址不公用request,重定后浏览器的地址是变化的。

@RequestMapping("/login2.action")
public String login3(){
    return "redirect:index.jsp";
}

3.表示逻辑视图名

  返回一个string如果即不是转发格式,也不是重定向的格式,就表示一个逻辑视图名。

@RequestMapping("/login2.action")
public String login(){
    return "index.jsp";
}

7、Springmvc实现数据回显

数据回显就是把数据传给页面,在jsp页面可以直接通过${}来获取内容

7.1使用ModelAndView回显数据

@Override
public ModelAndView handleRequest(javax.servlet.http.HttpServletRequest httpServletRequest, javax.servlet.http.HttpServletResponse httpServletResponse) throws Exception {
    ModelAndView modelAndView=new ModelAndView();
    //传递参数给页面,类似于域对象
    modelAndView.addObject("msg","这是mvc");
    modelAndView.setViewName("index.jsp");
    return modelAndView;
}

7.2使用Model回显数据

在请求转发时常常使用。

@RequestMapping("/login6.action")
public String login6(Model model){
   model.addAttribute("msg","我是model传递过来的数据");
   return "index.jsp";
}

7.3使用@ModelAttribute回显数据

//把方法的返回值封装到model中,携带到要跳转的页面中
//添加注解后这个方法是全局的,不管任何一个方法执行都会调用这个方法,不常用
@ModelAttribute
public User getUser(){
    User user=new User();
    user.setUsername("hhh");
    user.setPassword("123");
    return user;
}
//在jsp页面可以使用${user.username}的方式取到值

7.4将请求时携带的参数作为数据回显

如下代码会把传递过来的user放到model中携带到要跳转的界面

//将传入的参数作为参数返回到页面
@RequestMapping("/login2.action")
public String login2(@ModelAttribute("user") User user){
    return "index.jsp";
}
//在jsp页面可以使用${user.username}的方式取到值

7.5重定向传递数据

当使用return “index.jsp”传递数据给页面时,可以使用request方法,上面已经介绍了,下面介绍重定向传递数据。重定向传递数据使用RedirectAttributes类,使用方式见下面代码:

addAttribute可以把参数传递给页面,但是只是拼接在地址栏中

@RequestMapping("/login.action")
public String login(RedirectAttributes attributes){
    attributes.addAttribute("msg","我是addAttribute");
    return "redirect:index.jsp";
}

addFlashAttribute把参数传递给页面,存放在session的map中,使用完毕后自动清空session。如果要获取参数,不能直接获取,要使用@ModelAttribute

@RequestMapping("/login.action")
public String login(RedirectAttributes attributes){
    attributes.addFlashAttribute("msg","我是addFlashAttribute");
    return "redirect:index.jsp";
}

以上两种方式虽然都可以传递参数到页面,但是页面不能显示这些数据,因此需要其他方式结合来使用。

第一种方式:内部跳转(分发器)

@Controller
public class Login {
    @RequestMapping("/login.action")
    public String login(RedirectAttributes attributes){
        attributes.addFlashAttribute("msg","我是addFlashAttribute");
        //这里不直接跳转到页面,而是内部跳转,然后再跳转到页面
        return "redirect:login_jsp.action";
    }

    @RequestMapping("login_jsp.action")
    public String login(@ModelAttribute("msg")String msg){
        System.out.println(msg);
        return "index.jsp";
    }
}

第二种方式:直接将数据存放到session中,类似于之前的servlet中重定向的传值,获取到数据后清空session.

8Springmvc对异常的处理

8.1处理异步骤:

当异常发生时跳转到错误的页面,给用户相应的提示

1、自定义一个异常类用于抛出异常

package com.controller;

public class MyException extends Exception {
    //自定义异常,继承Exception,重写父类中的部分方法
    public MyException() {}
    public MyException(String message) {
        super(message);
    }
}

2、创建一个异常处理器,实现ExceptionResolver接口,并交给springmvc管理

package com.controller;

import org.springframework.stereotype.Component;
import org.springframework.web.servlet.HandlerExceptionResolver;
import org.springframework.web.servlet.ModelAndView;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
@Component
public class HandlerException implements HandlerExceptionResolver {
    //创建一个异常处理器,实现ExceptionResolver接口
//只要任何一层发生异常,就会调用下面的方法 
    @Override
    public ModelAndView resolveException(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o, Exception e) {
        ModelAndView modelAndView=new ModelAndView();
    //判断是自定义异常还是系统异常
        if(e instanceof MyException){
            modelAndView.addObject("msg",e.getMessage());
        }else{
            modelAndView.addObject("msg","服务器飞啦,请稍后再试");
        }
        modelAndView.setViewName("error.jsp");
        return modelAndView;
    }
}

3、写一个类,测试异常

package com.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
@Controller
public class Test {
    @RequestMapping("test.action")
    public void test() throws MyException {
        //这里发生自定义异常,用于某些特定异常发生时处理异常
        MyException myException=new MyException("我是自定义异常");
        throw myException;
    }

    @RequestMapping("test2.action")
    public void test2(){
        //这里会发生系统异常
        int i=10/0;
    }
}

4、错误页面

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body><center>
<img src="http://img1.imgtn.bdimg.com/it/u=2272026066,3668786831&fm=26&gp=0.jpg"><br>
${msg}</center>
</body>
</html>

9Springmvc文件上传

1.导入所需要的jar

 

 

 2.创建上传文件的jsp

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>
<!--文件上传必须按照下面的格式写,缺一不可-->
<form action="upload.action" enctype="multipart/form-data" method="post">
    <input type="file" name="file">
    <input type="submit">
</form>
</body>
</html>

3.创建接收文件上传的controller

package com.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.multipart.MultipartFile;

import java.io.File;
import java.io.IOException;
import java.util.UUID;

@Controller
public class UploadController {
    @RequestMapping("/upload.action")
    public String upload(MultipartFile file) throws IOException {
        //多文件上传MultipartFile[] file,遍历这个数组
        if(file!=null&& file.getOriginalFilename()!=null&&!file.getOriginalFilename().equals("")){
           //获取文件的名字
            String fileName = file.getOriginalFilename();
            //获取文件的后缀名
            int index = fileName.lastIndexOf(".");
            //UUID这个方法是给文件命名,不重名
            String newFileName =UUID.randomUUID()+fileName.substring(index);
            File NewFile=new File("E:\\upload",newFileName);
            //把上传的文件的内容保写到保存的位置
            file.transferTo(NewFile);
        }
        return "success.jsp";

    }
}

4.springmvc.xml中配置文件解析器

<!-- Multipart解析器 -->
<bean id="multipartResolver" class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
    <!-- 设置上传文件的最大尺寸为5MB -->
    <property name="maxUploadSize">
        <value>5242880</value>
    </property>
</bean>

5.配置虚拟目录

将文件上传到固定的物理目录下,通过虚拟目录 访问物理目录 下的图片。

tomcat上配置虚拟目录,访问虚拟目录可以访问虚拟目录对应物理目录

server.xml添加以下代码: 

<Context docBase="F:\upload" path="/upload/files"/>

10springmvc处理json数据

@RequestBody注解将json数据转成java对象    ..test(@RequestBody User user{}

@ResponseBody注解实现将java对象转成json输出

10.1导包与配置

导入jackson包或fastjson包,springmvc默认是使用jackson包。

1)导入jackson包并配置springmvc.xml

 

 如果使用xml配置适配器和映射器,需要如下代码:

<!--注解适配器 -->
<bean class="org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter">
    <property name="messageConverters">
        <list>
            <bean class="org.springframework.http.converter.json.MappingJacksonHttpMessageConverter"></bean>
        </list>
    </property>
</bean>

如果使用注解配置适配器和映射器,就不要再配置。

2)导入fastjson包并配置springmvc.xml

<!--配置注解处理器映射器和适配器-->
<mvc:annotation-driven>
    <mvc:message-converters register-defaults="true">
        <bean class="com.alibaba.fastjson.support.spring.FastJsonHttpMessageConverter">
            <property name="supportedMediaTypes" value="application/json"/>
            <property name="features">
                <array>
                    <value>WriteMapNullValue</value>
                    <value>WriteDateUseDateFormat</value>
                </array>
            </property>
        </bean>
    </mvc:message-converters>
</mvc:annotation-driven>

10.2注册案例

1.register.jsp页面

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
    <script src="${pageContext.request.contextPath}/js/jquery-1.11.0.min.js"></script>
</head>
<body>
<input type="text" name="username" id="username"><font id="msg"></font>
<script>
    $(function(){
        $("#username").blur(function () {
            var username=$(this).val();
            $.post("regist.action",{"username":username},function (data) {
                $("#msg").html(data.message);
            });
        });
    })
</script>
</body>
</html>

2.UserController类

package com.controller;

import com.entity.JsonResult;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

@Controller
public class UserController {
    @RequestMapping("regist.action")
    @ResponseBody
     public JsonResult regist(String username){
         if("zys".equals(username)){
             return new JsonResult(false,"用户名已存在");
         }else{
             return new JsonResult(true,"验证通过");
         }
     }
}

3.注解介绍

@Controller
//是将这个类交给springmvc管理 @RestController
//它是等于@Controller+@ResponseBody,当这个类中的方法全部有返回值时可以直接使用,省去两个注解,它会在每个方法前面自动加@ResponseBody那么这个类只能做返回,不能页面跳转

11springmvcrest的支持

RESTful,即Representational State Transfer的缩写,表现层状态转化。所谓"资源",就是网络上的一个实体,或者说是网络上的一个具体信息,应四种基本操作:GET用来获取资源,POST用来新建资源(也可以用于更新资源),PUT用来更新资源,DELETE用来删除资源。

url模板映射:@RequestMapping(value="/ user/{id}"):{×××}占位符,请求的URL可以是“/user/1”或“/user/2”,通过在方法中使用@PathVariable获取{×××}中的×××变量。

@PathVariable用于将请求URL中的模板变量映射到功能处理方法的参数上。

Controller中添加如下代码:

 @RequestMapping("/test3/{id}")
public void test3(@PathVariable("id")int id){
    System.out.println("id"+id);
}

在浏览器进行测试,控制台会打印id47

 

注意:使用restful时,web.xml中url-pattern必须是/,不能是其他的,那么这样又会拦截一些需要的静态资源,所以需要在springmvc.xml中配置来加载静态资源:

 

<mvc:resources mapping="/js/**" location="/js/"></mvc:resources>
<mvc:resources mapping="/css/**" location="/css/"></mvc:resources>
mapping代表映射文件目录,**表示当前以及子类的所有文件夹,*只是当前文件夹

restful的使用(了解)

//restful四种方式的使用(了解)
@RequestMapping(value = "/user/{abc}",method = RequestMethod.GET)
public void add(@PathVariable("abc") int id){
    System.out.println("获取数据"+id);
}
@RequestMapping(value = "/user/{abc}",method = RequestMethod.DELETE)
public void delete(@PathVariable("abc") int id){
    System.out.println("删除数据"+id);
}
@RequestMapping(value = "/user/{abc}",method = RequestMethod.PUT)
public void update(@PathVariable("abc") int id){
    System.out.println("更新数据"+id);
}
@RequestMapping(value = "/user/{abc}",method = RequestMethod.POST)
public void newRes(@PathVariable("abc") int id){
    System.out.println("新建数据"+id);
}

12、 springmvc拦截器

12.1拦截器的作用

springmvc提供拦截器实现对Handler进行面向切面编程,可以Handler执行之前、之后、之中添加代码,这种方式就是切面编程

12.2使用拦截器步骤

1.定义一个类实现HanlderInterceptor接口

package com.controller;

import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

public class Myintercept implements HandlerInterceptor {
    //preHandle:在Handler执行之前调用
    @Override
    public boolean preHandle(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o) throws Exception {
        System.out.println("pre...");
        //return true代表放行
        //return flase代表拦截
        return true;
    }

    //postHandle:在Handler中方法执行一半时调用(return ModelAndView前),可以更改跳转的视图
    @Override
    public void postHandle(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o, ModelAndView modelAndView) throws Exception {
        System.out.println("post...");
    }

    //afterCompletion:在Handler执行完毕之后调用,可以用于异常的处理
    @Override
    public void afterCompletion(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o, Exception e) throws Exception {
        System.out.println("after...");
    }
}

2.在springmvc.xml中配置拦截器

<!--配置拦截器-->
<mvc:interceptors>
    <!--设置一个拦截路径,也可以写多个 <mvc:interceptor>拦截多个路径-->
    <mvc:interceptor>
        <!--path里面是要拦截的路径-->
        <mvc:mapping path="/test.action"/>
        <!--把Myintercept交给springmvc管理-->
        <bean class="com.controller.Myintercept"></bean>
    </mvc:interceptor>
</mvc:interceptors>

13SSM框架整合

 

 

 dao层:mybatis+spring

service层:spring

controller层:springmvc+spring

 整合步骤:

  1. 新建一个web项目,在WEB-INF目录下创建一个lib目录,为它添加包依赖
  2. 导入所有的jar包到lib中
  3. 在根目录下新建一个config目录,设置为资源目录,用于存放配置文件
  4. 把所有需要的配置文件放到config目录中,修改部分配置
  5. web.xml配置加载spring容器
  6. 新建所有的类和接口进行测试

转载于:https://www.cnblogs.com/zys2019/p/11439836.html

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值