JAVA反射（二）-进阶
JAVA反射（二）-进阶
一、Java内存分析
| 分类 | 堆 |
|---|---|
| 堆 | - 存放new的对象和数组 可以被所有的线程共享，不会存放别的对象引用 |
| 栈 | - 存放基本变量类型（会包含这个基本类型的具体数值）- 存放 引用对象变量的地址（会存放这个引用在堆里面的具体地址） |
| 方法区 | 可以被所有的线程共享，包含了所有的class和static变量 |
二、类的加载的过程
2.1 类的加载3步骤
如果程序主动使用某个类时，
如果该类还未被加载到内存中，则系统会通过如下三个步骤来对该类进行初始化:
| 类的加载=> | 类的链接=> | 类的初始化 |
|---|---|---|
| Load | Link | Initialize |
| 将类的class文件读入内存， 并为此 创建一个java.lang.Class对象。此过程由类加载器完成 |
将类的二级制数据合并到JRE中 | JVM负责对类进行初始化 |
2.1.1 加载：
将class文件字节码内容加载到内存中，并将这些静态数据转换成方法区的运行时数据结构，然后生成一个代表这个类的java.lang.Class对象
2.1.2 链接：
将Java类的二进制代码合并到JVM的运行状态之中的过程
- 验证：确保加载的类信息符合JVM规范，没有安全方面的问题
- 准备：正式为类变量(static)分配内存并设置类变量，并分配默认值(如下面代码示例初始化m=0)
- 解析：虚拟机常量池内的符号引用(常量名)替换为直接引用(地址)的过程。
以上两步完成了一切准备工作。
2.1.3 初始化：
-
执行类构造器
<clinit>()方法的过程（这个过程是由JVM做的，程序员无法控制）。类构造器()方法时由编译器自动收集类中所有 类变量的赋值动作和静态代码块中的语句合并产生的。（即所有的static修饰的东西）（注意：类构造器是构造类信息的，不是构造该类对象的构造器。）
-
当初始化一个类的时候，如果发现其父类还诶有进行初始化，则需要先触发器父类的初始化
-
虚拟机会保证一个类的
()方法在 多线程环境中被正确加锁和同步。
2.2 类的初始化顺序代码示意：
package com.happy;
public class InitStudy {
public static void main(String[] args) {
A a = new A();
System.out.println(a.m);
System.out.println(A.m);
}
}
class A {
static {
System.out.println("0.A类静态代码块初始化之前m的值："+A.m);
System.out.println("1.A类静态代码块初始化");
m = 300;
}
static int m = 100;
public A() {
System.out.println("2.A类的无参构造方法初始化");
/* m=400;*/
}
}
结果如下：
0.A类静态代码块初始化之前m的值：0
1.A类静态代码块初始化
2.A类的无参构造方法初始化
100
100
package com.happy;
public class InitStudy {
public static void main(String[] args) {
A a = new A();
System.out.println(a.m);
System.out.println(A.m);
}
}
class A {
static int m = 100;
static {
System.out.println("1.A类静态代码块初始化");
m = 300;
}
public A() {
System.out.println("2.A类的无参构造方法初始化");
/* m=400;*/
}
}
改动static的顺序，结果如下，可见完全合并后按顺序执行。
1.A类静态代码块初始化
2.A类的无参构造方法初始化
300
300
2.3 什么时候会发生类的初始化？
2.3.1 类的主动引用（一定会发生类的初始化）
当虚拟机启动，
先初始化main方法所在的类new一个类的对象
调用类的静态成员（除了final常量）和静态方法
使用java.lang.reflect包的方法对类进行反射调用
当初始化一个类，如果其父类没有被初始化，则先会初始化它的父类。
代码示例：
package com.happy;
public class ClassLoadStudy {
static {
System.out.println("Main所在类被加载：");
}
public static void main(String[] args) throws ClassNotFoundException {
// 1.主动调用子类
Son gaoyiheng = new Son();
// 2.反射也会产生主动调用
// Class.forName("com.happy.Son");
}
}
class Father {
static {
System.out.println("父类静态代码块执行前，m=" + Father.m);
System.out.println("父类静态代码块执行，在被加载");
m = 8;
System.out.println("父类静态代码块执行后，m=" + Father.m);
}
static int m;
}
class Son extends Father {
static {
System.out.println("子类静态代码块执行，在被加载");
}
public Son() {
this.m=123;
System.out.println("子类son的构造方法被执行");
System.out.println("子类son的构造方法被执行后m="+this.m);
}
}
执行结果如下：
Main所在类被加载：
父类静态代码块执行前，m=0
父类静态代码块执行，在被加载
父类静态代码块执行后，m=8
子类静态代码块执行，在被加载
子类son的构造方法被执行
子类son的构造方法被执行后m=123
2.3.2 类的被动引用（不会发生类的初始化）
- 当访问一个静态域时，只有真正声明这个域的类才会被初始化。如：当通过子类引用父类的静态变量，不会导致子类初始化。
- 通过数组定义类应用，不会出发此类的初始化
- 引用常量不会触发此类的初始化(
常量在链接阶段就存入调用类的常量池中了)
package com.happy;
public class ClassLoadStudy {
static {
System.out.println("Main所在类被加载：");
}
public static void main(String[] args) throws ClassNotFoundException {
// 1.主动调用子类
// Son gaoyiheng = new Son();
// 2.反射也会产生主动调用
// Class.forName("com.happy.Son");
// 3.调用父类的static变量，并不会初始化子类
int fatherB=Son.b;
System.out.println(fatherB);
}
}
class Father {
static int b=2;
static {
System.out.println("父类静态代码块执行前，m=" + Father.m);
System.out.println("父类静态代码块执行，在被加载");
m = 8;
System.out.println("父类静态代码块执行后，m=" + Father.m);
}
static int m;
}
class Son extends Father {
final static int constant = 666;
static {
System.out.println("子类静态代码块执行，在被加载");
}
public Son() {
this.m = 123;
System.out.println("子类son的构造方法被执行");
System.out.println("子类son的构造方法被执行后m=" + this.m);
}
}
结果如下，调用父类的static变量，并不会初始化子类
Main所在类被加载：
父类静态代码块执行前，m=0
父类静态代码块执行，在被加载
父类静态代码块执行后，m=8
2
package com.happy;
public class ClassLoadStudy {
static {
System.out.println("Main所在类被加载：");
}
public static void main(String[] args) throws ClassNotFoundException {
// 1.主动调用子类
// Son gaoyiheng = new Son();
// 2.反射也会产生主动调用
// Class.forName("com.happy.Son");
// 3.调用父类的static变量，并不会初始化子类
// int fatherB=Son.b;
// System.out.println(fatherB);
// 4.数组声明引用，只是分配空间，并不会初始化
Son[] sons = new Son[5];
}
}
class Father {
static int b = 2;
static {
System.out.println("父类静态代码块执行前，m=" + Father.m);
System.out.println("父类静态代码块执行，在被加载");
m = 8;
System.out.println("父类静态代码块执行后，m=" + Father.m);
}
static int m;
}
class Son extends Father {
final static int constant = 666;
static {
System.out.println("子类静态代码块执行，在被加载");
}
public Son() {
this.m = 123;
System.out.println("子类son的构造方法被执行");
System.out.println("子类son的构造方法被执行后m=" + this.m);
}
}
结果如下，只有main所在类初始化
Main所在类被加载：
三、类加载器的作用
3.1 类加载的作用：
类加载器的作用就是将class文件字节码内容加载到内存中，并将这些静态数据转换成方法区的运行时数据结构，然后在堆中生成了一个
代表这个类的java.lang.Class对象（不管这个类有多少个对象，只生成一个他的class对象），作为方法区中类数据的访问入口。
3.2 类缓存：
标准的JavaSE类加载器可以按要求查找类，但一旦某个类被加载到类加载器中，它将维持加载（缓存）一段时间。不过JVM垃圾回收机制可以回收这些Class对象。
类加载顺序如下图：
3.3 类加载器的分类
| 引导类加载器 | 扩展类加载器 | 系统类加载器 |
|---|---|---|
用C++编写的，是JVM自带的类加载器，负责Java平台核心库，用来加载核心类库。该加载器无法直接获取。如jdk的rt.jar。 |
负责jre/lib/ext目录下的jar包或-D java.ext.dirs指定目录下的jar包装入工作库。 | 负责java -classpath或-D java.class.path所指的目录下的类与jar包装入工作。是常用的加载器。就是我们自己写的jar包。 |
如下图，安装的jdk里面的rt.jar包，含有java核心类
代码示例如下：
package com.happy;
public class ClassLoadStudy2 {
static {
System.out.println("Main所在类被加载：");
}
public static void main(String[] args) throws ClassNotFoundException {
// 1.获取系统类加载器
ClassLoader systemClassLoader = ClassLoader.getSystemClassLoader();
System.out.println("systemClassLoader:" + systemClassLoader);
System.out.println(systemClassLoader.getClass());
// 2.获取系统类加载的父类加载器，实际为扩展类加载器
ClassLoader parentClassLoader = systemClassLoader.getParent();
System.out.println("parentClassLoader(extension):" + parentClassLoader);
System.out.println(parentClassLoader.getClass());
// 3.获取扩展类的父类加载器，是用c++写的，java读取不到
ClassLoader bootClassLoader = parentClassLoader.getParent();
System.out.println("bootClassLoader:" + bootClassLoader);
// 4.测试当前我们写的这个类是哪个加载器加载的，一般程序员写的都是系统加载器加载的
ClassLoader thisclassLoader =Class.forName("com.happy.ClassLoadStudy2").getClassLoader();
System.out.println("我们的类的类加载器:" + thisclassLoader);
// 5.测试jdk的核心类是由哪个加载器加载的
ClassLoader jdkClassLoader =Class.forName("java.lang.Object").getClassLoader();
System.out.println("jdk类的类加载器:" + jdkClassLoader);
// 6.如何获得system加载类可以加载的加载路径
System.out.println(System.getProperty("java.class.path"));
/* D:\software\jdk1.8\jre\lib\charsets.jar;
D:\software\jdk1.8\jre\lib\deploy.jar;
D:\software\jdk1.8\jre\lib\ext\access-bridge-64.jar;
D:\software\jdk1.8\jre\lib\ext\cldrdata.jar;
D:\software\jdk1.8\jre\lib\ext\dnsns.jar;
D:\software\jdk1.8\jre\lib\ext\jaccess.jar;
D:\software\jdk1.8\jre\lib\ext\jfxrt.jar;
D:\software\jdk1.8\jre\lib\ext\localedata.jar;
D:\software\jdk1.8\jre\lib\ext\nashorn.jar;
D:\software\jdk1.8\jre\lib\ext\sunec.jar;
D:\software\jdk1.8\jre\lib\ext\sunjce_provider.jar;
D:\software\jdk1.8\jre\lib\ext\sunmscapi.jar;
D:\software\jdk1.8\jre\lib\ext\sunpkcs11.jar;
D:\software\jdk1.8\jre\lib\ext\zipfs.jar;
D:\software\jdk1.8\jre\lib\javaws.jar;
D:\software\jdk1.8\jre\lib\jce.jar;
D:\software\jdk1.8\jre\lib\jfr.jar;
D:\software\jdk1.8\jre\lib\jfxswt.jar;
D:\software\jdk1.8\jre\lib\jsse.jar;
D:\software\jdk1.8\jre\lib\management-agent.jar;
D:\software\jdk1.8\jre\lib\plugin.jar;
D:\software\jdk1.8\jre\lib\resources.jar;D:\software\jdk1.8\jre\lib\rt.jar;
C:\Users\pcuser\IdeaProjects\happyStudy\target\classes;
D:\software\idea\IntelliJ IDEA 2021.2.2\lib\idea_rt.jar
*/
}
}
结果如下：
Main所在类被加载：
systemClassLoader:sun.misc.Launcher$AppClassLoader@18b4aac2
class sun.misc.Launcher$AppClassLoader
parentClassLoader(extension):sun.misc.Launcher$ExtClassLoader@4554617c
class sun.misc.Launcher$ExtClassLoader
bootClassLoader:null
我们的类的类加载器:sun.misc.Launcher$AppClassLoader@18b4aac2
jdk类的类加载器:null
D:\software\jdk1.8\jre\lib\charsets.jar;D:\software\jdk1.8\jre\lib\deploy.jar;D:\software\jdk1.8\jre\lib\ext\access-bridge-64.jar;D:\software\jdk1.8\jre\lib\ext\cldrdata.jar;D:\software\jdk1.8\jre\lib\ext\dnsns.jar;D:\software\jdk1.8\jre\lib\ext\jaccess.jar;D:\software\jdk1.8\jre\lib\ext\jfxrt.jar;D:\software\jdk1.8\jre\lib\ext\localedata.jar;D:\software\jdk1.8\jre\lib\ext\nashorn.jar;D:\software\jdk1.8\jre\lib\ext\sunec.jar;D:\software\jdk1.8\jre\lib\ext\sunjce_provider.jar;D:\software\jdk1.8\jre\lib\ext\sunmscapi.jar;D:\software\jdk1.8\jre\lib\ext\sunpkcs11.jar;D:\software\jdk1.8\jre\lib\ext\zipfs.jar;D:\software\jdk1.8\jre\lib\javaws.jar;D:\software\jdk1.8\jre\lib\jce.jar;D:\software\jdk1.8\jre\lib\jfr.jar;D:\software\jdk1.8\jre\lib\jfxswt.jar;D:\software\jdk1.8\jre\lib\jsse.jar;D:\software\jdk1.8\jre\lib\management-agent.jar;D:\software\jdk1.8\jre\lib\plugin.jar;D:\software\jdk1.8\jre\lib\resources.jar;D:\software\jdk1.8\jre\lib\rt.jar;C:\Users\pcuser\IdeaProjects\happyStudy\target\classes;D:\software\idea\IntelliJ IDEA 2021.2.2\lib\idea_rt.jar
四、获取运行时类的完整结构
通过反射获取运行时类的完整结构：
Field，Method，Constructor，SuperClass，Interface，Annotation
4.1 获取各种Class对象的完整结构
package com.happy;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.sql.SQLOutput;
public class ReflectionStudy3 {
public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, InstantiationException, IllegalAccessException, InvocationTargetException {
Class clazz = Class.forName("com.happy.User");
User user;
// 1.打印类名称
System.out.println("包名+类名：" + clazz.getName());
System.out.println("类名：" + clazz.getSimpleName());
System.out.println("fields:获得所有public属性=============================");
// 2.获取属性
Field[] fields = clazz.getFields();
for (Field field : fields) {
System.out.println(field);
}
System.out.println("DeclaredFields:获得所有属性，包括public和private=============================");
fields = clazz.getDeclaredFields();
for (Field field : fields) {
System.out.println(field);
}
System.out.println("获取方法method====================");
Method[] methods = clazz.getMethods();
for (Method method : methods) {
System.out.println("public method：" + method);
}
methods = clazz.getDeclaredMethods();
for (Method method : methods) {
System.out.println("所有method：" + method);
}
System.out.println("获取指定方法：使用getMethod（）");
Method getName = clazz.getMethod("getName", null);
System.out.println(getName);
Method setName = clazz.getMethod("setName", String.class);
System.out.println(setName);
Object object = clazz.newInstance();
setName.invoke(object, "happy");
System.out.println(object);
System.out.println("获取constructor====================");
Constructor[] constructors = clazz.getConstructors();
for (Constructor constructor : constructors) {
System.out.println("所有public的constructor：" + constructor);
}
constructors = clazz.getDeclaredConstructors();
for (Constructor constructor : constructors) {
System.out.println("所有的constructor：" + constructor);
}
Constructor constructor = clazz.getConstructor(String.class, int.class, int.class);
System.out.println(constructor);
}
}
结果如下：
包名+类名：com.happy.User
类名：User
fields:获得所有public属性=============================
DeclaredFields:获得所有属性，包括public和private=============================
private java.lang.String com.happy.User.name
private int com.happy.User.id
private int com.happy.User.age
获取方法method====================
public method：public java.lang.String com.happy.User.toString()
public method：public java.lang.String com.happy.User.getName()
public method：public int com.happy.User.getId()
public method：public void com.happy.User.setName(java.lang.String)
public method：public void com.happy.User.setId(int)
public method：public int com.happy.User.getAge()
public method：public void com.happy.User.setAge(int)
public method：public final void java.lang.Object.wait() throws java.lang.InterruptedException
public method：public final void java.lang.Object.wait(long,int) throws java.lang.InterruptedException
public method：public final native void java.lang.Object.wait(long) throws java.lang.InterruptedException
public method：public boolean java.lang.Object.equals(java.lang.Object)
public method：public native int java.lang.Object.hashCode()
public method：public final native java.lang.Class java.lang.Object.getClass()
public method：public final native void java.lang.Object.notify()
public method：public final native void java.lang.Object.notifyAll()
所有method：public java.lang.String com.happy.User.toString()
所有method：public java.lang.String com.happy.User.getName()
所有method：public int com.happy.User.getId()
所有method：public void com.happy.User.setName(java.lang.String)
所有method：private void com.happy.User.test()
所有method：public void com.happy.User.setId(int)
所有method：public int com.happy.User.getAge()
所有method：public void com.happy.User.setAge(int)
获取指定方法：使用getMethod（）
public java.lang.String com.happy.User.getName()
public void com.happy.User.setName(java.lang.String)
User{name='happy', id=0, age=0}
获取constructor====================
所有public的constructor：public com.happy.User(java.lang.String,int,int)
所有public的constructor：public com.happy.User()
所有的constructor：public com.happy.User(java.lang.String,int,int)
所有的constructor：public com.happy.User()
public com.happy.User(java.lang.String,int,int)
4.2 使用反射的方法创建对象以及调用方法等
{$某method}.invoke()
{$某constructor}.newInstance()
{$某field}.set()
package com.happy;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
public class ReflectionStudy4 {
public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, InstantiationException, IllegalAccessException, InvocationTargetException, NoSuchFieldException {
Class clazz = Class.forName("com.happy.User");
// 方法一:使用class类的对象的newInstance, 本质上和new 对象差不多，就是只能使用无参构造器
Object o = clazz.newInstance();
System.out.println(o);
// 方法二:先使用getConstructor,再使用得到的指定有參構造器newInstance
Constructor constructor = clazz.getConstructor(String.class, int.class, int.class);
Object happy = constructor.newInstance("happy", 518, 35);
System.out.println(happy);
System.out.println(happy.getClass());
// 通过反射调用方法
Method setAge = clazz.getMethod("setAge", int.class);
setAge.invoke(o,18);
System.out.println("永远18岁是不是："+o);
// 通过方法操作属性，尤其是私有属性
Field name = clazz.getDeclaredField("name");
// 因为name是私有属性，可以设置accessible，跳过属性限制,关闭安全检测。
name.setAccessible(true);
name.set(o,"gaoyiheng");
System.out.println("改名字了："+o);
}
}
User{name='null', id=0, age=0}
User{name='happy', id=518, age=35}
class com.happy.User
永远18岁是不是：User{name='null', id=0, age=18}
改名字了：User{name='gaoyiheng', id=0, age=18}
Process finished with exit code 0
4.3 使用反射和普通方式执行方法的性能对比
package com.happy;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
public class ReflectionStudy5 {
public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, InstantiationException, IllegalAccessException, InvocationTargetException, NoSuchFieldException {
test1();
test2();
test3();
}
public static void test1() {
long startTime = System.currentTimeMillis();
int times = 1000000000;
User happy = new User("happy", 1, 34);
for (int i = 0; i < times; i++) {
happy.getName();
}
long endTime = System.currentTimeMillis();
System.out.println("普通调用对象方式所用时间:" + (endTime - startTime));
}
public static void test2() throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
long startTime = System.currentTimeMillis();
int times = 1000000000;
User happy = new User("happy", 1, 34);
Class clazz = happy.getClass();
Method getName = clazz.getMethod("getName", null);
for (int i = 0; i < times; i++) {
getName.invoke(happy, null);
}
long endTime = System.currentTimeMillis();
System.out.println("反射调用对象方式所用时间:" + (endTime - startTime));
}
//打开accessible
public static void test3() throws NoSuchMethodException, InvocationTargetException, IllegalAccessException {
long startTime = System.currentTimeMillis();
int times = 1000000000;
User happy = new User("happy", 1, 34);
Class clazz = happy.getClass();
Method getName = clazz.getMethod("getName", null);
getName.setAccessible(true);
for (int i = 0; i < times; i++) {
getName.invoke(happy, null);
}
long endTime = System.currentTimeMillis();
System.out.println("反射调用对象方式所用时间(打开accessible):" + (endTime - startTime));
}
}
性能时间如下：
普通调用对象方式所用时间:5
反射调用对象方式所用时间:2848
反射调用对象方式所用时间(打开accessible):1816
五、通过反射操作泛型
Java通过采用泛型擦除的机制来引入泛型，java中的
泛型仅仅是给编译器Javac使用的，确保数据的安全性和免去强制类型转换问题，但是，一旦编译完成，所有和泛型有关的类型全部擦除。
为了通过反射操作这些类型，Java新增了ParameterizedType，GenericArrayType，TypeVariable和WildcardType 几种类型来代表不能被归一到Class类中的类型，但是又和原始类型齐名的类型。（即不能归类到Class类的类型有泛型）
-
ParamerizedType：表示一种参数化类型，比如Collection
-
GenericArrayType:表示一种元素类型是参数化类型或者类型变量的数组类型
-
TypeVariable：是各种类型变量的公共父接口
-
WildcardType: 代表一种通配符类型表达式
六、通过反射操作注解
6.1 简单回顾ORM
了解什么是ORM？
Object relationship Mapping——》对象关系映射
class Person{
int id；
String name;
int age;
}
| id | name | age |
|---|---|---|
| 001 | 高兴 | 88 |
| 002 | 高一恒 | 5 |
-
类和表结构对应（类名和表名）
-
属性和字段对应
-
对象和记录对应
6.2 反射操作注解
很多框架都是通过反射读取注解的信息，hibernate的底层就是如此：
下面示例通过注解完成类和表的映射：
package com.happy;
import java.lang.annotation.*;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
public class ReflectionStudy6 {
public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, InstantiationException, IllegalAccessException, InvocationTargetException, NoSuchFieldException {
Class clazz = Class.forName("com.happy.ReflectionStudy6$Person");
// 通过反射获取注解
Annotation[] annotations = clazz.getAnnotations();
for (Annotation annotation : annotations) {
System.out.println(annotation);
}
// 获取注解value的值
TablePerson tablePerson = (TablePerson) clazz.getAnnotation(TablePerson.class);
System.out.println(tablePerson);
String value = tablePerson.value();
System.out.println(value);
// 获得类指定的注解
Field name = clazz.getDeclaredField("name");
TableField annotation = (TableField) name.getAnnotation(TableField.class);
String s = annotation.columnName();
System.out.println(s);
String s2 = annotation.type();
System.out.println(s2);
int s3 = annotation.length();
System.out.println(s3);
}
@TablePerson("db_Person")
class Person {
@TableField(columnName = "db_id", type = "int", length = 10)
private int id;
@TableField(columnName = "db_name", type = "varchar", length = 10)
private String name;
@TableField(columnName = "db_age", type = "int", length = 10)
private int age;
public Person() {
}
public Person(int id, String name, int age) {
this.id = id;
this.name = name;
this.age = age;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
@Override
public String toString() {
return "Person{" +
"id=" + id +
", name='" + name + '\'' +
", age=" + age +
'}';
}
}
// 类名的注解
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@interface TablePerson {
String value();
}
// 属性的的注解
@Target(ElementType.FIELD)
@Retention(RetentionPolicy.RUNTIME)
@interface TableField {
String columnName();
String type();
int length();
}
}
结果如下：
@com.happy.ReflectionStudy6$TablePerson(value=db_Person)
@com.happy.ReflectionStudy6$TablePerson(value=db_Person)
db_Person
db_name
varchar
10
