@SuppressWarnings("unchecked") private static <A extends Annotation> void findRepeatableAnnotations( Annotation[] candidates, Class<A> annotationType, Class<? extends Annotation> containerType, boolean inherited, Set<A> found, Set<Annotation> visited) { for (Annotation candidate : candidates) { if (!isInJavaLangAnnotationPackage(candidate) && visited.add(candidate)) { // Exact match? if (candidate.annotationType().equals(annotationType)) { found.add(annotationType.cast(candidate)); } // Container? else if (candidate.annotationType().equals(containerType)) { // Note: it's not a legitimate container annotation if it doesn't declare // a 'value' attribute that returns an array of the contained annotation type. // Thus we proceed without verifying this assumption. Method method = ReflectionUtils.getMethod(containerType, "value").get(); Annotation[] containedAnnotations = (Annotation[]) ReflectionUtils.invokeMethod(method, candidate); found.addAll((Collection<? extends A>) asList(containedAnnotations)); } // Otherwise search recursively through the meta-annotation hierarchy... else { findRepeatableAnnotations( candidate.annotationType(), annotationType, containerType, inherited, found, visited); } } } }
@Test public void testMethodAnnotation() throws Exception { Method m = ReflectionUtils.getMethod(Bar1.class, "yelp"); Annotation a = ReflectionUtils.getMethodAnnotation(m, ControllerMethod.class); assertNotNull(a); assertTrue(a instanceof ControllerMethod); assertEquals("false", ((ControllerMethod) a).allow()); m = ReflectionUtils.getMethod(Alpha1.class, "yelp"); a = ReflectionUtils.getMethodAnnotation(m, ControllerMethod.class); assertNotNull(a); assertTrue(a instanceof ControllerMethod); m = ReflectionUtils.getMethod(Bogus1.class, "yelp"); a = ReflectionUtils.getMethodAnnotation(m, ControllerMethod.class); assertNull(a); }
/** * @param mBeanName * @param mBeanInstance * @param mBeanClassHierarchy * @param target * @param componentInstantiator * @param duServiceName the deployment unit's service name */ MBeanServices( final String mBeanName, final Object mBeanInstance, final List<ClassReflectionIndex<?>> mBeanClassHierarchy, final ServiceTarget target, ServiceComponentInstantiator componentInstantiator, final ServiceName duServiceName) { if (mBeanClassHierarchy == null) { throw SarMessages.MESSAGES.nullVar("mBeanName"); } if (mBeanInstance == null) { throw SarMessages.MESSAGES.nullVar("mBeanInstance"); } if (target == null) { throw SarMessages.MESSAGES.nullVar("target"); } final Method createMethod = ReflectionUtils.getMethod(mBeanClassHierarchy, CREATE_METHOD_NAME, NO_ARGS, false); final Method destroyMethod = ReflectionUtils.getMethod(mBeanClassHierarchy, DESTROY_METHOD_NAME, NO_ARGS, false); createDestroyService = new CreateDestroyService( mBeanInstance, createMethod, destroyMethod, componentInstantiator, duServiceName); createDestroyServiceName = ServiceNameFactory.newCreateDestroy(mBeanName); createDestroyServiceBuilder = target.addService(createDestroyServiceName, createDestroyService); if (componentInstantiator != null) { // the service that starts the EE component needs to start first createDestroyServiceBuilder.addDependency( componentInstantiator.getComponentStartServiceName()); } final Method startMethod = ReflectionUtils.getMethod(mBeanClassHierarchy, START_METHOD_NAME, NO_ARGS, false); final Method stopMethod = ReflectionUtils.getMethod(mBeanClassHierarchy, STOP_METHOD_NAME, NO_ARGS, false); startStopService = new StartStopService(mBeanInstance, startMethod, stopMethod, duServiceName); startStopServiceName = ServiceNameFactory.newStartStop(mBeanName); startStopServiceBuilder = target.addService(startStopServiceName, startStopService); startStopServiceBuilder.addDependency(createDestroyServiceName); this.mBeanName = mBeanName; this.target = target; this.duServiceName = duServiceName; }
/** * Reset the title settings * * @param player Player */ public static void resetTitle(Player player) { try { // Send timings first Object handle = ReflectionUtils.getHandle(player); Object connection = ReflectionUtils.getField(handle.getClass(), "playerConnection").get(handle); Object[] actions = packetActions.getEnumConstants(); Method sendPacket = ReflectionUtils.getMethod(connection.getClass(), "sendPacket"); Object packet = packetTitle .getConstructor(packetActions, chatBaseComponent) .newInstance(actions[4], null); sendPacket.invoke(connection, packet); } catch (Exception e) { e.printStackTrace(); } }
private static Value<?> getValue( final ValueFactory valueFactory, final List<ClassReflectionIndex> mBeanClassHierarchy, final ClassLoader classLoader) throws DeploymentUnitProcessingException { final String methodName = valueFactory.getMethodName(); final ValueFactoryParameter[] parameters = valueFactory.getParameters(); final List<Class<?>> paramTypes = new ArrayList<Class<?>>(parameters.length); final List<Value<?>> paramValues = new ArrayList<Value<?>>(parameters.length); for (ValueFactoryParameter parameter : parameters) { final Class<?> attributeTypeValue = ReflectionUtils.getClass(parameter.getType(), classLoader); paramTypes.add(attributeTypeValue); paramValues.add( new ImmediateValue<Object>(newValue(attributeTypeValue, parameter.getValue()))); } final Value<Method> methodValue = new ImmediateValue<Method>( ReflectionUtils.getMethod( mBeanClassHierarchy, methodName, paramTypes.toArray(new Class<?>[0]), true)); return cached(new MethodValue<Object>(methodValue, Values.injectedValue(), paramValues)); }
/** * Get a craft handle for a bukkit entity. * * @param entity entity to get the handle for. * @return the craft handle. */ public static Object getHandle(Entity entity) throws Exception { Object nms_entity = null; Method entity_getHandle = ReflectionUtils.getMethod(entity.getClass(), "getHandle"); nms_entity = entity_getHandle.invoke(entity); return nms_entity; }