SpringMVC-02

阅读量

1 获取Servlet的API

在Spring MVC获取原生的Servlet中的相关对象：HttpServletRequest request, HttpServletResponse response, HttpSession session

只需要在处理器方法中定义这3种类型的形式参数即可：

1
public String servletApi(HttpServletRequest request, HttpServletResponse response, HttpSession session)

相关注解：

@RequestHeader：获取指定的请求头数据

1
public String headApi(@RequestHeader("Accept-Encoding") String headMsg)

@CookieValue：获取指定的cookie数据

1
public String cookieApi(@CookieValue("JSESSIONID") String jsessionid)

@SessionAttribute：获取Session中的数据

1
2
3
public String sessionApi(@SessionAttribute("name") String name,
                         @SessionAttribute("age") int age,
                         @SessionAttribute("gender") String gender)

@SessionAttributes：把Model中的指定的数据存储到Session中

1
2
3
4
5
6
7
8
9
10
11
@SessionAttributes(names = {"age","gender"})
public class UserController {

    @RequestMapping("/setSessionData2")
    public String setSessionDate2(Model model) {
        model.addAttribute("age",39);
        model.addAttribute("gender","男");
        return "page";
    }
    
}

2 异步请求

2.1 请求体数据的封装

把要异步请求中请求体的数据通过spring mvc进行接收，只需要在方法的形式参数上使用**@RequestBody**进行标注。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
@RequestMapping("/ajaxController")
//使用@RequestBody注解，可以将请求体内容封装到指定参数中
public String ajaxController(@RequestBody String message){
    System.out.println("ajax request is running..."+message);
    return "page.jsp";
}

@RequestMapping("/ajaxPojoToController")
//如果处理参数是POJO，且页面发送的请求数据格式与POJO中的属性对应，@RequestBody注解可以自动映射对应请求数据到POJO中
//注意：POJO中的属性如果请求数据中没有，属性值为null，POJO中没有的属性如果请求数据中有，不进行映射
public String  ajaxPojoToController(@RequestBody User user){
    System.out.println("controller pojo :"+user);
    return "page.jsp";
}

@RequestMapping("/ajaxListToController")
//如果处理参数是List集合且封装了POJO，且页面发送的数据是JSON格式的对象数组，数据将自动映射到集合参数中
public String  ajaxListToController(@RequestBody List<User> userList){
    System.out.println("controller list :"+userList);
    return "page.jsp";
}

2.2 给前端响应数据

使用**@ResponseBody**注解对方法进行标注即可。

@ResponseBody：会使用指定的转换器将方法的返回值转换成指定的类型，然后将这个返回值作为响应体数据，响应到前端。

默认情况下，方法的返回值类型只支持String类型。

1
2
3
4
public @ResponseBody String ajaxReturnString(){
    System.out.println("controller return string ...");
    return "page.jsp";
}

如果说我们方法的返回值类型不是String，Spring MVC就会使用指定的转换器将返回值转换成json数据，然后将这个返回值作为响应体数据，响应到前端。

在Spring MVC把一个实体类转换成json数据使用到的转换器：MappingJackson2HttpMessageConverter

要使用这个转换器进行转换，底层使用的就是jackson的工具，因此需要在项目中加入jackson依赖。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
<!--json相关坐标3个-->
<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-core</artifactId>
    <version>2.9.0</version>
</dependency>
<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
    <version>2.9.0</version>
</dependency>
<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-annotations</artifactId>
    <version>2.9.0</version>
</dependency>

示例代码：

1
2
3
4
5
6
7
8
9
10
@RequestMapping("/ajaxReturnJson")
@ResponseBody
public User ajaxReturnJson(){								//基于jackon技术，使用@ResponseBody注解可以将返回的POJO对象转成json格式数据
    System.out.println("controller return json pojo...");
    User user = new User();
    user.setName("Jockme");
    user.setAge(39);
    return user;
}

