Examples of net.sf.cglib.proxy.Enhancer

net.sf.cglib.proxy.Enhancer
Generates dynamic subclasses to enable method interception. This class started as a substitute for the standard Dynamic Proxy support included with JDK 1.3, but one that allowed the proxies to extend a concrete base class, in addition to implementing interfaces. The dynamically generated subclasses override the non-final methods of the superclass and have hooks which callback to user-defined interceptor implementations.
The original and most general callback type is the {@link MethodInterceptor}, which in AOP terms enables "around advice"--that is, you can invoke custom code both before and after the invocation of the "super" method. In addition you can modify the arguments before calling the super method, or not call it at all.
Although MethodInterceptor is generic enough to meet any interception need, it is often overkill. For simplicity and performance, additional specialized callback types, such as {@link LazyLoader} are also available.Often a single callback will be used per enhanced class, but you can control which callback is used on a per-method basis with a {@link CallbackFilter}.
The most common uses of this class are embodied in the static helper methods. For advanced needs, such as customizing the ClassLoader to use, you should create a new instance of Enhancer. Other classes within CGLIB follow a similar pattern.
All enhanced objects implement the {@link Factory} interface, unless {@link #setUseFactory} isused to explicitly disable this feature. The Factory interface provides an API to change the callbacks of an existing object, as well as a faster and easier way to create new instances of the same type.
For an almost drop-in replacement for java.lang.reflect.Proxy, see the {@link Proxy} class.

   * Construct default instances using the CGLIB enhancer object instead.
   * @param enhancer - a CGLIB enhancer to use.
   * @return A default instance generator that uses the CGLIB enhancer.
   */
  public DefaultInstances forEnhancer(Enhancer enhancer) {
    final Enhancer ex = enhancer;
    
    return new DefaultInstances(this) {
      @SuppressWarnings("unchecked")
      @Override
      protected <T> T createInstance(Class<T> type, Constructor<T> constructor, Class<?>[] types, Object[] params) {
        // Use the enhancer instead
        return (T) ex.create(types, params);
      }
    };
  }

View Full Code Here

    this.modifierRest = new WritePacketModifier(reporter, false);
  }
  
  private Class<?> createProxyClass(int packetId) {
    // Construct the proxy object
    Enhancer ex = EnhancerFactory.getInstance().createEnhancer();
    
    // Attempt to share callback filter 
    if (filter == null) {
      filter = new CallbackFilter() {
        @Override
        public int accept(Method method) {
          // Skip methods defined in Object
          if (WRITE_PACKET.isMatch(MethodInfo.fromMethod(method), null)) {
            writePacketIntercepted = true;
            return 0;
          } else {
            return 1;
          }
        }
      };
    }
    
    // Subclass the generic packet class
    ex.setSuperclass(MinecraftReflection.getPacketClass());
    ex.setCallbackFilter(filter);
    ex.setUseCache(false);
    
    ex.setCallbackTypes( new Class[] { WritePacketModifier.class, WritePacketModifier.class });
    Class<?> proxyClass = ex.createClass();
    
    // Register write modifiers too
    Enhancer.registerStaticCallbacks(proxyClass, new Callback[] { modifierWrite, modifierRest });


    if (proxyClass != null) {

View Full Code Here

    final int packetID = type.getLegacyId();
    
    if (hasPacketHandler(type))
      return false;
    
    Enhancer ex = EnhancerFactory.getInstance().createEnhancer();
    
    // Unfortunately, we can't easily distinguish between these two functions:
    //   * Object lookup(int par1)
    //   * Object removeObject(int par1)
    
    // So, we'll use the classMapToInt registry instead.
    Map<Integer, Class> overwritten = PacketRegistry.getOverwrittenPackets();
    Map<Integer, Class> previous = PacketRegistry.getPreviousPackets();
    Map<Class, Integer> registry = PacketRegistry.getPacketToID();
    Class old = PacketRegistry.getPacketClassFromType(type);
    
    // If this packet is not known
    if (old == null) {
      throw new IllegalStateException("Packet ID " + type + " is not a valid packet type in this version.");
    }
    // Check for previous injections
    if (Factory.class.isAssignableFrom(old)) {
      throw new IllegalStateException("Packet " + type + " has already been injected.");
    }
    
    if (filter == null) {
      readPacketIntercepted = false;
      
      filter = new CallbackFilter() {
        @Override
        public int accept(Method method) {
          // Skip methods defined in Object
          if (method.getDeclaringClass().equals(Object.class)) {
            return 0;
          } else if (READ_PACKET.isMatch(MethodInfo.fromMethod(method), null)) {
            readPacketIntercepted = true;
            return 1;
          } else {
            return 2;
          }
        }
      };
    }
    
    // Subclass the specific packet class
    ex.setSuperclass(old);
    ex.setCallbackFilter(filter);
    ex.setCallbackTypes(new Class<?>[] { NoOp.class, ReadPacketModifier.class, ReadPacketModifier.class });
    Class proxy = ex.createClass();
    
    // Create the proxy handlers
    ReadPacketModifier modifierReadPacket = new ReadPacketModifier(packetID, this, reporter, true);
    ReadPacketModifier modifierRest = new ReadPacketModifier(packetID, this, reporter, false);

View Full Code Here

  /**
   * Create a new CGLib enhancer.
   * @return The new enhancer.
   */
  public Enhancer createEnhancer() {
    Enhancer enhancer = new Enhancer();
    enhancer.setClassLoader(loader);
    return enhancer;
  }

View Full Code Here

    //      public int size() {
    //         return -super.size();
    //      }
    //   ect.
    //   }
    Enhancer ex = EnhancerFactory.getInstance().createEnhancer();
    ex.setSuperclass(MinecraftReflection.getPacketClass());
    ex.setInterfaces(new Class[] { FakePacket.class } );
    ex.setUseCache(true);
    ex.setCallbackType(InvertedIntegerCallback.class);


    Class<?> proxyClass = ex.createClass();
    Enhancer.registerCallbacks(proxyClass, new Callback[] { callback });
    
    try {
      // Temporarily associate the fake packet class
      invoker.registerPacketClass(proxyClass, type.getLegacyId());

View Full Code Here

          }
        };
      }
      
      // Create our proxy object
      Enhancer ex = EnhancerFactory.getInstance().createEnhancer();
      ex.setSuperclass(networkInterface);
      ex.setCallbacks(new Callback[] { queueFilter, dispatch });
      ex.setCallbackFilter(callbackFilter);
      
      // Inject it, if we can.
      networkManagerRef.setValue(ex.create());
    }
  }

