DEV Community: JJBRT

Querying and validating a JSON document in Java

JJBRT — Wed, 25 Oct 2023 09:19:56 +0000

The JSON format is now the standard for communication between distributed services and there are various solutions for reading and validating these documents: here we will present a new one compatible with the latest Java versions: the Burningwave JSON library.

To start we need to add the following dependency to our pom.xml:

In this library there are 3 types of objects that respectively deal with reading, querying and validating JSON documents:

the ObjectHandler
the Finder
the Validator

To explain how these types of objects work we will take the following JSON document as input:

The ObjectHandler

First of all, to find values in a JSON document we need to load it via ObjectHandler. The ObjectHandler wraps the JSON document and contains the path and the value of the node you are visiting within the JSON. To instantiate an ObjectHandler follow this code:

The Finder

After loaded the JSON document, to search elements within it we need to instantiate a Finder. There are 3 kinds of Finder:

the ObjectHandler.Finder that which allows you to search for elements within the JSON returning ObjectHandlers
the ObjectHandler.ValueFinder that which allows you to search for elements within the JSON directly returning the values
the ObjectHandler.ValueFinderAndConverter that which allows you to search for elements within the JSON and convert the values found

The ObjectHandler.Finder

To obtain this kind of finder we need to use this code:

Once we obtained the finder we can use it to search items inside the JSON document:

The ObjectHandler.ValueFinder

To obtain this kind of finder we need to use this code:

Once we obtained the finder we can use it to search items inside the JSON document:

The ObjectHandler.ValueFinderAndConverter

To obtain this kind of finder we need to use this code:

Once you obtained the finder we can use it to search items inside the JSON document and convert them:

The Validator

To validate a JSON document we need to obtain the Validator and then register the checks:

Once registered the checks, to execute the validation you must call the validate method:

The search and validation possibilities offered by this library are practically infinite and this tutorial only shows an overview of the components exposed by the library and some examples of basic operation: for any further help you can open a discussion on GitHub.

From here you can download/clone the tutorial shared on GitHub.

How to configure host name resolution to use a universal host name resolver in Java

JJBRT — Fri, 28 Oct 2022 21:59:00 +0000

In the JDK 8 the java.net.InetAddress resolves host names using the local machine's default host name resolver by default:

Host name-to-IP address resolution is accomplished through the use of a combination of local machine configuration information and network naming services such as the Domain Name System (DNS) and Network Information Service(NIS). The particular naming services(s) being used is by default the local machine configured one. For any host name, its corresponding IP address is returned. ^[source]

In the JDK 19 the java.net.InetAddress works the same way but there is also the option to use a custom configuration:

The built-in InetAddress resolver implementation does host name-to-IP address resolution and vice versa through the use of a combination of local machine configuration information and network naming services such as the Domain Name System (DNS) and the Lightweight Directory Access Protocol (LDAP). The particular naming services that the built-in resolver uses by default depends on the configuration of the local machine. InetAddress has a service provider mechanism for InetAddress resolvers that allows a custom InetAddress resolver to be used instead of the built-in implementation. ^[source]

So how can we configure this behavior without modifying the local machine's default host name resolver in a universal way that works for Java 8 and later?

In this situation Burningwave Tools comes to our aid by providing us with the HostResolutionRequestInterceptor that allows us:

to use a custom resolver instead the default one
to prepend a custom resolver to the default one
to postpone a custom resolver to the default one

To include Burningwave Tools in our project we need to add the following dependency to our pom.xml:

And to install the HostResolutionRequestInterceptor component we must proceed as follows:

Burningwave Tools provides also a DNS server connection based host resolver:

But you can also define a new custom resolver by implementing the HostResolver interface that create DNS packet requests, send them to the servers through the java.net.DatagramSocket and parse the responses:

If we add the Jackson framework to our project we can add the configuration via yaml file support with a few lines of code by using the PathHelper component:

From here you can download/clone the tutorial shared on GitHub.

Iterating collections and arrays in parallel by setting thread priority

JJBRT — Wed, 16 Mar 2022 11:06:55 +0000

