Java tutorial
/* * Licensed to the Apache Software Foundation (ASF) under one * or more contributor license agreements. See the NOTICE file * distributed with this work for additional information * regarding copyright ownership. The ASF licenses this file * to you under the Apache License, Version 2.0 (the * "License"); you may not use this file except in compliance * with the License. You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, * software distributed under the License is distributed on an * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY * KIND, either express or implied. See the License for the * specific language governing permissions and limitations * under the License. */ package org.apache.felix.scrplugin.helper; import static org.objectweb.asm.ClassReader.SKIP_CODE; import static org.objectweb.asm.ClassReader.SKIP_DEBUG; import static org.objectweb.asm.ClassReader.SKIP_FRAMES; import java.io.File; import java.io.FileInputStream; import java.io.FilterInputStream; import java.io.IOException; import java.io.InputStream; import java.lang.reflect.Array; import java.lang.reflect.Field; import java.lang.reflect.Method; import java.util.ArrayList; import java.util.Collection; import java.util.HashMap; import java.util.Iterator; import java.util.List; import java.util.Map; import java.util.StringTokenizer; import java.util.jar.JarEntry; import java.util.jar.JarFile; import java.util.jar.Manifest; import java.util.regex.Matcher; import java.util.regex.Pattern; import org.apache.felix.scrplugin.Log; import org.apache.felix.scrplugin.Project; import org.apache.felix.scrplugin.SCRDescriptorException; import org.apache.felix.scrplugin.SCRDescriptorFailureException; import org.apache.felix.scrplugin.Source; import org.apache.felix.scrplugin.annotations.AnnotationProcessor; import org.apache.felix.scrplugin.annotations.ClassAnnotation; import org.apache.felix.scrplugin.annotations.FieldAnnotation; import org.apache.felix.scrplugin.annotations.MethodAnnotation; import org.apache.felix.scrplugin.annotations.ScannedAnnotation; import org.apache.felix.scrplugin.annotations.ScannedClass; import org.apache.felix.scrplugin.description.ClassDescription; import org.apache.felix.scrplugin.description.ComponentDescription; import org.apache.felix.scrplugin.description.PropertyDescription; import org.apache.felix.scrplugin.description.ReferenceDescription; import org.apache.felix.scrplugin.description.ServiceDescription; import org.apache.felix.scrplugin.xml.ComponentDescriptorIO; import org.objectweb.asm.ClassReader; import org.objectweb.asm.Type; import org.objectweb.asm.tree.AnnotationNode; import org.objectweb.asm.tree.ClassNode; import org.objectweb.asm.tree.FieldNode; import org.objectweb.asm.tree.MethodNode; /** * The class scanner scans class files for annotations and invokes * the {@link AnnotationProcessor} on each scanned class file. */ public class ClassScanner { /** * The name of the Bundle manifest header providing the list of service * component descriptor files. */ private static final String SERVICE_COMPONENT = "Service-Component"; /** * The name of the file containing the scanned information from older * SCR generator versions. */ private static final String ABSTRACT_DESCRIPTOR_ARCHIV_PATH = "OSGI-INF/scr-plugin/scrinfo.xml"; /** Source for all generated descriptions. */ private static final String GENERATED = "<generated>"; /** With this syntax array parameters names are returned by reflection API */ private static final Pattern ARRAY_PARAM_TYPE_NAME = Pattern.compile("^\\[L(.*);$"); /** Component descriptions loaded from dependencies*/ private Map<String, ClassDescription> loadedDependencies; /** All used component descriptions. */ private final Map<String, ClassDescription> allDescriptions; /** The log. */ private final Log log; /** The issue log. */ private final IssueLog iLog; /** The project. */ private final Project project; /** The annotation processor. */ private final AnnotationProcessor aProcessor; /** * Create a new scanner. */ public ClassScanner(final Log log, final IssueLog iLog, final Project project, final AnnotationProcessor aProcessor) { // create map for all descriptions and dummy entry for Object this.allDescriptions = new HashMap<String, ClassDescription>(); allDescriptions.put(Object.class.getName(), new ClassDescription(Object.class, GENERATED)); this.log = log; this.iLog = iLog; this.project = project; this.aProcessor = aProcessor; } /** * Scan all source class files for annotations and process them. */ public List<ClassDescription> scanSources() throws SCRDescriptorFailureException, SCRDescriptorException { final List<ClassDescription> result = new ArrayList<ClassDescription>(); for (final Source src : project.getSources()) { if (src.getFile().getName().equals("package-info.java")) { log.debug("Skipping file " + src.getClassName()); continue; } log.debug("Scanning class " + src.getClassName()); try { // load the class final Class<?> annotatedClass = project.getClassLoader().loadClass(src.getClassName()); this.process(annotatedClass, src, result); } catch (final ClassNotFoundException cnfe) { throw new SCRDescriptorException("Unable to load compiled class: " + src.getClassName(), src.getFile().toString(), cnfe); } } return result; } /** * Process a class * @throws SCRDescriptorException * @throws SCRDescriptorFailureException */ private void process(final Class<?> annotatedClass, final Source src, final List<ClassDescription> result) throws SCRDescriptorFailureException, SCRDescriptorException { final ClassDescription desc = this.processClass(annotatedClass, src.getFile().toString()); if (desc != null) { this.allDescriptions.put(annotatedClass.getName(), desc); if (desc.getDescriptions(ComponentDescription.class).size() > 0) { result.add(desc); log.debug("Found component description " + desc + " in " + annotatedClass.getName()); } else { // check whether one of the other annotations is used and log a warning (FELIX-3636) if (desc.getDescription(PropertyDescription.class) != null || desc.getDescription(ReferenceDescription.class) != null || desc.getDescription(ServiceDescription.class) != null) { iLog.addWarning("Class '" + src.getClassName() + "' contains SCR annotations, but not a " + "@Component (or equivalent) annotation. Therefore no component descriptor is created for this " + "class. Please add a @Component annotation and consider making it abstract.", src.getFile().toString()); } } } else { this.allDescriptions.put(annotatedClass.getName(), new ClassDescription(annotatedClass, GENERATED)); } // process inner classes for (final Class<?> innerClass : annotatedClass.getDeclaredClasses()) { if (!innerClass.isAnnotation() && !innerClass.isInterface()) { process(innerClass, src, result); } } } /** * Scan a single class. */ private ClassDescription processClass(final Class<?> annotatedClass, final String location) throws SCRDescriptorFailureException, SCRDescriptorException { log.debug("Processing " + annotatedClass.getName()); try { // get the class file for ASM final String pathToClassFile = annotatedClass.getName().replace('.', '/') + ".class"; final InputStream input = project.getClassLoader().getResourceAsStream(pathToClassFile); final ClassReader classReader; try { classReader = new ClassReader(input); } finally { input.close(); } final ClassNode classNode = new ClassNode(); classReader.accept(classNode, SKIP_CODE | SKIP_DEBUG | SKIP_FRAMES); // create descriptions final List<ScannedAnnotation> annotations = extractAnnotation(classNode, annotatedClass); if (annotations.size() > 0) { // process annotations and create descriptions final ClassDescription desc = new ClassDescription(annotatedClass, location); aProcessor.process(new ScannedClass(annotations, annotatedClass), desc); log.debug("Found descriptions " + desc + " in " + annotatedClass.getName()); return desc; } } catch (final IllegalArgumentException ioe) { throw new SCRDescriptorException("Unable to scan class files: " + annotatedClass.getName() + " (Class file format probably not supported by ASM ?)", location, ioe); } catch (final IOException ioe) { throw new SCRDescriptorException("Unable to scan class files: " + annotatedClass.getName(), location, ioe); } return null; } /** * Extract annotations */ private final List<ScannedAnnotation> extractAnnotation(final ClassNode classNode, final Class<?> annotatedClass) throws SCRDescriptorException { final List<ScannedAnnotation> descriptions = new ArrayList<ScannedAnnotation>(); // first parse class annotations @SuppressWarnings("unchecked") final List<AnnotationNode> annotations = getAllAnnotations(classNode.invisibleAnnotations, classNode.visibleAnnotations); if (annotations != null) { for (final AnnotationNode annotation : annotations) { this.parseAnnotation(descriptions, annotation, annotatedClass); } // second parse method annotations @SuppressWarnings("unchecked") final List<MethodNode> methods = classNode.methods; if (methods != null) { for (final MethodNode method : methods) { final String name = method.name; // check for constructor if (!"<init>".equals(name)) { @SuppressWarnings("unchecked") final List<AnnotationNode> annos = getAllAnnotations(method.invisibleAnnotations, method.visibleAnnotations); if (annos != null) { final Type[] signature = Type.getArgumentTypes(method.desc); final Method[] allMethods = annotatedClass.getDeclaredMethods(); Method found = null; for (final Method m : allMethods) { if (m.getName().equals(name)) { if (m.getParameterTypes().length == 0 && (signature == null || signature.length == 0)) { found = m; } if (m.getParameterTypes().length > 0 && signature != null && m.getParameterTypes().length == signature.length) { found = m; for (int index = 0; index < m.getParameterTypes().length; index++) { String parameterTypeName = m.getParameterTypes()[index].getName(); // Name of array parameters is returned with syntax [L<name>;, convert to <name>[] Matcher matcher = ARRAY_PARAM_TYPE_NAME.matcher(parameterTypeName); if (matcher.matches()) { parameterTypeName = matcher.group(1) + "[]"; } if (!parameterTypeName.equals(signature[index].getClassName()) && !m.getParameterTypes()[index].getSimpleName() .equals(signature[index].getClassName())) { found = null; } } } // if method is found return it now, to avoid resetting 'found' to null if next method has same name but different parameters if (found != null) { break; } } } if (found == null) { throw new SCRDescriptorException("Annotated method " + name + " not found.", annotatedClass.getName()); } for (final AnnotationNode annotation : annos) { parseAnnotation(descriptions, annotation, found); } } } } } // third parse field annotations @SuppressWarnings("unchecked") final List<FieldNode> fields = classNode.fields; if (fields != null) { for (final FieldNode field : fields) { @SuppressWarnings("unchecked") final List<AnnotationNode> annos = getAllAnnotations(field.invisibleAnnotations, field.visibleAnnotations); if (annos != null) { final String name = field.name; final Field[] allFields = annotatedClass.getDeclaredFields(); Field found = null; for (final Field f : allFields) { if (f.getName().equals(name)) { found = f; break; } } if (found == null) { throw new SCRDescriptorException("Annotated field " + name + " not found.", annotatedClass.getName()); } for (final AnnotationNode annotation : annos) { parseAnnotation(descriptions, annotation, found); } } } } } return descriptions; } /** * Method is used to get both invisible (e.g. RetentionPolicy.CLASS) and visible (e.g. RetentionPolicy.RUNTIME) annotations. * Although it is recommended to use RetentionPolicy.CLASS for SCR annotations, it may make sense to declae them with another * RetentionPolicy if the same annotation is used for other usecases which require runtime access as well. * @param annotationLists List of invisible and visible annotations. * @return List with all annotations from all lists, or null if none found */ private List<AnnotationNode> getAllAnnotations(List<AnnotationNode>... annotationLists) { List<AnnotationNode> resultList = null; for (List<AnnotationNode> annotationList : annotationLists) { if (annotationList != null && annotationList.size() > 0) { if (resultList == null) { resultList = new ArrayList<AnnotationNode>(); } resultList.addAll(annotationList); } } return resultList; } private <T> T[] convertToArray(final List<?> values, final Class<T> type) { @SuppressWarnings("unchecked") final T[] result = (T[]) Array.newInstance(type, values.size()); return values.toArray(result); } /** * Parse annotation and create a description. */ private void parseAnnotation(final List<ScannedAnnotation> descriptions, final AnnotationNode annotation, final Object annotatedObject) { // desc has the format 'L' + className.replace('.', '/') + ';' final String name = annotation.desc.substring(1, annotation.desc.length() - 1).replace('/', '.'); Map<String, Object> values = null; if (annotation.values != null) { values = new HashMap<String, Object>(); final Iterator<?> i = annotation.values.iterator(); while (i.hasNext()) { final Object vName = i.next(); Object value = i.next(); // convert type to class name string if (value instanceof Type) { value = ((Type) value).getClassName(); } else if (value instanceof List<?>) { final List<?> objects = (List<?>) value; if (objects.size() > 0) { if (objects.get(0) instanceof Type) { final String[] classNames = new String[objects.size()]; int index = 0; for (final Object v : objects) { classNames[index] = ((Type) v).getClassName(); index++; } value = classNames; } else if (objects.get(0) instanceof AnnotationNode) { final List<ScannedAnnotation> innerDesc = new ArrayList<ScannedAnnotation>(); for (final Object v : objects) { parseAnnotation(innerDesc, (AnnotationNode) v, annotatedObject); } if (annotatedObject instanceof Method) { value = innerDesc.toArray(new MethodAnnotation[innerDesc.size()]); } else if (annotatedObject instanceof Field) { value = innerDesc.toArray(new FieldAnnotation[innerDesc.size()]); } else { value = innerDesc.toArray(new ClassAnnotation[innerDesc.size()]); } } else { value = convertToArray(objects, objects.get(0).getClass()); } } else { value = null; } } values.put(vName.toString(), value); } } final ScannedAnnotation a; if (annotatedObject instanceof Method) { a = new MethodAnnotation(name, values, (Method) annotatedObject); ((Method) annotatedObject).setAccessible(true); } else if (annotatedObject instanceof Field) { a = new FieldAnnotation(name, values, (Field) annotatedObject); ((Field) annotatedObject).setAccessible(true); } else { a = new ClassAnnotation(name, values); } descriptions.add(a); } /** * Get a description for the class */ public ClassDescription getDescription(final Class<?> clazz) throws SCRDescriptorException, SCRDescriptorFailureException { final String name = clazz.getName(); // we don't need to scan classes in the java. or javax. package namespace if (name.startsWith("java.") || name.startsWith("javax.")) { return null; } ClassDescription result = this.allDescriptions.get(name); if (result == null) { // use scanner first result = this.processClass(clazz, GENERATED); if (result == null) { // now check loaded dependencies result = this.getComponentDescriptors().get(name); } // not found, create dummy if (result == null) { result = new ClassDescription(clazz, GENERATED); } // and cache allDescriptions.put(name, result); } return result.clone(); } /** * Returns a map of component descriptors which may be extended by the java * sources. * <p> * This method calls the {@link #getDependencies()} method and checks for * any Service-Component descriptors in the returned files. * <p> * This method may be overwritten by extensions of this class. * * @throws SCRDescriptorException May be thrown if an error occurs * gathering the component descriptors. */ private Map<String, ClassDescription> getComponentDescriptors() throws SCRDescriptorException { if (loadedDependencies == null) { loadedDependencies = new HashMap<String, ClassDescription>(); final Collection<File> dependencies = this.project.getDependencies(); for (final File artifact : dependencies) { try { this.log.debug("Trying to get scrinfo from artifact " + artifact); // First try to read the private scr info file from previous scr generator versions InputStream scrInfoFile = null; try { scrInfoFile = this.getFile(artifact, ABSTRACT_DESCRIPTOR_ARCHIV_PATH); if (scrInfoFile != null) { this.readServiceComponentDescriptor(scrInfoFile, artifact.toString() + ':' + ABSTRACT_DESCRIPTOR_ARCHIV_PATH); continue; } this.log.debug("Artifact has no scrinfo file (it's optional): " + artifact); } catch (final IOException ioe) { throw new SCRDescriptorException("Unable to get scrinfo from artifact", artifact.toString(), ioe); } finally { if (scrInfoFile != null) { try { scrInfoFile.close(); } catch (final IOException ignore) { } } } this.log.debug("Trying to get manifest from artifact " + artifact); final Manifest manifest = this.getManifest(artifact); if (manifest != null) { // read Service-Component entry if (manifest.getMainAttributes().getValue(SERVICE_COMPONENT) != null) { final String serviceComponent = manifest.getMainAttributes() .getValue(SERVICE_COMPONENT); this.log.debug( "Found Service-Component: " + serviceComponent + " in artifact " + artifact); final StringTokenizer st = new StringTokenizer(serviceComponent, ","); while (st.hasMoreTokens()) { final String entry = st.nextToken().trim(); if (entry.length() > 0) { this.readServiceComponentDescriptor(artifact, entry); } } } else { this.log.debug("Artifact has no service component entry in manifest " + artifact); } } else { this.log.debug("Unable to get manifest from artifact " + artifact); } } catch (IOException ioe) { throw new SCRDescriptorException("Unable to get manifest from artifact", artifact.toString(), ioe); } } } return this.loadedDependencies; } /** * Parses the descriptors read from the given input stream. This method may * be called by the {@link #getComponentDescriptors()} method to parse the * descriptors gathered in an implementation dependent way. * * @throws SCRDescriptorException If an error occurs reading the * descriptors from the stream. */ private void readServiceComponentDescriptor(final InputStream file, final String location) throws SCRDescriptorException { final List<ClassDescription> list = ComponentDescriptorIO.read(file, this.project.getClassLoader(), iLog, location); if (list != null) { for (final ClassDescription cd : list) { final String name; if (cd.getDescribedClass() == null) { name = cd.getDescription(ComponentDescription.class).getName(); } else { name = cd.getDescribedClass().getName(); } loadedDependencies.put(name, cd); } } } /** * Read the service component description. * * @param artifact * @param entry * @throws IOException * @throws SCRDescriptorException */ private void readServiceComponentDescriptor(final File artifactFile, String entry) { this.log.debug("Reading " + entry + " from " + artifactFile); InputStream xml = null; try { xml = this.getFile(artifactFile, entry); if (xml == null) { throw new SCRDescriptorException("Entry " + entry + " not contained in JAR File ", artifactFile.toString()); } this.readServiceComponentDescriptor(xml, artifactFile.toString() + ':' + entry); } catch (final IOException mee) { this.log.warn("Unable to read SCR descriptor file from JAR File " + artifactFile + " at " + entry); this.log.debug("Exception occurred during reading: " + mee.getMessage(), mee); } catch (final SCRDescriptorException mee) { this.log.warn("Unable to read SCR descriptor file from JAR File " + artifactFile + " at " + entry); this.log.debug("Exception occurred during reading: " + mee.getMessage(), mee); } finally { if (xml != null) { try { xml.close(); } catch (final IOException ignore) { } } } } /** * Get the manifest from the artifact. * The artifact can either be a jar or a directory. */ private Manifest getManifest(final File artifact) throws IOException { if (artifact.isDirectory()) { // this is maybe a classes directory, try to read manifest file directly final File dir = new File(artifact, "META-INF"); if (!dir.exists() || !dir.isDirectory()) { return null; } final File mf = new File(dir, "MANIFEST.MF"); if (!mf.exists() || !mf.isFile()) { return null; } final InputStream is = new FileInputStream(mf); try { return new Manifest(is); } finally { try { is.close(); } catch (final IOException ignore) { } } } JarFile file = null; try { file = new JarFile(artifact); return file.getManifest(); } finally { if (file != null) { try { file.close(); } catch (final IOException ignore) { } } } } private InputStream getFile(final File artifactFile, final String path) throws IOException { if (artifactFile.isDirectory()) { final String filePath = path.replace('/', File.separatorChar).replace('\\', File.separatorChar); final File file = new File(artifactFile, filePath); if (file.exists() && file.isFile()) { return new FileInputStream(file); } return null; } JarFile file = null; try { file = new JarFile(artifactFile); final JarEntry entry = file.getJarEntry(path); if (entry != null) { final InputStream stream = new ArtifactFileInputStream(file, entry); file = null; // prevent file from being closed now return stream; } return null; } finally { if (file != null) { try { file.close(); } catch (final IOException ignore) { } } } } private static class ArtifactFileInputStream extends FilterInputStream { final JarFile jarFile; ArtifactFileInputStream(JarFile jarFile, JarEntry jarEntry) throws IOException { super(jarFile.getInputStream(jarEntry)); this.jarFile = jarFile; } @Override public void close() throws IOException { try { super.close(); } catch (final IOException ioe) { // ignore } jarFile.close(); } @Override protected void finalize() throws Throwable { try { close(); } finally { super.finalize(); } } } }