當前位置：首頁 » 編程語言 » java代理

java代理

發布時間: 2022-01-11 06:59:00

Ⅰ java代理的作用和實現

JDK 動態代理

動態代理的核心其實就是代理對象的生成，即 Proxy.newProxyInstance(classLoader, proxyInterface, handler)。

讓我們進入newProxyInstance方法觀摩下，核心代碼其實就三行。

這個方法需要三個參數：

  • ClassLoader，用於載入代理類的 Loader 類，通常這個 Loader 和被代理的類是同一個 Loader 類。

  • Interfaces，是要被代理的那些那些介面。

  • InvocationHandler，就是用於執行除了被代理介面中方法之外的用戶自定義的操作，也是用戶需要代理的最終目的。用戶調用目標方法都被代理到 InvocationHandler 類中定義的唯一方法 invoke 中。

  • //獲取代理類 Class cl = getProxyClass(loader, interfaces);

  • //獲取帶有InvocationHandler參數的構造方法 Constructor cons = cl.getConstructor(constructorParams);

  • //把handler傳入構造方法生成實例 return (Object) cons.newInstance(new Object[] { h });

    • 一個典型的動態代理創建對象過程可分為以下四個步驟：

    1、通過實現InvocationHandler介面創建調用處理器

  • IvocationHandler handler = new InvocationHandlerImpl(...);

    • 2、通過為Proxy類指定ClassLoader對象和一組interface創建動態代理類

  • Class clazz = Proxy.getProxyClass(classLoader,new Class[]{...});

    • 3、通過反射機制獲取動態代理類的構造函數，其參數類型是調用處理器介面類型

  • Constructor constructor = clazz.getConstructor(new Class[]{InvocationHandler.class});

    • 4、通過構造函數創建代理類實例，此時需將調用處理器對象作為參數被傳入

  • Interface Proxy = (Interface)constructor.newInstance(new Object[] (handler));

    • 為了簡化對象創建過程，Proxy類中的newProxyInstance方法封裝了2~4，只需兩步即可完成代理對象的創建。

  • Subject proxySubject = (Subject)Proxy.newProxyInstance(Subject.class.getClassLoader(),

  • new Class[]{Subject.class}, new InvocationHandlerImpl (real));

    • 生成的proxySubject繼承Proxy類實現Subject介面。實現的Subject的方法實際是調用處理器的invoke方法，而invoke方法利用反射調用的是被代理對象的方法（Object result=method.invoke(proxied,args)）；
    重點Proxy.newProxyInstance，源碼分析，會在其他文檔中單獨總結記錄。類Proxy的getProxyClass方法調用ProxyGenerator的 generateProxyClass方法產生ProxySubject.class的二進制數據。

    創建代理對象時序圖

    獲取代理類

    getProxyClass(loader, interfaces)方法用於獲取代理類，它主要做了三件事情：

    在當前類載入器的緩存里搜索是否有代理類，沒有則生成代理類並緩存在本地JVM里。

  • // 緩存的key使用介面名稱生成的List Object key = Arrays.asList(interfaceNames);

  • synchronized (cache) {

  • do {

  • Object value = cache.get(key);

  • // 緩存里保存了代理類的引用 if (value instanceof Reference) {

  • proxyClass = (Class) ((Reference) value).get();

  • }

  • if (proxyClass != null) {

  • // 代理類已經存在則返回

  • return proxyClass;

  • } else if (value == pendingGenerationMarker) {

  • // 如果代理類正在產生，則等待

  • try {

  • cache.wait();

  • } catch (InterruptedException e) {

  • }

  • continue;

  • } else {

  • //沒有代理類，則標記代理准備生成

  • cache.put(key, pendingGenerationMarker);

  • break;

  • }

  • } while (true);

  • }

    • 生成並載入代理類

    代理類的生成主要是以下這兩行代碼：

  • //生成代理類的位元組碼文件並保存到硬碟中(默認不保存到硬碟) proxyClassFile = ProxyGenerator.generateProxyClass(proxyName, interfaces);

  • //使用類載入器將位元組碼載入到內存中 proxyClass = defineClass0(loader, proxyName,proxyClassFile, 0, proxyClassFile.length);

    • 代理類的生成過程


    ProxyGenerator.generateProxyClass()方法屬於sun.misc包下，Oracle並沒有提供源代碼，但是我們可以使用
    JD-GUI這樣的反編譯軟體打開jrelib t.jar來一探究竟，以下是其核心代碼的分析。

  • //添加介面中定義的方法，此時方法體為空 for (int i = 0; i < this.interfaces.length; i++) {

  • localObject1 = this.interfaces[i].getMethods();

  • for (int k = 0; k < localObject1.length; k++) {

  • addProxyMethod(localObject1[k], this.interfaces[i]);

  • }

  • }

  • //添加一個帶有InvocationHandler的構造方法 MethodInfo localMethodInfo = new MethodInfo("<init>", "(Ljava/lang/reflect/InvocationHandler;)V", 1);

  • //循環生成方法體代碼（省略） //方法體里生成調用InvocationHandler的invoke方法代碼。（此處有所省略） this.cp.getInterfaceMethodRef("InvocationHandler", "invoke", "Object; Method; Object;")

  • //將生成的位元組碼，寫入硬碟，前面有個if判斷，默認情況下不保存到硬碟。 localFileOutputStream = new FileOutputStream(ProxyGenerator.access$000(this.val$name) + ".class");

  • localFileOutputStream.write(this.val$classFile);

    • 生成的代理類源碼

    那麼通過以上分析，我們可以推出動態代理為我們生成了一個這樣的代理類。把方法doSomeThing的方法體修改為調用LogInvocationHandler的invoke方法。

  • public class ProxyBusiness extends Proxy implements IBusiness, IBusiness2 {

  • private LogInvocationHandler h;

  • @Override public void doSomeThing2() {

  • try {

  • Method m = (h.target).getClass().getMethod("doSomeThing2",null);

  • h.invoke(this, m, null);

  • } catch (Throwable e) {

  • // 異常處理（略）

  • }

  • }

  • @Override public boolean doSomeThing() {

  • try {

  • Method m = (h.target).getClass().getMethod("doSomeThing", null);

  • return (Boolean) h.invoke(this, m, null);

  • } catch (Throwable e) {

  • // 異常處理（略）

  • }

  • return false;

  • }

  • public ProxyBusiness(LogInvocationHandler h) {

  • this.h = h;

  • }

    • 測試代理的代碼如下：

  • //測試public static void main(String[] args) {

  • //構建AOP的Advice

  • LogInvocationHandler handler = new LogInvocationHandler(new Business());

  • new ProxyBusiness(handler).doSomeThing();

  • new ProxyBusiness(handler).doSomeThing2();

  • }

    • 下面看一個自定義代理的實現。

    被代理類介面

  • public interface Subject {

  • public void doSomething();

  • }

    • 被代理類

  • //目標對象public class RealSubject implements Subject{ public void doSomething() {

  • System.out.println( "call doSomething()" );

  • }

  • }

    • 調用處理器(切面)

  • public class ProxyHandler implements InvocationHandler {

  • private Object proxied;

  • public ProxyHandler( Object proxied ) {

  • this.proxied = proxied;

  • }

  • public Object invoke( Object proxy, Method method, Object[] args ) throws Throwable {

  • //在轉調具體目標對象之前，可以執行一些功能處理System.out.println( "doSomething before" ); //轉調具體目標對象的方法

  • return method.invoke( proxied, args);

  • //在轉調具體目標對象之後，可以執行一些功能處理System.out.println( "doSomething after" );

  • }

  • }

    • 測試我們的代理實現

  • public class DynamicProxy {

  • public static void main( String args[] ) {

  • RealSubject real = new RealSubject();

  • Subject proxySubject = (Subject)Proxy.newProxyInstance(Subject.class.getClassLoader(),

  • new Class[]{Subject.class}, new ProxyHandler(real));

  • proxySubject.doSomething(); //write proxySubject class binary data to file

  • createProxyClassFile();

  • }

  • public static void createProxyClassFile() {

  • String name = "ProxySubject";

  • byte[] data = ProxyGenerator.generateProxyClass( name, new Class[] { Subject.class } );

  • try{

  • FileOutputStream out = new FileOutputStream( name + ".class" );

  • out.write( data );

  • out.close();

  • }catch( Exception e ) {

  • e.printStackTrace();

  • }

  • }

  • }

    • 運行結果：

  • doSomething beforecall doSomething()doSomething after

    • Proxy 介面

    Proxy 的主要靜態變數

  • // 映射表：用於維護類裝載器對象到其對應的代理類緩存private static Map loaderToCache = new WeakHashMap();// 標記：用於標記一個動態代理類正在被創建中private static Object pendingGenerationMarker = new Object();// 同步表：記錄已經被創建的動態代理類類型，主要被方法 isProxyClass 進行相關的判斷private static Map proxyClasses = Collections.synchronizedMap(new WeakHashMap());// 關聯的調用處理器引用protected InvocationHandler h;

  • Proxy的構造方法// 由於 Proxy 內部從不直接調用構造函數，所以 private 類型意味著禁止任何調用private Proxy() {}// 由於 Proxy 內部從不直接調用構造函數，所以 protected 意味著只有子類可以調用protected Proxy(InvocationHandler h) {this.h = h;}

    • ProxySubject 源碼

    創建的代理類 ProxySubject.class

  • import java.lang.reflect.*;

  • public final class ProxySubject extends Proxy implements Subject{

  • private static Method m1;

  • private static Method m0;

  • private static Method m3;

  • private static Method m2;

  • public ProxySubject(InvocationHandler invocationhandler){

  • super(invocationhandler);

  • }

  • public final boolean equals(Object obj){

  • try {

  • return ((Boolean)super.h.invoke(this, m1, new Object[] {

  • obj

  • })).booleanValue();

  • }catch(Error _ex) {

  • }catch(Throwable throwable){

  • throw new UndeclaredThrowableException(throwable);

  • }

  • }

  • public final int hashCode() {

  • try {

  • return ((Integer)super.h.invoke(this, m0, null)).intValue();

  • }catch(Error _ex) {

  • }catch(Throwable throwable){

  • throw new UndeclaredThrowableException(throwable);

  • }

  • }

  • /*關鍵部分*/

  • public final void doSomething() {

  • try {

  • // Proxy類中protected InvocationHandler h;關聯的調用處理器引用

  • super.h.invoke(this, m3, null);

  • return;

  • }catch(Error _ex) {

  • }catch(Throwable throwable) {

  • throw new UndeclaredThrowableException(throwable);

  • }

  • }

  • public final String toString() {

  • try {

  • return (String)super.h.invoke(this, m2, null);

  • } catch(Error _ex) {

  • } catch(Throwable throwable){

  • throw new UndeclaredThrowableException(throwable);

  • }

  • }

  • static{

  • try {

  • m1 = Class.forName("java.lang.Object").getMethod("equals", new Class[] {

  • Class.forName("java.lang.Object")

  • });

  • m0 = Class.forName("java.lang.Object").getMethod("hashCode", new Class[0]);

  • m3 = Class.forName("Subject").getMethod("doSomething", new Class[0]);

  • m2 = Class.forName("java.lang.Object").getMethod("toString", new Class[0]);

  • }catch(NoSuchMethodException nosuchmethodexception) {

  • throw new NoSuchMethodError(nosuchmethodexception.getMessage());

  • }catch(ClassNotFoundException classnotfoundexception){

  • throw new NoClassDefFoundError(classnotfoundexception.getMessage());

  • }

  • }

  • }

    • CGLib 動態代理

    動態位元組碼生成。使用動態位元組碼生成技術實現AOP原理是在運行期間目標位元組碼載入後，生成目標類的子類，將切面邏輯加入到子類中，所以使用Cglib實現AOP不需要基於介面。

  • public static void main(String[] args) {

  • byteCodeGe();

  • }

  • public static void byteCodeGe() {

  • //創建一個織入器

  • Enhancer enhancer = new Enhancer();

  • //設置父類

  • enhancer.setSuperclass(Business.class);

  • //設置需要織入的邏輯

  • enhancer.setCallback(new LogIntercept());

  • //使用織入器創建子類

  • IBusiness2 newBusiness = (IBusiness2) enhancer.create();

  • newBusiness.doSomeThing2();

  • }

  • /**

  • * 記錄日誌

  • */ public static class LogIntercept implements MethodInterceptor {

  • @Override

  • public Object intercept(Object target, Method method, Object[] args, MethodProxy proxy) throws Throwable {

  • //執行原有邏輯，注意這里是invokeSuper

  • Object rev = proxy.invokeSuper(target, args);

  • //執行織入的日誌

  • if (method.getName().equals("doSomeThing2")) {

  • System.out.println("記錄日誌");

  • }

  • return rev;

  • }

  • }

