databinder.java

非常接近C/S操作方式的Java Ajax框架－ZK 用ZK框架使你的B/S应用程序更漂亮更易操作。 官网：www.zkoss.org

			Binding binding = (Binding) it.next();
			binding.registerSaveEventListener(comp);
			binding.registerLoadEventListeners(comp);
		}
	}
	
	private void registerBeanidBinding(Component comp, Collection attrs) {
		for(final Iterator it = attrs.iterator(); it.hasNext();) {
			Binding binding = (Binding) it.next();
			if (binding.canLoad()) {
				final String beanid = binding.getBeanid();
				Set bindings = (Set) _beanBindingMap.get(beanid);
				if (bindings == null) {
					bindings = new LinkedHashSet(32);
					_beanBindingMap.put(beanid, bindings);
				}
				bindings.add(binding);
			}
		}
	}
	
//vv----------------------------------------
//:TODO: The following code is Component type tightly coupled, should change to use interface...

	//20061205, Henri Chen: Tightly coupled with Component type
	private void setupRenderer(Component template) {
		if (template instanceof Listitem) {
			final Listitem li = (Listitem) template;
			final Listbox lbx = li.getListbox();
			if (lbx.getItemRenderer() == null) {
				lbx.setItemRenderer(new Renderer(li));
			}
		}
	}
	
	//20061205, Henri Chen: Tightly coupled with Component type
	//get index of the specified component, if not a indexitem, return -1.
	private Object getListModelItem(Component comp, String beanid) {
		final Component indexitem = (Component) comp.getAttribute(INDEXITEM);
		if (indexitem != null && indexitem instanceof Listitem) {
			final Listitem li = (Listitem) indexitem;
			final String var = (String)getTemplateComponent(li).getAttribute(VAR);
			if (beanid.equals(var)) {
				final Listbox lbx = li.getListbox();
				final ListModel model = lbx.getModel();
				final int index = li.getIndex();
				return model.getElementAt(index);
			} else {
				return NA;
			}
		}
		throw new UiException("Unsupported collection item component for DataBinder: "+comp);
	}
	
