Deep learning about Java--贯穿Java的反射机制（3）

1.代理模式的定义

给委托对象提供一个代理对象，并由代理对象控制对于委托对象的访问，也就是说客户不能够直接操作委托对象，而是通过代理对象间接地操作委托对象。

简单地说就是：通过代理对象对委托对象的相关方法的调用来提供特定的服务。

代理对象一般主要负责的行为有：

为委托对象预处理消息、过滤消息、转发消息给委托对象（代理对象对于委托对象的调用/控制）以及事后处理消息。

再来，以经典的代理模式的例子来说明（引用计数–reference counting）代理：

当需要一个复杂对象的多份副本时，代理模式可以结合享元模式以减少存储器的使用量。

典型的做法时创建一个复杂对象以及多个代理，每个代理都会引用原本的复杂对象，在代理产生操作数据时会把数据传输到原本的复杂对象。如果所有的代理都不存在时，复杂对象也没有存在的意义了，它将会被移除。

现实中代理的例子：

譬如，我们搭个梯子来越过GFW来访问海外网站，这个远程代理的过程是这样的：

（1）用户把Http请求发送给代理

（2）代理把Http请求发送给服务器

（3）服务器把Http响应发送给代理

（4）代理把Http响应发送给用户



2.代理模式的实现思路

代理类和目标类都需要实现同一个接口。

代理类和目标类分别实现接口的具体逻辑。

在代理类的构造函数中实例化一个目标类的对象。

在代理类中调用目标类中实现的接口逻辑。

客户如果需要访问或调用目标类的接口逻辑只能通过代理来进行。

3.静态代理和动态代理（JDK、cglib）

静态代理：

即不通过反射的方式，而是通过直接对委托类的初始化和方法访问进行控制。在所有的源代码进过编译之后，所有的类都会产生.class文件，此时，我们为了获取更好的加载性能，一开始并不是就对所有的类进行加载，而是选择加载他们的代理类。这样的做法的优势是 加快系统的启动速度，减少用户的等待时间。

下面给出一个能很好地解释静态代理设计模式–懒汉模式（延迟加载，即使用时才会加载）

public interface MyInterface{
//public abstract是可以不用写的，因为在接口中默认的Modifier就是public abstract
public abstract void method();
public abstract void method2();
}

public class ConsignorSubject implements MyInterface{

public ConsignorSubject(){}

@Override
public void method(){
System.out.println("hello method");
}

@Override
public void method2(){
System.out.println("hello method2");
}
}

public class StaticProxy implements MyInterface{
//指定代理对象
private ConsignorSubject consignor = null;
//加载的时候主要对象是对代理类
//需要使用new进行代理类的初始化
public StaticProxy(){}

//在静态代理中，代理类和委托类都必须实现统一的接口
@Override
public void method(){
if(null == consignor)
consignor = new ConsignorSubject();
//前置消息的过滤、修饰
System.out.println("Information filtering and decorating");
//消息转发给委托类、控制委托类处理消息
consignor.method();
//后置消息的清除
System.out.println("After!")
}

@Override
public void method2(){
Sif(null == consignor)
consignor = new ConsignorSubject();
//前置消息的过滤、修饰
System.out.println("Information filtering and decorating");
//消息转发给委托类、控制委托类处理消息
consignor.method2();
//后置消息的清除
System.out.println("After!")
}
}

public class Demo{
public static void main(String[] args){
StaticProxy sp = new StaticProxy();
sp.method();
sp.method2();
}
}

动态代理：

在程序运行时，通过反射机制创建生成；动态代理Proxy是一个静态类，它已经是在java.lang.reflect.Proxy中封装好的，不需要我们再去编写它的具体实现，只需要传入相应的参数即可通过反射来代理委托类。

Proxy类提供了创建动态代理类及其实例的静态方法。

（1）getProxyClass0()静态方法负责创建动态代理类，它的完整定义如下：

