1 /*
2 * Copyright (c) 1999, 2013, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation. Oracle designates this
8 * particular file as subject to the "Classpath" exception as provided
9 * by Oracle in the LICENSE file that accompanied this code.
10 *
11 * This code is distributed in the hope that it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 * version 2 for more details (a copy is included in the LICENSE file that
15 * accompanied this code).
16 *
17 * You should have received a copy of the GNU General Public License version
18 * 2 along with this work; if not, write to the Free Software Foundation,
19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20 *
21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22 * or visit www.oracle.com if you need additional information or have any
23 * questions.
24 */
25
26 package java.lang.reflect;
27
28 import java.lang.ref.WeakReference;
29 import java.security.AccessController;
30 import java.security.PrivilegedAction;
31 import java.util.Arrays;
32 import java.util.IdentityHashMap;
33 import java.util.Map;
34 import java.util.Objects;
35 import java.util.concurrent.atomic.AtomicLong;
36 import java.util.function.BiFunction;
37 import sun.misc.ProxyGenerator;
38 import sun.misc.VM;
39 import sun.reflect.CallerSensitive;
40 import sun.reflect.Reflection;
41 import sun.reflect.misc.ReflectUtil;
42 import sun.security.util.SecurityConstants;
43
44 /**
45 * {@code Proxy} provides static methods for creating dynamic proxy
46 * classes and instances, and it is also the superclass of all
47 * dynamic proxy classes created by those methods.
48 *
49 * <p>To create a proxy for some interface {@code Foo}:
50 * <pre>
51 * InvocationHandler handler = new MyInvocationHandler(...);
52 * Class<?> proxyClass = Proxy.getProxyClass(Foo.class.getClassLoader(), Foo.class);
53 * Foo f = (Foo) proxyClass.getConstructor(InvocationHandler.class).
54 * newInstance(handler);
55 * </pre>
56 * or more simply:
57 * <pre>
58 * Foo f = (Foo) Proxy.newProxyInstance(Foo.class.getClassLoader(),
59 * new Class<?>[] { Foo.class },
60 * handler);
61 * </pre>
62 *
63 * <p>A <i>dynamic proxy class</i> (simply referred to as a <i>proxy
64 * class</i> below) is a class that implements a list of interfaces
65 * specified at runtime when the class is created, with behavior as
66 * described below.
67 *
68 * A <i>proxy interface</i> is such an interface that is implemented
69 * by a proxy class.
70 *
71 * A <i>proxy instance</i> is an instance of a proxy class.
72 *
73 * Each proxy instance has an associated <i>invocation handler</i>
74 * object, which implements the interface {@link InvocationHandler}.
75 * A method invocation on a proxy instance through one of its proxy
76 * interfaces will be dispatched to the {@link InvocationHandler#invoke
77 * invoke} method of the instance's invocation handler, passing the proxy
78 * instance, a {@code java.lang.reflect.Method} object identifying
79 * the method that was invoked, and an array of type {@code Object}
80 * containing the arguments. The invocation handler processes the
81 * encoded method invocation as appropriate and the result that it
82 * returns will be returned as the result of the method invocation on
83 * the proxy instance.
84 *
85 * <p>A proxy class has the following properties:
86 *
87 * <ul>
88 * <li>Proxy classes are <em>public, final, and not abstract</em> if
89 * all proxy interfaces are public.</li>
90 *
91 * <li>Proxy classes are <em>non-public, final, and not abstract</em> if
92 * any of the proxy interfaces is non-public.</li>
93 *
94 * <li>The unqualified name of a proxy class is unspecified. The space
95 * of class names that begin with the string {@code "$Proxy"}
96 * should be, however, reserved for proxy classes.
97 *
98 * <li>A proxy class extends {@code java.lang.reflect.Proxy}.
99 *
100 * <li>A proxy class implements exactly the interfaces specified at its
101 * creation, in the same order.
102 *
103 * <li>If a proxy class implements a non-public interface, then it will
104 * be defined in the same package as that interface. Otherwise, the
105 * package of a proxy class is also unspecified. Note that package
106 * sealing will not prevent a proxy class from being successfully defined
107 * in a particular package at runtime, and neither will classes already
108 * defined by the same class loader and the same package with particular
109 * signers.
110 *
111 * <li>Since a proxy class implements all of the interfaces specified at
112 * its creation, invoking {@code getInterfaces} on its
113 * {@code Class} object will return an array containing the same
114 * list of interfaces (in the order specified at its creation), invoking
115 * {@code getMethods} on its {@code Class} object will return
116 * an array of {@code Method} objects that include all of the
117 * methods in those interfaces, and invoking {@code getMethod} will
118 * find methods in the proxy interfaces as would be expected.
119 *
120 * <li>The {@link Proxy#isProxyClass Proxy.isProxyClass} method will
121 * return true if it is passed a proxy class-- a class returned by
122 * {@code Proxy.getProxyClass} or the class of an object returned by
123 * {@code Proxy.newProxyInstance}-- and false otherwise.
124 *
125 * <li>The {@code java.security.ProtectionDomain} of a proxy class
126 * is the same as that of system classes loaded by the bootstrap class
127 * loader, such as {@code java.lang.Object}, because the code for a
128 * proxy class is generated by trusted system code. This protection
129 * domain will typically be granted
130 * {@code java.security.AllPermission}.
131 *
132 * <li>Each proxy class has one public constructor that takes one argument,
133 * an implementation of the interface {@link InvocationHandler}, to set
134 * the invocation handler for a proxy instance. Rather than having to use
135 * the reflection API to access the public constructor, a proxy instance
136 * can be also be created by calling the {@link Proxy#newProxyInstance
137 * Proxy.newProxyInstance} method, which combines the actions of calling
138 * {@link Proxy#getProxyClass Proxy.getProxyClass} with invoking the
139 * constructor with an invocation handler.
140 * </ul>
141 *
142 * <p>A proxy instance has the following properties:
143 *
144 * <ul>
145 * <li>Given a proxy instance {@code proxy} and one of the
146 * interfaces implemented by its proxy class {@code Foo}, the
147 * following expression will return true:
148 * <pre>
149 * {@code proxy instanceof Foo}
150 * </pre>
151 * and the following cast operation will succeed (rather than throwing
152 * a {@code ClassCastException}):
153 * <pre>
154 * {@code (Foo) proxy}
155 * </pre>
156 *
157 * <li>Each proxy instance has an associated invocation handler, the one
158 * that was passed to its constructor. The static
159 * {@link Proxy#getInvocationHandler Proxy.getInvocationHandler} method
160 * will return the invocation handler associated with the proxy instance
161 * passed as its argument.
162 *
163 * <li>An interface method invocation on a proxy instance will be
164 * encoded and dispatched to the invocation handler's {@link
165 * InvocationHandler#invoke invoke} method as described in the
166 * documentation for that method.
167 *
168 * <li>An invocation of the {@code hashCode},
169 * {@code equals}, or {@code toString} methods declared in
170 * {@code java.lang.Object} on a proxy instance will be encoded and
171 * dispatched to the invocation handler's {@code invoke} method in
172 * the same manner as interface method invocations are encoded and
173 * dispatched, as described above. The declaring class of the
174 * {@code Method} object passed to {@code invoke} will be
175 * {@code java.lang.Object}. Other public methods of a proxy
176 * instance inherited from {@code java.lang.Object} are not
177 * overridden by a proxy class, so invocations of those methods behave
178 * like they do for instances of {@code java.lang.Object}.
179 * </ul>
180 *
181 * <h3>Methods Duplicated in Multiple Proxy Interfaces</h3>
182 *
183 * <p>When two or more interfaces of a proxy class contain a method with
184 * the same name and parameter signature, the order of the proxy class's
185 * interfaces becomes significant. When such a <i>duplicate method</i>
186 * is invoked on a proxy instance, the {@code Method} object passed
187 * to the invocation handler will not necessarily be the one whose
188 * declaring class is assignable from the reference type of the interface
189 * that the proxy's method was invoked through. This limitation exists
190 * because the corresponding method implementation in the generated proxy
191 * class cannot determine which interface it was invoked through.
192 * Therefore, when a duplicate method is invoked on a proxy instance,
193 * the {@code Method} object for the method in the foremost interface
194 * that contains the method (either directly or inherited through a
195 * superinterface) in the proxy class's list of interfaces is passed to
196 * the invocation handler's {@code invoke} method, regardless of the
197 * reference type through which the method invocation occurred.
198 *
199 * <p>If a proxy interface contains a method with the same name and
200 * parameter signature as the {@code hashCode}, {@code equals},
201 * or {@code toString} methods of {@code java.lang.Object},
202 * when such a method is invoked on a proxy instance, the
203 * {@code Method} object passed to the invocation handler will have
204 * {@code java.lang.Object} as its declaring class. In other words,
205 * the public, non-final methods of {@code java.lang.Object}
206 * logically precede all of the proxy interfaces for the determination of
207 * which {@code Method} object to pass to the invocation handler.
208 *
209 * <p>Note also that when a duplicate method is dispatched to an
210 * invocation handler, the {@code invoke} method may only throw
211 * checked exception types that are assignable to one of the exception
212 * types in the {@code throws} clause of the method in <i>all</i> of
213 * the proxy interfaces that it can be invoked through. If the
214 * {@code invoke} method throws a checked exception that is not
215 * assignable to any of the exception types declared by the method in one
216 * of the proxy interfaces that it can be invoked through, then an
217 * unchecked {@code UndeclaredThrowableException} will be thrown by
218 * the invocation on the proxy instance. This restriction means that not
219 * all of the exception types returned by invoking
220 * {@code getExceptionTypes} on the {@code Method} object
221 * passed to the {@code invoke} method can necessarily be thrown
222 * successfully by the {@code invoke} method.
223 *
224 * @author Peter Jones
225 * @see InvocationHandler
226 * @since 1.3
227 */
228 public class Proxy implements java.io.Serializable {
229
230 private static final long serialVersionUID = -2222568056686623797L;
231
232 /** parameter types of a proxy class constructor */
233 private static final Class<?>[] constructorParams =
234 { InvocationHandler.class };
235
236 /**
237 * a cache of proxy classes
238 */
239 private static final WeakCache<ClassLoader, Class<?>[], Class<?>>
240 proxyClassCache = new WeakCache<>(new KeyFactory(), new ProxyClassFactory());
241
242 /**
243 * the invocation handler for this proxy instance.
244 * @serial
245 */
246 protected InvocationHandler h;
247
248 /**
249 * Prohibits instantiation.
250 */
251 private Proxy() {
252 }
253
254 /**
255 * Constructs a new {@code Proxy} instance from a subclass
256 * (typically, a dynamic proxy class) with the specified value
257 * for its invocation handler.
258 *
259 * @param h the invocation handler for this proxy instance
260 *
261 * @throws NullPointerException if the given invocation handler, {@code h},
262 * is {@code null}.
263 */
264 protected Proxy(InvocationHandler h) {
265 Objects.requireNonNull(h);
266 this.h = h;
267 }
268
269 /**
270 * Returns the {@code java.lang.Class} object for a proxy class
271 * given a class loader and an array of interfaces. The proxy class
272 * will be defined by the specified class loader and will implement
273 * all of the supplied interfaces. If any of the given interfaces
274 * is non-public, the proxy class will be non-public. If a proxy class
275 * for the same permutation of interfaces has already been defined by the
276 * class loader, then the existing proxy class will be returned; otherwise,
277 * a proxy class for those interfaces will be generated dynamically
278 * and defined by the class loader.
279 *
280 * <p>There are several restrictions on the parameters that may be
281 * passed to {@code Proxy.getProxyClass}:
282 *
283 * <ul>
284 * <li>All of the {@code Class} objects in the
285 * {@code interfaces} array must represent interfaces, not
286 * classes or primitive types.
287 *
288 * <li>No two elements in the {@code interfaces} array may
289 * refer to identical {@code Class} objects.
290 *
291 * <li>All of the interface types must be visible by name through the
292 * specified class loader. In other words, for class loader
293 * {@code cl} and every interface {@code i}, the following
294 * expression must be true:
295 * <pre>
296 * Class.forName(i.getName(), false, cl) == i
297 * </pre>
298 *
299 * <li>All non-public interfaces must be in the same package;
300 * otherwise, it would not be possible for the proxy class to
301 * implement all of the interfaces, regardless of what package it is
302 * defined in.
303 *
304 * <li>For any set of member methods of the specified interfaces
305 * that have the same signature:
306 * <ul>
307 * <li>If the return type of any of the methods is a primitive
308 * type or void, then all of the methods must have that same
309 * return type.
310 * <li>Otherwise, one of the methods must have a return type that
311 * is assignable to all of the return types of the rest of the
312 * methods.
313 * </ul>
314 *
315 * <li>The resulting proxy class must not exceed any limits imposed
316 * on classes by the virtual machine. For example, the VM may limit
317 * the number of interfaces that a class may implement to 65535; in
318 * that case, the size of the {@code interfaces} array must not
319 * exceed 65535.
320 * </ul>
321 *
322 * <p>If any of these restrictions are violated,
323 * {@code Proxy.getProxyClass} will throw an
324 * {@code IllegalArgumentException}. If the {@code interfaces}
325 * array argument or any of its elements are {@code null}, a
326 * {@code NullPointerException} will be thrown.
327 *
328 * <p>Note that the order of the specified proxy interfaces is
329 * significant: two requests for a proxy class with the same combination
330 * of interfaces but in a different order will result in two distinct
331 * proxy classes.
332 *
333 * @param loader the class loader to define the proxy class
334 * @param interfaces the list of interfaces for the proxy class
335 * to implement
336 * @return a proxy class that is defined in the specified class loader
337 * and that implements the specified interfaces
338 * @throws IllegalArgumentException if any of the restrictions on the
339 * parameters that may be passed to {@code getProxyClass}
340 * are violated
341 * @throws SecurityException if a security manager, <em>s</em>, is present
342 * and any of the following conditions is met:
343 * <ul>
344 * <li> the given {@code loader} is {@code null} and
345 * the caller's class loader is not {@code null} and the
346 * invocation of {@link SecurityManager#checkPermission
347 * s.checkPermission} with
348 * {@code RuntimePermission("getClassLoader")} permission
349 * denies access.</li>
350 * <li> for each proxy interface, {@code intf},
351 * the caller's class loader is not the same as or an
352 * ancestor of the class loader for {@code intf} and
353 * invocation of {@link SecurityManager#checkPackageAccess
354 * s.checkPackageAccess()} denies access to {@code intf}.</li>
355 * </ul>
356
357 * @throws NullPointerException if the {@code interfaces} array
358 * argument or any of its elements are {@code null}
359 */
360 @CallerSensitive
361 public static Class<?> getProxyClass(ClassLoader loader,
362 Class<?>... interfaces)
363 throws IllegalArgumentException
364 {
365 final Class<?>[] intfs = interfaces.clone();
366 final SecurityManager sm = System.getSecurityManager();
367 if (sm != null) {
368 checkProxyAccess(Reflection.getCallerClass(), loader, intfs);
369 }
370
371 return getProxyClass0(loader, intfs);
372 }
373
374 /*
375 * Check permissions required to create a Proxy class.
376 *
377 * To define a proxy class, it performs the access checks as in
378 * Class.forName (VM will invoke ClassLoader.checkPackageAccess):
379 * 1. "getClassLoader" permission check if loader == null
380 * 2. checkPackageAccess on the interfaces it implements
381 *
382 * To get a constructor and new instance of a proxy class, it performs
383 * the package access check on the interfaces it implements
384 * as in Class.getConstructor.
385 *
386 * If an interface is non-public, the proxy class must be defined by
387 * the defining loader of the interface. If the caller's class loader
388 * is not the same as the defining loader of the interface, the VM
389 * will throw IllegalAccessError when the generated proxy class is
390 * being defined via the defineClass0 method.
391 */
392 private static void checkProxyAccess(Class<?> caller,
393 ClassLoader loader,
394 Class<?>... interfaces)
395 {
396 SecurityManager sm = System.getSecurityManager();
397 if (sm != null) {
398 ClassLoader ccl = caller.getClassLoader();
399 if (VM.isSystemDomainLoader(loader) && !VM.isSystemDomainLoader(ccl)) {
400 sm.checkPermission(SecurityConstants.GET_CLASSLOADER_PERMISSION);
401 }
402 ReflectUtil.checkProxyPackageAccess(ccl, interfaces);
403 }
404 }
405
406 /**
407 * Generate a proxy class. Must call the checkProxyAccess method
408 * to perform permission checks before calling this.
409 */
410 private static Class<?> getProxyClass0(ClassLoader loader,
411 Class<?>... interfaces) {
412 if (interfaces.length > 65535) {
413 throw new IllegalArgumentException("interface limit exceeded");
414 }
415
416 // If the proxy class defined by the given loader implementing
417 // the given interfaces exists, this will simply return the cached copy;
418 // otherwise, it will create the proxy class via the ProxyClassFactory
419 return proxyClassCache.get(loader, interfaces);
420 }
421
422 /*
423 * a key used for proxy class with 0 implemented interfaces
424 */
425 private static final Object key0 = new Object();
426
427 /*
428 * Key1 and Key2 are optimized for the common use of dynamic proxies
429 * that implement 1 or 2 interfaces.
430 */
431
432 /*
433 * a key used for proxy class with 1 implemented interface
434 */
435 private static final class Key1 extends WeakReference<Class<?>> {
436 private final int hash;
437
438 Key1(Class<?> intf) {
439 super(intf);
440 this.hash = intf.hashCode();
441 }
442
443 @Override
444 public int hashCode() {
445 return hash;
446 }
447
448 @Override
449 public boolean equals(Object obj) {
450 Class<?> intf;
451 return this == obj ||
452 obj != null &&
453 obj.getClass() == Key1.class &&
454 (intf = get()) != null &&
455 intf == ((Key1) obj).get();
456 }
457 }
458
459 /*
460 * a key used for proxy class with 2 implemented interfaces
461 */
462 private static final class Key2 extends WeakReference<Class<?>> {
463 private final int hash;
464 private final WeakReference<Class<?>> ref2;
465
466 Key2(Class<?> intf1, Class<?> intf2) {
467 super(intf1);
468 hash = 31 * intf1.hashCode() + intf2.hashCode();
469 ref2 = new WeakReference<>(intf2);
470 }
471
472 @Override
473 public int hashCode() {
474 return hash;
475 }
476
477 @Override
478 public boolean equals(Object obj) {
479 Class<?> intf1, intf2;
480 return this == obj ||
481 obj != null &&
482 obj.getClass() == Key2.class &&
483 (intf1 = get()) != null &&
484 intf1 == ((Key2) obj).get() &&
485 (intf2 = ref2.get()) != null &&
486 intf2 == ((Key2) obj).ref2.get();
487 }
488 }
489
490 /*
491 * a key used for proxy class with any number of implemented interfaces
492 * (used here for 3 or more only)
493 */
494 private static final class KeyX {
495 private final int hash;
496 private final WeakReference<Class<?>>[] refs;
497
498 @SuppressWarnings("unchecked")
499 KeyX(Class<?>[] interfaces) {
500 hash = Arrays.hashCode(interfaces);
501 refs = (WeakReference<Class<?>>[])new WeakReference<?>[interfaces.length];
502 for (int i = 0; i < interfaces.length; i++) {
503 refs[i] = new WeakReference<>(interfaces[i]);
504 }
505 }
506
507 @Override
508 public int hashCode() {
509 return hash;
510 }
511
512 @Override
513 public boolean equals(Object obj) {
514 return this == obj ||
515 obj != null &&
516 obj.getClass() == KeyX.class &&
517 equals(refs, ((KeyX) obj).refs);
518 }
519
520 private static boolean equals(WeakReference<Class<?>>[] refs1,
521 WeakReference<Class<?>>[] refs2) {
522 if (refs1.length != refs2.length) {
523 return false;
524 }
525 for (int i = 0; i < refs1.length; i++) {
526 Class<?> intf = refs1[i].get();
527 if (intf == null || intf != refs2[i].get()) {
528 return false;
529 }
530 }
531 return true;
532 }
533 }
534
535 /**
536 * A function that maps an array of interfaces to an optimal key where
537 * Class objects representing interfaces are weakly referenced.
538 */
539 private static final class KeyFactory
540 implements BiFunction<ClassLoader, Class<?>[], Object>
541 {
542 @Override
543 public Object apply(ClassLoader classLoader, Class<?>[] interfaces) {
544 switch (interfaces.length) {
545 case 1: return new Key1(interfaces[0]); // the most frequent
546 case 2: return new Key2(interfaces[0], interfaces[1]);
547 case 0: return key0;
548 default: return new KeyX(interfaces);
549 }
550 }
551 }
552
553 /**
554 * A factory function that generates, defines and returns the proxy class given
555 * the ClassLoader and array of interfaces.
556 */
557 private static final class ProxyClassFactory
558 implements BiFunction<ClassLoader, Class<?>[], Class<?>>
559 {
560 // prefix for all proxy class names
561 private static final String proxyClassNamePrefix = "$Proxy";
562
563 // next number to use for generation of unique proxy class names
564 private static final AtomicLong nextUniqueNumber = new AtomicLong();
565
566 @Override
567 public Class<?> apply(ClassLoader loader, Class<?>[] interfaces) {
568
569 Map<Class<?>, Boolean> interfaceSet = new IdentityHashMap<>(interfaces.length);
570 for (Class<?> intf : interfaces) {
571 /*
572 * Verify that the class loader resolves the name of this
573 * interface to the same Class object.
574 */
575 Class<?> interfaceClass = null;
576 try {
577 interfaceClass = Class.forName(intf.getName(), false, loader);
578 } catch (ClassNotFoundException e) {
579 }
580 if (interfaceClass != intf) {
581 throw new IllegalArgumentException(
582 intf + " is not visible from class loader");
583 }
584 /*
585 * Verify that the Class object actually represents an
586 * interface.
587 */
588 if (!interfaceClass.isInterface()) {
589 throw new IllegalArgumentException(
590 interfaceClass.getName() + " is not an interface");
591 }
592 /*
593 * Verify that this interface is not a duplicate.
594 */
595 if (interfaceSet.put(interfaceClass, Boolean.TRUE) != null) {
596 throw new IllegalArgumentException(
597 "repeated interface: " + interfaceClass.getName());
598 }
599 }
600
601 String proxyPkg = null; // package to define proxy class in
602 int accessFlags = Modifier.PUBLIC | Modifier.FINAL;
603
604 /*
605 * Record the package of a non-public proxy interface so that the
606 * proxy class will be defined in the same package. Verify that
607 * all non-public proxy interfaces are in the same package.
608 */
609 for (Class<?> intf : interfaces) {
610 int flags = intf.getModifiers();
611 if (!Modifier.isPublic(flags)) {
612 accessFlags = Modifier.FINAL;
613 String name = intf.getName();
614 int n = name.lastIndexOf('.');
615 String pkg = ((n == -1) ? "" : name.substring(0, n + 1));
616 if (proxyPkg == null) {
617 proxyPkg = pkg;
618 } else if (!pkg.equals(proxyPkg)) {
619 throw new IllegalArgumentException(
620 "non-public interfaces from different packages");
621 }
622 }
623 }
624
625 if (proxyPkg == null) {
626 // if no non-public proxy interfaces, use com.sun.proxy package
627 proxyPkg = ReflectUtil.PROXY_PACKAGE + ".";
628 }
629
630 /*
631 * Choose a name for the proxy class to generate.
632 */
633 long num = nextUniqueNumber.getAndIncrement();
634 String proxyName = proxyPkg + proxyClassNamePrefix + num;
635
636 /*
637 * Generate the specified proxy class.
638 */
639 byte[] proxyClassFile = ProxyGenerator.generateProxyClass(
640 proxyName, interfaces, accessFlags);
641 try {
642 return defineClass0(loader, proxyName,
643 proxyClassFile, 0, proxyClassFile.length);
644 } catch (ClassFormatError e) {
645 /*
646 * A ClassFormatError here means that (barring bugs in the
647 * proxy class generation code) there was some other
648 * invalid aspect of the arguments supplied to the proxy
649 * class creation (such as virtual machine limitations
650 * exceeded).
651 */
652 throw new IllegalArgumentException(e.toString());
653 }
654 }
655 }
656
657 /**
658 * Returns an instance of a proxy class for the specified interfaces
659 * that dispatches method invocations to the specified invocation
660 * handler.
661 *
662 * <p>{@code Proxy.newProxyInstance} throws
663 * {@code IllegalArgumentException} for the same reasons that
664 * {@code Proxy.getProxyClass} does.
665 *
666 * @param loader the class loader to define the proxy class
667 * @param interfaces the list of interfaces for the proxy class
668 * to implement
669 * @param h the invocation handler to dispatch method invocations to
670 * @return a proxy instance with the specified invocation handler of a
671 * proxy class that is defined by the specified class loader
672 * and that implements the specified interfaces
673 * @throws IllegalArgumentException if any of the restrictions on the
674 * parameters that may be passed to {@code getProxyClass}
675 * are violated
676 * @throws SecurityException if a security manager, <em>s</em>, is present
677 * and any of the following conditions is met:
678 * <ul>
679 * <li> the given {@code loader} is {@code null} and
680 * the caller's class loader is not {@code null} and the
681 * invocation of {@link SecurityManager#checkPermission
682 * s.checkPermission} with
683 * {@code RuntimePermission("getClassLoader")} permission
684 * denies access;</li>
685 * <li> for each proxy interface, {@code intf},
686 * the caller's class loader is not the same as or an
687 * ancestor of the class loader for {@code intf} and
688 * invocation of {@link SecurityManager#checkPackageAccess
689 * s.checkPackageAccess()} denies access to {@code intf};</li>
690 * <li> any of the given proxy interfaces is non-public and the
691 * caller class is not in the same {@linkplain Package runtime package}
692 * as the non-public interface and the invocation of
693 * {@link SecurityManager#checkPermission s.checkPermission} with
694 * {@code ReflectPermission("newProxyInPackage.{package name}")}
695 * permission denies access.</li>
696 * </ul>
697 * @throws NullPointerException if the {@code interfaces} array
698 * argument or any of its elements are {@code null}, or
699 * if the invocation handler, {@code h}, is
700 * {@code null}
701 */
702 @CallerSensitive
703 public static Object newProxyInstance(ClassLoader loader,
704 Class<?>[] interfaces,
705 InvocationHandler h)
706 throws IllegalArgumentException
707 {
708 Objects.requireNonNull(h);
709
710 final Class<?>[] intfs = interfaces.clone();
711 final SecurityManager sm = System.getSecurityManager();
712 if (sm != null) {
713 checkProxyAccess(Reflection.getCallerClass(), loader, intfs);
714 }
715
716 /*
717 * Look up or generate the designated proxy class.
718 */
719 Class<?> cl = getProxyClass0(loader, intfs);
720
721 /*
722 * Invoke its constructor with the designated invocation handler.
723 */
724 try {
725 if (sm != null) {
726 checkNewProxyPermission(Reflection.getCallerClass(), cl);
727 }
728
729 final Constructor<?> cons = cl.getConstructor(constructorParams);
730 if (!Modifier.isPublic(cl.getModifiers())) {
731 AccessController.doPrivileged(new PrivilegedAction<>() {
732 public Void run() {
733 cons.setAccessible(true);
734 return null;
735 }
736 });
737 }
738 return cons.newInstance(new Object[]{h});
739 } catch (IllegalAccessException | InstantiationException | NoSuchMethodException e) {
740 throw new InternalError(e.toString(), e);
741 } catch (InvocationTargetException e) {
742 Throwable t = e.getCause();
743 if (t instanceof RuntimeException) {
744 throw (RuntimeException) t;
745 } else {
746 throw new InternalError(t.toString(), t);
747 }
748 }
749 }
750
751 private static void checkNewProxyPermission(Class<?> caller, Class<?> proxyClass) {
752 SecurityManager sm = System.getSecurityManager();
753 if (sm != null) {
754 if (ReflectUtil.isNonPublicProxyClass(proxyClass)) {
755 ClassLoader ccl = caller.getClassLoader();
756 ClassLoader pcl = proxyClass.getClassLoader();
757
758 // do permission check if the caller is in a different runtime package
759 // of the proxy class
760 int n = proxyClass.getName().lastIndexOf('.');
761 String pkg = (n == -1) ? "" : proxyClass.getName().substring(0, n);
762
763 n = caller.getName().lastIndexOf('.');
764 String callerPkg = (n == -1) ? "" : caller.getName().substring(0, n);
765
766 if (pcl != ccl || !pkg.equals(callerPkg)) {
767 sm.checkPermission(new ReflectPermission("newProxyInPackage." + pkg));
768 }
769 }
770 }
771 }
772
773 /**
774 * Returns true if and only if the specified class was dynamically
775 * generated to be a proxy class using the {@code getProxyClass}
776 * method or the {@code newProxyInstance} method.
777 *
778 * <p>The reliability of this method is important for the ability
779 * to use it to make security decisions, so its implementation should
780 * not just test if the class in question extends {@code Proxy}.
781 *
782 * @param cl the class to test
783 * @return {@code true} if the class is a proxy class and
784 * {@code false} otherwise
785 * @throws NullPointerException if {@code cl} is {@code null}
786 */
787 public static boolean isProxyClass(Class<?> cl) {
788 return Proxy.class.isAssignableFrom(cl) && proxyClassCache.containsValue(cl);
789 }
790
791 /**
792 * Returns the invocation handler for the specified proxy instance.
793 *
794 * @param proxy the proxy instance to return the invocation handler for
795 * @return the invocation handler for the proxy instance
796 * @throws IllegalArgumentException if the argument is not a
797 * proxy instance
798 * @throws SecurityException if a security manager, <em>s</em>, is present
799 * and the caller's class loader is not the same as or an
800 * ancestor of the class loader for the invocation handler
801 * and invocation of {@link SecurityManager#checkPackageAccess
802 * s.checkPackageAccess()} denies access to the invocation
803 * handler's class.
804 */
805 @CallerSensitive
806 public static InvocationHandler getInvocationHandler(Object proxy)
807 throws IllegalArgumentException
808 {
809 /*
810 * Verify that the object is actually a proxy instance.
811 */
812 if (!isProxyClass(proxy.getClass())) {
813 throw new IllegalArgumentException("not a proxy instance");
814 }
815
816 final Proxy p = (Proxy) proxy;
817 final InvocationHandler ih = p.h;
818 if (System.getSecurityManager() != null) {
819 Class<?> ihClass = ih.getClass();
820 Class<?> caller = Reflection.getCallerClass();
821 if (ReflectUtil.needsPackageAccessCheck(caller.getClassLoader(),
822 ihClass.getClassLoader()))
823 {
824 ReflectUtil.checkPackageAccess(ihClass);
825 }
826 }
827
828 return ih;
829 }
830
831 private static native Class<?> defineClass0(ClassLoader loader, String name,
832 byte[] b, int off, int len);
833 }