@Override public void queueInit() { if (queueInit != null) { queueInit.invoke(this.service); } }
public void addMethods(final String path, final Collection<MethodAccess> methods) { /* Only add methods that could be REST endpoints. */ methods.stream().filter(methodAccess -> !methodAccess.isPrivate() && //No private methods !methodAccess.isStatic() && //No static methods !methodAccess.method().isSynthetic() && //No synthetic methods !methodAccess.method().getDeclaringClass().getName().contains("$$EnhancerByGuice$$") && !methodAccess.name().contains("$")) //No methods with $ as this could be Scala generated // method or byte code lib generated .forEach(methodAccess -> addMethod(path, methodAccess)); }
private static boolean hasQueueCallbackAnnotations(Object service) { @SuppressWarnings("unchecked") ClassMeta<Class<?>> classMeta = (ClassMeta<Class<?>>) ClassMeta.classMeta(service.getClass()); final Iterable<MethodAccess> methods = classMeta.methods(); for (MethodAccess methodAccess : methods) { if (methodAccess.hasAnnotation(QUEUE_CALLBACK_ANNOTATION_NAME)) { return true; } } return false; } }
private boolean hasHandlers(MethodAccess serviceMethod) { if (Promise.class.isAssignableFrom(serviceMethod.returnType())) { return true; } for (Class<?> paramType : serviceMethod.parameterTypes()) { if (paramType == Callback.class) { return true; } } return false; }
private void registerMethod(MethodAccess methodAccess) { if (!methodAccess.isPrivate()) { String methodAddress = readAddressFromAnnotation(methodAccess); if (methodAddress != null && !methodAddress.isEmpty()) { doRegisterMethodUnderURI(methodAccess, methodAddress); } } doRegisterMethodUnderURI(methodAccess, methodAccess.name()); doRegisterMethodUnderURI(methodAccess, methodAccess.name().toLowerCase()); doRegisterMethodUnderURI(methodAccess, methodAccess.name().toUpperCase()); }
private <T> Map<String, String> createMethodToChannelMap(final String channelPrefix, final Class<T> eventBusProxyInterface) { final Map<String, String> methodToChannelMap = new ConcurrentHashMap<>(20); final ClassMeta<T> classMeta = classMeta(eventBusProxyInterface); final AnnotationData classAnnotation = classMeta.annotation(AnnotationUtils.EVENT_CHANNEL_ANNOTATION_NAME); final String classEventBusName = AnnotationUtils.getClassEventChannelName(classMeta, classAnnotation); classMeta.methods().forEach(methodAccess -> { AnnotationData methodAnnotation = methodAccess.annotation(AnnotationUtils.EVENT_CHANNEL_ANNOTATION_NAME); String methodEventBusName = methodAnnotation != null && methodAnnotation.getValues().get("value") != null ? methodAnnotation.getValues().get("value").toString() : null; if (Str.isEmpty(methodEventBusName)) { methodEventBusName = methodAccess.name(); } final String channelName = createChannelName(channelPrefix, classEventBusName, methodEventBusName); methodToChannelMap.put(methodAccess.method().toString(), channelName); }); return methodToChannelMap; }
private void processAnnotationForMethod(final MethodAccess methodAccess) { final AnnotationData annotation = methodAccess.annotation(QUEUE_CALLBACK_ANNOTATION_NAME); final Object[] values = (Object[]) annotation.getValues().get("value"); break; case DYNAMIC: switch (methodAccess.name()) { case "queueIdle": queueIdle = methodAccess;
public static void invokeMethodWithAnnotationWithReturnType(Class<?> type, Object object, String annotation, Class<?> returnType) { ClassMeta classMeta = ClassMeta.classMeta(type); Iterable<MethodAccess> iterate = classMeta.methods(); for (MethodAccess m : iterate) { if (m.hasAnnotation(annotation)) { if (m.parameterTypes().length == 0 && m.returnType() == void.class) { m.invoke(object); break; } } } }
public Response<Object> mapArgsAsyncHandlersAndInvoke(MethodCall<Object> methodCall, MethodAccess serviceMethod) { boolean hasHandlers = boonServiceMethodCallHandler.hasHandlers(methodCall, serviceMethod); Object returnValue; if (hasHandlers) { Object[] args = (Object[]) methodCall.body(); Object[] argsList = prepareArgumentList(methodCall, serviceMethod.parameterTypes()); extractHandlersFromArgumentList(serviceMethod, args, argsList); returnValue = serviceMethod.invoke(boonServiceMethodCallHandler.service, argsList); if (returnValue instanceof Promise) { final Promise<Object> promise = ((Promise<Object>) returnValue); promise .then(value -> { boonServiceMethodCallHandler.responseSendQueue.send(ResponseImpl.response(methodCall, value)); }) .catchError(error -> { boonServiceMethodCallHandler.responseSendQueue.send(ResponseImpl.error(methodCall, error)); }).invoke(); return ServiceConstants.VOID; } } else { final Object[] argsList = (Object[]) methodCall.body(); returnValue = serviceMethod.invoke(boonServiceMethodCallHandler.service, argsList); } return boonServiceMethodCallHandler.response(serviceMethod, methodCall, returnValue); }
Class<?> compType = null; if (Promise.class.isAssignableFrom(method.returnType()) ) { Type t0 = method.method().getGenericReturnType(); if (t0 instanceof ParameterizedType) { ParameterizedType parameterizedType = ((ParameterizedType) t0); if (method.parameterTypes().length > 0) { Type[] genericParameterTypes = method.getGenericParameterTypes(); ParameterizedType parameterizedType = genericParameterTypes.length > 0 ? (ParameterizedType) genericParameterTypes[0] : null;
public Response<Object> mapArgsAsyncHandlersAndInvoke(MethodCall<Object> serviceMethodCall, MethodAccess serviceMethod) { if (serviceMethod.parameterTypes().length == 0 && !(Promise.class.isAssignableFrom(serviceMethod.returnType()))) { Object returnValue = serviceMethod.invokeDynamicObject(boonServiceMethodCallHandler.service, null); return boonServiceMethodCallHandler.response(serviceMethod, serviceMethodCall, returnValue); List<Object> argsList = boonServiceMethodCallHandler.prepareArgumentList(serviceMethodCall, serviceMethod.parameterTypes()); if (body instanceof List || body instanceof Object[]) { boonServiceMethodCallHandler.extractHandlersFromArgumentList(serviceMethodCall.callback(), serviceMethod, body, argsList); returnValue = serviceMethod.invokeDynamicObject(boonServiceMethodCallHandler.service, argsList); if (serviceMethodCall.body() instanceof List) { final List argsList = (List) serviceMethodCall.body(); returnValue = serviceMethod.invokeDynamic(boonServiceMethodCallHandler.service, argsList.toArray(new Object[argsList.size()])); } else if (serviceMethodCall.body() instanceof Object[]) { final Object[] argsList = (Object[]) serviceMethodCall.body(); returnValue = serviceMethod.invokeDynamic(boonServiceMethodCallHandler.service, argsList); } else { returnValue = serviceMethod.invokeDynamic(boonServiceMethodCallHandler.service, serviceMethodCall.body());
public ServiceBuilder setServiceObject(final Object serviceObject) { if (serviceObject == null) { throw new IllegalArgumentException("ServiceBuilder setServiceObject:: serviceObject cant be null"); } ClassMeta<?> classMeta = ClassMeta.classMeta(serviceObject.getClass()); Iterable<MethodAccess> methods = classMeta.methods(); Set<String> methodNames = new HashSet<>(); for (MethodAccess methodAccess : methods) { if (methodAccess.isPrivate() || methodAccess.method().getDeclaringClass().getName().contains("$$EnhancerByGuice$$")) { continue; } if (methodNames.contains(methodAccess.name())) { logger.error("QBit does not support method overloading methods in Service Queues" + " problem name " + methodAccess.name() + " is overloaded " + methodNames + " from class " + classMeta.longName()); } else { methodNames.add(methodAccess.name()); } } this.serviceObject = serviceObject; return this; }
public void addParameters(final String rootPath, final String servicePath, final String path, final MethodAccess methodAccess) { final List<List<AnnotationData>> paramsAnnotationData = methodAccess.annotationDataForParams(); final List<TypeType> typeTypes = methodAccess.paramTypeEnumList(); final Class<?>[] parameterTypes = methodAccess.method().getParameterTypes();
returnType = methodAccess.returnType(); ParameterizedType genericReturnType = (ParameterizedType) methodAccess.method().getGenericReturnType(); this.returnTypeComponent = (Class) genericReturnType.getActualTypeArguments()[0]; } else if (Map.class.isAssignableFrom(returnType)) { genericReturnType = GenericReturnType.MAP; ParameterizedType genericReturnType = (ParameterizedType) methodAccess.method().getGenericReturnType(); this.returnTypeComponentKey = (Class) genericReturnType.getActualTypeArguments()[0]; this.returnTypeComponentValue = (Class) genericReturnType.getActualTypeArguments()[1]; } else if (Optional.class.isAssignableFrom(returnType)) { genericReturnType = GenericReturnType.OPTIONAL; ParameterizedType genericReturnType = (ParameterizedType) methodAccess.method().getGenericReturnType(); this.returnTypeComponent = (Class) genericReturnType.getActualTypeArguments()[0]; } else if (JSendResponse.class.isAssignableFrom(returnType)) { genericReturnType = GenericReturnType.JSEND; ParameterizedType genericReturnType = (ParameterizedType) methodAccess.method().getGenericReturnType();
public String getName() { if (name == null) { if (methodAccess != null) { name = methodAccess.name(); } } return name; }
@Override public void handleEvent(Event<Object> event) { MethodAccess methodAccess = eventMap.get(event.channel()); if (invokeDynamic) { final Object body = event.body(); if (body instanceof List) { List list = ((List) body); methodAccess.invokeDynamic(service, list.toArray(new Object[list.size()])); } else if (body instanceof Object[]) { final Object[] array = (Object[]) body; methodAccess.invokeDynamic(service, array); } else { methodAccess.invokeDynamicObject(service, body); } } else { final Object body = event.body(); if (body instanceof List) { List list = ((List) body); methodAccess.invoke(service, list.toArray(new Object[list.size()])); } else if (body instanceof Object[]) { final Object[] array = (Object[]) body; methodAccess.invoke(service, array); } else { methodAccess.invoke(service, body); } } }
final Object[] inputParams, final List<Object> preparedArgumentList) { final Class<?>[] parameterTypes = serviceMethod.method().getParameterTypes();
final Class<?>[] parameterTypes = serviceMethod.method().getParameterTypes(); if (serviceMethod.method().getReturnType() == void.class && (list.size() - 1 == serviceMethod.parameterTypes().length)) { if (parameterTypes[0] == Callback.class) { list = Lists.slc(list, 1); //remove the callback from the args bc the callback is called
public boolean respondsTo(String methodName, Class<?>... types) { Iterable<MethodAccess> methods = this.methodsMulti.getAll(methodName); for (MethodAccess methodAccess : methods) { if (methodAccess.isStatic()) continue; if (methodAccess.respondsTo(types) ) { return true; }; } return false; }
protected Response<Object> response(MethodAccess methodAccess, MethodCall<Object> methodCall, Object returnValue) { if (methodAccess.returnType() == void.class || methodAccess.returnType() == Void.class) { return ServiceConstants.VOID; } return ResponseImpl.response(methodCall.id(), methodCall.timestamp(), methodCall.address(), methodCall.returnAddress(), returnValue, methodCall); }