Java反射机制在UI自动化测试中的一个应用

package com.sap.crm.ui.core.pages;

import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import com.sap.crm.ui.core.tags.ContainerElement;
import com.sap.crm.ui.core.tags.Element;
import com.sap.crm.ui.core.tags.ElementFactory;
import com.sap.crm.ui.core.tags.ParentElement;
import com.sap.crm.ui.core.tags.SubFactory;
import com.sap.crm.ui.core.tags.UISession;

public class AbstractPage {

	protected final UISession session;
	protected ParentElement container;

	public AbstractPage(final UISession session) {
		super();
		this.session = session;
		init();
	}

	protected void init() {
		final List<Field> fields = new ArrayList<Field>();
		final List<Field> subFields = new ArrayList<Field>();
		Map<Class<? extends SubObject>, Map<String, SubFactory<? extends SubObject>>> subFactories = new HashMap<>();

		Page pageAnnotation = this.getClass().getAnnotation(Page.class);
		Location defaultLocation = null;
		if (pageAnnotation != null) {
			defaultLocation = pageAnnotation.defaultLocation();
		}

		// Retrieve all fields/members that are declared as
		// public/protected/private.
		for (final Field field : this.getClass().getDeclaredFields()) {

			if (!field.isAccessible())
				field.setAccessible(true);

			final Class<?> type = field.getType();
			if (Element.class.isAssignableFrom(type) || type == String.class) {
				if (field.getAnnotation(Container.class) != null) {
					fields.add(0, field);
				} else {
					fields.add(field);
				}

			} else if (AbstractPage.class.isAssignableFrom(type)) {
				// element is inheriting from AbstractPage
				createSubPage(field, type);

			} else if (SubObject.class.isAssignableFrom(type)) {
				// subFactory e.g. for table columns
				subFields.add(field);
			}
		}

		// Now consider all fields that have a PageElement annotation and create
		// the concrete element instances via factory
		for (final Field field : fields) {
			PageElement pageElement = resolveAnnotations(field);

			if (pageElement != null) {
				final Class<?> type = field.getType();
				if (type == String.class) {
					// Just a versioned ID
					setField(field, pageElement.id());
					continue;
				}

				// Determine element type
				@SuppressWarnings("unchecked")
				Class<? extends Element> fieldType = (Class<? extends Element>) type;
				if (pageElement.type() != Element.class) {
					if (!fieldType.isAssignableFrom(pageElement.type())) {
						throw new IllegalArgumentException();
					}

					fieldType = pageElement.type();
				}

				// Get factory dependent from location
				Element element;
				ElementFactory factory = null;

				factory = resolveLocation(factory, pageElement, defaultLocation);

				// Check if proxy needed
				if (ElementFactory.isConcreteType(fieldType)) {
					// Concrete type is known, no proxy needed
					element = factory.element(fieldType, pageElement.id());
				} else {
					// Final Type is not known, need a proxy
					element = factory.proxy(pageElement.id());
				}

				if (field.getAnnotation(Container.class) != null) {
					container = (ContainerElement) element;
				}

				setField(field, element);

				// Remember subFactories
				if (SubFactory.class.isAssignableFrom(fieldType)) {
					registerSubFactory(subFactories, field, fieldType, element);
				}

			}
		}

		// Instantiate subObject fields from factories
		for (Field subField : subFields) {
			PageElement pageElement = resolveAnnotations(subField);

			// Get factory
			Map<String, SubFactory<? extends SubObject>> subFactoriesForType = subFactories
					.get(subField.getType());
			if (subFactoriesForType == null) {
				throw new IllegalArgumentException("Subfactory for type "
						+ subField.getType() + " could not be found on page");
			}
			SubFactory<? extends SubObject> subFactory = subFactoriesForType
					.get(pageElement.subFactoryName());
			if (subFactory == null) {
				throw new IllegalArgumentException("Subfactory for type "
						+ subField.getType() + " with name "
						+ pageElement.subFactoryName()
						+ " could not be found on page");
			}

			// Get parametrization for generic types
			ParameterizedType genericType = (ParameterizedType) subField
					.getGenericType();
			Type[] actualTypeArguments = genericType.getActualTypeArguments();

			// Produce and assign
			Object subObject = subFactory.produce(pageElement.id(),
					actualTypeArguments);
			try {
				subField.set(this, subObject);
			} catch (final IllegalAccessException e) {
				throw new IllegalStateException(e);
			}
		}
	}

