user/src/com/google/web/bindery/requestfactory/server/ReflectiveServiceLayer.java - gwt - Git at Google

 /*
  * 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.shared.ValueCodex;
 import com.google.web.bindery.autobean.vm.impl.BeanMethod;
 import com.google.web.bindery.autobean.vm.impl.TypeUtils;
 import com.google.web.bindery.requestfactory.shared.BaseProxy;
 import com.google.web.bindery.requestfactory.shared.InstanceRequest;
 import com.google.web.bindery.requestfactory.shared.Request;

 import java.lang.reflect.Constructor;
 import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Method;
 import java.lang.reflect.Modifier;
 import java.lang.reflect.Type;
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.Iterator;
 import java.util.List;
 import java.util.Set;
 import java.util.logging.Level;
 import java.util.logging.Logger;

 import javax.validation.ConstraintViolation;
 import javax.validation.Validation;
 import javax.validation.ValidationException;
 import javax.validation.Validator;
 import javax.validation.ValidatorFactory;

 /**
  * Implements all methods that interact with domain objects.
  */
 final class ReflectiveServiceLayer extends ServiceLayerDecorator {
   /*
    * NB: All calls that ReflectiveServiceLayer makes to public APIs inherited
    * from ServiceLayer should be made to use the instance returned from
    * getTop().
    */

   private static final Validator jsr303Validator;
   private static final Logger log = Logger.getLogger(ServiceLayer.class.getName());

   static {
     Validator found;
     try {
       ValidatorFactory validatorFactory = Validation.buildDefaultValidatorFactory();
       found = validatorFactory.getValidator();
     } catch (ValidationException e) {
       log.log(Level.INFO, "Unable to initialize a JSR 303 Bean Validator", e);
       found = null;
     }
     jsr303Validator = found;
   }

   /**
    * Linear search, but we want to handle getFoo, isFoo, and hasFoo. The result
    * of this method will be cached by the ServiceLayerCache.
    */
   private static Method getBeanMethod(BeanMethod methodType, Class<?> domainType, String property) {
     for (Method m : domainType.getMethods()) {
       if (methodType.matches(m) && property.equals(methodType.inferName(m))) {
         m.setAccessible(true);
         return m;
       }
     }
     return null;
   }

   @Override
   public <T> T createDomainObject(Class<T> clazz) {
     Throwable ex;
     try {
       Constructor<T> c = clazz.getConstructor();
       c.setAccessible(true);
       return c.newInstance();
     } catch (InstantiationException e) {
       e.printStackTrace();
       return this.<T> report("Could not create a new instance of the requested type");
     } catch (NoSuchMethodException e) {
       return this.<T> report("The requested type is not default-instantiable");
     } catch (InvocationTargetException e) {
       return this.<T> report(e);
     } catch (IllegalAccessException e) {
       ex = e;
     } catch (SecurityException e) {
       ex = e;
     } catch (IllegalArgumentException e) {
       ex = e;
     }
     return this.<T> die(ex, "Could not create a new instance of domain type %s", clazz
         .getCanonicalName());
   }

   @Override
   public Method getGetter(Class<?> domainType, String property) {
     return getBeanMethod(BeanMethod.GET, domainType, property);
   }

   @Override
   public Object getId(Object domainObject) {
     return getTop().getProperty(domainObject, "id");
   }

   @Override
   public Class<?> getIdType(Class<?> domainType) {
     return getFind(domainType).getParameterTypes()[0];
   }

   @Override
   public Object getProperty(Object domainObject, String property) {
     try {
       Method getter = getTop().getGetter(domainObject.getClass(), property);
       if (getter == null) {
         die(null, "Could not determine getter for property %s on type %s", property, domainObject
             .getClass().getCanonicalName());
       }
       Object value = getter.invoke(domainObject);
       return value;
     } catch (IllegalAccessException e) {
       return die(e, "Could not retrieve property %s", property);
     } catch (InvocationTargetException e) {
       return report(e);
     }
   }

   @Override
   public Type getRequestReturnType(Method contextMethod) {
     Class<?> returnClass = contextMethod.getReturnType();
     if (InstanceRequest.class.isAssignableFrom(returnClass)) {
       Type[] params =
           TypeUtils
               .getParameterization(InstanceRequest.class, contextMethod.getGenericReturnType());
       assert params.length == 2;
       return params[1];
     } else if (Request.class.isAssignableFrom(returnClass)) {
       Type param =
           TypeUtils.getSingleParameterization(Request.class, contextMethod.getGenericReturnType());
       return param;
     } else {
       return die(null, "Unknown RequestContext return type %s", returnClass.getCanonicalName());
     }
   }

   @Override
   public Method getSetter(Class<?> domainType, String property) {
     Method setter = getBeanMethod(BeanMethod.SET, domainType, property);
     if (setter == null) {
       setter = getBeanMethod(BeanMethod.SET_BUILDER, domainType, property);
     }
     return setter;
   }

   @Override
   public Object getVersion(Object domainObject) {
     return getTop().getProperty(domainObject, "version");
   }

   @Override
   public Object invoke(Method domainMethod, Object... args) {
     Throwable ex;
     try {
       domainMethod.setAccessible(true);
       if (Modifier.isStatic(domainMethod.getModifiers())) {
         return domainMethod.invoke(null, args);
       } else {
         Object[] realArgs = new Object[args.length - 1];
         System.arraycopy(args, 1, realArgs, 0, realArgs.length);
         return domainMethod.invoke(args[0], realArgs);
       }
     } catch (IllegalArgumentException e) {
       ex = e;
     } catch (IllegalAccessException e) {
       ex = e;
     } catch (InvocationTargetException e) {
       return report(e);
     }
     return die(ex, "Could not invoke method %s", domainMethod.getName());
   }

   /**
    * This implementation attempts to re-load the object from the backing store.
    */
   @Override
   public boolean isLive(Object domainObject) {
     Object id = getTop().getId(domainObject);
     return getTop().invoke(getFind(domainObject.getClass()), id) != null;
   }

   @Override
   public <T> T loadDomainObject(Class<T> clazz, Object id) {
     if (id == null) {
       die(null, "Cannot invoke find method with a null id");
     }
     return clazz.cast(getTop().invoke(getFind(clazz), id));
   }

   @Override
   public List<Object> loadDomainObjects(List<Class<?>> classes, List<Object> domainIds) {
     if (classes.size() != domainIds.size()) {
       die(null, "Size mismatch in paramaters. classes.size() = %d domainIds.size=%d", classes
           .size(), domainIds.size());
     }
     List<Object> toReturn = new ArrayList<Object>(classes.size());
     Iterator<Class<?>> classIt = classes.iterator();
     Iterator<Object> idIt = domainIds.iterator();
     while (classIt.hasNext()) {
       toReturn.add(getTop().loadDomainObject(classIt.next(), idIt.next()));
     }
     return toReturn;
   }

   @Override
   public void setProperty(Object domainObject, String property, Class<?> expectedType, Object value) {
     try {
       Method setter = getTop().getSetter(domainObject.getClass(), property);
       if (setter == null) {
         die(null, "Could not locate setter for property %s in type %s", property, domainObject
             .getClass().getCanonicalName());
       }
       setter.invoke(domainObject, value);
       return;
     } catch (IllegalAccessException e) {
       die(e, "Could not set property %s", property);
     } catch (InvocationTargetException e) {
       report(e);
     }
   }

   @Override
   public <T> Set<ConstraintViolation<T>> validate(T domainObject) {
     if (jsr303Validator != null) {
       return jsr303Validator.validate(domainObject);
     }
     return Collections.emptySet();
   }

   private Method getFind(Class<?> clazz) {
     if (clazz == null) {
       return die(null, "Could not find static method with a single" + " parameter of a key type");
     }
     String searchFor = "find" + clazz.getSimpleName();
     for (Method method : clazz.getMethods()) {
       if (!Modifier.isStatic(method.getModifiers())) {
         continue;
       }
       if (!searchFor.equals(method.getName())) {
         continue;
       }
       if (method.getParameterTypes().length != 1) {
         continue;
       }
       if (!isKeyType(method.getParameterTypes()[0])) {
         continue;
       }
       return method;
     }
     return getFind(clazz.getSuperclass());
   }

   /**
    * Returns <code>true</code> if the given class can be used as an id or
    * version key.
    */
   private boolean isKeyType(Class<?> domainClass) {
     if (ValueCodex.canDecode(domainClass)) {
       return true;
     }

     return BaseProxy.class.isAssignableFrom(getTop().resolveClientType(domainClass,
         BaseProxy.class, true));
   }
 }
	/*
	* 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.shared.ValueCodex;
	import com.google.web.bindery.autobean.vm.impl.BeanMethod;
	import com.google.web.bindery.autobean.vm.impl.TypeUtils;
	import com.google.web.bindery.requestfactory.shared.BaseProxy;
	import com.google.web.bindery.requestfactory.shared.InstanceRequest;
	import com.google.web.bindery.requestfactory.shared.Request;

	import java.lang.reflect.Constructor;
	import java.lang.reflect.InvocationTargetException;
	import java.lang.reflect.Method;
	import java.lang.reflect.Modifier;
	import java.lang.reflect.Type;
	import java.util.ArrayList;
	import java.util.Collections;
	import java.util.Iterator;
	import java.util.List;
	import java.util.Set;
	import java.util.logging.Level;
	import java.util.logging.Logger;

	import javax.validation.ConstraintViolation;
	import javax.validation.Validation;
	import javax.validation.ValidationException;
	import javax.validation.Validator;
	import javax.validation.ValidatorFactory;

	/**
	* Implements all methods that interact with domain objects.
	*/
	final class ReflectiveServiceLayer extends ServiceLayerDecorator {
	/*
	* NB: All calls that ReflectiveServiceLayer makes to public APIs inherited
	* from ServiceLayer should be made to use the instance returned from
	* getTop().
	*/

	private static final Validator jsr303Validator;
	private static final Logger log = Logger.getLogger(ServiceLayer.class.getName());

	static {
	Validator found;
	try {
	ValidatorFactory validatorFactory = Validation.buildDefaultValidatorFactory();
	found = validatorFactory.getValidator();
	} catch (ValidationException e) {
	log.log(Level.INFO, "Unable to initialize a JSR 303 Bean Validator", e);
	found = null;
	}
	jsr303Validator = found;
	}

	/**
	* Linear search, but we want to handle getFoo, isFoo, and hasFoo. The result
	* of this method will be cached by the ServiceLayerCache.
	*/
	private static Method getBeanMethod(BeanMethod methodType, Class<?> domainType, String property) {
	for (Method m : domainType.getMethods()) {
	if (methodType.matches(m) && property.equals(methodType.inferName(m))) {
	m.setAccessible(true);
	return m;
	}
	}
	return null;
	}

	@Override
	public <T> T createDomainObject(Class<T> clazz) {
	Throwable ex;
	try {
	Constructor<T> c = clazz.getConstructor();
	c.setAccessible(true);
	return c.newInstance();
	} catch (InstantiationException e) {
	e.printStackTrace();
	return this.<T> report("Could not create a new instance of the requested type");
	} catch (NoSuchMethodException e) {
	return this.<T> report("The requested type is not default-instantiable");
	} catch (InvocationTargetException e) {
	return this.<T> report(e);
	} catch (IllegalAccessException e) {
	ex = e;
	} catch (SecurityException e) {
	ex = e;
	} catch (IllegalArgumentException e) {
	ex = e;
	}
	return this.<T> die(ex, "Could not create a new instance of domain type %s", clazz
	.getCanonicalName());
	}

	@Override
	public Method getGetter(Class<?> domainType, String property) {
	return getBeanMethod(BeanMethod.GET, domainType, property);
	}

	@Override
	public Object getId(Object domainObject) {
	return getTop().getProperty(domainObject, "id");
	}

	@Override
	public Class<?> getIdType(Class<?> domainType) {
	return getFind(domainType).getParameterTypes()[0];
	}

	@Override
	public Object getProperty(Object domainObject, String property) {
	try {
	Method getter = getTop().getGetter(domainObject.getClass(), property);
	if (getter == null) {
	die(null, "Could not determine getter for property %s on type %s", property, domainObject
	.getClass().getCanonicalName());
	}
	Object value = getter.invoke(domainObject);
	return value;
	} catch (IllegalAccessException e) {
	return die(e, "Could not retrieve property %s", property);
	} catch (InvocationTargetException e) {
	return report(e);
	}
	}

	@Override
	public Type getRequestReturnType(Method contextMethod) {
	Class<?> returnClass = contextMethod.getReturnType();
	if (InstanceRequest.class.isAssignableFrom(returnClass)) {
	Type[] params =
	TypeUtils
	.getParameterization(InstanceRequest.class, contextMethod.getGenericReturnType());
	assert params.length == 2;
	return params[1];
	} else if (Request.class.isAssignableFrom(returnClass)) {
	Type param =
	TypeUtils.getSingleParameterization(Request.class, contextMethod.getGenericReturnType());
	return param;
	} else {
	return die(null, "Unknown RequestContext return type %s", returnClass.getCanonicalName());
	}
	}

	@Override
	public Method getSetter(Class<?> domainType, String property) {
	Method setter = getBeanMethod(BeanMethod.SET, domainType, property);
	if (setter == null) {
	setter = getBeanMethod(BeanMethod.SET_BUILDER, domainType, property);
	}
	return setter;
	}

	@Override
	public Object getVersion(Object domainObject) {
	return getTop().getProperty(domainObject, "version");
	}

	@Override
	public Object invoke(Method domainMethod, Object... args) {
	Throwable ex;
	try {
	domainMethod.setAccessible(true);
	if (Modifier.isStatic(domainMethod.getModifiers())) {
	return domainMethod.invoke(null, args);
	} else {
	Object[] realArgs = new Object[args.length - 1];
	System.arraycopy(args, 1, realArgs, 0, realArgs.length);
	return domainMethod.invoke(args[0], realArgs);
	}
	} catch (IllegalArgumentException e) {
	ex = e;
	} catch (IllegalAccessException e) {
	ex = e;
	} catch (InvocationTargetException e) {
	return report(e);
	}
	return die(ex, "Could not invoke method %s", domainMethod.getName());
	}

	/**
	* This implementation attempts to re-load the object from the backing store.
	*/
	@Override
	public boolean isLive(Object domainObject) {
	Object id = getTop().getId(domainObject);
	return getTop().invoke(getFind(domainObject.getClass()), id) != null;
	}

	@Override
	public <T> T loadDomainObject(Class<T> clazz, Object id) {
	if (id == null) {
	die(null, "Cannot invoke find method with a null id");
	}
	return clazz.cast(getTop().invoke(getFind(clazz), id));
	}

	@Override
	public List<Object> loadDomainObjects(List<Class<?>> classes, List<Object> domainIds) {
	if (classes.size() != domainIds.size()) {
	die(null, "Size mismatch in paramaters. classes.size() = %d domainIds.size=%d", classes
	.size(), domainIds.size());
	}
	List<Object> toReturn = new ArrayList<Object>(classes.size());
	Iterator<Class<?>> classIt = classes.iterator();
	Iterator<Object> idIt = domainIds.iterator();
	while (classIt.hasNext()) {
	toReturn.add(getTop().loadDomainObject(classIt.next(), idIt.next()));
	}
	return toReturn;
	}

	@Override
	public void setProperty(Object domainObject, String property, Class<?> expectedType, Object value) {
	try {
	Method setter = getTop().getSetter(domainObject.getClass(), property);
	if (setter == null) {
	die(null, "Could not locate setter for property %s in type %s", property, domainObject
	.getClass().getCanonicalName());
	}
	setter.invoke(domainObject, value);
	return;
	} catch (IllegalAccessException e) {
	die(e, "Could not set property %s", property);
	} catch (InvocationTargetException e) {
	report(e);
	}
	}

	@Override
	public <T> Set<ConstraintViolation<T>> validate(T domainObject) {
	if (jsr303Validator != null) {
	return jsr303Validator.validate(domainObject);
	}
	return Collections.emptySet();
	}

	private Method getFind(Class<?> clazz) {
	if (clazz == null) {
	return die(null, "Could not find static method with a single" + " parameter of a key type");
	}
	String searchFor = "find" + clazz.getSimpleName();
	for (Method method : clazz.getMethods()) {
	if (!Modifier.isStatic(method.getModifiers())) {
	continue;
	}
	if (!searchFor.equals(method.getName())) {
	continue;
	}
	if (method.getParameterTypes().length != 1) {
	continue;
	}
	if (!isKeyType(method.getParameterTypes()[0])) {
	continue;
	}
	return method;
	}
	return getFind(clazz.getSuperclass());
	}

	/**
	* Returns <code>true</code> if the given class can be used as an id or
	* version key.
	*/
	private boolean isKeyType(Class<?> domainClass) {
	if (ValueCodex.canDecode(domainClass)) {
	return true;
	}

	return BaseProxy.class.isAssignableFrom(getTop().resolveClientType(domainClass,
	BaseProxy.class, true));
	}
	}