private ClassMetadata createMetadata(Class<? extends Object> cls) { ClassMetadata md = ResourceMetadataCollector.collectMetadata(cls); md = fixConsumesAndProduces(md); return md; }
public static boolean isResource(Class<?> cls) { return (isStaticResource(cls) || isDynamicResource(cls)); }
public static ClassMetadata collectMetadata(Class<?> clazz) { logger.trace("collectMetadata({}) entry", clazz); ResourceMetadataCollector collector = new ResourceMetadataCollector(clazz); collector.parseClass(); collector.parseFields(); collector.parseConstructors(); collector.parseMethods(); ClassMetadata md = collector.getMetadata(); logger.trace("collectMetadata() exit returning {}", md); return md; }
private boolean parseClassConsumes(Class<?> cls) { String[] consumes = getConsumes(cls); // if (consumes.length == 0) { // getMetadata().addConsumes(MediaType.WILDCARD_TYPE); // return false; // } for (String mediaType : consumes) { getMetadata().addConsumes(MediaType.valueOf(mediaType)); } return true; }
final Class<Object> cls = (Class<Object>)bean.getClass(); if (ResourceMetadataCollector.isStaticResource(cls)) { springOFFactory .addResourceOrProvider(bean, new SpringObjectFactory(applicationContext, beanName, ProviderMetadataCollector .collectMetadata(cls))); } else if (ResourceMetadataCollector.isDynamicResource(cls)) { springOFFactory .addDynamicResource(bean, new SpringObjectFactory(applicationContext, beanName, ResourceMetadataCollector .collectMetadata(cls)));
MethodMetadata metadata = new MethodMetadata(getMetadata()); metadata.setReflectionMethod(method); HttpMethod httpMethod = getHttpMethod(method); if (httpMethod != null) { hasAnnotation = true; Path path = getPath(method); if (path != null) { hasAnnotation = true; String[] consumes = getConsumes(method); for (String mediaType : consumes) { hasAnnotation = true; String[] produces = getProduces(method); for (String mediaType : produces) { hasAnnotation = true; String defaultValue = getDefaultValue(method); if (defaultValue != null) { metadata.setDefaultValue(defaultValue); MethodMetadata createdMetadata = createMethodMetadata(superclass, method); mergeFormalParameterMetadata(createdMetadata, method); logger.trace("createMethodMetadata() exit returning {} from superclass {}", createdMetadata,
public void addResourceOrProvider(Object bean, String beanName, SpringObjectFactory objectFactory) { Class<? extends Object> cls = bean.getClass(); if (ResourceMetadataCollector.isStaticResource(cls) || ProviderMetadataCollector .isProvider(cls)) { SpringObjectFactory old = class2factory.put(cls, objectFactory); if (old != null) { if (logger.isWarnEnabled()) { logger.warn(Messages.getMessage("springClassReplaceNewerObjectFactory", cls)); //$NON-NLS-1$ } } } else { if (logger.isWarnEnabled()) { logger.warn(Messages.getMessage("springBeanNotResourceNorProvider", beanName, cls)); //$NON-NLS-1$ } } }
protected static <T> ClassMetadata collectClassMetadata(final Class<T> cls, boolean validateConstructor) { ClassMetadata classMetadata = null; if (ProviderMetadataCollector.isProvider(cls)) { classMetadata = ProviderMetadataCollector.collectMetadata(cls); } else if (ResourceMetadataCollector.isResource(cls)) { classMetadata = ResourceMetadataCollector.collectMetadata(cls); } else if (ApplicationMetadataCollector.isApplication(cls)) { classMetadata = ApplicationMetadataCollector.collectMetadata(cls); } else { throw new IllegalArgumentException(Messages.getMessage("cannotCreateFactoryForClass", cls)); //$NON-NLS-1$ } // validate that there is a valid constructor if needed if (validateConstructor && classMetadata.getConstructor().getConstructor() == null) { throw new IllegalStateException(Messages.getMessage("noValidConstructorFoundFor", cls //$NON-NLS-1$ .getCanonicalName())); } return classMetadata; }
protected boolean isResource(Class<?> cls) { if (ResourceMetadataCollector.isDynamicResource(cls)) { return true; } if (cls.getAnnotation(Path.class) != null) { return true; } Class<?> declaringClass = cls; while (!declaringClass.equals(Object.class)) { // try a superclass Class<?> superclass = declaringClass.getSuperclass(); if (superclass.getAnnotation(Path.class) != null) { return true; } // try interfaces Class<?>[] interfaces = declaringClass.getInterfaces(); for (Class<?> interfaceClass : interfaces) { if (interfaceClass.getAnnotation(Path.class) != null) { return true; } } declaringClass = declaringClass.getSuperclass(); } return false; }
/** * Process the given {@link Set} of {@link Class} objects and add them to the JAX-RS Class List if they are valid * JAX-RS Classes * * @param classes {@link Set} of {@link Class} objects to process */ private void processClasses(Set<Class<?>> classes) { for (Class<?> cls : classes) { if (ProviderMetadataCollector.isProvider(cls)) { LOGGER.log(Level.FINE, "Loaded REST Provider class: " + cls.getName()); jaxRSClasses.add(cls); } else if (ResourceMetadataCollector.isResource(cls)) { final Parent parent = (Parent) cls.getAnnotation(Parent.class); if ((parent != null && BaseRestResource.class.equals(parent.value()))) { LOGGER.log(Level.FINE, "Loaded REST Resource class: " + cls.getName()); jaxRSClasses.add(cls); } else if (BaseRestResource.class.equals(cls)) { LOGGER.log(Level.FINE, "Loaded Base REST Resource class: " + cls.getName()); jaxRSClasses.add(cls); } else { LOGGER.log(Level.FINE, "Class [" + cls.getName() + "] is not a valid REST Resource, " + "the @Parent(BaseRestResource.class) annotation is missing"); } } else { LOGGER.log(Level.FINE, "Skipping class [" + cls.getName() + "]; Its not a REST Resource or Provider"); } } }
private void parseMethods() { logger.trace("entry"); F1: for (Method method : getMetadata().getResourceClass().getMethods()) { Class<?> declaringClass = method.getDeclaringClass(); if (declaringClass == Object.class) { continue F1; MethodMetadata methodMetadata = createMethodMetadata(method); logger.trace("Found methodMetadata {} for method {}", methodMetadata, method); logger.trace("Was subresource method"); getMetadata().getSubResourceMethods().add(methodMetadata); } else { logger.trace("Was subresource locator"); getMetadata().getSubResourceLocators().add(methodMetadata); getMetadata().getResourceMethods().add(methodMetadata);
Method declaredMethod = declaringClass.getDeclaredMethod(method.getName(), method.getParameterTypes()); return createMethodMetadata(declaredMethod); } catch (SecurityException e) { return createMethodMetadata(candidateMethod);
if (ResourceMetadataCollector.isStaticResource(cls)) { resourceRegistry.addResource(obj, priority); } else if (ProviderMetadataCollector.isProvider(cls)) {
public void addDynamicResource(Object bean, String beanName, SpringObjectFactory objectFactory) { Class<? extends Object> cls = bean.getClass(); if (ResourceMetadataCollector.isDynamicResource(cls)) { DynamicResource dynResource = (DynamicResource)bean; dynResource.setBeanName(beanName); SpringObjectFactory old = id2factory.put(beanName, objectFactory); if (old != null) { if (logger.isWarnEnabled()) { logger.warn(Messages .getMessage("springClassReplaceNewerObjectFactory", beanName)); //$NON-NLS-1$ } } } else { if (logger.isWarnEnabled()) { logger .warn(Messages.getMessage("springBeanClassNotDynamicResource", beanName, cls)); //$NON-NLS-1$ } } }
public SpringObjectFactory getSpringObjectFactory(T object, String beanName) { Class<? extends Object> cls = object.getClass(); if (ResourceMetadataCollector.isStaticResource(cls) || ProviderMetadataCollector .isProvider(cls)) { return class2factory.get(cls); } if (ResourceMetadataCollector.isDynamicResource(cls)) { return id2factory.get(beanName); } return null; }
if (ResourceMetadataCollector.isStaticResource(cls) || ProviderMetadataCollector .isProvider(cls)) { if (logger.isTraceEnabled()) {
/* package */Set<ClassMetadata> buildClassMetdata(Set<Class<?>> classes) { Set<ClassMetadata> metadataSet = new HashSet<ClassMetadata>(classes.size()); for (Class<?> c : classes) { if (!isResource(c)) { /* not a resource, so skip it */ continue; } ClassMetadata metadata = ResourceMetadataCollector.collectMetadata(c); metadataSet.add(metadata); } return metadataSet; }
/** * Returns true if the resource is valid resource and false otherwise. * Notice that a class with Path annotation can be validated only once, * since it must be unique. Therefore, calling this method for the same * class can return true only for the first time. * * @param cls * @return true if the resource is valid resource and false otherwise. */ public boolean isValidResource(Class<?> cls) { return isValidClass(cls) && ((ResourceMetadataCollector.isStaticResource(cls) && classUnique(cls)) || ResourceMetadataCollector .isDynamicResource(cls)); }
if (ResourceMetadataCollector.isStaticResource(cls)) { resourceRegistry.addResource(cls, priority); } else if (ProviderMetadataCollector.isProvider(cls)) {
@SuppressWarnings("unchecked") public ObjectFactory<T> createObjectFactory(T object) throws ObjectCreationException { Class<? extends Object> cls = object.getClass(); if (ResourceMetadataCollector.isStaticResource(cls) || ProviderMetadataCollector .isProvider(cls)) { return (ObjectFactory<T>)class2factory.get(cls); } if (ResourceMetadataCollector.isDynamicResource(cls)) { DynamicResource dynResource = (DynamicResource)object; String beanName = dynResource.getBeanName(); return (ObjectFactory<T>)id2factory.get(beanName); } return null; }