public static Class<?> getProxyClass0(ClassLoader loader,Class<?>[] interfaces) throwsIllegalArgumentException

参数loader 指定动态代理类的类加载器，参数interfaces指定动态代理类需要实现的所有接口。

（2）newProxyInstance()静态方法负责创建动态代理类的实例，它的完整定义如下：

public static Object newProxyInstance(ClassLoader loader,Class<?>[] interfaces,InvocationHandler handler) throws
IllegalArgumentException

参数loader指定动态代理类的类加载器，参数interfaces 指定动态代理类需要实现的所有接口，参数handler 指定与动态代理类关联的InvocationHandler 对象。

下面我们来看一个实例：

package com.unicorn.reflect.pojo;

public interface Person {
public void testMethod();

public void testMethod2();

public int testMethod3(String str);
}

package com.unicorn.reflect.pojo;

import java.io.Serializable;

import lombok.EqualsAndHashCode;
import lombok.Getter;
import lombok.NoArgsConstructor;
import lombok.NonNull;
import lombok.Setter;
import lombok.ToString;

@NoArgsConstructor/**JavaBean规范：实现无参构造器*/
@ToString(exclude={"id"})/**JavaBean规范：重载tostring方法*/
@EqualsAndHashCode
public class Emp implements Serializable, Person{

/**
* JavaBean规范：实现序列化接口
*/
private static final long serialVersionUID = -720655243074260608L;

/**
* JavaBean规范：实现getter and setter
* 在这里使用lombok的注解简化冗余的代码
*/
@Getter @Setter private Long id;
@Getter @Setter private String empName;
@Getter @Setter private String depart;
@Getter @Setter private Double salary;
@Getter @Setter public Byte Sex;
public static final int STABLE_VAL = 1;

public Emp(@NonNull Long id){
this.id = id;
}

@Override
public void testMethod() {
// TODO Auto-generated method stub
System.out.println("method1 says'I wanna to do somthing crazy!'");
}

@Override
public void testMethod2() {
// TODO Auto-generated method stub
System.out.println("method2 says'I wanna to kick the method1 for its crazy behaviors!'");
}

@Override
public int testMethod3(String str) {
// TODO Auto-generated method stub
System.out.println("method2 s
126ac
ays'The crazy world! Are you fxxxing kiding me ?" + str + "'");
return 0;
}

//  @Override public boolean equals(Object o){
//      if(o == this)
//          return true;
//      if(!(o instanceof Emp))
//          return false;
//  }
}

package com.unicorn.reflect.service;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;

import lombok.NoArgsConstructor;
import lombok.NonNull;

/**
* 反射中最重要的动态代理
* @author Unicorn
*
*/
@NoArgsConstructor
public class TestInvocationHandler implements InvocationHandler {

private Object tar;

public TestInvocationHandler(@NonNull Object tar){
this.tar = tar;
}

@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
// TODO Auto-generated method stub
System.out.println("Look！");
Object result = method.invoke(tar, args);
System.out.println("Bye!");
return result;
}

}

package com.unicorn.reflect.service;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Proxy;

import org.junit.Test;

import com.unicorn.reflect.pojo.Emp;
import com.unicorn.reflect.pojo.Person;

public class TestProxy {

@Test
public void testFunc() throws Throwable{
/**
* 原本，正常的emp实现的接口功能是这样的
*/
Person e = new Emp(666L);
e.testMethod();
e.testMethod2();
e.testMethod3("shawn");

System.out.println("---------------------");
/**
* 使用代理（proxy）之后，可以增添新的功能，相当于装饰，而不需要去改变原本的类
*/
TestInvocationHandler t = new TestInvocationHandler(e);
Person eProxy = (Person)Proxy.newProxyInstance(e.getClass().getClassLoader(),
e.getClass().getInterfaces(), t);
eProxy.testMethod();
eProxy.testMethod2();
eProxy.testMethod3("shawn");
}

}