2.3 跨域问题

什么跨域？通过一个域的js代码请求另外一个域的后端地址。

同域是可以访问的：什么是同域？协议、ip、域名、端口都是相同的

解决方案？

在方法上或者类上使用**@CrossOrigin**进行标注即可。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
@RequestMapping("/cross")
@ResponseBody
//使用@CrossOrigin开启跨域访问
//标注在处理器方法上方表示该方法支持跨域访问
//标注在处理器类上方表示该处理器类中的所有处理器方法均支持跨域访问
@CrossOrigin
public User cross(HttpServletRequest request){
    System.out.println("controller cross..."+request.getRequestURL());
    User user = new User();
    user.setName("Jockme");
    user.setAge(39);
    return user;
}

3 拦截器

3.1 拦截器概述

作用：拦截请求

为什么要进行请求拦截？

把请求拦截下来的主要作用：对访问权限进行判断

整体请求响应的过程：

Filter和拦截器的区别：

1、Filter是属于JavaEE规范的技术，拦截器是属于Spring MVC的技术

2、Filter可以拦截所有的请求，拦截器只拦截满足DispatcherServlet处理规则的请求

3.2 拦截器的开发

开发步骤：

1、自定义一个拦截器

2、在Spring MVC的配置文件中去配置拦截器

自定义一个拦截器：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
public class MyInterceptor implements HandlerInterceptor {
    //处理器运行之前执行
    @Override
    public boolean preHandle(HttpServletRequest request,
                             HttpServletResponse response,
                             Object handler) throws Exception {
        System.out.println("前置运行----a1");
        //返回值为false将拦截原始处理器的运行
        //如果配置多拦截器，返回值为false将终止当前拦截器后面配置的拦截器的运行
        return true;
    }

    //处理器运行之后返回ModelAndView之前
    @Override
    public void postHandle(HttpServletRequest request,
                           HttpServletResponse response,
                           Object handler,
                           ModelAndView modelAndView) throws Exception {
        System.out.println("后置运行----b1");
    }

    //处理器运行之后返回ModelAndView之后
    @Override
    public void afterCompletion(HttpServletRequest request,
                                HttpServletResponse response,
                                Object handler,
                                Exception ex) throws Exception {
        System.out.println("完成运行----c1");
    }

    //三个方法的运行顺序为    preHandle -> postHandle -> afterCompletion
    //如果preHandle返回值为false，三个方法仅运行preHandle
}

在Spring MVC的配置文件中去配置拦截器

1
2
3
4
5
6
7
8
9
<!--开启拦截器使用-->
<mvc:interceptors>
    <mvc:interceptor>
        <!-- 配置拦截器的拦截规则 -->
        <mvc:mapping path="/handleRun"/>
        <bean class="com.itheima.interceptor.MyInterceptor" />  <!-- 配置拦截器 -->
    </mvc:interceptor> 
</mvc:interceptors>

加入拦截器以后的请求流程：

3.3 拦截器方法参数

方法参数：

  • HttpServletRequest request ： 请求对象
  • HttpServletResponse response ： 响应对象
  • Object handler ： 处理器（就是对应的方法对象）
  • ModelAndView modelAndView : 模型和视图信息的对象
  • Exception ex : 表示的就是处理器异常信息

拦截规则的配置：

