So vergleichen Sie Umleitung und Anforderungsweiterleitung mit httpclient in Java

Hier ist eine Einführung: HttpClient 4.x-Version, die Get-Request-Methode wird automatisch umgeleitet, aber die Post-Request-Methode wird nicht automatisch umgeleitet. Darauf sollten Sie achten. Das letzte Mal, dass ich einen Fehler gemacht habe, war, als ich das Anmeldeformular per Post abgeschickt habe, aber zu diesem Zeitpunkt gab es keine automatische Weiterleitung.

Der Unterschied zwischen Anforderungsweiterleitung und -umleitung

1 Bei der Umleitung handelt es sich um zwei Anforderungen und bei der Weiterleitung um eine Anforderung, sodass die Weiterleitungsgeschwindigkeit schneller ist als bei der Umleitung.

2. Nach der Weiterleitung ändert sich die Adresse in der Adressleiste und wird zum zweiten Mal zur angeforderten Adresse. Nach der Weiterleitung ändert sich die Adresse in der Adressleiste nicht und bleibt die zum ersten Mal angeforderte Adresse.

3. Weiterleitung ist ein Serververhalten und Umleitung ist ein Clientverhalten. Bei der Weiterleitung ändert sich die URL im Browser; bei der Weiterleitung bleibt die URL im Browser unverändert.

4. Die Umleitung besteht aus zwei Anfragen und die Weiterleitung aus nur einer Anfrage.

5. Die URL bei der Weiterleitung kann eine beliebige URL sein und die weitergeleitete URL muss die URL dieser Website sein.

Hier konzentrieren wir uns auf den dritten und vierten Punkt.

HTTP-Nachricht enthält Antwortcode, Antwortheader und Antworttext. Hier werden nur 200 und 302 erwähnt. Antwortcode: 2xx (normalerweise 200). Zeigt an, dass die Anfrage erfolgreich ist und die Antwortdaten dann akzeptiert werden können. Antwortcode: 3xx (normalerweise 302). zeigt eine Umleitung an. Der Server fordert den Client auf, eine Anfrage erneut zu senden. Der Server sendet einen Antwortheader „Location“, der die URL-Adresse der neuen Anfrage angibt. (Das ist sehr wichtig! Der Client muss die umgeleitete Adresse über den Location-Header erhalten. )

Die Anforderungsweiterleitung wird hier nicht erwähnt, da die Anforderungsweiterleitung ein serverseitiger Vorgang ist, der innerhalb des Servers ausgeführt wird . , es handelt sich also nur um eine Anfrage (Kein Unterschied zu einer gewöhnlichen Anfrage auf Kundenseite). Bei der Umleitung handelt es sich um einen Client-Vorgang, da der Server vom Client verlangt, eine Anforderung erneut zu senden. Bei der Umleitung handelt es sich also um zwei Anforderungen. Dies erklärt auch, warum die Anfrageparameter nach der Umleitung verloren gehen, da es sich überhaupt nicht um eine Anfrage handelt. Ich spreche hier vom Client, nicht vom Browser, denn manchmal verwenden wir nicht unbedingt den Browser als Client. Beispielsweise ist ein Crawler auch ein Client.

Wenn Sie jedoch zum ersten Mal mit dem Lernen beginnen, oder für normale Benutzer, können Sie den Unterschied zwischen den beiden nicht spüren. Sie können höchstens herausfinden, ob sich die Browseradresse geändert hat. Die Browseradresse für die Anforderungsweiterleitung bleibt unverändert, während sich die Browseradresse für die Weiterleitung in eine neue Adresse ändert. (Die beiden umgeleiteten Anforderungen werden jedoch in diesem Prozess nicht berücksichtigt. Dies liegt daran, dass der Browser uns automatisch umleitet.) 4.

Java-WebpartTestServlet-Klasse

stellt eine einfache Servlet-Klasse mit ihrer Funktionalität und Einfachheit bereit. Sie trägt einen Schlüsselparameter. Wenn der Parameter vorhanden ist und der Wert „1“ ist, wird die Anforderung an „/“ weitergeleitet. „dispatcher.jsp“-Seite; andernfalls leiten Sie zur Seite „redirect.jsp“ weiter.

package com.study;

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

@WebServlet("/TestServlet")
public class TestServlet extends HttpServlet {
	private static final long serialVersionUID = 1L;
    
	protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
		request.setCharacterEncoding("UTF-8");
		String key = request.getParameter("key");
		if((key != null && key.equals("1"))) {
			System.out.println("请求转发：key " + key);
			//请求转发
			request.getRequestDispatcher("/dispatcher.jsp").forward(request,response);
		}else {
			//重定向
			response.sendRedirect("redirect.jsp");
			System.out.println("重定向：key " + key);
		}
	}

	protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
		doGet(request, response);
	}

}

dispacher.jsp

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>请求转发</title>
</head>
<body>
<h2>请求转发</h2>
</body>
</html>

redirect.jsp

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>重定向</title>
</head>
<body>
<h2>重定向</h2>
</body>
</html>

Projekttest starten

Mein Zweck hier ist hauptsächlich der Zugriffsunterschied zwischen Anforderungsweiterleitung und -umleitung, nicht der Vergleich anderer Unterschiede zwischen ihnen, daher ist das Beispiel sehr einfach.

Testanforderungsadresse: http://localhost:8080/study/TestServlet?key=1

Hinweis: Die Anforderungsadresse hat sich nicht geändert.

Testanfrageadresse: http://localhost:8080/study/TestServlet?key=2

Hinweis: Die Anfrageadresse hat sich geändert.

