Java MethodHandler类代码示例

import javassist.util.proxy.MethodHandler; //导入依赖的package包/类
@SuppressWarnings("unchecked")
private MethodHandler blockHandler(final Class clazz) {
    return (o, method, method1, args) -> {
        Pair<ThriftServerInfo, AbstractTrpcClient> borrowClient = ClientCluster.getBlockClient(clientArgs);
        Object client = borrowClient.getValue().getClient(clazz);
        boolean success = false;
        long startTime = System.currentTimeMillis();
        try {
            Object result = method.invoke(client, args);
            success = true;
            //将连接归还对象池
            clientArgs.getPoolProvider().returnConnection(borrowClient.getKey(), borrowClient.getValue());
            return result;
        } catch (Exception e) {
            log.error("call rpc error", e);
            clientArgs.getPoolProvider().returnBrokenConnection(borrowClient.getKey(), borrowClient.getValue());
            throw e;
        } finally {
            log.info("call " + method.getName() + " " + success + " time: " + (System.currentTimeMillis() - startTime));
        }
    };
}
 

import javassist.util.proxy.MethodHandler; //导入依赖的package包/类
@SuppressWarnings("unchecked")
private MethodHandler asyncHandler(final Class clazz) {
    return (o, method, method1, args) -> {
        Pair<ThriftServerInfo, AbstractTrpcClient> borrowClient = ClientCluster.getBlockClient(clientArgs);
        Object client = borrowClient.getValue().getClient(clazz);
        try {
            if (args.length > 0 && args[args.length - 1] instanceof AsyncMethodCallback) {
                //代理AsyncMethodCallback
                args[args.length - 1] = java.lang.reflect.Proxy.newProxyInstance(AsyncMethodCallback.class.getClassLoader(),
                        new Class[]{AsyncMethodCallback.class},
                        new AsyncMethodCallbackProxy(args[args.length - 1], clientArgs, borrowClient));
            }
            return method.invoke(client, args);
        } catch (Exception e) {
            log.error("call rpc error", e);
            throw e;
        }
    };
}
 

import javassist.util.proxy.MethodHandler; //导入依赖的package包/类
public static <T> T nullSafe(Class<T> klass, final Object instance){
    try {
        if (Modifier.isFinal(klass.getModifiers())) return (T)instance;
        ProxyFactory factory = new ProxyFactory();
        factory.setSuperclass(klass);
        Class clazz = factory.createClass();
        MethodHandler handler = (self, overridden, forwarder, args) -> {
            Object returnval = (instance != null) ? overridden.invoke(instance, args) : null;
            return nullSafe(overridden.getReturnType(), returnval);

        };
        Object proxyInstance = clazz.newInstance();
        ((ProxyObject) proxyInstance).setHandler(handler);
        return (T) proxyInstance;
    } catch (Exception e) {
        throw new RuntimeException(e);
    }
}
 

import javassist.util.proxy.MethodHandler; //导入依赖的package包/类
static NonTrivialBean newJavassistProxy() 
        throws InstantiationException, IllegalAccessException {
  ProxyFactory f = new ProxyFactory();
  f.setSuperclass(NonTrivialBean.class);
  Class<?> c = f.createClass();
  MethodHandler mi = new MethodHandler() {
    // delegate to source methods
    public Object invoke(Object self, Method m, Method proceed, 
        Object[] args) throws Throwable {
      return proceed.invoke(self, args);
    }
  };
  NonTrivialBean b = (NonTrivialBean) c.newInstance();
  ((Proxy) b).setHandler(mi);
  return b;
}
 