1
2
3
4
5
6
<mvc:mapping path="/*"/>						<!-- 拦截所有的一级请求 -->
<mvc:mapping path="/**"/>						<!-- 拦截所有的请求 -->
<mvc:mapping path="/handleRun"/>
<!--设置拦截排除的路径，配置/**或/*，达到快速配置的目的-->
<mvc:exclude-mapping path="/b*"/>

3.4 多拦截器的配置

多拦截器的配置：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
<!--开启拦截器使用-->
<mvc:interceptors>

    <!--开启具体的拦截器的使用，可以配置多个-->
    <mvc:interceptor>
        <!--设置拦截器的拦截路径，支持*通配-->
        <!--/**         表示拦截所有映射-->
        <!--/*          表示拦截所有/开头的映射-->
        <!--/user/*     表示拦截所有/user/开头的映射-->
        <!--/user/add*  表示拦截所有/user/开头，且具体映射名称以add开头的映射-->
        <!--/user/*All  表示拦截所有/user/开头，且具体映射名称以All结尾的映射-->
        <mvc:mapping path="/*"/>
        <mvc:mapping path="/**"/>
        <mvc:mapping path="/handleRun*"/>
        <!--设置拦截排除的路径，配置/**或/*，达到快速配置的目的-->
        <mvc:exclude-mapping path="/b*"/>
        <!--指定具体的拦截器类-->
        <bean class="MyInterceptor"/>
    </mvc:interceptor>
    <!--配置多个拦截器，配置顺序即为最终运行顺序-->
    <mvc:interceptor>
        <mvc:mapping path="/*"/>
        <bean class="MyInterceptor2"/>
    </mvc:interceptor>
    <mvc:interceptor>
        <mvc:mapping path="/*"/>
        <bean class="MyInterceptor3"/>
    </mvc:interceptor>

</mvc:interceptors>

执行顺序就是配置顺序。

4 异常处理

4.1 传统方式

三层架构中针对每一层的异常应该如何处理？

dao：不处理

service：不处理

controller：肯定需要进行处理

问题怎么处理？

现在我们在Controller中没有对异常进行处理，此时如果程序产生了异常，会交给Spring MVC中的异常处理器（HandlerExceptionResolver）进行处理。这个异常处理器

获取到异常了以后，会把异常的错误信息返回给页面。

这种处理机制不太友好，怎么办？

1、在每一个方法中进行try…catch中（麻烦）

2、进行统一的异常处理（自定义异常处理器）

实现方案:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
@Component
public class ExceptionResolver implements HandlerExceptionResolver {

    @Override
    public ModelAndView resolveException(HttpServletRequest request,  HttpServletResponse response,  Object handler,  Exception ex) {
        System.out.println("my exception is running ...."+ex);
        ModelAndView modelAndView = new ModelAndView();
        if( ex instanceof NullPointerException){
            modelAndView.addObject("msg","空指针异常");
        }else if ( ex instanceof  ArithmeticException){
            modelAndView.addObject("msg","算数运算异常");
        }else{
            modelAndView.addObject("msg","未知的异常");
        }
        modelAndView.setViewName("error.jsp");
        return modelAndView;
    }
}

4.2 注解方式

常见注解：

@Component：把某一个bean纳入到spring容器中

@ControllerAdvice：声明当前这个类就是一个异常处理器

@ExceptionHandler：使用在方法上，用来处理指定的异常

示例代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
@Component
@ControllerAdvice
public class ExceptionAdvice {

    //类中定义的方法携带@ExceptionHandler注解的会被作为异常处理器，后面添加实际处理的异常类型
    @ExceptionHandler(NullPointerException.class)
    @ResponseBody
    public String doNullException(Exception ex){
        return "空指针异常";
    }

    @ExceptionHandler(ArithmeticException.class)
    @ResponseBody
    public String doArithmeticException(Exception ex){
        return "ArithmeticException";
    }

    @ExceptionHandler(Exception.class)
    @ResponseBody
    public String doException(Exception ex){
        return "all";
    }

}

4.3 在项目中去处理异常

上述的异常处理方案存在的弊端：随着异常类型的增多需要不断的去添加新的方法进行异常处理。

分析项目中常见的异常的分类：

1、业务异常

  • 不满足业务规则的时候，就可以主动的去产生一些异常
  • 举例：系统要求注册的用户的年龄必须在18-100之间

2、系统异常

  • 系统级别的异常
  • 举例：数据库连接不上了

可以自定义这两种异常，然后当程序真正的产生了异常，此时只需要将这个异常转换成对应的自定义异常即可。这时我们的异常处理器只需要去处理两种类型的异常即可。

如何把程序产生的异常转换成对应的自定义的异常呢？

1
2
3
4
5
6
7
8
9
10
11
12
13
public class UserServlceImpl {

    public void save(){
        //业务层中如果出现了异常，就对出现异常的代码进行try...catch...处理
        //在catch中将出现的异常包装成自定义异常，同时务必将当前异常对象传入自定义异常，避免真正的异常信息消失
        try {
            throw new SQLException();
        } catch (SQLException e) {
            throw new SystemException("数据库连接超时！",e);
        }
    }
}

异常处理器：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
@Component
@ControllerAdvice
public class ProjectExceptionAdvice {

    @ExceptionHandler(BusinessException.class)
    public String doBusinessException(Exception ex, Model m){
        //使用参数Model将要保存的数据传递到页面上，功能等同于ModelAndView
        //业务异常出现的消息要发送给用户查看
        m.addAttribute("msg",ex.getMessage());
        return "error.jsp";
    }

    @ExceptionHandler(SystemException.class)
    public String doSystemException(Exception ex, Model m){
        //系统异常出现的消息不要发送给用户查看，发送统一的信息给用户看
        m.addAttribute("msg","服务器出现问题，请联系管理员！");
        //实际的问题现象应该传递给redis服务器，运维人员通过后台系统查看
        //实际的问题显现更应该传递给redis服务器，运维人员通过后台系统查看
        return "error.jsp";
    }

    @ExceptionHandler(Exception.class)
    public String doException(Exception ex, Model m){
        m.addAttribute("msg",ex.getMessage());
        //将ex对象保存起来
        return "error.jsp";
    }

}

5 文件上传

5.1 实现

页面表单要求：

1、提交方式必须是POST

2、表单的enctype属性必须是：enctype=”multipart/form-data”

3、表单中必须存在一个文件表单项

Spring MVC实现文件上传：

Spring MVC实现文件上传的时候底层也是对Apache下面的fileupload组件进行封装。因此就需要在pom.xml文件中加入依赖：

1
2
3
4
5
6
<dependency>
    <groupId>commons-fileupload</groupId>
    <artifactId>commons-fileupload</artifactId>
    <version>1.4</version>
</dependency>

默认情况Spring MVC是不支持文件上传的，要进行文件的上传就需要去开启一个文件上传的组件：MultipartResolver(接口)

1
2
3
4
5
<!--配置文件上传处理器, 这个bean的id必须是multipartResolver-->
<bean id="multipartResolver" class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
    <property name="maxUploadSize" value="1024000000"/>
</bean>

后端代码：

1
2
3
4
public String fileupload(MultipartFile file) throws IOException {	// MultipartFile封装了文件的相关数据， 参数的名称需要和文件表单项的名称一致
	file.transferTo(new File("abc.png"));
}

5.2 注意事项

注意事项：

1、文件大小的设置

1
2
3
4
5
<!--配置文件上传处理器-->
<bean id="multipartResolver" class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
    <property name="maxUploadSize" value="1024000000"/>
</bean>

2、文件名重复问题

思路：给保存的文件设置一个唯一的文件名称即可

1
2
String newFileName = UUID.randomUUID().toString().replace("-", "");

3、进行目录打撒

常见的打撒算法：

规则：获取文件名所对应的哈希值，使用哈希值第一个作为1级目录 ， 使用哈希值第二个作为2级目录 ， 使用哈希值第三个作为3级目录

6 Restful接口

6.1 入门案例

接口：其实就是一个http的请求地址。

相关概念：

Rest：其实就是网络资源的一种访问风格。就是把请求参数作为请求路径的一部分。

网络资源的访问就是通过http的接口进行访问：

1、传统的http接口

查询：http://localhost:8080/user/findById?id=1

2、Rest风格

查询：http://localhost:8080/user/findById/1

使用Rest风格的好处：简化url

Restful：就是按照Rest的封装去访问网络资源

网络资源的访问是存在很多的操作的：增，删，改，查

通过Restful的方式去访问网络资源，如何去区分具体的操作呢？

约定：

GET: 表示的就是查询

POST: 表示的就是新增

PUT: 表示的就是修改

DELETE: 表示的就是删除

如何去开发一个Rrestful风格的接口：

1
2
3
4
5
6
7
8
9
// http://localhost:8080/user/1
// http://localhost:8080/user/2
@RequestMapping(value="/user/{userId}" , method = RequestMethod.GET)			// {userId}：表示占位符
@ResponseBody							// 把方法的返回值作为响应体响应给浏览器
public String restLocation(@PathVariable(name="userId") Integer id){		//使用@PathVariable注解获取路径上配置的具名变量，该配置可以使用多次
    System.out.println("restful is running ....");
    return "success.jsp";
}

@PathVariable: 主要作用就是从请求地址中获取指定的请求参数

@RequestParam：用来指定请求参数的名称，适用于传统方式的url请求地址：http://localhost:8080/user/findById?id=1

@RequestBody：获取异步请求中请求体的数据将其封装到方法形式参数上

@RestController注解：相当于@Controller和@ResponseBody

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Controller
@ResponseBody
public @interface RestController {

   /**
    * The value may indicate a suggestion for a logical component name,
    * to be turned into a Spring bean in case of an autodetected component.
    * @return the suggested component name, if any (or empty String otherwise)
    * @since 4.0.1
    */
   @AliasFor(annotation = Controller.class)
   String value() default "";

}

