Metadata Mapping Pattern


Java/Java EE Tutorials Java 8 Tutorial Java Tutorial for Beginners JSP Tutorial Java Collections Tutorial JDBC 4.2 Tutorial Data Structures Tutorial
Java API Guides Google GSON Tutorial Java String API Guide Java XML Tutorial Maven Tutorial
Java Lang Package Tutorial Java SQL Package Tutorial Java Util Package Tutorial Java IO Package Tutorial Java Time Package Tutorial Java Lang Reflect Package
Java Best Practices OOPS Tutorial SOLID Principles J2EE Best Practices Java Utility Classes Free Resources
JUnit 5 Tutorial JUnit 4 Tutorial JUnit Examples
Spring Boot 2 Tutorial Spring Boot Developer Guide Spring Boot Annotations Spring Boot Free Projects
Spring Core 5 Tutorial Spring MVC 5 Tutorial Spring Data JPA Tutorial Spring's Form Tags Tutorial
Java Persistence API Hibernate 5 Tutorial Hibernate Developer Guide Spring Hibernate Tutorials
This pattern belongs to Object-Relational Metadata Mapping Patterns Catalog and this Catalog belongs to Patterns of Enterprise Application Architecture.

Intent

Holds details of object-relational mapping in the metadata.

Real World example

Hibernate ORM Tool uses Metadata Mapping Pattern to specify the mapping between classes and tables either using XML or annotations in code.
ORM tools require metadata to specify the mapping between classes and tables, properties and columns, associations and foreign keys, Java types and SQL types, and so on. This information is called the object/relational mapping metadata. 
Metadata is data about data, and mapping metadata defines and governs the transformation between the different type systems and relationship representations in object-oriented and SQL systems.
Example of Hibernate ORM metadata mapping using XML.
<?xml version = "1.0" encoding = "utf-8"?>
<!DOCTYPE hibernate-mapping PUBLIC 
"-//Hibernate/Hibernate Mapping DTD//EN"
"http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd"> 

<hibernate-mapping>
   <class name = "Employee" table = "EMPLOYEE">
      
      <meta attribute = "class-description">
         This class contains the employee detail. 
      </meta>
      
      <id name = "id" type = "int" column = "id">
         <generator class="native"/>
      </id>
      
      <property name = "firstName" column = "first_name" type = "string"/>
      <property name = "lastName" column = "last_name" type = "string"/>
      <property name = "salary" column = "salary" type = "int"/>
      
   </class>
</hibernate-mapping>
Much of the code that deals with object-relational mapping describes how fields in the database correspond to fields in in-memory objects. The resulting code tends to be tedious and repetitive to write. A Metadata Mapping allows developers to define the mappings in a simple tabular form, which can then be processed by generic code to carry out the details of reading, inserting, and updating the data.

How It Works

The biggest decision in using Metadata Mapping is how the information in the metadata manifests itself in terms of running code. There are two main routes to take: code generation and reflective programming.
With code generation, you write a program whose input is the metadata and whose output is the source code of classes that do the mapping. These classes look as though they’re hand-written, but they’re entirely generated during the build process, usually just prior to compilation. The resulting mapper classes are deployed with the server code.
A reflective program may ask an object for a method named,setName and then run an invoke method on the setName method passing in the appropriate argument. By treating methods (and fields) as data the reflective program can read in field and method names from a metadata file and use them to carry out the mapping.

When to Use It

  • Metadata Mapping can greatly reduce the amount of work needed to handle database mapping. However, some setup work is required to prepare the Metadata Mapping framework. 
  • The extra work of hand-coding can be greatly reduced by creating a good Layer Supertype that handles all the common behavior.

Source code

To demonstrate this pattern I am going to use Hibernate ORM Framework strategy.
An Object/relational mappings are usually defined in an XML document or annotations in Hibernate. This mapping file instructs Hibernate — how to map the defined class or classes to the database tables?
Step 1: Let's create Employee POJO class whose objects will persist in the table employee.
public class Employee {
   private int id;
   private String firstName; 
   private String lastName;   
   private int salary;  

   public Employee() {}
   
   public Employee(String fname, String lname, int salary) {
      this.firstName = fname;
      this.lastName = lname;
      this.salary = salary;
   }
   
   public int getId() {
      return id;
   }
   
   public void setId( int id ) {
      this.id = id;
   }
   
   public String getFirstName() {
      return firstName;
   }
   
   public void setFirstName( String first_name ) {
      this.firstName = first_name;
   }
   
   public String getLastName() {
      return lastName;
   }
   
   public void setLastName( String last_name ) {
      this.lastName = last_name;
   }
   
   public int getSalary() {
      return salary;
   }
   
   public void setSalary( int salary ) {
      this.salary = salary;
   }
}
Step 2: Let's create a corresponding database table named the employee.
create table EMPLOYEE (
   id INT NOT NULL auto_increment,
   first_name VARCHAR(20) default NULL,
   last_name  VARCHAR(20) default NULL,
   salary     INT  default NULL,
   PRIMARY KEY (id)
);
Based on the two above entities, we can define following mapping file, which instructs Hibernate how to map the defined class or classes to the database tables.
<?xml version = "1.0" encoding = "utf-8"?>
<!DOCTYPE hibernate-mapping PUBLIC 
"-//Hibernate/Hibernate Mapping DTD//EN"
"http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd"> 

<hibernate-mapping>
   <class name = "Employee" table = "EMPLOYEE">
      
      <meta attribute = "class-description">
         This class contains the employee detail. 
      </meta>
      
      <id name = "id" type = "int" column = "id">
         <generator class="native"/>
      </id>
      
      <property name = "firstName" column = "first_name" type = "string"/>
      <property name = "lastName" column = "last_name" type = "string"/>
      <property name = "salary" column = "salary" type = "int"/>
      
   </class>
</hibernate-mapping>

References


Comments

Post a Comment