Bagaimana untuk membandingkan pengalihan dan pemajuan permintaan menggunakan httpclient dalam Java

Berikut ialah pengenalan: Versi HttpClient 4.x, kaedah permintaan dapatkan akan mengubah hala secara automatik, tetapi kaedah permintaan siaran tidak akan mengubah hala secara automatik. Ini adalah sesuatu yang perlu diberi perhatian. Kali terakhir saya membuat ralat ialah apabila saya menggunakan pos untuk menyerahkan borang untuk log masuk, tetapi tiada ubah hala automatik pada masa itu.

Perbezaan antara pemajuan permintaan dan pengalihan semula

1 Pengalihan semula ialah dua permintaan, dan pemajuan ialah satu permintaan, jadi kelajuan pemajuan lebih cepat daripada pengalihan.

2. Selepas ubah hala, alamat pada bar alamat akan bertukar kepada alamat yang diminta untuk kali kedua Selepas pemajuan, alamat pada bar alamat tidak akan berubah dan kekal sebagai alamat yang diminta untuk kali pertama.

3. Pemajuan ialah tingkah laku pelayan dan pengalihan semula ialah tingkah laku pelanggan. Apabila mengubah hala, URL pada penyemak imbas berubah apabila memajukan, URL pada penyemak imbas kekal tidak berubah.

4 Ubah hala ialah dua permintaan dan pemajuan hanyalah satu permintaan.

5 URL semasa mengubah hala boleh menjadi mana-mana URL dan URL yang dimajukan mestilah URL tapak ini.

Di sini kita fokus pada item ketiga dan keempat.

Mesej HTTP mengandungi kod respons, pengepala respons dan badan respons. Hanya 200 dan 302 disebut di sini Kod respons: 2xx (biasanya 200). Menunjukkan bahawa permintaan itu berjaya, dan kemudian data respons boleh diterima. Kod respons: 3xx (biasanya 302). menunjukkan ubah hala Pelayan akan meminta klien menghantar semula permintaan Pelayan akan menghantar pengepala respons Lokasi, yang menentukan alamat URL permintaan baharu. (Ini sangat penting! Pelanggan perlu mendapatkan alamat diubah hala melalui pengepala Lokasi. )

Tiada sebutan tentang pemajuan permintaan di sini, kerana pemajuan permintaan ialah pelayan -sisi Operasi dilakukan di dalam pelayan, jadi ia hanyalah permintaan (Tiada perbezaan antara klien dan permintaan biasa). Pengalihan adalah berbeza, ia adalah operasi klien, kerana pelayan memerlukan klien untuk menghantar semula permintaan, jadi pengalihan adalah dua permintaan. Ini juga menerangkan sebab parameter permintaan hilang selepas ubah hala, kerana ia bukan permintaan sama sekali. Saya bercakap tentang pelanggan di sini, bukan penyemak imbas, kerana kadangkala kita mungkin tidak semestinya menggunakan penyemak imbas sebagai pelanggan Sebagai contoh, perangkak juga pelanggan.

Namun, bagi mereka yang baru mula belajar, atau bagi pengguna biasa, nampaknya mereka tidak dapat merasakan perbezaan antara kedua-duanya, mereka boleh mengetahui sama ada alamat penyemak imbas telah berubah . Alamat penyemak imbas pemajuan permintaan kekal tidak berubah, manakala alamat penyemak imbas yang mengubah hala bertukar kepada alamat baharu. (Walau bagaimanapun, kedua-dua permintaan diubah hala tidak ditunjukkan dalam proses ini. Ini kerana penyemak imbas secara automatik mengubah hala kami .)

Mari kita lihat permintaan kedua menggunakan pengaturcaraan Java antara: Item 3 dan 4 di atas.

Bahagian web Java

Kelas TestServlet

Menyediakan kelas Servlet yang ringkas, fungsi dan kesederhanaannya, ia akan membawa parameter utama, jika parameter wujud dan nilainya ialah " 1", maka permintaan itu dimajukan ke halaman "/dispatcher.jsp"; jika tidak, permintaan itu diubah hala ke halaman "redirect.jsp".

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 id="请求转发">请求转发</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 id="重定向">重定向</h2>
</body>
</html>

Mulakan ujian projek

Tujuan saya di sini adalah terutamanya untuk meminta pemajuan Perbezaan antara akses dan ubah hala bukanlah perbezaan lain antara membandingkannya, jadi contohnya sangat mudah.

Alamat permintaan ujian: http://localhost:8080/study/TestServlet?key=1

Nota: Alamat permintaan tidak berubah.

Alamat permintaan ujian: http://localhost:8080/study/TestServlet?key=2 Nota: Alamat permintaan Sesuatu telah berubah.

Dalam kes ini, anda tidak dapat melihat sebarang perbezaan dalam akses antara kedua-duanya, tetapi jika anda tidak dapat melihatnya, ia tidak bermakna ada tiada perbezaan di antara mereka. Mari gunakan kod di bawah Lihat perbezaan kaedah akses antara kedua-duanya.

Gunakan HttpClient

• 301 Dialihkan Secara Kekal

• 302 Ditemui

• 30 Lihat Lain

• 307 Ubah Hala Sementara

Disebabkan HttpClient 4.x Versi akan mengubah hala secara automatik, jadi kami mesti mematikan ubah hala automatik untuk menjejak proses pengalihan.

Tetapkan dalam RequestConfig dan tetapkan tamat masa (tiga).

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

Kemudian tetapkan dan benarkan ubah hala automatik apabila menghantar permintaan.

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

Dengan cara ini, apabila kita mengakses laluan: http://localhost:8080/study/TestServlet?key=1

Pelayan akan memajukan permintaan, tetapi ini adalah tingkah laku pelayan, dan Pelanggan tiada kaitan dengannya, jadi kami tidak perlu peduli Jika permintaan itu betul, kod respons ialah 200.

Keputusan ujian:

当我们访问路径为：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"));
								}
							}
						}
					}
				}
			} 
		}
	}
}

Atas ialah kandungan terperinci Bagaimana untuk membandingkan pengalihan dan pemajuan permintaan menggunakan httpclient dalam Java. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!