Introduce overriding the default type map. fixes #16

Author: gyszalai

CHANGELOG.md

@@ -1,5 +1,10 @@
 # EasyDao Changelog:
 
+## 3.2.0
+
+* Overriding of the default type map is now possible through a replacement-type.properties #16
+* Small localization fixes
+
 ## 3.1.0
 
 * Handling Oracle virtual (read-only) fields #13

README.md

@@ -190,6 +190,7 @@ Configuration example:
         <replacementTableFilename>replacement-table</replacementTableFilename>
         <replacementFieldFilename>replacement-field</replacementFieldFilename>
         <enumFieldFilename>enum-field</enumFieldFilename>
+        <replacementTypeFilename>replacement-type</replacementTypeFilename>
         <sequenceNameConvention>PREFIXED_TABLE_NAME</sequenceNameConvention>
         <generateModelToString>false</generateModelToString>
         <licenseFilename>${baesdir}/src/myLicense.txt</licenseFilename>
@@ -296,6 +297,16 @@ If you want to use Java enum for a database field, put it into the file as TABLE
 CUS_CUSTOMER_ORDER.ORDER_MODE = hu.vanio.myapp.model.OrderMode
 ```
 
+## replacementTypeFilename
+
+Map file name for databse types that should not be mapped by the default type map. Resource bundle file in src/main/resources without file extension, e.g: replacement-type
+
+If you want to use a custom type instead of the built in one for one or a set of database types, put it into the file as <type name regex pattern> = <fully qualified classname of the type>, <fully qualified classname of the type converter>, e.g:
+
+```
+date.* = hu.vanio.myapp.model.MyCustomDateType, hu.vanio.myapp.converter.MyCustomDateTypeConverter
+```
+
 ## sequenceNameConvention
 Defines database sequence naming convention with **SEQ** string, optional, default value is SUFFIXED_TABLE_NAME.
 
@@ -417,6 +428,85 @@ public enum MyFieldIrregularEnum {
 }
 ```
 
+# Using custom types
+
+EasyDAO maps database types to the most sensible Java types, but sometimes it's not appropriate. In these cases you can
+override the default type mapping via a properties file. Overriding it consists of the following:
+
+  * implementation of the custom type class, see the example below.
+  * implementation of a type converter class that converts the custom type to a type that is recognized by the database driver and/or spring JDBC, see the example below
+  * registering the custom type in the replacement-type.properties and specifying the file name in the maven plugin configuration
+
+
+Let's assume we have an Oracle database and the default DATE -> java.sql.Timestamp mapping is not appropriate for some reason.
+In this case we need to implement the MyCustomDateType class and the corresponding MyCustomDateTypeConverter as seen below.
+In addition you have to register the new custom type in the replacement type map file (replacement-type.properties):
+```
+date.* = hu.vanio.myapp.model.MyCustomDateType, hu.vanio.myapp.converter.MyCustomDateTypeConverter
+```
+> Note the `date.*` expression on the left hand side. It means that *any* field with a type that starts with the string `date` will be mapped to the given custom type.
+
+### Example custom type class
+
+
+```java
+package hu.vanio.myapp.model;
+
+public class MyCustomDateType {
+
+    // properties...
+
+    // methods...
+
+    /** Constructor */
+    public MyCustomDateType(String) {
+        // ...
+    }
+
+    public java.sql.Date toSqlDate() {
+        java.sql.Date dateValue = ....
+        return dateValue;
+    }
+
+}
+```
+
+### Example type converter implementation
+
+Type converters are convention based so it's not necessary to extend any base class or implement any interface.
+The only requirement is to implement two public static methods: extractValue and convertValue.
+
+> WARNING: This class must be thread safe, so don't use any instance fields!
+
+```java
+package hu.vanio.myapp.converter;
+
+import hu.vanio.myapp.model.MyCustomDateType;
+
+/** Converter class. */
+public class MyCustomDateTypeConverter {
+
+    /**
+     * Extracts the value of the field with the specified name as a custom type from the specified resultset.
+     * is of type DATE you have to return either java.util.Date, java.sql.Date or java.sql.Timestamp.
+     */
+    static public MyCustomDateType extractValue(ResultSet rs, String fieldName) throws SQLException {
+        String strValue = rs.getString(fieldName);
+        return new MyCustomDateType(strValue);
+    }
+
+    /**
+     * Maps the custom Java type to a Java type that can be written to the database field. i.e. if the database field
+     * is of type DATE you have to return either java.util.Date, java.sql.Date or java.sql.Timestamp.
+     */
+    static public Date convertValue(MyCustomDateType value) {
+        // Additional processing may come here
+        return value.toSqlDate();
+    }
+
+}
+```
+
 > If you just want **to use** this easy model and dao generator, then use the maven plugin at https://github.com/vanioinformatika/easydao-maven-plugin and a small dependeny in your project: https://github.com/vanioinformatika/easydao-core
 
 

easydao-maven-plugin/src/main/java/hu/vanio/easydao/EngineConfiguration.java

