import java.io.BufferedReader;
 import java.io.IOException;
 import java.io.InputStreamReader;
 import java.io.OutputStreamWriter;
 import java.net.URI;
 import java.net.URISyntaxException;
 import java.net.URL;
 import java.net.URLConnection;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Map;
 
import org.apache.http.HttpResponse;
 import org.apache.http.NameValuePair;
 import org.apache.http.client.ClientProtocolException;
 import org.apache.http.client.config.RequestConfig;
 import org.apache.http.client.entity.UrlEncodedFormEntity;
 import org.apache.http.client.methods.CloseableHttpResponse;
 import org.apache.http.client.methods.HttpGet;
 import org.apache.http.client.methods.HttpPost;
 import org.apache.http.client.utils.URIBuilder;
 import org.apache.http.entity.StringEntity;
 import org.apache.http.impl.client.CloseableHttpClient;
 import org.apache.http.impl.client.HttpClients;
 import org.apache.http.message.BasicNameValuePair;
 import org.apache.http.util.EntityUtils;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
 
import com.alibaba.fastjson.JSON;
 import com.alibaba.fastjson.JSONObject;
 
@Service
 public class HttpService {
 
    // 创建HttpClient对象
     @Autowired(required = false)
     private CloseableHttpClient httpClient;
 
    /* @Autowired(required = false)表示的含义是，spring容器里面有这个bean就注入，没有就不注入。 */
 
    // 请求信息的配置
     @Autowired(required = false)
     private RequestConfig requestConfig;
 
    /**
      * 执行Get请求
      * 
      * @param url
      * @return 请求到的内容
      * @throws URISyntaxException
      * @throws IOException
      * @throws ClientProtocolException
      */
     public String doGet(String url) throws URISyntaxException, ClientProtocolException, IOException {
 
        return doGet(url, null);
 
    }
 
    /**
      * @param url
      * @param intoParams 请求中的参数
      * @return 请求到的内容
      * @throws URISyntaxException
      * @throws ClientProtocolException
      * @throws IOException
      */
     public String doPost(String url) throws URISyntaxException, ClientProtocolException, IOException {
 
        return doPost(url, null);
 
    }
 
    /**
      * 执行Get请求
      * 
      * @param url
      * @param params 请求中的参数
      * @return 请求到的内容
      * @throws URISyntaxException
      * @throws IOException
      * @throws ClientProtocolException
      */
     public String doGet(String url, Map<String, Object> params) throws URISyntaxException, ClientProtocolException, IOException {
         // 定义请求的参数
         URI uri = null;
         if (params != null) {
             URIBuilder builder = new URIBuilder(url);
             for (Map.Entry<String, Object> entry : params.entrySet()) {
                 builder.addParameter(entry.getKey(), String.valueOf(entry.getValue()));
             }
             uri = builder.build();
         }
 
        // 创建http GET请求
         HttpGet httpGet = null;
         if (uri != null) {
             httpGet = new HttpGet(uri);
         } else {
             httpGet = new HttpGet(url);
         }
         // 设置请求参数
         httpGet.setConfig(this.requestConfig);
 
        // 请求的结果
         CloseableHttpResponse response = null;
         try {
             // 执行请求
             response = httpClient.execute(httpGet);
             // 判断返回状态是否为200
             if (response.getStatusLine().getStatusCode() == 200) {
                 // 获取服务端返回的数据,并返回
                 return EntityUtils.toString(response.getEntity(), "UTF-8");
             }
         } finally {
             if (response != null) {
                 response.close();
             }
         }
         return null;
     }
 
    /**
      * @param url
      * @param params 请求中的参数
      * @return 请求到的内容
      * @throws URISyntaxException
      * @throws ClientProtocolException
      * @throws IOException
      */
     public String doPost(String url, Map<String, Object> params)
             throws URISyntaxException, ClientProtocolException, IOException {
         // url = GlobalUtil.getValue("remoteAddress") + url;
         // 设置post参数
         List<NameValuePair> parameters = null;
         // 构造一个form表单式的实体
         UrlEncodedFormEntity formEntity = null;
         // 定义请求的参数
         if (params != null) {
             // 设置post参数
             parameters = new ArrayList<NameValuePair>();
 
            for (Map.Entry<String, Object> entry : params.entrySet()) {
                 // 添加参数
                 parameters.add(new BasicNameValuePair(entry.getKey(), String.valueOf(entry.getValue())));
 
            }
             // 构造一个form表单式的实体
             formEntity = new UrlEncodedFormEntity(parameters);
         }
 
        // 创建HTTP GET请求
         HttpPost httpPost = null;
 
        if (formEntity != null) {
 
            httpPost = new HttpPost(url);
             // 将请求实体设置到httpPost对象中
             httpPost.setEntity(formEntity);
             // 伪装浏览器请求
             httpPost.setHeader("User-Agent", "Mozilla/5.0 (Windows NT 6.3; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/41.0.2272.118 Safari/537.36");
         } else {
             httpPost = new HttpPost(url);
             // 伪装浏览器请求
             httpPost.setHeader("User-Agent", "Mozilla/5.0 (Windows NT 6.3; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/41.0.2272.118 Safari/537.36");
         }
         // 设置请求参数
         httpPost.setConfig(this.requestConfig);
         // 请求的结果
         CloseableHttpResponse response = null;
         try {
             // 执行请求
             response = httpClient.execute(httpPost);
             // 判断返回状态是否为200
             if (response.getStatusLine().getStatusCode() == 200) {
                 // 获取服务端返回的数据,并返回
                 return EntityUtils.toString(response.getEntity(), "UTF-8");
 
            }
         } finally {
 
            if (response != null) {
 
                response.close();
 
            }
 
        }
 
        return null;
 
    }
 
    /**使用post以“raw-JSON(application/json)”类型推送数据
      * @param url
      * @param params 请求中的参数
      * @return 请求到的内容
      * @throws URISyntaxException
      * @throws ClientProtocolException
      * @throws IOException
      */
     public String httpPostWithJSON(String url, Map<String, Object> params) throws URISyntaxException, ClientProtocolException, IOException {
 
        CloseableHttpClient client = HttpClients.createDefault();
         // 设置post参数
         StringEntity entity = null;
         // 构造一个form表单式的实体
         // 定义请求的参数
         if (params != null) {
             // 设置post参数
             String json = JSON.toJSONString(params);// map转String
             JSONObject jsonObject = JSON.parseObject(json);// String转json
             entity = new StringEntity(jsonObject.toString(), "utf-8");// 解决中文乱码问题
             entity.setContentEncoding("UTF-8");
             entity.setContentType("application/json");
         }
 
        // 创建HTTP GET请求
         HttpPost httpPost = new HttpPost(url);
 
        httpPost.setEntity(entity);
 
        try {
             // 执行请求
             HttpResponse response = client.execute(httpPost);
             // 判断返回状态是否为200
             if (response.getStatusLine().getStatusCode() == 200) {
                 // 获取服务端返回的数据,并返回
                 return EntityUtils.toString(response.getEntity(), "UTF-8");
 
            }
         } finally {
 
            if (client != null) {
 
                client.close();
 
            }
 
        }
 
        return null;
 
    }
 
    /**
      * 使用post以“x-www-form-urlencoded”类型推送数据
      * 
      * @param url
      * @param params 请求中的参数
      * @return 请求到的内容
      */
     public String httpSendPost(String url, Map<String, Object> params) {
         StringBuffer resultBuffer = null;
         // 构建请求参数
         StringBuffer sbParams = new StringBuffer();
         if (params != null && params.size() > 0) {
             for (Map.Entry<String, Object> e : params.entrySet()) {
                 sbParams.append(e.getKey());
                 sbParams.append("=");
                 sbParams.append(e.getValue());
                 sbParams.append("&");
             }
         }
         URLConnection con = null;
         OutputStreamWriter osw = null;
         BufferedReader br = null;
         try {
             URL realUrl = new URL(url);
             // 打开和URL之间的连接
             con = realUrl.openConnection();
             // 设置通用的请求属性
             con.setRequestProperty("accept", "*/*");
             con.setRequestProperty("connection", "Keep-Alive");
             con.setRequestProperty("Content-Type", "application/x-www-form-urlencoded");
             con.setRequestProperty("user-agent", "Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1;SV1)");
             // 发送POST请求必须设置如下两行
             con.setDoOutput(true);
             con.setDoInput(true);
             // 获取URLConnection对象对应的输出流
             osw = new OutputStreamWriter(con.getOutputStream(), "utf-8");
             if (sbParams != null && sbParams.length() > 0) {
                 // 发送请求参数
                 osw.write(sbParams.substring(0, sbParams.length() - 1));
                 // flush输出流的缓冲
                 osw.flush();
             }
             // 定义BufferedReader输入流来读取URL的响应
             resultBuffer = new StringBuffer();
             int contentLength = Integer.parseInt(con.getHeaderField("Content-Length"));
             if (contentLength > 0) {
                 br = new BufferedReader(new InputStreamReader(con.getInputStream(), "utf-8"));
                 String temp;
                 while ((temp = br.readLine()) != null) {
                     resultBuffer.append(temp);
                 }
             }
         } catch (Exception e) {
             throw new RuntimeException(e);
         } finally {
             if (osw != null) {
                 try {
                     osw.close();
                 } catch (IOException e) {
                     osw = null;
                     throw new RuntimeException(e);
                 }
             }
             if (br != null) {
                 try {
                     br.close();
                 } catch (IOException e) {
                     br = null;
                     throw new RuntimeException(e);
                 }
             }
         }
         return resultBuffer.toString();
     }
 
}
  

 
 
 
 
 
 
 
 