这个例子是使用了JDK提供的Proxy代理方式，它的特点就是面向接口编程，它所能代理的委托类一定是一个接口，非接口类是不能够通过Proxy代理的，只能通过cglib来进行纯粹的类代理。

使用Proxy是不需要实现接口类的，但是需要传入InvocationHandler的实现类，前两个参数是传递给getProxyClass0来创建动态代理类。

我们现在来看看源代码关于proxy对象的创建流程：

/**
* Returns an instance of a proxy class for the specified interfaces
* that dispatches method invocations to the specified invocation
* handler.
*
* <p>{@code Proxy.newProxyInstance} throws
* {@code IllegalArgumentException} for the same reasons that
* {@code Proxy.getProxyClass} does.
*
* @param   loader the class loader to define the proxy class
* @param   interfaces the list of interfaces for the proxy class
*          to implement
* @param   h the invocation handler to dispatch method invocations to
* @return  a proxy instance with the specified invocation handler of a
*          proxy class that is defined by the specified class loader
*          and that implements the specified interfaces
* @throws  IllegalArgumentException if any of the restrictions on the
*          parameters that may be passed to {@code getProxyClass}
*          are violated
* @throws  SecurityException if a security manager, <em>s</em>, is present
*          and any of the following conditions is met:
*          <ul>
*          <li> the given {@code loader} is {@code null} and
*               the caller's class loader is not {@code null} and the
*               invocation of {@link SecurityManager#checkPermission
*               s.checkPermission} with
*               {@code RuntimePermission("getClassLoader")} permission
*               denies access;</li>
*          <li> for each proxy interface, {@code intf},
*               the caller's class loader is not the same as or an
*               ancestor of the class loader for {@code intf} and
*               invocation of {@link SecurityManager#checkPackageAccess
*               s.checkPackageAccess()} denies access to {@code intf};</li>
*          <li> any of the given proxy interfaces is non-public and the
*               caller class is not in the same {@linkplain Package runtime package}
*               as the non-public interface and the invocation of
*               {@link SecurityManager#checkPermission s.checkPermission} with
*               {@code ReflectPermission("newProxyInPackage.{package name}")}
*               permission denies access.</li>
*          </ul>
* @throws  NullPointerException if the {@code interfaces} array
*          argument or any of its elements are {@code null}, or
*          if the invocation handler, {@code h}, is
*          {@code null}
*/
@CallerSensitive
public static Object newProxyInstance(ClassLoader loader,
Class<?>[] interfaces,
InvocationHandler h)
throws IllegalArgumentException
{
Objects.requireNonNull(h);
//获取委托类的接口信息
final Class<?>[] intfs = interfaces.clone();
final SecurityManager sm = System.getSecurityManager();
if (sm != null) {
checkProxyAccess(Reflection.getCallerClass(), loader, intfs);
}

/*
* Look up or generate the designated proxy class.
*/
//生成动态代理类
Class<?> cl = getProxyClass0(loader, intfs);

/*
* Invoke its constructor with the designated invocation handler.
*/
try {
if (sm != null) {
checkNewProxyPermission(Reflection.getCallerClass(), cl);
}

final Constructor<?> cons = cl.getConstructor(constructorParams);
final InvocationHandler ih = h;
if (!Modifier.isPublic(cl.getModifiers())) {
AccessController.doPrivileged(new PrivilegedAction<Void>() {
public Void run() {
cons.setAccessible(true);
return null;
}
});
}
return cons.newInstance(new Object[]{h});
} catch (IllegalAccessException|InstantiationException e) {
throw new InternalError(e.toString(), e);
} catch (InvocationTargetException e) {
Throwable t = e.getCause();
if (t instanceof RuntimeException) {
throw (RuntimeException) t;
} else {
throw new InternalError(t.toString(), t);
}
} catch (NoSuchMethodException e) {
throw new InternalError(e.toString(), e);
}
}