Ⅱ Java 中怎樣在程序中設置代理伺服器

importjava.io.BufferedReader;
importjava.io.InputStreamReader;
importjava.net.Authenticator;
importjava.net.HttpURLConnection;
importjava.net.InetSocketAddress;
importjava.net.PasswordAuthentication;
importjava.net.Proxy;
importjava.net.URL;

publicclassProxyDemo2{
publicstaticvoidmain(String[]args)throwsException{
URLurl=newURL("http://www.3lai8.com");
///創建代理伺服器
InetSocketAddressaddr=newInetSocketAddress("192.168.0.254",8080);
//Proxyproxy=newProxy(Proxy.Type.SOCKS,addr);//Socket代理
Proxyproxy=newProxy(Proxy.Type.HTTP,addr);//http代理
Authenticator.setDefault(newMyAuthenticator("username","password"));//設置代理的用戶和密碼
HttpURLConnectionconnection=(HttpURLConnection)url.openConnection(proxy);//設置代理訪問
InputStreamReaderin=newInputStreamReader(connection.getInputStream());
BufferedReaderreader=newBufferedReader(in);
while(true){
Strings=reader.readLine();
if(s!=null){
System.out.println(s);
}
}
}

{
privateStringuser="";
privateStringpassword="";

publicMyAuthenticator(Stringuser,Stringpassword){
this.user=user;
this.password=password;
}

(){
(user,password.toCharArray());
}
}

}

