import net.sf.cglib.proxy.NoOp; //导入依赖的package包/类
@DB()
protected T toEntityBean(final ResultSet result, final boolean cache) throws SQLException {
    final T entity = (T) _factory.newInstance(new Callback[]{NoOp.INSTANCE, new UpdateBuilder(this)});

    toEntityBean(result, entity);

    if (cache && _cache != null) {
        try {
            _cache.put(new Element(_idField.get(entity), entity));
        } catch (final Exception e) {
            s_logger.debug("Can't put it in the cache", e);
        }
    }

    return entity;
}
 

import net.sf.cglib.proxy.NoOp; //导入依赖的package包/类
public void testSupportForClassBasedProxyWithAdditionalInterface()
    throws NullPointerException {
    final Enhancer enhancer = new Enhancer();
    enhancer.setSuperclass(HashMap.class);
    enhancer.setCallback(NoOp.INSTANCE);
    enhancer.setInterfaces(new Class[]{Runnable.class});
    final Map orig = (Map)enhancer.create();
    final String xml = ""
        + "<CGLIB-enhanced-proxy>\n"
        + "  <type>java.util.HashMap</type>\n"
        + "  <interfaces>\n"
        + "    <java-class>java.lang.Runnable</java-class>\n"
        + "  </interfaces>\n"
        + "  <hasFactory>true</hasFactory>\n"
        + "  <net.sf.cglib.proxy.NoOp_-1/>\n"
        + "</CGLIB-enhanced-proxy>";

    final Object serialized = assertBothWays(orig, xml);
    assertTrue(serialized instanceof HashMap);
    assertTrue(serialized instanceof Map);
    assertTrue(serialized instanceof Runnable);
}
 

import net.sf.cglib.proxy.NoOp; //导入依赖的package包/类
public void testSupportsProxiesWithMultipleInterfaces() throws NullPointerException {
    final Enhancer enhancer = new Enhancer();
    enhancer.setCallback(NoOp.INSTANCE);
    enhancer.setInterfaces(new Class[]{Map.class, Runnable.class});
    final Map orig = (Map)enhancer.create();
    final String xml = ""
        + "<CGLIB-enhanced-proxy>\n"
        + "  <type>java.lang.Object</type>\n"
        + "  <interfaces>\n"
        + "    <java-class>java.util.Map</java-class>\n"
        + "    <java-class>java.lang.Runnable</java-class>\n"
        + "  </interfaces>\n"
        + "  <hasFactory>true</hasFactory>\n"
        + "  <net.sf.cglib.proxy.NoOp_-1/>\n"
        + "</CGLIB-enhanced-proxy>";

    final Object serialized = assertBothWays(orig, xml);
    assertTrue(serialized instanceof Map);
    assertTrue(serialized instanceof Runnable);
}
 

import net.sf.cglib.proxy.NoOp; //导入依赖的package包/类
public void testSupportProxiesWithMultipleCallbackSetToNull() throws NullPointerException {
    final Enhancer enhancer = new Enhancer();
    enhancer.setSuperclass(HashMap.class);
    enhancer.setCallback(NoOp.INSTANCE);
    final HashMap orig = (HashMap)enhancer.create();
    ((Factory)orig).setCallback(0, null);
    final String xml = ""
        + "<CGLIB-enhanced-proxy>\n"
        + "  <type>java.util.HashMap</type>\n"
        + "  <interfaces/>\n"
        + "  <hasFactory>true</hasFactory>\n"
        + "  <null/>\n"
        + "</CGLIB-enhanced-proxy>";

    assertBothWays(orig, xml);
}
 

import net.sf.cglib.proxy.NoOp; //导入依赖的package包/类
public void testSupportsSerialVersionUID()
    throws NullPointerException, NoSuchFieldException, IllegalAccessException {
    final Enhancer enhancer = new Enhancer();
    enhancer.setCallback(NoOp.INSTANCE);
    enhancer.setInterfaces(new Class[]{Runnable.class});
    enhancer.setSerialVersionUID(new Long(20060804L));
    final Runnable orig = (Runnable)enhancer.create();
    final String xml = ""
        + "<CGLIB-enhanced-proxy>\n"
        + "  <type>java.lang.Object</type>\n"
        + "  <interfaces>\n"
        + "    <java-class>java.lang.Runnable</java-class>\n"
        + "  </interfaces>\n"
        + "  <hasFactory>true</hasFactory>\n"
        + "  <net.sf.cglib.proxy.NoOp_-1/>\n"
        + "  <serialVersionUID>20060804</serialVersionUID>\n"
        + "</CGLIB-enhanced-proxy>";

    final Object serialized = assertBothWays(orig, xml);
    final Field field = serialized.getClass().getDeclaredField("serialVersionUID");
    field.setAccessible(true);
    assertEquals(20060804L, field.getLong(null));
}
 

