JDK 동적 에이전트 절차 상세 설명(소스 코드 분석)
1.인터페이스 Invocation Handler 를 실현 하 는 클래스 를 만 듭 니 다.invoke 방법 을 실현 해 야 합 니 다.
2.프 록 시 클래스 와 인 터 페 이 스 를 만 듭 니 다.
3.프 록 시 를 통한 정적 방법
Proxy 를 통한 정적 방법
ProxyObject proxyObject = new ProxyObject();
InvocationHandler invocationHandler = new DynamicProxy(proxyObject);
ClassLoader classLoader = proxyObject.getClass().getClassLoader();
ProxyObjectInterface proxy = (IRoom) Proxy.newProxyInstance(classLoader,new Class[]
{ProxyObjectInterface.class},invocationHandler);
proxy.execute();
public class DynamicProxy implements InvocationHandler {
private Object object;
public DynamicProxy(Object object){
this.object = object;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
Object result = method.invoke(object,args);
return result;
}
}
프 록 시 newProxyInstance 만 들 기
public static Object newProxyInstance(ClassLoader loader,
Class<?>[] interfaces,
InvocationHandler h)
throws IllegalArgumentException
{
// h ,h
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 。
*/
Class<?> cl = getProxyClass0(loader, intfs);
/*
* Invoke its constructor with the designated invocation handler.
*/
try {
if (sm != null) {
checkNewProxyPermission(Reflection.getCallerClass(), cl);
}
// , constructorParams
// constructorParames :
private static final Class<?>[] constructorParams = { InvocationHandler.class };
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;
}
});
}
// , new Object[]{h}
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);
}
}
먼저 h 에 대해 공중 처 리 를 진행 하 다.이 코드 의 핵심 은 getProxyClass 0(loader,intfs)을 통 해 프 록 시 클래스 의 Class 대상 을 얻 은 다음 에 Class 대상 을 통 해 구조 방법 을 얻어 프 록 시 대상 을 만 드 는 것 이다.다음 단 계 는 getProxy Class 0 방법 을 보 겠 습 니 다.1 을 통 해 알 수 있 듯 이 먼저 인터페이스 류 를 얻 고 인터페이스의 수량 이 65535 를 초과 하면 이상 을 알 수 있다.
// Proxy
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
// the given interfaces exists, this will simply return the cached copy;
// otherwise, it will create the proxy class via the ProxyClassFactory
// : loader , interfaces,
// , ProxyClassFactory 。
return proxyClassCache.get(loader, interfaces);
}
proxy ClassCache 는 약 한 인용 캐 시 입 니 다.여기 서 proxy ClassCache 를 보면 Cache 가 있 으 면 캐 시 라 는 뜻 을 알 수 있 습 니 다.바로 앞 에 Look up or generate the designated proxy class 에 호응 하 였 습 니 다.(캐 시 에 이미 있 음)을 조회 하거나 지정 한 프 록 시 클래스 의 클 라 스 대상 을 만 드 는 설명 입 니 다.
get 방법 에 들 어가 기 전에 proxy ClassCache 가 무엇 인지 볼 까요?고에너지 경고,전방 코드 가 어 지 러 워 보일 수 있 지만,우 리 는 중점 만 주목 하면 된다.
private static final WeakCache<ClassLoader, Class<?>[], Class<?>>
proxyClassCache = new WeakCache<>(new KeyFactory(), new ProxyClassFactory());
//K key ,P ,V value 。
// WeakCache<ClassLoader, Class<?>[], Class<?>> proxyClassCache proxyClassCache Class<?> , 。
final class WeakCache<K, P, V> {
private final ReferenceQueue<K> refQueue
= new ReferenceQueue<>();
// the key type is Object for supporting null key
private final ConcurrentMap<Object, ConcurrentMap<Object, Supplier<V>>> map
= new ConcurrentHashMap<>();
private final ConcurrentMap<Supplier<V>, Boolean> reverseMap
= new ConcurrentHashMap<>();
private final BiFunction<K, P, ?> subKeyFactory;
private final BiFunction<K, P, V> valueFactory;
public WeakCache(BiFunction<K, P, ?> subKeyFactory,
BiFunction<K, P, V> valueFactory) {
this.subKeyFactory = Objects.requireNonNull(subKeyFactory);
this.valueFactory = Objects.requireNonNull(valueFactory);
}
그 중에서 map 변 수 는 캐 시 를 실현 하 는 핵심 변수 입 니 다.그 는 이중 맵 구조 입 니 다.(key,sub-key)->value.그 중 키 는 들 어 온 Classloader 를 포장 한 대상 이 고,sub-key 는 WeakCache 구조 함수 전달 자의 KeyFactory()에서 생 성 된다.value 는 프 록 시 클래스 를 만 드 는 대상 으로 WeakCache 구조 함수 전달 자의 Proxy ClassFactory()에서 생 성 됩 니 다.다음 과 같이 돌 이 켜 보면:proxy ClassCache 는 WeakCache 류 의 대상 으로 proxy ClassCache.get(loader,interfaces)을 호출 합 니 다.캐 시 된 프 록 시 클래스 를 얻 거나 프 록 시 클래스 를 만 들 수 있 습 니 다(캐 시 없 는 경우).
WeakCache 에 get 이라는 방법 이 있다 는 뜻 입 니 다.먼저 WeakCache 류 의 정 의 를 살 펴 보고(여기 서 변수의 정의 와 구조 함수 만 제시 합 니 다)get()을 계속 봅 니 다.
//K P WeakCache ,key ,parameter
public V get(K key, P parameter) {
// parameter
Objects.requireNonNull(parameter);
//
expungeStaleEntries();
// cacheKey (key, sub-key) -> value key,
Object cacheKey = CacheKey.valueOf(key, refQueue);
// lazily install the 2nd level valuesMap for the particular cacheKey
// key ConcurrentMap<Object, Supplier<V>> 。 , ConcurrentMap<Object, Supplier<V>> cacheKey( key) 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
// sub-key ,
Object subKey = Objects.requireNonNull(subKeyFactory.apply(key, parameter));
// sub-key supplier
Supplier<V> supplier = valuesMap.get(subKey);
//supplier factory
Factory factory = null;
while (true) {
// supplier , get , , , , get 。
if (supplier != null) {
// supplier might be a Factory or a CacheValue<V> instance
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
// : supplier, Factory , factory supplier。
// while(true) , get , 。
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);
}
}
}
}
그래서 다음은 Factory 류 의 get 방법 을 살 펴 보 겠 습 니 다.다음은 supplier 의 get()
public synchronized V get() { // serialize access
// re-check
Supplier<V> supplier = valuesMap.get(subKey);
// supplier
if (supplier != this) {
// something changed while we were waiting:
// might be that we were replaced by a CacheValue
// or were removed because of failure ->
// return null to signal WeakCache.get() to retry
// the loop
return null;
}
// else still us (supplier == this)
// create new value
V value = null;
try {
// valueFactory
//valueFactory new ProxyClassFactory()
// ProxyClassFactory() apply
value = Objects.requireNonNull(valueFactory.apply(key, parameter));
} finally {
if (value == null) { // remove us on failure
valuesMap.remove(subKey, this);
}
}
// the only path to reach here is with non-null value
assert value != null;
// wrap value with CacheValue (WeakReference)
// value
CacheValue<V> cacheValue = new CacheValue<>(value);
// put into reverseMap
// reverseMap
reverseMap.put(cacheValue, Boolean.TRUE);
// try replacing us with CacheValue (this should always succeed)
if (!valuesMap.replace(subKey, this, cacheValue)) {
throw new AssertionError("Should not reach here");
}
// successfully replaced us with new CacheValue -> return the value
// wrapped by it
return value;
}
}
구름 을 헤 치고 날 이 밝 으 면 Proxy ClassFactory 에 온 apply 방법 입 니 다.대리 류 는 바로 이곳 에서 생 성 된 것 입 니 다.우선 proxy ClassCache 의 정 의 를 보십시오 WeakCache
// BiFunction<T, U, R> , T,U , R
private static final class ProxyClassFactory
implements BiFunction<ClassLoader, Class<?>[], Class<?>>
{
// prefix for all proxy class names
//
private static final String proxyClassNamePrefix = "$Proxy";
// next number to use for generation of unique proxy class names
//
private static final AtomicLong nextUniqueNumber = new AtomicLong();
@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
// : public ,final
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.
*/
// ;
// , com.sun.proxy,
// $Proxy
// non-public proxy interface ,
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();
// , com.sun.proxy.$Proxy0.calss
String proxyName = proxyPkg + proxyClassNamePrefix + num;
/*
* Generate the specified proxy class.
*/
// ,
byte[] proxyClassFile = ProxyGenerator.generateProxyClass(
proxyName, interfaces, accessFlags);
try {
// JVM ,
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());
}
}
}
그리고 getMethod()를 호출 하여 equals(),hashcode(),toString()등 방법 을 추가 합 니 다.그리고 모든 인 터 페 이 스 를 옮 겨 다 니 는 방법 을 프 록 시 클래스 에 추가 합 니 다.마지막 으로 이 방법 들 을 정렬 합 니 다.
private static List<Method> getMethods(Class<?>[] interfaces) {
List<Method> result = new ArrayList<Method>();
try {
result.add(Object.class.getMethod("equals", Object.class));
result.add(Object.class.getMethod("hashCode", EmptyArray.CLASS));
result.add(Object.class.getMethod("toString", EmptyArray.CLASS));
} catch (NoSuchMethodException e) {
throw new AssertionError();
}
getMethodsRecursive(interfaces, result);
return result;
}
private static void getMethodsRecursive(Class<?>[] interfaces, List<Method> methods) {
for (Class<?> i : interfaces) {
getMethodsRecursive(i.getInterfaces(), methods);
Collections.addAll(methods, i.getDeclaredMethods());
}
}
마지막 출력 관련 proxy class
package com.zhb.jdk.proxy;
import java.io.FileOutputStream;
import java.io.IOException;
import java.lang.reflect.Proxy;
import com.zhb.jdk.dynamicProxy.HelloworldImpl;
import sun.misc.ProxyGenerator;
/**
* @author ZHB
* @date 2018 8 31 11:35:07
* @todo TODO
*/
public class DynamicProxyTest {
public static void main(String[] args) {
IUserService target = new UserServiceImpl();
MyInvocationHandler handler = new MyInvocationHandler(target);
// ( )
// ( , )
// invocation handler, 。 handler
IUserService proxyObject = (IUserService) Proxy.newProxyInstance(DynamicProxyTest.class.getClassLoader(),
target.getClass().getInterfaces(), handler);
proxyObject.add(" ");
String path = "D:/$Proxy0.class";
byte[] classFile = ProxyGenerator.generateProxyClass("$Proxy0", HelloworldImpl.class.getInterfaces());
FileOutputStream out = null;
try {
out = new FileOutputStream(path);
out.write(classFile);
out.flush();
} catch (Exception e) {
e.printStackTrace();
} finally {
try {
out.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
// Decompiled by Jad v1.5.8e2. Copyright 2001 Pavel Kouznetsov.
// Jad home page: http://kpdus.tripod.com/jad.html
// Decompiler options: packimports(3) fieldsfirst ansi space
import com.zhb.jdk.proxy.IUserService;
import java.lang.reflect.*;
public final class $Proxy0 extends Proxy
implements IUserService
{
private static Method m1;
private static Method m2;
private static Method m3;
private static Method m0;
// , InvocationHandler ,
//Proxy.newInstance
public $Proxy0(InvocationHandler invocationhandler)
{
super(invocationhandler);
}
// Object ,equals,toString, hashCode
public final boolean equals(Object obj)
{
try
{
return ((Boolean)super.h.invoke(this, m1, new Object[] {
obj
})).booleanValue();
}
catch (Error ) { }
catch (Throwable throwable)
{
throw new UndeclaredThrowableException(throwable);
}
}
public final String toString()
{
try
{
return (String)super.h.invoke(this, m2, null);
}
catch (Error ) { }
catch (Throwable throwable)
{
throw new UndeclaredThrowableException(throwable);
}
}
//
public final void add(String s)
{
try
{
// invocation handler invoke
super.h.invoke(this, m3, new Object[] {
s
});
return;
}
catch (Error ) { }
catch (Throwable throwable)
{
throw new UndeclaredThrowableException(throwable);
}
}
public final int hashCode()
{
try
{
// invoke 。
return ((Integer)super.h.invoke(this, m0, null)).intValue();
}
catch (Error ) { }
catch (Throwable throwable)
{
throw new UndeclaredThrowableException(throwable);
}
}
//
static
{
try
{
m1 = Class.forName("java.lang.Object").getMethod("equals", new Class[] {
Class.forName("java.lang.Object")
});
m2 = Class.forName("java.lang.Object").getMethod("toString", new Class[0]);
m3 = Class.forName("com.zhb.jdk.proxy.IUserService").getMethod("add", new Class[] {
Class.forName("java.lang.String")
});
m0 = Class.forName("java.lang.Object").getMethod("hashCode", new Class[0]);
}
catch (NoSuchMethodException nosuchmethodexception)
{
throw new NoSuchMethodError(nosuchmethodexception.getMessage());
}
catch (ClassNotFoundException classnotfoundexception)
{
throw new NoClassDefFoundError(classnotfoundexception.getMessage());
}
}
}
이상 은 바로 JDK 동적 에이전트 절차 상세(소스 코드 분석)의 상세 한 내용 입 니 다.더 많은 JDK 동적 에이전트 에 관 한 자 료 는 저희 의 다른 관련 글 을 주목 해 주 십시오!이 내용에 흥미가 있습니까?
현재 기사가 여러분의 문제를 해결하지 못하는 경우 AI 엔진은 머신러닝 분석(스마트 모델이 방금 만들어져 부정확한 경우가 있을 수 있음)을 통해 가장 유사한 기사를 추천합니다:
【Java】 STS (Eclipse)에 AdoptOpen JDK 설정· Eclipse를 2020-09로 업데이트하면 jre로 Eclipse를 움직이고 있습니다! 라는 메시지가 나온다. ・메모리 상태의 파악을 위해 MissionControl 넣으려고 하면 JDK로 움직이지 않으면 안 ...
텍스트를 자유롭게 공유하거나 복사할 수 있습니다.하지만 이 문서의 URL은 참조 URL로 남겨 두십시오.
CC BY-SA 2.5, CC BY-SA 3.0 및 CC BY-SA 4.0에 따라 라이센스가 부여됩니다.