Scanning Java annotations at runtime
Use org.springframework.context.annotation.ClassPathScanningCandidateComponentProvider
API
A component provider that scans the classpath from a base package. It then applies exclude and include filters to the resulting classes to find candidates.
ClassPathScanningCandidateComponentProvider scanner =
new ClassPathScanningCandidateComponentProvider(<DO_YOU_WANT_TO_USE_DEFALT_FILTER>);
scanner.addIncludeFilter(new AnnotationTypeFilter(<TYPE_YOUR_ANNOTATION_HERE>.class));
for (BeanDefinition bd : scanner.findCandidateComponents(<TYPE_YOUR_BASE_PACKAGE_HERE>))
System.out.println(bd.getBeanClassName());
run time annotation scanning when Dynamic class loading
This approach worked for me. hope this helps someone.
DemoClass= (Class<Annotation>) Class.forName("com.this.class.DemoClass");
if (method.isAnnotationPresent(DemoClass)) {
for (Annotation annotation : method.getAnnotations()) {
Class<? extends Annotation> annotationType = annotation.annotationType();
if (annotationType.getName() == "com.this.class.DemoClass") {
for (Method annotationMethod : annotationType.getDeclaredMethods()) {
value= annotationMethod.invoke(annotation, (Object[]) null);
}
}
}
How can I find Annotated methods in Scala/Java on Runtime
Try one of classpath scanners based on Java reflection (e.g. Reflections) + scala-reflect. Since we use Java reflection only to look for classes and scala-reflect to look for annotated methods, annotations can be written in Scala.
import org.reflections.Reflections
import org.reflections.scanners.SubTypesScanner
import org.reflections.util.{ClasspathHelper, ConfigurationBuilder}
import scala.annotation.StaticAnnotation
import scala.jdk.CollectionConverters._
import scala.reflect.runtime.currentMirror
import scala.reflect.runtime.universe._
class printme extends StaticAnnotation
val reflections = new Reflections(
(new ConfigurationBuilder)
.setUrls(ClasspathHelper.forPackage(""))
.setScanners(new SubTypesScanner(false))
)
def getAllAnnotated(): Unit =
reflections.getAllTypes.asScala
.flatMap(className =>
currentMirror.classSymbol(Class.forName(className))
.toType
.decls
.filter(symbol =>
symbol.isMethod && symbol.annotations.exists(_.tree.tpe =:= typeOf[printme])
)
.map(method => s"$className.${method.name}")
).foreach(println)
Alternatives to Reflections library are for example ClassGraph and Burningwave. If we replace scala-reflect with Java reflection then annotation will have to be written in Java because only annotations written in Java are visible at runtime with Java reflection.
Java - loading annotated classes
First answer: Take a look at this project.
Reflections reflections = new Reflections("org.home.junk");
Set<Class<?>> annotated = reflections.getTypesAnnotatedWith(javax.persistence.Entity.class);
It returns all the classes from org.home.junk
annotated with javax.persistence.Entity
annotation.
Second Answer: To create new instance of above classes you can do this
for (Class<?> clazz : annotated) {
final Object newInstance = clazz.newInstance();
}
Hope this answers everything.
Related Topics
Accept Server'S Self-Signed Ssl Certificate in Java Client
What's the Difference Between @Component, @Repository & @Service Annotations in Spring
Sorting an Arraylist of Objects Using a Custom Sorting Order
How to Use Comparator in Java to Sort
Display Java.Util.Date in a Specific Format
Appending to an Objectoutputstream
Byte Order Mark Screws Up File Reading in Java
Wait For Page Load in Selenium
How Many Threads Can a Java Vm Support
How to Prevent Java.Lang.Numberformatexception: For Input String: "N/A"
Why Are Arrays Covariant But Generics Are Invariant
How to "Decompile" Java Class Files
What Is the Concept of Erasure in Generics in Java
Java: Unresolved Compilation Problem
In Java Streams Is Peek Really Only For Debugging
In Java, Is the Result of the Addition of Two Chars an Int or a Char