//^^----------------------------------------------
	//get associated template component of a cloned component
	private Component getTemplateComponent(Component comp) {
		return (Component) comp.getAttribute(TEMPLATE);
	}
	
	//set associated template component of a cloned component
	private void setTemplateComponent(Component comp, Component template) {
		comp.setAttribute(TEMPLATE, template);
	}

	//whether a cloned item
	private boolean isClone(Component comp) {
		return getTemplateComponent(comp) != null;
	}

	//whether the specified component a template component
	private boolean isTemplate(Component comp) {
		return comp.getAttribute(ISTEMPLATE) == Boolean.TRUE;
	}

	//set the specified comp and its decendents to be template (or not)
	private void setupTemplate(Component comp, Boolean b) {
		comp.setAttribute(ISTEMPLATE, b);
		List kids = comp.getChildren();
		for(final Iterator it = kids.iterator(); it.hasNext(); ) {
			setupTemplate((Component) it.next(), b); //recursive
		}
	}

	//given reference cloned component, return assoicated cloned component of _comp
	private Object lookupComponentByReference(Object bean, Component ref, Component comp) {
		if (isTemplate(comp)) {
			final Component item = (Component) ref.getAttribute(INDEXITEM);
			final Map compMap = (Map) (item != null ? _cloneMap.get(item) : _cloneMap.get(bean));
			//ref could have not been rendered, so the associate _cloneMap has not been established.
			if (compMap != null) {
				return (Component) compMap.get(comp);
			} else {
				return NA;
			}
		} else {
			return comp;
		}
	}

	//parse token and return as a String[]
	protected String[] parseExpression(String expr, String seperator) {
		List list = myParseExpression(expr, seperator);
		if (list == null) {
			return null;
		}
		String[] results = new String[list.size()];
		int j = 0;
		for(final Iterator it = list.iterator(); it.hasNext(); ++j) {
			String result = (String) it.next();
			if (result != null) {
				result  = result.trim();
				if (result.length() == 0)
					result = null;
			}
			if (j == 0 && result == null) {
				return null;
			}
			results[j] = result;
		}
		return results;
	}
	
	private List myParseExpression(String expr, String separator) {
		if (expr == null) {
			return null;
		}
		List results = new ArrayList(5);
		while(true) {
			int j = expr.indexOf(separator);
			if (j < 0) {
				results.add(expr);
				return results;
			}
			results.add(expr.substring(0, j));

			if (expr.length() <= (j+1)) {
				return results;
			}
			expr = expr.substring(j+1);
		}
	}

	//assume no state is stored in TypeConverter
	private static TypeConverter lookupConverter(String clsName) {
		TypeConverter converter = (TypeConverter) _converterMap.get(clsName);
		if (converter == null) {
			try {
				converter = (TypeConverter) Classes.newInstanceByThread(clsName);
				_converterMap.put(clsName, converter);
			} catch (java.lang.reflect.InvocationTargetException ex) {
				throw UiException.Aide.wrap(ex);
			} catch (Exception ex) {
				throw UiException.Aide.wrap(ex);
			}
		}
		return converter;
	}

	private String[] mergeStringArray(String[] s1, String[] s2) {
		if (s2 == null) {
			return s1;
		}
		int sz1 = s1 == null ? 0 : s1.length;
		int sz2 = s2.length;
		String[] merge = new String[sz1 + sz2];
		
		if (sz1 > 0) {
			System.arraycopy(s1, 0, merge, 0, sz1);
		}
		if (sz2 > 0) {
			System.arraycopy(s2, 0, merge, sz1, sz2);
		}
		return merge;
	}
	
	//A binding association class.
	private class Binding {
		private Component _comp;
		private String _attr;
		private String _value;
		private String _beanid;
		private String _props; //a.b.c
		private String[] _loadWhenEvents;
		private String _saveWhenEvent;
		private boolean _canLoad = true; //default access to "load"
		private boolean _canSave;
		private TypeConverter _converter;
		
		/** Construtor to form a binding between UI component and backend data bean.
		 * @param comp The concerned component
		 * @param attr The attribute of the component to be associated.
		 * @param value The expression to associate the data bean.
		 * @param loadWhenEvents The event list when to load data.
		 * @param saveWhenEvent The event when to save data.
		 * @param access In the view of UI component: "load" load only, "both" load/save, "save" save only when doing
		 * data binding. null means using the default access natural of the component. e.g. Label.value is "load", 
		 * but Textbox.value is "both".
		 * @param converter The converter class used to convert classes between component and the associated bean.
		 * null means using the default class conversion method.
		 */
		private Binding(Component comp, String attr, String value, 
			String[] loadWhenEvents, String saveWhenEvent, String access, String converter) {
				
			_comp = comp;
			setAttr(attr);
			setValue(value);
			addLoadWhenEvents(loadWhenEvents);
			setSaveWhenEvent(saveWhenEvent);
			setAccess(access);
			setConverter(converter);
		}
		
		private void setAttr(String attr) {
			_attr = attr;
		}
		
		private void setValue(String value) {
			if (value != null) {
				String[] results = splitBeanid(value);
				_beanid = results[0];
				_props = results[1];
			}
		}
		
		private void setSaveWhenEvent(String saveWhenEvent) {
			if (saveWhenEvent != null) {
				_saveWhenEvent = saveWhenEvent;
			}
		}
		
		private void addLoadWhenEvents(String[] loadWhenEvents) {
			_loadWhenEvents = mergeStringArray(_loadWhenEvents, loadWhenEvents);
		}

		private void setAccess(String access) {
			if (access == null) { //default access to load
				return;
			}
			
			if ("both".equals(access)) {
				_canLoad = true;
				_canSave = true;
			} else if ("load".equals(access)) {
				_canLoad = true;
				_canSave = false;
			} else if ("save".equals(access)) {
				_canLoad = false;
				_canSave = true;
			} else if ("none".equals(access)) { //unknow access mode
				_canLoad = false;
				_canSave = false;
			} else {
				throw new UiException("Unknown DataBinder access mode. Should be \"both\", \"load\", \"save\", or \"none\": "+access);
			}
		}
		
		private void setConverter(String converter) {
			if (converter != null) {
				_converter = lookupConverter(converter);
			}
		}			
		
		private String getBeanid() {
			return _beanid;
		}
		
		private String getValue() {
			return _beanid+(_props == null ? "" : ("."+_props));
		}
		
		private String getAttr() {
			return _attr;
		}
		
		//register events when to load component value from the bean
		private void registerLoadEventListeners(Component comp) {
			if (_loadWhenEvents != null) {
				for(int j = 0; j < _loadWhenEvents.length; ++j) {
					String expr = _loadWhenEvents[j];
					String[] results = splitBeanid(expr); //[0] bean id or bean path, [1] event name
					Component target = (Component) ("self".equals(results[0]) ? comp : lookupBean(comp, results[0]));
					registerLoadEventListener(results[1], target, comp);
				}
			}
		}

		//register events when to save component value to the bean.
		private void registerSaveEventListener(Component comp) {
			if (_saveWhenEvent != null) {
				String expr = _saveWhenEvent;
				String[] results = splitBeanid(expr); //[0] bean id or bean path, [1] event name
				Component target = (Component) ("self".equals(results[0]) ? comp : lookupBean(comp, results[0]));
				registerSaveEventListener(results[1], target, comp);
			}
		}

		private void registerLoadEventListener(String eventName, Component target, Component dataTarget) {
			target.addEventListener(eventName, new LoadEventListener(dataTarget));
		}

		private void registerSaveEventListener(String eventName, Component target, Component dataTarget) {
			target.addEventListener(eventName, new SaveEventListener(dataTarget));
		}
		
		private boolean canLoad() {
			return _canLoad;
		}
		
		private boolean canSave() {
			return _canSave;
		}

		private void loadAttributeByReference(Component comp, Object bean) {
			final Object clone = lookupComponentByReference(bean, comp, _comp);
			if (clone != NA) {
				loadAttribute((Component)clone);
			}
		}
		
		//link same beanid together
		private void registerSameBeanid(Object bean) {
			if (!canLoad()) {
				return;
			}
			//register beanid
			Set beanidSet = null;
			beanidSet = (Set) _sameBeanidMap.get(bean);
			if (beanidSet == null) {
				beanidSet = (Set) _sameBeanidMap.get(_beanid);
			}
			if (beanidSet == null) {
				beanidSet = new HashSet(5);
			}
			if (bean != null) {
				_sameBeanidMap.put(bean, beanidSet);
			}
			_sameBeanidMap.put(_beanid, beanidSet);
			beanidSet.add(_beanid);
		}			
		
		private void loadAttribute(Component comp) {
			if (!canLoad()) { //cannot load , skip
				return;
			}