Java tutorial
/******************************************************************************* * Copyright (c) 2003, 2015 IBM Corporation and others. * All rights reserved. This program and the accompanying materials * are made available under the terms of the Eclipse Public License v1.0 * which accompanies this distribution, and is available at * http://www.eclipse.org/legal/epl-v10.html * * Contributors: * IBM Corporation - initial API and implementation *******************************************************************************/ package org.eclipse.jst.j2ee.componentcore; import java.util.ArrayList; import java.util.Arrays; import java.util.HashMap; import java.util.Iterator; import java.util.List; import java.util.Map; import org.eclipse.core.resources.IContainer; import org.eclipse.core.resources.IProject; import org.eclipse.core.resources.ResourcesPlugin; import org.eclipse.core.runtime.CoreException; import org.eclipse.core.runtime.IPath; import org.eclipse.core.runtime.IProgressMonitor; import org.eclipse.core.runtime.Path; import org.eclipse.jdt.core.IClasspathAttribute; import org.eclipse.jdt.core.IClasspathEntry; import org.eclipse.jst.common.internal.modulecore.IClasspathDependencyComponent; import org.eclipse.jst.common.internal.modulecore.IClasspathDependencyProvider; import org.eclipse.jst.common.internal.modulecore.IClasspathDependencyReceiver; import org.eclipse.jst.common.internal.modulecore.util.ManifestUtilities; import org.eclipse.jst.common.jdt.internal.javalite.IJavaProjectLite; import org.eclipse.jst.common.jdt.internal.javalite.JavaCoreLite; import org.eclipse.jst.common.jdt.internal.javalite.JavaLiteUtilities; import org.eclipse.jst.j2ee.classpathdep.ClasspathDependencyUtil; import org.eclipse.jst.j2ee.commonarchivecore.internal.util.ArchiveUtil; import org.eclipse.jst.j2ee.internal.J2EEConstants; import org.eclipse.jst.j2ee.internal.classpathdep.ClasspathDependencyVirtualComponent; import org.eclipse.jst.j2ee.internal.common.J2EEDependencyListener; import org.eclipse.jst.j2ee.internal.plugin.J2EEPlugin; import org.eclipse.jst.j2ee.internal.project.J2EEProjectUtilities; import org.eclipse.jst.j2ee.project.EarUtilities; import org.eclipse.jst.j2ee.project.JavaEEProjectUtilities; import org.eclipse.wst.common.componentcore.ComponentCore; import org.eclipse.wst.common.componentcore.internal.builder.IDependencyGraph; import org.eclipse.wst.common.componentcore.internal.resources.VirtualArchiveComponent; import org.eclipse.wst.common.componentcore.internal.resources.VirtualComponent; import org.eclipse.wst.common.componentcore.internal.resources.VirtualFolder; import org.eclipse.wst.common.componentcore.internal.resources.VirtualReference; import org.eclipse.wst.common.componentcore.internal.util.IComponentImplFactory; import org.eclipse.wst.common.componentcore.internal.util.VirtualReferenceUtilities; import org.eclipse.wst.common.componentcore.resources.ITaggedVirtualResource; import org.eclipse.wst.common.componentcore.resources.IVirtualComponent; import org.eclipse.wst.common.componentcore.resources.IVirtualFolder; import org.eclipse.wst.common.componentcore.resources.IVirtualReference; public class J2EEModuleVirtualComponent extends VirtualComponent implements IComponentImplFactory, IClasspathDependencyProvider, IClasspathDependencyReceiver { public static final String DD_FOLDER_TAG = org.eclipse.wst.common.componentcore.internal.WorkbenchComponent.DEFAULT_ROOT_SOURCE_TAG; public static String GET_JAVA_REFS = "GET_JAVA_REFS"; //$NON-NLS-1$ public static String GET_FUZZY_EAR_REFS = "GET_FUZZY_EAR_REFS"; //$NON-NLS-1$ public static String GET_EXPANDED_LIB_REFS = "GET_EXPANDED_LIB_REFS"; //$NON-NLS-1$ /** * Use this value to retrieve references consisting of only META-INF/MANIFEST.MF classpath * attributes. Do this as follows: * <code> * IVirtualCompoment component = a virtual component * Map<String, Object> onlyManifestRefs = new HashMap<String, Object>(); * onlyManifestRefs.put(IVirtualComponent.REQUESTED_REFERENCE_TYPE, J2EEModuleVirtualComponent.ONLY_MANIFEST_REFERENCES); * IVirtualReference[] refs = component.getReferences(onlyManifestRefs); * </code> */ public static String ONLY_MANIFEST_REFERENCES = "ONLY_MANIFEST_REFERENCES"; //$NON-NLS-1$ private long depGraphModStamp; private long jeeModStamp; /** * Accessors of this field should always use getHardReferences() */ private IVirtualReference[] hardReferences = null; private IVirtualReference[] javaReferences = null; private IVirtualReference[] parentEarManifestReferences = null; private IVirtualReference[] fuzzyEarManifestReferences = null; public J2EEModuleVirtualComponent() { super(); } public J2EEModuleVirtualComponent(IProject aProject, IPath aRuntimePath) { super(aProject, aRuntimePath); } public IVirtualComponent createComponent(IProject aProject) { return new J2EEModuleVirtualComponent(aProject, new Path("/")); //$NON-NLS-1$ } public IVirtualComponent createArchiveComponent(IProject aProject, String archiveLocation, IPath aRuntimePath) { return new J2EEModuleVirtualArchiveComponent(aProject, archiveLocation, aRuntimePath); } public IVirtualFolder createFolder(IProject aProject, IPath aRuntimePath) { return new VirtualFolder(aProject, aRuntimePath); } /** * Retrieves all references except those computed dynamically from * tagged Java classpath entries. * @return IVirtualReferences for all non-Java classpath entry references. */ public IVirtualReference[] getNonJavaReferences() { return getReferences(false, false); } protected IVirtualReference[] getHardReferences() { if (!checkIfStillValid() || hardReferences == null) { Map<String, Object> map = new HashMap<String, Object>(); map.put(REQUESTED_REFERENCE_TYPE, HARD_REFERENCES); hardReferences = super.getReferences(map); } return hardReferences; } protected static IVirtualReference[] getHardReferences(IVirtualComponent component) { Map<String, Object> map = new HashMap<String, Object>(); map.put(REQUESTED_REFERENCE_TYPE, HARD_REFERENCES); return component.getReferences(map); } public IVirtualReference[] getJavaClasspathReferences() { //broken by cache //if (javaReferences == null || !checkIfStillValid()) javaReferences = getJavaClasspathReferences(getHardReferences()); return javaReferences; } @Override public IVirtualReference[] getReferences(Map<String, Object> options) { Object val = options.get(REQUESTED_REFERENCE_TYPE); if (val != null) { if (HARD_REFERENCES.equals(val) || NON_DERIVED_REFERENCES.equals(val) || DISPLAYABLE_REFERENCES.equals(val)) { return getHardReferences(); } else if (DISPLAYABLE_REFERENCES_ALL.equals(val)) { checkIfStillValid(); // This will clear the cache of raw references if needed. return getAllReferences(); } else if (ONLY_MANIFEST_REFERENCES.equals(val)) { ArrayList<IVirtualReference> all = new ArrayList<IVirtualReference>(); checkIfStillValid(); cacheManifestReferences(); all.addAll(Arrays.asList(parentEarManifestReferences)); all.addAll(Arrays.asList(fuzzyEarManifestReferences)); IVirtualReference[] refs = all.toArray(new IVirtualReference[all.size()]); VirtualReferenceUtilities.INSTANCE.ensureReferencesHaveNames(refs); return refs; } } Boolean objGetJavaRefs = (Boolean) options.get(GET_JAVA_REFS); Boolean objGetFuzzyEarRefs = (Boolean) options.get(GET_FUZZY_EAR_REFS); Boolean objGetExpandRefs = (Boolean) options.get(GET_EXPANDED_LIB_REFS); boolean getJavaRefs = objGetJavaRefs != null ? objGetJavaRefs.booleanValue() : true; boolean findFuzzyEARRefs = objGetFuzzyEarRefs != null ? objGetFuzzyEarRefs.booleanValue() : false; boolean getExpandRefs = objGetExpandRefs != null ? objGetExpandRefs.booleanValue() : false; IVirtualReference[] nonManifestRefs = getNonManifestRefs(getJavaRefs); if (val != null && FLATTENABLE_REFERENCES.equals(val)) { if (getExpandRefs) { return JavaEEProjectUtilities.getExpandedReferences(this, nonManifestRefs); } return nonManifestRefs; } ArrayList<IVirtualReference> all = new ArrayList<IVirtualReference>(); all.addAll(Arrays.asList(nonManifestRefs)); // retrieve the dynamic references specified via the MANIFEST.MF classpath cacheManifestReferences(); ArrayList<IVirtualReference> dynamicRefs = new ArrayList<IVirtualReference>(); dynamicRefs.addAll(Arrays.asList(parentEarManifestReferences)); if (findFuzzyEARRefs) dynamicRefs.addAll(Arrays.asList(fuzzyEarManifestReferences)); for (Iterator<IVirtualReference> iterator = dynamicRefs.iterator(); iterator.hasNext();) { IVirtualReference reference = iterator.next(); IVirtualComponent dynamicComponent = reference.getReferencedComponent(); boolean shouldInclude = true; for (IVirtualReference hardRef : getHardReferences()) { if (hardRef.getReferencedComponent().equals(dynamicComponent)) { shouldInclude = false; break; } } if (shouldInclude) { all.add(reference); } } IVirtualReference[] refs = all.toArray(new IVirtualReference[all.size()]); VirtualReferenceUtilities.INSTANCE.ensureReferencesHaveNames(refs); if (getExpandRefs) { return JavaEEProjectUtilities.getExpandedReferences(this, refs); } return refs; } @Override public IVirtualReference[] getReferences() { return getReferences(true, false); } public IVirtualReference[] getReferences(final boolean getJavaRefs, final boolean findFuzzyEARRefs) { Map<String, Object> options = new HashMap<String, Object>(); options.put(GET_JAVA_REFS, new Boolean(getJavaRefs)); options.put(GET_FUZZY_EAR_REFS, new Boolean(findFuzzyEARRefs)); return getReferences(options); } /** * Non-manifest references are hard references *OR* java classpath * references * * @return */ public IVirtualReference[] getNonManifestReferences() { Map<String, Object> options = new HashMap<String, Object>(); options.put(IVirtualComponent.REQUESTED_REFERENCE_TYPE, IVirtualComponent.FLATTENABLE_REFERENCES); return getReferences(options); } @Deprecated public IVirtualReference[] getNonManifestReferences(final boolean getJavaRefs) { Map<String, Object> options = new HashMap<String, Object>(); options.put(IVirtualComponent.REQUESTED_REFERENCE_TYPE, IVirtualComponent.FLATTENABLE_REFERENCES); options.put(GET_JAVA_REFS, new Boolean(getJavaRefs)); return getReferences(options); } private IVirtualReference[] getNonManifestRefs(final boolean getJavaRefs) { ArrayList<IVirtualReference> allRefs = new ArrayList<IVirtualReference>(); IVirtualReference[] hardRefs = getHardReferences(); allRefs.addAll(Arrays.asList(hardRefs)); if (getJavaRefs) allRefs.addAll(Arrays.asList(getJavaClasspathReferences(hardRefs))); return allRefs.toArray(new IVirtualReference[allRefs.size()]); } public static String[] getManifestClasspath(IVirtualComponent moduleComponent) { return ManifestUtilities.getManifestClasspath(moduleComponent, new Path(J2EEConstants.MANIFEST_URI)); } public IVirtualReference[] getJavaClasspathReferences(IVirtualReference[] hardReferences) { final boolean isLegacyJ2EE = JavaEEProjectUtilities.isLegacyJ2EEComponent(this); final boolean isWebApp = JavaEEProjectUtilities.isDynamicWebComponent(this); final IProject project = getProject(); final List cpRefs = new ArrayList(); try { if (project == null || !project.isAccessible() || !project.hasNature(JavaCoreLite.NATURE_ID)) { return new IVirtualReference[0]; } final IJavaProjectLite javaProjectLite = JavaCoreLite.create(project); if (javaProjectLite == null) return new IVirtualReference[0]; // retrieve all referenced classpath entries final Map referencedEntries = ClasspathDependencyUtil.getComponentClasspathDependencies(javaProjectLite, isLegacyJ2EE); if (referencedEntries.isEmpty()) return new IVirtualReference[0]; IVirtualReference[] innerHardReferences = hardReferences == null ? getHardReferences() : hardReferences; final IPath[] hardRefPaths = new IPath[innerHardReferences.length]; for (int j = 0; j < innerHardReferences.length; j++) { final IVirtualComponent comp = innerHardReferences[j].getReferencedComponent(); if (comp.isBinary()) { hardRefPaths[j] = (IPath) comp.getAdapter(IPath.class); } } IContainer[] mappedClassFolders = null; final Iterator i = referencedEntries.keySet().iterator(); while (i.hasNext()) { final IClasspathEntry entry = (IClasspathEntry) i.next(); final IClasspathAttribute attrib = (IClasspathAttribute) referencedEntries.get(entry); final boolean isClassFolder = ClasspathDependencyUtil.isClassFolderEntry(entry); final IPath runtimePath = ClasspathDependencyUtil.getRuntimePath(attrib, isWebApp, isClassFolder); boolean add = true; final IPath entryLocation = ClasspathDependencyUtil.getEntryLocation(entry); if (entryLocation == null) { // unable to retrieve location for cp entry, do not // contribute as a virtual ref add = false; } else if (!isClassFolder) { // check hard archive refs for (int j = 0; j < hardRefPaths.length; j++) { if (entryLocation.equals(hardRefPaths[j])) { // entry resolves to same file as existing hard // reference, can skip add = false; break; } } } else { // check class folders mapped in component file as // class folders associated with mapped src folders if (mappedClassFolders == null) { List<IContainer> containers = JavaLiteUtilities.getJavaOutputContainers(this); mappedClassFolders = containers.toArray(new IContainer[containers.size()]); } for (int j = 0; j < mappedClassFolders.length; j++) { if (entryLocation.equals(mappedClassFolders[j].getFullPath())) { // entry resolves to same file as existing class // folder mapping, skip add = false; break; } } } if (add && entryLocation != null) { final IVirtualReference entryReference; String componentPath = null; if (entry.getEntryKind() == IClasspathEntry.CPE_PROJECT) { final IProject cpEntryProject = ResourcesPlugin.getWorkspace().getRoot() .getProject(entry.getPath().lastSegment()); IVirtualComponent entryComponent = ComponentCore.createComponent(cpEntryProject); entryReference = ComponentCore.createReference(this, entryComponent, runtimePath); entryReference.setArchiveName( VirtualReferenceUtilities.INSTANCE.getDefaultProjectArchiveName(entryComponent)); } else { componentPath = VirtualArchiveComponent.CLASSPATHARCHIVETYPE + IPath.SEPARATOR + entryLocation.toPortableString(); ClasspathDependencyVirtualComponent entryComponent = new ClasspathDependencyVirtualComponent( project, componentPath, isClassFolder); entryReference = ComponentCore.createReference(this, entryComponent, runtimePath); ((VirtualReference) entryReference).setDerived(true); entryReference.setArchiveName(ClasspathDependencyUtil.getArchiveName(entry)); } cpRefs.add(entryReference); } } } catch (CoreException jme) { J2EEPlugin.logError(jme); } return (IVirtualReference[]) cpRefs.toArray(new IVirtualReference[cpRefs.size()]); } private void cacheManifestReferences() { if (parentEarManifestReferences == null || fuzzyEarManifestReferences == null) { IVirtualReference[][] refs = calculateManifestReferences(this, true); parentEarManifestReferences = refs[0]; fuzzyEarManifestReferences = refs[1]; } } private static IVirtualReference[][] calculateManifestReferences(IVirtualComponent moduleComponent, boolean checkFuzzyRefs) { String[] manifestClasspath = getManifestClasspath(moduleComponent); IProject[] earProjects = EarUtilities.getReferencingEARProjects(moduleComponent.getProject()); // Early aborts if (manifestClasspath == null || manifestClasspath.length == 0 || earProjects.length == 0) { return new IVirtualReference[][] { new IVirtualReference[0], new IVirtualReference[0] }; } // Get our found cache going boolean[] foundRefAlready = new boolean[manifestClasspath.length]; for (int i = 0; i < foundRefAlready.length; i++) foundRefAlready[i] = false; // Get the true parent references IProject firstEar = earProjects[earProjects.length - 1]; ArrayList<IVirtualReference> tmp = cacheOneEarProjectManifestRefs(moduleComponent, firstEar, manifestClasspath, foundRefAlready); IVirtualReference[] parentEarManifestReferences = tmp.toArray(new IVirtualReference[tmp.size()]); ArrayList<IVirtualReference> dynamicReferences = new ArrayList<IVirtualReference>(); // get the fuzzy references if (checkFuzzyRefs) { if (earProjects.length > 1) { for (int earIndex = earProjects.length - 2; earIndex > -1; earIndex--) { if (earProjects[earIndex] != null) { tmp = cacheOneEarProjectManifestRefs(moduleComponent, earProjects[earIndex], manifestClasspath, foundRefAlready); dynamicReferences.addAll(tmp); } } } } IVirtualReference[] fuzzyEarManifestReferences = dynamicReferences .toArray(new IVirtualReference[dynamicReferences.size()]); // return our two creatures return new IVirtualReference[][] { parentEarManifestReferences, fuzzyEarManifestReferences }; } protected static ArrayList<IVirtualReference> cacheOneEarProjectManifestRefs(IVirtualComponent moduleComponent, IProject earProject, String[] manifestClasspath, boolean[] foundRefAlready) { ArrayList<IVirtualReference> dynamicReferences = new ArrayList<IVirtualReference>(); IVirtualReference foundRef = null; String earArchiveURI = null; // The URI for this archive in the EAR boolean simplePath = false; IVirtualReference[] earRefs = null; IVirtualComponent tempEARComponent = ComponentCore.createComponent(earProject); IVirtualReference[] tempEarRefs = tempEARComponent.getReferences(); for (int j = 0; j < tempEarRefs.length && earRefs == null; j++) { if (tempEarRefs[j].getReferencedComponent().equals(moduleComponent)) { earRefs = tempEarRefs; foundRef = tempEarRefs[j]; earArchiveURI = foundRef.getRuntimePath() == null ? foundRef.getArchiveName() : foundRef.getRuntimePath().append(foundRef.getArchiveName()).makeRelative().toString(); simplePath = earArchiveURI != null ? earArchiveURI.lastIndexOf("/") == -1 : true; //$NON-NLS-1$ } } if (null != earRefs) { for (int manifestIndex = 0; manifestIndex < manifestClasspath.length; manifestIndex++) { boolean found = false; if (foundRefAlready != null && foundRefAlready[manifestIndex]) { continue; } for (int j = 0; j < earRefs.length && !found; j++) { if (foundRef != earRefs[j]) { String archiveName = earRefs[j].getArchiveName(); if (null != archiveName) { boolean shouldAdd = false; String manifestEntryString = manifestClasspath[manifestIndex]; if (manifestEntryString != null) { IPath manifestPath = new Path(manifestEntryString); manifestEntryString = manifestPath.toPortableString(); } if (simplePath && manifestEntryString != null && manifestEntryString.lastIndexOf("/") == -1) { //$NON-NLS-1$ shouldAdd = archiveName.equals(manifestEntryString); } else { String earRelativeURI = ArchiveUtil.deriveEARRelativeURI(manifestEntryString, earArchiveURI); if (null != earRelativeURI) { IPath earRefPath = earRefs[j].getRuntimePath().makeRelative(); shouldAdd = earRelativeURI.equals(earRefPath.append(archiveName).toString()); } } if (shouldAdd) { if (foundRefAlready != null) { foundRefAlready[manifestIndex] = true; } found = true; IVirtualComponent dynamicComponent = earRefs[j].getReferencedComponent(); IVirtualReference dynamicReference = ComponentCore.createReference(moduleComponent, dynamicComponent); ((VirtualReference) dynamicReference).setDerived(true); dynamicReferences.add(dynamicReference); } } } } } } return dynamicReferences; } public static List getManifestReferences(IVirtualComponent moduleComponent, IVirtualReference[] hardReferences) { return getManifestReferences(moduleComponent, hardReferences, false); } public static List getManifestReferences(IVirtualComponent moduleComponent, IVirtualReference[] hardReferences, boolean findFuzzyEARRefs) { IVirtualReference[][] refs = calculateManifestReferences(moduleComponent, findFuzzyEARRefs); ArrayList<IVirtualReference> tmp = new ArrayList<IVirtualReference>(); tmp.addAll(Arrays.asList(refs[0])); if (findFuzzyEARRefs) tmp.addAll(Arrays.asList(refs[1])); return tmp; } private boolean checkIfStillValid() { boolean valid = IDependencyGraph.INSTANCE.getModStamp() == depGraphModStamp; valid = valid && J2EEDependencyListener.INSTANCE.getModStamp() == jeeModStamp; if (!valid) { clearCache(); } return valid; } @Override protected void clearCache() { super.clearCache(); depGraphModStamp = IDependencyGraph.INSTANCE.getModStamp(); jeeModStamp = J2EEDependencyListener.INSTANCE.getModStamp(); hardReferences = null; javaReferences = null; parentEarManifestReferences = null; fuzzyEarManifestReferences = null; } public boolean canReceiveClasspathDependencies() { return J2EEProjectUtilities.isDynamicWebProject(getProject()); } public IPath getClasspathFolderPath(IClasspathDependencyComponent component) { if (J2EEProjectUtilities.isDynamicWebProject(getProject())) { return new Path(J2EEConstants.WEB_INF_LIB).makeAbsolute(); } return new Path("/"); //$NON-NLS-1$ } public static void setDefaultDeploymentDescriptorFolder(IVirtualFolder folder, IPath aProjectRelativeLocation, IProgressMonitor monitor) { if (folder instanceof ITaggedVirtualResource) { ITaggedVirtualResource taggedFolder = (ITaggedVirtualResource) folder; //First, remove tag is there is already one folder already tagged IPath[] paths = taggedFolder.getTaggedResources(DD_FOLDER_TAG); for (IPath path : paths) { taggedFolder.tagResource(path, null, monitor); } // Now, tag the correct path ((ITaggedVirtualResource) folder).tagResource(aProjectRelativeLocation, DD_FOLDER_TAG, monitor); } } public static IPath getDefaultDeploymentDescriptorFolder(IVirtualFolder folder) { IPath returnValue = null; if (folder instanceof ITaggedVirtualResource) { returnValue = ((ITaggedVirtualResource) folder).getFirstTaggedResource(DD_FOLDER_TAG); } return returnValue; } }