spring 截取 url

转载

mob64ca14116c53 2024-09-20 17:51:04

文章标签 spring 截取 url xml 文件上传 spring 文章分类 架构后端开发

响应数据和视图解析

返回值是void

如果控制器的方法返回值编写成void，执行程序报404的异常，默认查找JSP页面没有找到。

默认会跳转到@RequestMapping(value="/xxx") xxx的页面

可以使用请求转发或者重定向跳转到指定的页面

@RequestMapping("testReturnVoid")
    public void testReturnVoid(HttpServletRequest request, HttpServletResponse response) throws Exception, IOException {
        //1 使用 request 转向页面
        //request.getRequestDispatcher("/WEB-INF/pages/success.jsp").forward(request,response);

        //2 也可以通过 response 页面重定向：
		//response.sendRedirect("testReturnString");
        //3 也可以通过 response 指定响应结果，例如响应 json 数据：
        response.setCharacterEncoding("utf-8");
        response.setContentType("application/json;charset=utf-8");
        response.getWriter().write("json 串");
    }

转发:是服务器发送状态码，客户端自己去访问目标资源
重定向：是服务器访问目标资源然后响应给客户端

返回值是ModelAndView对象

ModelAndView对象是Spring提供的一个对象，可以用来调整具体的JSP视图，可以传入视图的名称（即跳转的页面），还可以传入对象

success.jsp代码

<%@ page isELIgnored="false" language="java" contentType="text/html; charset=UTF-8"
         pageEncoding="UTF-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
"http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
    <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
    <title>执行成功</title>
</head>
<body>
执行成功！
<%--${requestScope.username}--%>
</body>
</html>

控制器代码

@RequestMapping("/testReturnModelAndView")
    public ModelAndView testReturnModelAndView() {
        ModelAndView mv=new ModelAndView();
        mv.addObject("username", "史珍香");
        mv.setViewName("success");
        return  mv;
    }

ResponseBody响应json数据

DispatcherServlet会拦截到所有的资源，导致一个问题就是静态资源（img、css、js）也会被拦截到，从而
不能被使用。解决问题就是需要配置静态资源不进行拦截，在springmvc.xml配置文件添加如下配置

mvc:resources标签配置不过滤

location元素表示webapp目录下的包下的所有文件
mapping元素表示以/static开头的所有请求路径，如/static/a 或者/static/a/b

<!-- 设置静态资源不过滤 -->
<mvc:resources location="/css/" mapping="/css/**"/> <!-- 样式 -->
<mvc:resources location="/images/" mapping="/images/**"/> <!-- 图片 -->
<mvc:resources location="/js/" mapping="/js/**"/> <!-- javascript -->

使用@RequestBody获取请求体数据

使用@RequestBody注解把json的字符串转换成JavaBean的对象
使用@ResponseBody注解把JavaBean对象转换成json字符串，直接响应（要求方法需要返回JavaBean的对象）

json字符串和JavaBean对象互相转换的过程中，需要使用jackson的jar包,在pom.xml添加依赖

<!--json包-->
    <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-core</artifactId>
      <version>2.9.0</version>
    </dependency>
    <dependency>
      <groupId>com.fasterxml.jackson.core</groupId>
      <artifactId>jackson-annotations</artifactId>
      <version>2.9.0</version>
    </dependency>

代码案例
jsp代码

function fun() {
            //创建核心对象
            var xmlhttp;
            if (window.XMLHttpRequest)
            {// code for IE7+, Firefox, Chrome, Opera, Safari
                xmlhttp=new XMLHttpRequest();
            }
            else
            {// code for IE6, IE5
                xmlhttp=new ActiveXObject("Microsoft.XMLHTTP");
            }
            //建立连接
            /*
                    参数：
                        1. 请求方式：GET、POST
                            * get方式，请求参数在URL后边拼接。send方法为空参
                            * post方式，请求参数在send方法中定义
                        2. 请求的URL：
                        3. 同步或异步请求：true（异步）或 false（同步）

                 */
            xmlhttp.open("post","springTest/testResponseJson",true);
            xmlhttp.setRequestHeader('content-type', 'application/json');
            //发送请求
            xmlhttp.send('{"name":"hehe","id":123,"money":30}');

            //4.接受并处理来自服务器的响应结果
            //获取方式 ：xmlhttp.responseText
            //什么时候获取？当服务器响应成功后再获取

            //当xmlhttp对象的就绪状态改变时，触发事件onreadystatechange。
            xmlhttp.onreadystatechange=function()
            {
                //判断readyState就绪状态是否为4，判断status响应状态码是否为200
                if (xmlhttp.readyState==4 && xmlhttp.status==200)
                {
                    //获取服务器的响应结果    responseText	获得字符串形式的响应数据。
                    //responseXML	获得 XML形式的响应数据。
                    var responseText=xmlhttp.responseText;
                    alert(responseText);
                }
            }

        }

    <input type="button" value="发送异步请求" onclick="fun();">