@@ -128,12 +128,18 @@ static public enum SEQUENCE_NAME_CONVENTION {
      *  You can disable Java source generation for a certain field by putting the field name in the list with no Java field name.
      *  e.g.: USER.FNAME = */
     private final String replacementFieldFilename;
-    
+        
     /** Map of Java enum names and database field names. Names included in this list will be generated with the specified enum type.
      * The key is the table name and field name, the value is the fully qualified name of the enum.
      *  e.g.: USER.STATE = hu.vanio.myapp.model.UserState */
     private final String enumFieldFilename;
 
+    /** Filename for the replacement map of database types and Java types. Types not included in this map will be generated 
+     * according to the default type map.
+     * e.g.: date = java.util.Date -> java.util.Date instead of java.sql.Timestamp
+     */
+    private final String replacementTypeMapFilename;
+    
     /** License file name (its content will be inserted into all generated Java source files) */
     private final String licenseFilename;
     /** License text */
@@ -149,6 +155,12 @@ static public enum SEQUENCE_NAME_CONVENTION {
      *  e.g.: USER.STATE = hu.vanio.myapp.model.UserState */
     private Map<String, String> enumFieldMap = new HashMap<>();
 
+    /** Replacement map of database types and Java types. Types not included in this map will be generated according 
+     * to the default type map.
+     * e.g.: date = java.util.Date -> java.util.Date instead of java.sql.Timestamp
+     */
+    private Map<String, String> replacementTypeMap = new HashMap<>();
+    
     /**
      * Engine configuration init.
      * @param databaseName database name: generated Dao DataSource name in @Qualifier annotation
@@ -177,6 +189,9 @@ static public enum SEQUENCE_NAME_CONVENTION {
      * @param enumFieldFilename Map of Java enum names and database field names. Names included in this list will be generated with the specified enum type.
      *                          The key is the table name and field name, the value is the fully qualified name of the enum.
      *                          e.g.: USER.STATE = hu.vanio.myapp.model.UserState
+     * @param replacementTypeMapFilename Filename for the replacement map of database types and Java types. Types not included in 
+     *                                    this list will be generated according to the default type map.
+     *                                    e.g.: date = java.util.Date -> java.util.Date instead of java.sql.Timestamp
      * @param licenseFilename License file name (its content will be inserted into all generated Java source files)
      * @param tableNameIncludes
      * @param encoding Encoding of the generated source files
@@ -190,7 +205,7 @@ public EngineConfiguration(
             String packageOfJavaDao, String daoSuffix,
             boolean generateModelToString,
             SEQUENCE_NAME_CONVENTION sequenceNameConvention,
-            String replacementTableFilename, String replacementFieldFilename, String enumFieldFilename,
+            String replacementTableFilename, String replacementFieldFilename, String enumFieldFilename, String replacementTypeMapFilename,
             String licenseFilename,
             List<String> tableNameIncludes,
             String encoding,
@@ -214,6 +229,7 @@ public EngineConfiguration(
         this.replacementTableFilename = replacementTableFilename;
         this.replacementFieldFilename = replacementFieldFilename;
         this.enumFieldFilename = enumFieldFilename;
+        this.replacementTypeMapFilename = replacementTypeMapFilename;
         this.licenseFilename = licenseFilename;
         this.tableNameIncludes = tableNameIncludes;
         this.encoding = encoding;
@@ -231,6 +247,9 @@ public EngineConfiguration(
         if (this.enumFieldFilename != null) {
             loadResourceBundleToMap(this.enumFieldFilename, this.enumFieldMap);
         }
+        if (this.replacementTypeMapFilename != null) {
+            loadResourceBundleToMap(this.replacementTypeMapFilename, this.replacementTypeMap);
+        }
 
         if (this.licenseFilename != null) {
             this.licenseText = readFile(this.licenseFilename, Charset.forName(this.encoding));
@@ -278,6 +297,7 @@ static public EngineConfiguration createFromProperties(Properties props) throws
                 props.getProperty("replacementTableFilename"),
                 props.getProperty("replacementFieldFilename"),
                 props.getProperty("enumFieldFilename"),
+                props.getProperty("replacementTypeMapFilename"),
                 props.getProperty("licenseFilename"),
                 getPropertyAsList(props, "tableNameIncludes"),
                 props.getProperty("encoding"),
@@ -534,6 +554,16 @@ public String getEnumFieldFilename() {
         return enumFieldFilename;
     }
 
+    /**
+     * Filename for the replacement map of database types and Java types. Types not included in this map will be generated
+     * according to the default type map.
+     * e.g.: date = java.util.Date -> java.util.Date instead of java.sql.Timestamp
+     * @return the replacementTypeMapFilename
+     */
+    public String getReplacementTypeMapFilename() {
+        return replacementTypeMapFilename;
+    }
+
     /**
      * License file name (its content will be inserted into all generated Java source files)
      * @return the licenseFilename
@@ -600,6 +630,26 @@ public void setEnumFieldMap(Map<String, String> enumFieldMap) {
         this.enumFieldMap = enumFieldMap;
     }
 
+    /**
+     * Replacement map of database types and Java types. Types not included in this map will be generated according
+     * to the default type map.
+     * e.g.: date = java.util.Date -> java.util.Date instead of java.sql.Timestamp
+     * @return the typeMap
+     */
+    public Map<String, String> getReplacementTypeMap() {
+        return replacementTypeMap;
+    }
+
+    /**
+     * Replacement map of database types and Java types. Types not included in this map will be generated according
+     * to the default type map.
+     * e.g.: date = java.util.Date -> java.util.Date instead of java.sql.Timestamp
+     * @param typeMap the typeMap to set
+     */
+    public void setTypeMap(Map<String, String> replacementTypeMap) {
+        this.replacementTypeMap = replacementTypeMap;
+    }
+
     /**
      * The locale for generating comments
      * @return the locale
@@ -644,10 +694,14 @@ public String toString() {
                 + ", generateModelToString=" + generateModelToString 
                 + ", replacementTableFilename=" + replacementTableFilename 
                 + ", replacementFieldFilename=" + replacementFieldFilename 
+                + ", enumFieldFilename=" + enumFieldFilename 
+                + ", replacementTypeMapFilename=" + replacementTypeMapFilename 
                 + ", licenseFilename=" + licenseFilename 
                 + ", licenseText=" + licenseText 
                 + ", replacementTableMap=" + replacementTableMap 
                 + ", replacementFieldMap=" + replacementFieldMap 
+                + ", enumFieldMap=" + enumFieldMap 
+                + ", replacementTypeMap=" + replacementTypeMap 
                 + ", locale=" + locale 
                 + ", tableNameIncludes=" + tableNameIncludes
                 + ", encoding=" + encoding

easydao-maven-plugin/src/main/java/hu/vanio/easydao/model/Field.java

@@ -51,6 +51,11 @@ public class Field {
     private String javaName;
     /** The type of this field in Java code */
     private String javaType;
+    
+    /** Indicates whether this field has a custom type */
+    private boolean customType;
+    /** The type converter for this field (optional) */
+    private String typeConverterClass;
 
     /**
      * Constructor
@@ -73,6 +78,8 @@ public Field(boolean primaryKey,
             boolean array,
             boolean enumerated,
             boolean irregularEnum,
+            boolean customType,
+            String typeConverterClass,
             String dbName,
             String dbType,
             String comment,
@@ -84,6 +91,8 @@ public Field(boolean primaryKey,
         this.array = array;
         this.enumerated = enumerated;
         this.irregularEnum = irregularEnum;
+        this.customType = customType;
+        this.typeConverterClass = typeConverterClass;
         this.dbName = dbName;
         this.dbType = dbType;
         this.comment = comment;
@@ -93,9 +102,21 @@ public Field(boolean primaryKey,
 
     @Override
     public String toString() {
-        return "Field{" + "dbName: \"" + dbName + "\", javaName: \"" + javaName + "\", dbType: \"" + dbType + "\", javaType: \"" + getJavaType()
-                + "\", primaryKey: " + primaryKey + ", nullable: " + nullable + ", array: " + array + ", enumerated: " + enumerated
-                + ", comment: \"" + comment + "\"}";
+        return "Field{" + 
+                "dbName: " + dbName + 
+                ", javaName: " + javaName + 
+                ", dbType: " + dbType + 
+                ", javaType: " + getJavaType() +
+                ", primaryKey: " + primaryKey + 
+                ", nullable: " + nullable + 
+                ", array: " + array + 
+                ", enumerated: " + enumerated +
+                ", irregularEnum: " + irregularEnum +
+                ", virtual: " + virtual +
+                ", customType: " + customType +
+                ", typeConverterClass: " + typeConverterClass +
+                ", comment: " + comment +
+                "\"}";
     }
 
     /**
@@ -291,6 +312,38 @@ public void setJavaType(String javaType) {
         this.javaType = javaType;
     }
 
+    /**
+     * Indicates whether this field has a custom type
+     * @return the customType
+     */
+    public boolean isCustomType() {
+        return customType;
+    }
+
+    /**
+     * Indicates whether this field has a custom type
+     * @param customType the customType to set
+     */
+    public void setCustomType(boolean customType) {
+        this.customType = customType;
+    }
+
+    /**
+     * The type converter for this field (optional)
+     * @return the typeConverterClass
+     */
+    public String getTypeConverterClass() {
+        return typeConverterClass;
+    }
+
+    /**
+     * The type converter for this field (optional)
+     * @param typeConverterClass the typeConverterClass to set
+     */
+    public void setTypeConverterClass(String typeConverterClass) {
+        this.typeConverterClass = typeConverterClass;
+    }
+
     /**
      * indicates whether the value of this field sould be read from the resultset as a String
      * @return true if this field should be read from the resultset as a String
@@ -311,7 +364,8 @@ public boolean isReadAsString() {
                 && javaClass != java.sql.Clob.class
                 && javaClass != java.sql.Blob.class
                 && !javaClass.isArray()
-                && !this.enumerated) {
+                && !this.enumerated
+                && !this.customType) {
             retVal = true;
         }
         return retVal;