java-反射-注解-json-xml

反射：

框架设计的灵魂

　　框架：半成品软件。可以再框架的基础上进行软件开发，简化代码

定义：将类的各个组成部分封装为其他对象，这就是反射机制

好处：

　　可以再程序运行过程中，操作这些对象

　　可以解耦，提高程序的可扩展性。

获取Class类对象

　　

对应第一阶段：Class.forName(全类名)：将字节码文件加载进内存，返回Class对象
对应第二阶段：类名.class:通过类名的属性class获取
对应第三阶段：对象.getClass():getClass()方法在Object类中定义

注意：同一个字节码文件（*.class）在一次程序运行过程中，只会被加载一次

　　　　无论通过哪一种方式获取的Class对象都是同一个

第一种方式：多用于配置文件，将类名定义在配置文件当中，读取文件，加载类
第二种方式：多用于参数的传递
第三种方式：多用于对象的获取字节码的方式

public class ReflectDEmo {
    /*
    获CLass对象方式：
    对应第一阶段：Class.forName(全类名)：将字节码文件加载进内存，返回Class对象
    对应第二阶段：类名.class:通过类名的属性class获取
    对应第三阶段：对象.getClass():getClass()方法在Object类中定义
     */

    public static void main(String[] args) throws ClassNotFoundException {
        Class cls1 = Class.forName("domain.Person");
        System.out.println(cls1);

        Class<Person> cls2 =Person.class;//ctrl+alt+V
        System.out.println(cls2);

        Person p = new Person();
        Class cls3 = p.getClass();
        System.out.println(cls3);

        // ==比较三个对象
        System.out.println(cls1 == cls2);//true
        System.out.println(cls1 == cls3);//true
    }
}

使用Class对象

　　

获取功能：
    获取成员变量们
          Field[] getFields() 返回包含一个数组 Field对象反射由此表示的类或接口的所有可访问的公共字段 
　　　　　　　　　　　　　　　　　　类对象
          Field getField(String name) 返回一个 Field对象，它反映此表示的类或接口的指定公共成员字段 
　　　　　　　　　　　　　　　　　　　　　　　　类对象。
          Field[] getDeclaredFields() 返回的数组 Field对象反映此表示的类或接口声明的所有字段 类对象。
          Field getDeclaredField(String name) 返回一个 Field对象，它反映此表示的类或接口的指定已
　　　　　　　　　　　　　　　　　　　　　　　　　　　　声明字段 类对象。 

    获取构造方法们
          Constructor<T> getConstructor(类<?>...parameterTypes) 返回一个 Constructor对象，
　　　　　　　　　　　　　　　　　　　　　　　　该对象反映 Constructor对象表示的类的指定的公共 类函数。
          Constructor<?>[] getConstructors() 返回包含一个数组 Constructor对象反射由此表示的类
　　　　　　　　　　　　　　　　　　　　　　　　　　　　的所有公共构造 类对象。
          Constructor<T> getDeclaredConstructor(类<?>... parameterTypes) 返回一个 Constructor
　　　　　　　　　　　　　　　　　　　　　　　　对象，该对象反映 Constructor对象表示的类或接口的指定 类函数。
Constructor<?>[] getDeclaredConstructors() 返回一个反映 Constructor对象表示的类声明的所有 
　　　　　　　　　　　　　　　　　　　　　　　　　　Constructor对象的数组 类 。

    获取成员方法们
　　　　　　Method getMethod(String name, 类<?>... parameterTypes) 返回一个 方法对象，它反映此表示
　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　的类或接口的指定公共成员方法 类对象。
　　　　　　Method[] getMethods() 返回包含一个数组 方法对象反射由此表示的类或接口的所有公共方法 类对象，
　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　包括那些由类或接口和那些从超类和超接口继承的声明。
　　　　　　Method getDeclaredMethod(String name, 类<?>... parameterTypes) 返回一个 方法对象，
　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　它反映此表示的类或接口的指定声明的方法 类对象。
　　　　　　Method[] getDeclaredMethods() 返回包含一个数组 方法对象反射的类或接口的所有声明的方法，
　　　　　　　　　　　　　　通过此表示 类对象，包括公共，保护，默认（包）访问和私有方法，但不包括继承的方法。 

    获取类名   
　　　　　　String getName() 返回由 类对象表示的实体（类，接口，数组类，原始类型或空白）的名称，
　　　　　　　　　　　　　　　　作为 String 。  

Field

　　获取到的成员变量可以进行get和set值

　　还可以设置忽略访问权限修饰符的安全检测

setAccessible(true);//忽略访问权限修饰符的安全检测,暴力反射

public class ReflectDemo2 {
    public static void main(String[] args) throws Exception {
        //获取Person的Class对象
        Class personClass = Person.class;
        //获取成员变量
        Field[] fieldsp = personClass.getFields();
        for (Field field : fieldsp) {
            System.out.println(field);
            //re:public int domain.Person.birtha
        }

        System.out.println("@@@@@@@@@@@@@@@");
        //获取成员变量，指定成员变量名
        Field fpbirth = personClass.getField("birtha");
        Person p = new Person();
        //获取值，需要指定实例对象名字
        Object value = fpbirth.get(p);
        System.out.println(value);//re: 0 因为没有设置值，所以默认0
        //设置值，需要指定实例名i在
        fpbirth.set(p,90);
        System.out.println(p);
        //re：Person{name='null', age=0, birtha=90, birthb=0, birthc=0, birthd=0}

        System.out.println("++++++++++++++++++++");
        //忽略成员变量修饰符，全部获取成员变量
        Field[] decaredFieadsp = personClass.getDeclaredFields();
        for (Field field : decaredFieadsp) {
            System.out.println(field);
        }
        //re:
        /*
        private java.lang.String domain.Person.name
        private int domain.Person.age
        public int domain.Person.birtha
        protected int domain.Person.birthb
        int domain.Person.birthc
        private int domain.Person.birthd
         */
        //忽略修饰符，指定名字获取变量
        Field field =personClass.getDeclaredField("birthd");
        field.setAccessible(true);//忽略访问权限修饰符的安全检测,暴力反射
        Object value2 = field.get(p);
        System.out.println(value2);//re: 0
    }
}

