public Object invoke() throws Throwable { Object returnValue = null; if (index < ans.length) { Annotation annotation = ans[index++]; if (pluginMap.containsKey(annotation.annotationType())) { returnValue = pluginMap .get(annotation.annotationType()) .intercept(annotation, this, args, target, method, isHandled); } if (isHandled[0]) { return returnValue; } } else if (index++ == ans.length) { try { if (useInjectTarget) returnValue = methodProxy.invoke(target, args); else returnValue = methodProxy.invokeSuper(target, args); } catch (InvocationTargetException e) { Throwable t = e.getTargetException(); throw t instanceof RuntimeException ? (RuntimeException) t : new RuntimeException(e); } catch (RuntimeException e) { throw e; } catch (Throwable t) { throw new RuntimeException(t); } return returnValue; } return returnValue; }
public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable { Object returnObj = null; if (openConnection) { ConnectionHandler.getConnection(); if (CacheMark.getTran(method)) { try { ConnectionHandler.beginTransaction(); returnObj = proxy.invokeSuper(obj, args); ConnectionHandler.commit(); } catch (Exception e) { ConnectionHandler.rollback(); MethodParamHandler.getMethodParam(e, method, args); } } else { try { returnObj = proxy.invokeSuper(obj, args); } catch (Exception e) { MethodParamHandler.getMethodParam(e, method, args); } } ConnectionHandler.close(); } else { returnObj = proxy.invokeSuper(obj, args); } return returnObj; }
public Object intercept( Object obj, java.lang.reflect.Method method, Object[] args, MethodProxy proxy) throws Throwable { printIdent(ident); System.out.println(method); for (int i = 0; i < args.length; i++) { printIdent(ident); System.out.print("arg" + (i + 1) + ": "); if (obj == args[i]) System.out.println("this"); else System.out.println(args[i]); } ident++; Object retValFromSuper = null; try { retValFromSuper = proxy.invokeSuper(obj, args); ident--; } catch (Throwable t) { ident--; printIdent(ident); System.out.println("throw " + t); System.out.println(); throw t.fillInStackTrace(); } printIdent(ident); System.out.print("return "); if (obj == retValFromSuper) System.out.println("this"); else System.out.println(retValFromSuper); if (ident == 1) System.out.println(); return retValFromSuper; }
public Object intercept(Object obj, Method m, Object[] args, MethodProxy proxy) throws Throwable { // TODO Auto-generated method stub System.out.println("实际类方法调用前,cglib 代理类逻辑"); proxy.invokeSuper(obj, args); System.out.println("实际类方法调用后,cglib 代理类逻辑"); return null; }
public Object intercept(Object o, Method method, Object[] args, MethodProxy methodProxy) throws Throwable { if (Modifier.isAbstract(method.getModifiers())) { return invoker.invoke(o, method, args); } else { return methodProxy.invokeSuper(o, args); } }
@Override public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable { System.out.println("===== before method : " + method); Object ret = proxy.invokeSuper(obj, args); System.out.println("===== before method : " + method); return ret; }
@Override public Object intercept(Object o, Method method, Object[] args, MethodProxy methodProxy) throws Throwable { System.out.println("事物开始"); methodProxy.invokeSuper(o, args); System.out.println("事物结束"); return null; }
@Override public Object intercept(Object object, Method method, Object[] params, MethodProxy proxy) throws Throwable { before(); Object result = proxy.invokeSuper(object, params); after(); return result; }
@Override // 回调方法 public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable { System.out.println("事务开始"); proxy.invokeSuper(obj, args); System.out.println("事务结束"); return null; }
/* * (non-Javadoc) * @see net.sf.cglib.proxy.MethodInterceptor#intercept(java.lang.Object, * java.lang.reflect.Method, java.lang.Object[], * net.sf.cglib.proxy.MethodProxy) */ @Override public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable { if (Modifier.isAbstract(method.getModifiers())) { if (method.isAnnotationPresent(Block.class)) { Block anno = method.getAnnotation(Block.class); Class<?>[] clazzList = anno.value(); ObjectBlock objBlock = new ObjectBlock(method, clazzList); this.objBlockList.add(objBlock); } // thực thi hàm getOptionsList trên ConfigModule interface if (method.getName().equals("getOptionsList") && method.getParameterTypes().length == 0) { checkBlock(method); return this.optionsList; } else if (method.getName().equals("getTargetClass") && method.getParameterTypes().length == 0) { checkBlock(method); return this.targetClass; } else if (method.getName().equals("getConfigInstance") && method.getParameterTypes().length == 1) { checkBlock(method); return this.configObjList.get(args[0]); } else { if (!this.objBlockList.isEmpty()) { ObjectBlock objb = this.objBlockList.get(this.configObjList.size() - 1); List<Class<?>> clazzList = null; clazzList = objb.getBlockList(); for (Class<?> clazz : clazzList) { Object objConfig = this.configObjList.get(clazz); List<Method> methodList = Arrays.asList(objConfig.getClass().getMethods()); if (methodList.contains(method)) { checkBlock(method); return method.invoke(objConfig, args); } else { continue; } } } // Nếu không có for (Class<?> clazz : this.configObjList.keySet()) { Object objConfig = this.configObjList.get(clazz); List<Method> methodList = Arrays.asList(ReflectUtils.getAllDeclaredMethods(clazz)); if (methodList.contains(method)) { checkBlock(method); return method.invoke(objConfig, args); } else { continue; } } throw new NoSuchMethodException("Could not found " + method + " method!"); } } else { checkBlock(method); return proxy.invokeSuper(obj, args); } }
/** * @param o 代理对象 * @param method 目标对象方法 * @param objects 对象方法参数 * @param methodProxy 目标对象方法代理方法 * @return * @throws Throwable */ @Override public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable { before(); Object result = methodProxy.invokeSuper(o, objects); after(); return result; }
public Object doProxyChain() throws Throwable { Object methodResult; if (proxyIndex < proxyList.size()) { methodResult = proxyList.get(proxyIndex++).doProxy(this); } else { methodResult = methodProxy.invokeSuper(targetBean, methodParams); } return methodResult; }
@Override public Object intercept(Object object, Method method, Object[] args, MethodProxy methodProxy) throws Throwable { Transaction txn = interceptStart(method); try { return methodProxy.invokeSuper(object, args); } finally { interceptComplete(method, txn); } }
public Object proceed() throws Throwable { try { index++; return index == interceptors.length ? methodProxy.invokeSuper(proxy, arguments) : interceptors[index].invoke(this); } finally { index--; } }
private Object executeTestStepMethod( Object obj, Method method, Object[] args, MethodProxy proxy, Object result) throws Throwable { try { result = proxy.invokeSuper(obj, args); notifyStepFinishedFor(method, args); } catch (PendingStepException pendingStep) { notifyStepPending(pendingStep.getMessage()); } catch (IgnoredStepException ignoredStep) { notifyStepIgnored(ignoredStep.getMessage()); } return result; }
@Override public Object intercept(Object object, Method method, Object[] args, MethodProxy methodProxy) throws Throwable { String name = method.getName(); if (name.startsWith("set")) { String field = methodToField(name, 3); makeChange(field, args[0]); } else if (name.startsWith("incr")) { makeIncrChange(name, args); } else if (name.startsWith("decr")) { makeDecrChange(name, args); } return methodProxy.invokeSuper(object, args); }
public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable { for (int ii = 0; ii < methodsToIntercept.length; ii++) { if (MethodUtil.areMethodsEqual(method, methodsToIntercept[ii])) { return methodsToIntercept[ii].invoke(delegate, args); } } for (int ii = 0; ii < methodsToDuplicate.length; ii++) { if (MethodUtil.areMethodsEqual(method, methodsToDuplicate[ii])) { methodsToDuplicate[ii].invoke(delegate, args); } } return proxy.invokeSuper(obj, args); }
/* * (non-Javadoc) * * @see com.absir.aop.AopProxyHandler#invoke(java.lang.Object, * java.lang.reflect.Method, java.lang.Object[], * net.sf.cglib.proxy.MethodProxy) */ @Override public Object invoke(Object proxy, Method method, Object[] args, MethodProxy methodProxy) throws Throwable { if (beanObject == null) { return methodProxy.invokeSuper(proxy, args); } else { if (!method.isAccessible()) { method.setAccessible(true); } return method.invoke(beanObject, args); } }
@Override public Object intercept(Object object, Method method, Object[] args, MethodProxy methodProxy) throws Throwable { EventVO event = interceptStart(method); boolean success = true; try { return methodProxy.invokeSuper(object, args); } catch (Exception e) { success = false; interceptException(method, event); throw e; } finally { if (success) { interceptComplete(method, event); } } }
public Object intercept(Object enhanced, Method method, Object[] args, MethodProxy methodProxy) throws Throwable { final String methodName = method.getName(); try { synchronized (lazyLoader) { if (WRITE_REPLACE_METHOD.equals(methodName)) { Object original = null; if (constructorArgTypes.isEmpty()) { original = objectFactory.create(type); } else { original = objectFactory.create(type, constructorArgTypes, constructorArgs); } PropertyCopier.copyBeanProperties(type, enhanced, original); if (lazyLoader.size() > 0) { return new CglibSerialStateHolder( original, lazyLoader.getProperties(), objectFactory, constructorArgTypes, constructorArgs); } else { return original; } } else { if (lazyLoader.size() > 0 && !FINALIZE_METHOD.equals(methodName)) { if (aggressive || lazyLoadTriggerMethods.contains(methodName)) { lazyLoader.loadAll(); } else if (PropertyNamer.isProperty(methodName)) { final String property = PropertyNamer.methodToProperty(methodName); if (lazyLoader.hasLoader(property)) { lazyLoader.load(property); } } } } } return methodProxy.invokeSuper(enhanced, args); } catch (Throwable t) { throw ExceptionUtil.unwrapThrowable(t); } }
public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable { // We conveniently mock abstract methods be default if (Modifier.isAbstract(method.getModifiers())) { return handler.invoke(obj, method, args); } // Here I need to check if the fillInStackTrace was called by EasyMock inner code // If it's the case, just ignore the call. We ignore it for two reasons // 1- In Java 7, the fillInStackTrace won't work because, since no constructor was called, the // stackTrace attribute is null // 2- There might be some unexpected side effect in the original fillInStackTrace. So it seems // more logical to ignore the call if (obj instanceof Throwable && method.getName().equals("fillInStackTrace")) { if (isCallerMockInvocationHandlerInvoke(new Throwable())) { return obj; } } // Bridges should delegate to their bridged method. It should be done before // checking for mocked methods because only unbridged method are mocked // It also make sure the method passed to the handler is not the bridge. Normally it // shouldn't be necessary because bridges are never mocked so are never in the mockedMethods // map. So the normal case is that is will call invokeSuper which will call the interceptor // for // the bridged method. The problem is that it doesn't happen. It looks like a cglib bug. For // package scoped bridges (see GenericTest), the interceptor is not called for the bridged // method. Not normal from my point of view. if (method.isBridge()) { method = BridgeMethodResolver.findBridgedMethod(method); } if (mockedMethods != null && !mockedMethods.contains(method)) { return proxy.invokeSuper(obj, args); } return handler.invoke(obj, method, args); }
@Override public Object intercept( Object target, Method method, Object[] methodParams, MethodProxy methodProxy) throws Throwable { // 用户进行判断 // TODO 再完善一下打印的信息 最好能过滤出类名和方法名出来 Object result = null; // class com.liusoft.tools.test.AOPSupportBean$$EnhancerByCGLIB$$ef560001test3 String proxyCalss = target.getClass().getName(); TimeUnit timeUnit = null; try { timeUnit = TimeUnit.valueOf(timeUnitName); } catch (Exception e) { } Profiler.enter(proxyCalss.split("\\$\\$")[0] + "." + method.getName(), timeUnit); result = methodProxy.invokeSuper(target, methodParams); Profiler.release(); return result; }
@Override public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable { return proxy.invokeSuper(obj, args); }
@Override public Object intercept(Object enhanced, Method method, Object[] args, MethodProxy methodProxy) throws Throwable { final Object o = super.invoke(enhanced, method, args); return (o instanceof AbstractSerialStateHolder) ? o : methodProxy.invokeSuper(o, args); }
private Object invokeMethod( final Object obj, final Method method, final Object[] args, final MethodProxy proxy) throws Throwable { return proxy.invokeSuper(obj, args); }