public static <T> T implementInterfaces(Object target, InvocationHandler handler) { return implement(target, handler, Cls.getImplementedInterfaces(target.getClass())); }
public static <T> T implement(final Object target, final InvocationHandler handler, Class<?>... interfaces) { final Class<?> targetClass = target.getClass(); return createProxy((proxy, method, args) -> { if (method.getDeclaringClass().isAssignableFrom(targetClass)) { return method.invoke(target, args); } return handler.invoke(proxy, method, args); }, interfaces); }
public static <T> T tracer(Object target) { return implementInterfaces(target, (target1, method, args) -> { Log.trace("intercepting", "method", method.getName(), "args", Arrays.toString(args)); return method.invoke(target1, args); }); }
public static <T> T implement(InvocationHandler handler, Class<?>... classes) { return implement(new InterceptorProxy(U.str(classes)), handler, classes); }
public static <TAG extends Tag> TAG create(Class<?> tagInterface, String tagName, Object[] contents) { TagImpl tag = new TagImpl(tagInterface, tagName, contents); TAG proxy = Proxies.createProxy(new TagProxy(tag, tagInterface), tagInterface, TagInternals.class); tag.setProxy(proxy); return proxy; }
public static <T, B extends Builder<T>> B builder(final Class<B> builderInterface, final Class<T> builtInterface, final Class<? extends T> implClass) { final Map<String, Object> properties = U.map(); InvocationHandler handler = new InvocationHandler() { @Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { if (method.getDeclaringClass().equals(Builder.class)) { T instance = inject(Cls.newInstance(implClass, properties), properties); Beany.update(instance, properties, false, true); return instance; } else { U.must(args.length == 1, "expected 1 argument!"); properties.put(method.getName(), args[0]); return proxy; } } }; B builder = Proxies.implement(handler, builderInterface); return builder; }
public static <T, B extends Builder<T>> B builder(final Class<B> builderInterface, final Class<T> builtInterface, final Class<? extends T> implClass) { final Map<String, Object> properties = U.map(); InvocationHandler handler = new InvocationHandler() { @Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { if (method.getDeclaringClass().equals(Builder.class)) { T instance = Cls.newInstance(implClass, properties); update(instance, properties, false, true); return instance; } else { U.must(args.length == 1, "expected 1 argument!"); properties.put(method.getName(), args[0]); return proxy; } } }; B builder = Proxies.implement(handler, builderInterface); return builder; }
private static <T> T proxyWrap(T instance) { Set<F3<Object, Object, Method, Object[]>> done = U.set(); for (Class<?> interf : Cls.getImplementedInterfaces(instance.getClass())) { final List<F3<Object, Object, Method, Object[]>> interceptors = INTERCEPTORS.get(interf); if (interceptors != null) { for (final F3<Object, Object, Method, Object[]> interceptor : interceptors) { if (interceptor != null && !done.contains(interceptor)) { Log.debug("Creating proxy", "target", instance, "interface", interf, "interceptor", interceptor); final T target = instance; InvocationHandler handler = new InvocationHandler() { @Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { return interceptor.execute(target, method, args); } }; instance = Proxies.implement(instance, handler, interf); done.add(interceptor); } } } } return instance; }