/**
* Generate a proxy class.  Must call the checkProxyAccess method
* to perform permission checks before calling this.
*/
private static Class<?> getProxyClass0(ClassLoader loader,
Class<?>... interfaces) {
if (interfaces.length > 65535) {
throw new IllegalArgumentException("interface limit exceeded");
}

// If the proxy class defined by the given loader implementing --->loader
// the given interfaces exists, this will simply return the cached copy; --->interfaces
// otherwise, it will create the proxy class via the ProxyClassFactory
/**
*这段英文说的是，如果loader已经定义过和interfaces已经存在（也就是说proxy已经至少实现过一次），就会从缓存中直接拿proxy副本作为proxy；否则就通过ProxyClassFactory生成一个
*/
return proxyClassCache.get(loader, interfaces);
}

/**
* a cache of proxy classes
*/
private static final WeakCache<ClassLoader, Class<?>[], Class<?>>
proxyClassCache = new WeakCache<>(new KeyFactory(), new ProxyClassFactory());

/**
* Look-up the value through the cache. This always evaluates the
* {@code subKeyFactory} function and optionally evaluates
* {@code valueFactory} function if there is no entry in the cache for given
* pair of (key, subKey) or the entry has already been cleared.
*
* @param key       possibly null key
* @param parameter parameter used together with key to create sub-key and
*                  value (should not be null)
* @return the cached value (never null)
* @throws NullPointerException if {@code parameter} passed in or
*                              {@code sub-key} calculated by
*                              {@code subKeyFactory} or {@code value}
*                              calculated by {@code valueFactory} is null.
*/
public V get(K key, P parameter) {
Objects.requireNonNull(parameter);
//清理持有弱引用的WeakHashMap这种数据结构，一般用于缓存
expungeStaleEntries();
//从队列中获取cacheKey
Object cacheKey = CacheKey.valueOf(key, refQueue);

// lazily install the 2nd level valuesMap for the particular cacheKey
//利用懒加载的方式填充Supplier， ConcurrentMap是一种线程安全的map
ConcurrentMap<Object, Supplier<V>> valuesMap = map.get(cacheKey);
if (valuesMap == null) {
ConcurrentMap<Object, Supplier<V>> oldValuesMap
= map.putIfAbsent(cacheKey,
valuesMap = new ConcurrentHashMap<>());
if (oldValuesMap != null) {
valuesMap = oldValuesMap;
}
}

// create subKey and retrieve the possible Supplier<V> stored by that
// subKey from valuesMap
Object subKey = Objects.requireNonNull(subKeyFactory.apply(key, parameter));
Supplier<V> supplier = valuesMap.get(subKey);
Factory factory = null;
//while循环的作用就是不停的获取实现InvokeHandler的类， 这个类可以是从缓存中拿到，也可是是从proxyFactoryClass生成的
while (true) {
if (supplier != null) {
// supplier might be a Factory or a CacheValue<V> instance
//supplier可能是一个工厂或者是CacheValue<V>的实例对象
V value = supplier.get();
if (value != null) {
return value;
}
}
// else no supplier in cache
// or a supplier that returned null (could be a cleared CacheValue
// or a Factory that wasn't successful in installing the CacheValue)

// lazily construct a Factory
if (factory == null) {
factory = new Factory(key, parameter, subKey, valuesMap);
}

if (supplier == null) {
supplier = valuesMap.putIfAbsent(subKey, factory);
if (supplier == null) {
// successfully installed Factory
supplier = factory;
}
// else retry with winning supplier
} else {
if (valuesMap.replace(subKey, supplier, factory)) {
// successfully replaced
// cleared CacheEntry / unsuccessful Factory
// with our Factory
supplier = factory;
} else {
// retry with current supplier
supplier = valuesMap.get(subKey);
}
}
}
}

proxyClassCache对象中传入new ProxyClassFactory()

中的apply方法才是创建代理的方法

