private <T> void invokePostConstruct(T target) { List<Method> methods = Cls.getMethodsAnnotated(target.getClass(), PostConstruct.class); for (Method method : methods) { Cls.invoke(method, target); } }
public static void bind(Object destBean, Map<String, ?> src) { Method bind = Cls.findMethod(destBean.getClass(), "bind", Map.class); if (bind != null) { Cls.invoke(bind, destBean, src); } else { update(destBean, src, false, false); } }
public Map<String, String> match(String path) { Matcher matcher = pattern.matcher(path); boolean matches = matcher.matches(); Map<String, String> params = null; if (matches) { params = U.map(); for (Map.Entry<String, String> e : groups.entrySet()) { U.notNull(MATCHER_GROUP != null, "Regex matcher"); String val = Cls.invoke(MATCHER_GROUP, matcher, e.getValue()); if (val != null) { val = URIs.urlDecodeOrKeepOriginal(val); params.put(e.getKey(), val); } } } return params; }
private <T> T instantiate(Class<T> type, Map<String, Object> properties) { ClassMetadata meta = meta(type); if (U.notEmpty(meta.injectableConstructors)) { U.must(meta.injectableConstructors.size() == 1, "Found more than 1 @Inject-annotated constructor for: %s", type); Constructor<?> constr = U.single(meta.injectableConstructors); Class<?>[] paramTypes = constr.getParameterTypes(); Object[] args = new Object[paramTypes.length]; for (int i = 0; i < args.length; i++) { Class<?> paramType = paramTypes[i]; String paramName = null; // FIXME inject by name args[i] = provideIoCInstanceOf(null, paramType, paramName, properties, false); } return Cls.invoke(constr, args); } else if (meta.defaultConstructor != null) { return Cls.invoke(meta.defaultConstructor); } else { throw U.illegal("Cannot find a default nor @Inject-annotated constructor for: %s", type); } }
@Override public void run() { Runtime rt = Runtime.getRuntime(); long totalMem = rt.totalMemory(); long maxMem = rt.maxMemory(); long freeMem = rt.freeMemory(); long usedMem = totalMem - freeMem; double megs = 1024.0 * 1024; MEM_TOTAL.put(U.time(), totalMem / megs); MEM_USED.put(U.time(), usedMem / megs); if (sysCpuM != null) { SYSTEM_CPU.put(U.time(), ((Number) Cls.invoke(sysCpuM, os)).doubleValue()); } if (procCpuM != null) { PROCESS_CPU.put(U.time(), ((Number) Cls.invoke(procCpuM, os)).doubleValue()); } if (openFileDescriptorCount != null) { NUM_FILE_DESC.put(U.time(), ((Number) Cls.invoke(openFileDescriptorCount, os)).doubleValue()); } NUM_THREADS.put(U.time(), threads.getThreadCount()); }
@Override public Object runManageableAction(String action) { Method method = Cls.findMethod(source().getClass(), Str.uncapitalized(action)); if (method != null) { return Cls.invoke(method, source()); } else { return doManageableAction(action); } }
@Override public List<String> getManageableActions() { Object source = source(); List<String> actions = U.list(); List<Method> actionMethods = Cls.getMethodsAnnotated(source.getClass(), Action.class); // sort the actions by @Order Msc.sortByOrder(actionMethods); for (Method method : actionMethods) { Action action = method.getAnnotation(Action.class); actions.add(!action.name().isEmpty() ? action.name() : method.getName()); } for (Method method : Cls.getMethodsAnnotated(source.getClass(), ActionCondition.class)) { ActionCondition condition = method.getAnnotation(ActionCondition.class); U.must(method.getReturnType() == boolean.class, "The method return type must be boolean: " + method); boolean cond = Cls.invoke(method, source); if (!cond) { String name; if (!condition.name().isEmpty()) { name = condition.name(); } else { name = method.getName(); U.must(name.startsWith("can"), "The action condition method must start with 'can', to infer the action name!"); name = Str.uncapitalized(Str.triml(name, "can")); } actions.remove(name); } } return actions; }
Object[] parameters = Cls.invoke(getParameters, method);
private static <T> void invokePostConstruct(T target) { List<Method> methods = Cls.getMethodsAnnotated(target.getClass(), Init.class); for (Method method : methods) { Cls.invoke(method, target); } }
private <T> void invokePostConstruct(T target) { List<Method> methods = Cls.getMethodsAnnotated(target.getClass(), PostConstruct.class); for (Method method : methods) { Cls.invoke(method, target); } }
public static void bind(Object destBean, Map<String, Object> src) { Method bind = Cls.findMethod(destBean.getClass(), "bind", Map.class); if (bind != null) { Cls.invoke(bind, destBean, src); } else { update(destBean, src, false, false); } }
public Map<String, String> match(String path) { Matcher matcher = pattern.matcher(path); boolean matches = matcher.matches(); Map<String, String> params = null; if (matches) { params = U.map(); for (Map.Entry<String, String> e : groups.entrySet()) { U.notNull(MATCHER_GROUP != null, "Regex matcher"); String val = Cls.invoke(MATCHER_GROUP, matcher, e.getValue()); if (val != null) { val = Msc.urlDecodeOrKeepOriginal(val); params.put(e.getKey(), val); } } } return params; }
private <T> T instantiate(Class<T> type, Map<String, Object> properties) { ClassMetadata meta = meta(type); if (U.notEmpty(meta.injectableConstructors)) { U.must(meta.injectableConstructors.size() == 1, "Found more than 1 @Inject-annotated constructor for: %s", type); Constructor<?> constr = U.single(meta.injectableConstructors); Class<?>[] paramTypes = constr.getParameterTypes(); Object[] args = new Object[paramTypes.length]; for (int i = 0; i < args.length; i++) { Class<?> paramType = paramTypes[i]; String paramName = null; // FIXME inject by name args[i] = provideIoCInstanceOf(null, paramType, paramName, properties, false); } return Cls.invoke(constr, args); } else if (meta.defaultConstructor != null) { return Cls.invoke(meta.defaultConstructor); } else { throw U.illegal("Cannot find a default nor @Inject-annotated constructor for: %s", type); } }
@Override public Object call() throws Exception { for (int i = index; i < interceptors.length; i++) { InterceptorConfig ic = interceptors[i]; Annotation ann = null; boolean any = ic.annotated.isEmpty(); if (!any) { ann = findAnnotation(annotations, ic); } if (any || ann != null) { Callable<Object> forward = new ForwardCall(ic, annotations, m, target, args, interceptors, i + 1); Log.debug("Intercepting AOP call", "method", m, "annotation", ann); return ic.interceptor.intercept(forward, ann, context, m, target, args); } } return Cls.invoke(m, target, args); }