版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/xiey94/article/details/83094855
OkHttp3 Proxy
每次我看到代理，都感到特激动，因为我也不会；
public class Proxy {
/**
* Represents the proxy type.
*
* @since 1.5
*/
public enum Type {
/**
* Represents a direct connection, or the absence of a proxy.
*/
DIRECT,
/**
* Represents proxy for high level protocols such as HTTP or FTP.
*/
HTTP,
/**
* Represents a SOCKS (V4 or V5) proxy.
*/
SOCKS
};
private Type type;
private SocketAddress sa;
/**
* A proxy setting that represents a {@code DIRECT} connection,
* basically telling the protocol handler not to use any proxying.
* Used, for instance, to create sockets bypassing any other global
* proxy settings (like SOCKS):
* <P>
* {@code Socket s = new Socket(Proxy.NO_PROXY);}
*
*/
public final static Proxy NO_PROXY = new Proxy();
// Creates the proxy that represents a {@code DIRECT} connection.
private Proxy() {
type = Type.DIRECT;
sa = null;
}
/**
* Creates an entry representing a PROXY connection.
* Certain combinations are illegal. For instance, for types Http, and
* Socks, a SocketAddress <b>must</b> be provided.
* <P>
* Use the {@code Proxy.NO_PROXY} constant
* for representing a direct connection.
*
* @param type the {@code Type} of the proxy
* @param sa the {@code SocketAddress} for that proxy
* @throws IllegalArgumentException when the type and the address are
* incompatible
*/
public Proxy(Type type, SocketAddress sa) {
if ((type == Type.DIRECT) || !(sa instanceof InetSocketAddress))
throw new IllegalArgumentException("type " + type + " is not compatible with address " + sa);
this.type = type;
this.sa = sa;
}
/**
* Returns the proxy type.
*
* @return a Type representing the proxy type
*/
public Type type() {
return type;
}
/**
* Returns the socket address of the proxy, or
* {@code null} if its a direct connection.
*
* @return a {@code SocketAddress} representing the socket end
* point of the proxy
*/
public SocketAddress address() {
return sa;
}
/**
* Constructs a string representation of this Proxy.
* This String is constructed by calling toString() on its type
* and concatenating " @ " and the toString() result from its address
* if its type is not {@code DIRECT}.
*
* @return a string representation of this object.
*/
public String toString() {
if (type() == Type.DIRECT)
return "DIRECT";
return type() + " @ " + address();
}
/**
* Compares this object against the specified object.
* The result is {@code true} if and only if the argument is
* not {@code null} and it represents the same proxy as
* this object.
* <p>
* Two instances of {@code Proxy} represent the same
* address if both the SocketAddresses and type are equal.
*
* @param obj the object to compare against.
* @return {@code true} if the objects are the same;
* {@code false} otherwise.
* @see java.net.InetSocketAddress#equals(java.lang.Object)
*/
public final boolean equals(Object obj) {
if (obj == null || !(obj instanceof Proxy))
return false;
Proxy p = (Proxy) obj;
if (p.type() == type()) {
if (address() == null) {
return (p.address() == null);
} else
return address().equals(p.address());
}
return false;
}
/**
* Returns a hashcode for this Proxy.
*
* @return a hash code value for this Proxy.
*/
public final int hashCode() {
if (address() == null)
return type().hashCode();
return type().hashCode() + address().hashCode();
}
}
老规矩，拆着看
| 变量/方法 | 解释 |
|---|---|
| public enum Type { DIRECT,HTTP,SOCKS }; | 代理类型：三个类型 |
| private Proxy() | 构造 |
| public Proxy(Type type, SocketAddress sa) | 带参构造 |
| public Type type() | 返回指定type |
| public SocketAddress address() | 返回指定的SocketAddress |
| public String toString() | |
| public final boolean equals(Object obj) | |
| public final int hashCode() | |
| private Type type; | type |
| private SocketAddress sa; | SocketAddress |
| public final static Proxy NO_PROXY = new Proxy(); | 默认构造 |
这么来看，也没啥，170行，注释占掉一半，还重写了三个方法，剩下的就寥寥无几了；
public enum Type {
/**
* Represents a direct connection, or the absence of a proxy.
*/
DIRECT,
/**
* Represents proxy for high level protocols such as HTTP or FTP.
*/
HTTP,
/**
* Represents a SOCKS (V4 or V5) proxy.
*/
SOCKS
};
三种代理类型：DIRECT、HTTP、SOCKS；这三个是什么意思？遗留问题
private Proxy() {
type = Type.DIRECT;
sa = null;
}
默认构造中取得代理类型是 Type.DIRECT；SocketAddress是null;
public Proxy(Type type, SocketAddress sa) {
if ((type == Type.DIRECT) || !(sa instanceof InetSocketAddress))
throw new IllegalArgumentException("type " + type + " is not compatible with address " + sa);
this.type = type;
this.sa = sa;
}
带参构造：
做赋值操作；
如果类型是直连类型，就炸了；或者Http或者socks类型，则socket必须是InetSocketAddress，否则没得谈；
/**
* Returns the proxy type.
*
* @return a Type representing the proxy type
*/
public Type type() {
return type;
}
/**
* Returns the socket address of the proxy, or
* {@code null} if its a direct connection.
*
* @return a {@code SocketAddress} representing the socket end
* point of the proxy
*/
public SocketAddress address() {
return sa;
}
get
public String toString() {
if (type() == Type.DIRECT)
return "DIRECT";
return type() + " @ " + address();
}
public final boolean equals(Object obj) {
if (obj == null || !(obj instanceof Proxy))
return false;
Proxy p = (Proxy) obj;
if (p.type() == type()) {
if (address() == null) {
return (p.address() == null);
} else
return address().equals(p.address());
}
return false;
}
先做判空和类型判断，然后对type和address进行判断；
public final int hashCode() {
if (address() == null)
return type().hashCode();
return type().hashCode() + address().hashCode();
}
public final static Proxy NO_PROXY = new Proxy();
这样所有的代码就都跑完了，里面没有什么神鬼莫测的逻辑，看起来很简单，看来主要是在使用中体现价值的了，亏我这么激动。
遗留问题：
1、Type中的三个类型是什么意思？（主要是第一个不知道）