JackJson反序列化为何一定需要TypeReference

==

==

import java.util.ArrayList;
import java.util.List;

import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.ObjectMapper;

public class TestJackson {
	public static ObjectMapper mapper = new ObjectMapper();
	public static ObjectMapper mapper1 = new ObjectMapper();
	public static void main(String[] args) throws Exception {
		List<Person> listPerson = new ArrayList<>();
		listPerson.add(new Person("张三1"));
		listPerson.add(new Person("张三2"));
		String jsonPerson = mapper.writeValueAsString(listPerson);
		// [{"name":"张三1"},{"name":"张三2"}]
		System.out.println(jsonPerson);
		// 现在我要用jsonPerson还原
		List<Person> getlistPerson = mapper1.readValue(jsonPerson,
				new TypeReference<List<Person>>() {
				});
		System.out.println(getlistPerson.get(0).name);
	}
}
class Person {
	public Person(){
	}
	public String name;
	public Person(String name) {
		this.name = name;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
}

这是一个Jackson json的例子。

==

首先说泛型类。比如说我们平时使用的HashMap，类的定义是  public class HashMap<K,V>  这里的K V就是两个泛型，

如果要使用HashMap就需要指定泛型的实际类型。比如说 new  HashMap<String,String>, 

 ①  对于类的定义,也就是HashMap的制作角度讲，使用了K V字符后,便可以使用KV这两个字符，但是只能存在声明和引用的使用，而不能实例化。

 ② 对于类的使用来说，比如 HashMap<String,String>  hashmap=   new  HashMap<String,String>，之后便可以使用所以定义的方法，此时put和get  所对应的KV必须一致。

如果是其他类，子类也是可以的。比如   List<Person> 之后，add方法可以存放Person的子类，get后也被Person所引用。不需转化。

如果是泛型方法的定义，

比如：

public <T> T add(T t){
return null;
}

这里的T已经和类无关了，这里的T对应的是   Person  p=new ClassName().add(new Person())   这里public后面<T>这里的T限定了后面的返回类型必须是T，参数也必须是T，尖括号里面的T来自于Person p  这里的Person  p，也就是说因为 这里的Person导致了<T>的对应关系，于是乎  add方法的参数和返回值必须是Person。 当然add函数的返回和参数也可以不是T。

泛型擦除讲的是什么：

山面的①和②中①是定义   ②是声明，泛型擦除讲的是擦除②  而不是①。

比如说   List<Person> list=new ArrayList<>();  这个语句经过编译后会成为   List  list=new Arraylist();  这样的语句。

但是  如果是class<T> Cname{ } 这个类经过编译之后，所有的信息都还在。

==

public class R {

	public static void main(String[] args) {
		TClass t = new TClass<String>() {};
		//TClass<java.lang.String>
		System.out.println(t.getClass().getGenericSuperclass());
	}
}
class TClass<T> {
}

 ==

这里获取到了//TClass<java.lang.String>

这个代码其实是

public class R {

	public static void main(String[] args) {
		TClass t = new InnerTClass();
		System.out.println(t.getClass().getGenericSuperclass());
	}
}
class TClass<T> {
}
class InnerTClass extends TClass<String>{
	
}

==

这里的两个代码等价了。根据superclass获取到了type的类型。Jackson就是以这个type为框架实现的类实例化。在InnerClass中泛型已经是被使用者而不是定义者了。

这里的String的意思是  java.lang.String

如果代码是

class TClass<T> {
}
class InnerTClass<String> extends TClass<String> {
 
}

这样的形式的话,那么对于这里的两个String 都是定义 ，不是使用，也就是说这里的两个String都和T是一个意思，而不是java.lang.Sting那个String。 两个没有一点关系。