Through the underlying configurable BackgroundExecutor the IterableObjectHelper component is able to iterate a collection or an array in parallel and execute an action on each iterated item giving also the ability to set the threads priority. Before starting to use this component we need to add the following dependency to our pom.xml:

… And now let’s see the code:

package org.burningwave.core.examples.iterableobjecthelper;

import static org.burningwave.core.assembler.StaticComponentContainer.IterableObjectHelper;
import static org.burningwave.core.assembler.StaticComponentContainer.ManagedLoggerRepository;

import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.IntStream;

import org.burningwave.core.iterable.IterableObjectHelper.IterationConfig;

public class CollectionAndArrayIterator {

    public static void execute() {
        Collection<Integer> inputCollection =
            IntStream.rangeClosed(1, 1000000).boxed().collect(Collectors.toList());

        List<String> outputCollection = IterableObjectHelper.iterateAndGet(
            IterationConfig.of(inputCollection)
            //Enabling parallel iteration when the input collection size is greater than 2
            .parallelIf(inputColl -> inputColl.size() > 2)
            //Setting threads priority
            .withPriority(Thread.MAX_PRIORITY)
            //Setting up the output collection
            .withOutput(new ArrayList<String>())
            .withAction((number, outputCollectionSupplier) -> {
                if (number > 500000) {
                    //Terminating the current thread iteration early.
                    IterableObjectHelper.terminateCurrentThreadIteration();
                    //If you need to terminate all threads iteration (useful for a find first iteration) use
                    //IterableObjectHelper.terminateIteration();
                }
                if ((number % 2) == 0) {                        
                    outputCollectionSupplier.accept(outputColl ->
                        //Converting and adding item to output collection
                        outputColl.add(number.toString())
                    );
                }
            })    
        );

        IterableObjectHelper.iterate(
            IterationConfig.of(outputCollection)
            //Disabling parallel iteration
            .parallelIf(inputColl -> false)
            .withAction((number) -> {
                ManagedLoggerRepository.logInfo(CollectionAndArrayIterator.class::getName, "Iterated number: {}", number);
            })    
        );

        ManagedLoggerRepository.logInfo(
            CollectionAndArrayIterator.class::getName,
            "Output collection size {}", outputCollection.size()
        );
    }

    public static void main(String[] args) {
        execute();
    }

}

How to create your own dependency injection framework in Java

JJBRT — Thu, 25 Nov 2021 06:16:33 +0000

Overview

This article will guide you to understand and build a lightweight Java application using your own Dependency Injection implementation.

Dependency Injection… DI… Inversion Of Control… IoC…, I guess you might have heard these names so many times while your regular routine or specially interview preparation time that you wonder what exactly it is.

But if you really want to understand how internally it works then continue reading here.

So, what is dependency injection?

Dependency injection is a design pattern used to implement IoC, in which instance variables (ie. dependencies) of an object got created and assigned by the framework.

To use DI feature a class and it's instance variables just need to add annotations predefined by the framework.

The Dependency Injection pattern involves 3 types of classes.

Client Class: The client class (dependent class) depends on the service class.
Service Class: The service class (dependency class) that provides service to the client class.
Injector Class: The injector class injects the service class object into the client class.

In this way, the DI pattern separates the responsibility of creating an object of the service class out of the client class. Below are a couple more terms used in DI.

Interfaces that define how the client may use the services.
Injection refers to the passing of a dependency (a service) into the object (a client), this is also referred to as auto wire.

So, what is Inversion of Control?

In short, "Don't call us, we'll call you."

Inversion of Control (IoC) is a design principle. It is used to invert different kinds of controls (ie. object creation or dependent object creation and binding ) in object-oriented design to achieve loose coupling.
Dependency injection one of the approach to implement the IoC.
IoC helps to decouple the execution of a task from implementation.
IoC helps it focus a module on the task it is designed for.
IoC prevents side effects when replacing a module.

Class diagram of dependency injection design pattern:

In the above class diagram, the Client class that requires UserService and AccountService objects does not instantiate the UserServiceImpl and AccountServiceImpl classes directly.

Instead, an Injector class creates the objects and injects them into the Client, which makes the client independent of how the objects are created.

Types of Dependency Injection