import net.sf.cglib.proxy.NoOp; //导入依赖的package包/类
public void testSupportsProxiesAsFieldMember() throws NullPointerException {
    ClassWithProxyMember expected = new ClassWithProxyMember();
    xstream.alias("with-proxy", ClassWithProxyMember.class);
    final Enhancer enhancer = new Enhancer();
    enhancer.setCallback(NoOp.INSTANCE);
    enhancer.setInterfaces(new Class[]{Map.class, Runnable.class});
    final Map orig = (Map)enhancer.create();
    expected.runnable = (Runnable)orig;
    expected.map = orig;
    final String xml = ""
        + "<with-proxy>\n"
        + "  <runnable class=\"CGLIB-enhanced-proxy\">\n"
        + "    <type>java.lang.Object</type>\n"
        + "    <interfaces>\n"
        + "      <java-class>java.util.Map</java-class>\n"
        + "      <java-class>java.lang.Runnable</java-class>\n"
        + "    </interfaces>\n"
        + "    <hasFactory>true</hasFactory>\n"
        + "    <net.sf.cglib.proxy.NoOp_-1/>\n"
        + "  </runnable>\n"
        + "  <map class=\"CGLIB-enhanced-proxy\" reference=\"../runnable\"/>\n"
        + "</with-proxy>";

    final Object serialized = assertBothWays(expected, xml);
    assertTrue(serialized instanceof ClassWithProxyMember);
}
 

import net.sf.cglib.proxy.NoOp; //导入依赖的package包/类
@SuppressWarnings("unchecked")
@DB()
protected T toEntityBean(final ResultSet result, final boolean cache) throws SQLException {
    final T entity = (T)_factory.newInstance(new Callback[] {NoOp.INSTANCE, new UpdateBuilder(this)});

    toEntityBean(result, entity);

    if (cache && _cache != null) {
        try {
            _cache.put(new Element(_idField.get(entity), entity));
        } catch (final Exception e) {
            s_logger.debug("Can't put it in the cache", e);
        }
    }

    return entity;
}
 

import net.sf.cglib.proxy.NoOp; //导入依赖的package包/类
/**
 * Performs a benchmark of an interface implementation using cglib.
 *
 * @return The created instance, in order to avoid JIT removal.
 */
@Benchmark
public ExampleInterface benchmarkCglib() {
    Enhancer enhancer = new Enhancer();
    enhancer.setUseCache(false);
    enhancer.setClassLoader(newClassLoader());
    enhancer.setSuperclass(baseClass);
    CallbackHelper callbackHelper = new CallbackHelper(Object.class, new Class[]{baseClass}) {
        @Override
        protected Object getCallback(Method method) {
            if (method.getDeclaringClass() == baseClass) {
                return new FixedValue() {
                    @Override
                    public Object loadObject() throws Exception {
                        return null;
                    }
                };
            } else {
                return NoOp.INSTANCE;
            }
        }
    };
    enhancer.setCallbackFilter(callbackHelper);
    enhancer.setCallbacks(callbackHelper.getCallbacks());
    return (ExampleInterface) enhancer.create();
}
 

import net.sf.cglib.proxy.NoOp; //导入依赖的package包/类
public Remote createServiceEndpoint() throws ServiceException {
        //TODO figure out why this can't be called in readResolve!
//        synchronized (this) {
//            if (!initialized) {
//                initialize();
//                initialized = true;
//            }
//        }
        Service service = ((ServiceImpl) serviceImpl).getService();
        GenericServiceEndpoint serviceEndpoint = new GenericServiceEndpoint(portQName, service, location);
        Callback callback = new ServiceEndpointMethodInterceptor(serviceEndpoint, sortedOperationInfos, credentialsName);
        Callback[] callbacks = new Callback[]{NoOp.INSTANCE, callback};
        Enhancer.registerCallbacks(serviceEndpointClass, callbacks);
        try {
            return (Remote) constructor.newInstance(new Object[]{serviceEndpoint});
        } catch (InvocationTargetException e) {
            throw (ServiceException) new ServiceException("Could not construct service instance", e.getTargetException()).initCause(e);
        }
    }
 

