pluginregistryimpl.java

java插件系统源码

                            }
                        }
                    }
                }
            }
            for (Iterator it = registeredExtensions.values().iterator();
                    it.hasNext();) {
                Extension ext = (Extension) it.next();
                registryChangeData.putRemovedExtension(ext.getUniqueId(),
                        makeUniqueId(ext.getExtendedPluginId(),
                                ext.getExtendedPointId()));
            }
            // fire event
            fireEvent(registryChangeData);
        }
        return result;
    }
    
    private void checkVersions(final Map plugins)
            throws ManifestProcessingException {
        Map versions = new HashMap(); //<ID, [Version, URL]>
        Set toBeRemovedUrls = new HashSet(); //<URL>
        for (Iterator it = plugins.entrySet().iterator(); it.hasNext();) {
            Map.Entry entry = (Map.Entry) it.next();
            URL url = (URL) entry.getKey();
            ModelPluginManifest model = (ModelPluginManifest) entry.getValue();
            if (registeredPlugins.containsKey(model.getId())) {
                if (stopOnError) {
                    throw new ManifestProcessingException(PACKAGE_NAME,
                            "duplicatePlugin", //$NON-NLS-1$
                            model.getId());
                }
                it.remove();
                registrationReport.add(new ReportItemImpl(
                        ReportItem.SEVERITY_ERROR, null,
                        ReportItem.ERROR_MANIFEST_PROCESSING_FAILED,
                        "duplicatedPluginId", model.getId())); //$NON-NLS-1$
                continue;
            }
            if (registeredFragments.containsKey(model.getId())) {
                if (stopOnError) {
                    throw new ManifestProcessingException(PACKAGE_NAME,
                            "duplicatePluginFragment", //$NON-NLS-1$
                            model.getId());
                }
                it.remove();
                registrationReport.add(new ReportItemImpl(
                        ReportItem.SEVERITY_ERROR, null,
                        ReportItem.ERROR_MANIFEST_PROCESSING_FAILED,
                        "duplicatedFragmentId", model.getId())); //$NON-NLS-1$
                continue;
            }
            Object[] version = (Object[]) versions.get(model.getId());
            if (version == null) {
                versions.put(model.getId(),
                        new Object[] {model.getVersion(), url});
                continue;
            }
            if (((Version) version[0]).compareTo(model.getVersion()) < 0) {
                toBeRemovedUrls.add(version[1]);
                versions.put(model.getId(),
                        new Object[] {model.getVersion(), url});
            } else {
                toBeRemovedUrls.add(url);
            }
        }
        versions.clear();
        for (Iterator it = toBeRemovedUrls.iterator(); it.hasNext();) {
            URL url = (URL) it.next();
            plugins.remove(url);
            log.warn("ignoring duplicated manifest " + url); //$NON-NLS-1$
        }
        toBeRemovedUrls.clear();
    }

    private PluginDescriptor registerPlugin(final URL url,
            final ModelPluginDescriptor model,
            final RegistryChangeDataImpl registryChangeData)
            throws ManifestProcessingException {
        if (log.isDebugEnabled()) {
            log.debug("registering plug-in, URL - " + url); //$NON-NLS-1$
        }
        PluginDescriptorImpl result = null;
        try {
            result = new PluginDescriptorImpl(this, model, url);
            registryChangeData.addedPlugins().add(result.getId());
            // applying fragments to the new plug-in
            for (Iterator it = registeredFragments.values().iterator();
                    it.hasNext();) {
                PluginFragmentImpl fragment = (PluginFragmentImpl) it.next();
                if (fragment.matches(result)) {
                    result.registerFragment(fragment);
                }
            }
            registrationReport.add(new ReportItemImpl(
                    ReportItem.SEVERITY_INFO, null,
                    ReportItem.ERROR_NO_ERROR,
                    "pluginRegistered", result.getUniqueId())); //$NON-NLS-1$
        } catch (ManifestProcessingException mpe) {
            log.error("failed registering plug-in, URL - " + url, mpe); //$NON-NLS-1$
            if (stopOnError) {
                throw mpe;
            }
            registrationReport.add(new ReportItemImpl(
                    ReportItem.SEVERITY_ERROR, null,
                    ReportItem.ERROR_MANIFEST_PROCESSING_FAILED,
                    "pluginRegistrationFailed", new Object[] {url, mpe})); //$NON-NLS-1$
            return null;
        }
        registeredPlugins.put(result.getId(), result);
        return result;
    }

    private PluginFragment registerFragment(final URL url,
            final ModelPluginFragment model,
            final RegistryChangeDataImpl registryChangeData)
            throws ManifestProcessingException {
        if (log.isDebugEnabled()) {
            log.debug("registering plug-in fragment descriptor, URL - " + url); //$NON-NLS-1$
        }
        PluginFragmentImpl result = null;
        try {
            result = new PluginFragmentImpl(this, model, url);
            // register fragment with all matches plug-ins
            boolean isRegistered = false;
            PluginDescriptorImpl descr =
                (PluginDescriptorImpl) getPluginDescriptor(
                        result.getPluginId());
            if (result.matches(descr)) {
                descr.registerFragment(result);
                if (!registryChangeData.addedPlugins().contains(
                        descr.getId())) {
                    registryChangeData.modifiedPlugins().add(descr.getId());
                }
                isRegistered = true;
            }
            if (!isRegistered) {
                log.warn("no matching plug-ins found for fragment " //$NON-NLS-1$
                        + result.getUniqueId());
                registrationReport.add(new ReportItemImpl(
                        ReportItem.SEVERITY_WARNING, null,
                        ReportItem.ERROR_NO_ERROR,
                        "noMatchingPluginFound", result.getUniqueId())); //$NON-NLS-1$
            }
            registrationReport.add(new ReportItemImpl(
                    ReportItem.SEVERITY_INFO, null,
                    ReportItem.ERROR_NO_ERROR,
                    "fragmentRegistered", result.getUniqueId())); //$NON-NLS-1$
        } catch (ManifestProcessingException mpe) {
            log.error("failed registering plug-in fragment descriptor, URL - " //$NON-NLS-1$
                    + url, mpe);
            if (stopOnError) {
                throw mpe;
            }
            registrationReport.add(new ReportItemImpl(
                    ReportItem.SEVERITY_ERROR, null,
                    ReportItem.ERROR_MANIFEST_PROCESSING_FAILED,
                    "fragmentRegistrationFailed", new Object[] {url, mpe})); //$NON-NLS-1$
            return null;
        }
        registeredFragments.put(result.getId(), result);
        return result;
    }

    /**
     * @see org.java.plugin.registry.PluginRegistry#unregister(java.lang.String[])
     */
    public Collection unregister(final String[] ids) {
        // collecting registered extension points and extensions
        List registeredPoints = new LinkedList(); //<ExtensionPointImpl>
        Map registeredExtensions = new HashMap(); //<extensionUid, ExtensionImpl>
        for (Iterator it = registeredPlugins.values().iterator();
                it.hasNext();) {
            for (Iterator it2 = ((PluginDescriptor) it.next())
                    .getExtensionPoints().iterator();
                    it2.hasNext();) {
                ExtensionPoint point = (ExtensionPoint) it2.next();
                registeredPoints.add(point);
                for (Iterator it3 = point.getConnectedExtensions().iterator();
                        it3.hasNext();) {
                    Extension ext = (Extension) it3.next();
                    registeredExtensions.put(ext.getUniqueId(), ext);
                }
            }
        }
        Set result = new HashSet();
        RegistryChangeDataImpl registryChangeData =
            new RegistryChangeDataImpl();
        // collect objects to be unregistered
        registrationReport.add(new ReportItemImpl(
                ReportItem.SEVERITY_INFO, null,
                ReportItem.ERROR_NO_ERROR, "unregisteringPrepare", null)); //$NON-NLS-1$
        Map removingPlugins = new HashMap();
        Map removingFragments = new HashMap();
        for (int i = 0; i < ids.length; i++) {
            PluginDescriptor descr =
                (PluginDescriptor) registeredPlugins.get(ids[i]);
            if (descr != null) {
                for (Iterator it = getDependingPlugins(descr).iterator();
                        it.hasNext();) {
                    PluginDescriptor depDescr = (PluginDescriptor) it.next();
                    removingPlugins.put(depDescr.getId(), depDescr);
                    registryChangeData.removedPlugins().add(depDescr.getId());
                }
                removingPlugins.put(descr.getId(), descr);
                registryChangeData.removedPlugins().add(descr.getId());
                continue;
            }
            PluginFragment fragment =
                (PluginFragment) registeredFragments.get(ids[i]);
            if (fragment != null) {
                removingFragments.put(fragment.getId(), fragment);
                continue;
            }
            registrationReport.add(new ReportItemImpl(
                    ReportItem.SEVERITY_WARNING, null,
                    ReportItem.ERROR_NO_ERROR,
                    "pluginToUngregisterNotFound", ids[i])); //$NON-NLS-1$
        }
        // collect fragments for removing plug-ins
        for (Iterator it = removingPlugins.values().iterator(); it.hasNext();) {
            PluginDescriptor descr = (PluginDescriptor) it.next();
            for (Iterator it2 = descr.getFragments().iterator();
                    it2.hasNext();) {
                PluginFragment fragment = (PluginFragment) it2.next();
                if (removingFragments.containsKey(fragment.getId())) {
                    continue;
                }
                removingFragments.put(fragment.getId(), fragment);
            }
        }
        // notify about plug-ins removal first
        fireEvent(registryChangeData);
        registrationReport.add(new ReportItemImpl(ReportItem.SEVERITY_INFO,
                null, ReportItem.ERROR_NO_ERROR,
                "unregisteringFragmentsStart", null)); //$NON-NLS-1$
        for (Iterator it = removingFragments.values().iterator();
                it.hasNext();) {
            PluginFragmentImpl fragment = (PluginFragmentImpl) it.next();
            unregisterFragment(fragment);
            if (!removingPlugins.containsKey(fragment.getPluginId())) {
                registryChangeData.modifiedPlugins().add(
                        fragment.getPluginId());
            }
            result.add(fragment.getUniqueId());
        }
        removingFragments.clear();
        registrationReport.add(new ReportItemImpl(ReportItem.SEVERITY_INFO,
                null, ReportItem.ERROR_NO_ERROR,
                "unregisteringPluginsStart", null)); //$NON-NLS-1$
        for (Iterator it = removingPlugins.values().iterator(); it.hasNext();) {
            PluginDescriptorImpl descr = (PluginDescriptorImpl) it.next();
            unregisterPlugin(descr);
            result.add(descr.getUniqueId());
        }
        removingPlugins.clear();
        registrationReport.add(new ReportItemImpl(ReportItem.SEVERITY_INFO,
                null, ReportItem.ERROR_NO_ERROR,
                "unregisteringPluginsFinish", //$NON-NLS-1$
                new Integer(registeredPlugins.size())));
        registrationReport.add(new ReportItemImpl(ReportItem.SEVERITY_INFO,
                null, ReportItem.ERROR_NO_ERROR,
                "unregisteringFragmentsFinish", //$NON-NLS-1$
                new Integer(registeredFragments.size())));
        log.info("plug-in and fragment descriptors unregistered - " //$NON-NLS-1$
                + result.size());
        dump();
        if (result.isEmpty()) {
            return result;
        }
        // notify all interested members that plug-ins set has been changed
        for (Iterator it = registeredPoints.iterator(); it.hasNext();) {
            ((ExtensionPointImpl) it.next()).registryChanged();
        }
        for (Iterator it = registeredExtensions.values().iterator();
                it.hasNext();) {
            ((ExtensionImpl) it.next()).registryChanged();
        }
        if (!listeners.isEmpty() || log.isDebugEnabled()) {
            // analyze changes in extensions set
            for (Iterator it = registeredPlugins.values().iterator();
                    it.hasNext();) {
                for (Iterator it2 = ((PluginDescriptor) it.next())
                        .getExtensionPoints().iterator();
                        it2.hasNext();) {
                    for (Iterator it3 = ((ExtensionPoint) it2.next())
                            .getConnectedExtensions().iterator();
                            it3.hasNext();) {
                        Extension ext = (Extension) it3.next();
                        if (!registeredExtensions.containsKey(
                                ext.getUniqueId())) {
                            registryChangeData.putAddedExtension(
                                    ext.getUniqueId(),
                                    makeUniqueId(ext.getExtendedPluginId(),
                                            ext.getExtendedPointId()));
                        } else {
                            registeredExtensions.remove(ext.getUniqueId());
                            if (registryChangeData.modifiedPlugins().contains(
                                    ext.getDeclaringPluginDescriptor().getId())
                                    || registryChangeData.modifiedPlugins()
                                        .contains(ext.getExtendedPluginId())) {
                                registryChangeData.putModifiedExtension(
                                        ext.getUniqueId(),
                                        makeUniqueId(ext.getExtendedPluginId(),
                                                ext.getExtendedPointId()));