控制器代码

package cn.org.zhang.domain;

public class TestUser {
    private String name;
    private Integer id;
    private Integer money;

    public String getName() {
        return name;
    }

    @Override
    public String toString() {
        return "TestUser{" +
                "name='" + name + '\'' +
                ", id=" + id +
                ", money=" + money +
                '}';
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public Integer getMoney() {
        return money;
    }

    public void setMoney(Integer money) {
        this.money = money;
    }
}

@RequestMapping("/testResponseJson")
    public @ResponseBody TestUser testResponseJson(@RequestBody TestUser testUser){
        System.out.println("异步请求："+testUser);
        testUser.setId(100);
        return testUser;
    }

SpringMVC实现文件上传

传统文件和springmvc文件上传

导入文件上传的jar包

<!-- springmvc文件上传组件-->
    <dependency>
      <groupId>commons-fileupload</groupId>
      <artifactId>commons-fileupload</artifactId>
      <version>1.3.1</version>
    </dependency>
    <dependency>
      <groupId>commons-io</groupId>
      <artifactId>commons-io</artifactId>
      <version>2.4</version>
    </dependency>

springmvc.xml配置文件解析器对象

<!-- 配置文件解析器对象，要求id名称必须是multipartResolver -->
    <bean id="multipartResolver" class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
        <property name="maxUploadSize" value="10485760"/>
    </bean>

SpringMVC框架提供了MultipartFile对象，该对象表示上传的文件，要求变量名称必须和表单file标签的
name属性名称相同

<%--文件上传--%>
    <form action="springTest/fileUpload2" method="post" enctype="multipart/form-data">
        <%--使用springmvc文件上传组件 upload名必须和控制器MultipartFile参数名称相同--%>
        选择文件：<input type="file" name="upload"/><br/>
        <input type="submit" value=" 上传 "/>
    </form>

//传统文件上传
    @RequestMapping("/fileUpload")
    public String fileUpload(HttpServletRequest request)  throws Exception {
        /// 先获取到要上传的文件目录
        String path=request.getSession().getServletContext().getRealPath("/uploads");
        //创建文件对象
        File file=new File(path);
        if(!file.exists()){
            file.mkdir();
        }
        //解析request对象，获取上传文件项
        DiskFileItemFactory factory=new DiskFileItemFactory();
        ServletFileUpload upload=new ServletFileUpload(factory);
        //解析request
        List<FileItem> items=upload.parseRequest(request);
        for (FileItem fileItem:items){
            if(fileItem.isFormField()){
                //普通表单项
            }else {
                //上传文件项
                String fileName=fileItem.getName();
                // 把文件的名称设置唯一值，uuid
                String uid=UUID.randomUUID().toString().replace("-", "");
                fileName=uid+"_"+fileName;
                //完成文件上传
                fileItem.write(new File(path,fileName));
                //删除临时文件
                fileItem.delete();

            }
        }
        return "success";
    }
    //SpringMVC文件上传
    //变量名称必须和表单file标签的name属性名称相同
    @RequestMapping("/fileUpload1")
    public String fileUpload1(HttpServletRequest request,MultipartFile upload)  throws Exception {
        // 使用fileupload组件完成文件上传
        // 上传的位置
        String path = request.getSession().getServletContext().getRealPath("/uploads/");
        // 判断，该路径是否存在
        File file = new File(path);
        if(!file.exists()){
            // 创建该文件夹
            file.mkdirs();
        }
        // 获取上传文件的名称
        String fileName=upload.getOriginalFilename();
        // 把文件的名称设置唯一值，uuid
        String uuid = UUID.randomUUID().toString().replace("-", "");
        fileName = uuid+"_"+fileName;
        //完成文件上传
        upload.transferTo(new File(path,fileName));
        return "success";
    }

跨服文件上传

搭建图片服务器

新建tomcat服务器,新建项目，修改服务器端口和jvm端口

创建文件夹存放图片

开启tomcat文件读写权限

<!--    开启读写文件权限          -->
        <init-param>
            <param-name>readonly</param-name>
            <param-value>false</param-value>
        </init-param>

导入jar包

<!-- springmvc跨服文件上传的jar包-->
    <dependency>
      <groupId>com.sun.jersey</groupId>
      <artifactId>jersey-core</artifactId>
      <version>1.18.1</version>
    </dependency>
    <dependency>
      <groupId>com.sun.jersey</groupId>
      <artifactId>jersey-client</artifactId>
      <version>1.18.1</version>
    </dependency>

jsp代码

<%--文件上传--%>
    <form action="springTest/fileUpload2" method="post" enctype="multipart/form-data">
        <%--使用springmvc文件上传组件 upload名必须和控制器MultipartFile参数名称相同--%>
        选择文件：<input type="file" name="upload"/><br/>
        <input type="submit" value=" 上传 "/>
    </form>

控制器代码

//SpringMVC跨服文件上传
    @RequestMapping("/fileUpload2")
    public String fileUpload2(MultipartFile upload)  throws Exception {
        // 定义上传文件服务器路径
        String path = "http://localhost:9090/fileServer_war_exploded/uploads/";
        // 获取上传文件的名称
        String fileName=upload.getOriginalFilename();
        // 把文件的名称设置唯一值，uuid
        String uuid = UUID.randomUUID().toString().replace("-", "");
        fileName = uuid+"_"+fileName;
        //创建客户端
        Client client=Client.create();
        // 和图片服务器进行连接
        WebResource webResource=client.resource(path+fileName);
        //上传文件
        webResource.put(upload.getBytes());
        return "success";
    }

SpringMVC的异常处理

异常处理流程

Controller调用service，service调用dao，异常都是向上抛出的，最终有DispatcherServlet找异常处理器进
行异常的处理

SpringMVC的异常处理

springmvc.xml配置异常处理器

<!-- 配置异常处理器 -->
    <bean id="sysExceptionResolver" class="cn.org.zhang.exception.SysExceptionResolver"/>

自定义异常类

package cn.org.zhang.exception;

public class SysException extends Exception {
    //存储提示信息
    private String message;

