コード例 #1
0
  /**
   * Find the InputSource for the WSDL file stored in _wsdlName. This method attempts to find a WSDL
   * file by:
   *
   * <ol>
   *   <li>If the _wsdlName can be converted to a URL, use url.openStream()
   *   <li>Attempt to locate _wsdlName using the bean context's getResourceAsStream()
   *   <li>Attempt to locate _wsdlName using the current class loader's getResourceAsStream()
   * </ol>
   *
   * @return An InputSource for the WSDL file.
   */
  public InputSource getBaseInputSource() {

    InputStream wsdlStream = null;

    // try to open as URL first --
    try {
      URL url = new URL(_wsdlName);
      wsdlStream = url.openStream();
    } catch (MalformedURLException e) {
      // not fatal keep trying
    } catch (IOException e) {
      // fatal - abort
      throw new RuntimeException("Cannot load WSDL file: " + _wsdlName, e);
    }

    if (wsdlStream == null) {
      wsdlStream = _beanContext.getBeanContext().getResourceAsStream(_wsdlName, _beanContext);
    }

    if (wsdlStream == null) {
      wsdlStream = this.getClass().getClassLoader().getResourceAsStream(_wsdlName);
    }

    if (wsdlStream == null) {
      throw new RuntimeException("Cannot find WSDL file: " + _wsdlName, null);
    }

    _openStreams.add(wsdlStream);
    return new InputSource(wsdlStream);
  }
コード例 #2
0
ファイル: Beans.java プロジェクト: bloodstars/OpenJDK
 @SuppressWarnings("unchecked")
 private static void unsafeBeanContextAdd(BeanContext beanContext, Object res) {
   beanContext.add(res);
 }
