Drools: Expert System for Java Business Rules Management

Before embarking on a new journey, set up the Java environment and include Drools dependencies using Maven or Gradle. This is akin to creating a stage for the “intelligent mentor” to showcase its capabilities, allowing it to shine in complex scenarios.

Assuming we want to build a simple student growth incentive system, first import the key classes:

import org.drools.core.impl.KnowledgeBaseImpl;
import org.drools.core.impl.KnowledgeBaseFactory;
import org.drools.core.impl.SessionFactoryImpl;
import org.drools.core.impl.StatefulKnowledgeSessionImpl;
import org.kie.api.KieServices;
import org.kie.api.runtime.KieContainer;
import org.kie.api.runtime.KieSession;

These familiar Drools classes remain powerful assistants in building a robust business rules engine, lighting the way for student growth.

Next, initialize the rules engine:

KieServices kieServices = KieServices.Factory.get();
KieContainer kieContainer = kieServices.getKieClasspathContainer();
KieSession kieSession = kieContainer.newKieSession();

It’s like creating a dedicated “intelligent decision cockpit” where all judgments and decisions regarding student incentives will be accurately produced, and the “intelligent mentor” is ready, waiting for student data input.

Then, define the business rules. Create a rules file (e.g., incentive.drl):

import org.dozer.DozerBeanMapper;

Next, initialize DozerBeanMapper:

DozerBeanMapper mapper = new DozerBeanMapper();

This step is like awakening the sleeping “moving master,” ready to obey commands and transfer data between different objects.

Then, define the source and target objects. Assume the detailed employee information queried from the backend is as follows:

EmployeeDB employeeDB = new EmployeeDB(1, "John Doe", "[email protected]", "123-456-7890", "Engineering", 50000, new Date());

And the employee information model to be displayed on the frontend is:

EmployeeFrontend employeeFrontend = new EmployeeFrontend();

Now, let the “moving master” perform its magic:

mapper.map(employeeDB, employeeFrontend);

System.out.println("Employee Name: " + employeeFrontend.getName());
System.out.println("Employee Email: " + employeeFrontend.getEmail());

Dozer Mapping also possesses powerful custom mapping rule capabilities. Suppose the department ID in the employee table needs to be displayed as the corresponding department name on the frontend instead of the numeric ID:

// Custom field mapping rules
mapper.addMapping(new DozerCustomMapper() {
    @Override
    public void map(Object source, Object destination, DozerMapper mapper) {
        EmployeeDB empDB = (EmployeeDB) source;
        EmployeeFrontend empFrontend = (EmployeeFrontend) destination;
        if (empDB.getDepartmentId() == 1) {
            empFrontend.setDepartmentName("Research Department");
        } else if (empDB.getDepartmentId() == 2) {
            empFrontend.setDepartmentName("Marketing Department");
        }
    }
});

Additionally, it supports complex object nested mapping. For example, if the employee information contains a department object, which in turn has supervisor information, etc., in a multi-layer nested structure:

Department department = new Department(1, "Research Department", new EmployeeDB(2, "Manager Jane", "[email protected]", "", "", 80000, new Date()));
employeeDB.setDepartment(department);

// During mapping, Dozer Mapping automatically handles nested relationships
mapper.map(employeeDB, employeeFrontend);

System.out.println("Department Name: " + employeeFrontend.getDepartment().getName());
System.out.println("Department Supervisor: " + employeeFrontend.getDepartment().getManager().getName());

In the face of such complex scenarios, the “moving master” remains adept and methodical, seamlessly traversing between multi-layer objects to achieve precise mapping, ensuring smooth data flow.

Leave a Comment Cancel reply