	private void setField(final Field field, Object value) {
		try {
			field.set(this, value);
		} catch (final IllegalAccessException e) {
			throw new IllegalStateException(e);
		}
	}

	private void createSubPage(final Field field, final Class<?> type) {
		@SuppressWarnings("unchecked")
		final Class<? extends AbstractPage> pageType = (Class<AbstractPage>) type;
		// Create sub pages
		try {
			final Constructor<? extends AbstractPage> constructor = pageType
					.getConstructor(UISession.class);
			try {
				final AbstractPage page = constructor.newInstance(session);
				field.set(this, page);
			} catch (final IllegalArgumentException e) {
				e.printStackTrace();
			} catch (final InstantiationException e) {
				e.printStackTrace();
			} catch (final IllegalAccessException e) {
				e.printStackTrace();
			} catch (final InvocationTargetException e) {
				e.printStackTrace();
			}
		} catch (final NoSuchMethodException e) {
			// Ignore it, has to be coded manually
		}
	}

	private ElementFactory resolveLocation(ElementFactory factory,
			PageElement pageElement, Location defaultLocation) {
		Location location = pageElement.location();
		if (location == Location.DEFAULT && defaultLocation != null) {
			location = defaultLocation;
		}

		switch (location) {
		case ROOT:
			factory = session.ui();
			break;
		case CONTAINER:
			factory = container.contained();
			break;
		case DEFAULT:
			if (container != null) {
				factory = container.contained();
			} else {
				factory = session.workArea();
			}
			break;
		case TOOLBAR:
			factory = session.getToolbarFactory();
			break;
		case WORK_AREA:
			factory = session.workArea();
			break;
		}
		return factory;
	}

	private void registerSubFactory(
			Map<Class<? extends SubObject>, Map<String, SubFactory<? extends SubObject>>> subFactories,
			final Field field, Class<? extends Element> fieldType,
			Element element) {

		@SuppressWarnings("unchecked")
		SubFactory<? extends SubObject> subFactory = (SubFactory<? extends SubObject>) element;

		// Determine Name
		com.sap.crm.ui.core.pages.SubFactory annotation = field
				.getAnnotation(com.sap.crm.ui.core.pages.SubFactory.class);
		String subFactoryName = (annotation != null) ? annotation.name() : "";

		Class<? extends SubObject> targetType = findSubObjectFactoryTargetType(fieldType);
		Map<String, SubFactory<? extends SubObject>> subFactoriesForType = subFactories
				.get(targetType);
		if (subFactoriesForType == null) {
			subFactoriesForType = new HashMap<>();
			subFactories.put(targetType, subFactoriesForType);
		}

		if (subFactoriesForType.put(subFactoryName, subFactory) != null) {
			throw new IllegalStateException(
					"Ambiguous subObjectFactories on page for type "
							+ targetType + " with name " + subFactoryName);
		}
	}

	@SuppressWarnings("unchecked")
	private Class<? extends SubObject> findSubObjectFactoryTargetType(
			Class<? extends Element> fieldType) {
		Type[] genericInterfaces = fieldType.getGenericInterfaces();
		for (Type intf : genericInterfaces) {
			if (intf instanceof ParameterizedType
					&& ((ParameterizedType) intf).getRawType() == SubFactory.class) {
				Type[] actualTypeArguments = ((ParameterizedType) intf)
						.getActualTypeArguments();
				Type type = actualTypeArguments[0];
				Class<? extends SubObject> targetType;
				if (type instanceof ParameterizedType) {
					targetType = (Class<? extends SubObject>) ((ParameterizedType) type)
							.getRawType();

				} else {
					targetType = (Class<? extends SubObject>) type;
				}
				return targetType;
			}
		}
		throw new IllegalArgumentException();
	}

	private PageElement resolveAnnotations(final Field field) {
		// Fetch annotations
		final Versioned versionedAnnotation = field
				.getAnnotation(Versioned.class);
		PageElement pageElement = field.getAnnotation(PageElement.class);

		// Process versions
		if (versionedAnnotation != null) {
			int highestVersion = 0;
			for (final Version version : versionedAnnotation.versions()) {
				if (version.majorVersion() >= session.getMajorVersion()
						&& version.majorVersion() > highestVersion) {
					pageElement = version.element();
					highestVersion = version.majorVersion();
				}
			}
		}
		return pageElement;
	}
}