java之SpringMVC

最新推荐文章于 2024-09-21 10:38:43 发布

「已注销」

最新推荐文章于 2024-09-21 10:38:43 发布

阅读量191

点赞数

分类专栏： SpringMVC 文章标签： java

本文链接：https://blog.csdn.net/weixin_49588744/article/details/107707244

版权

SpringMVC 专栏收录该内容

3 篇文章 0 订阅

订阅专栏

SpringMVC

1. 什么是SpringMVC?
答:SpringMVC是web层的mvc开发框架，数据Spring框架的WEB模块中的一部分。

2. SpringMVC的执行流程
答:
1. 启动服务器的时候配置在web.xml文件中的中央控制器 (DispatcherServlet) 被初始化完成，并且加载配置的springMVC的配置文件。
2. 客户端浏览器发送http请求。
3. http请求被中央控制器 (DispatcherServlet) 拦截，转交给url解析器解析。
4. Url解析器解析http请求，得到具体的请求路径。
5. Url解析器将解析得到的具体的请求路径返回给中央控制器 (DispatcherServlet) 。
6. 中央控制器 (DispatcherServlet) 将得到的具体的请求路径转交给控制器适配器。
7. 控制器适配器根据具体的请求路径查找与之对应的请求处理类。
8. 请求处理类就执行具体的请求处理，得到ModelAndView对象 (1.数据。2.跳转地址)，将ModelAndView对象交给控制器适配器，控制器适配器将ModelAndView对象返回给中央控制器 (DispatcherServlet)。
9. 中央控制器 (DispatcherServlet) 将ModelAndView对象转交给视图解析器去解析。
10. 视图解析器解析ModelAndView对象，得到一个具体的数据显示路径，将这个具体的数据显示路径返回给中央控制器(DispatcherServlet)。
11. 中央控制器 (DispatcherServlet) 得到具体的数据显示路径之后，将路径所代表的资源转换执行成一个html数据。
将转换执行后的html数据返回给客户端浏览器。
在这里插入图片描述

3. 请求的访问路径配置
答:
1. web.xml文件中DispatcherServlet配置的
1.1 /
对应 http://127.0.0.1:8080/springmvc1/add
1.2 .do
对应 http://127.0.0.1:8080/springmvc1/add.do
1.3 / 这是一个错误的方式

2.springmvc配置文件中的控制器的name属性值
	控制器的name属性值设置要与web.xml文件中DispatcherServlet配置的<url-pattern>的配置形式一致
2.1  web.xml文件中DispatcherServlet配置的<url-pattern>/</url-pattern>那么springmvc配置文件中的控制器的name属性值应该为“/xxxx”
2.2  web.xml文件中DispatcherServlet配置的<url-pattern>*.do</url-pattern>那么springmvc配置文件中的控制器的name属性值应该为“/xxxx.do”
	以后控制器的name属性值会被@RequestMapper注解的value属性代替

1.创建一个普通的java类，实现org.springframework.web.servlet.mvc.Controller接口
2.重写handleRequest方法【处理用请求的方法】
3.在springmvc的配置文件中配置

<!-- 控制器 -->
<!-- 与web.xml文件中的中央处理器DispatcherServlet的url-pattern的配置形式匹配-->
<bean name="/hello" class="com.click369.springmvc.controller.HelloController"></bean>

测试：

package com.click369.springmvc.controller;
import org.springframework.web.servlet.ModelAndView;
import org.springframework.web.servlet.mvc.Controller;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
public class HelloController implements Controller{
    @Override
    public ModelAndView handleRequest(HttpServletRequest request, HttpServletResponse response) throws Exception {
        System.out.println("HelloController---请求处理方法");
        ModelAndView  mav=new ModelAndView();
        mav.addObject("username","zhangsan");
        mav.setViewName("test");
        return mav;
    }
}

4. ModelAndView类
答：
1.请求处理方法的返回值是ModelAndView类
2. 组成ModelAndView类的第一部分是一个Model(模型)封装数据
第二部分是一个View(视图)展示数据的页面元素
3. ModelAndView类是用来封装数据，展示数据的页面元素。
4. 构造方法ModelAndView()来创建ModelAndView类的对象
ModelAndView mav=new ModelAndView();
5. 封装数据的方法addObject(attributeName, attributeValue)相当于setAttribute(key,value)
mav.addObject(“username”,“zhangsan”);
6. 设置展示数据的页面元素的名称setViewName(viewName)

