public interface People {
public String eat(String param);
}
public class Jack implements People {
@Override
public String eat(String param) {
System.out.println("=========Jack老师喜欢吃东=======");
return "=========Jack老师喜欢吃东=======";
}
}
public class Advice implements InvocationHandler1 {
People people;//接口，传进来实例
public Advice(People people) {
this.people = people;
}
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
//前置增强
before();
//被代理方
Object value = method.invoke(people,args);
//后置增强
after();
return value;
}
private void before() {
System.out.println("===========jack吃饭之前�?要洗�?==========");
}
private void after() {
System.out.println("===========jack吃完饭要洗碗=============");
}
}
public class MyTest {
public static void main(String[] args) {
People proxyObject = (People) Proxy1.newProxyInstance(MyTest.class.getClassLoader(),
new Class<?>[] { People.class }, new Advice(new Jack())); // 获取代理，MyTest.class.getClassLoader()是类加载器，
//new Advice是对实现类new Jack()的增强，People.class是接口，在吃饭之前之后要洗手，
proxyObject.eat("chi");// proxyObject是在内存的代理对象，对象名字$Proxy数字，
//proxyObject = com.zhuguang.jack.aop.jdkProxy.Jack@5e5792a0，里面的h = com.zhuguang.jack.aop.jdkProxy.Advice@26653222
// $Proxy0/1 extends Proxy1 implements People，Proxy里面有一个属性InvocationHandler h;
// proxyObject.eat("chi")调用的是h.invoke(Object proxy, Method method, Object[]
// args)，
// h.invoke()方法调到advice.invoke()，
}
}
public class Proxy1 implements java.io.Serializable {
private static final long serialVersionUID = -2222568056686623797L;
private static final Class<?>[] constructorParams = { InvocationHandler1.class };
private static final WeakCache1<ClassLoader, Class<?>[], Class<?>> proxyClassCache = new WeakCache1<>( new ProxyClassFactory());
protected InvocationHandler1 h;
private Proxy1() {}
protected Proxy1(InvocationHandler1 h) {
Objects.requireNonNull(h);
this.h = h;
}
//一个利用给定的类加载器和接口类数组生成，定义并返回代理类对象的工厂方法。代理类生成工厂。
private static final class ProxyClassFactory implements BiFunction<ClassLoader, Class<?>[], Class<?>> {
private static final String proxyClassNamePrefix = "$Proxy1";
private static final AtomicLong nextUniqueNumber = new AtomicLong();
@Override
public Class<?> apply(ClassLoader loader, Class<?>[] interfaces) {
String proxyPkg = null; // 代理类的包名
int accessFlags = Modifier.PUBLIC | Modifier.FINAL;//生成代理类的访问标志, 默认是public final的
//验证所有非公共代理接口都在同一个包中
for (Class<?> intf : interfaces) {
int flags = intf.getModifiers();//获取接口的访问标志
//如果接口的访问标志不是public, 那么生成代理类的包名和接口包名相同
if (!Modifier.isPublic(flags)) {
accessFlags = Modifier.FINAL;//生成的代理类的访问标志设置为final
String name = intf.getName();//获取接口全限定名, 例如：java.util.Collection
int n = name.lastIndexOf('.');
String pkg = ((n == -1) ? "" : name.substring(0, n + 1));//剪裁后得到包名:java.util
if (proxyPkg == null) {//生成的代理类的包名和接口包名是一样的
proxyPkg = pkg;
} else if (!pkg.equals(proxyPkg)) {//代理类如果实现不同包的接口, 并且接口都不是public的, 那么就会在这里报错
throw new IllegalArgumentException("non-public interfaces from different packages");
}
}
}
//如果接口访问标志都是public的话, 那生成的代理类都放到默认的包下：com.sun.proxy
if (proxyPkg == null) {
proxyPkg = ReflectUtil.PROXY_PACKAGE + ".";
}
long num = nextUniqueNumber.getAndIncrement();
String proxyName = proxyPkg + proxyClassNamePrefix + num;
byte[] proxyClassFile = ProxyGenerator.generateProxyClass(proxyName, interfaces, accessFlags);//com.sun.proxy.$Proxy10，[interface proxy.People]，
try {// 返回代理类对象，根据二进制文件生成相应的Class实例。
return defineClass0(loader, proxyName, proxyClassFile, 0, proxyClassFile.length);
} catch (Exception e) {
System.out.println(e.toString());
}
return null;
}
}
public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler1 h) throws IllegalArgumentException {
final Class<?>[] intfs = interfaces.clone();//[interface proxy.People]，
Class<?> cl = proxyClassCache.get(loader, intfs);//先走WeakCache的get()，再通过Factory的get方法，最后通过ProxyClassFactory的apply()获取代理类的Class对象。
try {
// 从代理类对象中查找参数为InvocationHandler的构造器，获取参数类型是InvocationHandler.class的代理类构造器
final Constructor<?> cons = cl.getConstructor(constructorParams);
final InvocationHandler1 ih = h;
// 检测构造器是否是Public修饰，如果不是则强行转换为可以访问的。
if (!Modifier.isPublic(cl.getModifiers())) {
AccessController.doPrivileged(new PrivilegedAction<Void>() {
public Void run() {
cons.setAccessible(true);
return null;
}
});
}
// 通过反射，将h作为参数，实例化代理类，返回代理类实例。2.利用反射技术实例化代理类，并返回实例化对象。传入InvocationHandler实例去
//构造一个代理类的实例，所有代理类都继承自Proxy, 因此这里会调用Proxy的构造器将InvocationHandler引用传入，
return cons.newInstance(new Object[] { h });
} catch (Exception e) {
throw new InternalError(e.toString(), e);
}
}
private static native Class<?> defineClass0(ClassLoader loader, String name, byte[] b, int off, int len);
}
final class WeakCache1<K, P, V> {
private final BiFunction<K, P, V> valueFactory;
public WeakCache1(BiFunction<K, P, V> valueFactory) {//构造方法，，，
this.valueFactory = Objects.requireNonNull(valueFactory);//new ProxyClassFactory()
}
public V get(K key, P parameter) {
Supplier<V> supplier = null;
Factory factory = null;
while (true) {
if (supplier != null) {
V value = supplier.get();
if (value != null) {
return value;
}
}
if (factory == null) {
factory = new Factory(key, parameter );
}
if (supplier == null) {
if (supplier == null) {
supplier = factory;
}
}
}
}
private final class Factory implements Supplier<V> {
private final K key;
private final P parameter;
Factory(K key, P parameter) {
this.key = key;
this.parameter = parameter;
}
@Override
public synchronized V get() {
V value = null;
// valueFactory就是WeakCache的valueFactory属性，因为Factory是WeakCache的内部类，所以可以直接访问WeakCache的valueFactory属性
value = valueFactory.apply(key, parameter);
return value;
}
}
}
