basicintrospector.java

pojo的mvc框架

package xyz.frame.introspector;

import java.lang.reflect.Array;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.TreeSet;

import org.apache.log4j.Logger;
import xyz.frame.LogicRequest;
import xyz.frame.annotations.In;
import xyz.frame.annotations.Out;
import xyz.frame.component.ComponentInstantiationException;
import xyz.frame.component.ComponentType;
import xyz.frame.component.FieldAnnotation;
import xyz.frame.converter.ConversionException;
import xyz.frame.converter.ConverterManager;
import xyz.frame.i18n.Message;
import xyz.frame.jpath.JPathExecutor;
import xyz.frame.scope.RequestContext;
import xyz.frame.scope.ScopeLocator;
import xyz.frame.util.GettingException;
import xyz.frame.util.ReflectionUtil;
import xyz.frame.util.SettingException;

/**
 * The default introspector implementation.
 * 
 * @author Guilherme Silveira
 */
public class BasicIntrospector implements Introspector {

	private static final Logger logger = Logger
			.getLogger(BasicIntrospector.class);

	private KeyExtractor keyExtractor = new KeyExtractor();

	private ScopeLocator scopeLocator = new ScopeLocator();

	private TreeSet<Parameter> addAll(Set<String> keys) {
		TreeSet<Parameter> ts = new TreeSet<Parameter>();
		for (String key : keys) {
			ts.add(new Parameter(key));
		}
		return ts;
	}

	@SuppressWarnings("unchecked")
	public List<Message> readParameters(ComponentType clazz, Object component,
			LogicRequest logicRequest, ConverterManager converterManager)
			throws SettingException {

		JPathExecutor executor = new JPathExecutor(converterManager,
				logicRequest);
		RequestContext request = logicRequest.getRequestContext();

		Map<String, Object> parameters = request.getParameterMap();
		List<Message> problems = new ArrayList<Message>();

		out: for (Parameter p : addAll(parameters.keySet())) {
			String parameter = p.getKey();
			// String path[] = parameter.split("[\\.\\[\\]]+");
			for (FieldReadParameter read : clazz.getReadParameters()) {
				// tries to fill
				if (p.getPath()[0].equals(read.getKey())) {
					logger.debug("Parameter " + parameter
							+ " will be used on field " + read.getKey());
					try {
						// dont do this, cache it in request instead (or use the
						// internal request itself)
						executor.set(component, p.getPath(),
								singleValue(parameters.get(parameter)),
								arrayValue(parameters.get(parameter)), read);
					} catch (ConversionException e) {
						// validation problem...
						logger.debug(e.getMessage(), e);
						problems.add(e.getI18NMessage());
					}
					continue out;
				}
			}
			logger.debug("Parameter not used: " + parameter);
		}

		return problems;

	}

	private String[] arrayValue(Object val) {
		if (val.getClass().isArray()) {
			return (String[]) val;
		}
		return new String[] { (String) val };
	}

	private String singleValue(Object val) {
		if (val.getClass().isArray()) {
			return (String) Array.get(val, 0);
		}
		return (String) val;
	}

	public void inject(List<FieldAnnotation<In>> inAnnotations,
			Object component, LogicRequest context)
			throws ComponentInstantiationException, SettingException {

		for (FieldAnnotation<In> info : inAnnotations) {

			// tries to fill
			In in = info.getAnnotation();
			String key = keyExtractor.extractInKey(info);
			Object value = scopeLocator.get(in.scope(), context).getAttribute(
					key);

			logger.debug("Injecting " + value + " with key " + key + " at "
					+ in.scope());

			if (value == null) {
				if (in.create()) {
					logger.debug("Trying to create "
							+ info.getField().getType().getName());
					value = ReflectionUtil.instantiate(info.getField()
							.getType());
				} else if (in.required()) {
					throw new SettingException(
							"Unable to fill inject value for field "
									+ info.getField().getName());
				}
			}

			ReflectionUtil.setField(component, info.getField(), value);

		}

	}

	/**
	 * @see xyz.frame.introspector.Introspector#outject(java.util.List,
	 *      java.lang.Object, xyz.frame.scope.LogicRequest)
	 */
	public void outject(List<FieldAnnotation<Out>> outAnnotations,
			Object component, LogicRequest context) throws GettingException {
		for (FieldAnnotation<Out> info : outAnnotations) {
			// tries to fill
			Out out = info.getAnnotation();
			String key = keyExtractor.extractOutKey(info);
			Object value = ReflectionUtil.get(component, info.getField());
			logger.debug("Outjecting " + value + " with key " + key + " at "
					+ out.scope());
			scopeLocator.get(out.scope(), context).setAttribute(key, value);
		}
	}

}