自定义数据类型的数据库映射方案

import grails.persistence.Entity

@Entity
class MyEntity {
    String code
    String name
    static constraints = {
        code(unique: true, minSize: 4, maxSize: 4)
        name(blank: false, maxSize: 255)
    }
}

class IDNumber{
    String idNumber

    Address address
    InsDate birthday
    Gender gender
    IDNumber() {}
    IDNumber(val) {       
        if (val.length() == 15) {
            val = to18IdNumber(val)
        }
        if (val.length() != 18) {
            throw new IllegalArgumentException("不是身份证格式")
        }
        this.idNumber = val
        return
    }
    def getAddress() {
        if (address) return address
        else return address = parseAddress()
    }
    def getBirthday() {
        if (birthday) return birthday
        else return birthday = parseBirth()
    }
    def getGender() {
        if (gender) return gender
        else return gender = parseGender()
    }
    def parseBirth() {
        ...
    }
}

@grails.persistence.Entity
class PersonInfo {
    String name
    IDNumber idNumber
}

class MyString extends InsDataType implements UserType{
    String value

    @Override
    void buildData(val) {
        if (val instanceof MyString) {
            value = val.value
            return
        }
        if (val == null) value = null
        else if (val instanceof String) value = val
        else if (val instanceof Number) value = String.valueOf(val)
        else value = val.toString()
        return
    }

    static MyString from(val) {
        if (val instanceof MyString) return val
        MyString data = new MyString()
        data.build(val)
        return data
    }

    public String toString() {
        return value
    }

    int[] sqlTypes() {
        return [Types.VARCHAR]
    }

    Class returnedClass() {
        return MyString
    }

    boolean equals(Object x, Object y) {
        MyString mx, my
        if (x instanceof String) mx = MyString.from(x)
        if (x instanceof MyString) mx = x

        if (y instanceof String) my = MyString.from(y)
        if (y instanceof MyString) my = y
        if (mx?.value == my?.value) return true
        return false
    }

    int hashCode(Object x) {
        return ((MyString) x)?.value?.hashCode()
    }

    Object nullSafeGet(ResultSet rs, String[] names, Object owner) {
        if (rs.wasNull()) return null
//        String stringFromDb = (String) Hibernate.STRING.nullSafeGet(rs, names[0]);
        String stringFromDb = rs.getString(names[0]);
        return MyString.from(stringFromDb)
    }

    void nullSafeSet(PreparedStatement st, Object value, int index) {
        if (value == null)
            st.setNull(index, Types.VARCHAR);
        else {
            MyString myString = (MyString) value;
            st.setString(index, myString.value);
//            Hibernate.STRING.nullSafeSet(st, myString.value, index);
        }
    }

    Object deepCopy(Object value) {
        if (!value || !((MyString) value).value) return null
        return MyString.from(value)
    }

    boolean isMutable() {
        return true
    }

    Serializable disassemble(Object value) {
        return ((MyString) value).value
    }

    Object assemble(Serializable cached, Object owner) {
        return MyString.from(cached)
    }

    Object replace(Object original, Object target, Object owner) {
        return null
    }
}

@grails.persistence.Entity
class MyEntity {
    MyString name
    static constraints = {
        name(nullable: true)
    }
    static mapping = {
        name(length: 10)
    }
}

def testSave() {
        MyEntity entity = new MyEntity(name: MyString.from("hehe"))
        TestDomain.withTransaction {
            if (entity.hasErrors() || !entity.save(flush: true)) {
                println "save error:" + entity.errors
            }
        }
    }

MyEntity entity = MyEntity.findByName(MyString.from("hehe"))

@grails.persistence.Entity
class MyEntity {
    MyChineseName name
    static constraints = {
        name(nullable: true)
    }
    static mapping = {
        name type: MyChineseName, {
            column name: "chineseFamilyName", length: 10
            column name: "chineseGivenName", length: 10
        }
    }
}

def testSave() {
        MyEntity entity = new MyEntity(name: new MyChineseName(familyName: "泛", givenName: "华"))
        TestDomain.withTransaction {
            if (entity.hasErrors() || !entity.save(flush: true)) {
                println "save error:" + entity.errors
            }
        }
        println ToStringBuilder.reflectionToString(entity)
    }

class MyChineseName implements UserType {
    String familyName
    String givenName

    String toOneString() {
        return "fn:${familyName};gn:${givenName}"
    }
    MyChineseName parseString(String str) {
        def regular = /(fn|gn):([^;]*)/
        def result = str =~ regular
        def map = [:]
        result.each { map[it[1]] = it[2] }
        return new MyChineseName(familyName: map["fn"], givenName: map["gn"])
    }
    int[] sqlTypes() {
        return [Types.VARCHAR]
    }
    Class returnedClass() {
        return MyChineseName
    }
    boolean equals(Object x, Object y) {
        if (x == y)
            return true;
        if (x == null || y == null)
            return false;
        return x.equals(y);
    }
    int hashCode(Object x) {
        return x.hashCode()
    }
    Object nullSafeGet(ResultSet rs, String[] names, Object owner) {
        return parseString(rs.getString(names[0]))
    }
    void nullSafeSet(PreparedStatement st, Object value, int index) {
        if (value == null)
            st.setNull(index, Types.VARCHAR);
        else {
            MyChineseName name = (MyChineseName) value
            st.setString(index, name.toOneString())
        }
    }
    Object deepCopy(Object value) {
        if (value == null)
            return null;
        MyChineseName name = (MyChineseName) value;
        return new MyChineseName(familyName: name.familyName, givenName: name.givenName);
    }
    boolean isMutable() {
        return false
    }
    Serializable disassemble(Object value) {
        return (Serializable) deepCopy(value);
    }
    Object assemble(Serializable cached, Object owner) {
        return (Serializable) deepCopy(cached);
    }
    Object replace(Object original, Object target, Object owner) {
        return null
    }
}

@grails.persistence.Entity
class MyComp {
    String name
    String code
}
@grails.persistence.Entity
class MyEntity {
    String keyName
    MyComp comp

    static constraints = {
        comp(nullable: true)
    }
}

class MyComp {
    String name
    String code
}
@grails.persistence.Entity
class MyEntity {
    String keyName
    MyComp comp

    static embedded = ['comp']
    static constraints = {
        comp(nullable: true)
    }
}