import net.sf.cglib.proxy.NoOp; //导入依赖的package包/类
public static Class<?> getProxyClass(Class<?> clazz) {
    Enhancer e = new Enhancer();
    if (clazz.isInterface()) {
     e.setSuperclass(clazz);
    } else {
     e.setSuperclass(clazz);
     e.setInterfaces(clazz.getInterfaces());
    }
    e.setCallbackTypes(new Class[]{
        InvocationHandler.class,
        NoOp.class,
    });
    e.setCallbackFilter(BAD_OBJECT_METHOD_FILTER);
    e.setUseFactory(true);
    e.setNamingPolicy(new LithiumTestProxyNamingPolicy());
    return e.createClass();
}
 

import net.sf.cglib.proxy.NoOp; //导入依赖的package包/类
private static Object newProxyByCglib(Typing typing, Handler handler) {
  Enhancer enhancer = new Enhancer() {
    /** includes all constructors */
    protected void filterConstructors(Class sc, List constructors) {}
  };
  enhancer.setClassLoader(Thread.currentThread().getContextClassLoader());
  enhancer.setUseFactory(true);
  enhancer.setSuperclass(typing.superclass);
  enhancer.setInterfaces(typing.interfaces.toArray(new Class[0]));
  enhancer.setCallbackTypes(new Class[] { MethodInterceptor.class, NoOp.class });
  enhancer.setCallbackFilter(new CallbackFilter() {
    /** ignores bridge methods */
    public int accept(Method method) {
      return method.isBridge() ? 1 : 0;
    }
  });
  Class<?> proxyClass = enhancer.createClass();
  Factory proxy = (Factory) new ObjenesisStd().newInstance(proxyClass);
  proxy.setCallbacks(new Callback[] { asMethodInterceptor(handler), new SerializableNoOp() });
  return proxy;
}
 

import net.sf.cglib.proxy.NoOp; //导入依赖的package包/类
@Override
protected Class<?> createProxyClass() {
	Enhancer en = new Enhancer();
   	en.setInterceptDuringConstruction(false);
   	en.setUseFactory(true);
   	
   	en.setSuperclass(unproxiedClass);
   	en.setInterfaces(new Class[] { Persistent.class });
   	en.setCallbackType(NoOp.class);
   	en.setStrategy(new DefaultGeneratorStrategy() {
		protected ClassGenerator transform(ClassGenerator cg) throws Exception {
			return new TransformingClassGenerator(cg, new AddPropertyTransformer(
					new String[] { ORIGINAL_ONE, ORIGINAL_THE_OTHER },
					new Type[] { Type.getType(String.class), Type.getType(List.class) }
				));
		}
   	});
   	
   	return en.createClass();
}
 

import net.sf.cglib.proxy.NoOp; //导入依赖的package包/类
static Map.Entry<Object, SetterInterceptor> getProxiedEntity(Class<?> entityClass) {
    EntityProxyFactory proxyFactory = getFactory(ClassHelper.actualClass(entityClass));
    
    try {
        Object entity = null;
        SetterInterceptor interceptor = proxyFactory.new SetterInterceptor();
        
        if (proxyFactory.isDistinguishable) {
            entity = proxyFactory.factory.newInstance(new Callback[] { interceptor, NoOp.INSTANCE });
        } else {
            entity = proxyFactory.factory.newInstance(interceptor);
        }
        
        proxyFactory.modifiedPropNames.set(entity, new HashSet<String>());
        interceptor.setEntity(entity);
        
        return new AbstractMap.SimpleEntry<Object, SetterInterceptor>(entity, interceptor);
        
    } catch (Throwable t) {
        throw new ODMException("Unable to instantiate proxy instance", t);
    }
}
 