Ⅲ 如何用java使用代理

Java中，使用proxy是通過設置java環境變數來實現的，也就是JVM的系統屬性。

我們需要設置三個屬性，proxySet proxyHost和proxyPort。
proxySet 是個boolean類型的，可以設置為true或者false，true代表使用代理伺服器。
proxyHost 是代理伺服器的IP地址
proxyPort 是代理伺服器的埠地址。

我們有兩種方法設置這種系統屬性，
一種是命令行下運行Java程序的時候，通過參數付值
一種是在java源程序中設置。

第一種方法的格式如下：
java -DproxySet=true -DproxyHost=myProxyServer.come -DproxyPort=80 MyJavaApp

第二種方法，就是直接在源程序中通過系統屬性來寫，如下：
import java.util.Properties;
...
...

strProxy="221.15.5.67";
strPort="8080";

Properties systemProperties = System.getProperties();
systemProperties.setProperty("http.proxyHost",strProxy);
systemProperties.setProperty("http.proxyPort",strPort);
....

JDK1.3以上版本，只要設置了proxyHost和proxyPort就不用寫proxySet了。

那麼反過來，顯示這些系統屬性，就可以看到有沒有使用代理了。

Ⅳ Java代理的三種模式有什麼

Java的三種代理模式簡述

本文著重講述三種代理模式在java代碼中如何寫出，為保證文章的針對性，暫且不討論底層實現原理，具體的原理將在下一篇文章中講述。

