需要执行的方法
@param call
@param content
@return
12319
public <T> Future<T> executeMethod(Callable<T> call,Content content){
		LogProcessContext logProcessContext = getLogProcessContext();
		return logProcessContext.getExecuteManager().cacheCall(call, content);
	}
840504
public static Response call(String server, String service, DataBinder binder, String... params) {
        return call(server, service, false, binder, params);
    }
375856
@Override
    public <R, T extends Object> R callMethod(final String methodName, final T argument) throws CouldNotPerformException, InterruptedException {
        return callMethod(methodName, argument, -1);
    }
742774
protected void invoke(Object pObject) throws APPErrorException {
        try {
            Method method =tgtools.util.ReflectionUtil.findMethod(mService.getClass(),getMethodName(),getModelClass());
            method.invoke(mService,pObject);
        }catch (Exception ex)
        {
            throw new APPErrorException("执行方法错误；原因："+ex.getCause().getMessage(),ex);
        }
    }
606228
public static <T> T execute(HttpRequestBase request, HttpResponseCallbackHandler<T> responseHandler)
            throws Exception {

        CloseableHttpResponse httpclientResponse = null;

        try {

            if (LOGGER.isDebugEnabled()) {
                Header[] headers = request.getAllHeaders();
                for (Header header : headers) {
                    LOGGER.debug("request: " + header.getName() + "\t" + header.getValue());
                }
            }

            httpclientResponse = httpclient.execute(request);

            if (LOGGER.isDebugEnabled()) {
                for (Header header : httpclientResponse.getAllHeaders()) {
                    LOGGER.debug("response header: {}\t{}", header.getName(), header.getValue());
                }
            }

            // 填充状态码
            int statusCode = httpclientResponse.getStatusLine().getStatusCode();

            String requestBody = null;
            if (request instanceof HttpEntityEnclosingRequestBase) {
                HttpEntity requestEntity = ((HttpEntityEnclosingRequestBase) request).getEntity();
                if (requestEntity != null) {
                    requestBody = EntityUtils.toString(requestEntity);
                }
            }

            LOGGER.info("execute http request [{}], status code [{}]", requestBody, statusCode);

            if (statusCode != 200) {
                throw new Exception("execute  request failed [" + requestBody + "], statusCode [" + statusCode
                        + "]");
            }

            // 处理响应体
            HttpEntity entity = httpclientResponse.getEntity();
            if (entity != null && responseHandler != null) {
                return responseHandler.handleResponse(requestBody, entity);
            } else {
                LOGGER.info("execute response [{}], response empty", requestBody);
            }

            return null;

        } catch (Exception e) {
            throw e;
        } finally {
            if (httpclientResponse != null) {
                try {
                    httpclientResponse.close();
                } catch (IOException e) {
                }
            }
        }
    }
781312
@Override
    <Result> String execute(final Callable<Result> callable,
                            final TaskCallback<Result> callback,
                            final Object caller) {
        checkArguments(callable, caller);
        return execute(TaskBuilder.create(callable).with(caller).
                callback(callback).on(this).done());
    }
774740
@Override
    public CallableStatement prepareCall(String sql, int resultSetType, int resultSetConcurrency) throws SQLException
    {
        if (resultSetType == ResultSet.TYPE_SCROLL_INSENSITIVE && resultSetConcurrency == ResultSet.CONCUR_READ_ONLY)
            return prepareCall(sql);
        checkClosed();
        throw SQLError.noSupport();
    }
710653
@Override
	public Object call(Object[] args, Context context) {
		// 只能有一个参数且只能为字符串
		if ((args.length >= 1) && (args[0] instanceof String) && (args[0] != null)) {
			String spel = (String) args[0];
			Expression expression = getExpression(spel);
			// 如果有第二参数，取他作为根对象
			if ((args.length >= 2) && (args[1] != null)) {
				return expression.getValue(createEvaluationContext(args[1], context));
			} else {
				return expression.getValue(createEvaluationContext(Collections.emptyMap(), context));
			}
		}
		return null;
	}
1216071
public static <T> BaseDTO<T> exec(Callable<BaseDTO<T>> callable, String msg, Object... param) {
        try {
            log.info("函数调用");
            BaseDTO<T> dto = callable.call();
            log.info("函数调用结果为：[{}]", dto);
            return dto;
        } catch (Exception e) {
            if (param == null || param.length == 0) {
                log.error(msg, e);
            } else {
                Object[] params = new Object[param.length + 1];
                System.arraycopy(param, 0, params, 0, param.length);
                params[param.length] = e;
                log.error(msg, params);
            }
            return BaseDTO.buildError();
        }
    }
