Java Code Examples for java.lang.reflect.Proxy
The following are top voted examples for showing how to use
java.lang.reflect.Proxy. These examples are extracted from open source projects.
You can vote up the examples you like and your votes will be used in our system to generate
more good examples.
Example 1
Project: jDialects File: ClassUtils.java View source code | 7 votes |
/** * Return a descriptive name for the given object's type: usually simply * the class name, but component type class name + "[]" for arrays, * and an appended list of implemented interfaces for JDK proxies. * @param value the value to introspect * @return the qualified name of the class */ public static String getDescriptiveType(Object value) { if (value == null) { return null; } Class<?> clazz = value.getClass(); if (Proxy.isProxyClass(clazz)) { StringBuilder result = new StringBuilder(clazz.getName()); result.append(" implementing "); Class<?>[] ifcs = clazz.getInterfaces(); for (int i = 0; i < ifcs.length; i++) { result.append(ifcs[i].getName()); if (i < ifcs.length - 1) { result.append(','); } } return result.toString(); } else if (clazz.isArray()) { return getQualifiedNameForArray(clazz); } else { return clazz.getName(); } }
Example 2
Project: the-vigilantes File: JDBC4ConnectionWrapper.java View source code | 6 votes |
/** * Returns an object that implements the given interface to allow access to * non-standard methods, or standard methods not exposed by the proxy. The * result may be either the object found to implement the interface or a * proxy for that object. If the receiver implements the interface then that * is the object. If the receiver is a wrapper and the wrapped object * implements the interface then that is the object. Otherwise the object is * the result of calling <code>unwrap</code> recursively on the wrapped * object. If the receiver is not a wrapper and does not implement the * interface, then an <code>SQLException</code> is thrown. * * @param iface * A Class defining an interface that the result must implement. * @return an object that implements the interface. May be a proxy for the * actual implementing object. * @throws java.sql.SQLException * If no object found that implements the interface * @since 1.6 */ public synchronized <T> T unwrap(java.lang.Class<T> iface) throws java.sql.SQLException { try { if ("java.sql.Connection".equals(iface.getName()) || "java.sql.Wrapper.class".equals(iface.getName())) { return iface.cast(this); } if (unwrappedInterfaces == null) { unwrappedInterfaces = new HashMap<Class<?>, Object>(); } Object cachedUnwrapped = unwrappedInterfaces.get(iface); if (cachedUnwrapped == null) { cachedUnwrapped = Proxy.newProxyInstance(this.mc.getClass().getClassLoader(), new Class<?>[] { iface }, new ConnectionErrorFiringInvocationHandler(this.mc)); unwrappedInterfaces.put(iface, cachedUnwrapped); } return iface.cast(cachedUnwrapped); } catch (ClassCastException cce) { throw SQLError.createSQLException("Unable to unwrap to " + iface.toString(), SQLError.SQL_STATE_ILLEGAL_ARGUMENT, this.exceptionInterceptor); } }
Example 3
Project: OpenJSharp File: Class.java View source code | 6 votes |
private void checkPackageAccess(final ClassLoader ccl, boolean checkProxyInterfaces) { final SecurityManager s = System.getSecurityManager(); if (s != null) { final ClassLoader cl = getClassLoader0(); if (ReflectUtil.needsPackageAccessCheck(ccl, cl)) { String name = this.getName(); int i = name.lastIndexOf('.'); if (i != -1) { // skip the package access check on a proxy class in default proxy package String pkg = name.substring(0, i); if (!Proxy.isProxyClass(this) || ReflectUtil.isNonPublicProxyClass(this)) { s.checkPackageAccess(pkg); } } } // check package access on the proxy interfaces if (checkProxyInterfaces && Proxy.isProxyClass(this)) { ReflectUtil.checkProxyPackageAccess(ccl, this.getInterfaces()); } } }
Example 4
Project: GitHub File: DistinctUntilChangedInterceptor.java View source code | 6 votes |
@SuppressWarnings("unchecked") @NonNull public <V extends TiView> V wrap(@NonNull final V view) { Class<?> foundInterfaceClass = getInterfaceOfClassExtendingGivenInterface(view.getClass(), TiView.class); if (foundInterfaceClass == null) { throw new IllegalStateException("the interface extending View could not be found"); } if (!hasObjectMethodWithAnnotation(view, DistinctUntilChanged.class)) { // not method has the annotation, returning original view // not creating a proxy return view; } return (V) Proxy.newProxyInstance( foundInterfaceClass.getClassLoader(), new Class<?>[]{foundInterfaceClass}, new DistinctUntilChangedInvocationHandler<>(view)); }
Example 5
Project: openjdk-jdk10 File: SerialFilterTest.java View source code | 6 votes |
@Override public ObjectInputFilter.Status checkInput(FilterInfo filter) { Class<?> serialClass = filter.serialClass(); System.out.printf(" checkInput: class: %s, arrayLen: %d, refs: %d, depth: %d, bytes; %d%n", serialClass, filter.arrayLength(), filter.references(), filter.depth(), filter.streamBytes()); count++; if (serialClass != null) { if (serialClass.getName().contains("$$Lambda$")) { // TBD: proper identification of serialized Lambdas? // Fold the serialized Lambda into the SerializedLambda type classes.add(SerializedLambda.class); } else if (Proxy.isProxyClass(serialClass)) { classes.add(Proxy.class); } else { classes.add(serialClass); } } this.maxArray = Math.max(this.maxArray, filter.arrayLength()); this.maxRefs = Math.max(this.maxRefs, filter.references()); this.maxDepth = Math.max(this.maxDepth, filter.depth()); this.maxBytes = Math.max(this.maxBytes, filter.streamBytes()); return ObjectInputFilter.Status.UNDECIDED; }
Example 6
Project: jdk8u-jdk File: RuntimeExceptionTest.java View source code | 6 votes |
/** * Test the monitor notifications. */ public int monitorNotifications() throws Exception { server = MBeanServerFactory.newMBeanServer(); MBeanServerForwarderInvocationHandler mbsfih = (MBeanServerForwarderInvocationHandler) Proxy.getInvocationHandler(server); mbsfih.setGetAttributeException( new RuntimeException("Test RuntimeException")); domain = server.getDefaultDomain(); obsObjName = ObjectName.getInstance(domain + ":type=ObservedObject"); server.registerMBean(new ObservedObject(), obsObjName); echo(">>> ----------------------------------------"); int error = counterMonitorNotification(); echo(">>> ----------------------------------------"); error += gaugeMonitorNotification(); echo(">>> ----------------------------------------"); error += stringMonitorNotification(); echo(">>> ----------------------------------------"); return error; }
Example 7
Project: ProyectoPacientes File: WrapperBase.java View source code | 6 votes |
/** * Recursively checks for interfaces on the given object to determine * if it implements a java.sql interface, and if so, proxies the * instance so that we can catch and fire SQL errors. * * @param toProxy * @param clazz */ private Object proxyIfInterfaceIsJdbc(Object toProxy, Class<?> clazz) { Class<?>[] interfaces = clazz.getInterfaces(); for (Class<?> iclass : interfaces) { String packageName = Util.getPackageName(iclass); if ("java.sql".equals(packageName) || "javax.sql".equals(packageName)) { return Proxy.newProxyInstance(toProxy.getClass().getClassLoader(), interfaces, new ConnectionErrorFiringInvocationHandler(toProxy)); } return proxyIfInterfaceIsJdbc(toProxy, iclass); } return toProxy; }
Example 8
Project: whackpad File: VMBridge_jdk13.java View source code | 6 votes |
@Override protected Object getInterfaceProxyHelper(ContextFactory cf, Class<?>[] interfaces) { // XXX: How to handle interfaces array withclasses from different // class loaders? Using cf.getApplicationClassLoader() ? ClassLoader loader = interfaces[0].getClassLoader(); Class<?> cl = Proxy.getProxyClass(loader, interfaces); Constructor<?> c; try { c = cl.getConstructor(new Class[] { InvocationHandler.class }); } catch (NoSuchMethodException ex) { // Should not happen throw Kit.initCause(new IllegalStateException(), ex); } return c; }
Example 9
Project: OpenJSharp File: AbstractWrapperBeanGenerator.java View source code | 6 votes |
private void processXmlElement(List<Annotation> jaxb, String elemName, String elemNS, T type) { XmlElement elemAnn = null; for (Annotation a : jaxb) { if (a.annotationType() == XmlElement.class) { elemAnn = (XmlElement) a; jaxb.remove(a); break; } } String name = (elemAnn != null && !elemAnn.name().equals("##default")) ? elemAnn.name() : elemName; String ns = (elemAnn != null && !elemAnn.namespace().equals("##default")) ? elemAnn.namespace() : elemNS; boolean nillable = nav.isArray(type) || (elemAnn != null && elemAnn.nillable()); boolean required = elemAnn != null && elemAnn.required(); XmlElementHandler handler = new XmlElementHandler(name, ns, nillable, required); XmlElement elem = (XmlElement) Proxy.newProxyInstance(this.getClass().getClassLoader(), new Class<?>[]{XmlElement.class}, handler); jaxb.add(elem); }
Example 10
Project: openjdk-jdk10 File: ObjectStreamClass.java View source code | 6 votes |
/** * Returns ObjectStreamField array describing the serializable fields of * the given class. Serializable fields backed by an actual field of the * class are represented by ObjectStreamFields with corresponding non-null * Field objects. Throws InvalidClassException if the (explicitly * declared) serializable fields are invalid. */ private static ObjectStreamField[] getSerialFields(Class<?> cl) throws InvalidClassException { ObjectStreamField[] fields; if (Serializable.class.isAssignableFrom(cl) && !Externalizable.class.isAssignableFrom(cl) && !Proxy.isProxyClass(cl) && !cl.isInterface()) { if ((fields = getDeclaredSerialFields(cl)) == null) { fields = getDefaultSerialFields(cl); } Arrays.sort(fields); } else { fields = NO_FIELDS; } return fields; }
Example 11
Project: the-vigilantes File: UtilsTest.java View source code | 6 votes |
/** * Tests Util.isJdbcInterface() * * @throws Exception */ public void testIsJdbcInterface() throws Exception { // Classes directly or indirectly implementing JDBC interfaces. assertTrue(Util.isJdbcInterface(PreparedStatement.class)); assertTrue(Util.isJdbcInterface(StatementImpl.class)); assertTrue(Util.isJdbcInterface(Statement.class)); assertTrue(Util.isJdbcInterface(ResultSetImpl.class)); Statement s = (Statement) Proxy.newProxyInstance(this.getClass().getClassLoader(), new Class<?>[] { Statement.class }, new InvocationHandler() { public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { return null; } }); assertTrue(Util.isJdbcInterface(s.getClass())); // Classes not implementing JDBC interfaces. assertFalse(Util.isJdbcInterface(Util.class)); assertFalse(Util.isJdbcInterface(UtilsTest.class)); }
Example 12
Project: meparty File: RestApiProxyFactory.java View source code | 6 votes |
/** * Returns Rest API implementation. * * @param restApiClass type of Rest API * @param <T> Rest Api type * @return Rest API instance */ @SuppressWarnings("unchecked") public static <T extends Controller> T createProxy(Class<T> restApiClass) { AssertHelper.notNull(restApiClass); if (!restApiClass.isAnnotationPresent(RestApi.class)) { throw new RestApiAnnotationIsMissingException(restApiClass); } RestApi restApiAnnotation = restApiClass.getAnnotation(RestApi.class); String applicationName = restApiAnnotation.value(); if (StringHelper.isNullOrEmpty(applicationName)) { throw new ApplicationNameCannotBeNullOrEmptyException(restApiClass); } InvocationHandler handler = new RestApiProxyInvocationHandler(); T restApi = (T) Proxy.newProxyInstance(restApiClass.getClassLoader(), new Class[]{restApiClass}, handler); return restApi; }
Example 13
Project: incubator-netbeans File: MetaInfCacheTest.java View source code | 6 votes |
private static Object generateProxyType(final int i) { class DummyH implements InvocationHandler { @Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { if (method.getName().equals("equals")) { return proxy == args[0]; } if (method.getName().equals("toString")) { return "DummyH[" + i + "]"; } return null; } } return Proxy.newProxyInstance( MetaInfCache.class.getClassLoader(), findTypes(i), new DummyH() ); }
Example 14
Project: incubator-netbeans File: BlacklistedClassesHandlerSingleton.java View source code | 6 votes |
/** * Use this method to get existing or new non-initialized instance of * BlacklistedClassesHandler. This method ensures that only one instance of * BlacklistedClassesHandler is shared across the different classloaders. * * Use initSingleton methods to initialize BlacklistedClassesHandler * @return existing or new non-initialized instance of * BlacklistedClassesHandler */ public static synchronized BlacklistedClassesHandler getInstance() { if (instance == null) { try { // TODO Is it really necessary to use proxies? ClassLoader myClassLoader = BlacklistedClassesHandlerSingleton.class.getClassLoader(); ClassLoader parentClassLoader = ClassLoader.getSystemClassLoader(); if (myClassLoader != parentClassLoader) { Class otherClassInstance = parentClassLoader.loadClass(BlacklistedClassesHandlerSingleton.class.getName()); Method getInstanceMethod = otherClassInstance.getDeclaredMethod("getInstance", new Class[] { }); Object otherAbsoluteSingleton = getInstanceMethod.invoke(null, new Object[] { } ); instance = (BlacklistedClassesHandler) Proxy.newProxyInstance(myClassLoader, new Class[] { BlacklistedClassesHandler.class }, new PassThroughProxyHandler(otherAbsoluteSingleton)); } else { instance = new BlacklistedClassesHandlerSingleton(); } } catch (Exception e) { throw new RuntimeException("Failed to get BlacklistedClassesHandler instance", e); } } return instance; }
Example 15
Project: OpenJSharp File: RemoteObjectInvocationHandler.java View source code | 6 votes |
/** * Handles java.lang.Object methods. **/ private Object invokeObjectMethod(Object proxy, Method method, Object[] args) { String name = method.getName(); if (name.equals("hashCode")) { return hashCode(); } else if (name.equals("equals")) { Object obj = args[0]; return proxy == obj || (obj != null && Proxy.isProxyClass(obj.getClass()) && equals(Proxy.getInvocationHandler(obj))); } else if (name.equals("toString")) { return proxyToString(proxy); } else { throw new IllegalArgumentException( "unexpected Object method: " + method); } }
Example 16
Project: BibliotecaPS File: JDBC4StatementWrapper.java View source code | 6 votes |
/** * Returns an object that implements the given interface to allow access to * non-standard methods, or standard methods not exposed by the proxy. The * result may be either the object found to implement the interface or a * proxy for that object. If the receiver implements the interface then that * is the object. If the receiver is a wrapper and the wrapped object * implements the interface then that is the object. Otherwise the object is * the result of calling <code>unwrap</code> recursively on the wrapped * object. If the receiver is not a wrapper and does not implement the * interface, then an <code>SQLException</code> is thrown. * * @param iface * A Class defining an interface that the result must implement. * @return an object that implements the interface. May be a proxy for the * actual implementing object. * @throws java.sql.SQLException * If no object found that implements the interface * @since 1.6 */ public synchronized <T> T unwrap(java.lang.Class<T> iface) throws java.sql.SQLException { try { if ("java.sql.Statement".equals(iface.getName()) || "java.sql.Wrapper.class".equals(iface.getName())) { return iface.cast(this); } if (unwrappedInterfaces == null) { unwrappedInterfaces = new HashMap<Class<?>, Object>(); } Object cachedUnwrapped = unwrappedInterfaces.get(iface); if (cachedUnwrapped == null) { cachedUnwrapped = Proxy.newProxyInstance(this.wrappedStmt.getClass().getClassLoader(), new Class<?>[] { iface }, new ConnectionErrorFiringInvocationHandler(this.wrappedStmt)); unwrappedInterfaces.put(iface, cachedUnwrapped); } return iface.cast(cachedUnwrapped); } catch (ClassCastException cce) { throw SQLError.createSQLException("Unable to unwrap to " + iface.toString(), SQLError.SQL_STATE_ILLEGAL_ARGUMENT, this.exceptionInterceptor); } }
Example 17
Project: dremio-oss File: ProxiesManager.java View source code | 6 votes |
private Class<Proxy> getProxyClassForInterface( final Class<?> interfaceType ) { assert interfaceType.isInterface(); Class<Proxy> proxyReturnClass = interfacesToProxyClassesMap.get( interfaceType ); if ( null == proxyReturnClass ) { // Suppressed because we know getProxyClass returns class extending Proxy. @SuppressWarnings("unchecked") Class<Proxy> newProxyReturnClass = (Class<Proxy>) Proxy.getProxyClass( interfaceType.getClassLoader(), new Class[] { interfaceType }); interfacesToProxyClassesMap.put( interfaceType, newProxyReturnClass ); proxyReturnClass = newProxyReturnClass; } return proxyReturnClass; }
Example 18
Project: reflection-util File: ClassUtils.java View source code | 6 votes |
private static <T> Class<T> getRealClass(Class<T> clazz) { if (isProxyClass(clazz)) { if (Proxy.isProxyClass(clazz)) { Class<?>[] interfaces = clazz.getInterfaces(); if (interfaces.length != 1) { throw new IllegalArgumentException("Unexpected number of interfaces: " + interfaces.length); } @SuppressWarnings("unchecked") Class<T> proxiedInterface = (Class<T>) interfaces[0]; return proxiedInterface; } @SuppressWarnings("unchecked") Class<T> superclass = (Class<T>) clazz.getSuperclass(); return getRealClass(superclass); } return clazz; }
Example 19
Project: ditb File: HbaseHandlerMetricsProxy.java View source code | 6 votes |
public static Hbase.Iface newInstance(Hbase.Iface handler, ThriftMetrics metrics, Configuration conf) { return (Hbase.Iface) Proxy.newProxyInstance( handler.getClass().getClassLoader(), new Class[]{Hbase.Iface.class}, new HbaseHandlerMetricsProxy(handler, metrics, conf)); }
Example 20
Project: ramus File: InternetClient.java View source code | 6 votes |
@SuppressWarnings("unchecked") private Object createDeligate(Class[] classes) { return Proxy.newProxyInstance(getClass().getClassLoader(), classes, new InvocationHandler() { @Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { CallParameters parameters = new CallParameters(method .getName(), args); Result result = connection.call(parameters); if (result.exception != null) throw result.exception; return result.result; } }); }
Example 21
Project: crnk-framework File: CrnkClient.java View source code | 6 votes |
@SuppressWarnings("unchecked") public <R extends ResourceRepositoryV2<?, ?>> R getRepositoryForInterface(Class<R> repositoryInterfaceClass) { init(); RepositoryInformationProvider informationBuilder = moduleRegistry.getRepositoryInformationBuilder(); PreconditionUtil.assertTrue("no a valid repository interface", informationBuilder.accept(repositoryInterfaceClass)); ResourceRepositoryInformation repositoryInformation = (ResourceRepositoryInformation) informationBuilder .build(repositoryInterfaceClass, new DefaultRepositoryInformationProviderContext(moduleRegistry)); Class<?> resourceClass = repositoryInformation.getResourceInformation().get().getResourceClass(); Object actionStub = actionStubFactory != null ? actionStubFactory.createStub(repositoryInterfaceClass) : null; ResourceRepositoryV2<?, Serializable> repositoryStub = getQuerySpecRepository(resourceClass); ClassLoader classLoader = repositoryInterfaceClass.getClassLoader(); InvocationHandler invocationHandler = new ClientStubInvocationHandler(repositoryInterfaceClass, repositoryStub, actionStub); return (R) Proxy.newProxyInstance(classLoader, new Class[] { repositoryInterfaceClass, ResourceRepositoryV2.class }, invocationHandler); }
Example 22
Project: openjdk-jdk10 File: ScriptEngineSecurityTest.java View source code | 5 votes |
@Test public static void proxyStaticAccessCheckTest() { if (System.getSecurityManager() == null) { // pass vacuously return; } final ScriptEngineManager m = new ScriptEngineManager(); final ScriptEngine e = m.getEngineByName("nashorn"); final Runnable r = (Runnable)Proxy.newProxyInstance( ScriptEngineSecurityTest.class.getClassLoader(), new Class[] { Runnable.class }, new InvocationHandler() { @Override public Object invoke(final Object p, final Method mtd, final Object[] a) { return null; } }); e.put("rc", r.getClass()); e.put("cl", ScriptEngineSecurityTest.class.getClassLoader()); e.put("intfs", new Class[] { Runnable.class }); // make sure static methods of Proxy is not accessible via subclass try { e.eval("rc.static.getProxyClass(cl, intfs)"); fail("Should have thrown SecurityException"); } catch (final Exception exp) { if (! (exp instanceof SecurityException)) { fail("SecurityException expected, got " + exp); } } }
Example 23
Project: Reer File: PropertyAccessorExtractionContext.java View source code | 5 votes |
public List<Method> getGetters() { List<Method> getters; if (mostSpecificDeclaration.getReturnType()==Boolean.TYPE) { getters = Lists.newArrayList(); for (Method getter : declaringMethods) { if (Proxy.isProxyClass(getter.getDeclaringClass())) { continue; } getters.add(getter); } } else { getters = Collections.singletonList(mostSpecificDeclaration); } return getters; }
Example 24
Project: KTools File: BaseApi.java View source code | 5 votes |
protected Service createProxyService(final Service service) { Class<Service> serviceClass = getServiceClass(); return (Service) Proxy.newProxyInstance(serviceClass.getClassLoader(), new Class[]{serviceClass}, new InvocationHandler() { @Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { if (NetworkUtils.isNetAvailable()) { return ((Flowable) method.invoke(service, args)).subscribeOn(Schedulers.io()); } else { return Flowable.error(new NetworkErrorException()).subscribeOn(Schedulers.io()); } } }); }
Example 25
Project: lams File: JRubyScriptUtils.java View source code | 5 votes |
private boolean isProxyForSameRubyObject(Object other) { if (!Proxy.isProxyClass(other.getClass())) { return false; } InvocationHandler ih = Proxy.getInvocationHandler(other); return (ih instanceof RubyObjectInvocationHandler && this.rubyObject.equals(((RubyObjectInvocationHandler) ih).rubyObject)); }
Example 26
Project: eZooKeeper File: ViewerFactory.java View source code | 5 votes |
private static void initViewer(StructuredViewer viewer, ElementTypes elementTypes, Object input, IElementBinding elementBinding, IViewerType viewerType, Class<?> contentProviderInterfaceType) { PluggableContentProvider pluggableContentProvider = new PluggableContentProvider(viewerType, elementTypes, elementBinding); ElementTypesLabelProvider labelProvider = new ElementTypesLabelProvider(elementTypes); DelegatingInvocationHandler invocationHandler = new DelegatingInvocationHandler(pluggableContentProvider); IContentProvider contentProvider = (IContentProvider) Proxy.newProxyInstance(contentProviderInterfaceType .getClassLoader(), new Class[] { contentProviderInterfaceType }, invocationHandler); viewer.setContentProvider(contentProvider); viewer.setLabelProvider(labelProvider); viewer.setUseHashlookup(true); viewer.setInput(input); }
Example 27
Project: uroborosql File: TestConsts.java View source code | 5 votes |
@SuppressWarnings("unchecked") private static <I> I newProxy(final Class<I> interfaceType) { Object o = new Object(); Method getOriginal; try { getOriginal = ProxyContainer.class.getMethod("getOriginal"); } catch (NoSuchMethodException | SecurityException e) { throw new AssertionError(e); } I proxyInstance = (I) Proxy.newProxyInstance(Thread.currentThread().getContextClassLoader(), new Class<?>[] { interfaceType, ProxyContainer.class }, (proxy, method, args) -> { if (getOriginal.equals(method)) { return o; } if (args != null) { for (int i = 0; i < args.length; i++) { if (args[i] instanceof ProxyContainer) { args[i] = ((ProxyContainer) args[i]).getOriginal(); } } } return method.invoke(o, args); }); return proxyInstance; }
Example 28
Project: mug File: RetryerTest.java View source code | 5 votes |
@Test public void testNulls() throws Exception { Stream<?> statelessStream = (Stream<?>) Proxy.newProxyInstance( RetryerTest.class.getClassLoader(), new Class<?>[] {Stream.class}, (p, method, args) -> method.invoke(Stream.of(), args)); new NullPointerTester() .setDefault(Stream.class, statelessStream) .ignore(Retryer.class.getMethod("uponReturn", Object.class, Stream.class)) .ignore(Retryer.class.getMethod("uponReturn", Object.class, List.class)) .testAllPublicInstanceMethods(new Retryer()); }
Example 29
Project: Reer File: DefaultSingleRequestWorkerProcessBuilder.java View source code | 5 votes |
@Override public PROTOCOL build() { return protocolType.cast(Proxy.newProxyInstance(protocolType.getClassLoader(), new Class[]{protocolType}, new InvocationHandler() { @Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { Receiver receiver = new Receiver(getBaseName()); try { WorkerProcess workerProcess = builder.build(); workerProcess.start(); ObjectConnection connection = workerProcess.getConnection(); RequestProtocol requestProtocol = connection.addOutgoing(RequestProtocol.class); connection.addIncoming(ResponseProtocol.class, receiver); connection.useJavaSerializationForParameters(workerImplementation.getClassLoader()); connection.connect(); requestProtocol.runThenStop(method.getName(), method.getParameterTypes(), args); boolean hasResult = receiver.awaitNextResult(); workerProcess.waitForStop(); if (!hasResult) { // Reached the end of input, worker has exited without failing throw new IllegalStateException(String.format("No response was received from %s but the worker process has finished.", getBaseName())); } } catch (Exception e) { throw WorkerProcessException.runFailed(getBaseName(), e); } return receiver.getNextResult(); } })); }
Example 30
Project: NotifyTools File: ProxyPersistenceDelegate.java View source code | 5 votes |
@Override protected boolean mutatesTo(Object oldInstance, Object newInstance) { if((oldInstance instanceof Proxy) && (newInstance instanceof Proxy)){ return super.mutatesTo(oldInstance, newInstance); } return false; }
Example 31
Project: jdk8u-jdk File: Obj.java View source code | 5 votes |
protected Class<?> resolveProxyClass(String[] interfaces) throws IOException, ClassNotFoundException { ClassLoader nonPublicLoader = null; boolean hasNonPublicInterface = false; // define proxy in class loader of non-public interface(s), if any Class<?>[] classObjs = new Class<?>[interfaces.length]; for (int i = 0; i < interfaces.length; i++) { Class<?> cl = Class.forName(interfaces[i], false, classLoader); if ((cl.getModifiers() & Modifier.PUBLIC) == 0) { if (hasNonPublicInterface) { if (nonPublicLoader != cl.getClassLoader()) { throw new IllegalAccessError( "conflicting non-public interface class loaders"); } } else { nonPublicLoader = cl.getClassLoader(); hasNonPublicInterface = true; } } classObjs[i] = cl; } try { return Proxy.getProxyClass(hasNonPublicInterface ? nonPublicLoader : classLoader, classObjs); } catch (IllegalArgumentException e) { throw new ClassNotFoundException(null, e); } }
Example 32
Project: java-codes File: ProxyPattern.java View source code | 5 votes |
public static <T> T proxy(T target) { return (T) Proxy.newProxyInstance(Thread.currentThread().getContextClassLoader(), target.getClass().getInterfaces(), (proxy, method, args) -> { System.out.println("前置代理,调用方法:" + method.getName()+"()"); Object result = method.invoke(target, args); System.out.println("后置代理,方法返回:" + result); return result; }); }
Example 33
Project: iron File: ProxyConstructorFactory.java View source code | 5 votes |
private static <T> Constructor<T> createProxyConstructor(@Nullable LoadingCache<CacheKey, ClassLoader> cache, Class<T> interfaceClass, Class<?>... otherInterfaceClasses) { Class<?>[] interfaceClasses = new Class[1 + otherInterfaceClasses.length]; interfaceClasses[0] = interfaceClass; ClassLoader classLoader; if (otherInterfaceClasses.length == 0) { classLoader = interfaceClass.getClassLoader(); } else { System.arraycopy(otherInterfaceClasses, 0, interfaceClasses, 1, otherInterfaceClasses.length); List<ClassLoader> classLoaders = extractClassloaderList(interfaceClasses); if (classLoaders.size() == 1) { classLoader = classLoaders.get(0); } else if (cache != null) { classLoader = cache.getUnchecked(new CacheKey(classLoaders)); } else { classLoader = createClassLoader(classLoaders); } } Class<?> uncheckedProxyClass = Proxy.getProxyClass(classLoader, interfaceClasses); Class<T> proxyClass = interfaceClass.getClass().cast(uncheckedProxyClass); try { return proxyClass.getConstructor(InvocationHandler.class); } catch (NoSuchMethodException e) { throw new StoreException(e); } }
Example 34
Project: Elasticsearch File: FactoryProvider2.java View source code | 5 votes |
/** * @param factoryType a Java interface that defines one or more create methods. * @param producedType a concrete type that is assignable to the return types of all factory * methods. */ FactoryProvider2(TypeLiteral<F> factoryType, Key<?> producedType) { this.producedType = producedType; Errors errors = new Errors(); @SuppressWarnings("unchecked") // we imprecisely treat the class literal of T as a Class<T> Class<F> factoryRawType = (Class) factoryType.getRawType(); try { ImmutableMap.Builder<Method, Key<?>> returnTypesBuilder = ImmutableMap.builder(); ImmutableMap.Builder<Method, List<Key<?>>> paramTypesBuilder = ImmutableMap.builder(); // TODO: also grab methods from superinterfaces for (Method method : factoryRawType.getMethods()) { Key<?> returnType = getKey( factoryType.getReturnType(method), method, method.getAnnotations(), errors); returnTypesBuilder.put(method, returnType); List<TypeLiteral<?>> params = factoryType.getParameterTypes(method); Annotation[][] paramAnnotations = method.getParameterAnnotations(); int p = 0; List<Key<?>> keys = new ArrayList<>(); for (TypeLiteral<?> param : params) { Key<?> paramKey = getKey(param, method, paramAnnotations[p++], errors); keys.add(assistKey(method, paramKey, errors)); } paramTypesBuilder.put(method, Collections.unmodifiableList(keys)); } returnTypesByMethod = returnTypesBuilder.build(); paramTypes = paramTypesBuilder.build(); } catch (ErrorsException e) { throw new ConfigurationException(e.getErrors().getMessages()); } factory = factoryRawType.cast(Proxy.newProxyInstance(factoryRawType.getClassLoader(), new Class[]{factoryRawType}, this)); }
Example 35
Project: ibm-cos-sdk-java File: ClientConnectionRequestFactory.java View source code | 5 votes |
/** * Returns a wrapped instance of {@link ConnectionRequest} * to capture the necessary performance metrics. * @param orig the target instance to be wrapped */ static ConnectionRequest wrap(ConnectionRequest orig) { if (orig instanceof Wrapped) throw new IllegalArgumentException(); return (ConnectionRequest) Proxy.newProxyInstance( // https://github.com/aws/aws-sdk-java/pull/48#issuecomment-29454423 ClientConnectionRequestFactory.class.getClassLoader(), interfaces, new Handler(orig)); }
Example 36
Project: GitHub File: DistinctUntilChangedInterceptor.java View source code | 5 votes |
@SuppressWarnings("unchecked") @Nullable public static DistinctUntilChangedInvocationHandler<TiView> unwrap(@NonNull final TiView view) { try { return (DistinctUntilChangedInvocationHandler) Proxy.getInvocationHandler(view); } catch (ClassCastException e) { return null; } }
Example 37
Project: the-vigilantes File: ResultSetScannerInterceptor.java View source code | 5 votes |
public ResultSetInternalMethods postProcess(String sql, Statement interceptedStatement, ResultSetInternalMethods originalResultSet, Connection connection) throws SQLException { // requirement of anonymous class final ResultSetInternalMethods finalResultSet = originalResultSet; return (ResultSetInternalMethods) Proxy.newProxyInstance(originalResultSet.getClass().getClassLoader(), new Class[] { ResultSetInternalMethods.class }, new InvocationHandler() { public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { if ("equals".equals(method.getName())) { // Let args[0] "unwrap" to its InvocationHandler if it is a proxy. return args[0].equals(this); } Object invocationResult = method.invoke(finalResultSet, args); String methodName = method.getName(); if (invocationResult != null && invocationResult instanceof String || "getString".equals(methodName) || "getObject".equals(methodName) || "getObjectStoredProc".equals(methodName)) { Matcher matcher = ResultSetScannerInterceptor.this.regexP.matcher(invocationResult.toString()); if (matcher.matches()) { throw new SQLException("value disallowed by filter"); } } return invocationResult; } }); }
Example 38
Project: openjdk-jdk10 File: MethodUtil.java View source code | 5 votes |
/** * Test if the given class is a proxy class that implements * non-public interface. Such proxy class may be in a non-restricted * package that bypasses checkPackageAccess. */ private static boolean isNonPublicProxyClass(Class<?> cls) { String name = cls.getName(); int i = name.lastIndexOf('.'); String pkg = (i != -1) ? name.substring(0, i) : ""; return Proxy.isProxyClass(cls) && !pkg.startsWith(PROXY_PACKAGE); }
Example 39
Project: hadoop File: ProtobufRpcEngine.java View source code | 5 votes |
@Override @SuppressWarnings("unchecked") public <T> ProtocolProxy<T> getProxy(Class<T> protocol, long clientVersion, InetSocketAddress addr, UserGroupInformation ticket, Configuration conf, SocketFactory factory, int rpcTimeout, RetryPolicy connectionRetryPolicy, AtomicBoolean fallbackToSimpleAuth) throws IOException { final Invoker invoker = new Invoker(protocol, addr, ticket, conf, factory, rpcTimeout, connectionRetryPolicy, fallbackToSimpleAuth); return new ProtocolProxy<T>(protocol, (T) Proxy.newProxyInstance( protocol.getClassLoader(), new Class[]{protocol}, invoker), false); }
Example 40
Project: spanner-jdbc File: CloudSpannerXAConnection.java View source code | 5 votes |
/**** * XAConnection interface ****/ @Override public ICloudSpannerConnection getConnection() throws SQLException { if (logger.logDebug()) { debug("CloudSpannerXAConnection.getConnection called"); } Connection conn = super.getConnection(); // When we're outside an XA transaction, autocommit // is supposed to be true, per usual JDBC convention. // When an XA transaction is in progress, it should be // false. if (state == STATE_IDLE) { conn.setAutoCommit(true); } /* * Wrap the connection in a proxy to forbid application from fiddling * with transaction state directly during an XA transaction */ ConnectionHandler handler = new ConnectionHandler(conn); return (ICloudSpannerConnection) Proxy.newProxyInstance(getClass().getClassLoader(), new Class[] { Connection.class, ICloudSpannerConnection.class }, handler); }