| /* | |
| * Copyright 2010 Google Inc. | |
| * | |
| * Licensed under the Apache License, Version 2.0 (the "License"); you may not | |
| * use this file except in compliance with the License. You may obtain a copy of | |
| * the License at | |
| * | |
| * http://www.apache.org/licenses/LICENSE-2.0 | |
| * | |
| * Unless required by applicable law or agreed to in writing, software | |
| * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT | |
| * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the | |
| * License for the specific language governing permissions and limitations under | |
| * the License. | |
| */ | |
| package com.google.web.bindery.requestfactory.server; | |
| import com.google.web.bindery.autobean.vm.impl.TypeUtils; | |
| import com.google.web.bindery.requestfactory.shared.BaseProxy; | |
| import com.google.web.bindery.requestfactory.shared.EntityProxy; | |
| import com.google.web.bindery.requestfactory.shared.EntityProxyId; | |
| import com.google.web.bindery.requestfactory.shared.ProxyFor; | |
| import com.google.web.bindery.requestfactory.shared.ProxyForName; | |
| import com.google.web.bindery.requestfactory.shared.RequestContext; | |
| import com.google.web.bindery.requestfactory.shared.Service; | |
| import com.google.web.bindery.requestfactory.shared.ServiceName; | |
| import com.google.web.bindery.requestfactory.shared.ValueProxy; | |
| import java.lang.reflect.Method; | |
| import java.util.List; | |
| import java.util.Set; | |
| import java.util.logging.Logger; | |
| /** | |
| * Implements all of the resolution methods in ServiceLayer. | |
| */ | |
| final class ResolverServiceLayer extends ServiceLayerDecorator { | |
| private static final Logger log = Logger.getLogger(ServiceLayer.class.getName()); | |
| /** | |
| * All instances of the service layer that are loaded by the same classloader | |
| * can use a shared validator. The use of the validator should be | |
| * synchronized, since it is stateful. | |
| */ | |
| private static final RequestFactoryInterfaceValidator validator = | |
| new RequestFactoryInterfaceValidator(log, | |
| new RequestFactoryInterfaceValidator.ClassLoaderLoader(ServiceLayer.class | |
| .getClassLoader())); | |
| @Override | |
| public ClassLoader getDomainClassLoader() { | |
| return Thread.currentThread().getContextClassLoader(); | |
| } | |
| @Override | |
| public Class<? extends BaseProxy> resolveClass(String typeToken) { | |
| Class<?> found = forName(typeToken); | |
| if (!EntityProxy.class.isAssignableFrom(found) && !ValueProxy.class.isAssignableFrom(found)) { | |
| die(null, "The requested type %s is not assignable to %s or %s", typeToken, EntityProxy.class | |
| .getCanonicalName(), ValueProxy.class.getCanonicalName()); | |
| } | |
| synchronized (validator) { | |
| validator.antidote(); | |
| validator.validateProxy(found.getName()); | |
| if (validator.isPoisoned()) { | |
| die(null, "The type %s did not pass RequestFactory validation", found.getCanonicalName()); | |
| } | |
| } | |
| return found.asSubclass(BaseProxy.class); | |
| } | |
| @Override | |
| public <T> Class<? extends T> resolveClientType(Class<?> domainClass, Class<T> clientClass, | |
| boolean required) { | |
| String name; | |
| synchronized (validator) { | |
| name = validator.getEntityProxyTypeName(domainClass.getName(), clientClass.getName()); | |
| } | |
| if (name != null) { | |
| return forName(name).asSubclass(clientClass); | |
| } | |
| if (List.class.isAssignableFrom(domainClass)) { | |
| return List.class.asSubclass(clientClass); | |
| } | |
| if (Set.class.isAssignableFrom(domainClass)) { | |
| return Set.class.asSubclass(clientClass); | |
| } | |
| if (TypeUtils.isValueType(domainClass)) { | |
| return domainClass.asSubclass(clientClass); | |
| } | |
| if (required) { | |
| die(null, "The domain type %s cannot be sent to the client", domainClass.getCanonicalName()); | |
| } | |
| return null; | |
| } | |
| @Override | |
| public Class<?> resolveDomainClass(Class<?> clazz) { | |
| if (List.class.equals(clazz)) { | |
| return List.class; | |
| } else if (Set.class.equals(clazz)) { | |
| return Set.class; | |
| } else if (BaseProxy.class.isAssignableFrom(clazz)) { | |
| ProxyFor pf = clazz.getAnnotation(ProxyFor.class); | |
| if (pf != null) { | |
| return pf.value(); | |
| } | |
| ProxyForName pfn = clazz.getAnnotation(ProxyForName.class); | |
| if (pfn != null) { | |
| Class<?> toReturn = forName(pfn.value()); | |
| return toReturn; | |
| } | |
| } | |
| return die(null, "Could not resolve a domain type for client type %s", clazz.getCanonicalName()); | |
| } | |
| @Override | |
| public Method resolveDomainMethod(Method requestContextMethod) { | |
| Class<?> declaringClass = requestContextMethod.getDeclaringClass(); | |
| Class<?> searchIn = | |
| getTop().resolveServiceClass(declaringClass.asSubclass(RequestContext.class)); | |
| Class<?>[] parameterTypes = requestContextMethod.getParameterTypes(); | |
| Class<?>[] domainArgs = new Class<?>[parameterTypes.length]; | |
| for (int i = 0, j = domainArgs.length; i < j; i++) { | |
| if (BaseProxy.class.isAssignableFrom(parameterTypes[i])) { | |
| domainArgs[i] = getTop().resolveDomainClass(parameterTypes[i].asSubclass(BaseProxy.class)); | |
| } else if (EntityProxyId.class.isAssignableFrom(parameterTypes[i])) { | |
| domainArgs[i] = | |
| TypeUtils.ensureBaseType(TypeUtils.getSingleParameterization(EntityProxyId.class, | |
| requestContextMethod.getGenericParameterTypes()[i])); | |
| } else { | |
| domainArgs[i] = parameterTypes[i]; | |
| } | |
| } | |
| Throwable ex; | |
| try { | |
| return searchIn.getMethod(requestContextMethod.getName(), domainArgs); | |
| } catch (SecurityException e) { | |
| ex = e; | |
| } catch (NoSuchMethodException e) { | |
| return report("Could not locate domain method %s", requestContextMethod.getName()); | |
| } | |
| return die(ex, "Could not get domain method %s in type %s", requestContextMethod.getName(), | |
| searchIn.getCanonicalName()); | |
| } | |
| @Override | |
| public Method resolveRequestContextMethod(String requestContextClass, String methodName) { | |
| synchronized (validator) { | |
| validator.antidote(); | |
| validator.validateRequestContext(requestContextClass); | |
| if (validator.isPoisoned()) { | |
| die(null, "The RequestContext type %s did not pass validation", requestContextClass); | |
| } | |
| } | |
| Class<?> searchIn = forName(requestContextClass); | |
| for (Method method : searchIn.getMethods()) { | |
| if (method.getName().equals(methodName)) { | |
| return method; | |
| } | |
| } | |
| return report("Could not locate %s method %s::%s", RequestContext.class.getSimpleName(), | |
| requestContextClass, methodName); | |
| } | |
| @Override | |
| public Class<?> resolveServiceClass(Class<? extends RequestContext> requestContextClass) { | |
| Class<?> searchIn = null; | |
| Service s = requestContextClass.getAnnotation(Service.class); | |
| // TODO Handle case when both annotations are present | |
| if (s != null) { | |
| searchIn = s.value(); | |
| } | |
| ServiceName sn = requestContextClass.getAnnotation(ServiceName.class); | |
| if (sn != null) { | |
| searchIn = forName(sn.value()); | |
| } | |
| if (searchIn == null) { | |
| die(null, "The %s type %s did not specify a service type", RequestContext.class | |
| .getSimpleName(), requestContextClass.getCanonicalName()); | |
| } | |
| return searchIn; | |
| } | |
| @Override | |
| public String resolveTypeToken(Class<? extends BaseProxy> clazz) { | |
| return clazz.getName(); | |
| } | |
| /** | |
| * Call {@link Class#forName(String)} and report any errors through | |
| * {@link #die()}. | |
| */ | |
| private Class<?> forName(String name) { | |
| try { | |
| return Class.forName(name, false, getTop().getDomainClassLoader()); | |
| } catch (ClassNotFoundException e) { | |
| return die(e, "Could not locate class %s", name); | |
| } | |
| } | |
| } |