    public String getMessage() {
        return message;
    }

    public void setMessage(String message) {
        this.message = message;
    }

    public SysException(String message) {
        this.message = message;
    }
}

自定义异常处理器

package cn.org.zhang.exception;

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

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

public class SysExceptionResolver implements HandlerExceptionResolver {

    @Override
    public ModelAndView resolveException(HttpServletRequest httpServletRequest, HttpServletResponse httpServletResponse, Object o, Exception e) {
        //获取异常对象
        SysException ex = null;
        if(e instanceof SysException ){
            ex=(SysException)e;
        }else {
            ex=new SysException("系统正在维护");
        }
        //创建ModelAndView对象
        ModelAndView mv=new ModelAndView();
        mv.addObject("errorMsg", ex.getMessage());
        mv.setViewName("error");
        return mv;
    }
}

jsp代码

<a href="springTest/testException" >异常处理</a>

控制器代码

@RequestMapping("/testException")
    public String testException() throws SysException{
        System.out.println("testException执行了...");
        try {
            // 模拟异常
            int a = 10/0;
        } catch (Exception e) {
            // 打印异常信息
            e.printStackTrace();
            // 抛出自定义异常信息
            throw new SysException("查询所有用户出现错误了...");
        }
        return "success";
    }

SpringMVC框架中的拦截器

SpringMVC框架中的拦截器用于对处理器进行预处理和后处理的技术。
可以定义拦截器链，连接器链就是将拦截器按着一定的顺序结成一条链，在访问被拦截的方法时，拦截器链
中的拦截器会按着定义的顺序执行。
拦截器和过滤器的功能比较类似，有区别
过滤器是Servlet规范的一部分，任何框架都可以使用过滤器技术。
拦截器是SpringMVC框架独有的。
过滤器配置了/*，可以拦截任何资源。
拦截器只会对控制器中的方法进行拦截。
拦截器也是AOP思想的一种实现方式
想要自定义拦截器，需要实现HandlerInterceptor接口

自定义拦截器步骤

在springmvc.xml中配置拦截器类

<!-- 配置拦截器 -->
    <mvc:interceptors>
        <mvc:interceptor>
            <!-- 哪些方法进行拦截 -->
            <mvc:mapping path="/springTest/*"/>
            <!-- 哪些方法不进行拦截
            <mvc:exclude-mapping path=""/>
            -->
            <!-- 注册拦截器对象 -->
            <bean class="cn.org.zhang.interceptor.MyInterceptor1"/>
        </mvc:interceptor>

        <mvc:interceptor>
            <!-- 哪些方法进行拦截 -->
            <mvc:mapping path="/**"/>
            <!-- 注册拦截器对象 -->
            <bean class="cn.org.zhang.interceptor.MyInterceptor2"/>
        </mvc:interceptor>
    </mvc:interceptors>

创建类，实现HandlerInterceptor接口，重写需要的方法

package cn.org.zhang.interceptor;

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

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

public class MyInterceptor1 implements HandlerInterceptor {
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        System.out.println("MyInterceptor1,控制器方法前执行");
        return true;
    }

    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        System.out.println("MyInterceptor1,控制器方法后执行");
    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        System.out.println("MyInterceptor1,jsp后执行");

    }
}

package cn.org.zhang.interceptor;

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

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

public class MyInterceptor2 implements HandlerInterceptor {
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        System.out.println("MyInterceptor2,控制器方法前执行");
        return true;
    }

    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        System.out.println("MyInterceptor2,控制器方法后执行");
    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        System.out.println("MyInterceptor2,jsp后执行");

    }
}