一、请求转发和请求重定向的区别 
请求转发和请求重定向又分别称为服务器跳转和客户端跳转
 
1.1、组件之间可否共享信息不同（本质区别） 
 当客户端向服务器发送请求时，服务器收到请求后，会将请求封装成一个HttpServletRequest对象request，并且所有的请求参数都封装在request对象中，这个对象时Jsp的内置对象可以直接在Jsp中使用。服务器收到请求后，还需要请求别的页面，这是就有两种方式：请求转发和请求重定向。
 
所谓请求转发，是服务器的行为，请求由服务器转发给另外一个页面处理，如何转发，何时转发，转发几次，客户端是不知道的。请求转发时，从发送第一次到最后一次请求的过程中，web容器只创建一次request和response对象，新的页面继续处理同一个请求。也可以理解为服务器将request对象在页面之间传递。
 
所谓请求重定向，是客户端的行为，每次请求重定向都是由客户端发起的，也就是说重定向一次，就刷新request对象的属性，之前的request对象的属性值就失效了。
 
1.2、浏览器地址栏显示不同（表面区别）
 
请求转发之后地址栏的信息并不会有任何的改变。 
 请求重定向之后地址栏是会改变的，变为跳转之后的页面地址。
 
二、Java实现 
 2.1 Java中的请求转发(服务器跳转) 
 执行到跳转语句时就会立刻进行跳转
 