In diesem Fall können Sie keinen Unterschied im Zugriff zwischen den beiden erkennen, aber wenn Sie ihn nicht sehen können, bedeutet das nicht, dass es keinen Unterschied im Zugriff gibt Methode zwischen den beiden durch den folgenden Code.

HttpClient verwenden

301 Dauerhaft verschoben

• 302 Gefunden

• 303 Andere anzeigen

• 307 Temporäre Weiterleitung

• Da die HttpClient 4.x-Version automatisch umleitet, müssen wir die automatische Umleitung deaktivieren um den Weiterleitungsvorgang nachzuverfolgen.

In RequestConfig einstellen und das Timeout festlegen (drei).

//HttpClient4.3中默认允许自动重定向，导致程序中不能跟踪跳转情况。
int timeout = 10*1000;
RequestConfig config = RequestConfig.custom()
		.setSocketTimeout(timeout)
		.setConnectTimeout(timeout)
		.setConnectionRequestTimeout(timeout)
		.setRedirectsEnabled(false)   //关闭自动重定向，默认值为true。
		.build();

Dann stellen Sie die automatische Weiterleitung beim Senden einer Anfrage ein und erlauben Sie diese.

//创建get请求对象
HttpGet getMethod = new HttpGet(url);
//设置请求方法关闭自动重定向
getMethod.setConfig(config);  //配置信息

Auf diese Weise, wenn wir auf den Pfad zugreifen: http://localhost:8080/study/TestServlet?key=1

Der Server leitet die Anfrage weiter, aber das ist Serververhalten und hat nichts mit dem Client zu tun , also ist uns das egal. Wenn die Anfrage korrekt ist, lautet der Antwortcode 200.

Testergebnisse:

当我们访问路径为：http://localhost:8080/study/TestServlet?key=2，服务器会要求客户端进行重定向（即要求客户端请求另一个地址），这时会先收到状态码 302，当再次访问成功时状态码为 200（当然了，也许重定向不止一次，但是浏览器会对重定向次数有限制）。

如果发生了重定向，我们需要获取响应头中的 Location 字段，这里面是重定向的地址。

//读取新的 URL 地址
Header header = response.getFirstHeader("location");
String newUrl = header.getValue();

注意：重定向是可以访问服务器外的地址的，服务器内部的地址一般是相对地址，需要拼接 URL，服务器外就是绝对 URL 了。

测试结果：

完整测试代码

package com.learn;

import java.io.IOException;

import org.apache.http.Header;
import org.apache.http.HttpEntity;
import org.apache.http.HttpStatus;
import org.apache.http.ParseException;
import org.apache.http.client.config.RequestConfig;
import org.apache.http.client.methods.CloseableHttpResponse;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.util.EntityUtils;

public class TestRedirect {
	
	/**
	 * 重定向是客户端操作，而请求转发是服务端操作 。
	 * 但是通常用户使用浏览器，并不注意二者的区别，
	 * 这是因为浏览器自动帮我们重定向了。（当然了，
	 * 编程还是需要注意的）。
	 * @throws IOException 
	 * @throws ParseException 
	 * */
	public static void main(String[] args) throws ParseException, IOException {
		String root = "http://localhost:8080/study/";  //网站的根路径，因为重定向得到的是相对路径（服务器内部的路径）
		
		//HttpClient4.3中默认允许自动重定向，导致程序中不能跟踪跳转情况。
		int timeout = 10*1000;
		RequestConfig config = RequestConfig.custom()
				.setSocketTimeout(timeout)
				.setConnectTimeout(timeout)
				.setConnectionRequestTimeout(timeout)
				.setRedirectsEnabled(false)   //关闭自动重定向，默认值为true。
				.build();
		
		
		String url = "http://localhost:8080/study/TestServlet?key=1";  //请求转发。
		
		//创建 httpclient 对象
		CloseableHttpClient httpClient = HttpClients.createDefault();
		//创建get请求对象
		HttpGet getMethod = new HttpGet(url);
		getMethod.setConfig(config);  //配置信息
	
		//执行请求，得到响应信息
		try (CloseableHttpResponse response = httpClient.execute(getMethod)) {
			HttpEntity entity = null;
			int statusCode = response.getStatusLine().getStatusCode();
			System.out.println("返回值状态码：" + statusCode);
			if (statusCode == HttpStatus.SC_OK) {  
				//获取请求转发的实体信息
				entity = response.getEntity();
				if (entity != null) {
					System.out.println(EntityUtils.toString(entity, "UTF-8"));
				}
			} else if (statusCode == HttpStatus.SC_MOVED_TEMPORARILY) {
				
				//读取新的 URL 地址
				Header header = response.getFirstHeader("location");
				System.out.println(header);
				if (header != null) {
					String newUrl = header.getValue();
					if (newUrl != null && !newUrl.equals("")) {
						//使用get方法转向。
						HttpGet redirectGet = new HttpGet(root+newUrl);
						System.out.println("重定向到新的地址：" + redirectGet.getURI());
						redirectGet.setConfig(config);
						//发送请求，做进一步处理。。。
						try (CloseableHttpResponse redirectRes = httpClient.execute(redirectGet)) {
							statusCode = redirectRes.getStatusLine().getStatusCode();
							System.out.println("返回值状态码：" + statusCode);
							if (statusCode == HttpStatus.SC_OK) {  
								//获取请求转发的实体信息
								entity = redirectRes.getEntity();
								if (entity != null) {
									System.out.println(EntityUtils.toString(entity, "UTF-8"));
								}
							}
						}
					}
				}
			} 
		}
	}
}

Das obige ist der detaillierte Inhalt vonSo vergleichen Sie Umleitung und Anforderungsweiterleitung mit httpclient in Java. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!