Data Mapper is a powerful Java library that offers a comprehensive solution for parsing, transforming, and mapping JSON or XML files to Java beans, driven by a given set of rules. It is designed to simplify the process of data manipulation and conversion in your Java projects.
With the latest version, Data Mapper introduces a new feature that allows seamless transformation of one Java bean to another type. Now, you can effortlessly convert your Java beans between different classes, making it even more versatile and adaptable to various data processing scenarios.
- Effortlessly parse JSON and XML files into Java beans.
- Seamlessly transform JSON and XML strings into Java beans.
- Preview the transformed JSON or XML as a string.
- Flexibly transform one Java bean type into another using specified rules.
- Transform data using custom rules to match specific requirements.
- Exceptionally fast and lightweight for optimal performance.
To use Data Mapper in your project, include the following dependency:
<dependency>
<groupId>org.perfios</groupId>
<artifactId>data-mapper</artifactId>
<version>1.1.1</version>
</dependency>Transforms a JSON or XML file according to specified rules and returns an instance of the desired class type.
The overloaded version of this method accepts JSON or XML along with the rules as File type to perform the same.
inputPath StringThe path to the input file (JSON or XML) to be transformed. |
rulesPath StringThe path to the rules file containing transformation rules. |
className Class<T>The desired class type to be returned after transformation. |
input FileThe input JSON or XML file to be transformed. |
rules FileThe rules file containing transformation rules. |
An instance of the desired class type, representing the transformed data.
import org.perfios.DataMapper;
import org.perfios.DataMapperImpl;
public class Usage
{
public static void main(String[] args) {
// Create an instance of the DataMapper interface
DataMapper dataMapper = new DataMapperImpl();
// Specify the paths to the input JSON file and the rules file
String inputPath = "/path/to/input.json";
String rulesPath = "/path/to/rules.txt";
// Define the desired Java bean class (Employee in this case)
Class<Employee> desiredClass = Employee.class;
// Transform the JSON file using the specified rules and class type
Employee transformedEmployee = dataMapper.transformFile(inputPath, rulesPath, desiredClass);
}
}Transforms a JSON or XML string according to specified rules and returns an instance of the desired class type.
inputString String The JSON or XML string to be transformed. |
rulesString StringThe string containing transformation rules. |
className Class<T>The desired class type to be returned after transformation. |
An instance of the desired class type, representing the transformed data.
import org.perfios.DataMapper;
import org.perfios.DataMapperImpl;
public class Usage
{
public static void main(String[] args) {
// Create an instance of the DataMapper interface
DataMapper dataMapper = new DataMapperImpl();
// Specify the paths to the input JSON file and the rules file
String inputPath = "/path/to/input.json";
String rulesPath = "/path/to/rules.txt";
// Read the contents of the input JSON file and rules file into strings
String inputString = new String(Files.readAllBytes(Paths.get(inputPath.getAbsolutePath())));
String rulesString = new String(Files.readAllBytes(Paths.get(rulesPath.getAbsolutePath())));
// Define the desired Java bean class (Employee in this case)
Class<Employee> desiredClass = Employee.class;
// Transform the JSON file using the specified rules and class type
Employee transformedEmployee = dataMapper.transformString(inputString, rulesString, desiredClass);
}
}Transforms an input Java Bean according to specified rules and returns another Java bean of the desired type.
The overloaded version of this method accepts the transformation rules as File type to perform the same.
inputBean ObjectThe input Java bean to be transformed. |
rulesString StringThe rules string containing transformation rules. |
className Class<T>The desired class type to be returned after transformation. |
rules FileThe rules file containing transformation rules. |
An instance of the desired class type, representing the transformed data.
import org.perfios.DataMapper;
import org.perfios.DataMapperImpl;
public class Usage
{
public static void main(String[] args) {
// Create an instance of the DataMapper interface
DataMapper dataMapper = new DataMapperImpl();
// Specify the paths to the input Java bean and the rules file
EmployeeTypeA inputBean = new EmployeeTypeA("emp_id","emp_name","emp_salary");
File rules= new File("/path/to/rules.txt");
// Define the desired Java bean class (Employee in this case)
Class<EmployeeTypeB> desiredClass = EmployeeTypeB.class;
// Transform the JSON file using the specified rules and class type
EmployeeTypeB transformedEmployee = dataMapper.transformFile(inputBean, rules, desiredClass);
}
}Transforms an input JSON or XML string according to specified rules and returns a string representing the transformed input in the desired extension format.
The overloaded version of this method accepts JSON or XML along with the rules as File type to perform the same.
input StringThe input JSON or XML string to be transformed. |
rules StringThe rules string containing transformation rules. |
ext DataMapperImpl.ExtensionThe extension indicating the format of the input file (JSON or XML). |
input FileThe input JSON or XML file to be transformed. |
rules FileThe rules file containing transformation rules. |
A string representing the transformed JSON or XML input in the desired extension format.
import org.perfios.DataMapper;
import org.perfios.DataMapperImpl;
public class Usage
{
public static void main(String[] args) {
// Create an instance of the DataMapper interface
DataMapper dataMapper = new DataMapperImpl();
//Create File objects of input file and rules file using their respective paths
File input = new File("/path/to/input.json");
File rules = new File("/path/to/rules.txt");
// Transform the JSON file using the specified rules and desired output type
String transformedEmployee = dataMapper.getTransformedString(input, rules, DataMapperImpl.Extension.XML);
}
}#add |
"Facilitates addition of numbers or concatenation of two input fields." |
#sub |
Facilitates subtraction of numbers between two fields from input file |
#mul |
Facilitates multiplication of numbers between two fields from input file |
#div |
Facilitates division of numbers between two fields from input file |
#default |
Facilitates setting default values for fields. |
| Example Input JSON File | Example Input XML File |
{
"details": {
"name": {
"firstName": "John",
"lastName": "Doe"
},
"addresses": [
{
"address1": {
"phoneNumber": 1234567890,
"state": "California"
}
},
{
"address2": {
"phoneNumber": 9876543210,
"state": "New York"
}
}
]
}
}
|
<root>
<details>
<name>
<firstName>Jane</firstName>
<lastName>Doe</lastName>
</name>
<addresses>
<address1>
<phoneNumber>5555555555</phoneNumber>
<state>Texas</state>
</address1>
</addresses>
<addresses>
<address2>
<phoneNumber>1234567890</phoneNumber>
<state>Washington</state>
</address2>
</addresses>
</details>
</root>
|
rules.txt
| PersonalInfo/name = details/name/firstName #add details/name/lastName |
| PersonalInfo/details = details/addresses[]/address1/state |
| PersonalInfo/age = #default 25 |
@AllArgsConstructor
@NoArgsConstructor
@Getter
@Setter
public class PersonalInfo {
String name;
String age;
Object details;
}If you have any questions or feedback, feel free to reach out to us via e-mail .