Java代码：
 
<span style="color:#000000"><code><span style="color:#4f4f4f">request</span>.getRequestDispatcher(<span style="color:#009900">"success.jsp"</span>).forward(<span style="color:#4f4f4f">request</span>,<span style="color:#4f4f4f">response</span>);</code></span>
 
1
在jsp页面中你也会看到通过下面的方式实现转发：
 
<span style="color:#000000"><code><span style="color:#006666"><<span style="color:#4f4f4f">jsp:forward</span> <span style="color:#4f4f4f">page</span>=<span style="color:#009900">"success.jsp"</span> /></span></code></span>
 
1
2.2 Java中的请求重定向(客户端跳转)
 
response.sendRedirect("apage.jsp"); 不能传递request 范围的属性 ，但是可以通过地址重写的方式向跳转页传递参数，因为该方法执行完之后就相当于一次http request 的结束，这是服务器会向客户端发送302 状态码和新的url ，告诉客户端重新发送request 请求到新的url ，然后客户端照此执行，执行即新的请求响应流程开始，服务器再重新创建HttpServletRequest 对象和HttpServletResponse 对象，此时两个请求已经不在一个线程了，所以request 和response 对象都不是开始的那个了；
response.setHeader("refresh","2;URL=index.jsp") 2 秒后跳转到其他页面；
<a href="http://www.baidu.com"> 百度</a> 超链接
表单提交
三、路径问题
 
