ModelMapper 해시코드 충돌과 오픈 소스 기여

// 중략 ...
private static final Map<Integer, Accessor> ACCESSOR_CACHE = new ConcurrentHashMap<Integer, Accessor>();

// 중략 ...
static synchronized Accessor accessorFor(Class<?> type,
                                         Method method,
                                         Configuration configuration,
                                         String name) {
    
  Integer hashCode = hashCodeFor(type, name, configuration);
  Accessor accessor = ACCESSOR_CACHE.get(hashCode);
  if (accessor == null) {
    accessor = new MethodAccessor(type, method, name);
    ACCESSOR_CACHE.put(hashCode, accessor);
  }

  return accessor;
}

// 중략 ...
private static Integer hashCodeFor(Class<?> initialType,
                                   String propertyName,
                                   Configuration configuration) {
    
  int result = 31 + initialType.hashCode();
  result = 31 * result + propertyName.hashCode();
  result = 31 * result + configuration.hashCode();
  return result;
}

// ...

@Test
public void hashCollision() {
    val key1 = new Key("aaa");
    val key2 = new Key("bbb");
    val key1HashCode = key1.hashCode();
    val key2HashCode = key2.hashCode();

    /*
     * hashCode 결과가 같은 Key 인스턴스를 키로 하여, 맵에 저장.
     * 해시 충돌 해결이 잘 되는 경우
     */
    val valid = new HashMap<Key, String>();
    valid.put(key1, "AAA");
    valid.put(key2, "BBB");
    assertEquals("AAA", valid.get(key1));
    assertEquals("BBB", valid.get(key2));

    /*
     * hashCode 결과를 키로 사용하는 경우.
     * 값은 다른데, hashCode 결과는 얼마든지 같을 수 있음.
     * 그런데도, 이걸 그대로 키로 사용하면 문제가 됨.
     */
    val invalid = new HashMap<Integer, String>();
    invalid.put(key1HashCode, "AAA");
    invalid.put(key2HashCode, "BBB");
    assertEquals("AAA", invalid.get(key1HashCode)); // 여기서 "BBB"가 반환됨
    assertEquals("BBB", invalid.get(key2HashCode));
}

@Getter
@RequiredArgsConstructor
class PropertyKey {

    private final Class<?> initialType;
    private final String propertyName;
    private final Configuration configuration;

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        PropertyKey that = (PropertyKey) o;
        return Objects.equals(initialType, that.initialType) &&
                Objects.equals(propertyName, that.propertyName) &&
                Objects.equals(configuration, that.configuration);
    }

    @Override
    public int hashCode() {
        int result = 31 + initialType.hashCode();
        result = 31 * result + propertyName.hashCode();
        result = 31 * result + configuration.hashCode();
        return result;
    }
}

class PropertyInfoRegistry {

    // 중략 ...
    private static final Map<PropertyKey, Accessor> ACCESSOR_CACHE = new ConcurrentHashMap<>();

    // 중략 ...
    static synchronized Accessor accessorFor(Class<?> type,
                                             Method method,
                                             Configuration configuration,
                                             String name) {
                                             
        final PropertyKey key = new PropertyKey(type, name, configuration);
        Accessor accessor = ACCESSOR_CACHE.get(key);
        if (accessor == null) {
            accessor = new MethodAccessor(type, method, name);
            ACCESSOR_CACHE.put(key, accessor);
        }

        return accessor;
    }

    // 중략 ...
}

public V get(Object key) {
    Node<K,V> e;
    return (e = getNode(hash(key), key)) == null ? null : e.value;
}

final Node<K,V> getNode(int hash, Object key) {
    Node<K,V>[] tab; Node<K,V> first, e; int n; K k;
    if ((tab = table) != null && (n = tab.length) > 0 &&
            (first = tab[(n - 1) & hash]) != null) {
        if (first.hash == hash && // always check first node
                ((k = first.key) == key || (key != null && key.equals(k))))
            return first;
        if ((e = first.next) != null) {
            if (first instanceof TreeNode)
                return ((TreeNode<K,V>)first).getTreeNode(hash, key);
            do {
                if (e.hash == hash &&
                        ((k = e.key) == key || (key != null && key.equals(k))))
                    return e;
            } while ((e = e.next) != null);
        }
    }
    return null;
}