News from Jun 22, 2008

try {
  // save/update operation here
} catch (final DataIntegrityViolationException e) {
  // tell the user than something happened
}

@Documented
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface UniqueConstraints {

  UniqueConstraint[] value();

}

@Documented
@Target(ElementType.PARAMETER)
@Retention(RetentionPolicy.RUNTIME)
public @interface UniqueConstraint {

  /**
   * A set of class fields representing a unique constraint (to allow
   * multi-field constraints)
   */
  String[] value();

  /**
   * I18N message key on constraint failure (a default one will be constructed
   * on the fly if not specified here)
   */
  String key() default "";

}

public interface UniquenessValidationService {

  void validate(Object target) throws UniquenessViolationException;

}

public final class UniquenessValidationServiceImpl implements UniquenessValidationService {

  private static final char I18N_KEY_SEPARATOR = '.';

  private final SessionFactory sessionFactory;

  public UniquenessValidationServiceImpl(final SessionFactory sessionFactory) {
    this.sessionFactory = sessionFactory;
  }

  @Override
  public void validate(final Object target) throws UniquenessViolationException {
    final Class<?> targetClass = target.getClass();

    final UniqueConstraints constraints = targetClass
        .getAnnotation(UniqueConstraints.class);

    if (constraints == null) {
      return;
    }

    final List<String> messageKeys = new ArrayList<String>();
    final List<String> fallbackMessages = new ArrayList<String>();

    for (final UniqueConstraint constraint : constraints.value()) {
      final Criteria c = createCriteria(targetClass);
      final String[] fields = constraint.value();

      for (final String field : fields) {
        // There's no need to show the ReflectionUtils.getValue(Object, String)'s
        // implementation, it's easy and you can figure it out yourself, I know :)
        final Object value = ReflectionUtils.getValue(target, field);
        c.add(Restrictions.eq(field, value));
      }

      final Object uniqueResult = c.uniqueResult();

      if (uniqueResult != null && uniqueResult != target) {
        messageKeys.add(constructI18nKey(targetClass, constraint));
        fallbackMessages.add(constructFallbackMessage(constraint));
      }
    }

    if (messageKeys.size() > 0) {
      final String[] keysArray = messageKeys.toArray(new String[0]);
      final String[] fallbackMessagesArray = fallbackMessages
          .toArray(new String[0]);
      throw new UniquenessViolationException(keysArray, fallbackMessagesArray);
    }
  }

  private static String constructI18nKey(final Class<?> targetClass,
      final UniqueConstraint constraint) {
    if (StringUtils.isNotBlank(constraint.key())) {
      return constraint.key();
    }

    final String[] fields = constraint.value();
    final StringBuilder buf = new StringBuilder(fields.length * 7);
    buf.append("validator").append(I18N_KEY_SEPARATOR).append(
        targetClass.getSimpleName());

    for (final String field : fields) {
      buf.append(I18N_KEY_SEPARATOR).append(field);
    }

    return buf.toString();
  }

  private static String constructFallbackMessage(
      final UniqueConstraint constraint) {
    final String[] fields = constraint.value();

    if (fields.length == 1) {
      return fields[0] + " must be a unique value";
    }

    return StringUtils.join(fields, ", ") + " must be a unique tuple";
  }

  private Session getSession() {
    return sessionFactory.getCurrentSession();
  }

  private Criteria createCriteria(final Class<?> targetClass) {
    return getSession().createCriteria(targetClass);
  }

}

public final class UniquenessViolationException extends CheckedSystemException {

  private static final String LENGTH_ASSERTION_ERROR = 
    "must supply an equal number of constraint violation message keys and fallback messages";

  private static final long serialVersionUID = 1L;

  private final String[] messageKeys;

  private final String[] fallbackMessages;

  public UniquenessViolationException(final String[] messageKeys,
      final String[] fallbackMessages) {
    final boolean equalLength = messageKeys.length == fallbackMessages.length;

    Assert.isTrue(equalLength, LENGTH_ASSERTION_ERROR);

    this.messageKeys = messageKeys;
    this.fallbackMessages = fallbackMessages;
  }

  public String[] getMessageKeys() {
    return messageKeys;
  }

  public String[] getFallbackMessages() {
    return fallbackMessages;
  }

}

public final class UniquenessValidator implements Validator {

  private final UniquenessValidationService validationService;

  public UniquenessValidator(
      final UniquenessValidationService validationService) {
    this.validationService = validationService;
  }

  @Override
  @SuppressWarnings("unchecked")
  public boolean supports(final Class clazz) {
    // calling to Object.class.isAssignableFrom(clazz) would be fun :)
    return true;
  }

  @Override
  public void validate(final Object target, final Errors errors) {
    try {
      validationService.validate(target);
    } catch (final UniquenessViolationException e) {
      final String[] constraintViolationMessages = e.getMessageKeys();
      final String[] fallbackMessages = e.getFallbackMessages();

      for (int i = 0; i < constraintViolationMessages.length; i++) {
        errors.reject(constraintViolationMessages[i], fallbackMessages[i]);
      }
    }
  }

}

@Entity
@UniqueConstraints({ @UniqueConstraint({ "group", "name" }) })
public final class ExtraSpecialDomainObject {

  // dunno what this group is about, but bear with me
  private Group group;

  private String name;

  public Group getGroup() {
    return group;
  }

  public void setGroup(final Group group) {
    this.group = group;
  }

  public String getName() {
    return name;
  }

  public void setName(final String name) {
    this.name = name;
  }

}