转发和重定向的URLString前有加 / 为绝对路径 反之为相对路径
 
3.1绝对路径 
 1、重定向的 / 表示：http://服务器ip:端口/
 
<span style="color:#000000"><code>response<span style="color:#009900">.sendRedirect</span>(<span style="color:#009900">"/Manager/index.jsp"</span>)</code></span>
 
1
生成的地址：web服务器本身地址+参数生成完整的URL 即：http://localhost:8080/Manager/index.jsp
 
2、请求转发的 / 表示：http://服务器ip:端口/项目名
 
<span style="color:#000000"><code><span style="color:#4f4f4f">request</span>.getRequestDispatcher(<span style="color:#009900">"/index.jsp"</span>).forward(<span style="color:#4f4f4f">request</span>, <span style="color:#4f4f4f">response</span>); </code></span>
 
1
生成的地址：http://localhost:8080/项目名/index.jsp
 
重定向是浏览器发来的，只知道发到某个服务器，但是不知道发到服务器的哪个project，所以需要自己用代码声明； 而请求转发是服务器某个project内部的转发，转来转去都是在某个project内部，所以不需要手动声明项目名。
 
3.2 相对路径
 
假设通过表单请求指定的Url资源 action="LoginServlet" 
 则表单生成的请求地址为：http://localhost:8080/项目名/LoginServlet
 
1、请求重定向：response.sendRedirect("Manager/index.jsp") 
 生成相对路径：http://localhost:8080/项目名/Manager/index.jsp 
 2、请求转发：相对路径情况下生成的完整URL与重定向方法相同。

[Java] 请求转发, 请求包含与请求重定向
 
请求转发: 
 
 
request.getRequestDispatcher("/DispatcherTest2").forward(request, response);

 或 

 
 

this.getServletContext().getRequestDispatcher("/DispatcherTest2").forward(request, response);
 
 

 Note:
 

 1)一次请求只能转发一次, 否则会发生下面的异常: -- 可以得到第一次转发获取的数据
 
java.lang.IllegalStateException: Cannot forward after response has been committed
 2)当有数据已经写到客户端时再请求转发也会抛出异常. 

 


 
 

 
 
3)若转发前有数据写入到response缓冲区,则请求转发会清空response缓冲区的实体内容, 但不会清空请求头信息. 
 
 

 
 
 
请求包含:
 

 当需要将多个servlet的输出合并到一块打给浏览器时可以使用请求包含
 
request.getRequestDispatcher("/DispatcherTest2").include(request, response);
或  
 
 
this.getServletContext().getRequestDispatcher("/DispatcherTest2").include(request, response);
 
 

 
 
 

 Notice:
 

     1)
 被包含的Servlet程序不能改变响应消息的状态码和响应头，如果它里面存在这样的语句，这些语句的执行结果将被忽略.
 

     2)常被用来进行页面布局
 
 

 
 
请求重定向:
 

 
 