@Override
public Class<?> apply(ClassLoader loader, Class<?>[] interfaces) {

Map<Class<?>, Boolean> interfaceSet = new IdentityHashMap<>(interfaces.length);
for (Class<?> intf : interfaces) {
/*
* Verify that the class loader resolves the name of this
* interface to the same Class object.
*/
Class<?> interfaceClass = null;
try {
interfaceClass = Class.forName(intf.getName(), false, loader);
} catch (ClassNotFoundException e) {
}
if (interfaceClass != intf) {
throw new IllegalArgumentException(
intf + " is not visible from class loader");
}
/*
* Verify that the Class object actually represents an
* interface.
*/
if (!interfaceClass.isInterface()) {
throw new IllegalArgumentException(
interfaceClass.getName() + " is not an interface");
}
/*
* Verify that this interface is not a duplicate.
*/
if (interfaceSet.put(interfaceClass, Boolean.TRUE) != null) {
throw new IllegalArgumentException(
"repeated interface: " + interfaceClass.getName());
}
}

String proxyPkg = null;     // package to define proxy class in
int accessFlags = Modifier.PUBLIC | Modifier.FINAL;
//到此为止都是对接口的必要检查
/*
* Record the package of a non-public proxy interface so that the
* proxy class will be defined in the same package.  Verify that
* all non-public proxy interfaces are in the same package.
*/
for (Class<?> intf : interfaces) {
int flags = intf.getModifiers();
if (!Modifier.isPublic(flags)) {
accessFlags = Modifier.FINAL;
String name = intf.getName();
int n = name.lastIndexOf('.');
String pkg = ((n == -1) ? "" : name.substring(0, n + 1));
if (proxyPkg == null) {
proxyPkg = pkg;
} else if (!pkg.equals(proxyPkg)) {
throw new IllegalArgumentException(
"non-public interfaces from different packages");
}
}
}

if (proxyPkg == null) {
// if no non-public proxy interfaces, use com.sun.proxy package
proxyPkg = ReflectUtil.PROXY_PACKAGE + ".";
}

/*
* Choose a name for the proxy class to generate.
*/
long num = nextUniqueNumber.getAndIncrement();
String proxyName = proxyPkg + proxyClassNamePrefix + num;
//产生代理的随机名称，如果日后调试看到了$Proxy+数字的exception那么很可能就是你的代理出现问题了

/*
* Generate the specified proxy class.
*/
//以上通过之后，就会真正产生代理啦
byte[] proxyClassFile = ProxyGenerator.generateProxyClass(
proxyName, interfaces, accessFlags);
//这个generateProxyClass才是核心，apply只是调用了它产生代理
try {
return defineClass0(loader, proxyName,
proxyClassFile, 0, proxyClassFile.length);//返回代理对象的字节流
} catch (ClassFormatError e) {
/*
* A ClassFormatError here means that (barring bugs in the
* proxy class generation code) there was some other
* invalid aspect of the arguments supplied to the proxy
* class creation (such as virtual machine limitations
* exceeded).
*/
throw new IllegalArgumentException(e.toString());
}
}
}