View Full Code Here

   */
  private static void initializePacket() {
    // Initialize the methods
    if (packetReadByteBuf == null || packetWriteByteBuf == null) {
      // This object will allow us to detect which methods were called
      Enhancer enhancer = EnhancerFactory.getInstance().createEnhancer();
      enhancer.setSuperclass(MinecraftReflection.getPacketDataSerializerClass());
      enhancer.setCallback(new MethodInterceptor() {
        @Override
        public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy)
            throws Throwable {
          if (method.getName().contains("read"))
            throw new ReadMethodException();
          if (method.getName().contains("write"))
            throw new WriteMethodException();
          return proxy.invokeSuper(obj, args);
        }
      });
      
      // Create our proxy object
      Object javaProxy = enhancer.create(
        new Class<?>[] { ByteBuf.class }, 
        new Object[]   { UnpooledByteBufAllocator.DEFAULT.buffer() }
      );
      
      Object lookPacket = new PacketContainer(PacketType.Play.Client.BLOCK_PLACE).getHandle();

View Full Code Here

      
      // Find the register event method
      Method registerEvent = FuzzyReflection.fromObject(manager).getMethodByParameters("registerEvent", 
          eventTypes, Listener.class, eventPriority, Plugin.class);
      
      Enhancer playerLow = EnhancerFactory.getInstance().createEnhancer();
      Enhancer playerEx = EnhancerFactory.getInstance().createEnhancer();
      Enhancer serverEx = EnhancerFactory.getInstance().createEnhancer();
      
      playerLow.setSuperclass(playerListener);
      playerLow.setClassLoader(classLoader);
      playerLow.setCallback(new MethodInterceptor() {
        @Override
        public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy)
            throws Throwable {
          // Must have a parameter
          if (args.length == 1) {
            Object event = args[0];


            if (event instanceof PlayerJoinEvent) {
              onPrePlayerJoin((PlayerJoinEvent) event);
            }
          }
          return null;
        }
      });
      
      playerEx.setSuperclass(playerListener);
      playerEx.setClassLoader(classLoader);
      playerEx.setCallback(new MethodInterceptor() {
        @Override
        public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
          if (args.length == 1) {
            Object event = args[0];
            
            // Check for the correct event
            if (event instanceof PlayerJoinEvent) {
              onPlayerJoin((PlayerJoinEvent) event);
            } else if (event instanceof PlayerQuitEvent) {
              onPlayerQuit((PlayerQuitEvent) event);
            }
          }
          return null;
        }
      });
      
      serverEx.setSuperclass(serverListener);
      serverEx.setClassLoader(classLoader);
      serverEx.setCallback(new MethodInterceptor() {
        @Override
        public Object intercept(Object obj, Method method, Object[] args,
            MethodProxy proxy) throws Throwable {
          // Must have a parameter
          if (args.length == 1) {
            Object event = args[0];
            
            if (event instanceof PluginDisableEvent)
              onPluginDisabled((PluginDisableEvent) event, plugin);
          }
          return null;
        }
      });
      
      // Create our listener
      Object playerProxyLow = playerLow.create();
      Object playerProxy = playerEx.create();
      Object serverProxy = serverEx.create();
      
      registerEvent.invoke(manager, playerJoinType, playerProxyLow, priorityLowest, plugin);
      registerEvent.invoke(manager, playerJoinType, playerProxy, priorityMonitor, plugin);
      registerEvent.invoke(manager, playerQuitType, playerProxy, priorityMonitor, plugin);
      registerEvent.invoke(manager, pluginDisabledType, serverProxy, priorityMonitor, plugin);