mav.setViewName("test");
mav.setViewName("test.jsp");
mav.setViewName("test.html");
mav.setViewName("控制器对应的请求处理路径");

mav.setViewName("test");---forword跳转[转发]
mav.setViewName("forward:test.jsp");
mav.setViewName("redirect:test.jsp");----sendRedirect跳转[重定向]

5. 视图解析器
答:
InternalResourceViewResolver------解析展示数据的页面元素

<!-- 视图解析器 -->
<!-- 利用请求处理类中的得到的视图名，通过视图解析器的前缀和后缀合并得到一个完整的页面元素的访问路径。 -->
	 <!-- prefix+视图名称+suffix : 完整的页面元素的访问路径 -->
	 <!-- prefix==http://localhost:8080/demo1/ -->
	 <!-- 视图名称:ModelAndView中setViewName("test")的参数test -->
	 <!-- suffix:后缀[.jsp] -->
	 <!-- http://localhost:8080/demo1/test.jsp -->
	 <bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
	 	<property name="prefix" value="/"></property>
	 	<property name="suffix"  value=""></property>
	 </bean>

6. DispatcherServlet中央处理器设置加载SpringMVC配置文件的设置
答: 我们在启动程序的时候需要加载SpringMVC配置文件，此时这个SpringMVC配置文件的位置可能有所不同，SpringMVC配置文件在不同的位置是DispatcherServlet中央处理器如何配置SpringMVC配置文件的位置。
1.通过init-param元素配置加载SpringMVC配置文件
2.SpringMVC配置文件在src/main/resources文件夹下的时候：

src/main/resources----->springmvcconfig.xml
<init-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>classpath:springmvcconfig.xml</param-value>
</init-param>

3.SpringMVC配置文件在WEB-INF文件夹下的时候:

src/main/webapp/WEB-INF----->springmvcconfig.xml
<init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>/WEB-INF/myspringmvc.xml</param-value>
</init-param>

4.如果我们不在web.xml文件中配置init-param元素配置加载SpringMVC配置文件
4.1.将SpringMVC配置文件放放置在WEB-INF文件夹下
4.2.SpringMVC配置文件，名称“-servlet.xml”

例如：myspringmvc-servlet.xml
<servlet>
	    <servlet-name>springmvc</servlet-name>
	    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<servlet>

SpringMVC配置文件
  src/main/webapp/WEB-INF-------[springmvc-servlet.xml]

注意：通常情况下我们把SpringMVC配置文件/资源文件(jsp/html)放置在WEB-INF文件夹。

7. @Controller/@RequestMapping/@Service/@RestController/@Component/@Autowired/
@Resource/@RequestBody/@ResponseBody
答:
@Controller—表示我们所编写的java类是一个处理请求的控制器类。
@RequestMapping–设置控制器类/请求处理方法的访问路径的。
@PathVariable 定义在方法上获取请求url路径上的参数数据。
@RequestParam 定义在方法上，获取请求中通过key=value方式传递的参数数据。
@Service用于标注业务层组件。
@Repository用于标注数据访问组件。
@Component泛指组件，当组件不好归类的时候，我们可以使用这个注解进行标注。
@RestController这个注解相当于@Controller+@ResponseBody两个注解的结合
但使用@RestController这个注解，就不能返回jsp,html页面，视图解析器无法解析jsp,html页面。
@Autowired注解是按类型装配依赖对象，默认情况下它要求依赖对象必须存在，如果允许null值，可以设置它required属性为false。
@Resource注解和@Autowired一样，也可以标注在字段或属性的setter方法上，但它默认按名称装配。
@ResponseBody是作用在方法上的。
@RequestBody是作用在形参列表上。
8. 请求处理方法接收请求参数值
答：
8.1.@PathVariable 定义在方法上获取请求url路径上的参数数据
http请求:http://localhost:8080/mvc/user/login/zhangsan/123456
请求参数：/zhangsan/123456