代理模式是什麼

代理模式是一種設計模式，簡單說即是在不改變源碼的情況下，實現對目標對象的功能擴展。

比如有個歌手對象叫Singer，這個對象有一個唱歌方法叫sing()。

假如你希望，通過你的某種方式生產出來的歌手對象，在唱歌前後還要想觀眾問好和答謝，也即對目標對象Singer的sing方法進行功能擴展。

但是往往你又不能直接對源代碼進行修改，可能是你希望原來的對象還保持原來的樣子，又或許你提供的只是一個可插拔的插件，甚至你有可能都不知道你要對哪個目標對象進行擴展。這時就需要用到java的代理模式了。網上好多用生活中的經理人的例子來解釋「代理」，看似通俗易懂，但我覺得不適合程序員去理解。程序員應該從代碼的本質入手。

Ⅳ 想用java編寫個代理伺服器，求具體一些思路，詳細一些，謝謝

在編寫代理伺服器之前，首先應該明白一點，Java的代理機制，如圖所示：

那麼Java就處於中間這層代理伺服器，代理伺服器所作的事情如下：
1、接收客戶端請求，進行處理，然後發送給服務端
2、接收服務端響應，進行處理，然後發送給客戶端
這樣，就更清晰了，Java提供了代理的API為，java.net.Proxy類。此類表示代理設置，通常為類型（http、socks）和套接字地址。Proxy 是不可變對象。

