Examples with ProxyFactory javassist.util.proxy.ProxyFactory used on opensource projects

Example 1 with ProxyFactory

use of javassist.util.proxy.ProxyFactory in project che by eclipse.

the class JUnitTestRunner method create3xTestListener.

private Object create3xTestListener(ClassLoader loader, Class<?> listenerClass, AbstractTestListener delegate) throws Exception {
    ProxyFactory f = new ProxyFactory();
    f.setSuperclass(Object.class);
    f.setInterfaces(new Class<?>[] { listenerClass });
    f.setFilter(new MethodFilter() {

        @Override
        public boolean isHandled(Method m) {
            String methodName = m.getName();
            switch(methodName) {
                case "startTest":
                case "endTest":
                case "addError":
                case "addFailure":
                    return true;
            }
            return false;
        }
    });
    Class<?> c = f.createClass();
    MethodHandler mi = new MethodHandler() {

        public Object invoke(Object self, Method method, Method proceed, Object[] args) throws Throwable {
            String testKey = args[0].getClass().toString();
            String testName = args[0].getClass().getName();
            String methodName = method.getName();
            switch(methodName) {
                case "startTest":
                    delegate.startTest(testKey, testName);
                    break;
                case "endTest":
                    delegate.endTest(testKey, testName);
                    break;
                case "addError":
                    delegate.addError(testKey, (Throwable) args[1]);
                    break;
                case "addFailure":
                    delegate.addFailure(testKey, (Throwable) args[1]);
                    break;
            }
            return null;
        }
    };
    Object listener = c.getConstructor().newInstance();
    ((javassist.util.proxy.Proxy) listener).setHandler(mi);
    return listener;
}

Example 2 with ProxyFactory

use of javassist.util.proxy.ProxyFactory in project fastjson by alibaba.

the class ProxyTest method create.

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;
}

Example 3 with ProxyFactory

use of javassist.util.proxy.ProxyFactory in project byte-buddy by raphw.

the class ClassByImplementationBenchmark method benchmarkJavassist.

/**
     * Performs a benchmark of an interface implementation using javassist proxies.
     *
     * @return The created instance, in order to avoid JIT removal.
     * @throws java.lang.Exception If the reflective invocation causes an exception.
     */
@Benchmark
public ExampleInterface benchmarkJavassist() throws Exception {
    ProxyFactory proxyFactory = new ProxyFactory();
    proxyFactory.setUseCache(false);
    ProxyFactory.classLoaderProvider = new ProxyFactory.ClassLoaderProvider() {

        @Override
        public ClassLoader get(ProxyFactory proxyFactory) {
            return newClassLoader();
        }
    };
    proxyFactory.setSuperclass(Object.class);
    proxyFactory.setInterfaces(new Class<?>[] { baseClass });
    proxyFactory.setFilter(new MethodFilter() {

        public boolean isHandled(Method method) {
            return true;
        }
    });
    @SuppressWarnings("unchecked") Object instance = proxyFactory.createClass().getDeclaredConstructor().newInstance();
    ((javassist.util.proxy.Proxy) instance).setHandler(new MethodHandler() {

        public Object invoke(Object self, Method thisMethod, Method proceed, Object[] args) throws Throwable {
            Class<?> returnType = thisMethod.getReturnType();
            if (returnType.isPrimitive()) {
                if (returnType == boolean.class) {
                    return defaultBooleanValue;
                } else if (returnType == byte.class) {
                    return defaultByteValue;
                } else if (returnType == short.class) {
                    return defaultShortValue;
                } else if (returnType == char.class) {
                    return defaultCharValue;
                } else if (returnType == int.class) {
                    return defaultIntValue;
                } else if (returnType == long.class) {
                    return defaultLongValue;
                } else if (returnType == float.class) {
                    return defaultFloatValue;
                } else {
                    return defaultDoubleValue;
                }
            } else {
                return defaultReferenceValue;
            }
        }
    });
    return (ExampleInterface) instance;
}

Example 4 with ProxyFactory

use of javassist.util.proxy.ProxyFactory in project byte-buddy by raphw.

the class TrivialClassCreationBenchmark method benchmarkJavassist.

/**
     * Performs a benchmark for a trivial class creation using javassist proxies.
     *
     * @return The created instance, in order to avoid JIT removal.
     */
@Benchmark
public Class<?> benchmarkJavassist() {
    ProxyFactory proxyFactory = new ProxyFactory();
    proxyFactory.setUseCache(false);
    ProxyFactory.classLoaderProvider = new ProxyFactory.ClassLoaderProvider() {

        @Override
        public ClassLoader get(ProxyFactory proxyFactory) {
            return newClassLoader();
        }
    };
    proxyFactory.setSuperclass(baseClass);
    proxyFactory.setFilter(new MethodFilter() {

        public boolean isHandled(Method method) {
            return false;
        }
    });
    return proxyFactory.createClass();
}

Example 5 with ProxyFactory

use of javassist.util.proxy.ProxyFactory in project dropwizard by dropwizard.

the class UnitOfWorkAwareProxyFactory method create.

/**
     * Creates a new <b>@UnitOfWork</b> aware proxy of a class with a complex constructor.
     *
     * @param clazz                 the specified class definition
     * @param constructorParamTypes the types of the constructor parameters
     * @param constructorArguments  the arguments passed to the constructor
     * @param <T>                   the type of the class
     * @return a new proxy
     */
@SuppressWarnings("unchecked")
public <T> T create(Class<T> clazz, Class<?>[] constructorParamTypes, Object[] constructorArguments) {
    final ProxyFactory factory = new ProxyFactory();
    factory.setSuperclass(clazz);
    try {
        final Proxy proxy = (Proxy) (constructorParamTypes.length == 0 ? factory.createClass().getConstructor().newInstance() : factory.create(constructorParamTypes, constructorArguments));
        proxy.setHandler((self, overridden, proceed, args) -> {
            final UnitOfWork unitOfWork = overridden.getAnnotation(UnitOfWork.class);
            final UnitOfWorkAspect unitOfWorkAspect = newAspect(sessionFactories);
            try {
                unitOfWorkAspect.beforeStart(unitOfWork);
                Object result = proceed.invoke(self, args);
                unitOfWorkAspect.afterEnd();
                return result;
            } catch (InvocationTargetException e) {
                unitOfWorkAspect.onError();
                throw e.getCause();
            } catch (Exception e) {
                unitOfWorkAspect.onError();
                throw e;
            } finally {
                unitOfWorkAspect.onFinish();
            }
        });
        return (T) proxy;
    } catch (NoSuchMethodException | InstantiationException | IllegalAccessException | InvocationTargetException e) {
        throw new IllegalStateException("Unable to create a proxy for the class '" + clazz + "'", e);
    }
}