例如：
package com.click369.springmvc.handler;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.servlet.ModelAndView;
@Controller
@RequestMapping(value="/user")
public class UserHandler {
    //处理注册请求的方法
	@RequestMapping(value="/register1/{username}/{mypass}",method=RequestMethod.GET)
	public  ModelAndView  registerMethod1(@PathVariable("username")String name,
			@PathVariable("mypass")String pass)throws Exception{
		System.out.println("name=="+name);
		System.out.println("pass=="+pass);
		ModelAndView  mav=new ModelAndView();
		mav.addObject("myname",name);
		mav.addObject("mypass",pass);
		mav.setViewName("test");
		return mav;
	}
}

测试：http://localhost:8080/mvc/user/register1/zhangsan/123456

8.2.@RequestParam 定义在方法上，获取请求中通过key=value方式传递的参数数据
http请求:http://localhost:8080/test/my?name=zhangsan&password=123456
请求参数：name=zhangsan&password=123456
请求处理方法：
registerMethod2(@RequestParam(“username”)String name,
@RequestParam(“password”)String pass)
格式:@RequestParam(“form表单中input元素的name属性值”)String 形式参数
说明:通过@RequestParam将form表单中input元素的name属性值得到赋值给形式参数，然后在请求处理方法中使用这形式参数

例如：
<%@ page language="java" contentType="text/html; charset=UTF-8"
         pageEncoding="UTF-8" isELIgnored="false" %>
<!DOCTYPE html>
<html>
<head>
    <meta charset="UTF-8">
    <title>用户注册</title>
</head>
<body>
<h2>用户注册</h2>
<form action="register.do">
    用户名：<input type="text" name="myname"><br>
    密码：<input type="password" name="mypass"><br>
    年龄：<input type="text" name="myage"><br>
    地址：<input type="text" name="myaddress"><br>
    注册日期：<input type="text" name="myday"><br>
    <input type="submit" value="注册">
</form>
</body>
</html>

@RequestMapping(“register.do”)
通过@RequestParam将form表单中input元素的name属性值得到赋值给形式参数，然后在请求处理方法中使用这形式参数

public ModelAndView testGetReqParam1(@RequestParam("myname")String name,
                                    @RequestParam("mypass")String pass,
                                    @RequestParam("myage")Integer age,
                                    @RequestParam("myaddress")String address,
                                    @RequestParam("myday")String day){
    System.out.println("testGetReqParam1------");
    System.out.println("myname------"+name);
    System.out.println("mypass------"+pass);
    System.out.println("myage------"+age);
    System.out.println("myaddress------"+address);
    System.out.println("myday------"+day);
    ModelAndView modelAndView=new ModelAndView();
    modelAndView.addObject("myname",name);
    modelAndView.addObject("mypass",pass);
    modelAndView.addObject("myage",age);
    modelAndView.addObject("myaddress",address);
    modelAndView.addObject("myday",day);
    modelAndView.setViewName("test.jsp");
    return modelAndView;
}

测试:
http://localhost:8080/register.do?myname=zhangsan&mypass=111111&myage=12&myaddress=xian&myday=2020-05-23

8.3.HttpServletRequest对象接收数据

@RequestMapping("register.do")
public ModelAndView testGetReqParam2(HttpServletRequest req){
    System.out.println("testGetReqParam2------");
    String name=req.getParameter("myname");
    String pass=req.getParameter("mypass");
    Integer age=Integer.parseInt(req.getParameter("myage"));
    String address=req.getParameter("myaddress");
    String day=req.getParameter("myday");
    System.out.println("myname------"+req.getParameter("myname"));
    System.out.println("mypass------"+pass);
    System.out.println("myage------"+age);
    System.out.println("myaddress------"+address);
    System.out.println("myday------"+day);
    ModelAndView modelAndView=new ModelAndView();
    modelAndView.addObject("myname",name);
    modelAndView.addObject("mypass",pass);
    modelAndView.addObject("myage",age);
    modelAndView.addObject("myaddress",address);
    modelAndView.addObject("myday",day);
    modelAndView.setViewName("test.jsp");
    return modelAndView;
}