6.2 常见注解

常见注解：

1
2
3
4
5
@GetMapping			相当于: @RequestMapping(value = "{id}",method = RequestMethod.GET)
@PostMapping		相当于: @RequestMapping(value = "{id}",method = RequestMethod.POST)
@PutMapping			相当于: @RequestMapping(value = "{id}",method = RequestMethod.PUT)
@DeleteMapping		相当于: @RequestMapping(value = "{id}",method = RequestMethod.DELETE)

注意事项：

默认情况下页面表单所支持的请求方式只有GET和POST

如果需要通过页面表单来发送PUT或者DELETE的请求，此时就需要进行如下配置：

1、在页面表单中添加一个隐藏域

1
2
3
4
5
6
7
<form action="/user/1" method="post">
    <%--当添加了name为_method的隐藏域时，可以通过设置该隐藏域的值，修改请求的提交方式，切换为PUT请求或DELETE请求，但是form表单的提交方式method属性必须填写post--%>
    <%--该配置需要配合HiddenHttpMethodFilter过滤器使用，单独使用无效，请注意检查web.xml中是否配置了对应过滤器--%>
    <input type="text" name="_method" value="PUT"/>
    <input type="submit"/>
</form>

隐藏域的名称必须是_method

2、在web.xml文件中去添加一个过滤器HiddenHttpMethodFilter（这个过滤器的主要作用就是把表单的POST请求转换成指定的请求方式）

1
2
3
4
5
6
7
8
9
10
<!--配置拦截器，解析请求中的参数_method，否则无法发起PUT请求与DELETE请求，配合页面表单使用-->
<filter>
    <filter-name>HiddenHttpMethodFilter</filter-name>
    <filter-class>org.springframework.web.filter.HiddenHttpMethodFilter</filter-class>
</filter>
<filter-mapping>
    <filter-name>HiddenHttpMethodFilter</filter-name>
    <servlet-name>DispatcherServlet</servlet-name>
</filter-mapping>

6.3 postman工具

工具作用: 可以直接去发送Restful风格的请求，类似于浏览器

赏

谢谢你请我吃糖果

扫一扫，分享到微信

微信分享二维码

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

一枚17级软件工程学生<br><br>愿待java如初恋<br>也希java诚待我