How retrieve all classes that implement one or more interfaces

Let's look for all classes that implement java.io.Closeable or java.io.Serializable interface:

import java.io.Closeable;
import java.io.Serializable;
import java.util.Collection;

import org.burningwave.core.assembler.ComponentContainer;
import org.burningwave.core.assembler.ComponentSupplier;
import org.burningwave.core.classes.ClassCriteria;
import org.burningwave.core.classes.ClassHunter;
import org.burningwave.core.classes.ClassHunter.SearchResult;
import org.burningwave.core.classes.SearchConfig;

public class Finder {
    
    public Collection<Class<?>> simplifiedFind() {

        ComponentSupplier componentSupplier = ComponentContainer.getInstance();
        ClassHunter classHunter = componentSupplier.getClassHunter();
        
        //With this the search will be executed on default configured paths that are the 
        //runtime class paths plus, on java 9 and later, the jmods folder of the Java home.
        //The default configured paths are indicated in the 'paths.hunters.default-search-config.paths'
        //property of burningwave.properties file
        //(see https://github.com/burningwave/core/wiki/In-depth-look-to-ClassHunter-and-configuration-guide)
        try (SearchResult searchResult = classHunter.loadInCache(
                SearchConfig.byCriteria(
                    ClassCriteria.create().allThat(currentScannedClass ->
                        Closeable.class.isAssignableFrom(currentScannedClass) ||
                        Serializable.class.isAssignableFrom(currentScannedClass)
                    )
                )
            ).find()) {
            return searchResult.getClasses();
        }
    }

}

It is also possible to expressly indicate the paths on which to search:

import java.io.Closeable;
import java.io.Serializable;
import java.util.Collection;

import org.burningwave.core.assembler.ComponentContainer;
import org.burningwave.core.assembler.ComponentSupplier;
import org.burningwave.core.classes.CacheableSearchConfig;
import org.burningwave.core.classes.ClassCriteria;
import org.burningwave.core.classes.ClassHunter;
import org.burningwave.core.classes.SearchConfig;
import org.burningwave.core.classes.ClassHunter.SearchResult;
import org.burningwave.core.io.PathHelper;

public class Finder {

    public Collection<Class<?>> find() {
        ComponentSupplier componentSupplier = ComponentContainer.getInstance();
        PathHelper pathHelper = componentSupplier.getPathHelper();
        ClassHunter classHunter = componentSupplier.getClassHunter();

        CacheableSearchConfig searchConfig = SearchConfig.forPaths(
            //Here you can add all absolute path you want:
            //both folders, zip, jar, ear and war will be recursively scanned.
            //For example you can add: "C:\\Users\\user\\.m2", or a path of
            //an ear file that contains nested war with nested jar files
            //With the rows below the search will be executed on runtime class paths and
            //on java 9 and later also on .jmod files contained in jmods folder of the Java home
            //(see https://github.com/burningwave/core/wiki/In-depth-look-to-ClassHunter-and-configuration-guide)
            pathHelper.getAllMainClassPaths(),
            pathHelper.getPaths(PathHelper.Configuration.Key.MAIN_CLASS_REPOSITORIES)
            //If you want to scan only one jar you can replace the two line of code above with:
            //pathHelper.getPaths(path -> path.contains("spring-core-4.3.4.RELEASE.jar"))
        ).by(
            ClassCriteria.create().byClasses((uploadedClasses, currentScannedClass) ->
                //[1]here you recall the uploaded class by "useClasses" method.
                //In this case we're looking for all classes that implement java.io.Closeable or java.io.Serializable
                uploadedClasses.get(Closeable.class).isAssignableFrom(currentScannedClass) ||
                uploadedClasses.get(Serializable.class).isAssignableFrom(currentScannedClass)
            ).useClasses(
                //With this directive we ask the library to load one or more classes to be used for comparisons:
                //it serves to eliminate the problem that a class, loaded by different class loaders, 
                //turns out to be different for the comparison operators (eg. The isAssignableFrom method).
                //If you call this method, you must retrieve the uploaded class in all methods that support this feature like in the point[1]
                Closeable.class,
                Serializable.class
            )
        );
        //The loadInCache method loads all classes in the paths of the SearchConfig received as input
        //and then execute the queries of the ClassCriteria on the cached data. Once the data has been 
        //cached, it is possible to take advantage of faster searches for the loaded paths also through 
        //the findBy method. In addition to the loadCache method, loading data into the cache can also
        //take place via the findBy method if the latter receives a SearchConfig without ClassCriteria
        //as input. It is possible to clear the cache individually for every hunter (ClassHunter, 
        //ByteCodeHunter and ClassPathHunter) with clearCache method but to avoid inconsistencies 
        //it is recommended to perform this cleaning using the clearHuntersCache method of the ComponentSupplier.
        //To perform searches that do not use the cache you must instantiate the search configuration with 
        //SearchConfig.withoutUsingCache() method
        try (SearchResult searchResult = classHunter.loadInCache(searchConfig).find()) {
            return searchResult.getClasses();
        }
    }

}