也就是說Java可以製作高級協議的代理，如 HTTP 或 FTP。也可以製作SOCKS（V4 或 V5）代理。
首先，使用到了URL類，HttpURLConnection類及其我們的代理類Proxy類。他們都位於java.net包中。

第一步：生成代理，指定埠為8888：

第二步：使用URLConnection類進行連接www.moonsos.com

第三步：打開URL，並且讀取HTML源碼

Ⅵ Java怎麼設置代理來訪問網路

你的問題應該是：在java中通過編程設置代理伺服器並訪問網路，現在作答如下：

1，講解一下基礎知識：
HTTP：是應用層協議，是基於傳輸層協議的。
TCP: 是傳輸層協議，是基於網路層協議的。
IP: 是網路層協議。
一個TCP的連接要進行三次握手（就像轉戶口一樣，不詳說），HTTP只是一個應用協議，也就是相當於一個自定義協議，即其沒有對底層的傳輸方式進行干涉，只是對數據內容格式進行了定義。

2，我們再說說HTTP代理，從上可以理解，HTTP代理伺服器就是這樣一台機器：你把所有的HTTP請求都發到這個 HTTP代理伺服器，然後這個HTTP代理伺服器請求你要訪問的最終地址，把響應回傳給你。這里還要注意它代理的是HTTP協議，而HTTP又是基於 TCP的，也就是說這個伺服器代理的是指定HTTP內容格式的TCP連接。再說下去也沒意思了，看以下代碼：
//以下地址是代理伺服器的地址
Socket socket = new Socket("10.1.2.188", 80);
//寫與的內容就是遵循HTTP請求協議格式的內容，請求網路
socket.getOutputStream().write(new String("GET http://www..com/ HTTP/1.1\r\n\r\n").getBytes());
byte[] bs = new byte[1024];
InputStream is = socket.getInputStream();
int i;
while ((i = is.read(bs)) > 0) {
System.out.println(new String(bs, 0, i));
}
is.close();
3，當然在Java中，有Proxy代理上網的使用，此時使用URL(HTTP)就不涉及Socket(TCP)了，看如下代碼
//設置代理
System.setProperty("http.proxySet", "true");
System.setProperty("http.proxyHost", "10.1.2.188");
System.setProperty("http.proxyPort", "80");

//直接訪問目的地址
URL url = new URL("http://www..com");
URLConnection con = url.openConnection();
InputStreamReader isr = new InputStreamReader(con.getInputStream());
char[] cs = new char[1024];
int i = 0;
while ((i = isr.read(cs)) > 0) {
System.out.println(new String(cs, 0, i));
}
isr.close();

Ⅶ java爬蟲代理如何實現

爬蟲離不開的就是代理伺服器了，如果我們不用http來爬蟲，ip不更改的情況下，是很難進行的。當我們在使用爬蟲爬取網站資料，速度快，可以不知疲倦地連續工作。但是由於爬蟲軟體在訪問網站時，行為過於頻繁，遠超人力操作速度，就很容易被網站察覺，而封掉用戶的IP。
所以，使用爬蟲軟體時，為了防止IP被封，或者IP已經被封，還想用自己的IP訪問封了自己IP的網站時，就要用到代理IP了。http能夠對我們的ip地址進行更改，這一操作能夠有效減少了網站的ip限制的影響，對爬蟲是很有幫助的。Ipidea含有240＋國家地區的ip，真實住宅網路高度匿名強力保護本地信息。

Ⅷ java中的代理有什麼用

主要就是包裝被代理類,注冊一個回調類，攔截被代理類調用，執行相關操作，spring的aop就可以用代理來實現

Ⅸ java中的代理類一般在什麼時候使用呢

1.代理模式

代理模式的作用是：為其他對象提供一種代理以控制對這個對象的訪問。在某些情況下，一個客戶不想或者不能直接引用另一個對象，而代理對象可以在客戶端和目標對象之間起到中介的作用。

代理模式一般涉及到的角色有：

抽象角色 ：聲明真實對象和代理對象的共同介面；