1060489
@Override
    public Void call() throws Exception {
        OutputStream out = null;
        InputStream in = null;
        try {
            out = new FileOutputStream(destination);
            in = new FileInputStream(source);
            JasperCompileManager.compileReportToStream(in, out);
            if (verbose) {
                log.info("Compiling " + source.getName());
            }
        } catch (Exception e) {
            cleanUpAndThrowError(destination, e);
        } finally {
            if (out != null) {
                out.close();
            }
            if (in != null) {
                in.close();
            }
        }
        return null;
    }
889718
public Object getNext(KCall call) {

		if (map.get(call.getProcedure().getId()) == null) {

			Object context = call.getProcess().getContext();

			// getting data by reflection
			Method readMethod = null;
			try {
				readMethod = new PropertyDescriptor(pipelineDataName,
						context.getClass()).getReadMethod();
			} catch (IntrospectionException e) {
				MessageKind.W0003.format(e);
			}
			Object invoke = null;
			try {
				invoke = readMethod.invoke(context);
			} catch (IllegalArgumentException e) {
				MessageKind.W0003.format(e);
			} catch (IllegalAccessException e) {
				MessageKind.W0003.format(e);
			} catch (InvocationTargetException e) {
				MessageKind.W0003.format(e);
			}

			// putting new Iterator into map
			if (invoke instanceof Iterable<?>) {
				Iterator newIterator = ((Iterable) invoke).iterator();
				this.add(call.getProcedure().getId(), newIterator);
			}
		}
		Iterator iterator = map.get(call.getProcedure().getId());
		return iterator.next();
	}
944766
private void executeInClassScope(Callable<Void> call) {
        try {
            classContext.get().activate(deploymentClass);
            call.call();
        } catch (Exception e) {
            throw new RuntimeException("Could not invoke operation", e); // NOPMD
        } finally {
            classContext.get().deactivate();
        }
    }
609850
private static Object invoke(Class target, Object o, String methodName, Object[] paras)
			throws IllegalAccessException, IllegalArgumentException, InvocationTargetException
	{

		ObjectInfo info = getObjectInfo(target);
		Class[] parameterType = new Class[paras.length];
		int i = 0;
		for (Object para : paras)
		{
			parameterType[i++] = para == null ? null : para.getClass();
		}
		ObjectMethodMatchConf mf = findMethod(target, methodName, parameterType);
		if (mf == null)
		{
			throw new BeetlParserException(BeetlParserException.NATIVE_CALL_INVALID, "根据参数未找到匹配的方法"+methodName+BeetlUtil.getParameterDescription(parameterType));
		}
		Object result = invoke(o, mf, paras);
		return result;

	}
620663
@Override
    public Object execIdCall(IdFunctionObject f, Context cx, Scriptable scope,
                             Scriptable thisObj, Object[] args)
    {
        throw f.unknown();
    }
1216265
public static <T> T exec(JavaScriptObject jsFunction, Object... args) {
    assert isFunction(jsFunction);
    return jsni(jsFunction, "call", jsFunction, args);
  }
921679
@Override
  public RemoteCallReturn invokeSoapCall(SoapCall<BindingProvider> soapCall) {
    BindingProvider webService = soapCall.getSoapClient();
    RemoteCallReturn.Builder builder = new RemoteCallReturn.Builder();
    synchronized (webService) {
      Object result = null;
      try {
        result = invoke(soapCall);
      } catch (InvocationTargetException e) {
        builder.withException(e.getTargetException());
      } catch (Exception e) {
        builder.withException(e);
      } finally {
        JaxWsSoapContextHandler contextHandler = getContextHandlerFromClient(webService);
        String url = getEndpointAddress(webService);
        builder.withRequestInfo(contextHandler.getLastRequestInfoBuilder().withUrl(url).build());
        builder.withResponseInfo(contextHandler.getLastResponseInfoBuilder().build());
      }
      return builder.withReturnValue(result).build();
    }
  }
72576
<V> V execute(final TransactionalClosureWithReturn<V> closure) {
        return getSessionFactory().doInSession(
                new Callable<V>() {
                    @Override
                    public V call() {
                        PersistenceSession persistenceSession = getPersistenceSession();
                        persistenceSession.getServicesInjector().injectServicesInto(closure);
                        return doExecute(closure);
                    }
                }
        );
    }