org.glassfish.jersey.server.internal.scanning.AnnotationAcceptingListener Maven / Gradle / Ivy
Show all versions of jersey-server Show documentation
/*
* Copyright (c) 2012, 2019 Oracle and/or its affiliates. All rights reserved.
*
* This program and the accompanying materials are made available under the
* terms of the Eclipse Public License v. 2.0, which is available at
* http://www.eclipse.org/legal/epl-2.0.
*
* This Source Code may also be made available under the following Secondary
* Licenses when the conditions for such availability set forth in the
* Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
* version 2 with the GNU Classpath Exception, which is available at
* https://www.gnu.org/software/classpath/license.html.
*
* SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
*/
package org.glassfish.jersey.server.internal.scanning;
import java.io.IOException;
import java.io.InputStream;
import java.lang.annotation.Annotation;
import java.security.AccessController;
import java.security.PrivilegedActionException;
import java.util.HashSet;
import java.util.LinkedHashSet;
import java.util.Set;
import javax.ws.rs.Path;
import javax.ws.rs.ext.Provider;
import org.glassfish.jersey.internal.OsgiRegistry;
import org.glassfish.jersey.internal.util.ReflectionHelper;
import org.glassfish.jersey.server.internal.LocalizationMessages;
import jersey.repackaged.org.objectweb.asm.AnnotationVisitor;
import jersey.repackaged.org.objectweb.asm.Attribute;
import jersey.repackaged.org.objectweb.asm.ClassReader;
import jersey.repackaged.org.objectweb.asm.ClassVisitor;
import jersey.repackaged.org.objectweb.asm.FieldVisitor;
import jersey.repackaged.org.objectweb.asm.MethodVisitor;
import jersey.repackaged.org.objectweb.asm.ModuleVisitor;
import jersey.repackaged.org.objectweb.asm.Opcodes;
import jersey.repackaged.org.objectweb.asm.TypePath;
/**
* A scanner listener that processes Java class files (resource names
* ending in ".class") annotated with one or more of a set of declared
* annotations.
*
* Java classes of a Java class file are processed, using ASM, to ascertain
* if those classes are annotated with one or more of the set of declared
* annotations.
*
* Such an annotated Java class of a Java class file is loaded if the class
* is public or is an inner class that is static and public.
*
* @author Paul Sandoz
*/
public final class AnnotationAcceptingListener implements ResourceProcessor {
private final ClassLoader classloader;
private final Set> classes;
private final Set annotations;
private final AnnotatedClassVisitor classVisitor;
/**
* Create a scanning listener to check for Java classes in Java
* class files annotated with {@link javax.ws.rs.Path} or {@link javax.ws.rs.ext.Provider}.
*
* @return new instance of {@link AnnotationAcceptingListener} which looks for
* {@link javax.ws.rs.Path} or {@link javax.ws.rs.ext.Provider} annotated classes.
*
*/
@SuppressWarnings({"unchecked"})
public static AnnotationAcceptingListener newJaxrsResourceAndProviderListener() {
return new AnnotationAcceptingListener(Path.class, Provider.class);
}
/**
* Create a scanning listener to check for Java classes in Java
* class files annotated with {@link Path} or {@link Provider}.
*
* @param classLoader the class loader to use to load Java classes that
* are annotated with any one of the annotations.
* @return new instance of {@link AnnotationAcceptingListener} which looks for
* {@link javax.ws.rs.Path} or {@link javax.ws.rs.ext.Provider} annotated classes.
*/
@SuppressWarnings({"unchecked"})
public static AnnotationAcceptingListener newJaxrsResourceAndProviderListener(final ClassLoader classLoader) {
return new AnnotationAcceptingListener(classLoader, Path.class, Provider.class);
}
/**
* Create a scanner listener to check for annotated Java classes in Java
* class files.
*
* @param annotations the set of annotation classes to check on Java class
* files.
*/
public AnnotationAcceptingListener(final Class... annotations) {
this(AccessController.doPrivileged(ReflectionHelper.getContextClassLoaderPA()), annotations);
}
/**
* Create a scanner listener to check for annotated Java classes in Java
* class files.
*
* @param classloader the class loader to use to load Java classes that
* are annotated with any one of the annotations.
* @param annotations the set of annotation classes to check on Java class
* files.
*/
public AnnotationAcceptingListener(final ClassLoader classloader,
final Class... annotations) {
this.classloader = classloader;
this.classes = new LinkedHashSet>();
this.annotations = getAnnotationSet(annotations);
this.classVisitor = new AnnotatedClassVisitor();
}
/**
* Get the set of annotated classes.
*
* @return the set of annotated classes.
*/
public Set> getAnnotatedClasses() {
return classes;
}
private Set getAnnotationSet(final Class... annotations) {
final Set a = new HashSet();
for (final Class c : annotations) {
a.add("L" + c.getName().replaceAll("\\.", "/") + ";");
}
return a;
}
// ScannerListener
public boolean accept(final String name) {
return !(name == null || name.isEmpty()) && name.endsWith(".class");
}
public void process(final String name, final InputStream in) throws IOException {
new ClassReader(in).accept(classVisitor, 0);
}
//
private final class AnnotatedClassVisitor extends ClassVisitor {
/**
* The name of the visited class.
*/
private String className;
/**
* True if the class has the correct scope
*/
private boolean isScoped;
/**
* True if the class has the correct declared annotations
*/
private boolean isAnnotated;
private AnnotatedClassVisitor() {
super(Opcodes.ASM7);
}
public void visit(final int version, final int access, final String name,
final String signature, final String superName, final String[] interfaces) {
className = name;
isScoped = (access & Opcodes.ACC_PUBLIC) != 0;
isAnnotated = false;
}
public AnnotationVisitor visitAnnotation(final String desc, final boolean visible) {
isAnnotated |= annotations.contains(desc);
return null;
}
public void visitInnerClass(final String name, final String outerName,
final String innerName, final int access) {
// If the name of the class that was visited is equal
// to the name of this visited inner class then
// this access field needs to be used for checking the scope
// of the inner class
if (className.equals(name)) {
isScoped = (access & Opcodes.ACC_PUBLIC) != 0;
// Inner classes need to be statically scoped
isScoped &= (access & Opcodes.ACC_STATIC) == Opcodes.ACC_STATIC;
}
}
public void visitEnd() {
if (isScoped && isAnnotated) {
// Correctly scoped and annotated
// add to the set of matching classes.
classes.add(getClassForName(className.replaceAll("/", ".")));
}
}
public void visitOuterClass(final String string, final String string0,
final String string1) {
// Do nothing
}
public FieldVisitor visitField(final int i, final String string,
final String string0, final String string1,
final Object object) {
// Do nothing
return null;
}
public void visitSource(final String string, final String string0) {
// Do nothing
}
public void visitAttribute(final Attribute attribute) {
// Do nothing
}
public MethodVisitor visitMethod(final int i, final String string,
final String string0, final String string1,
final String[] string2) {
// Do nothing
return null;
}
public ModuleVisitor visitModule(final String name, final int access, final String version) {
// Do nothing
return null;
}
public void visitNestHost(final String nestHost) {
// do nothing
}
public void visitNestMember(final String nestMember) {
// do nothing
}
public AnnotationVisitor visitTypeAnnotation(
final int typeRef, final TypePath typePath, final String descriptor, final boolean visible) {
//do nothing
return null;
}
private Class getClassForName(final String className) {
try {
final OsgiRegistry osgiRegistry = ReflectionHelper.getOsgiRegistryInstance();
if (osgiRegistry != null) {
return osgiRegistry.classForNameWithException(className);
} else {
return AccessController.doPrivileged(ReflectionHelper.classForNameWithExceptionPEA(className, classloader));
}
} catch (final ClassNotFoundException ex) {
throw new RuntimeException(LocalizationMessages.ERROR_SCANNING_CLASS_NOT_FOUND(className), ex);
} catch (final PrivilegedActionException pae) {
final Throwable cause = pae.getCause();
if (cause instanceof ClassNotFoundException) {
throw new RuntimeException(LocalizationMessages.ERROR_SCANNING_CLASS_NOT_FOUND(className), cause);
} else if (cause instanceof RuntimeException) {
throw (RuntimeException) cause;
} else {
throw new RuntimeException(cause);
}
}
}
}
}