代理角色 ：代理對象角色內部含有對真實對象的引用，從而可以操作真實對象，同時代理對象提供與真實對象相同的介面以便在任何時刻都能代替真實對象。同時，代理對象可以在執行真實對象操作時，附加其他的操作，相當於對真實對象進行封裝。

真實角色 ：代理角色所代表的真實對象，是我們最終要引用的對象。

代理模式使用原因和應用方面

（1）授權機制 不同級別的用戶對同一對象擁有不同的訪問權利,如Jive論壇系統中,就使用Proxy進行授權機制控制,訪問論壇有兩種人:注冊用戶和遊客(未注冊用戶),Jive中就通過類似ForumProxy這樣的代理來控制這兩種用戶對論壇的訪問許可權.

（2）某個客戶端不能直接操作到某個對象,但又必須和那個對象有所互動.
舉例兩個具體情況:
如果那個對象是一個是很大的圖片,需要花費很長時間才能顯示出來,那麼當這個圖片包含在文檔中時,使用編輯器或瀏覽器打開這個文檔,打開文檔必須很迅速,不能等待大圖片處理完成,這時需要做個圖片Proxy來代替真正的圖片.

如果那個對象在Internet的某個遠端伺服器上,直接操作這個對象因為網路速度原因可能比較慢,那我們可以先用Proxy來代替那個對象.

總之原則是,對於開銷很大的對象,只有在使用它時才創建,這個原則可以為我們節省很多寶貴的Java內存. 所以,有些人認為Java耗費資源內存,我以為這和程序編制思路也有一定的關系.

（3）現實中，Proxy應用范圍很廣,現在流行的分布計算方式RMI和Corba等都是Proxy模式的應用

Ⅹ java中的代理是什麼意思

動態代理在Java中是很重要的一部分，在很多框架中都會用到，如Spring中的AOP、Hadoop中的RPC等。為此在這把我對Java中的動態代理的理解分享給大家，同時寫了一個模擬AOP編程的實例。

有兩種方法可以實現，一種是利用繼承，另一種是利用聚合。舉例說明：
假設第三方中提供一個Run介面，裡面只一個run方法，以及它的實現類Person。
Run.java
如果要對第三方提供的JAR包中的某個類中的某個方法的前後加上自己的邏輯，比如打LOG，注意此時我們只有第三方提供的CLASS文件，因此根本不可能去修改別人的源代碼，那該怎麼辦？
有兩種方法可以實現，一種是利用繼承，另一種是利用聚合。舉例說明：
假設第三方中提供一個Run介面，裡面只一個run方法，以及它的實現類Person。
Run.java
如果要對第三方提供的JAR包中的某個類中的某個方法的前後加上自己的邏輯，比如打LOG，注意此時我們只有第三方提供的CLASS文件，因此根本不可能去修改別人的源代碼，那該怎麼辦？
有兩種方法可以實現，一種是利用繼承，另一種是利用聚合。舉例說明：
假設第三方中提供一個Run介面，裡面只一個run方法，以及它的實現類Person。
Run.java
分析動態代理過程
1.根據輸入的介面，利用反射機制，肯定可以拿到有哪些方法；
2.根據輸入的被代理類，同樣利用反射機制，肯定去調用其實現的方法。
到了這里，好像少了一點東西，就是少了對某個方法的前後的加強的邏輯。

閱讀全文

與java代理相關的資訊

熱點內容
單片機android 發布：2024-09-20 09:07:24 瀏覽：762
如何提高三星a7安卓版本 發布：2024-09-20 08:42:35 瀏覽：661
如何更換伺服器網站 發布：2024-09-20 08:42:34 瀏覽：309
子彈演算法 發布：2024-09-20 08:41:55 瀏覽：286
手機版網易我的世界伺服器推薦 發布：2024-09-20 08:41:52 瀏覽：815
安卓x7怎麼邊打游戲邊看視頻 發布：2024-09-20 08:41:52 瀏覽：160
sql資料庫安全 發布：2024-09-20 08:31:32 瀏覽：91
蘋果連接id伺服器出錯是怎麼回事 發布：2024-09-20 08:01:07 瀏覽：505
編程鍵是什麼 發布：2024-09-20 07:52:47 瀏覽：655
學考密碼重置要求的證件是什麼 發布：2024-09-20 07:19:46 瀏覽：479
© Design www.ultimate-communications.com 2015-2022
本站內容源自於網路，如遇問題可聯系相關處理。