Examples of javassist.util.proxy.ProxyFactory$CacheKey

javassist.util.proxy.ProxyFactory
ute the original method. } }; f.setFilter(new MethodFilter() { public boolean isHandled(Method m) { // ignore finalize() return !m.getName().equals("finalize"); } }); Class c = f.createClass(); Foo foo = (Foo)c.newInstance(); ((ProxyObject)foo).setHandler(mi);

Then, the following method call will be forwarded to MethodHandler mi and prints a message before executing the originally called method bar() in Foo.

 foo.bar();

The last three lines of the code shown above can be replaced with a call to the helper method create, which generates a proxy class, instantiates it, and sets the method handler of the instance:

 : Foo foo = (Foo)f.create(new Class[0], new Object[0], mi);

To change the method handler during runtime, execute the following code:

 MethodHandler mi2 = ... ;    // another handler ((ProxyObject)foo).setHandler(mi2);

You can also specify the default method handler:

 ProxyFactory f2 = new ProxyFactory(); f2.setSuperclass(Foo.class); f2.setHandler(mi);            // set the default handler Class c2 = f2.createClass();

The default handler is implicitly attached to an instance of the generated class c2. Calling setHandler on the instance is not necessary unless another method handler must be attached to the instance.

The following code is an example of method handler. It does not execute anything except invoking the original method:

 class SimpleHandler implements MethodHandler { public Object invoke(Object self, Method m, Method proceed, Object[] args) throws Exception { return proceed.invoke(self, args); } }

A proxy object generated by ProxyFactory is serializable if its super class or interfaces implement a java.io.Serializable. However, a serialized proxy object will not be compatible with future releases. The serialization support should be used for short-term storage or RMI. @see MethodHandler @since 3.1

    {
        WebBeansAnnotation result = null;


        try
        {
            ProxyFactory pf = new ProxyFactory();
            pf.setInterfaces(new Class<?>[] { annotationType, Annotation.class });
            pf.setSuperclass(WebBeansAnnotation.class);
            pf.setHandler(new WebBeansAnnotation(annotationType));


            result = (WebBeansAnnotation) pf.create(new Class[] { Class.class }, new Object[] { annotationType });


        }
        catch (Exception e)
        {
            throw new WebBeansException(e);

    {
        X instance = null;
        try
        {
            //X TODO cache proxy class!
            ProxyFactory proxyFactory = JavassistProxyFactory.createProxyFactory(this);
            
            ResourceInjectionService resourceService = ServiceLoader.getService(ResourceInjectionService.class);
            this.actualResourceReference = resourceService.getResourceReference(this.resourceReference);
            proxyFactory.setHandler(new ResourceProxyHandler(this.actualResourceReference));
            
            instance = (X)(JavassistProxyFactory.getProxyClass(proxyFactory).newInstance());
        }
        catch (Exception e)
        {

                    {
                        // TODO move this part into JavassistProxyFactory
                        Class<?> proxyClass = interceptorProxyClasses.get(bean);
                        if (proxyClass == null)
                        {
                            ProxyFactory delegateFactory = JavassistProxyFactory.createProxyFactory(bean);
                            proxyClass = JavassistProxyFactory.getProxyClass(delegateFactory);
                            interceptorProxyClasses.put(bean, proxyClass);
                        }
                        Object delegate = proxyClass.newInstance();
                        delegateHandler = new DelegateHandler();

    {
       Object result = null;


        try
        {
            ProxyFactory pf = new ProxyFactory();
            pf.setInterfaces(new Class<?>[] {
                    Closable.class,
                    Serializable.class,
                    intf});
            
            pf.setHandler(new JmsProxyHandler(jmsComponent,intf));


            result = JavassistProxyFactory.getProxyClass(pf).newInstance();


        }
        catch (Exception e)

   * Note: The intention of this is to provide the bare essentials that are
   * required to make the {@linkplain MemPipeline} work. It lacks even the basic
   * things that can proved some support for unit testing pipeline.
   */
  private static TaskInputOutputContext<?, ?, ?, ?> getInMemoryContext(final Configuration conf) {
    ProxyFactory factory = new ProxyFactory();
    Class<TaskInputOutputContext> superType = TaskInputOutputContext.class;
    Class[] types = new Class[0];
    Object[] args = new Object[0];
    if (superType.isInterface()) {
      factory.setInterfaces(new Class[] { superType });
    } else {
      types = new Class[] { Configuration.class, TaskAttemptID.class, RecordWriter.class, OutputCommitter.class,
          StatusReporter.class };
      args = new Object[] { conf, new TaskAttemptID(), null, null, null };
      factory.setSuperclass(superType);
    }
    factory.setFilter(new MethodFilter() {
      @Override
      public boolean isHandled(Method m) {
        String name = m.getName();
        return "getConfiguration".equals(name) || "getCounter".equals(name) || "progress".equals(name);
      }
    });
    MethodHandler handler = new MethodHandler() {
      @Override
      public Object invoke(Object arg0, Method m, Method arg2, Object[] args) throws Throwable {
        String name = m.getName();
        if ("getConfiguration".equals(name)) {
          return conf;
        } else if ("progress".equals(name)) {
          // no-op
          return null;
        } else { // getCounter
          if (args.length == 1) {
            return MemPipeline.getCounters().findCounter((Enum<?>) args[0]);
          } else {
            return MemPipeline.getCounters().findCounter((String) args[0], (String) args[1]);
          }
        }
      }
    };
    try {
      Object newInstance = factory.create(types, args, handler);
      return (TaskInputOutputContext<?, ?, ?, ?>) newInstance;
    } catch (Exception e) {
      e.printStackTrace();
      throw new RuntimeException(e);
    }

    scanFields(classMeta, metaDbo);
  }
  
  @SuppressWarnings("unchecked")
  private <T> Class<T> createTheProxy(Class<?> mainClass) {
    ProxyFactory f = new ProxyFactory();
    f.setSuperclass(mainClass);
    f.setInterfaces(new Class[] {NoSqlProxy.class});
    f.setFilter(new MethodFilter() {
      public boolean isHandled(Method m) {
        // ignore finalize()
        if(m.getName().equals("finalize"))
          return false;
        else if(m.getName().equals("equals"))
          return false;
        else if(m.getName().equals("hashCode"))
          return false;
        return true;
      }
    });
    Class<T> clazz = f.createClass();
    testInstanceCreation(clazz);
    
    return clazz;
  }

                            return delegatingLoader;
                        }
                    };
                    
                    try {
                        ProxyFactory proxyFactory = new ProxyFactory();
                        proxyFactory.setInterfaces(interfaces);
                        proxyFactory.setSuperclass(superclass);


                        Class<?> proxyClass = proxyFactory.createClass();


                        try {
                            T proxy = (T) proxyClass.newInstance();


                            ((ProxyObject) proxy).setHandler(callback);

            @Override
            public Object makeMe(final Constructor<?> c, final Object[] args, final boolean neutralCCL)
                    throws Throwable {
                final MethodInterceptorHandler methodInterceptor = new MethodInterceptorHandler(locator, methodInterceptors);
                    
                final ProxyFactory proxyFactory = new ProxyFactory();
                proxyFactory.setSuperclass(implClass);
                proxyFactory.setFilter(METHOD_FILTER);
                
                return AccessController.doPrivileged(new PrivilegedExceptionAction<Object>() {


                    @Override
                    public Object run() throws Exception {
                        ClassLoader currentCCL = null;
                        if (neutralCCL) {
                            currentCCL = Thread.currentThread().getContextClassLoader();
                        }
                  
                        try {
                          return proxyFactory.create(c.getParameterTypes(), args, methodInterceptor);
                        }
                        catch (InvocationTargetException ite) {
                            Throwable targetException = ite.getTargetException();
                            Logger.getLogger().debug(c.getDeclaringClass().getName(), c.getName(), targetException);
                            if (targetException instanceof Exception) {

    @Override
    public Object makeMe(final Constructor<?> c, final Object[] args, final boolean neutralCCL)
            throws Throwable {
        final MethodInterceptorHandler methodInterceptor = new MethodInterceptorHandler(this.clazzCreator.locator, methodInterceptors);
            
        final ProxyFactory proxyFactory = new ProxyFactory();
        proxyFactory.setSuperclass(this.clazzCreator.implClass);
        proxyFactory.setFilter(METHOD_FILTER);
        
        return AccessController.doPrivileged(new PrivilegedExceptionAction<Object>() {


            @Override
            public Object run() throws Exception {
                ClassLoader currentCCL = null;
                if (neutralCCL) {
                    currentCCL = Thread.currentThread().getContextClassLoader();
                }
          
                try {
                  return proxyFactory.create(c.getParameterTypes(), args, methodInterceptor);
                }
                catch (InvocationTargetException ite) {
                    Throwable targetException = ite.getTargetException();
                    Logger.getLogger().debug(c.getDeclaringClass().getName(), c.getName(), targetException);
                    if (targetException instanceof Exception) {

                            return delegatingLoader;
                        }
                    };
                    
                    try {
                        ProxyFactory proxyFactory = new ProxyFactory();
                        proxyFactory.setInterfaces(interfaces);
                        proxyFactory.setSuperclass(superclass);


                        Class<?> proxyClass = proxyFactory.createClass();


                        try {
                            T proxy = (T) proxyClass.newInstance();


                            ((ProxyObject) proxy).setHandler(callback);

Examples of javassist.util.proxy.ProxyFactory$CacheKey

Related Classes of javassist.util.proxy.ProxyFactory$CacheKey