¿Hay una mejor manera a los valores de la copia de un objeto sin necesidad de utilizar la reflexión?

Jazzepi:

Tratando de comprobar de manera eficiente para ver si hay una nueva copia del objeto tiene ningún campos diferentes, y si lo hacen, actualizar los locales y hacer una nota de ello. Si alguno de los campos de cambio, entonces tengo que conservar el objeto a la base de datos. No quiero hacer esa llamada si yo no tengo que, por lo tanto, el booleano.

No podía pensar en una mejor manera de hacer esto sin necesidad de utilizar la reflexión, pero no quiero utilizar la reflexión aquí debido a la falta de seguridad del compilador respaldados (tendría referencias a los nombres de campos de cuerdas), y no todos los campos son del mismo tipo (tengo algunos campos instantáneos de Java 8 de allí).

Lo que realmente queremos evitar es la contabilidad de tener que recordar a sumar o restar a / desde el método de sincronización cuando se modifican los campos. Obviamente restando no es un gran problema porque el método se romperá, pero la adición es de miedo si alguien no se acuerda actualizar el nuevo campo.

public boolean syncWithFieldsFrom(User currentUser) {
    boolean doesUserNeedUpdating = false;
    if (!StringUtils.equals(email, currentUser.email)) {
        email = currentUser.email;
        doesUserNeedUpdating = true;
    }
    if (!StringUtils.equals(firstName, currentUser.firstName)) {
        firstName = currentUser.firstName;
        doesUserNeedUpdating = true;
    }
    if (!StringUtils.equals(lastName, currentUser.lastName)) {
        lastName = currentUser.lastName;
        doesUserNeedUpdating = true;
    }
    if (!StringUtils.equals(fullName, currentUser.fullName)) {
        fullName = currentUser.fullName;
        doesUserNeedUpdating = true;
    }
    return doesUserNeedUpdating;
}

shmosel:

Esto puede ser un poco exagerado, pero se puede utilizar lambdas para extraer los campos y ejecutar un bucle en contra de ellos. Voy a asumir que tiene captadores y definidores por cuestiones de simplicidad.

private static class Field<T> {
    final Function<User, T> getter;
    final BiConsumer<User, T> setter;

    Field(Function<User, T> getter, BiConsumer<User, T> setter) {
        this.getter = getter;
        this.setter = setter;
    }

    boolean sync(User src, User dst) {
        T srcField = getter.apply(src);
        if (!Objects.equal(srcField, getter.apply(dst))) {
            setter.accept(dst, srcField);
            return true;
        }
        return false;
    }
}

private static final List<Field<?>> FIELDS = Arrays.asList(
        new Field<>(User::getEmail, User::setEmail),
        new Field<>(User::getFirstName, User::setFirstName),
        new Field<>(User::getLastName, User::setLastName),
        new Field<>(User::getFullName, User::setFullName));

public boolean syncWithFieldsFrom(User currentUser) {
    boolean updated = false;
    for (Field<?> f : FIELDS) {
        updated |= f.sync(currentUser, this);
    }
    return updated;
}