8.4.在请求处理方法中定义对应参数变量，参数变量的名称与页面元素的name属性值相同

@RequestMapping("register.do")
//参数的名称一定要与表单中name属性值一样
public ModelAndView testGetReqParam3(String myname,String mypass,
                                  Integer myage,String myaddress,
                                     String myday){
    System.out.println("testGetReqParam3------");
    System.out.println("myname------"+myname);
    System.out.println("mypass------"+mypass);
    System.out.println("myage------"+myage);
    System.out.println("myaddress------"+myaddress);
    System.out.println("myday------"+myday);
    ModelAndView modelAndView=new ModelAndView();
    modelAndView.addObject("myname",myname);
    modelAndView.addObject("mypass",mypass);
    modelAndView.addObject("myage",myage);
    modelAndView.addObject("myaddress",myaddress);
    modelAndView.addObject("myday",myday);
    modelAndView.setViewName("test.jsp");
    return modelAndView;
}

8.5.将需要提交的请求参数值封装到java对象中 (java对象的成员变量的名称一定要与页面元素的name属性值相同)

package com.click369.springmvc.demo;
import org.springframework.format.annotation.DateTimeFormat;
import java.util.Date;
public class UserBean {
    private  String myname;
    private  String mypass;
    private  Integer myage;
    private  String myaddress;
    //时间日期型数据
    @DateTimeFormat(pattern="yyyy-MM-dd")
    private Date myday;
    public String getMyname() {
        return myname;
    }
    public void setMyname(String myname) {
        this.myname = myname;
    }
    public String getMypass() {
        return mypass;
    }
    public void setMypass(String mypass) {
        this.mypass = mypass;
    }
    public Integer getMyage() {
        return myage;
    }
   public void setMyage(Integer myage) {
        this.myage = myage;
    }
    public String getMyaddress() {
        return myaddress;
    }
    public void setMyaddress(String myaddress) {
        this.myaddress = myaddress;
    }
    public Date getMyday() {
        return myday;
    }
    public void setMyday(Date myday) {
        this.myday = myday;
    }
}

@RequestMapping("register.do")
//参数的名称一定要与表单中name属性值一样
public ModelAndView testGetReqParam4(UserBean user){
    System.out.println("testGetReqParam4------");
    String name=user.getMyname();
    String pass=user.getMypass();
    Integer age=user.getMyage();
    String address=user.getMyaddress();
    Date day=user.getMyday();
    System.out.println("myname------"+user.getMyname());
    System.out.println("mypass------"+user.getMypass());
    System.out.println("myage------"+user.getMyage());
    System.out.println("myaddress------"+user.getMyaddress());
    System.out.println("myday------"+user.getMyday());
    ModelAndView modelAndView=new ModelAndView();
    modelAndView.addObject("myname",name);
    modelAndView.addObject("mypass",pass);
    modelAndView.addObject("myage",age);
    modelAndView.addObject("myaddress",address);
    modelAndView.addObject("myday",day);
    modelAndView.setViewName("test.jsp");
    return modelAndView;
}

9. SpringMVC的文件上传和下载
答:
文件上传
9.1. 创建javaweb项目
9.2. 导入依赖

<!-- https://mvnrepository.com/artifact/org.springframework/spring-webmvc -->
<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-webmvc</artifactId>
  <version>4.2.4.RELEASE</version>
</dependency>
<!-- commons-fileupload组件 -->
<!-- https://mvnrepository.com/artifact/commons-fileupload/commons-fileupload -->
<dependency>
  <groupId>commons-fileupload</groupId>
  <artifactId>commons-fileupload</artifactId>
  <version>1.3.1</version>
</dependency>
<!-- 配置ServletAPI依赖 -->
<!-- https://mvnrepository.com/artifact/javax.servlet/javax.servlet-api -->
<dependency>
  <groupId>javax.servlet</groupId>
  <artifactId>javax.servlet-api</artifactId>
  <version>3.0.1</version>
  <scope>provided</scope>
</dependency>

9.3.配置web.xml文件

<!-- 配置中央处理器-->
<servlet>
  <servlet-name>dispatcherServlet</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>
  <load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
  <servlet-name>dispatcherServlet</servlet-name>
  <!--http://127.0.0.1:8080/springmvc1/add.do-->
  <url-pattern>*.do</url-pattern>