import javassist.util.proxy.MethodHandler; //导入依赖的package包/类
@SuppressWarnings("rawtypes")
public static <T> T create(final Object obj, final ProxyCallback onSuccess, final ProxyCallback onException) throws Exception {
	ProxyFactory factory = new ProxyFactory();
	Class<T> origClass = (Class<T>) obj.getClass();
	factory.setSuperclass(origClass);
	Class clazz = factory.createClass();
	MethodHandler handler = new MethodHandler() {

		@Override
		public Object invoke(Object self, Method overridden, Method forwarder,
				Object[] args) throws Throwable {
			try {
				Object returnVal = overridden.invoke(obj, args);
				if (null != onSuccess) onSuccess.execute();
				return returnVal;
			} catch (Throwable tr) {
				if (null != onException) onException.execute();
				throw tr;
			}
		}
	};
	Object instance = clazz.newInstance();
	((ProxyObject) instance).setHandler(handler);
	return (T) instance;
}
 

import javassist.util.proxy.MethodHandler; //导入依赖的package包/类
public static boolean isProxy(final Object element)
{
    if (null == element)
    {
        return false;
    }
    if (element instanceof ProxyObject)
    {
        final MethodHandler methodHandler = ((ProxyObject) element).getHandler();
        if (methodHandler instanceof LazyAssociationHandler)
        {
            return true;
        }
    }
    return false;
}
 

import javassist.util.proxy.MethodHandler; //导入依赖的package包/类
public static <T> T create(Class<T> classs) throws Exception {
    ProxyFactory factory = new ProxyFactory();
    factory.setSuperclass(classs);
    Class clazz = factory.createClass();
    MethodHandler handler = new MethodHandler() {

        public Object invoke(Object self, Method overridden, Method forwarder, Object[] args) throws Throwable {
            return forwarder.invoke(self, args);
        }
    };
    Object instance = clazz.newInstance();
    ((ProxyObject) instance).setHandler(handler);
    return (T) instance;
}
 

import javassist.util.proxy.MethodHandler; //导入依赖的package包/类
@Override
public <T> T postProcess(final T object, ResolutionContext context,
                         Resolution<?> resolution) throws ReflectiveOperationException {
    final Class<?> clazz = object.getClass();
    if (!hasProfileMethod(clazz)) {
        return null;
    }

    // The Proxy generated by javassist will have the same constructor args as on the real class
    // We can easily check and satisfy this by getting the instantiation method: if it is constructor injection
    // get the args from it. This approach requires some refactoring to support custom instantiation methods.
    Class<?>[] constructorTypes = getConstructorType(clazz);
    Object[] constructorArgs = resolveConstructorArgs(constructorTypes);

    ProxyFactory pf = new ProxyFactory();
    pf.setSuperclass(clazz);
    Class<?> proxyClass = pf.createClass(METHOD_FILTER);

    T proxy = (T) proxyClass
        .getConstructor(constructorTypes)
        .newInstance(constructorArgs);

    ((Proxy) proxy).setHandler(new MethodHandler() {
        @Override
        public Object invoke(Object self, Method thisMethod, Method proceed, Object[] args)
                             throws ReflectiveOperationException {
            invocations.add(clazz.getSimpleName() + "#" + thisMethod.getName());
            return thisMethod.invoke(object, args);
        }
    });
    return proxy;
}
 

import javassist.util.proxy.MethodHandler; //导入依赖的package包/类
private static <T> T createProxyInstance(Class<T> entityType, MethodHandler methodHandler) {
	ProxyFactory factory = new ProxyFactory();
	factory.setSuperclass(entityType);
	factory.setFilter(FILTER_INSTANCE);
	
	Class<?> clazz = factory.createClass();
	T proxy = instantiateClass(clazz);
	((Proxy) proxy).setHandler(methodHandler);
	return proxy;
}
 