コード例 #3
0
ファイル: Beans.java プロジェクト: java66liu/classlib6
  /**
   * Instantiate a bean.
   *
   * <p>The bean is created based on a name relative to a class-loader. This name should be a
   * dot-separated name such as "a.b.c".
   *
   * <p>In Beans 1.0 the given name can indicate either a serialized object or a class. Other
   * mechanisms may be added in the future. In beans 1.0 we first try to treat the beanName as a
   * serialized object name then as a class name.
   *
   * <p>When using the beanName as a serialized object name we convert the given beanName to a
   * resource pathname and add a trailing ".ser" suffix. We then try to load a serialized object
   * from that resource.
   *
   * <p>For example, given a beanName of "x.y", Beans.instantiate would first try to read a
   * serialized object from the resource "x/y.ser" and if that failed it would try to load the class
   * "x.y" and create an instance of that class.
   *
   * <p>If the bean is a subtype of java.applet.Applet, then it is given some special
   * initialization. First, it is supplied with a default AppletStub and AppletContext. Second, if
   * it was instantiated from a classname the applet's "init" method is called. (If the bean was
   * deserialized this step is skipped.)
   *
   * <p>Note that for beans which are applets, it is the caller's responsiblity to call "start" on
   * the applet. For correct behaviour, this should be done after the applet has been added into a
   * visible AWT container.
   *
   * <p>Note that applets created via beans.instantiate run in a slightly different environment than
   * applets running inside browsers. In particular, bean applets have no access to "parameters", so
   * they may wish to provide property get/set methods to set parameter values. We advise
   * bean-applet developers to test their bean-applets against both the JDK appletviewer (for a
   * reference browser environment) and the BDK BeanBox (for a reference bean container).
   *
   * @param cls the class-loader from which we should create the bean. If this is null, then the
   *     system class-loader is used.
   * @param beanName the name of the bean within the class-loader. For example "sun.beanbox.foobah"
   * @param beanContext The BeanContext in which to nest the new bean
   * @param initializer The AppletInitializer for the new bean
   * @exception java.lang.ClassNotFoundException if the class of a serialized object could not be
   *     found.
   * @exception java.io.IOException if an I/O error occurs.
   */
  public static Object instantiate(
      ClassLoader cls, String beanName, BeanContext beanContext, AppletInitializer initializer)
      throws java.io.IOException, ClassNotFoundException {

    java.io.InputStream ins;
    java.io.ObjectInputStream oins = null;
    Object result = null;
    boolean serialized = false;
    java.io.IOException serex = null;

    // If the given classloader is null, we check if an
    // system classloader is available and (if so)
    // use that instead.
    // Note that calls on the system class loader will
    // look in the bootstrap class loader first.
    if (cls == null) {
      try {
        cls = ClassLoader.getSystemClassLoader();
      } catch (SecurityException ex) {
        // We're not allowed to access the system class loader.
        // Drop through.
      }
    }

    // Try to find a serialized object with this name
    final String serName = beanName.replace('.', '/').concat(".ser");
    final ClassLoader loader = cls;
    ins =
        (InputStream)
            java.security.AccessController.doPrivileged(
                new java.security.PrivilegedAction() {
                  public Object run() {
                    if (loader == null) return ClassLoader.getSystemResourceAsStream(serName);
                    else return loader.getResourceAsStream(serName);
                  }
                });
    if (ins != null) {
      try {
        if (cls == null) {
          oins = new ObjectInputStream(ins);
        } else {
          oins = new ObjectInputStreamWithLoader(ins, cls);
        }
        result = oins.readObject();
        serialized = true;
        oins.close();
      } catch (java.io.IOException ex) {
        ins.close();
        // Drop through and try opening the class.  But remember
        // the exception in case we can't find the class either.
        serex = ex;
      } catch (ClassNotFoundException ex) {
        ins.close();
        throw ex;
      }
    }

    if (result == null) {
      // No serialized object, try just instantiating the class
      Class cl;

      try {
        cl = ClassFinder.findClass(beanName, cls);
      } catch (ClassNotFoundException ex) {
        // There is no appropriate class.  If we earlier tried to
        // deserialize an object and got an IO exception, throw that,
        // otherwise rethrow the ClassNotFoundException.
        if (serex != null) {
          throw serex;
        }
        throw ex;
      }

      /*
       * Try to instantiate the class.
       */

      try {
        result = cl.newInstance();
      } catch (Exception ex) {
        // We have to remap the exception to one in our signature.
        // But we pass extra information in the detail message.
        throw new ClassNotFoundException("" + cl + " : " + ex, ex);
      }
    }

    if (result != null) {

      // Ok, if the result is an applet initialize it.

      AppletStub stub = null;

      if (result instanceof Applet) {
        Applet applet = (Applet) result;
        boolean needDummies = initializer == null;

        if (needDummies) {

          // Figure our the codebase and docbase URLs.  We do this
          // by locating the URL for a known resource, and then
          // massaging the URL.

          // First find the "resource name" corresponding to the bean
          // itself.  So a serialzied bean "a.b.c" would imply a
          // resource name of "a/b/c.ser" and a classname of "x.y"
          // would imply a resource name of "x/y.class".

          final String resourceName;

          if (serialized) {
            // Serialized bean
            resourceName = beanName.replace('.', '/').concat(".ser");
          } else {
            // Regular class
            resourceName = beanName.replace('.', '/').concat(".class");
          }

          URL objectUrl = null;
          URL codeBase = null;
          URL docBase = null;

          // Now get the URL correponding to the resource name.

          final ClassLoader cloader = cls;
          objectUrl =
              (URL)
                  java.security.AccessController.doPrivileged(
                      new java.security.PrivilegedAction() {
                        public Object run() {
                          if (cloader == null) return ClassLoader.getSystemResource(resourceName);
                          else return cloader.getResource(resourceName);
                        }
                      });

          // If we found a URL, we try to locate the docbase by taking
          // of the final path name component, and the code base by taking
          // of the complete resourceName.
          // So if we had a resourceName of "a/b/c.class" and we got an
          // objectURL of "file://bert/classes/a/b/c.class" then we would
          // want to set the codebase to "file://bert/classes/" and the
          // docbase to "file://bert/classes/a/b/"

          if (objectUrl != null) {
            String s = objectUrl.toExternalForm();

            if (s.endsWith(resourceName)) {
              int ix = s.length() - resourceName.length();
              codeBase = new URL(s.substring(0, ix));
              docBase = codeBase;

              ix = s.lastIndexOf('/');

              if (ix >= 0) {
                docBase = new URL(s.substring(0, ix + 1));
              }
            }
          }

          // Setup a default context and stub.
          BeansAppletContext context = new BeansAppletContext(applet);

          stub = (AppletStub) new BeansAppletStub(applet, context, codeBase, docBase);
          applet.setStub(stub);
        } else {
          initializer.initialize(applet, beanContext);
        }

        // now, if there is a BeanContext, add the bean, if applicable.

        if (beanContext != null) {
          beanContext.add(result);
        }

        // If it was deserialized then it was already init-ed.
        // Otherwise we need to initialize it.

        if (!serialized) {
          // We need to set a reasonable initial size, as many
          // applets are unhappy if they are started without
          // having been explicitly sized.
          applet.setSize(100, 100);
          applet.init();
        }

        if (needDummies) {
          ((BeansAppletStub) stub).active = true;
        } else initializer.activate(applet);

      } else if (beanContext != null) beanContext.add(result);
    }

    return result;
  }