private static void evaluateResourceClass(ClassResourceInfo cri, boolean enableStatic) {
MethodDispatcher md = new MethodDispatcher();
Class<?> serviceClass = cri.getServiceClass();
boolean isFineLevelLoggable = LOG.isLoggable(Level.FINE);
for (Method m : serviceClass.getMethods()) {
Method annotatedMethod = AnnotationUtils.getAnnotatedMethod(serviceClass, m);
String httpMethod = AnnotationUtils.getHttpMethodValue(annotatedMethod);
Path path = AnnotationUtils.getMethodAnnotation(annotatedMethod, Path.class);
if (httpMethod != null || path != null) {
md.bind(createOperationInfo(m, annotatedMethod, cri, path, httpMethod), m);
if (httpMethod == null) {
// subresource locator
Class<?> subClass = m.getReturnType();
if (enableStatic) {
ClassResourceInfo subCri = cri.findResource(subClass, subClass);
if (subCri == null) {
ClassResourceInfo ancestor = getAncestorWithSameServiceClass(cri, subClass);
subCri =
ancestor != null
? ancestor
: createClassResourceInfo(
subClass, subClass, cri, false, enableStatic, cri.getBus());
}
if (subCri != null) {
cri.addSubClassResourceInfo(subCri);
}
}
}
} else if (isFineLevelLoggable) {
LOG.fine(
new org.apache.cxf.common.i18n.Message(
"NOT_RESOURCE_METHOD", BUNDLE, m.getDeclaringClass().getName(), m.getName())
.toString());
}
}
cri.setMethodDispatcher(md);
}
public static ClassResourceInfo createServiceClassResourceInfo(
Map<String, UserResource> resources,
UserResource model,
Class<?> sClass,
boolean isRoot,
boolean enableStatic,
Bus bus) {
if (model == null) {
throw new RuntimeException("Resource class " + sClass.getName() + " has no model info");
}
ClassResourceInfo cri =
new ClassResourceInfo(
sClass,
sClass,
isRoot,
enableStatic,
true,
model.getConsumes(),
model.getProduces(),
bus);
URITemplate t = URITemplate.createTemplate(model.getPath());
cri.setURITemplate(t);
MethodDispatcher md = new MethodDispatcher();
Map<String, UserOperation> ops = model.getOperationsAsMap();
Method defaultMethod = null;
Map<String, Method> methodNames = new HashMap<String, Method>();
for (Method m : cri.getServiceClass().getMethods()) {
if (m.getAnnotation(DefaultMethod.class) != null) {
// if needed we can also support multiple default methods
defaultMethod = m;
}
methodNames.put(m.getName(), m);
}
for (Map.Entry<String, UserOperation> entry : ops.entrySet()) {
UserOperation op = entry.getValue();
Method actualMethod = methodNames.get(op.getName());
if (actualMethod == null) {
actualMethod = defaultMethod;
}
if (actualMethod == null) {
continue;
}
OperationResourceInfo ori =
new OperationResourceInfo(
actualMethod,
cri,
URITemplate.createTemplate(op.getPath()),
op.getVerb(),
op.getConsumes(),
op.getProduces(),
op.getParameters(),
op.isOneway());
String rClassName = actualMethod.getReturnType().getName();
if (op.getVerb() == null) {
if (resources.containsKey(rClassName)) {
ClassResourceInfo subCri =
rClassName.equals(model.getName())
? cri
: createServiceClassResourceInfo(
resources,
resources.get(rClassName),
actualMethod.getReturnType(),
false,
enableStatic,
bus);
if (subCri != null) {
cri.addSubClassResourceInfo(subCri);
md.bind(ori, actualMethod);
}
}
} else {
md.bind(ori, actualMethod);
}
}
cri.setMethodDispatcher(md);
return checkMethodDispatcher(cri) ? cri : null;
}
