| /* |
| * 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.ProxyFor; |
| import com.google.web.bindery.requestfactory.shared.ProxyForName; |
| import com.google.web.bindery.requestfactory.shared.RequestContext; |
| import com.google.web.bindery.requestfactory.shared.RequestFactory; |
| import com.google.web.bindery.requestfactory.shared.Service; |
| import com.google.web.bindery.requestfactory.shared.ServiceName; |
| import com.google.web.bindery.requestfactory.vm.impl.Deobfuscator; |
| import com.google.web.bindery.requestfactory.vm.impl.OperationKey; |
| |
| import java.lang.reflect.Method; |
| import java.util.ArrayList; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.Set; |
| |
| /** |
| * Implements all of the resolution methods in ServiceLayer. |
| */ |
| final class ResolverServiceLayer extends ServiceLayerDecorator { |
| |
| private static Deobfuscator deobfuscator; |
| |
| private static synchronized void updateDeobfuscator(Class<? extends RequestFactory> clazz, |
| ClassLoader resolveClassesWith) { |
| Deobfuscator.Builder builder = Deobfuscator.Builder.load(clazz, resolveClassesWith); |
| if (deobfuscator != null) { |
| builder.merge(deobfuscator); |
| } |
| deobfuscator = builder.build(); |
| } |
| |
| @Override |
| public ClassLoader getDomainClassLoader() { |
| return Thread.currentThread().getContextClassLoader(); |
| } |
| |
| @Override |
| public Class<? extends BaseProxy> resolveClass(String typeToken) { |
| String deobfuscated = deobfuscator.getTypeFromToken(typeToken); |
| if (deobfuscated == null) { |
| die(null, "No type for token %s", typeToken); |
| } |
| |
| return forName(deobfuscated).asSubclass(BaseProxy.class); |
| } |
| |
| @Override |
| public <T> Class<? extends T> resolveClientType(Class<?> domainClass, Class<T> clientClass, |
| boolean required) { |
| if (List.class.isAssignableFrom(domainClass)) { |
| return List.class.asSubclass(clientClass); |
| } |
| if (Set.class.isAssignableFrom(domainClass)) { |
| return Set.class.asSubclass(clientClass); |
| } |
| if (Map.class.isAssignableFrom(domainClass)) { |
| return Map.class.asSubclass(clientClass); |
| } |
| if (TypeUtils.isValueType(domainClass)) { |
| return domainClass.asSubclass(clientClass); |
| } |
| |
| Class<? extends T> ret = resolveClientType(domainClass, clientClass); |
| if (ret == null && required) { |
| die(null, "The domain type %s cannot be sent to the client", domainClass.getCanonicalName()); |
| } |
| return ret; |
| } |
| |
| @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 (Map.class.equals(clazz)) { |
| return Map.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(String operation) { |
| /* |
| * The validator has already determined the mapping from the RequsetContext |
| * method to a domain method signature. We'll reuse this calculation instead |
| * of iterating over all methods. |
| */ |
| String domainDescriptor = deobfuscator.getDomainMethodDescriptor(operation); |
| |
| if (domainDescriptor == null) { |
| return die(null, "No domain method descriptor is mapped to operation %s", operation); |
| } |
| |
| Class<?>[] domainArgs = getArgumentTypes(domainDescriptor); |
| Class<? extends RequestContext> requestContext = getTop().resolveRequestContext(operation); |
| Class<?> serviceImplementation = getTop().resolveServiceClass(requestContext); |
| |
| // Request<FooProxy> someMethod(int a, double b, FooProxy c); |
| Method requestContextMethod = getTop().resolveRequestContextMethod(operation); |
| |
| Throwable ex; |
| try { |
| return serviceImplementation.getMethod(requestContextMethod.getName(), domainArgs); |
| } catch (SecurityException e) { |
| ex = e; |
| } catch (NoSuchMethodException e) { |
| ex = e; |
| } |
| |
| return die(ex, |
| "Could not find method in implementation %s matching descriptor %s for operation %s", |
| serviceImplementation.getCanonicalName(), domainDescriptor, operation); |
| } |
| |
| @Override |
| public Class<? extends RequestContext> resolveRequestContext(String operation) { |
| String requestContextClass = deobfuscator.getRequestContext(operation); |
| if (requestContextClass == null) { |
| die(null, "No RequestContext for operation %s", operation); |
| } |
| return forName(requestContextClass).asSubclass(RequestContext.class); |
| } |
| |
| @Override |
| public Method resolveRequestContextMethod(String operation) { |
| Class<?> searchIn = getTop().resolveRequestContext(operation); |
| String methodName = deobfuscator.getRequestContextMethodName(operation); |
| String descriptor = deobfuscator.getRequestContextMethodDescriptor(operation); |
| Class<?>[] params = getArgumentTypes(descriptor); |
| try { |
| return searchIn.getMethod(methodName, params); |
| } catch (NoSuchMethodException ex) { |
| return report("Could not locate %s operation %s", RequestContext.class.getSimpleName(), |
| operation); |
| } |
| } |
| |
| @Override |
| public Class<? extends RequestFactory> resolveRequestFactory(String binaryName) { |
| Class<? extends RequestFactory> toReturn = forName(binaryName).asSubclass(RequestFactory.class); |
| updateDeobfuscator(toReturn, getTop().getDomainClassLoader()); |
| return toReturn; |
| } |
| |
| @Override |
| public Class<?> resolveServiceClass(Class<? extends RequestContext> requestContextClass) { |
| Class<?> searchIn = null; |
| Service s = requestContextClass.getAnnotation(Service.class); |
| 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 OperationKey.hash(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); |
| } |
| } |
| |
| private Class<?>[] getArgumentTypes(String descriptor) { |
| assert descriptor.startsWith("(") && descriptor.endsWith(")V"); |
| ArrayList<Class<?>> params = new ArrayList<Class<?>>(); |
| for (int i = 1; i < descriptor.length() - 2; i++) { |
| switch (descriptor.charAt(i)) { |
| case 'Z': |
| params.add(boolean.class); |
| break; |
| case 'B': |
| params.add(byte.class); |
| break; |
| case 'C': |
| params.add(char.class); |
| break; |
| case 'D': |
| params.add(double.class); |
| break; |
| case 'F': |
| params.add(float.class); |
| break; |
| case 'I': |
| params.add(int.class); |
| break; |
| case 'J': |
| params.add(long.class); |
| break; |
| case 'S': |
| params.add(short.class); |
| break; |
| case 'V': |
| params.add(void.class); |
| break; |
| case 'L': |
| int end = descriptor.indexOf(';', i); |
| params.add(forName(descriptor.substring(i + 1, end).replace('/', '.'))); |
| i = end; |
| break; |
| case '[': |
| return die(null, "Unsupported Type (array) used in operation descriptor: %s", descriptor); |
| default: |
| return die(null, "Invalid operation descriptor: %s", descriptor); |
| } |
| } |
| return params.toArray(new Class<?>[params.size()]); |
| } |
| |
| private <T> Class<? extends T> resolveClientType(Class<?> domainClass, Class<T> clientClass) { |
| if (domainClass == null) { |
| return null; |
| } |
| |
| List<String> clientTypes = deobfuscator.getClientProxies(domainClass.getName()); |
| if (clientTypes != null) { |
| for (String clientType : clientTypes) { |
| Class<?> proxy = forName(clientType); |
| if (clientClass.isAssignableFrom(proxy)) { |
| return proxy.asSubclass(clientClass); |
| } |
| } |
| } |
| |
| for (Class<?> toSearch : domainClass.getInterfaces()) { |
| Class<? extends T> ret = resolveClientType(toSearch, clientClass); |
| if (ret != null) { |
| return ret; |
| } |
| } |
| |
| return resolveClientType(domainClass.getSuperclass(), clientClass); |
| } |
| } |