typefactory.java

来自「RESIN 3.2 最新源码」· Java 代码 · 共 870 行 · 第 1/2 页

    String scheme;

    int p = url.indexOf(':');
    if (p >= 0)
      scheme = url.substring(0, p);
    else
      scheme = url;

    String typeName = getDriverType(api.getName(), scheme);

    if (typeName == null) {
      ArrayList<String> schemes = new ArrayList<String>();

      getDriverSchemes(schemes, api.getName());

      Collections.sort(schemes);
      
      throw new ConfigException(L.l("'{0}' is an unknown scheme for driver '{1}'.  The available schemes are '{2}'",
				    scheme, api.getName(), schemes));
    }

    try {
      ClassLoader loader = Thread.currentThread().getContextClassLoader();
      Class cl = Class.forName(typeName, false, loader);

      if (! api.isAssignableFrom(cl))
	throw new ConfigException(L.l("'{0}' is not assignable to '{1}' for scheme '{2}'",
				      cl.getName(), api.getName(),
				      scheme));

      return cl;
    } catch (RuntimeException e) {
      throw e;
    } catch (Exception e) {
      throw new ConfigException(L.l("'{0}' is an undefined class for scheme '{1}'",
				    typeName, scheme), e);
    }
  }

  public ContainerProgram getUrlProgram(String url)
  {
    String properties = "";

    int p = url.indexOf(':');
    if (p >= 0) {
      properties = url.substring(p + 1);
    }
    else
      return null;

    String []props = properties.split("[;]");

    if (props.length == 0)
      return null;

    ContainerProgram program = new ContainerProgram();
    for (String prop : props) {
      if (prop.length() == 0)
	continue;
      
      String []values = prop.split("[=]");

      if (values.length != 2)
	throw new ConfigException(L.l("'{0}' is an invalid URL.  Bean URL syntax is 'scheme:prop1=value1;prop2=value2'", url));

      program.addProgram(new PropertyStringProgram(values[0], values[1]));
    }

    return program;
  }

  /**
   * Returns the classname of the given driver.
   *
   * @param apiType the driver API
   * @param scheme the configuration scheme
   */
  public String getDriverType(String apiType, String scheme)
  {
    HashMap<String,String> driverMap = getDriverTypeMap(apiType);
    
    return driverMap.get(scheme);
  }

  /**
   * Returns a list of schemes supported by the api type.
   *
   * @param schemes the return list of schemes scheme
   * @param apiType the driver API
   */
  public void getDriverSchemes(ArrayList<String> schemes, String apiType)
  {
    HashMap<String,String> driverMap = getDriverTypeMap(apiType);

    ClassLoader loader = _loader;
    if (_loader == null)
      loader = ClassLoader.getSystemClassLoader();
    
    for (Map.Entry<String,String> entry : driverMap.entrySet()) {
      String scheme = entry.getKey();
      String type = entry.getValue();

      try {
	Class cl = Class.forName(type, false, loader);

	if (cl != null)
	  schemes.add(scheme);
      } catch (Exception e) {
	log.finest(apiType + " schemes: " + e.toString());
      }
    }
  }

  /**
   * Loads the map for a driver.
   */
  private HashMap<String,String> getDriverTypeMap(String apiType)
  {
    synchronized (_driverTypeMap) {
      HashMap<String,String> driverMap = _driverTypeMap.get(apiType);

      if (driverMap == null) {
	driverMap = new HashMap<String,String>();

	if (_parent != null)
	  driverMap.putAll(_parent.getDriverTypeMap(apiType));

	loadDriverTypeMap(driverMap, apiType);

	_driverTypeMap.put(apiType, driverMap);
      }

      return driverMap;
    }
  }

  /**
   * Reads the drivers from the META-INF/caucho
   */
  private void loadDriverTypeMap(HashMap<String,String> driverMap,
				 String apiType)
  {
    try {
      ClassLoader loader = _loader;

      if (loader == null)
	loader = ClassLoader.getSystemClassLoader();
      
      Enumeration<URL> urls
	= loader.getResources("META-INF/caucho/com.caucho.config.uri/"
			      + apiType);

      while (urls.hasMoreElements()) {
	URL url = urls.nextElement();

	if (hasDriver(url))
	  continue;

	_driverTypeSet.add(url);

	InputStream is = url.openStream();

	try {
	  Properties props = new Properties();

	  props.load(is);

	  for (Map.Entry entry : props.entrySet()) {
	    driverMap.put((String) entry.getKey(), (String) entry.getValue());
	  }
	} finally {
	  is.close();
	}
      }
    } catch (Exception e) {
      throw ConfigException.create(e);
    }
  }

  protected boolean hasDriver(URL url)
  {
    synchronized (_driverTypeSet) {
      if (_driverTypeSet.contains(url))
	return true;
      else if (_parent != null)
	return _parent.hasDriver(url);
      else
	return false;
    }
  }

  //
  // AddLoaderListener
  //
  
  /**
   * Called with the loader config changes.
   */
  public void addLoader(EnvironmentClassLoader loader)
  {
    init(loader);
  }

  //
  // Configuration methods
  //

  /**
   * Adds an new environment attribute.
   */
  public NamespaceConfig createNamespace()
  {
    return new NamespaceConfig();
  }

  /**
   * Adds an new environment attribute.
   */
  public void addNamespace(NamespaceConfig ns)
  {
    _nsMap.put(ns.getName(), ns);

    if (ns.isDefault())
      _nsMap.put(ns.getName(), ns);
  }

  // configuration types
  public class NamespaceConfig {
    private String _ns = "";
    private boolean _isDefault;
    private Path _path;
    
    private AtomicBoolean _isBeansLoaded = new AtomicBoolean();

    private HashMap<String,BeanConfig> _beanMap
      = new HashMap<String,BeanConfig>();

    public void setName(String ns)
    {
      if ("default".equals(ns))
	ns = "";
      
      _ns = ns;
    }

    public String getName()
    {
      return _ns;
    }

    public void setDefault(boolean isDefault)
    {
      _isDefault = isDefault;
    }

    public boolean isDefault()
    {
      return _isDefault;
    }

    public void setPath(String path)
    {
      if (path.indexOf(':') < 0)
	_path = Vfs.lookup("classpath:" + path);
      else
	_path = Vfs.lookup(path);
    }

    public Path getPath()
    {
      return _path;
    }

    public void loadBeans()
    {
      if (_isBeansLoaded.getAndSet(true))
	return;

      try {
	new Config().configure(this, _path);
      } catch (IOException e) {
	log.log(Level.WARNING, e.toString(), e);
      }
    }

    public ConfigType getBean(String name)
    {
      BeanConfig beanConfig = _beanMap.get(name);

      if (beanConfig != null)
	return beanConfig.getConfigType();
      else
	return null;
    }

    public BeanConfig createBean()
    {
      return new BeanConfig(_ns, _isDefault);
    }

    public void addBean(BeanConfig bean)
    {
      _beanMap.put(bean.getName(), bean);
    }

    public FlowConfig createFlow()
    {
      return new FlowConfig(_ns, _isDefault);
    }

    public void addFlow(FlowConfig flow)
    {
      _beanMap.put(flow.getName(), flow);
    }
  }

  public class BeanConfig {
    private String _ns;
    private boolean _isDefault;

    private String _name;
    private String _className;

    private ConfigType _configType;
    private ClassLoader _loader;

    BeanConfig(String ns, boolean isDefault)
    {
      _ns = ns;
      _isDefault = isDefault;
      _loader = Thread.currentThread().getContextClassLoader();
    }

    public void setName(String name)
    {
      _name = name;
    }

    public String getName()
    {
      return _name;
    }

    public void setClass(String className)
    {
      _className = className;
    }

    public ConfigType getConfigType()
    {
      try {
	if (_configType == null) {
	  QName qName = new QName(null, _name, _ns);
	
	  Class cl = Class.forName(_className, false, _loader);

	  ConfigType type = createType(cl);

	  type.introspect();

	  _configType = type;
	}
      
	return _configType;
      } catch (Exception e) {
	throw ConfigException.create(e);
      }
    }

    @PostConstruct
    public void init()
    {
      if (_name == null)
	throw new ConfigException(L.l("bean requires a 'name' attribute"));
      
      if (_className == null)
	throw new ConfigException(L.l("bean requires a 'class' attribute"));
    }
  }

  public class FlowConfig extends BeanConfig {
    FlowConfig(String ns, boolean isDefault)
    {
      super(ns, isDefault);
    }
  }

  public String toString()
  {
    return getClass().getSimpleName() + "[" + _loader + "]";
  }

  static {
    _primitiveTypes.put(boolean.class, BooleanPrimitiveType.TYPE);
    _primitiveTypes.put(byte.class, BytePrimitiveType.TYPE);
    _primitiveTypes.put(short.class, ShortPrimitiveType.TYPE);
    _primitiveTypes.put(int.class, IntegerPrimitiveType.TYPE);
    _primitiveTypes.put(long.class, LongPrimitiveType.TYPE);
    _primitiveTypes.put(float.class, FloatPrimitiveType.TYPE);
    _primitiveTypes.put(double.class, DoublePrimitiveType.TYPE);
    _primitiveTypes.put(char.class, CharacterPrimitiveType.TYPE);

    _primitiveTypes.put(Boolean.class, BooleanType.TYPE);
    _primitiveTypes.put(Byte.class, ByteType.TYPE);
    _primitiveTypes.put(Short.class, ShortType.TYPE);
    _primitiveTypes.put(Integer.class, IntegerType.TYPE);
    _primitiveTypes.put(Long.class, LongType.TYPE);
    _primitiveTypes.put(Float.class, FloatType.TYPE);
    _primitiveTypes.put(Double.class, DoubleType.TYPE);
    _primitiveTypes.put(Character.class, CharacterType.TYPE);

    _primitiveTypes.put(Object.class, ObjectType.TYPE);
    
    _primitiveTypes.put(String.class, StringType.TYPE);
    _primitiveTypes.put(RawString.class, RawStringType.TYPE);
    
    _primitiveTypes.put(String[].class, StringArrayType.TYPE);
    
    _primitiveTypes.put(Class.class, ClassType.TYPE);
    _primitiveTypes.put(Path.class, PathType.TYPE);
    _primitiveTypes.put(File.class, FileType.TYPE);
    _primitiveTypes.put(URL.class, UrlType.TYPE);
    _primitiveTypes.put(Pattern.class, PatternType.TYPE);
    _primitiveTypes.put(Locale.class, LocaleType.TYPE);
    _primitiveTypes.put(Node.class, NodeType.TYPE);
    _primitiveTypes.put(QDate.class, QDateType.TYPE);
    _primitiveTypes.put(Date.class, DateType.TYPE);
    _primitiveTypes.put(Properties.class, PropertiesType.TYPE);
    
    // _primitiveTypes.put(DataSource.class, DataSourceType.TYPE);
    
    _primitiveTypes.put(MethodExpression.class, MethodExpressionType.TYPE);
  }
}