Constructor injection: the injector supplies the service (dependency) through the client class constructor. In this case, Autowired annotation added on the constructor.
Property injection: the injector supplies the service (dependency) through a public property of the client class. In this case Autowired annotation added while member variable declaration.
Setter method injection: the client class implements an interface that declares the method(s) to supply the service (dependency) and the injector uses this interface to supply the dependency to the client class.

In this case, Autowired annotation added while method declaration.

How it works?

To understand Dependency Injection implementation, refer code snippets here, or download/clone the tutorial shared here on GitHub.

Prerequisite

For a better understanding of this tutorial, it's good to have basic knowledge of Annotations and reflection in advance.

Required Java libraries

Before begin with the coding steps, you can create new maven project in the eclipse and add Burningwave Core dependency in pom.xml:

Create user-defined annotations

As described above DI implementation has to provide predefined annotations, which can be used while declaration of client class and service variables inside a client class.

Let's add basic annotations, which can be used by client and service classes:



package org.di.framework.annotations;

import java.lang.annotation.*;

/**
 * Client class should use this annotation
 */
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public @interface Component {

}



package org.di.framework.annotations;

import java.lang.annotation.*;
import static java.lang.annotation.ElementType.*;
import static java.lang.annotation.RetentionPolicy.RUNTIME;

/**
 * Service field variables should use this annotation
 */
@Target({ METHOD, CONSTRUCTOR, FIELD })
@Retention(RUNTIME)
@Documented
public @interface Autowired {

}



package org.di.framework.annotations;

import java.lang.annotation.*;

/**
 *  Service field variables should use this annotation
 *  This annotation Can be used to avoid conflict if there are multiple implementations of the same interface
 */
@Target({ ElementType.FIELD, ElementType.METHOD, ElementType.PARAMETER, ElementType.TYPE, ElementType.ANNOTATION_TYPE })
@Retention(RetentionPolicy.RUNTIME)
@Inherited
@Documented
public @interface Qualifier {
    String value() default "";
}

Service interfaces



package com.useraccount.services;

public interface UserService {
    String getUserName();
}



package com.useraccount.services;

public interface AccountService {
    Long getAccountNumber(String userName);
}

Service classes

These classes implement service interfaces and use DI annotations.



package com.useraccount.services.impl;

import org.di.framework.annotations.Component;

import com.useraccount.services.UserService;

@Component
public class UserServiceImpl implements UserService {

    @Override
    public String getUserName() {
        return "username";
    }
}



package com.useraccount.services.impl;

import org.di.framework.annotations.Component;

import com.useraccount.services.AccountService;

@Component
public class AccountServiceImpl implements AccountService {

    @Override
    public Long getAccountNumber(String userName) {
        return 12345689L;
    }
}

Client class

For using the DI features client class has to use predefined annotations provided by DI framework for the client and service class.



package com.useraccount;

import org.di.framework.annotations.*;

import com.useraccount.services.*;

/**
 * Client class, havin userService and accountService expected to initialized by
 * CustomInjector.java
 */
@Component
public class UserAccountClientComponent {

    @Autowired
    private UserService userService;

    @Autowired
    @Qualifier(value = "accountServiceImpl")
    private AccountService accountService;

    public void displayUserAccount() {
        String username = userService.getUserName();
        Long accountNumber = accountService.getAccountNumber(username);
        System.out.println("\n\tUser Name: " + username + "\n\tAccount Number: " + accountNumber);
    }
}

Injector class

Injector class plays a major role in the DI framework. Because it is responsible to create instances of all clients and autowire instances for each service in client classes.
Steps:

Scan all the clients under the root package and all sub packages
Create an instance of client class.
Scan all the services using in the client class (member variables, constructor parameters, method parameters)
Scan for all services declared inside the service itself (nested dependencies), recursively
Create instance for each service returned by step 3 and step 4
Autowire: Inject (ie. initialize) each service with instance created at step 5
Create Map all the client classes Map
Expose API to get the getBean(Class classz)/getService(Class classz).
Validate if there are multiple implementations of the interface or there is no implementation
Handle Qualifier for services or autowire by type in case of multiple implementations.

This class heavily uses basic method provided by the java.lang.Class and org.burningwave.classes.ClassHunter:



package org.di.framework;

import java.io.IOException;
import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Optional;
import java.util.Set;
import java.util.stream.Collectors;

import javax.management.RuntimeErrorException;

import org.burningwave.core.assembler.ComponentContainer;
import org.burningwave.core.classes.ClassCriteria;
import org.burningwave.core.classes.ClassHunter;
import org.burningwave.core.classes.SearchConfig;
import org.di.framework.annotations.Component;
import org.di.framework.utils.InjectionUtil;

/**
 * Injector, to create objects for all @CustomService classes. autowire/inject
 * all dependencies
 */
public class Injector {
    private Map<Class<?>, Class<?>> diMap;
    private Map<Class<?>, Object> applicationScope;

    private static Injector injector;

    private Injector() {
        super();
        diMap = new HashMap<>();
        applicationScope = new HashMap<>();
    }

    /**
     * Start application
     * 
     * @param mainClass
     */
    public static void startApplication(Class<?> mainClass) {
        try {
            synchronized (Injector.class) {
                if (injector == null) {
                    injector = new Injector();
                    injector.initFramework(mainClass);
                }
            }
        } catch (Exception ex) {
            ex.printStackTrace();
        }
    }

    public static <T> T getService(Class<T> classz) {
        try {
            return injector.getBeanInstance(classz);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * initialize the injector framework
     */
    private void initFramework(Class<?> mainClass)
            throws InstantiationException, IllegalAccessException, ClassNotFoundException, IOException {
        Class<?>[] classes = getClasses(mainClass.getPackage().getName(), true);
        ComponentContainer componentConatiner = ComponentContainer.getInstance();
        ClassHunter classHunter = componentConatiner.getClassHunter();
        String packageRelPath = mainClass.getPackage().getName().replace(".", "/");
        try (ClassHunter.SearchResult result = classHunter.findBy(
            SearchConfig.forResources(
                packageRelPath
            ).by(ClassCriteria.create().allThoseThatMatch(cls -> {
                return cls.getAnnotation(Component.class) != null;
            }))
        )) {
            Collection<Class<?>> types = result.getClasses();
            for (Class<?> implementationClass : types) {
                Class<?>[] interfaces = implementationClass.getInterfaces();
                if (interfaces.length == 0) {
                    diMap.put(implementationClass, implementationClass);
                } else {
                    for (Class<?> iface : interfaces) {
                        diMap.put(implementationClass, iface);
                    }
                }
            }

            for (Class<?> classz : classes) {
                if (classz.isAnnotationPresent(Component.class)) {
                    Object classInstance = classz.newInstance();
                    applicationScope.put(classz, classInstance);
                    InjectionUtil.autowire(this, classz, classInstance);
                }
            }
        };  

    }

    /**
     * Get all the classes for the input package
     */
    public Class<?>[] getClasses(String packageName, boolean recursive) throws ClassNotFoundException, IOException {
        ComponentContainer componentConatiner = ComponentContainer.getInstance();
        ClassHunter classHunter = componentConatiner.getClassHunter();
        String packageRelPath = packageName.replace(".", "/");
        SearchConfig config = SearchConfig.forResources(
            packageRelPath
        );
        if (!recursive) {
            config.findInChildren();
        }

        try (ClassHunter.SearchResult result = classHunter.findBy(config)) {
            Collection<Class<?>> classes = result.getClasses();
            return classes.toArray(new Class[classes.size()]);
        }   
    }


    /**
     * Create and Get the Object instance of the implementation class for input
     * interface service
     */
    @SuppressWarnings("unchecked")
    private <T> T getBeanInstance(Class<T> interfaceClass) throws InstantiationException, IllegalAccessException {
        return (T) getBeanInstance(interfaceClass, null, null);
    }

    /**
     * Overload getBeanInstance to handle qualifier and autowire by type
     */
    public <T> Object getBeanInstance(Class<T> interfaceClass, String fieldName, String qualifier)
            throws InstantiationException, IllegalAccessException {
        Class<?> implementationClass = getImplimentationClass(interfaceClass, fieldName, qualifier);

        if (applicationScope.containsKey(implementationClass)) {
            return applicationScope.get(implementationClass);
        }

        synchronized (applicationScope) {
            Object service = implementationClass.newInstance();
            applicationScope.put(implementationClass, service);
            return service;
        }
    }

    /**
     * Get the name of the implimentation class for input interface service
     */
    private Class<?> getImplimentationClass(Class<?> interfaceClass, final String fieldName, final String qualifier) {
        Set<Entry<Class<?>, Class<?>>> implementationClasses = diMap.entrySet().stream()
                .filter(entry -> entry.getValue() == interfaceClass).collect(Collectors.toSet());
        String errorMessage = "";
        if (implementationClasses == null || implementationClasses.size() == 0) {
            errorMessage = "no implementation found for interface " + interfaceClass.getName();
        } else if (implementationClasses.size() == 1) {
            Optional<Entry<Class<?>, Class<?>>> optional = implementationClasses.stream().findFirst();
            if (optional.isPresent()) {
                return optional.get().getKey();
            }
        } else if (implementationClasses.size() > 1) {
            final String findBy = (qualifier == null || qualifier.trim().length() == 0) ? fieldName : qualifier;
            Optional<Entry<Class<?>, Class<?>>> optional = implementationClasses.stream()
                    .filter(entry -> entry.getKey().getSimpleName().equalsIgnoreCase(findBy)).findAny();
            if (optional.isPresent()) {
                return optional.get().getKey();
            } else {
                errorMessage = "There are " + implementationClasses.size() + " of interface " + interfaceClass.getName()
                        + " Expected single implementation or make use of @CustomQualifier to resolve conflict";
            }
        }
        throw new RuntimeErrorException(new Error(errorMessage));
    }
}

This class heavily uses basic method provided by the java.lang.reflect.Field.
The autowire() method in this class is recursive method because it takes care of injecting dependencies declared inside the service classes (ie. nested dependencies):



package org.di.framework.utils;

import static org.burningwave.core.assembler.StaticComponentContainer.Fields;

import java.util.*;

import org.burningwave.core.classes.FieldCriteria;
import org.di.framework.Injector;
import org.di.framework.annotations.*;

import java.lang.reflect.Field;

public class InjectionUtil {

    private InjectionUtil() {
        super();
    }

    /**
     * Perform injection recursively, for each service inside the Client class
     */
    public static void autowire(Injector injector, Class<?> classz, Object classInstance)
            throws InstantiationException, IllegalAccessException {
        Collection<Field> fields = Fields.findAllAndMakeThemAccessible(
            FieldCriteria.forEntireClassHierarchy().allThat(field ->
                field.isAnnotationPresent(Autowired.class)
            ), 
            classz
        );
        for (Field field : fields) {
            String qualifier = field.isAnnotationPresent(Qualifier.class)
                    ? field.getAnnotation(Qualifier.class).value()
                    : null;
            Object fieldInstance = injector.getBeanInstance(field.getType(), field.getName(), qualifier);
            Fields.setDirect(classInstance, field, fieldInstance);
            autowire(injector, fieldInstance.getClass(), fieldInstance);
        }
    }

}

Application main class:



package com.useraccount;

import org.di.framework.Injector;

public class UserAccountApplication {

    public static void main(String[] args) {
        long startTime = System.currentTimeMillis();
        Injector.startApplication(UserAccountApplication.class);
        Injector.getService(UserAccountClientComponent.class).displayUserAccount();
        long endime = System.currentTimeMillis();
    }
}

Below is the comparison with dependencies added by Spring.

Spring dependencies:

Your own DI framework dependencies:

Conclusion

This article should give a clear understanding of how DI or autowire dependencies work.

With the implementation of your own DI framework, you don't need heavy frameworks, if you are really not using most of their features in your application, like Bean Life cycle Management method executions and much more heavy stuff.

You can do a lot of things which are not mentioned here like:

adding more user-defined annotations for various purpose (eg. like bean scopes singleton, prototype, request, session, global-session)
setting configurability with placeholders
setting configurability with Java coded properties
generating classes at runtime

... And many more features.

From here you can download/clone the tutorial shared on GitHub.

Special thanks to Shital Devalkar for writing the article.

Exporting all modules to all modules at runtime on Java 16 and later

JJBRT — Sat, 18 Sep 2021 21:31:06 +0000

From Java 9 is not allowed by default an application to see all classes from the JDK, unlike all previous versions of Java, due to the new module system. So if we try to access some reserved module we obtain an error like this:
module <module-name> does not "opens <package-name>" to unnamed module.
Everyone knows that we can solve this exception by using the JVM parameters --add-exports or add-opens, but how we can do for example if we have more environments and we don't want to have to change JVM args across these environments?
In this situation Burningwave Core comes to our aid by providing us with the method org.burningwave.core.assembler.StaticComponentContainer.Modules.exportAllToAll() that allows us to export all modules in all modules, thus solving our problem.
To include this library in our project we need to add the following dependency to our pom.xml:

The method org.burningwave.core.assembler.StaticComponentContainer.Modules.exportAllToAll() is called by default on the initialization of the class org.burningwave.core.assembler.StaticComponentContainer but this behavior can be changed by including in the base folder of your class path a file named burningwave.static.properties that contains a property named modules.export-all-to-all whose value is false thus leaving us the possibility to call this method manually (note that it is not necessary to put in the burningwave.static.properties file all the properties present in the relative link supplied before):

org.burningwave.core.assembler.StaticComponentContainer.Modules.exportAllToAll();
//Now that we have called exportAllToAll () we can use any class of any module
Method method = URLClassLoader.class.getDeclaredMethod("addURL", URL.class);
method.setAccessible(true);
ClassLoader classLoader = new URLClassLoader(new URL[] {}, null);
method.invoke(
    classLoader,
    org.burningwave.core.assembler.StaticComponentContainer.Resources.getClassPath(AllModulesToAllModulesExporter.class).getURL()
);
Class<?> fieldsHandlerClass = classLoader.loadClass(FieldsHandler.class.getName());
if (FieldsHandler.class != fieldsHandlerClass) {
    System.out.println(
        FieldsHandler.class.toString() + " and " + fieldsHandlerClass.toString() + " are loaded from the same bytecode but they are different instances:" +
        "\n\t" + FieldsHandler.class + " is loaded by " + FieldsHandler.class.getClassLoader() +
        "\n\t" + fieldsHandlerClass + " is loaded by " + fieldsHandlerClass.getClassLoader()
    );
}

The Modules component also exposes other methods for greater granularity:

export(String moduleNameFrom, String moduleNameTo)
exportPackage(String moduleNameFrom, String moduleNameTo, String... packageNames)
exportPackageToAll(String name, String... packageNames)
exportPackageToAllUnnamed(String name, String... packageNames)
exportToAll(String name)
exportToAllUnnamed(String name)

Therefore, referring to the example above, if we want to limit the export to the package of our interest we have just to replace the call exportAllToAll() with exportPackageToAllUnnamed("java.base", "java.net").

From here you can download/clone the tutorial shared on GitHub that contains another example about to use the method org.burningwave.core.assembler.StaticComponentContainer.Modules.exportAllToAll().

Making reflection fully work on Java 16 and later

JJBRT — Tue, 14 Sep 2021 11:00:33 +0000

Due to the strong encapsulation introduced starting from jdk 16 some non-public classes, methods and fields of the java.* package are no longer available via reflection, so how to get the legacy code to work on these new versions of JDK?

In this situation, the member handlers of Burningwave Core library comes to our aid, by giving us the ability to retrieve any field, method, or constructor of any class. These components are able to accomplish their task thanks to a special driver which requires no parameters to be passed to the jvm executable.

The members handlers use to cache all members for faster access, and now let's now see how to use these components.
To start we need to add the following dependency to our pom.xml:

For fields handling we are going to use Fields component:

org.burningwave.core.classes.Fields fields =
    org.burningwave.core.assembler.StaticComponentContainer.Fields;

ClassLoader classLoader =
    Thread.currentThread().getContextClassLoader();

//Fast access by memory address
Collection<Class<?>> loadedClasses =
    fields.getDirect(classLoader, "classes");

//Access by Reflection
loadedClasses = fields.get(classLoader, "classes");

//Get all field values of an object 
//through memory address access
Map<Field, ?> values =
    fields.getAllDirect(classLoader);

//Get all field values of an object
//through reflection access
values = fields.getAll(classLoader);

For methods handling we are going to use Methods component and we can accomplish the task in several ways:

by direct method invocation:

//loading the byte code
org.burningwave.core.io.FileSystemItem fileSystemItem = 
    org.burningwave.core.io.FileSystemItem.ofPath(
        "C:/my/pckg/MyClass.class"
    );
byte[] byteCode = fileSystemItem.toByteArray();

//invoking defineClass method
Class<?> cls = org.burningwave.core.assembler.StaticComponentContainer.Methods.invoke(
    Thread.currentThread().getContextClassLoader(),
    "defineClass",
    "my.pckg.MyClass",
    byteCode,
    0,
    byteCode.length,
    null
);

by direct method handle invocation:

//loading the byte code
org.burningwave.core.io.FileSystemItem fileSystemItem = 
    org.burningwave.core.io.FileSystemItem.ofPath(
        "C:/my/pckg/MyClass.class"
    );
byte[] byteCode = fileSystemItem.toByteArray();

//invoking defineClass method handle
Class<?> cls = org.burningwave.core.assembler.StaticComponentContainer.Methods.invokeDirect(
    Thread.currentThread().getContextClassLoader(),
    "defineClass",
    "my.pckg.MyClass",
    byteCode,
    0,
    byteCode.length,
    null
);

by retrieving and invoking a method:

org.burningwave.core.classes.Methods methods =
    org.burningwave.core.assembler.StaticComponentContainer.Methods;
//Filtering and obtaining a Method reference
Method method = methods.findFirst(
    MethodCriteria.byScanUpTo((cls) ->
        //We only analyze the ClassLoader class and not all of its hierarchy (default behavior)
        cls.getName().equals(ClassLoader.class.getName())
    ).name(
        "defineClass"::equals
    ).and().parameterTypes(params -> 
        params.length == 5
    ).and().parameterTypesAreAssignableFrom(
        String.class, byte[].class, int.class, int.class, ProtectionDomain.class
    ).and().returnType((cls) -> 
        cls.getName().equals(Class.class.getName())
    ), ClassLoader.class
);

//loading the byte code
org.burningwave.core.io.FileSystemItem fileSystemItem = 
    org.burningwave.core.io.FileSystemItem.ofPath(
        "C:/my/pckg/MyClass.class"
    );
byte[] byteCode = fileSystemItem.toByteArray();

//invoking defineClass method
Class<?> cls = methods.invoke(
    Thread.currentThread().getContextClassLoader(),
    method,
    "my.pckg.MyClass",
    byteCode,
    0,
    byteCode.length,
    null
);

by retrieving and invoking a method handle:

//Filtering and obtaining a MethodHandle reference
MethodHandle defineClassMethodHandle = org.burningwave.core.assembler.StaticComponentContainer.Methods.findFirstDirectHandle(
    MethodCriteria.byScanUpTo((cls) ->
        //We only analyze the ClassLoader class and not all of its hierarchy (default behavior)
        cls.getName().equals(ClassLoader.class.getName())
    ).name(
        "defineClass"::equals
    ).and().parameterTypes(params -> 
        params.length == 5
    ).and().parameterTypesAreAssignableFrom(
        String.class, byte[].class, int.class, int.class, ProtectionDomain.class
    ).and().returnType((cls) -> 
        cls.getName().equals(Class.class.getName())
    ), ClassLoader.class
);

//loading the byte code
org.burningwave.core.io.FileSystemItem fileSystemItem = 
    org.burningwave.core.io.FileSystemItem.ofPath(
        "C:/my/pckg/MyClass.class"
    );
byte[] byteCode = fileSystemItem.toByteArray();

//invoking defineClass method handle
Class<?> cls = defineClassMethodHandle.invoke(
    Thread.currentThread().getContextClassLoader(),
    "my.pckg.MyClass",
    byteCode,
    0,
    byteCode.length,
    null
);

Another way to use reflection is to export all modules to all modules at runtime through Modules component: in this case it will be possible to use reflection in the standard style without resorting to the reflection components of Burnignwave Core.

From here you can download/clone the tutorial shared on GitHub.