Constructor

　　创建对象

T	newInstance(Object... initargs) 使用此 Constructor对象表示的构造函数，使用指定的初始化参数来创建和初始化构造函数的声明类的新实例

　　　如果是使用无参创建对象，就可以直接使用Class类里面的：

　　

T	newInstance() 创建由此 类对象表示的类的新实例。

public class ReflectDemo3 {
    public static void main(String[] args) throws Exception {
        //获取Person的Class对象
        Class personClass = Person.class;

        //需要指定构造器的参数类型
        Constructor constructor =personClass.getConstructor(String.class,int.class);
        System.out.println(constructor);

        //创建对象
        Object person = constructor.newInstance("quan",23);
        System.out.println(person);

        System.out.println("############空参##############");
        Constructor constructorno =personClass.getConstructor();
        System.out.println(constructorno);

        //创建对象
        Object personno = constructorno.newInstance();
        System.out.println(personno);

        //使用Class类里面的方法，实例化无参对象
        Object noc = personClass.newInstance();
        System.out.println(noc);
    }
}

public domain.Person(java.lang.String,int)
Person{name='quan', age=23, birtha=0, birthb=0, birthc=0, birthd=0}
############空参##############
public domain.Person()
Person{name='null', age=0, birtha=0, birthb=0, birthc=0, birthd=0}
Person{name='null', age=0, birtha=0, birthb=0, birthc=0, birthd=0}

Method

public class ReflectDemo4 {
    public static void main(String[] args) throws Exception {
        //获取Person的Class对象
        Class personClass = Person.class;
        //获取指定的名称的方法
        Method eatmethon= personClass.getMethod("eat");
        Person p = new Person();
        eatmethon.invoke(p);//执行！！！！！！！！！
        //获取带参数的指定名称的方法
        Method eatmsg = personClass.getMethod("eat", String.class);
        eatmsg.invoke(p,"quanzhiqiang");//执行！！！！！！

        System.out.println("@@@@@@@@@@@@@@@@@@@@@@@@@@");
        Method[] all_methods = personClass.getMethods();
        for (Method all_method : all_methods) {
            System.out.println(all_method);//这里的方法会打印很多，因为是继承Object类
            System.out.println(all_method.getName());//获取方法名字String
        }

        //获取类名：
        String class_name = personClass.getName();
        System.out.println(class_name);//获取全类名

    }
}

result:

eatign
eatquanzhiqiang
@@@@@@@@@@@@@@@@@@@@@@@@@@
public java.lang.String domain.Person.toString()
toString
public java.lang.String domain.Person.getName()
getName
public void domain.Person.setName(java.lang.String)
setName
public int domain.Person.getAge()
getAge
public void domain.Person.setAge(int)
setAge
public void domain.Person.eat(java.lang.String)
eat
public void domain.Person.eat()
eat
public final void java.lang.Object.wait() throws java.lang.InterruptedException
wait
public final void java.lang.Object.wait(long,int) throws java.lang.InterruptedException
wait
public final native void java.lang.Object.wait(long) throws java.lang.InterruptedException
wait
public boolean java.lang.Object.equals(java.lang.Object)
equals
public native int java.lang.Object.hashCode()
hashCode
public final native java.lang.Class java.lang.Object.getClass()
getClass
public final native void java.lang.Object.notify()
notify
public final native void java.lang.Object.notifyAll()
notifyAll
domain.Person

反射的案例

需求：写一个“框架” ，不能改变该类的任何代码的前提下，
可以帮我们创建任意类的对象，并且之前其中的任意方法
    实现：
         11配置文件
         22反射
    步骤:
        1将需要拆改那就的对象的全类名和需要执行的方法定义在配置文件种
        2在程序种加载读取配置文件
        3使用反射技术来加载类文件进内存
        4创建对象
        5 执行方法

/*
框架类
 */
public class ReflectTest {
    public static void main(String[] args) throws Exception {
        //可以创建任意类的对象，可以执行任意方法

        /*
        不能改变框架的任何代码
        可以创建任意类的对象，可以执行任意方法
         */
//        Person p = new Person();
//        p.eat();
        //加载配置文件-创建propertiest对象
        Properties pro = new Properties();
        //加载配置文件-转换为一个集合
        //获取class目录下的配置文件
        ClassLoader classLoader = ReflectTest.class.getClassLoader();//通过反射获取类加载器
        //通过类加载器去按照path路径去以字节输入流加载配置文件
        InputStream is = classLoader.getResourceAsStream("reflect\\pro.properties");
        //使用properties类的load方法以字节输入流的形式获取数据
        pro.load(is);

        //获取配置文件种定义的数据
        String className = pro.getProperty("className");//通过getProperty指定变量名称去获取值
        String methodName = pro.getProperty("methodName");

        //加载该类进内存
        Class  cls = Class.forName(className);
        //创建对象
        Object o = cls.newInstance();
        //获取方法
        Method omethod = cls.getMethod(methodName);
        omethod.invoke(o);

    }
}

当配置文件是下面的时候：

结果：

eat...

配置文件的内容是：

结果为：

sleep...

涉及properties相关：https://www.cnblogs.com/java-quan/p/13160730.html