记一次MyBatis封装结果集java.lang.Integer cannot be cast to java.lang.String异常处理

本文更好的观看体验在笔者的个人博客中~

项目中利用Mybatis来获取数据，使用Map来对结果进行封装，但是在获取某个具体的值时抛出java.lang.Integer cannot be cast to java.lang.String异常，在debug过程中对为什么要这样解决产生了疑惑，所以想记录一下~
项目代码如下：

1. Dao.java

HashMap getEntityByName(String entityName); 

2. Mapper.xml

    SELECT entity_id, entity_table FROM entity WHERe entity_name=#{entityName};

3. 使用

HashMap entityInfo = DAO.getEntityByName(type);
int entityId = Integer.parseInt(entityInfo.get("entity_id"));  // 抛出异常

先说结论，解决方法很简单，将使用处代码修改为：

int entityId = Integer.parseInt(String.valueOf(entityInfo.get("entity_id")));

虽然这时候IDEA会告诉你String.valueOf()方法很多余，但是相信我，真的不多余…

之前对泛型并没有特别多的了解，类型擦除也是没有听说过，但是在解释这个问题上还是需要了解一下这方面的知识的~

Java的泛型是伪泛型，这是因为Java在编译期间，所有的泛型信息都会被擦掉，正确理解泛型概念的首要前提是理解类型擦除。Java的泛型基本上都是在编译器这个层次上实现的，在生成的字节码中是不包含泛型中的类型信息的，使用泛型的时候加上类型参数，在编译器编译的时候会去掉，这个过程称为类型擦除。

1. 原始类型相等：通过a对象和b对象的getClass()方法获取他们的类的信息，最后发现结果为true。说明泛型类型String和Integer都被擦除掉了，只剩下原始类型。

public static void main(String[] args) {  
    List a = new ArrayList();  
    List b = new ArrayList();  
    System.out.println(a.getClass() == b.getClass());  // true
}

2. 通过反射添加其他类型元素：定义了一个ArrayList泛型类型实例化为Integer对象，如果直接调用add()方法，那么只能存储整数数据，不过当我们利用反射调用add()方法的时候，却可以存储字符串，这说明了Integer泛型实例在编译之后被擦除掉了，只保留了原始类型。

public class Test {
    public static void main(String[] args) throws Exception{
        ArrayList list = new ArrayList();
        list.add(1);  //这样调用 add 方法只能存储整形，因为泛型类型的实例为 Integer
        list.getClass().getMethod("add", Object.class).invoke(list, "asd");
        for (int i = 0; i < list.size(); i++) {
            System.out.println(list.get(i));
        }
    }
}

原始类型 就是擦除去了泛型信息，最后在字节码中的类型变量的真正类型，无论何时定义一个泛型，相应的原始类型都会被自动提供，类型变量擦除，并使用其限定类型（无限定的变量用Object）替换。

1. 原始类型Object

public class Pair {  
    private T value;  
    public T getValue() {  
        return value;  
    }  
    public void setValue(T  value) {  
        this.value = value;  
    }  
}  

Pair的原始类型为：

public class Pair {  
    private Object value;  
    public Object getValue() {  
        return value;  
    }  
    public void setValue(Object  value) {  
        this.value = value;  
    }  
}

因为在Pair中，T 是一个无限定的类型变量，所以用Object替换，其结果就是一个普通的类，如同泛型加入Java语言之前的已经实现的样子。在程序中可以包含不同类型的Pair，如Pair或Pair，但是擦除类型后他们的就成为原始的Pair类型了，原始类型都是Object
[所以我们的集合类，如ArrayList类型擦除后的原始类型为Object，通过反射就可以存储各种类型]{.yellow}
但是如果用这样声明的话那原始类型就是Comparable：

public class Pair {}

要区分原始类型和泛型变量的类型。在调用泛型方法时，可以指定泛型，也可以不指定泛型。

• 在不指定泛型的情况下，泛型变量的类型为该方法中的几种类型的同一父类的最小级，直到 Object。
• 在指定泛型的情况下，该方法的几种类型必须是该泛型的实例的类型或者其子类。

public class Test {  
    public static void main(String[] args) {  

          
        int i = Test.add(1, 2); //这两个参数都是Integer，所以T为Integer类型  
        Number f = Test.add(1, 1.2); //这两个参数一个是Integer，以风格是Float，所以取同一父类的最小级，为Number  
        Object o = Test.add(1, "asd"); //这两个参数一个是Integer，以风格是Float，所以取同一父类的最小级，为Object  

          
        int a = Test.add(1, 2); //指定了Integer，所以只能为Integer类型或者其子类  
        int b = Test.add(1, 2.2); //编译错误，指定了Integer，不能为Float  
        Number c = Test.add(1, 2.2); //指定为Number，所以可以为Integer和Float  
    }  

    //这是一个简单的泛型方法  
    public static  T add(T x,T y){  
        return y;  
    }  
}

2. Object泛型
   注意看这个例子，我们这个问题的解释主要就是要看明白这个例子，如果不指定泛型，那么什么都能存

public static void main(String[] args) {  
    ArrayList list = new ArrayList();  
    list.add(1);  
    list.add("121");  
    list.add(new Date());  
}  

private void viewDetail(){ 
    Map map1 = new HashMap();
    Map map2 = new HashMap();
    Map map3 = new HashMap();
    Map map4 = new HashMap();
    test1(map1);
    test1(map2);
    test1(map3);  // 编译错误
    test1(map4);  // 编译错误
}
private void test1(Map map){}

泛型是后加入的，早期的版本没有，但是java的开发者希望不能因为加入泛型就要修改成千上万的现有应用，所以默认他可以通融老版本不加泛型的变量，这就是为什么我们的map1不会出错了。就是说[如果我们的泛型类不指定泛型，那么可以和任何指定泛型的变量赋值]{.yellow}

Q: 既然说类型变量会在编译的时候擦除掉，那为什么我们往 ArrayList 创建的对象中添加整数会报错呢？不是说泛型变量String会在编译的时候变为Object类型吗？为什么不能存别的类型呢？既然类型擦除了，如何保证我们只能使用泛型变量限定的类型呢？
A: Java编译器是通过先检查代码中泛型的类型，然后在进行类型擦除，再进行编译。

来看这两种情况：

ArrayList list1 = new ArrayList(); //第一种 情况，与完全使用泛型一样效果
ArrayList list2 = new ArrayList(); //第二种 情况，没有效果

因为类型检查就是编译时完成的，new ArrayList()只是在内存中开辟了一个存储空间，可以存储任何类型对象，而真正设计类型检查的是它的引用，因为我们是使用它引用list1来调用它的方法，比如说调用add方法，所以list1引用能完成泛型类型的检查。而引用list2没有使用泛型，所以不行。

public class Test {  
    public static void main(String[] args) {  

        ArrayList list1 = new ArrayList();  
        list1.add("1"); //编译通过  
        list1.add(1); //编译错误  
        String str1 = list1.get(0); //返回类型就是String  

        ArrayList list2 = new ArrayList();  
        list2.add("1"); //编译通过  
        list2.add(1); //编译通过  
        Object object = list2.get(0); //返回类型就是Object  

        new ArrayList().add("11"); //编译通过  
        new ArrayList().add(22); //编译错误  
    }  
}  

前面说了那么多，终于开始看我们的MyBatis源码了，用了MyBatis那么多次，竟然从来没有关心过它底层是怎么实现的，真是惭愧，借着这个机会简单了解下吧~

1. DefaultResultSetHandler的handleResultSets方法

@Override
public List