</servlet-mapping>

9.4.完善项目结构
9.5.创建springmvc配置文件

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
</beans>

9.6.创建上传文件用的html页面

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>上传文件</title>
</head>
<body>
    <center>
        <form  action="/myupload.do" method="post" enctype="multipart/form-data">
            选择文件：<input type="file" name="myfile"/><br>
            <input type="submit" value="开始上传" />
        </form>
    </center>
</body>
</html>

9.7.创建处理上传请求的控制器

package com.click369.test.controller;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.multipart.MultipartFile;
import org.springframework.web.multipart.MultipartHttpServletRequest;
import org.springframework.web.multipart.commons.CommonsMultipartResolver;
import org.springframework.web.servlet.ModelAndView;
import javax.servlet.ServletContext;
import javax.servlet.http.HttpServletRequest;
import java.io.File;
import java.util.Iterator;
/**
 * 处理上传文件请求的控制器
 */
@Controller
public class TestUpLoadConntroller {
    /**
     * 处理上传文件的请求处理方法
     */
    @RequestMapping(value = "/myupload.do",method = RequestMethod.POST)
    public ModelAndView  myupload(HttpServletRequest request)throws Exception{
        ModelAndView  mav=new ModelAndView();
        System.out.println("测试上传文件的请求处理方法");

        //将当前类中的ServletContext对象转换成CommonsMultipartResolver
        ServletContext servletContext=request.getSession().getServletContext();
        CommonsMultipartResolver commonsMultipartResolver=new CommonsMultipartResolver(servletContext);
        //检验HttpServletRequest是否是一个文件上传请求
        if(commonsMultipartResolver.isMultipart(request)){
            //将HttpServletRequest对象变成多部分MultipartHttpServletRequest
            MultipartHttpServletRequest multipartreq=(MultipartHttpServletRequest)request;
            //从MultipartHttpServletRequest对象中得到文件名称
            Iterator<String> itname=multipartreq.getFileNames();
            //遍历包含有name属性值的Iterator集合
            while(itname.hasNext()){
                //得到name属性值
                String nameshuxing=itname.next().toString();
                //根据得到的neme属性值得到具体的文件
                MultipartFile multipartfile=multipartreq.getFile(nameshuxing);
                String newfilename="";
                if(multipartfile!=null){
                    //重新为上传来的文件命名
                    long haomiaoshu=System.currentTimeMillis();
                    //得到被上传来的文件的真实名称【MavenJavaWeb.war】
                    String  zhenFileName=multipartfile.getOriginalFilename();
                    //得到文件的后缀名
                    String houzhuiming=zhenFileName.substring(zhenFileName.lastIndexOf("."));
                    newfilename=haomiaoshu+houzhuiming;
                    // 获取项目的根目录
                    String realPath = servletContext.getRealPath("/upload");
                    File uploadpicdir = new File(realPath);
                    if(!uploadpicdir.exists()){
                        //创建upload目录
                        uploadpicdir.mkdirs();
                    }
                    //组织一个保存文件的对象【文件保存目录+文件名称】
                    String pathfile=uploadpicdir.getAbsolutePath()+File.separator+newfilename;
                    System.out.println(pathfile);
                    File saveFile=new File(pathfile);
                    //保存文件到本地磁盘
                    multipartfile.transferTo(saveFile);
                }
                //得到上传成功以后的文件的http访问地址
                String reqURL=request.getRequestURL().toString();
                reqURL=reqURL.substring(0,reqURL.lastIndexOf("/"));
                reqURL=reqURL+"/upload/"+newfilename;
                //http://127.0.0.1:8080/upload/xxxxxx.jpg
                System.out.println("reqURL=="+reqURL);
            }
            mav.setViewName("success.html");
        }else{
            mav.setViewName("error.html");
        }
        return  mav;
    }
}

9.8.配置SpringMVC的配置文件

