背景
调整了一个旧项目的报表下载功能，原来文件是存储在服务器本地的，下载直接从本机获取就可以了，现在要改成从 FTP 服务器获取文件再返回给前台。
理论上，对代码稍微调整就可以了，实际上却踩了一个小坑，本文将整理 Java Web 应用文件下载的流程及注意点。
文件下载流程
文件下载是一个老生常谈的功能了，基本原理是直接向响应流写数据，并设置响应类型为二进制流格式：
设置响应编码 ；
设置响应文件类型 octet-stream ；
设置响应头域附件名称；
想 ServletResponse 的 OutputStream 流 write 数据。
第二、三、四步对应的代码为：
下载核心代码
下载操作源码
常见的文件下载代码为：
@ResponseBody@RequestMapping(value = "/download")public void download(HttpServletRequest request, HttpServletResponse response,String reportId) {// TODO 根据 reportId 查询报表对应的文件名称String fileName = "xxx日报表文件.xlsx";//设置响应类型和附件头域response.setCharacterEncoding("utf-8");response.setContentType("application/octet-stream");response.setHeader("content-disposition", "attachment;filename="+ fileName);//读取报表内容写入响应流对象InputStream inputStream = null;try {OutputStream output = response.getOutputStream();//检查文件是否存在if(!isFileExist(fileName)){logger.warn("文件/目录 {} 不存在", pathName);response.getWriter().println("报表文件不存在！");return;}inputStream = new FileInputStream(new File(pathName));int len = -1;byte[] bytes = new byte[2048];           // 向 Response 的响应流写入二进制数据while ((len = inputStream.read(bytes)) != -1) {output .write(bytes, 0, len);}output.flush();} catch (Exception e) {logger.error("下载文件异常",e);try {response.getWriter().println("下载文件异常！");} catch (IOException ex) {ex.printStackTrace();}}finally{if(output != null){try {output.close();} catch (IOException e) {logger.error("下载文件关闭输出流异常",e);}}if(inputStream != null){try {inputStream.close();} catch (IOException e) {logger.error("下载文件关闭输入流异常",e);}}}}
敲重点，运行下载操作后，xlsx 类型的报表文件现在下载栏中，查看网络请求的响应头为：
浏览器头域信息
响应头域设置位置
设置响应类型和头域信息必须在 write 写入之前，否则附件就是不可读的。调整代码顺序，先写后设置响应头：
错误的顺序

执行下载操作，发现 xlsx 类型的报表以 .zip 压缩包格式被下载，且内容不可读。
查看网络响应的头，可以看出，之后设置的头域没有生效：
无效头域
编程启示录
为什么设置顺序不同，下载附件显示就不一样呢？
反复验证了十几次，发现 response.setHeader 在 write 操作之后时，头域设置是无效的。推测这是由 http 通信协议包组装顺序决定的，因为 http 响应头域信息是在 body 之前组装的。
最后，再总结下文件下载的要点：
下载路径必须在后台设置，不能直接接收前台的下载路径，否则就有 ../.. 路径的任意文件下载风险；如果要接收带路径的 fileName 参数，必须校验 fileName 不能包含../ 等特殊路径；
必须注意响应头域设置和流写入操作的顺序，写设头域后写，否则附件不可用；
从 FTP 下载也是一样，将 ServletResponse 的 OutputStream 对象传给 FTPClient 的 retrieveFile(filename, outputStream) 直接下载到输出流中。

最近，我们的线上环境出现了一个问题，线上代码在执行过程中抛出了一个IllegalArgumentException，分析堆栈后，发现最根本的的异常是以下内容：
java.lang.IllegalArgumentException: No enum constant com.a.b.f.m.a.c.AType.P_M
大概就是以上的内容，看起来还是很简单的，提示的错误信息就是在AType这个枚举类中没有找到P_M这个枚举项。
于是经过排查，我们发现，在线上开始有这个异常之前，该应用依赖的一个下游系统有发布，而发布过程中是一个API包发生了变化，主要变化内容是在一个RPC接口的Response返回值类中的一个枚举参数AType中增加了P_M这个枚举项。
但是下游系统发布时，并未通知到我们负责的这个系统进行升级，所以就报错了。
我们来分析下为什么会发生这样的情况。
问题重现
首先，下游系统A提供了一个二方库的某一个接口的返回值中有一个参数类型是枚举类型。
一方库指的是本项目中的依赖
二方库指的是公司内部其他项目提供的依赖
三方库指的是其他组织、公司等来自第三方的依赖
然后B系统依赖了这个二方库，并且会通过RPC远程调用的方式调用AFacadeService的doSth方法。
这时候，如果A和B系统依赖的都是同一个二方库的话，两者使用到的枚举AType会是同一个类，里面的枚举项也都是一致的，这种情况不会有什么问题。
但是，如果有一天，这个二方库做了升级，在AType这个枚举类中增加了一个新的枚举项P_M，这时候只有系统A做了升级，但是系统B并没有做升级。
那么A系统依赖的的AType就是这样的：
而B系统依赖的AType则是这样的：
这种情况下，在B系统通过RPC调用A系统的时候，如果A系统返回的AResponse中的aType的类型为新增的P_M时候，B系统就会无法解析。一般在这种时候，RPC框架就会发生反序列化异常。导致程序被中断。
原理分析
这个问题的现象我们分析清楚了，那么再来看下原理是怎样的，为什么出现这样的异常呢。
其实这个原理也不难，这类RPC框架大多数会采用JSON的格式进行数据传输，也就是客户端会将返回值序列化成JSON字符串，而服务端会再将JSON字符串反序列化成一个Java对象。
而JSON在反序列化的过程中，对于一个枚举类型，会尝试调用对应的枚举类的valueOf方法来获取到对应的枚举。
而我们查看枚举类的valueOf方法的实现时，就可以发现，如果从枚举类中找不到对应的枚举项的时候，就会抛出IllegalArgumentException：
public static > T valueOf(Class enumType, String name) {    T result = enumType.enumConstantDirectory().get(name);    if (result != null)        return result;    if (name == null)        throw new NullPointerException("Name is null");    throw new IllegalArgumentException(        "No enum constant " + enumType.getCanonicalName() + "." + name);}
关于这个问题，其实在《阿里巴巴Java开发手册》中也有类似的约定：
这里面规定"对于二方库的参数可以使用枚举，但是返回值不允许使用枚举"。这背后的思考就是本文上面提到的内容。
扩展思考
为什么参数中可以有枚举？
不知道大家有没有想过这个问题，其实这个就和二方库的职责有点关系了。
一般情况下，A系统想要提供一个远程接口给别人调用的时候，就会定义一个二方库，告诉其调用方如何构造参数，调用哪个接口。
而这个二方库的调用方会根据其中定义的内容来进行调用。而参数的构造过程是由B系统完成的，如果B系统使用到的是一个旧的二方库，使用到的枚举自然是已有的一些，新增的就不会被用到，所以这样也不会出现问题。
比如前面的例子，B系统在调用A系统的时候，构造参数的时候使用到AType的时候就只有P_T和A_B两个选项，虽然A系统已经支持P_M了，但是B系统并没有使用到。
如果B系统想要使用P_M，那么就需要对该二方库进行升级。
但是，返回值就不一样了，返回值并不受客户端控制，服务端返回什么内容是根据他自己依赖的二方库决定的。
但是，其实相比较于手册中的规定，我更加倾向于，在RPC的接口中入参和出参都不要使用枚举。
一般，我们要使用枚举都是有几个考虑：
1、枚举严格控制下游系统的传入内容，避免非法字符。
2、方便下游系统知道都可以传哪些值，不容易出错。
不可否认，使用枚举确实有一些好处，但是我不建议使用主要有以下原因：
1、如果二方库升级，并且删除了一个枚举中的部分枚举项，那么入参中使用枚举也会出现问题，调用方将无法识别该枚举项。
2、有的时候，上下游系统有多个，如C系统通过B系统间接调用A系统，A系统的参数是由C系统传过来的，B系统只是做了一个参数的转换与组装。这种情况下，一旦A系统的二方库升级，那么B和C都要同时升级，任何一个不升级都将无法兼容。
我其实建议大家在接口中使用字符串代替枚举，相比较于枚举这种强类型，字符串算是一种弱类型。
如果使用字符串代替RPC接口中的枚举，那么就可以避免上面我们提到的两个问题，上游系统只需要传递字符串就行了，而具体的值的合法性，只需要在A系统内自己进行校验就可以了。
为了方便调用者使用，可以使用javadoc的@see注解表明这个字符串字段的取值从那个枚举中获取。
对于像阿里这种比较庞大的互联网公司，随便提供出去的一个接口，可能有上百个调用方，而接口升级也是常态，我们根本做不到每次二方库升级之后要求所有调用者跟着一起升级，这是完全不现实的，并且对于有些调用者来说，他用不到新特性，完全没必要做升级。
还有一种看起来比较特殊，但是实际上比较常见的情况，就是有的时候一个接口的声明在A包中，而一些枚举常量定义在B包中，比较常见的就是阿里的交易相关的信息，订单分很多层次，每次引入一个包的同时都需要引入几十个包。
对于调用者来说，我肯定是不希望我的系统引入太多的依赖的，一方面依赖多了会导致应用的编译过程很慢，并且很容易出现依赖冲突问题。
所以，在调用下游接口的时候，如果参数中字段的类型是枚举的话，那我没办法，必须得依赖他的二方库。但是如果不是枚举，只是一个字符串，那我就可以选择不依赖。
所以，我们在定义接口的时候，会尽量避免使用枚举这种强类型。规范中规定在返回值中不允许使用，而我自己要求更高，就是即使在接口的入参中我也很少使用。
最后，我只是不建议在对外提供的接口的出入参中使用枚举，并不是说彻底不要用枚举，我之前很多文章也提到过，枚举有很多好处，我在代码中也经常使用。所以，切不可因噎废食。
当然，文中的观点仅代表我个人，具体是是不是适用其他人，其他场景或者其他公司的实践，需要读者们自行分辨下，建议大家在使用的时候可以多思考一下。

介绍本篇内容前，先抛出我遇到的问题或者说是需求！(精读阅读本篇可能花费您15分钟，略读需5分钟左右)
一：需求说明
有一个Controller有两个方法
第一个方法通过指定的路径和参数去渲染jsp内容，并返回html数据
第二个方法获取第一个方法中的html进行封装
现在的做法是在第二个方法通过发送Http请求获取数据，然后返回进行封装！
问题：
需要优化的是 不通过Http请求，第二个方法可以拿到第一个方法中的Html数据
二：简化例子(待优化的例子)
注：使用的SpringMVC框架，使用贴出视图解析器 配置文件
class="org.springframework.web.servlet.view.InternalResourceViewResolver"
p:order="2">
value="org.springframework.web.servlet.view.JstlView" />
1.简化请求图示说明
简单说明：一个Controller中有三个方法，访问/index 返回html输出到页面，
浏览器页面显示内容为：
hello
url = http://blog.csdn.net/u010648555
world
url = http://blog.csdn.net/u010648555
/index中通过Http去请求/hello ，渲染hello.jsp 返回 hello.jsp 对应的html代码，去请求/world ，渲染world.jsp 返回 world..jsp 对应的html代码!
2.简化代码说明
(1)：Java代码
package com.dufy.web;
import org.apache.commons.lang3.StringUtils;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.HttpURLConnection;
import java.net.URL;
import java.net.URLEncoder;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
/**
* Created by dufy on 2017/3/21.
*/
@Controller
public class JspController {
/**
* 跳转到WEB_INF/jsp/welcome/index.jsp
* @param request
* @param response
* @return
*/
@RequestMapping("/index")
public String index(HttpServletRequest request ,HttpServletResponse response) {
List list = new ArrayList();
list.add("hello");
list.add("wrold");
String commonUrl = "http://"+request.getServerName()+":"+request.getServerPort()+request.getContextPath();
StringBuilder pageHtml = new StringBuilder();//使用StringBuilder拼接字符串效率高
if (list != null && list.size() > 0) {
for (String str : list
) {
StringBuffer paramsBuffer = new StringBuffer();//线程安全
paramsBuffer .append(str + "=" + str);//hello=hello  world=world
//如果参数中url 需要使用URLEncoder
paramsBuffer .append("url"+ "=" + URLEncoder.encode("http://blog.csdn.net/u010648555"));
//使用post请求 ，后台获取每个接口方法对应生成的html
String urlStr = commonUrl +"/" + str + "?jsppath=" + str;//reqest url 这里会调用 /hello  /world
String urlSourceResult = getURLSourcePost(urlStr,paramsBuffer.toString());
pageHtml.append(urlSourceResult);
}
}
request.setAttribute("pageHtml",pageHtml);
return "welcome/index";
}
/**
* 跳转到WEB_INF/jsp/welcome/hello.jsp
* @param request
* @param response
* @return
*/
@RequestMapping(value = "/hello",method = RequestMethod.POST)
public String hello(HttpServletRequest request,HttpServletResponse response){
String jsppath = request.getParameter("jsppath");
//处理一些业务逻辑
Map params = new HashMap<>();
for (Object p : request.getParameterMap().keySet()) {
try {
String s = request.getParameter(p.toString());
params.put(p.toString(), s);
} catch (Exception e) {
e.printStackTrace();
}
}
request.setAttribute("params",params);
return "welcome/" + jsppath;
}
/**
* 跳转到WEB_INF/jsp/welcome/world.jsp
* @param request
* @param response
* @return
*/
@RequestMapping(value = "/wrold" ,method = RequestMethod.POST)
public String world(HttpServletRequest request,HttpServletResponse response){
String jsppath = request.getParameter("jsppath");
//处理一些业务逻辑
Map params = new HashMap<>();
for (Object p : request.getParameterMap().keySet()) {
try {
String s = request.getParameter(p.toString());
params.put(p.toString(), s);
} catch (Exception e) {
e.printStackTrace();
}
}
request.setAttribute("params",params);
return "welcome/" + jsppath;
}
/**
* 通过网站域名URL使用POST方式 获取该网站的源码
* @param url 请求的地址
* @param param 请求的参数
* @return 返回请求的结果
*/
private  String getURLSourcePost(String url,String param) {
PrintWriter out = null;
BufferedReader in = null;
StringBuilder htmlResult = new StringBuilder();
try
{
URL realUrl = new URL(url);
//打开和URL之间的连接
HttpURLConnection conn = (HttpURLConnection)realUrl.openConnection();
//设置请求的方式
conn.setRequestMethod("POST");
conn.setConnectTimeout(5 * 1000);
//设置通用的请求属性
conn.setRequestProperty("accept", "*/*");
conn.setRequestProperty("connection", "Keep-Alive");
conn.setRequestProperty("user-agent", "Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1; SV1)");
// charset=UTF-8以防止乱码！
conn.setRequestProperty("content-type", "application/x-www-form-urlencoded; charset=UTF-8");
//发送POST请求必须设置如下两行
conn.setDoOutput(true);
conn.setDoInput(true);
//获取URLConnection对象对应的输出流
out = new PrintWriter(conn.getOutputStream());
//发送请求参数
out.print(param);
//flush输出流的缓冲
out.flush();
//定义BufferedReader输入流来读取URL的响应
in = new BufferedReader(
new InputStreamReader(conn.getInputStream()));
String line;
while ((line = in.readLine())!= null)
{
if(StringUtils.isNotBlank(line)){
htmlResult.append("\n" + line);
}
}
}
catch(Exception e)
{
throw new RuntimeException("发送POST请求出现异常！",e);
}
//使用finally块来关闭输出流、输入流
finally
{
try
{
if (out != null)
{
out.close();
}
if (in != null)
{
in.close();
}
}
catch (IOException ex)
{
ex.printStackTrace();
}
}
return htmlResult.toString();
}
}
(2)：对于的JSP页面
a:index.jsp
welcome index
${pageHtml}

一、根据url请求返回状态码
private static int getResultHttpUrl(String url){
int responseCode=0;//状态码
try {
URL u = new URL(url);
try {
HttpURLConnection uConnection = (HttpURLConnection) u.openConnection();
try {
uConnection.connect();
responseCode =  uConnection.getResponseCode();//获取状态码
} catch (Exception e) {
//System.out.println("connect failed");
}
} catch (IOException e) {
//System.out.println("build failed");
}
} catch (MalformedURLException e) {
//System.out.println("build url failed");
}
return responseCode;
}
二、根据请求获取html代码，并分为js,css,html三部分
private  TemplateVO getTemplateValue(HttpServletRequest request,
String templatePath,String templateId) throws Exception {
TemplateVO template = new TemplateVO();
String filePath = request.getSession().getServletContext()
.getRealPath("/")
+ templatePath;
String html = URLUtil.getValue(filePath);
if ("".equals(html)) {
return template;
}
memcacheDao.set(TEMPLATE_CACHE_KEY+templateId,html);
Document doc = DocumentUtils.getHtmlDoc(html);
//获取的dom对象放入缓存
String cssPath = doc.getElementsByTag("link").get(0).attr("href")
.replace("../../../", "/templateCenter/");
doc.getElementsByTag("a").removeAttr("href");
Elements csss = doc.getElementsByTag("link");
for (Element css : csss) {
template.getCsss().add(pathReplace(templatePath, css.attr("href")));
}
template.setCssPath(cssPath);
String body = pathReplace(templatePath, doc.body().html());// doc.body().html().replace("../../",
// "/templateCenter/");
body = body.replaceAll("(\r\n|\r|\n|\n\r)", "");
body = body.replaceAll("", "");
body = body.replaceAll("\\s{2,10}|\t|\r|\n", " ");
body = body.replaceAll(".*?\\1>", "");
template.setBody(body);
return template;
}
三、将html代码转为dom对象，并做相应的处理
/**
* @Title: getHtmlDoc
* @Description: html转换成dom对象
* @param html
* @return
*/
private  Document getHtmlDoc(String html) {
long start = System.currentTimeMillis();
Document doc = null;
try {
doc = (Document) Jsoup.parse(html);
} catch (Exception e) {
e.printStackTrace();
} finally {
LogMgr.writeSysInfoLog("Time is:"+ (System.currentTimeMillis() - start) + "ms");
}
return doc;
}
四、抓取网页内容
/**
* Description: 获得网页抓取后的内容
* @param htmlUrl 抓取的URL地址
* @param htmlCode 网页显示的编码
* @return
*/
public static String getUrlToHtml(String htmlUrl, String htmlCode) {
try {
StringBuilder contentBuf = null;
BufferedReader bufReader = null;
try {
URL url = new URL(htmlUrl);
HttpURLConnection httpConn = (HttpURLConnection) url.openConnection();
InputStreamReader input = new InputStreamReader(httpConn.getInputStream(), htmlCode);
bufReader = new BufferedReader(input);
String line = "";
contentBuf = new StringBuilder();
while ((line = bufReader.readLine()) != null) {
String lineJudge = "
Pattern patternJudge = Pattern.compile(lineJudge);
Matcher matcherJudge = patternJudge.matcher(line.toString());
if(matcherJudge.find()){
contentBuf.append(line);
}else if(isMessyCode(line)==false){
contentBuf.append(line);
}
}
return contentBuf.toString();
} catch (MalformedURLException e) {
return null;
} catch (Exception e) {
return null;
} finally {
if (bufReader != null) {
try {
bufReader.close();
} catch (IOException e) {
return null;
}
}
}
} catch (Exception e) {
return null;
}
}
/**
* 判断字符串是否是乱码
* @param strName 字符串
* @return 是否是乱码
*/
public static boolean isMessyCode(String strName) {
Pattern p = Pattern.compile("\\s*|\t*|\r*|\n*");
Matcher m = p.matcher(strName);
String after = m.replaceAll("");
String temp = after.replaceAll("\\p{P}", "");
char[] ch = temp.trim().toCharArray();
float chLength = ch.length;
float count = 0;
for (int i = 0; i < ch.length; i++) {
char c = ch[i];
if (!Character.isLetterOrDigit(c)) {
if (!isChinese(c)) {
count = count + 1;
}
}
}
float result = count / chLength;
if (result > 0.4) {
return true;
} else {
return false;
}
}
/**
* 判断字符是否是中文
* @param c 字符
* @return 是否是中文
*/
public static boolean isChinese(char c) {
Character.UnicodeBlock ub = Character.UnicodeBlock.of(c);
if (ub == Character.UnicodeBlock.CJK_UNIFIED_IDEOGRAPHS
|| ub == Character.UnicodeBlock.CJK_COMPATIBILITY_IDEOGRAPHS
|| ub == Character.UnicodeBlock.CJK_UNIFIED_IDEOGRAPHS_EXTENSION_A
|| ub == Character.UnicodeBlock.GENERAL_PUNCTUATION
|| ub == Character.UnicodeBlock.CJK_SYMBOLS_AND_PUNCTUATION
|| ub == Character.UnicodeBlock.HALFWIDTH_AND_FULLWIDTH_FORMS) {
return true;
}
return false;
}