Browse Prior Art Database

Dynamic Rule-based DataBean to a type-safe PropertySet Object Mapping algorithm Disclosure Number: IPCOM000198674D
Publication Date: 2010-Aug-11
Document File: 3 page(s) / 35K

Publishing Venue

The Prior Art Database


Described is an innovation for the area of mapping an internal application program interface (API) to an external API, consisting of a dynamic process for constructing a set of properties used in the external API definition for a component from a data bean used as part of the legacy internal software. The legacy internal software defines a large number of data beans, each with a large number of properties that are still changing since the software is common with another product. It is necessary to map the properties and methods of the legacy data beans to a new API definition used within the new product.

This text was extracted from a PDF file.
This is the abbreviated version, containing approximately 25% of the total text.

Page 1 of 3

Dynamic Rule-based DataBean to a type -safe PropertySet Object Mapping algorithm

The problem is that the various data beans in the legacy code have a large number of properties, and the property key names (either the key names in the software or the key values used at runtime) do not follow any consistent naming convention. Additionally, many of the data beans include accessor methods (getters primarily, but setters as well) that invoke business semantic logic within the bean which references sometimes several other properties (essentially derived property values) and sometimes make calls to the core runtime to retrieve dynamic data. Another problem is that the data bean properties are not of primitive data types, they frequently reference other data beans and complex objects.

Engineers must develop the system to:

Map these properties and accessor method values into a coherent set of properties with consistent naming conventions for use in the public API.

Avoid the introduction of methods performing business logic in the public API
Provide type-safe property set.

Avoid manually coding the mapping for the large quantities of data beans and properties

Known solutions include:

Various database-related mapping technologies that map fields between the physical database and some logical intermediate business data object (like an SDO Service Data Object). These technologies rely on deployment descriptor information to specifically associate one field to another, and the data type mappings are done according to well-understood mappings or an explicit mediation handler software. One example does not provide an automated algorithm for analyzing the two Java* classes and provide a mapping for the property names and values. [1]

Class libraries such as eclipse have methods for down casting (or coercing) objects to specific subclasses of themselves. [2] This is not the same as creating an object of a completely different object hierarchy and mapping all the internal names and data.

Rules based schema mapping mediators. [3] These references seem to use many of the same words, but the rules are used to map data sets within a completely different domain that is not related to Java and does not reflect or inspect the data objects dynamically.

Application class extensions [4]

No good, known solutions demonstrate rule-based property mapping that maps dynamically (names and values) based on Java class definitions of two similar to completely different sets of data classes, and along with intelligent caching and minimal configuration.

The solution described provides a dynamic data bean mapper that maps legacy data beans to the new public API PropertySet object. In the new API, the type-safe PropertySet

class is utilized to express all property sets. The Java parameterized class is used where the keyClass is an enumeration that specifically defines the set of allowable keys.

The data protection service management ConverterDriver class is responsible for...