Find Usages Diff Raw Download HTML Widget Stack Overflow Q&A
Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
1. Examples of GoF Design Patterns
I am learning GoF Java Design Patterns and I want to see some real life examples of them. Can you guys point to some good usage of these Design Patterns.(preferably in Java's core libraries). Thank you
2. Java Delegates?
Does the Java language have delegate features, similar to how C# has support for delegates?
3. Why do most system architects insist on first coding to an interface?
I'm not asking this question out of spite, but I really want to know, because I might be missing something. Almost every Java book I read talks about using the interface as a way to share state and behavior between objects that when first "constructed" did not seem to share a relationship. However, whenever I see architects design an application, the first thing they do is start coding to an in...
4. Java Reflection: Create an implementing class
Class someInterface = Class.fromName("some.package.SomeInterface"); How do I now create a new class that implements someInterface? I need to create a new class, and pass it to a function that needs a SomeInterface as an argument.
5. Simulating duck typing in Java
The problem: I'd like to be able to generically access in Java any property/field on a Java ojbect similarly to how a dynamic language (think Groovy, JavaScript) would. I won't know at the time I'm writing this plumbing code what type of object it is or what the property/field name will be. But I will know the property/field name when I go to use it. My current solution: So far I've written a ...
6. How to best execute a set of methods even if an exception happens
In a current Java project we have code similar to the following example: try { doSomeThing(anObject); } catch (SameException e) { // Do nothing or log, but don't abort current method. } try { doOtherThing(anObject); } catch (SameException e) { // Do nothing or log, but don't abort current method. } // ... some more calls to different method ... try { finallyDoYetSomethin...
7. Alternatives to java.lang.reflect.Proxy for creating proxies of abstract classes (rather than interfaces)
According to the documentation: [java.lang.reflect.]Proxy provides static methods for creating dynamic proxy classes and instances, and it is also the superclass of all dynamic proxy classes created by those methods. The newProxyMethod method (responsible for generating the dynamic proxies) has the following signature: public static Object newProxyInstance(ClassLoader loader, ...
8. Equivalent of #define in Java?
I'm writing a library that needs to have some code if a particular library is included. Since this code is scattered all around the project, it would be nice if users didn't have to comment/uncomment everything themselves. In C, this would be easy enough with a #define in a header, and then code blocks surrounded with #ifdefs. Of course, Java doesn't have the C preprocessor... To clarify - ...
9. How do I build a Java project with Java 6 against Java 1.4 libraries?
I've got a project that was originally written for Java 1.4, but I only have Java 6 on my Mac and I cannot install Java 1.4. Normally, I'd use a line like this to compile: javac -source=1.4 -target=1.4 MyClass.java However, MyClass.java implements the java.sql.ResultSet interface, which added several new methods in Java 6, so I get compile errors like: MyClass is not abstract and does not ...
10. What's an example of duck typing in Java?
I just recently heard of duck typing and I read the Wikipedia article about it, but I'm having a hard time translating the examples into Java, which would really help my understanding. Would anyone be able to give a clear example of duck typing in Java and how I might possibly use it?
11. What are Dynamic Proxy classes and why would I use one?
What is a use case for using a dynamic proxy? How do they relate to bytecode generation and reflection? Any recommended reading?
12. Method missing in Java or PHP
I have been looking at different languages to get started. I found method_missing in Ruby very interesting but was not able to find the same in Java and PHP. Is there something like method_missing in Java or PHP ?
13. Java Interface-Implementation Pair
Is there a preferred method or style of creating a default implementation for interface methods? Suppose I had a commonly used interface where in 90% of the cases the functionality I wanted was identical. My first instinct is to create a concrete class with static methods. I would then delegate the functionality to the static methods when I want the default functionality. Here is a simple ex...
14. PHP __call equivalent for java
Is there a Java equivalent for the __call of PHP? It would make sense to me if that's not the case, because it would probably result in compiler errors. From the PHP manual on magic methods: __call() is triggered when invoking inaccessible methods in an object context.
15. Implementing interfaces after the fact
I think, the following can't be done in Java. But I would be happy to learn how to implement something that resembles it. Suppose we have a class C, that is already used in compiled code. (We can neither change that code nor the original definition of C). Suppose further there is interesting code that could be re-used, if only C would implement interface I. It is, in fact, more or less trivia...
16. Type-safe configuration read/write library for Java?
Is there a good configuration library for Java which will allow me to read settings in a type-safe way? For example by taking my crafted IConfiguration interface with getters and setters declared and allowing me to read/write configuration via it. It's a bit boring to read settings using properties.getProperty("group.setting") and then cast it to needed type. Apache commons configuration allow...
17. Java method missing (ala Ruby) for decorating?
Is there any technique available in Java for intercepting messages (method calls) like the method_missing technique in Ruby? This would allow coding decorators and proxies very easily, like in Ruby: :Client p:Proxy im:Implementation ------- ---------- ----------------- p.foo() -------> method_missing() do_somethin...
18. Overriding a method in an instantiated Java object
I would like to override a method in an object that's handed to me by a factory that I have little control over. My specific problem is that I want to override the getInputStream and getOutputStream of a Socket object to perform wire logging; however the generic problem is as follows: public class Foo { public Bar doBar() { // Some activity } } Where I'd like to take an insta...
19. Extending or adding new classes at runtime in Java
Is there a way to add (or extend existing) classes at runtime in java. I'm stuck on a problem, in which I have to extend an existing class at runtime and add this to the classpath, so that this new class get picked up. thanks,
20. How to create an interface at Runtime
Assuming I have a class like public class FooImpl { public void bar(){}; } Is there a way to create its interface at runtime? e.g. public interface Foo { public void bar(); } I have been looking into Javasssist and the truth is it's reflection that I'm interested in using the interface for (as Esko Luontola and Yishai stated) So I want an interface that specifies a subset of the...
21. Making a JTable cell editable - but *not* by double clicking
I am trying to add a column to a JTable with the following behaviour (similar to Windows Explorer and similar shells): The cell can be clicked once to select it, as usual. The cell can be double-clicked to perform a separate action (launching an external program.) The cell value (a string) can still be edited, by single-clicking a second time (after a pause) or by pressing F2 when the cell is... 
1
  /*
2
   * Copyright 1999-2006 Sun Microsystems, Inc.  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.  Sun designates this
8
   * particular file as subject to the "Classpath" exception as provided
9
   * by Sun 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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
22
  * CA 95054 USA or visit www.sun.com if you need additional information or
23
  * have any questions.
24
  */
25
 
26
 package java.lang.reflect;
27
 
34
 import java.util.Map;
35
 import java.util.Set;
Proxy provides static methods for creating dynamic proxy classes and instances, and it is also the superclass of all dynamic proxy classes created by those methods.

To create a proxy for some interface Foo: 

     InvocationHandler handler = new MyInvocationHandler(...);
     Class proxyClass = Proxy.getProxyClass(
         Foo.class.getClassLoader(), new Class[] { Foo.class });
     Foo f = (Foo) proxyClass.
         getConstructor(new Class[] { InvocationHandler.class }).
         newInstance(new Object[] { handler });
or more simply: 
     Foo f = (Foo) Proxy.newProxyInstance(Foo.class.getClassLoader(),
                                          new Class[] { Foo.class },
                                          handler);

A dynamic proxy class (simply referred to as a proxy class below) is a class that implements a list of interfaces specified at runtime when the class is created, with behavior as described below. A proxy interface is such an interface that is implemented by a proxy class. A proxy instance is an instance of a proxy class. Each proxy instance has an associated invocation handler object, which implements the interface InvocationHandler. A method invocation on a proxy instance through one of its proxy interfaces will be dispatched to the invoke method of the instance's invocation handler, passing the proxy instance, a java.lang.reflect.Method object identifying the method that was invoked, and an array of type Object containing the arguments. The invocation handler processes the encoded method invocation as appropriate and the result that it returns will be returned as the result of the method invocation on the proxy instance.

A proxy class has the following properties:

  • Proxy classes are public, final, and not abstract.
  • The unqualified name of a proxy class is unspecified. The space of class names that begin with the string "$Proxy" should be, however, reserved for proxy classes.
  • A proxy class extends java.lang.reflect.Proxy.
  • A proxy class implements exactly the interfaces specified at its creation, in the same order.
  • If a proxy class implements a non-public interface, then it will be defined in the same package as that interface. Otherwise, the package of a proxy class is also unspecified. Note that package sealing will not prevent a proxy class from being successfully defined in a particular package at runtime, and neither will classes already defined by the same class loader and the same package with particular signers.
  • Since a proxy class implements all of the interfaces specified at its creation, invoking getInterfaces on its Class object will return an array containing the same list of interfaces (in the order specified at its creation), invoking getMethods on its Class object will return an array of Method objects that include all of the methods in those interfaces, and invoking getMethod will find methods in the proxy interfaces as would be expected.
  • The Proxy.isProxyClass method will return true if it is passed a proxy class-- a class returned by Proxy.getProxyClass or the class of an object returned by Proxy.newProxyInstance-- and false otherwise.
  • The java.security.ProtectionDomain of a proxy class is the same as that of system classes loaded by the bootstrap class loader, such as java.lang.Object, because the code for a proxy class is generated by trusted system code. This protection domain will typically be granted java.security.AllPermission.
  • Each proxy class has one public constructor that takes one argument, an implementation of the interface InvocationHandler, to set the invocation handler for a proxy instance. Rather than having to use the reflection API to access the public constructor, a proxy instance can be also be created by calling the Proxy.newProxyInstance method, which combines the actions of calling Proxy.getProxyClass with invoking the constructor with an invocation handler.

A proxy instance has the following properties:

  • Given a proxy instance proxy and one of the interfaces implemented by its proxy class Foo, the following expression will return true: 
         proxy instanceof Foo
    and the following cast operation will succeed (rather than throwing a ClassCastException): 
         (Foo) proxy
  • Each proxy instance has an associated invocation handler, the one that was passed to its constructor. The static Proxy.getInvocationHandler method will return the invocation handler associated with the proxy instance passed as its argument.
  • An interface method invocation on a proxy instance will be encoded and dispatched to the invocation handler's InvocationHandler.invoke(java.lang.Object,java.lang.reflect.Method,java.lang.Object[]) method as described in the documentation for that method.
  • An invocation of the hashCode, equals, or toString methods declared in java.lang.Object on a proxy instance will be encoded and dispatched to the invocation handler's invoke method in the same manner as interface method invocations are encoded and dispatched, as described above. The declaring class of the Method object passed to invoke will be java.lang.Object. Other public methods of a proxy instance inherited from java.lang.Object are not overridden by a proxy class, so invocations of those methods behave like they do for instances of java.lang.Object.

Methods Duplicated in Multiple Proxy Interfaces

When two or more interfaces of a proxy class contain a method with the same name and parameter signature, the order of the proxy class's interfaces becomes significant. When such a duplicate method is invoked on a proxy instance, the Method object passed to the invocation handler will not necessarily be the one whose declaring class is assignable from the reference type of the interface that the proxy's method was invoked through. This limitation exists because the corresponding method implementation in the generated proxy class cannot determine which interface it was invoked through. Therefore, when a duplicate method is invoked on a proxy instance, the Method object for the method in the foremost interface that contains the method (either directly or inherited through a superinterface) in the proxy class's list of interfaces is passed to the invocation handler's invoke method, regardless of the reference type through which the method invocation occurred.

If a proxy interface contains a method with the same name and parameter signature as the hashCode, equals, or toString methods of java.lang.Object, when such a method is invoked on a proxy instance, the Method object passed to the invocation handler will have java.lang.Object as its declaring class. In other words, the public, non-final methods of java.lang.Object logically precede all of the proxy interfaces for the determination of which Method object to pass to the invocation handler.

Note also that when a duplicate method is dispatched to an invocation handler, the invoke method may only throw checked exception types that are assignable to one of the exception types in the throws clause of the method in all of the proxy interfaces that it can be invoked through. If the invoke method throws a checked exception that is not assignable to any of the exception types declared by the method in one of the proxy interfaces that it can be invoked through, then an unchecked UndeclaredThrowableException will be thrown by the invocation on the proxy instance. This restriction means that not all of the exception types returned by invoking getExceptionTypes on the Method object passed to the invoke method can necessarily be thrown successfully by the invoke method.

Author(s):
Peter Jones
Since:
1.3
See also:
InvocationHandler
221
public class Proxy implements java.io.Serializable {
223
    private static final long serialVersionUID = -2222568056686623797L;

    
prefix for all proxy class names
226
    private final static String proxyClassNamePrefix = "$Proxy";

    
parameter types of a proxy class constructor
229
    private final static Class[] constructorParams =
230
        { InvocationHandler.class };

    
maps a class loader to the proxy class cache for that loader
233
    private static Map loaderToCache = new WeakHashMap();

    
marks that a particular proxy class is currently being generated
236
    private static Object pendingGenerationMarker = new Object();

    
next number to use for generation of unique proxy class names
239
    private static long nextUniqueNumber = 0;
240
    private static Object nextUniqueNumberLock = new Object();

    
set of all generated proxy classes, for isProxyClass implementation
243
    private static Map proxyClasses =
244
        Collections.synchronizedMap(new WeakHashMap());

    
the invocation handler for this proxy instance.

Serial:
250
    protected InvocationHandler h;

    
Prohibits instantiation. 
255
    private Proxy() {
256
    }

    
Constructs a new Proxy instance from a subclass (typically, a dynamic proxy class) with the specified value for its invocation handler.

Parameters:
h the invocation handler for this proxy instance
265
    protected Proxy(InvocationHandler h) {
266
        this. = h;
267
    }

    
Returns the java.lang.Class object for a proxy class given a class loader and an array of interfaces. The proxy class will be defined by the specified class loader and will implement all of the supplied interfaces. If a proxy class for the same permutation of interfaces has already been defined by the class loader, then the existing proxy class will be returned; otherwise, a proxy class for those interfaces will be generated dynamically and defined by the class loader.

There are several restrictions on the parameters that may be passed to Proxy.getProxyClass:

  • All of the Class objects in the interfaces array must represent interfaces, not classes or primitive types.
  • No two elements in the interfaces array may refer to identical Class objects.
  • All of the interface types must be visible by name through the specified class loader. In other words, for class loader cl and every interface i, the following expression must be true: 
         Class.forName(i.getName(), false, cl) == i
  • All non-public interfaces must be in the same package; otherwise, it would not be possible for the proxy class to implement all of the interfaces, regardless of what package it is defined in.
  • For any set of member methods of the specified interfaces that have the same signature:
    • If the return type of any of the methods is a primitive type or void, then all of the methods must have that same return type.
    • Otherwise, one of the methods must have a return type that is assignable to all of the return types of the rest of the methods.
  • The resulting proxy class must not exceed any limits imposed on classes by the virtual machine. For example, the VM may limit the number of interfaces that a class may implement to 65535; in that case, the size of the interfaces array must not exceed 65535.

If any of these restrictions are violated, Proxy.getProxyClass will throw an IllegalArgumentException. If the interfaces array argument or any of its elements are null, a NullPointerException will be thrown.

Note that the order of the specified proxy interfaces is significant: two requests for a proxy class with the same combination of interfaces but in a different order will result in two distinct proxy classes.

Parameters:
loader the class loader to define the proxy class
interfaces the list of interfaces for the proxy class to implement
Returns:
a proxy class that is defined in the specified class loader and that implements the specified interfaces
Throws:
java.lang.IllegalArgumentException if any of the restrictions on the parameters that may be passed to getProxyClass are violated
java.lang.NullPointerException if the interfaces array argument or any of its elements are null
343
    public static Class<?> getProxyClass(ClassLoader loader,
344
                                         Class<?>... interfaces)
345
        throws IllegalArgumentException
346
    {
347
        if (interfaces.length > 65535) {
348
            throw new IllegalArgumentException("interface limit exceeded");
349
        }
351
        Class proxyClass = null;
353
        /* collect interface names to use as key for proxy class cache */
354
        String[] interfaceNames = new String[interfaces.length];
356
        Set interfaceSet = new HashSet();       // for detecting duplicates
358
        for (int i = 0; i < interfaces.length; i++) {
359
            /*
360
             * Verify that the class loader resolves the name of this
361
             * interface to the same Class object.
362
             */
363
            String interfaceName = interfaces[i].getName();
364
            Class interfaceClass = null;
365
            try {
366
                interfaceClass = Class.forName(interfaceName, false, loader);
367
            } catch (ClassNotFoundException e) {
368
            }
369
            if (interfaceClass != interfaces[i]) {
370
                throw new IllegalArgumentException(
371
                    interfaces[i] + " is not visible from class loader");
372
            }
374
            /*
375
             * Verify that the Class object actually represents an
376
             * interface.
377
             */
378
            if (!interfaceClass.isInterface()) {
379
                throw new IllegalArgumentException(
380
                    interfaceClass.getName() + " is not an interface");
381
            }
383
            /*
384
             * Verify that this interface is not a duplicate.
385
             */
386
            if (interfaceSet.contains(interfaceClass)) {
387
                throw new IllegalArgumentException(
388
                    "repeated interface: " + interfaceClass.getName());
389
            }
390
            interfaceSet.add(interfaceClass);
392
            interfaceNames[i] = interfaceName;
393
        }
395
        /*
396
         * Using string representations of the proxy interfaces as
397
         * keys in the proxy class cache (instead of their Class
398
         * objects) is sufficient because we require the proxy
399
         * interfaces to be resolvable by name through the supplied
400
         * class loader, and it has the advantage that using a string
401
         * representation of a class makes for an implicit weak
402
         * reference to the class.
403
         */
404
        Object key = Arrays.asList(interfaceNames);
406
        /*
407
         * Find or create the proxy class cache for the class loader.
408
         */
409
        Map cache;
410
        synchronized () {
411
            cache = (Map) .get(loader);
412
            if (cache == null) {
413
                cache = new HashMap();
414
                .put(loader, cache);
415
            }
416
            /*
417
             * This mapping will remain valid for the duration of this
418
             * method, without further synchronization, because the mapping
419
             * will only be removed if the class loader becomes unreachable.
420
             */
421
        }
423
        /*
424
         * Look up the list of interfaces in the proxy class cache using
425
         * the key.  This lookup will result in one of three possible
426
         * kinds of values:
427
         *     null, if there is currently no proxy class for the list of
428
         *         interfaces in the class loader,
429
         *     the pendingGenerationMarker object, if a proxy class for the
430
         *         list of interfaces is currently being generated,
431
         *     or a weak reference to a Class object, if a proxy class for
432
         *         the list of interfaces has already been generated.
433
         */
434
        synchronized (cache) {
435
            /*
436
             * Note that we need not worry about reaping the cache for
437
             * entries with cleared weak references because if a proxy class
438
             * has been garbage collected, its class loader will have been
439
             * garbage collected as well, so the entire cache will be reaped
440
             * from the loaderToCache map.
441
             */
442
            do {
443
                Object value = cache.get(key);
444
                if (value instanceof Reference) {
445
                    proxyClass = (Class) ((Reference) value).get();
446
                }
447
                if (proxyClass != null) {
448
                    // proxy class already generated: return it
449
                    return proxyClass;
450
                } else if (value == ) {
451
                    // proxy class being generated: wait for it
452
                    try {
453
                        cache.wait();
454
                    } catch (InterruptedException e) {
455
                        /*
456
                         * The class generation that we are waiting for should
457
                         * take a small, bounded time, so we can safely ignore
458
                         * thread interrupts here.
459
                         */
460
                    }
461
                    continue;
462
                } else {
463
                    /*
464
                     * No proxy class for this list of interfaces has been
465
                     * generated or is being generated, so we will go and
466
                     * generate it now.  Mark it as pending generation.
467
                     */
468
                    cache.put(key, );
469
                    break;
470
                }
471
            } while (true);
472
        }
474
        try {
475
            String proxyPkg = null;     // package to define proxy class in
477
            /*
478
             * Record the package of a non-public proxy interface so that the
479
             * proxy class will be defined in the same package.  Verify that
480
             * all non-public proxy interfaces are in the same package.
481
             */
482
            for (int i = 0; i < interfaces.length; i++) {
483
                int flags = interfaces[i].getModifiers();
484
                if (!Modifier.isPublic(flags)) {
485
                    String name = interfaces[i].getName();
486
                    int n = name.lastIndexOf('.');
487
                    String pkg = ((n == -1) ? "" : name.substring(0, n + 1));
488
                    if (proxyPkg == null) {
489
                        proxyPkg = pkg;
490
                    } else if (!pkg.equals(proxyPkg)) {
491
                        throw new IllegalArgumentException(
492
                            "non-public interfaces from different packages");
493
                    }
494
                }
495
            }
497
            if (proxyPkg == null) {     // if no non-public proxy interfaces,
498
                proxyPkg = "";          // use the unnamed package
499
            }
501
            {
502
                /*
503
                 * Choose a name for the proxy class to generate.
504
                 */
505
                long num;
506
                synchronized () {
507
                    num = ++;
508
                }
509
                String proxyName = proxyPkg +  + num;
510
                /*
511
                 * Verify that the class loader hasn't already
512
                 * defined a class with the chosen name.
513
                 */
515
                /*
516
                 * Generate the specified proxy class.
517
                 */
518
                byte[] proxyClassFile = ProxyGenerator.generateProxyClass(
519
                    proxyName, interfaces);
520
                try {
521
                    proxyClass = defineClass0(loader, proxyName,
522
                        proxyClassFile, 0, proxyClassFile.length);
523
                } catch (ClassFormatError e) {
524
                    /*
525
                     * A ClassFormatError here means that (barring bugs in the
526
                     * proxy class generation code) there was some other
527
                     * invalid aspect of the arguments supplied to the proxy
528
                     * class creation (such as virtual machine limitations
529
                     * exceeded).
530
                     */
531
                    throw new IllegalArgumentException(e.toString());
532
                }
533
            }
534
            // add to set of all generated proxy classes, for isProxyClass
535
            .put(proxyClass, null);
537
        } finally {
538
            /*
539
             * We must clean up the "pending generation" state of the proxy
540
             * class cache entry somehow.  If a proxy class was successfully
541
             * generated, store it in the cache (with a weak reference);
542
             * otherwise, remove the reserved entry.  In all cases, notify
543
             * all waiters on reserved entries in this cache.
544
             */
545
            synchronized (cache) {
546
                if (proxyClass != null) {
547
                    cache.put(key, new WeakReference(proxyClass));
548
                } else {
549
                    cache.remove(key);
550
                }
551
                cache.notifyAll();
552
            }
553
        }
554
        return proxyClass;
555
    }

    
Returns an instance of a proxy class for the specified interfaces that dispatches method invocations to the specified invocation handler. This method is equivalent to: 
     Proxy.getProxyClass(loader, interfaces).
         getConstructor(new Class[] { InvocationHandler.class }).
         newInstance(new Object[] { handler });

Proxy.newProxyInstance throws IllegalArgumentException for the same reasons that Proxy.getProxyClass does.

Parameters:
loader the class loader to define the proxy class
interfaces the list of interfaces for the proxy class to implement
h the invocation handler to dispatch method invocations to
Returns:
a proxy instance with the specified invocation handler of a proxy class that is defined by the specified class loader and that implements the specified interfaces
Throws:
java.lang.IllegalArgumentException if any of the restrictions on the parameters that may be passed to getProxyClass are violated
java.lang.NullPointerException if the interfaces array argument or any of its elements are null, or if the invocation handler, h, is null
586
    public static Object newProxyInstance(ClassLoader loader,
587
                                          Class<?>[] interfaces,
588
                                          InvocationHandler h)
589
        throws IllegalArgumentException
590
    {
591
        if (h == null) {
592
            throw new NullPointerException();
593
        }
595
        /*
596
         * Look up or generate the designated proxy class.
597
         */
598
        Class cl = getProxyClass(loader, interfaces);
600
        /*
601
         * Invoke its constructor with the designated invocation handler.
602
         */
603
        try {
604
            Constructor cons = cl.getConstructor();
605
            return (Object) cons.newInstance(new Object[] { h });
606
        } catch (NoSuchMethodException e) {
607
            throw new InternalError(e.toString());
608
        } catch (IllegalAccessException e) {
609
            throw new InternalError(e.toString());
610
        } catch (InstantiationException e) {
611
            throw new InternalError(e.toString());
612
        } catch (InvocationTargetException e) {
613
            throw new InternalError(e.toString());
614
        }
615
    }

    
Returns true if and only if the specified class was dynamically generated to be a proxy class using the getProxyClass method or the newProxyInstance method.

The reliability of this method is important for the ability to use it to make security decisions, so its implementation should not just test if the class in question extends Proxy.

Parameters:
cl the class to test
Returns:
true if the class is a proxy class and false otherwise
Throws:
java.lang.NullPointerException if cl is null
631
    public static boolean isProxyClass(Class<?> cl) {
632
        if (cl == null) {
633
            throw new NullPointerException();
634
        }
636
        return .containsKey(cl);
637
    }

    
Returns the invocation handler for the specified proxy instance.

Parameters:
proxy the proxy instance to return the invocation handler for
Returns:
the invocation handler for the proxy instance
Throws:
java.lang.IllegalArgumentException if the argument is not a proxy instance
647
    public static InvocationHandler getInvocationHandler(Object proxy)
648
        throws IllegalArgumentException
649
    {
650
        /*
651
         * Verify that the object is actually a proxy instance.
652
         */
653
        if (!isProxyClass(proxy.getClass())) {
654
            throw new IllegalArgumentException("not a proxy instance");
655
        }
657
        Proxy p = (Proxy) proxy;
658
        return p.h;
659
    }
661
    private static native Class defineClass0(ClassLoader loader, String name,
662
                                             byte[] b, int off, int len);
New to GrepCode? Check out our FAQ X