View Full Code Here

    };
    
    // Don't care for everything else
    callbacks[2] = NoOp.INSTANCE;
    
    Enhancer enhancer = EnhancerFactory.getInstance().createEnhancer();
    enhancer.setSuperclass(getSpigotListenerClass());
    enhancer.setCallbacks(callbacks);
    enhancer.setCallbackFilter(new CallbackFilter() {
      @Override
      public int accept(Method method) {
        // We'll be pretty stringent
        if (matchMethod("packetReceived", method)) {
          found[0] = true;
          return 0;
        } else if (matchMethod("packetQueued", method)) {
          found[1] = true;
          return 1;
        } else {
          found[2] = true;
          return 2;
        }
      }
    });
    dynamicListener = enhancer.create();
    
    // Verify methods
    if (!found[0])
      throw new IllegalStateException("Unable to find a valid packet receiver in Spigot.");
    if (!found[1])

View Full Code Here

     */
    public Object create(Class realMpClass, MessageProcessorId id, Map<String, String> attributes, String fileName, String lineNumber)
    {
        try
        {
            Enhancer e = createEnhancer(realMpClass, id, attributes, fileName, lineNumber);
            return e.create();
        }
        catch (Throwable e)
        {
            logger.warn("The message processor " + id.getFullName() + " could not be mocked");
            try

View Full Code Here

0 1 2 3 4 5 6 7 8 9

TOP

Related Classes of net.sf.cglib.proxy.Enhancer

bitronix.tm.resource.jdbc.proxy.JdbcCglibProxyFactory

br.com.caelum.vraptor.proxy.DefaultProxifier

br.com.objectos.way.io.TableProxy

ch.bbv.fsm.impl.internal.aop.CallInterceptorBuilder

co.paralleluniverse.actors.behaviors.ProxyServerActor

com.alibaba.citrus.springext.util.SpringExtUtil

com.alibaba.citrus.util.internal.InterfaceImplementorBuilder

com.alibaba.citrus.util.internal.StaticFunctionDelegatorBuilder

com.avast.syringe.aop.cglib.CglibProxyFactory

com.cloud.utils.db.GenericDaoBase

All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.