A Proxy-Based DTO in Java

import java.io.Serializable;

/**
 * The base interface for any proxied DTO that provides
 * reading and writing of properties. Supports a "dirty" flag.
 */
public interface TransferableData extends Serializable
{
    /** @return true when this object has been changed by calling some setter. */
    boolean dirty();
}

import java.lang.reflect.Proxy;
import java.util.Date;

public class Demo
{
    public interface DemoEntity extends TransferableData
    {
        int getNumber();
        void setNumber(int number);
        
        String getName();
        void setName(String name);
        
        Date getDate();
        void setDate(Date date);
        
        boolean getBoolean();
        void setBoolean(boolean flag);
    }
    
    public static void main(String[] args) {
        final DemoEntity dto = (DemoEntity) Proxy.newProxyInstance(
                DemoEntity.class.getClassLoader(), 
                new Class<?> [] { DemoEntity.class },
                new GenericDtoInvocationHandler(DemoEntity.class));

        assert dto.dirty() == false : "DTO is dirty after construction!";
    }
}

    /**
     * Implements InvocationHandler.
     * @param proxy the JVM-generated object this invocation-handler acts for.
     * @param method the interface-method currently called on proxy.
     * @param arguments the parameters of the interface-method call.
     * @return the return of called method, as expected in the interface implemented by proxy.
     */
    @Override
    public Object invoke(Object proxy, Method method, Object[] arguments) throws Exception {
        assert proxy.getClass().getInterfaces()[0].equals(implementedInterface) :
            "The proxy's interface "+proxy.getClass().getInterfaces()[0]+" does not match the handler's one: "+implementedInterface;

        final String methodName = method.getName();
        if (predefinedMethods.contains(methodName))
            return invokePredefinedMethod(proxy, methodName, arguments);
  
        final String fieldName = makeFieldName(method);
        
        if (isGetter(method)) {
            final Object value = fieldValueMap.get(fieldName);
            final Class<?> type = fieldTypeMap.get(fieldName);
            assert type != null : "Unknown getter: "+method.getName();

            if (value == null && type.isPrimitive())
                return convertPrimitiveNullValue(type);
   
            return value;
        }
        else {    // must be setter
            putFieldValue(fieldName, arguments[0]);
            return null;
        }
    }

    private Object invokePredefinedMethod(Object proxy, String methodName, Object [] arguments) throws Exception  {
        if (methodName.equals("equals"))
            return Objects.equals(proxy, arguments[0]);

        if (methodName.equals("hashCode"))
            return proxy.hashCode();

        if (methodName.equals("toString"))
            return toString();

        if (methodName.equals("dirty"))
            return dirty;
        
        throw new IllegalStateException("Not an internal method: "+methodName);
    }
    
    private final String makeFieldName(Method method) {
        final String methodName = method.getName();
        
        if (methodName.startsWith("is"))
            return method.getName().substring("is".length());
        
        if (methodName.startsWith("get"))
            return method.getName().substring("get".length());
        
        if (methodName.startsWith("set"))
            return method.getName().substring("set".length());
        
        throw new IllegalArgumentException("Invoked method is neither getter nor setter: "+methodName);
    }

    private boolean isGetter(Method method) {
        return
            method.getReturnType().equals(void.class) == false &&
            (method.getName().startsWith("get") || method.getName().startsWith("is"));
    }
    
    private Object convertPrimitiveNullValue(final Class<?> clazz) {
        if (clazz.equals(boolean.class))
            return Boolean.FALSE;
        if (clazz.equals(byte.class))
            return Byte.valueOf((byte) 0);
        if (clazz.equals(char.class))
            return Character.valueOf((char) 0);
        if (clazz.equals(int.class))
            return Integer.valueOf(0);
        if (clazz.equals(short.class))
            return Short.valueOf((short) 0);
        if (clazz.equals(long.class))
            return Long.valueOf((long) 0);
        if (clazz.equals(float.class))
            return Float.valueOf((float) 0);
        if (clazz.equals(double.class))
            return Double.valueOf((double) 0);
                    
        throw new IllegalArgumentException("Unknown primitive type: "+clazz);
    }
    
    private void putFieldValue(String fieldName, Object value)    {
        assert fieldName != null;
        
        final Object oldValue = fieldValueMap.get(fieldName);
        if (Objects.equals(oldValue, value) == false)
            dirty = true;
        
        fieldValueMap.put(fieldName, value);
    }

    public static void main(String[] args) {
        // test data definition
        
        final int number = 3;
        final String name = "Hello";
        final Date now = new Date();
        
        // test execution
        
        final DemoEntity dto = (DemoEntity) Proxy.newProxyInstance(
                DemoEntity.class.getClassLoader(), 
                new Class<?> [] { DemoEntity.class },
                new GenericDtoInvocationHandler(DemoEntity.class));
        
        assert dto.dirty() == false : "DTO is dirty after construction!";
        
        dto.setNumber(number);
        dto.setName(name);
        dto.setDate(now);
        // leave boolean on default
        
        // test data assertions
        
        assert dto.dirty() == true : "DTO is not dirty!";
        assert dto.getNumber() == number : "Number is "+dto.getNumber();
        assert dto.getName().equals(name) : "Name is "+dto.getName();
        assert dto.getDate().equals(now) : "Date is "+dto.getDate();
        assert dto.getBoolean() == false : "Boolean is "+dto.getBoolean();
        
        System.out.println("Test succeeded!");
    }