import net.sf.cglib.proxy.NoOp; //导入依赖的package包/类
public T enhance(Class<T> clz) {
    Enhancer enhancer = new Enhancer();
    enhancer.setSuperclass(clz);
    enhancer.setCallbacks(new Callback[]{new PropertyInterceptor<>(this, schema), NoOp.INSTANCE});
    enhancer.setCallbackFilter(new SchemaFilter<>(clz));
    return (T) enhancer.create();
}
 

import net.sf.cglib.proxy.NoOp; //导入依赖的package包/类
private void readCallback(final HierarchicalStreamReader reader, final UnmarshallingContext context,
        final List<Callback> callbacksToEnhance, final List<Callback> callbacks) {
    final Callback callback = (Callback)context.convertAnother(null, mapper.realClass(reader.getNodeName()));
    callbacks.add(callback);
    if (callback == null) {
        callbacksToEnhance.add(NoOp.INSTANCE);
    } else {
        callbacksToEnhance.add(callback);
    }
}
 

import net.sf.cglib.proxy.NoOp; //导入依赖的package包/类
private Object createCgLibProxy() {
    Enhancer enhancer = new Enhancer();
    enhancer.setSuperclass(Collection.class);
    enhancer.setCallback(new NoOp() {
    });
    return enhancer.create();
}
 

import net.sf.cglib.proxy.NoOp; //导入依赖的package包/类
/**
 * 代理某一个对象指定方法，并在这个方法执行前后加入新方法，可指定过滤掉非代理的方法
 * @author nan.li
 * @param t
 * @param before 执行目标方法前要执行的方法
 * @param after  执行目标方法后要执行的方法
 * @return
 */
@SuppressWarnings("unchecked")
public static <T> T proxySurround(T t, CustomMethod before, CustomMethod after, CallbackFilter callbackFilter)
{
    MethodInterceptor methodInterceptor = new MethodInterceptor()
    {
        @Override
        public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy)
            throws Throwable
        {
            before.execute(obj, method, args);
            Object result = null;
            try
            {
                result = proxy.invokeSuper(obj, args);
            }
            finally
            {
                after.execute(obj, method, args);
            }
            return result;
        }
    };
    Enhancer enhancer = new Enhancer();
    enhancer.setSuperclass(t.getClass());
    // 回调方法
    //        enhancer.setCallback(methodInterceptor);
    enhancer.setCallbacks(new Callback[] {methodInterceptor, NoOp.INSTANCE});
    //NoOp回调把对方法的调用直接委派到这个方法在父类中的实现。
    //Methods using this Enhancer callback ( NoOp.INSTANCE ) will delegate directly to the default (super) implementation in the base class.
    //setCallbacks中定义了所使用的拦截器，其中NoOp.INSTANCE是CGlib所提供的实际是一个没有任何操作的拦截器， 他们是有序的。一定要和CallbackFilter里面的顺序一致。
    enhancer.setCallbackFilter(callbackFilter);
    // 创建代理对象
    return (T)enhancer.create();
}
 

import net.sf.cglib.proxy.NoOp; //导入依赖的package包/类
public ComponentInstantiationPostProcessor() {
    _callbacks = new Callback[2];
    _callbacks[0] = NoOp.INSTANCE;
    _callbacks[1] = new InterceptorDispatcher();

    _callbackFilter = new InterceptorFilter();
}
 

import net.sf.cglib.proxy.NoOp; //导入依赖的package包/类
@SuppressWarnings("unchecked")
public static <T> T create(Class<T> targetClass) throws InstantiationException, IllegalAccessException {
	Enhancer enhancer = new Enhancer();
	enhancer.setSuperclass(targetClass);
	enhancer.setClassLoader(targetClass.getClassLoader());
	enhancer.setCallbackFilter(new TransactionalCallbackFilter());
	Callback[] callbacks = new Callback[]{new DalTransactionInterceptor(), NoOp.INSTANCE};
	enhancer.setCallbacks(callbacks);
	enhancer.setInterfaces(new Class[]{TransactionalIntercepted.class});
	return (T)enhancer.create();
}
 

import net.sf.cglib.proxy.NoOp; //导入依赖的package包/类
@Override
protected Object getCallback(Method method) {
    if(method.getName().equals("name") && method.getReturnType().equals(String.class)) {
        return getNameCallback();
    }
    if (method.getName().equals("getRealClassName") && method.getReturnType().equals(String.class)) {
        return getRealClassName();
    }
    return NoOp.INSTANCE;
}