优化枚举值获取.

https://github.com/baomidou/mybatis-plus/issues/3272

mybatis-plus-core/src/main/java/com/baomidou/mybatisplus/core/handlers/MybatisEnumTypeHandler.java

@@ -19,6 +19,7 @@ import com.baomidou.mybatisplus.annotation.EnumValue;
 import com.baomidou.mybatisplus.annotation.IEnum;
 import com.baomidou.mybatisplus.core.toolkit.CollectionUtils;
 import com.baomidou.mybatisplus.core.toolkit.ExceptionUtils;
+import com.baomidou.mybatisplus.core.toolkit.ReflectionKit;
 import com.baomidou.mybatisplus.core.toolkit.StringUtils;
 import org.apache.ibatis.reflection.DefaultReflectorFactory;
 import org.apache.ibatis.reflection.MetaClass;
@@ -46,26 +47,27 @@ import java.util.concurrent.ConcurrentHashMap;
  * @since 2017-10-11
  */
 public class MybatisEnumTypeHandler<E extends Enum<E>> extends BaseTypeHandler<E> {
-
+    
     private static final Map<String, String> TABLE_METHOD_OF_ENUM_TYPES = new ConcurrentHashMap<>();
     private static final ReflectorFactory REFLECTOR_FACTORY = new DefaultReflectorFactory();
-    private final Class<E> type;
-
-    private final Invoker invoker;
-
-    public MybatisEnumTypeHandler(Class<E> type) {
-        if (type == null) {
+    private final Class<E> enumClassType;
+    private final Class<?> propertyType;
+    private final Invoker getInvoker;
+    
+    public MybatisEnumTypeHandler(Class<E> enumClassType) {
+        if (enumClassType == null) {
             throw new IllegalArgumentException("Type argument cannot be null");
         }
-        this.type = type;
-        MetaClass metaClass = MetaClass.forClass(type, REFLECTOR_FACTORY);
+        this.enumClassType = enumClassType;
+        MetaClass metaClass = MetaClass.forClass(enumClassType, REFLECTOR_FACTORY);
         String name = "value";
-        if (!IEnum.class.isAssignableFrom(type)) {
-            name = findEnumValueFieldName(this.type).orElseThrow(() -> new IllegalArgumentException(String.format("Could not find @EnumValue in Class: %s.", this.type.getName())));
+        if (!IEnum.class.isAssignableFrom(enumClassType)) {
+            name = findEnumValueFieldName(this.enumClassType).orElseThrow(() -> new IllegalArgumentException(String.format("Could not find @EnumValue in Class: %s.", this.enumClassType.getName())));
         }
-        this.invoker = metaClass.getGetInvoker(name);
+        this.propertyType = ReflectionKit.resolvePrimitiveIfNecessary(metaClass.getGetterType(name));
+        this.getInvoker = metaClass.getGetInvoker(name);
     }
-
+    
     /**
      * 查找标记EnumValue字段
      *
@@ -77,7 +79,7 @@ public class MybatisEnumTypeHandler<E extends Enum<E>> extends BaseTypeHandler<E
     public static Optional<Field> dealEnumType(Class<?> clazz) {
         return clazz.isEnum() ? Arrays.stream(clazz.getDeclaredFields()).filter(field -> field.isAnnotationPresent(EnumValue.class)).findFirst() : Optional.empty();
     }
-
+    
     /**
      * 查找标记标记EnumValue字段
      *
@@ -89,15 +91,17 @@ public class MybatisEnumTypeHandler<E extends Enum<E>> extends BaseTypeHandler<E
         if (clazz != null && clazz.isEnum()) {
             String className = clazz.getName();
             return Optional.ofNullable(CollectionUtils.computeIfAbsent(TABLE_METHOD_OF_ENUM_TYPES, className, key -> {
-                Optional<Field> optional = Arrays.stream(clazz.getDeclaredFields())
-                    .filter(field -> field.isAnnotationPresent(EnumValue.class))
-                    .findFirst();
-                return optional.map(Field::getName).orElse(null);
+                Optional<Field> fieldOptional = findEnumValueAnnotationField(clazz);
+                return fieldOptional.map(Field::getName).orElse(null);
             }));
         }
         return Optional.empty();
     }
-
+    
+    private static Optional<Field> findEnumValueAnnotationField(Class<?> clazz) {
+        return Arrays.stream(clazz.getDeclaredFields()).filter(field -> field.isAnnotationPresent(EnumValue.class)).findFirst();
+    }
+    
     /**
      * 判断是否为MP枚举处理
      *
@@ -108,7 +112,7 @@ public class MybatisEnumTypeHandler<E extends Enum<E>> extends BaseTypeHandler<E
     public static boolean isMpEnums(Class<?> clazz) {
         return clazz != null && clazz.isEnum() && (IEnum.class.isAssignableFrom(clazz) || findEnumValueFieldName(clazz).isPresent());
     }
-
+    
     @SuppressWarnings("Duplicates")
     @Override
     public void setNonNullParameter(PreparedStatement ps, int i, E parameter, JdbcType jdbcType)
@@ -120,36 +124,39 @@ public class MybatisEnumTypeHandler<E extends Enum<E>> extends BaseTypeHandler<E
             ps.setObject(i, this.getValue(parameter), jdbcType.TYPE_CODE);
         }
     }
-
+    
     @Override
     public E getNullableResult(ResultSet rs, String columnName) throws SQLException {
-        if (null == rs.getObject(columnName) && rs.wasNull()) {
+        Object value = rs.getObject(columnName, this.propertyType);
+        if (null == value && rs.wasNull()) {
             return null;
         }
-        return this.valueOf(this.type, rs.getObject(columnName));
+        return this.valueOf(value);
     }
-
+    
     @Override
     public E getNullableResult(ResultSet rs, int columnIndex) throws SQLException {
-        if (null == rs.getObject(columnIndex) && rs.wasNull()) {
+        Object value = rs.getObject(columnIndex, this.propertyType);
+        if (null == value && rs.wasNull()) {
             return null;
         }
-        return this.valueOf(this.type, rs.getObject(columnIndex));
+        return this.valueOf(value);
     }
-
+    
     @Override
     public E getNullableResult(CallableStatement cs, int columnIndex) throws SQLException {
-        if (null == cs.getObject(columnIndex) && cs.wasNull()) {
+        Object value = cs.getObject(columnIndex, this.propertyType);
+        if (null == value && cs.wasNull()) {
             return null;
         }
-        return this.valueOf(this.type, cs.getObject(columnIndex));
+        return this.valueOf(value);
     }
-
-    private E valueOf(Class<E> enumClass, Object value) {
-        E[] es = enumClass.getEnumConstants();
+    
+    private E valueOf(Object value) {
+        E[] es = this.enumClassType.getEnumConstants();
         return Arrays.stream(es).filter((e) -> equalsValue(value, getValue(e))).findAny().orElse(null);
     }
-
+    
     /**
      * 值比较
      *
@@ -167,10 +174,10 @@ public class MybatisEnumTypeHandler<E extends Enum<E>> extends BaseTypeHandler<E
         }
         return Objects.equals(sValue, tValue);
     }
-
+    
     private Object getValue(Object object) {
         try {
-            return invoker.invoke(object, new Object[0]);
+            return this.getInvoker.invoke(object, new Object[0]);
         } catch (ReflectiveOperationException e) {
             throw ExceptionUtils.mpe(e);
         }

mybatis-plus-core/src/main/java/com/baomidou/mybatisplus/core/toolkit/ReflectionKit.java

@@ -45,6 +45,8 @@ public final class ReflectionKit {
     private static final Map<Class<?>, List<Field>> CLASS_FIELD_CACHE = new ConcurrentHashMap<>();
 
     private static final Map<Class<?>, Class<?>> PRIMITIVE_WRAPPER_TYPE_MAP = new IdentityHashMap<>(8);
+    
+    private static final Map<Class<?>, Class<?>> PRIMITIVE_TYPE_TO_WRAPPER_MAP = new IdentityHashMap<>(8);
 
     static {
         PRIMITIVE_WRAPPER_TYPE_MAP.put(Boolean.class, boolean.class);
@@ -55,6 +57,9 @@ public final class ReflectionKit {
         PRIMITIVE_WRAPPER_TYPE_MAP.put(Integer.class, int.class);
         PRIMITIVE_WRAPPER_TYPE_MAP.put(Long.class, long.class);
         PRIMITIVE_WRAPPER_TYPE_MAP.put(Short.class, short.class);
+        for (Map.Entry<Class<?>, Class<?>> entry : PRIMITIVE_WRAPPER_TYPE_MAP.entrySet()) {
+            PRIMITIVE_TYPE_TO_WRAPPER_MAP.put(entry.getValue(), entry.getKey());
+        }
     }
 
     /**
@@ -230,5 +235,8 @@ public final class ReflectionKit {
         Assert.notNull(clazz, "Class must not be null");
         return (clazz.isPrimitive() || PRIMITIVE_WRAPPER_TYPE_MAP.containsKey(clazz));
     }
-
+    
+    public static Class<?> resolvePrimitiveIfNecessary(Class<?> clazz) {
+        return (clazz.isPrimitive() && clazz != void.class ? PRIMITIVE_TYPE_TO_WRAPPER_MAP.get(clazz) : clazz);
+    }
 }

mybatis-plus-extension/src/main/java/com/baomidou/mybatisplus/extension/handlers/MybatisEnumTypeHandler.java

@@ -15,28 +15,8 @@
  */
 package com.baomidou.mybatisplus.extension.handlers;
 
-import com.baomidou.mybatisplus.annotation.EnumValue;
-import com.baomidou.mybatisplus.annotation.IEnum;
-import com.baomidou.mybatisplus.core.toolkit.CollectionUtils;
-import com.baomidou.mybatisplus.core.toolkit.ExceptionUtils;
-import org.apache.ibatis.reflection.DefaultReflectorFactory;
-import org.apache.ibatis.reflection.MetaClass;
-import org.apache.ibatis.reflection.ReflectorFactory;
-import org.apache.ibatis.reflection.invoker.Invoker;
-import org.apache.ibatis.type.BaseTypeHandler;
-import org.apache.ibatis.type.JdbcType;
-
 import java.lang.reflect.Field;
-import java.math.BigDecimal;
-import java.sql.CallableStatement;
-import java.sql.PreparedStatement;
-import java.sql.ResultSet;
-import java.sql.SQLException;
-import java.util.Arrays;
-import java.util.Map;
-import java.util.Objects;
 import java.util.Optional;
-import java.util.concurrent.ConcurrentHashMap;
 
 /**
  * 自定义枚举属性转换器
@@ -46,63 +26,10 @@ import java.util.concurrent.ConcurrentHashMap;
  * @deprecated 3.4.0 @2020-06-23 use {@link com.baomidou.mybatisplus.core.handlers.MybatisEnumTypeHandler}
  */
 @Deprecated
-public class MybatisEnumTypeHandler<E extends Enum<?>> extends BaseTypeHandler<Enum<?>> {
-
-    private static ReflectorFactory reflectorFactory = new DefaultReflectorFactory();
-
-    private static final Map<String, String> TABLE_METHOD_OF_ENUM_TYPES = new ConcurrentHashMap<>();
-
-    private final Class<E> type;
-
-    private Invoker invoker;
+public class MybatisEnumTypeHandler<E extends Enum<E>> extends com.baomidou.mybatisplus.core.handlers.MybatisEnumTypeHandler<E> {
 
     public MybatisEnumTypeHandler(Class<E> type) {
-        if (type == null) {
-            throw new IllegalArgumentException("Type argument cannot be null");
-        }
-        this.type = type;
-        MetaClass metaClass = MetaClass.forClass(type, reflectorFactory);
-        String name = "value";
-        if (!IEnum.class.isAssignableFrom(type)) {
-            name = findEnumValueFieldName(this.type).orElseThrow(() -> new IllegalArgumentException(String.format("Could not find @EnumValue in Class: %s.", this.type.getName())));
-        }
-        this.invoker = metaClass.getGetInvoker(name);
-    }
-
-    @SuppressWarnings("Duplicates")
-    @Override
-    public void setNonNullParameter(PreparedStatement ps, int i, Enum<?> parameter, JdbcType jdbcType)
-        throws SQLException {
-        if (jdbcType == null) {
-            ps.setObject(i, this.getValue(parameter));
-        } else {
-            // see r3589
-            ps.setObject(i, this.getValue(parameter), jdbcType.TYPE_CODE);
-        }
-    }
-
-    @Override
-    public E getNullableResult(ResultSet rs, String columnName) throws SQLException {
-        if (null == rs.getObject(columnName) && rs.wasNull()) {
-            return null;
-        }
-        return this.valueOf(this.type, rs.getObject(columnName));
-    }
-
-    @Override
-    public E getNullableResult(ResultSet rs, int columnIndex) throws SQLException {
-        if (null == rs.getObject(columnIndex) && rs.wasNull()) {
-            return null;
-        }
-        return this.valueOf(this.type, rs.getObject(columnIndex));
-    }
-
-    @Override
-    public E getNullableResult(CallableStatement cs, int columnIndex) throws SQLException {
-        if (null == cs.getObject(columnIndex) && cs.wasNull()) {
-            return null;
-        }
-        return this.valueOf(this.type, cs.getObject(columnIndex));
+        super(type);
     }
 
     /**
@@ -114,7 +41,7 @@ public class MybatisEnumTypeHandler<E extends Enum<?>> extends BaseTypeHandler<E
      */
     @Deprecated
     public static Optional<Field> dealEnumType(Class<?> clazz) {
-        return clazz.isEnum() ? Arrays.stream(clazz.getDeclaredFields()).filter(field -> field.isAnnotationPresent(EnumValue.class)).findFirst() : Optional.empty();
+        return com.baomidou.mybatisplus.core.handlers.MybatisEnumTypeHandler.dealEnumType(clazz);
     }
 
     /**
@@ -125,16 +52,7 @@ public class MybatisEnumTypeHandler<E extends Enum<?>> extends BaseTypeHandler<E
      * @since 3.3.1
      */
     public static Optional<String> findEnumValueFieldName(Class<?> clazz) {
-        if (clazz != null && clazz.isEnum()) {
-            String className = clazz.getName();
-            return Optional.ofNullable(CollectionUtils.computeIfAbsent(TABLE_METHOD_OF_ENUM_TYPES, className, key -> {
-                Optional<Field> optional = Arrays.stream(clazz.getDeclaredFields())
-                    .filter(field -> field.isAnnotationPresent(EnumValue.class))
-                    .findFirst();
-                return optional.map(Field::getName).orElse(null);
-            }));
-        }
-        return Optional.empty();
+        return com.baomidou.mybatisplus.core.handlers.MybatisEnumTypeHandler.findEnumValueFieldName(clazz);
     }
 
     /**
@@ -145,37 +63,7 @@ public class MybatisEnumTypeHandler<E extends Enum<?>> extends BaseTypeHandler<E
      * @since 3.3.1
      */
     public static boolean isMpEnums(Class<?> clazz) {
-        return clazz != null && clazz.isEnum() && (IEnum.class.isAssignableFrom(clazz) || findEnumValueFieldName(clazz).isPresent());
-    }
-
-    private E valueOf(Class<E> enumClass, Object value) {
-        E[] es = enumClass.getEnumConstants();
-        return Arrays.stream(es).filter((e) -> equalsValue(value, getValue(e))).findAny().orElse(null);
-    }
-
-    /**
-     * 值比较
-     *
-     * @param sourceValue 数据库字段值
-     * @param targetValue 当前枚举属性值
-     * @return 是否匹配
-     * @since 3.3.0
-     */
-    protected boolean equalsValue(Object sourceValue, Object targetValue) {
-        String sValue = Objects.toString(sourceValue).trim();
-        String tValue = Objects.toString(targetValue).trim();
-        if (sourceValue instanceof Number && targetValue instanceof Number
-            && new BigDecimal(sValue).compareTo(new BigDecimal(tValue)) == 0) {
-            return true;
-        }
-        return Objects.equals(sValue, tValue);
-    }
-
-    private Object getValue(Object object) {
-        try {
-            return invoker.invoke(object, new Object[0]);
-        } catch (ReflectiveOperationException e) {
-            throw ExceptionUtils.mpe(e);
-        }
+        return com.baomidou.mybatisplus.core.handlers.MybatisEnumTypeHandler.isMpEnums(clazz);
     }
+    
 }

mybatis-plus-extension/src/test/java/com/baomidou/mybatisplus/test/handlers/MybatisEnumTypeHandlerTest.java

@@ -33,67 +33,67 @@ import static org.mockito.Mockito.when;
 
 @ExtendWith(MockitoExtension.class)
 public class MybatisEnumTypeHandlerTest extends BaseTypeHandlerTest {
-
+    
     private static final MybatisEnumTypeHandler<SexEnum> SEX_ENUM_ENUM_TYPE_HANDLER = new MybatisEnumTypeHandler<>(SexEnum.class);
-
+    
     private static final MybatisEnumTypeHandler<GradeEnum> GRADE_ENUM_ENUM_TYPE_HANDLER = new MybatisEnumTypeHandler<>(GradeEnum.class);
-
+    
     private static final MybatisEnumTypeHandler<CharacterEnum> CHARACTER_ENUM_MYBATIS_ENUM_TYPE_HANDLER = new MybatisEnumTypeHandler<>(CharacterEnum.class);
-
+    
     @Getter
     @AllArgsConstructor
     enum SexEnum implements IEnum<Integer> {
-
+        
         MAN(1, "1"),
         WO_MAN(2, "2");
         Integer code;
         String desc;
-
+        
         @Override
         public Integer getValue() {
             return this.code;
         }
     }
-
+    
     @Getter
     @AllArgsConstructor
     enum GradeEnum {
-
+        
         PRIMARY(1, "小学"),
         SECONDARY(2, "中学"),
         HIGH(3, "高中");
-
+        
         @EnumValue
         private final int code;
-
+        
         private final String desc;
     }
-
+    
     @Test
     @Override
     public void getResultFromResultSetByColumnName() throws Exception {
-        when(resultSet.getObject("column")).thenReturn(null);
+        when(resultSet.getObject("column", Integer.class)).thenReturn(null);
         assertNull(SEX_ENUM_ENUM_TYPE_HANDLER.getResult(resultSet, "column"));
-        when(resultSet.getObject("column")).thenReturn(1);
+        when(resultSet.getObject("column", Integer.class)).thenReturn(1);
         assertEquals(SexEnum.MAN, SEX_ENUM_ENUM_TYPE_HANDLER.getResult(resultSet, "column"));
-        when(resultSet.getObject("column")).thenReturn(2);
+        when(resultSet.getObject("column", Integer.class)).thenReturn(2);
         assertEquals(SexEnum.WO_MAN, SEX_ENUM_ENUM_TYPE_HANDLER.getResult(resultSet, "column"));
-
-        when(resultSet.getObject("column")).thenReturn(null);
+        
+        when(resultSet.getObject("column", Integer.class)).thenReturn(null);
         assertNull(GRADE_ENUM_ENUM_TYPE_HANDLER.getResult(resultSet, "column"));
-        when(resultSet.getObject("column")).thenReturn(1);
+        when(resultSet.getObject("column", Integer.class)).thenReturn(1);
         assertEquals(GradeEnum.PRIMARY, GRADE_ENUM_ENUM_TYPE_HANDLER.getResult(resultSet, "column"));
-        when(resultSet.getObject("column")).thenReturn(2);
+        when(resultSet.getObject("column", Integer.class)).thenReturn(2);
         assertEquals(GradeEnum.SECONDARY, GRADE_ENUM_ENUM_TYPE_HANDLER.getResult(resultSet, "column"));
-
-        when(resultSet.getObject("column")).thenReturn(null);
+        
+        when(resultSet.getObject("column", Character.class)).thenReturn(null);
         assertNull(CHARACTER_ENUM_MYBATIS_ENUM_TYPE_HANDLER.getResult(resultSet, "column"));
-        when(resultSet.getObject("column")).thenReturn("1");
+        when(resultSet.getObject("column", Character.class)).thenReturn('1');
         assertEquals(CharacterEnum.MAN, CHARACTER_ENUM_MYBATIS_ENUM_TYPE_HANDLER.getResult(resultSet, "column"));
-        when(resultSet.getObject("column")).thenReturn("2");
+        when(resultSet.getObject("column", Character.class)).thenReturn('2');
         assertEquals(CharacterEnum.WO_MAN, CHARACTER_ENUM_MYBATIS_ENUM_TYPE_HANDLER.getResult(resultSet, "column"));
     }
-
+    
     @Test
     void dealEnumType() {
         Assertions.assertFalse(MybatisEnumTypeHandler.dealEnumType(String.class).isPresent());
@@ -103,7 +103,7 @@ public class MybatisEnumTypeHandlerTest extends BaseTypeHandlerTest {
         Assertions.assertTrue(MybatisEnumTypeHandler.findEnumValueFieldName(GradeEnum.class).isPresent());
         Assertions.assertFalse(MybatisEnumTypeHandler.findEnumValueFieldName(SexEnum.class).isPresent());
     }
-
+    
     @Test
     @Override
     public void setParameter() throws Exception {
@@ -113,7 +113,7 @@ public class MybatisEnumTypeHandlerTest extends BaseTypeHandlerTest {
         verify(preparedStatement).setObject(2, 2);
         SEX_ENUM_ENUM_TYPE_HANDLER.setParameter(preparedStatement, 3, null, JdbcType.INTEGER);
         verify(preparedStatement).setNull(3, JdbcType.INTEGER.TYPE_CODE);
-
+        
         GRADE_ENUM_ENUM_TYPE_HANDLER.setParameter(preparedStatement, 4, GradeEnum.PRIMARY, null);
         verify(preparedStatement).setObject(4, 1);
         GRADE_ENUM_ENUM_TYPE_HANDLER.setParameter(preparedStatement, 5, GradeEnum.SECONDARY, null);
@@ -121,51 +121,51 @@ public class MybatisEnumTypeHandlerTest extends BaseTypeHandlerTest {
         GRADE_ENUM_ENUM_TYPE_HANDLER.setParameter(preparedStatement, 6, null, JdbcType.INTEGER);
         verify(preparedStatement).setNull(6, JdbcType.INTEGER.TYPE_CODE);
     }
-
+    
     @Getter
     @AllArgsConstructor
     enum CharacterEnum {
         MAN('1', "男"),
         WO_MAN('2', "女");
-
+        
         @EnumValue
         char code;
         String desc;
     }
-
+    
     @Test
     @Override
     public void getResultFromResultSetByColumnIndex() throws Exception {
-        when(resultSet.getObject(1)).thenReturn(1);
+        when(resultSet.getObject(1, Integer.class)).thenReturn(1);
         assertEquals(SexEnum.MAN, SEX_ENUM_ENUM_TYPE_HANDLER.getResult(resultSet, 1));
-        when(resultSet.getObject(2)).thenReturn(2);
+        when(resultSet.getObject(2, Integer.class)).thenReturn(2);
         assertEquals(SexEnum.WO_MAN, SEX_ENUM_ENUM_TYPE_HANDLER.getResult(resultSet, 2));
-        when(resultSet.getObject(3)).thenReturn(null);
+        when(resultSet.getObject(3, Integer.class)).thenReturn(null);
         assertNull(SEX_ENUM_ENUM_TYPE_HANDLER.getResult(resultSet, 3));
-
-        when(resultSet.getObject(4)).thenReturn(1);
+        
+        when(resultSet.getObject(4, Integer.class)).thenReturn(1);
         assertEquals(GradeEnum.PRIMARY, GRADE_ENUM_ENUM_TYPE_HANDLER.getResult(resultSet, 4));
-        when(resultSet.getObject(5)).thenReturn(2);
+        when(resultSet.getObject(5, Integer.class)).thenReturn(2);
         assertEquals(GradeEnum.SECONDARY, GRADE_ENUM_ENUM_TYPE_HANDLER.getResult(resultSet, 5));
-        when(resultSet.getObject(6)).thenReturn(null);
+        when(resultSet.getObject(6, Integer.class)).thenReturn(null);
         assertNull(GRADE_ENUM_ENUM_TYPE_HANDLER.getResult(resultSet, 6));
     }
-
+    
     @Test
     @Override
     public void getResultFromCallableStatement() throws Exception {
-        when(callableStatement.getObject(1)).thenReturn(1);
+        when(callableStatement.getObject(1, Integer.class)).thenReturn(1);
         assertEquals(SexEnum.MAN, SEX_ENUM_ENUM_TYPE_HANDLER.getResult(callableStatement, 1));
-        when(callableStatement.getObject(2)).thenReturn(2);
+        when(callableStatement.getObject(2, Integer.class)).thenReturn(2);
         assertEquals(SexEnum.WO_MAN, SEX_ENUM_ENUM_TYPE_HANDLER.getResult(callableStatement, 2));
-        when(callableStatement.getObject(3)).thenReturn(null);
+        when(callableStatement.getObject(3, Integer.class)).thenReturn(null);
         assertNull(SEX_ENUM_ENUM_TYPE_HANDLER.getResult(callableStatement, 3));
-
-        when(callableStatement.getObject(4)).thenReturn(1);
+        
+        when(callableStatement.getObject(4, Integer.class)).thenReturn(1);
         assertEquals(GradeEnum.PRIMARY, GRADE_ENUM_ENUM_TYPE_HANDLER.getResult(callableStatement, 4));
-        when(callableStatement.getObject(5)).thenReturn(2);
+        when(callableStatement.getObject(5, Integer.class)).thenReturn(2);
         assertEquals(GradeEnum.SECONDARY, GRADE_ENUM_ENUM_TYPE_HANDLER.getResult(callableStatement, 5));
-        when(callableStatement.getObject(6)).thenReturn(null);
+        when(callableStatement.getObject(6, Integer.class)).thenReturn(null);
         assertNull(GRADE_ENUM_ENUM_TYPE_HANDLER.getResult(callableStatement, 6));
     }
 }