response.sendRedirect(request.getContextPath() + "/DispatcherTest2");
 
 

  Notice:
 
 
 

  1) 不能在数据已经发送到浏览器之后再进行请求重定向:
 
 
 
java.lang.IllegalStateException: Cannot call sendRedirect() after the response has been committed
 
 
 

  2) 在请求重定向之前写入到response缓冲区的数据会被清空
 
 
 

  3) 一次请求只能重定向一次
 
 
 
 
 
 
 
 

 
 
 

  
 
Summary:
 
 

  请求重定向地址栏会发生变化.请求转发地址栏不发生变化.
 
 
 

  请求重定向两次请求两次响应.请求转发一次请求一次响应.
 
 
 

  
 
 
 
 

  如果需要在资源跳转时利用request域传递域属性则必须使用请求转发
 
 
 

  如果希望资源跳转后修改用户的地址栏则使用请求重定向
 
 
 

  如果使用请求转发也可以重定向也可以,则优先使用请求转发,减少浏览器对服务器的访问次数减轻服务器的压力.
 
 
 

 

 

 

1.Java web实现重定向
 
编写处理用户登录请求的LoginServlet类，如果在登录页面输入的用户名和密码正确就重定向到欢迎页面（welcome.html），否则重定向到登录页面（login.html）
 LoginServle.java
 
import java.io.IOException;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

public class LoginServlet extends HttpServlet {
	private static final long serialVersionUID = 1L;
	protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
		String name="admin";
		String pw="123456";
		String username=request.getParameter("name");
		String password=request.getParameter("password");
		if(!name.equals(username)) {
			response.sendRedirect("/WEB_TASK/login.html");
		}else if(!pw.equals(password)) {
			response.sendRedirect("/WEB_TASK/login.html");
		}else {
			response.sendRedirect("/WEB_TASK/welcome.html");
		}
	}
	protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {		
		doGet(request, response);
	}

}

 
welcome.html
 
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Insert title here</title>
</head>
<body>
<h2>WELCOME To Login!!!!</h2>
</body>
</html>
 
login.html
 
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Insert title here</title>
</head>
<body>
<h2>登录页面</h2>
<form action="/WEB_TASK/LoginServlet" method="post">
用户名:<input type="text" name="name"><br/>
密   码:<input type="password" name="password"><br/>
	<input type="submit" name="提交">
</form>
</body>
</html>
 
输入正确的用户名admin和密码123456
 
 此时跳转到welcome.html页面
 
 输入错误的用户名和密码，会再次登陆
 
 跳转到login.html页面
 
 
2.请求转发
 
编写接收用户请求的RequestForwardServlet，保存字符串数据到请求对象中，然后将请求转发给ResultServlet，ResultServlet取出保存在请求对象中的字符串数据并输出到客户端。
 
代码1：RequestForwardServlet.java
 
import java.io.IOException;

import javax.servlet.RequestDispatcher;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

public class RequestForwardServlet extends HttpServlet {
	private static final long serialVersionUID = 1L;
	protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
//		获取转发对象 转发到ResultServlet
		RequestDispatcher dispatcher=request.getRequestDispatcher("/ResultServlet");
//		调用转发方法 实现转发效果
		request.setAttribute("name", "aynu");
		dispatcher.forward(request, response);
	}
	protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
		doGet(request, response);
	}

}

 
代码2：ResultServlet.java
 
package lxq;

import java.io.IOException;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

public class ResultServlet extends HttpServlet {
	private static final long serialVersionUID = 1L;
	protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
		request.setCharacterEncoding("utf-8");
//		解决中文乱码问题
		response.setContentType("text/html;charset=utf-8");
		Object attribute=request.getAttribute("name");
		response.getWriter().write("RequestForwardServlet中保存的字符串是 ： "+attribute);
	}
	protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
		doGet(request, response);
	}

}

 
在RequestForwardServlet转发到ResultServlet，并输出