<?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
       http://www.springframework.org/schema/mvc/spring-mvc.xsd
       http://www.springframework.org/schema/context
       http://www.springframework.org/schema/context/spring-context.xsd">
    <!-- 开启mvc注解 -->
    <mvc:annotation-driven></mvc:annotation-driven>
    <!--配置自动扫描包-->
    <context:component-scan base-package="com.click369.test.controller"></context:component-scan>
    <!-- 视图解析器-->
    <bean id="multipartResolver" class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
        <property name="maxUploadSize" value="104857600" />
        <property name="maxInMemorySize" value="4096" />
        <property name="defaultEncoding" value="UTF-8"></property>
    </bean>
</beans>

部署测试。。。。。

文件下载：
9.1.创建javaweb项目
9.2.导入依赖

<!-- https://mvnrepository.com/artifact/org.springframework/spring-webmvc -->
<dependency>
  <groupId>org.springframework</groupId>
  <artifactId>spring-webmvc</artifactId>
  <version>4.2.4.RELEASE</version>
</dependency>
<!-- commons-fileupload组件 -->
<!-- https://mvnrepository.com/artifact/commons-fileupload/commons-fileupload -->
<dependency>
  <groupId>commons-fileupload</groupId>
  <artifactId>commons-fileupload</artifactId>
  <version>1.3.1</version>
</dependency>
<!-- 配置ServletAPI依赖 -->
<!-- https://mvnrepository.com/artifact/javax.servlet/javax.servlet-api -->
<dependency>
  <groupId>javax.servlet</groupId>
  <artifactId>javax.servlet-api</artifactId>
  <version>3.0.1</version>
  <scope>provided</scope>
</dependency>

9.3.配置web.xml文件

<!-- 配置中央处理器-->
<servlet>
  <servlet-name>dispatcherServlet</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>
  <load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
  <servlet-name>dispatcherServlet</servlet-name>
  <!--http://127.0.0.1:8080/springmvc1/add.do-->
  <url-pattern>*.do</url-pattern>
</servlet-mapping>

9.4.完善项目结构
9.5.创建springmvc配置文件

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">
</beans>

9.6.创建下载传文件用的html页面

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>文件下载</title>
</head>
<body>
    <center>
        <a href="dowload.do?filename=mybatis.jpg">MyBatis框架图标</a>
        <a href="dowload.do?filename=MavenJavaWeb.war">MavenJavaWeb.war</a>
        <a href="dowload.do?filename=Servlet(1).docx">Servlet(1).docx</a>
    </center>
</body>
</html>

9.7.创建控制器类

package com.click369.test.controller;
import org.apache.commons.io.FileUtils;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpStatus;
import org.springframework.http.MediaType;
import org.springframework.http.ResponseEntity;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import javax.servlet.http.HttpServletRequest;
import java.io.File;
/**
 * 处理下载请求的控制器类
 */
@Controller
public class TestDowloadController {
    @RequestMapping(value="/dowload.do")
    public ResponseEntity<byte[]> dowloadMethod(HttpServletRequest req)throws Exception{
        //得到请求中的文件名称
        String filename=req.getParameter("filename");
        //得到保存文件的目录地址
        //String realPath = req.getSession().getServletContext().getRealPath("/upload");
        String realPath = "F:"+File.separator+"upload";
        //创建保存文件的目录的文件对象
        File uploadpicdir = new File(realPath);
        //创建被下载的文件对象
        File file=new File(uploadpicdir,filename);
        System.out.println(file.getAbsolutePath());
        //设置http协议头
        HttpHeaders headers = new HttpHeaders();
        headers.setContentDispositionFormData("attachment",filename);
        headers.setContentType(MediaType.APPLICATION_OCTET_STREAM);
        return new ResponseEntity<byte[]>(FileUtils.readFileToByteArray(file),headers, HttpStatus.CREATED);
    }
}

9.7.配置springmvc配置文件

<?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
       http://www.springframework.org/schema/mvc/spring-mvc.xsd
       http://www.springframework.org/schema/context
       http://www.springframework.org/schema/context/spring-context.xsd">
    <!-- 开启mvc注解 -->
    <mvc:annotation-driven></mvc:annotation-driven>
    <!--配置自动扫描包-->
    <context:component-scan base-package="com.click369.test.controller"></context:component-scan>
</beans>