private byte[] generateClassFile() {
/*
* Step 1: Assemble ProxyMethod objects for all methods to
* generate proxy dispatching code for.
*/
//addProxyMethod方法，就是将方法都加入到一个列表中，并与对应的class对应起来
//这里给Object对应了三个方法hashCode，toString和equals
addProxyMethod(hashCodeMethod, Object.class);
addProxyMethod(equalsMethod, Object.class);
addProxyMethod(toStringMethod, Object.class);
//将接口列表中的接口与接口下的方法对应起来
for (int i = 0; i < interfaces.length; i++) {
Method[] methods = interfaces[i].getMethods();
for (int j = 0; j < methods.length; j++) {
addProxyMethod(methods[j], interfaces[i]);
}
}
/*
* For each set of proxy methods with the same signature,
* verify that the methods' return types are compatible.
*/
for (List<ProxyMethod> sigmethods : proxyMethods.values()) {
checkReturnTypes(sigmethods);
}
/*
* Step 2: Assemble FieldInfo and MethodInfo structs for all of
* fields and methods in the class we are generating.
*/
//方法中加入构造方法，这个构造方法只有一个，就是一个带有InvocationHandler接口的构造方法
//这个才是真正给class文件，也就是代理类加入方法了，不过还没真正处理，只是先加进来等待循环，构造方法在class文件中的名称描述是<init>
try {
methods.add(generateConstructor());
for (List<ProxyMethod> sigmethods : proxyMethods.values()) {
for (ProxyMethod pm : sigmethods) {
//给每一个代理方法加一个Method类型的属性，数字10是class文件的标识符，代表这些属性都是private static的
fields.add(new FieldInfo(pm.methodFieldName,
"Ljava/lang/reflect/Method;",
ACC_PRIVATE | ACC_STATIC));
//将每一个代理方法都加到代理类的方法中
methods.add(pm.generateMethod());
}
}
//加入一个静态初始化块，将每一个属性都初始化，这里静态代码块也叫类构造方法，其实就是名称为<clinit>的方法，所以加到方法列表
methods.add(generateStaticInitializer());
} catch (IOException e) {
throw new InternalError("unexpected I/O Exception");
}
//方法和属性个数都不能超过65535，包括之前的接口个数也是这样，
//这是因为在class文件中，这些个数都是用4位16进制表示的，所以最大值是2的16次方-1
if (methods.size() > 65535) {
throw new IllegalArgumentException("method limit exceeded");
}
if (fields.size() > 65535) {
throw new IllegalArgumentException("field limit exceeded");
}
//接下来就是写class文件的过程， 包括模数， 类名，常量池等一系列字节码的组成，就不一一细说了。需要的可以参考JVM虚拟机字节码的相关知识。
cp.getClass(dotToSlash(className));
cp.getClass(superclassName);
for (int i = 0; i < interfaces.length; i++) {
cp.getClass(dotToSlash(interfaces[i].getName()));
}
cp.setReadOnly();
ByteArrayOutputStream bout = new ByteArrayOutputStream();
DataOutputStream dout = new DataOutputStream(bout);
try {
// u4 magic;
dout.writeInt(0xCAFEBABE);
// u2 minor_version;
dout.writeShort(CLASSFILE_MINOR_VERSION);
// u2 major_version;
dout.writeShort(CLASSFILE_MAJOR_VERSION);
cp.write(dout);       // (write constant pool)
// u2 access_flags;
dout.writeShort(ACC_PUBLIC | ACC_FINAL | ACC_SUPER);
// u2 this_class;
dout.writeShort(cp.getClass(dotToSlash(className)));
// u2 super_class;
dout.writeShort(cp.getClass(superclassName));
// u2 interfaces_count;
dout.writeShort(interfaces.length);
// u2 interfaces[interfaces_count];
for (int i = 0; i < interfaces.length; i++) {
dout.writeShort(cp.getClass(
dotToSlash(interfaces[i].getName())));
}
// u2 fields_count;
dout.writeShort(fields.size());
// field_info fields[fields_count];
for (FieldInfo f : fields) {
f.write(dout);
}
// u2 methods_count;
dout.writeShort(methods.size());
// method_info methods[methods_count];
for (MethodInfo m : methods) {
m.write(dout);
}
// u2 attributes_count;
dout.writeShort(0); // (no ClassFile attributes for proxy classes)
} catch (IOException e) {
throw new InternalError("unexpected I/O Exception");
}
return bout.toByteArray();
}

到此就结束了！cglib的笔者比较少用，暂时就不写先了！

感谢pastqing （源码分析的思路是参照他的，笔者很服气这个博主，给个赞！）还有这个博主陈善亮-BUPT（写的没前面的博主好，但好在有一些理解是很值得借鉴的）。

转载请注明出处，谢谢！