import javassist.util.proxy.MethodHandler; //导入依赖的package包/类
@SuppressWarnings("unchecked")
@Override
protected <E> E createInternal(final Class<E> klass) {
	
	try {
	
   		ProxyFactory factory = new ProxyFactory();
   		factory.setSuperclass(klass);
   		
   		factory.setFilter(new MethodFilter() {
   
   			@Override
               public boolean isHandled(Method m) {
   				return getPropName(m) != null;
   			}
   		});
   		
   		MethodHandler handler = new MethodHandler() {
   	        
   			@Override
   	        public Object invoke(Object self, Method thisMethod, Method proceed, Object[] args) throws Throwable {
   				
   				return DefaultProxy.this.invoke(self, thisMethod, args);
   	        }
   	    };
   	    
   	    return (E) factory.create(new Class[0], new Object[0], handler);
   	    
	} catch(Exception e) {
		throw new BeanException(e);
	}
}
 

import javassist.util.proxy.MethodHandler; //导入依赖的package包/类
/** TODO !!! describe !!! **/
public static <T> T assertExceptionThrown(final T object, final Class<? extends Throwable> expectedExceptionClass, final String message) {

	assertNotNull(object, message);

	return createProxy(object.getClass(), new MethodHandler() {

		@Override
		public Object invoke(Object self, Method thisMethod, Method proceed, Object[] args) throws Throwable {

			Throwable methodException = null;

			try {
				thisMethod.invoke(object, args);
			} catch (InvocationTargetException e) {
				methodException = e.getCause();
			}

			if (methodException == null || !expectedExceptionClass.isAssignableFrom(methodException.getClass())) {
				fail(object, "method " + thisMethod.getName() + "(...) was expected to throw " + expectedExceptionClass.getName()
						+ " but it "
						+ (methodException == null ? "did not" : "threw " + methodException.getClass().getName() + " instead"), message);
			}

			return null;
		}

	});
}
 

import javassist.util.proxy.MethodHandler; //导入依赖的package包/类
public static <T> T proxy(Class<T> expected, MethodHandler handler, Class<?>[] paramTypes, Object[] args) {
    Class<?>[] interfaces = null;
    Class<?> superClass = null;
    if (expected.isInterface()) {
        interfaces = new Class[]{expected};
    } else {
        superClass = expected;
    }
    return proxy(expected, interfaces, superClass, handler, paramTypes, args);
}
 

import javassist.util.proxy.MethodHandler; //导入依赖的package包/类
public static <T> T narrow(Class<T> expected, final T target) {
    return proxy(expected, new MethodHandler() {
        public Object invoke(Object self, Method method, Method proceed, Object[] args) throws Throwable {
            return method.invoke(target, args);
        }
    });
}
 

import javassist.util.proxy.MethodHandler; //导入依赖的package包/类
public static Archive<?> toProxy(final Archive<?> archive, final String newArchiveName) {
    Class<? extends Archive> expected = (archive instanceof EnterpriseArchive) ? EnterpriseArchive.class : WebArchive.class;
    return BytecodeUtils.proxy(expected, new MethodHandler() {
        public Object invoke(Object self, Method method, Method proceed, Object[] args) throws Throwable {
            if ("getName".equals(method.getName())) {
                return newArchiveName;
            } else {
                return method.invoke(archive, args);
            }
        }
    });
}
 

import javassist.util.proxy.MethodHandler; //导入依赖的package包/类
/**
 * Creates a proxy class of bean and returns an instance of that class.
 *
 * @param context the activity context
 * @param beanRule the bean rule
 * @param constructorArgs the arguments passed to a constructor
 * @param constructorArgTypes the parameter types for a constructor
 * @return a new proxy bean object
 */
public static Object newInstance(ActivityContext context, BeanRule beanRule, Object[] constructorArgs, Class<?>[] constructorArgTypes) {
    try {
        ProxyFactory proxyFactory = new ProxyFactory();
        proxyFactory.setSuperclass(beanRule.getBeanClass());
        MethodHandler methodHandler = new JavassistDynamicBeanProxy(context, beanRule);
        return proxyFactory.create(constructorArgTypes, constructorArgs, methodHandler);
    } catch (Exception e) {
        throw new ProxyBeanInstantiationException(beanRule.getBeanClass(), e);
    }
}