澳门新葡亰娱乐官网0033 Java学习笔记-反射-初步1

澳门新葡亰娱乐官网 1

反射可以解决在编译时无法预知对象和类是属于那个类的,要根据程序运行时的信息才能知道该对象和类的信息的问题。

一. 类的加载,连接,初始化

先看看通过反射能干嘛

  • 示例:修改对象的private实例变量

    package testpack;
    import java.lang.reflect.Field;
    public class Test1 {

    public static void main(String[] args)throws Exception{ 
        Person per=new Person("Java",21);
        System.out.println("现在的per对象是:"+per);   //[name= Java , age= 21 ]
    
        Class<Person> perClazz=Person.class;           //获取Person类的Class对象
    
        Field fName=perClazz.getDeclaredField("name"); //获取Person类的名为“name”的变量,即使是private修饰
        fName.setAccessible(true);                     //取消该变量的访问权限检查
        fName.set(per, "C++");                         //将per对象的name变量改为“C++”
    
        Field fAge=perClazz.getDeclaredField("age");
        fAge.setAccessible(true);
        fAge.set(per, 33);                             //将per对象的age变量改为“33”
    
        System.out.println("private的实例变量被修改了,还是那个per对象:"+per); //[name= C++ , age= 33 ]
    }
    

    }
    class Person{

    private int age;
    private String name;
    public Person(String n,int a){
        name=n;
        age=a;
    }
    public String toString(){
        return "[name= "+name+" , age= "+age+" ]";
    }
    

    }

  • 上面的示例中,虽然age和name被private修饰,但还是被修改了,那这岂不是很不安全,违背了封装的初衷?我也不知道

在两个人协作开发时,你只要知道对方的类名就可以进行初步的开发了。

  1.1. JVM和类

当调用Java命令运行某个Java程序时,该命令将会启动一个Java虚拟机进程。不管Java程序多么复杂,启动多少个线程,它们都处于该Java虚拟机进程里,都是使用同一个Java进程内存区。

JVM程序终止的方式:

  • 程序运行到最后正常结束
  • 程序运行到使用System.exit()或Runtime.getRuntime().exit()代码处结束程序
  • 程序执行过程中遇到未捕获的异常或错误而结束
  • 程序所在平台强制结束了JVM进程

JVM进程结束,该进程所在内存中的状态将会丢失

java.lang.class

  • 有一个类很特别,它是所有类的类,它就是java.lang.class
  • 要使用一个类的时候,类加载器找到并加载这个类,同时返回其Class对象;也就是说只要一个类被加载了,那么就一定存在它的Class对象
  • 如何获得一个类的Class对象?以String类为例
    • Class.forName(“java.lang.String”):用Class类的静态方法forName(“包名+类名”)来获取
    • String.class:通过调用一个类的class属性来获取
      • 一般用这种方式
      • 代码更安全。程序在编译阶段就可以检查要访问的Class对象是否存在。?不懂
      • 程序性能更好。因为无须调用方法。
    • String的实例.getClass():通过Object类的一个实例方法getClass()方法获取
  • 获取一个类的Class对象后,就可以调用其方法获得该对象和该类的真实信息了

获取类对象

  • Class.forName(String clazzName)静态方法
  • 调用类的class属性,Person.class返回的就是Person的class对象(推荐使用)
  • 调用某个对象的getClass()方法

具体使用还是要根据实际来选择,第一种方式是比较自由的,只要知道一个类名就可以了,其不会做该类是否存在的校验,第二种、第三种则会做校验

  1.2 类的加载

当程序主动使用某个类时,如果该类还未被加载到内存中,则系统会通过加载、连接、初始化三个步骤来对该类进行初始化。

类的加载时将该类的class文件读入内存,并为之创建一个java.lang.Class对象,也就是说,当程序使用任何类时,系统都会为之建立一个java.lang.Class对象。

系统中所有的类实际上也是实例,它们都是java.lang.Class的实例

类的加载通过JVM提供的类加载器完成,类加载器时程序运行的基础,JVM提供的类加载器被称为系统类加载器。除此之外,开发者可以通过继承ClassLoader基类来创建自己的类加载器。

通过使用不同的类加载器,可以从不同来源加载类的二进制数据,通常有如下几种来源。

  1. 从本地文件系统加载class文件,这是前面绝大部分实例程序的类加载方式
  2. 从jar包加载class文件,这种方式也是很常见的,jdbc编程所用的驱动类就放在jar文件中,JVM可以直接从jar文件中加载该class文件。
  3. 通过网络加载class文件
  4. 把一个Java源文件动态编译,并执行加载

类加载器通常无需等到首次使用该类时才加载该类,Java虚拟机规范允许系统预先加载某些类。

  1.3 类的连接

当类被加载后,系统会为之生成一个对应的Class对象,接着会进入连接阶段,连接阶段负责把类的二进制数据合并到JRE中。类的链接可分为如下三个阶段。

  1. 验证:验证阶段用于检验被加载的类是否有正确的内部结构,并和其他类协调一致
  2. 准备:类准备阶段则负责为类的类变量分配内存,并设置默认初始值
  3. 解释:将类的二进制数据中的变量进行符号引用替换成直接引用

  1.4 类的初始化

再累舒适化阶段,虚拟机负责对类进行初始化,主要就是对类变量进行初始化。在Java类中对类变量指定初始值有两种方式:①声明类变量时指定初始值;②使用静态初始化块为类变量指定初始值。

JVM初始化一个类包含如下步骤

  1. 加载并连接该类
  2. 先初始化其直接父类
  3. 依次执行初始化语句

当执行第2步时,系统对直接父类的初始化也遵循1~3,以此类推

Class主要方法

  • 构造器:以下用“para”代表Class<?>…parameterTypes,这是个数可变的形参列表
    • Constructor
      getConstructor(para):返回该Class对象对应类的、带指定形参的public构造器
    • Constructor<?>[]
      getConstructors():返回对应类的所有public构造器
    • Constructor
      getDeclaredConstructor(para):返回对应类的、带指定形参列表的构造器,不论是什么访问权限
    • Constructor<?>[]
      getDeclaredConstructors():返回对应类的所有构造器,不论访问权限
  • 方法:
    • Method getMethod(String
      name,para):返回对应类的、指定方法名、指定形参列表的public方法
    • Method[] getMethods():返回指定类的所有public方法
    • Method getDeclaredMethod(String
      name,para):返回对应类的、指定方法名、指定形参列表的方法,不论访问权限
    • Method[]
      getDeclaredMethods():返回对应类的所有方法,不论访问权限
  • 成员变量
    • Field getField(String
      name):返回对应类的、指定名称的public成员变量
    • Filed[] getFields():返回对应类的所有public成员变量
    • Field getDeclaredField(String
      name):返回对应类的、指定名称的成员变量,不论访问权限
    • Field[]
      getDeclaredFields():返回对应类的所有成员变量,不论访问权限
  • 注解
    • <A extends Annotation> A
      getAnnotation(Class<A>AnnotationClass):获取对应类的指定的注解,不存在则返回null
    • <A extends Annotation> A
      getDeclaredAnnotation(Class<A>AnnotationClass):获取直接修饰该对应类的、指定的注解,不存在则返回null
    • Annotation[] getAnnotations():返回对应类上的所有注解
    • Annotation[]
      getDeclaredAnnotations():返回直接修饰该对应类的所有注解
    • <A extends Annotation> A[]
      getAnnotationsByType(Class<A>AnnotationClass):针对重复注解功能,返回修饰该对应类的、指定类型的多个注解
    • <A extends Annotation> A[]
      getDeclaredAnnotationsByType(Class<A>AnnotationClass):针对重复注解功能,获取直接修饰对应类的、指定类型的注解
  • 内部类
    • Class<?>[]
      getDeclaredClasses():返回对应类里包含所有内部类
  • 外部类:
    • Class<?> getDeclaringClass():返回对应类的所在的外部类
  • 接口:
    • Class<?> getInterfaces():返回对应类所实现的所有接口
  • 父类:
    • Class<?super T>
      getSuperclass():返回对应来的父类的Class对象
  • 修饰符:
    • int
      getModifiers():返回对应类或接口的所有修饰符对应的常量,应使用Modifier工具类的方法解码,才能获得真实的修饰符
  • 所在包:
    • Package getPackage():获取对应类所在的包
  • 类名:
    • String getName():返回对应类的名称,全局限定名(即包含包名)
    • String getSimpleName():返回对应类的名称,不包含包名的类名
  • is方法
    • boolean isAnnotation:是不是注解类型
    • boolean isAnnotationPresent(Class<? extends Annotation>
      annotationClass):对应类是否使用了Annotation修饰
    • boolean isAnonymousClass():对应类是否是一个匿名类
    • boolean isArray():对应类是否是一个数组
    • boolean isEnum():对应类是否是一个枚举
    • boolean isInterface():对应类是否是一个接口
    • boolean isInstance(Object
      obj):判断该obj是不是对应类的实例,可以完全替代instanceof
  • 相关方法示例:以Strin类为例

    package testpack;

    import java.lang.annotation.Annotation;
    import java.lang.reflect.Constructor;
    import java.lang.reflect.Field;
    import java.lang.reflect.Method;

    public class Test1 {

    public static void main(String[] args)throws Exception{ 
        Class clazz=String.class;
    
        System.out.println("---------------------------------下面是String的成员变量部分---------------------------------");
        System.out.println("-----------所有的public成员变量-----------");
        Field[] pfs=clazz.getFields();
        for (Field f:pfs) {
            System.out.println(f);
        }
        System.out.println("-----------所有成员变量-----------");
        Field[] fs=clazz.getDeclaredFields();
        for (Field f:fs) {
            System.out.println(f);
        }
    
        System.out.println("---------------------------------下面是String的构造器部分---------------------------------");
        System.out.println("String的无参构造:"+clazz.getConstructor(null));
        System.out.println("String以byte[]为参数的构造器:"+clazz.getConstructor(byte[].class));
        System.out.println("String以StringBuffer为参数的构造器:"+clazz.getConstructor(StringBuffer.class));
        System.out.println("---------------所有构造器-----------------");
        Constructor[] cs=clazz.getDeclaredConstructors();
        for(Constructor c:cs){
            System.out.println(c);
        }
    
        System.out.println("---------------------------------下面是String的方法部分---------------------------------");
        System.out.println("String的名为intern的无参方法:"+clazz.getMethod("intern",null));
        System.out.println("String的名为valueOf的参数为int的方法:"+clazz.getMethod("valueOf",int.class));
        System.out.println("--------------所有方法--------------------");
        Method[] ms=clazz.getDeclaredMethods();
        for (Method m:ms) {
            System.out.println(m);
        }
        System.out.println();
    
        System.out.println("---------------------------------下面是String的注解部分---------------------------------");
        System.out.println("---------下面是String的所有注解---------------");
        Annotation[] as=clazz.getAnnotations();
        for (Annotation a:as) {
            System.out.println(a);                      //没有输出:因为String类没有注解(但String类内部的一些元素有注解)
        }
        System.out.println("---------------------------------下面是String的所有内部类---------------------------------");
        Class[] css=clazz.getDeclaredClasses();
        for (Class c:css) {
            System.out.println(c);
        }
        System.out.println("---------------------------------下面是String实现的所有接口---------------------------------");
        Class[] is=clazz.getInterfaces();
        for (Class i:is) {
            System.out.println(i);
        }
        System.out.println("---------------------------------其他---------------------------------");
        System.out.println("String的直接父类:"+clazz.getSuperclass());
        System.out.println("String的修饰符:"+clazz.getModifiers());
        System.out.println("String所在的包:"+clazz.getPackage());
        System.out.println("String的全局限定名:"+clazz.getName());
        System.out.println("String的类名:"+clazz.getSimpleName());
    }
    

    }

获取类的信息

  1.5 类初始化时机

当Java程序首次通过下面6种方式使用某个类或接口时,系统会初始化该类或接口

  • 创建类的实例。创建类的实例包括new操作符来创建实例,通过反射来创建实例,通过反射实例化创建实例
  • 调用某个类的类方法(静态方法)
  • 访问某个类或接口的类变量或为该类变量赋值
  • 使用反射方式来强制来创建某个类或接口的java.lang.Class对象。例如代码“Class.forname(“Person”)”,如果系统还未初始化Person类,则这行代码会导致Person类被初始化,并返回person类的java.lang.Class对象
  • 初始化某个类的子类
  • 使用java.exe命令来运行某个主类。当运行某个主类时,程序会初始化该主类

二. 类加载器

  2.1类加载器介绍

  类加载器负责将.class文件加载到内存中,并为之生成对应的java.lang.Class对象。

一个载入JVM的类有一个唯一的标识。在Java中,一个类使用全限定类名(包括包名和类名)作为标识;但在JVM中,一个类使用全限定类名和其类加载器作为唯一标识。

当JVM启动时,会形成由三个类加载器组成的初始类加载器层次结构

  • Bootstrap ClassLoader:跟类加载器
  • Extension ClassLoader:扩展类加载器
  • System ClassLoader:系统类加载器

Bootrap
ClassLoader被称为引导(也称为原始或跟)类加载器,它负责加载Java的核心类。跟类加载器不是java.lang.ClassLoader的子类,而是JVM自身实现的。

Extension
ClassLoader负责加载JRE拓展目录中的JAR包的类,它的父类加载器是跟类加载器

System
ClassLoader,它负责在JVM启动时加载来自Java命令的-classpath选项、java.class,path系统属性,或CLASSPATH指定的jar包和类历经。系统可通过ClassLoader的静态方法或区该系统类加载器。如果没有特别指定,则用户自定义的类加载器都已类加载器作为父加载器

关于参数的反射:since1.8

  • 构造方法和方法中包含形参列表,Java1.8增加了Parameter类来描述参数
  • 上面Class对象关于构造器和方法的返回值分别是:Constructor和Method,这两个类是Executable类的子类
  • Executable的主要方法有:
    • boolean isVarArgs():是否包含可变数量的形参
    • int getModifiers():获取修饰符
    • int getParameterCount():获取形参数量
    • Parameter[] getParameters():获取所有形参
  • Parameter的主要方法
    • int getModifiers():获取形参的修饰符
    • String getName():获取形参名
    • Type getParameterizedType():获取带泛型的形参类型
    • Class<?> getType():获取形参类型
    • boolean
      isNamePresent():所在类的class文件中是否包含了形参名信息;

      • 一般情况下,编译的时候都不包含形参名,除非加上“-parameters”选项
    • boolean isVarArgs():该参数是否为个数可变的形参
  • 见示例:

    package testpack;

    import java.lang.reflect.Constructor;
    import java.lang.reflect.Parameter;

    public class Test1 {

    public static void main(String[] args)throws Exception{ 
        Class clazz=String.class;
        Constructor c=clazz.getConstructor(byte[].class,int.class,int.class);
        System.out.println("该构造器的形参个数:"+c.getParameterCount());
        Parameter[] ps=c.getParameters();
        for (Parameter p:ps) {
            System.out.println("该参数是:"+p);
            System.out.println("该参数的修饰符:"+p.getModifiers());
            System.out.println("该参数的形参名:"+p.getName());
            System.out.println("形参类型:"+p.getType());
            System.out.println("是否有形参名信息:"+p.isNamePresent());
            System.out.println("是否是个数可变的形参:"+p.isVarArgs());
            System.out.println("--------------------------");
        }
    }
    

    }

获取类构造器

  • Connstructor<T> getConstructor(Class<?>...parameterTypes):返回此Class对象对应类的带指定形参的public构造器
  • Constructor<?>[] getConstructors():返回此Class对象对应类的所有public构造器
  • Constructor<T>[] getDeclaredConstructor(Class<?>...parameterTypes):返回此class对象对应类的带指定参数的构造器,与构造器的访问权限无关
  • Constructor<?>[] getDeclaredConstructors():返回此class对象对应类的所有构造器,与构造器的访问权限无关

  2.2 类加载机制

JVM类加载机制主要有三种

  • 全盘负责。就是当类加载器负责加载某个Class时,该Class所依赖的和所引用的其他Class也将由该类加载器负责载入,除非显式使用另外一个类加载器来载入
  • 父类委托。所谓父类委托,就是先让父类加载器试图加载该Class。只有在父类加载器无法加载该类时才尝试从自己的类路径中加载该类
  • 缓存机制。缓存机制将会保证所有加载过的Class都会被缓存,当程序需要使用时,先从缓存中搜索该Class,当缓存中不存在该Class,系统菜才读取该类对应的二进制数据,并将其转为Class对象,存入缓存区中。这就是为什么修改了Class后,必须重新启动JVM,程序所做的修改才会生效的原因。

类加载器加载Class大致经过8个步骤

  1. 检测此Class是否载入过(即缓存区中是否有此Class),如果有则直接进入第8步,否者接着第2步
  2. 如果父类加载器(父类      gt+
    加载器,要么Parent一定是跟类加载器,要么本身就是跟类加载器)不存在,则调到第4步执行
  3. 请求使用父类加载器载入目标类,如果成功载入调到第8步
  4. 请求使用跟类加载器来载入目标类
  5. 当前类加载器尝试寻找Class文件(从与此ClassLoader相关的类路径中寻找),如果找到则执行第6步,如果找不到执行第7步
  6. 从文件中载入Class,成功载入调到第8步
  7. 抛出ClassNotFoundException异常
  8. 返回对应的java.lang.Class对象

其中,第5、6步允许重写ClassLoader的findClass()方法来实现自己的载入策略,甚至重写loadClass()方法来实现自己的载入过程。

获取类成员方法

  • Method getMethod(String name,Class<?>...parameterTypes):返回此class对象对应类的带指定形参的public方法
  • Method[] getMethods():返回此class对象所表示的类的所有public方法
  • Method getDeclaredMethod(string name,Class<?>...parameterTypes):返回此class对象对应类的带指定形参的方法,与方法访问权限无关
  • Method[] getDeclaredMethods():返回此class对象对应类的全部方法,与方法的访问权限无关

  2.3 创建并使用自定义的类加载器

JVM除跟类加载器之外的所有类加载器都是ClassLoader子类的实例,开发者可以通过拓展ClassLoader的子类,并重写该ClassLoader所包含的方法实现自定义的类加载器。ClassLoader有如下两个关键方法。

  • loadClass(String name,boolean
    resolve):该方法为ClassLoader的入口点,根据指定名称来加载类,系统就是调用ClassLoader的该方法来获取指定类的class对象
  • findClass(String name):根据指定名称来查找类

如果需要是实现自定义的ClassLoader,则可以通过重写以上两个方法来实现,通常推荐重写findClass()方法而不是loadClass()方法。

classLoader()方法的执行步骤:

  1. findLoadedClass():来检查是否加载类,如果加载直接返回。
  2. 父类加载器上调用loadClass()方法。如果父类加载器为null,则使用跟类加载器加载。
  3. 调用findClass(String)方法查找类

从上面看出,重写findClass()方法可以避免覆盖默认类加载器的父类委托,缓冲机制两种策略;如果重写loadClass()方法,则实现逻辑更为复杂。

ClassLoader的一些方法:

  • Class defineClass(String name,byte[] b,int off,int
    len):负责将字节码分析成运行时数据结构,并检验有效性
  • findSystemClass(String name):从本地文件系统装入文件。
  • static getSystemClassLoader():返回系统类加载器
  • getParent():获取该类加载器的父类加载器
  • resolveClass(Class<?> c):链接指定的类
  • findClassLoader(String
    name):如果加载器加载了名为name的类,则返回该类对用的Class实例,否则返回null。该方法是类加载缓存机制的体现。

下面程序开发了一个自定义的ClassLoader。该classLoader通过重写findClass()方法来实现自定义的类加载机制。这个ClassLoader可以在加载类之前先编译该类的源文件,从而实现运行Java之前先编译该程序的目标,这样即可通过该classLoader运行Java源文件。

 

package com.gdut.basic;

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.lang.reflect.Method;

public class CompileClassLoader extends ClassLoader {
private byte[] getBytes(String fileName) {
    File file = new File(fileName);
    Long len = file.length();
    byte[] raw = new byte[(int)len];

        FileInputStream fin = new FileInputStream(file);
        //一次读取class文件的二进制数据
        int r = fin.read(raw);
        if(r != len) {
            throw new IOException("无法读取文件"+r+"!="+raw);


    return null;
        }
}
    private boolean compile(String javaFile) throws IOException {
        System.out.println("正在编译"+javaFile+"...");
        Process p = Runtime.getRuntime().exec("javac"+javaFile);
        try {
            //其他线程都等待这线程完成
            p.waitFor();
        }catch(InterruptedException ie) {
            System.out.println(ie);
        }
        int ret = p.exitValue();
        return ret == 0;
    }
    @Override
    protected Class<?> findClass(String name) throws ClassNotFoundException {
        Class clazz = null;
        String findStub = name.replace(".", "/");
        String javaFileName = findStub+".java";
        String classFileName = findStub+".class";
        File javaFile = new File(javaFileName);
        File classFile = new File(classFileName);

        //但指定Java源文件存在,class文件不存在,或者Java源文件的修改时间比class文件修改的时间更晚时,重新编译
        if(javaFile.exists() && classFile.exists()
                || javaFile.lastModified() > classFile.lastModified()) {
            try {
            if(!compile(javaFileName)|| !classFile.exists()) {
                throw new ClassNotFoundException("ClassNotFoundExcetion"+javaFileName);
            }
            }catch(IOException ie) {
                ie.printStackTrace();
            }
        }
        if(classFile.exists()) {

                byte[] raw = getBytes(classFileName);

                clazz = defineClass(name,raw,0,raw.length);
        }
        //如果clazz为null,表明加载失败,则抛出异常
        if(clazz == null) {
            throw new ClassNotFoundException(name);
        }
        return clazz;
    }

    public static void main(String[] args) throws Exception {
        //如果运行该程序时没有参数,即没有目标类
        if (args.length<1) {
            System.out.println("缺少目标类,请按如下格式运行Java源文件:");
            System.out.println("java CompileClassLoader ClassName");
        }

        //第一个参数是需要运行的类
        String progClass = args[0];

        //剩下的参数将作为运行目标类时的参数,将这些参数复制到一个新数组中
        String[] progArgs = new String[args.length - 1];
        System.arraycopy(args, 1,progArgs,0, progArgs.length);

        CompileClassLoader ccl = new CompileClassLoader();
        //加载需要运行的类
        Class<?> clazz = ccl.loadClass(progClass);
        //获取运行时的类的主方法
        Method main = clazz.getMethod("main", (new String[0]).getClass());
        Object argsArray[] = {progArgs};
        main.invoke(null, argsArray);

    }
}

接下来可以提供任意一个简单的主类,该主类无需编译就可以使用上面的CompileClassLoader来运行他

package com.gdut.basic;

public class Hello {

    public static void main(String[] args) {
        for(String arg:args) {
            System.out.println("运行Hello的参数:"+arg);
        }

    }

}

无需编译该Hello.java,可以直接运行下面命令来运行该Hello.java程序

java CompileClassLoader hello 疯狂Java讲义

运行结果如下:

CompileClassLoader:正常编译 Hello.java...
运行hello的参数:疯狂Java讲义

 

使用自定义的类加载器,可以实现如下功能

  1. 执行代码前自动验证数字签名
  2. 根据用户提供的密码解密代码,从而可以实现代码混淆器来避免反编译*.class文件
  3. 根据应用需求把其他数据以字节码的形式加载到应用中。

    2.4 URLClassLoader类

该类时系统类加载器和拓展类加载器的父类(此处的父类,是指类与类之间的的继承关系)。URLClassLoader功能比较强大,它可以从本地文件系统获取二进制文件来加载类,也可以从远程主机获取二进制文件加载类。

该类提供两个构造器

  • URLClassLoader(URL[]
    urls):使用默认的父类加载器创建一个ClassLoader对象,该对象将从urls所指定的路径来查询并加载类
  • URLClassLoader(URL[] urls,ClassLoader
    prarent):使用指定的父类加载器创建一个ClassLoader对象,该对象将从urls所指定的路径来查询并加载类。

下面程序示范了如何从文件系统中加载MySQL驱动,并使用该驱动获取数据库连接。通过这种方式来获取数据库连接,无需将MySQL驱动添加到CLASSPATH中。

package java.gdut;

import java.net.URL;
import java.net.URLClassLoader;
import java.sql.Connection;
import java.sql.Driver;
import java.util.Properties;

public class URLClassLoaderTest {
    private static Connection conn;

    public static Connection getConn(String url,String user,String pass)throws Exception{
        if(conn == null){
            URL[] urls = {new URL("file:mysql-connection-java-5.1.46-bin.jar")};
            URLClassLoader myClassLoader = new URLClassLoader(urls);
            //加载MySQL,并创建实例
            Driver driver = (Driver)myClassLoader.loadClass("com.mysql.jdbc.Driveer").newInstance();

            Properties properties = new Properties();
            properties.setProperty("user",user);
            properties.setProperty("pass",pass);
            //调用driver的connect方法来取得数据库连接
            conn = driver.connect(url,properties);
        }
        return conn;
    }

    public static void main(String[] args) throws Exception {
        System.out.println(getConn("jdbc:mysql://localhost:3306/tb_test","sherman","a123"));
    }
}

本程序类加载器的加载路径是当前路径下的mysql-connection-java-5.1.46-bin.jar文件,将MySQL驱动复制到该路径下,这样保证ClassLoader可以正常加载到驱动类

获取类成员变量

  • Field getField(String name):返回此class对象对应类的指定名称的public成员变量
  • Field[] getFields():返回此class对象对应类的所有public成员变量
  • Field getDeclaredField(String name):返回此class对象对应类的指定名称的成员变量,与成员变量访问权限无关
  • Field[] getDeclaredFields():返回此class对象对应类的全部成员变量,与成员变量的访问权限无关

三. 通过反射查看类信息

Java程序中的许多对象在运行时都会出现收到外部传入的一个对象,该对象编译时类型是Object,但程序又需要调用该对象运行时的方法。

  • 第一种做法是假设编译时和运行时都知道该对象的的类型的具体信息,这种情况下,可以先用instanceof()运算符进行判断,再利用强制类型转换将其转换成运行时类型的变量即可
  • 第二种做法是编译时根本无法知道该对象和类可能属于那些类,程序只依靠运行时信息来发现该对象和类的真实信息,这就必须使用反射

获取类注解

  • <A extends Annotation>A getAnnotation(Class<A>annotationClass):尝试获取该class对象对应类上村子的指定类型的Annotation,如果该类型注解不存在,则返回null
  • <A extends Annotation>A getDeclaredAnnotation(Class<A>annotationClass):这是Java
    8中新增的,该方法获取直接修饰该class对象对应类的指定类型的Annotation,如果不存在,则返回null
  • Annotation[] getAnnotations():返回修饰该class对象对应类上存在的所有Annotation
  • Annotation[] getDeclaredAnnotations():返回修饰该Class对象对应类上存在的所有Annotation
  • <A extends Annotation>A[] getAnnotationByType(Class<A>annotationClass):该方法的功能与前面介绍的getAnnotation()方法基本相似,但由于Java8增加了重复注解功能,因此需要使用该方法获取修饰该类的指定类型的多个Annotation
  • <A extends Annotation>A[] getDeclaredAnnotationByType(Class<A>annotationClass):该方法发功能与前面介绍的getDeclaredAnnotations()方法相似,也是因为Java8的重复注解的功能,需要使用该方法获取直接修饰该类的指定类型的多个Annotation

  3.1 获得class对象

每个类被加载后,系统会为该类生成一个对应的Class对象,通过该Class对象可以访问到JVM中的这个类。获得Class对象通常三种方式

  1. 使用Class类的forName(String
    clazz)静态方法。字符串参数传入全限定类名(必须添加包名),可能会抛出ClassNotFoundexception异常。
  2. 调用某个类的class属性来获取该类的的Class对象。
  3. 调用某个对象的getClass()方法,该方法是Object类的一个方法。

对于第一种方式,第二种的优势:

  • 代码更安全。程序在编译阶段就可以检查需要访问的Class对象是否存在。
  • 程序性能更好。这的种方式无需调用方法,所以性能更好。

获取该类内部类

  • Class<?>[] getDeclaredClasses():返回该class队形对应类里包含的全部内部类

  3.2 从Class中获取信息

Class类提供了大量的实例方法获取该Class对象所对应类的详细信息

下面4个方法用于获取Class对象对应类的构造器

  • ConStructor<T> getConStructor(Class<?>
    parameterTypes):返回Class对象对应类的,带指定参数列表的public构造器
  • ConStructor<?>[]
    getConStructor():返回此Class对象对应类的所有public构造器
  • ConStructor<T> getDeclaredConStructor(Class<?>…
    parameterTypes):返回此Class对象对应类的、带指定参数列表的构造器,与构造器的访问权限无关
  • ConStructor<?>[]
    getDeclaredConStructor():返回此Class对象对应类的所有构造器,与构造器的访问权限无关

下面四个方法获取Class对象对应类所包含方法。

  • Method getMethod(String name,Class<?>
    parameterTypes):返回Class对象对应类的,带指定形参列表的public方法
  • Method[] getMethods():返回Class对象对应类的所有public方法
  • Method getDeclaredMethod(String name,Class<?>
    parameterTypes):返回Class对象对应类的,带指定形参列表的方法,与访问权限无关
  • Method[]
    getDeclaredMethods():返回Class对象对应类的所有全部方法,与方法的访问权限无关

下面四个方法获取Class对象对应类所包含的成员变量。

  • Field getField(String
    name):返回Class对象对应类的,指定名称的public成员变量
  • Field[] getFIelds():返回Class对象对应类的所有public成员变量
  • Field getDeclaredField(String
    name):返回Class对象对应类的,指定名称的成员变量,与成员的访问权限无关
  • Field[]
    getFIelds():返回Class对象对应类的所有成员变量,与成员的访问权限无关

如下几个方法用于访问Class对应类的上所包含的Annotation.

  • <A extends Annotation>A getAnnotation(Class<A>
    annotationClass):尝试获取该Class对象对应类存在的,指定类型的Annotation;如果该类型的注解不存在,则返回null。
  • <A extends Annotation>A getDeclaredAnnotation(Class<A>
    annotationClass):Java
    8新增方法,尝试获取直接修饰该Class对象对应类存在的,指定类型的Annotation;如果该类型的注解不存在,则返回null。
  • Annotation[]
    getAnnotations():获取该Class对象对应类存在的所有Annotation
  • Annotation[]
    getDiclaredAnnotations():获取直接修饰该Class对象对应类存在的所有Annotation
  • <A extends Annotation>A[] getAnnotationByType(Class<A>
    annotationClass):由于Java
    8的新增了重复注解功能,因此需要使用该方法获取修饰该Class对象对应类,指定类型的多个Annotation
  • <A extends Annotation>A[]
    getDeclaredAnnotationByType(Class<A> annotationClass):由于Java
    8的新增了重复注解功能,因此需要使用该方法获取直接修饰该类的,指定类型的多个Annotation

如下方法用于访问Class对应类的内部类

  • Class<?>[]
    getDeclaredClass():返回该Class对象对应类里包含的内部类

如下方法用于访问Class对应类的所在的外部类

  • Class<?>[]
    getDeclaringClass():返回该Class对象对应类所在的外部类

如下方法用于访问Class对应类的所实现的接口

  • Class<?>[]
    getInterfaces():返回该Class对象对应类的所实现的接口

如下方法用于访问Class对应类的所继承的父类

  • Class<? super T>
    getSuperClass():返回该Class对象对应类的超类的Class对象

如下方法用于访问Class对应类的修饰符,所在包,类名等基本信息

  • int
    getModifiers():返回此类或接口的所有修饰符对应的常量,返回的整数需要Modifier工具类的方法来解码,才可以获取真正的修饰符
  • Package getPackage():获取此类的包
  • String getName():以字符串的形式返回该Class对象对应类的类名
  • String getSimpleName():以字符串的形式返回该Class对象对应类的简称

以下几个方法来判断该类是否为接口、枚举、注解类型

  • boolean
    isAnnotation():返回此Class对象是否表示一个注解类型(有@interface定义)
  • boolean isAnnotationPresent(Class<? extends
    Annotation>annotationClass):判断此Class对象是否使用了注解修饰
  • boolean isAnonymousClass():返回此Class对象是否为匿名类
  • boolean isArray():返回此Class对象是否为数组类
  • boolean isEnum():返回此Class对象是否为枚举类
  • boolean isInterface():返回此Class对象是否为接口
  • boolean isInstance(Object
    obj):判断obj是否为该Class对象的实例,该方法可以替代instanceof操作符

以上getMethod()方法和getConStructor()方法中,都需要传入多个类型为Class<?>的参数,用于获取指定的方法和构造器。要确定一个方法应该由方法名和形参列表确定。例如下面代码获取clazz对应类的带一个String参数的info方法:

clazz.getMethods("info",String.class)

  若要获取clazz对应类的带一个String参数,一个Integer参数的info方法

clazz.getMethods("info",String.class,Integer.class)

获取该类对象所在的外部类

  • Class<?> getDeclaringClass():返回该Class对象对应类所在的外部类

  3.3 Java 8新增加的方法参数反射

Java
8新增了一个Executable抽象基类,该对象代表可执行的类成员,该类派生了Constructor和Method两个子类。

Executable抽象基类提供了大量方法来获取修饰该方法或构造器的注解信息;还提供了is
VarArgs()方法用于判断该方法或构造器是否包含数量可变的形参,以及通过getModifiers()方法获取该方法或构造器的修饰符。除此之外,还提供如下两个方法

  • int getParameterCount():获取该构造器或方法的形参个数
  • Parameter[] getParameters():获取该构造器或方法的所有形参

Parameter类是Java
8新增的api,提供了大量方法来获取声明该方法或参数个数的泛型信息,还提供了如下方法获取参数信息

  • getModifiers():获取修饰该形参的修饰符
  • String getName():获取形参名
  • Type getParameterizedType():获取带泛型的形参类型
  • Class<?> getType():获取形参类型
  • boolean
    isNamePresent():该方法返回该类的class文件中是否包含了方法的形参名信息
  • boolean isVarArgs():判断该参数是否为个数可变的形参

需要指出的是,使用javac命令编译Java源文件时,默认生成的class文件并不包含方法的形参名信息,因此调用isNamePresent()将返回false,调用getName()也不能得到该参数的形参名。需要编译时保留形参信息,则需要该命令指定-parameter选项。

下面示范了Java 8的参数反射功能

public class MethodParameterTest {
    public static void main(String[] args) throws Exception {
        Class<Test> clazz = Test.class;
        Method replace = clazz.getMethod("replace",String.class,List.class);
        System.out.println("replace方法的参数个数为:"+replace.getParameterCount());

        Parameter[] parameters = replace.getParameters();
        int index = 1;
        for(Parameter parameter:parameters){
            if(!parameter.isNamePresent()){
                System.out.println("-----第"+index+"行的参数信息-----");
                System.out.println("参数名:"+parameter.getName());
                System.out.println("形参类型:"+parameter.getType());
                System.out.println("泛型类型:"+parameter.getParameterizedType());
            }
        }
    }
}

澳门新葡亰娱乐官网 1

获取该类对象对应类所实现的接口

  • Class<?>[] getInterfaces():返回该Class对象对应类所实现的全部接口

  3.4 利用反射生成并操作对象

Class对象可以获得该类的方法,构造器,成员变量。程序可以通过Method对象来执行对应的方法,通过ConStructor对象调用对应的构造器创建实例,能通过Field对象直接访问并修改对象的成员变量值。

获取该类对象对应类所继承的父类

  • Class<? super T> getSuperclass():返回该Class对象对应类的超类的Class对象

3.4.1 创建对象

通过反射生成对象有两种方式。

  • 使用Class对象的newInstance()方法来创建该Class对象对应类的实例,这种方式要求该Class对象的对应类有默认构造器。
  • 先使用Class对象获取指定的Constructor对象,在调用Constructor对象的newInstance()方法来创建该Class对象对应类的实例。

获取该类对象对应类的修饰符、所在包、类名等基本信息

  • int getModifiers():返回此类或接口的所有修饰符,修饰符由public、protected、private、final、static、abstract等对应的常量组成,返回的整数应使用Modifier工具类的方法来解码,才可以获取真是的修饰符
  • Package getPackage():获取该类的包
  • String getName():以字符串形式返回此CLass对象所表示的类的简称

3.4.2 调用方法

可以通过Class对象的getMethods()方法和getMethod()方法来获取全部方法和指定方法。

每个Method对象对应一个方法,可以通过它调用对应的方法,在Method里包含一个invoke()方法,该方法的签名如下。

  • Object invoke(Object obj,Object…
    args):该方法中的obj是执行该方法的主调,后面的args是执行该方法时传入该方法的实参。

下面程序是对象池工厂加强版,它允许在配置文件中增加配置对象的成员变量的值,对象池工厂会读取为该对象配置的成员变量值,并利用该对象的Setter方法设置成员变量的值。

package com.gdut.test0516;

import java.io.FileInputStream;
import java.io.IOException;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.Map;
import java.util.Properties;

public class ExtendedObjectPoolFactory {
    //定义一个对象池,前面是对象名,后面是实际对象
    private Map<String,Object> objectPool = new HashMap<>();
    private Properties config = new Properties();

    public void init(String fileName)
    {
        try(FileInputStream fis = new FileInputStream(fileName))
        {
            config.load(fis);
        }catch(IOException ex){
            System.out.println("读取"+fileName+"异常");
        }
    }

   private Object createObject(String clazzName)throws ClassNotFoundException,
           InstantiationException,IllegalAccessException{
        Class<?> clazz = Class.forName(clazzName);
        //使用clazz默认构造器创建实例
        return clazz.newInstance();
   }


   public void initPool()throws ClassNotFoundException,
           InstantiationException,IllegalAccessException{
       for (String name:config.stringPropertyNames())
       {
           //没取出一个key-value对。如果key中不包含百分号(%),即可认为该key用于
           // 控制调用对象的setter方法设置值,%前半为对象名字,后半控制setter方法名
       if( !name.contains("%")){
           objectPool.put(name,createObject(config.getProperty(name)));
       }
       }
   }
   public Object getObject(String name){
        return objectPool.get(name);
   }

   public void initProperty()throws NoSuchMethodException,
   IllegalAccessException,InvocationTargetException {
       for (String name:config.stringPropertyNames()) {
           if(name.contains("%")){
               String[] objAndProp = name.split("%");
               Object target = getObject(objAndProp[0]);
               String mtdName = "set"+objAndProp[1].substring(1);
               Class<?> targetClass = target.getClass();
               Method mtd = targetClass.getMethod(mtdName);
               mtd.invoke(target,config.getProperty(name));
           }
       }
   }

    public static void main(String[] args)throws Exception {
        ExtendedObjectPoolFactory epf = new ExtendedObjectPoolFactory();
        epf.init("com/gdut/test0516/extObj.txt");
        epf.initPool();
        epf.initProperty();
        System.out.println(epf.getObject("a"));
    }
}

判断该类是否为接口、枚举、注解类型

  • boolean isAnnotation():返回此class对象是否表示一个注解类型
  • boolean isAnnotationPresent(Class<? extends Annotation>annotationClass):判断此Class对象是否使用类Annotation修饰
  • boolean isAnonymousClass():返回此class对象是否是一个匿名类
  • boolean isArray():返回此class对象是否表示一个数组类
  • boolean isEnum():返回此class对象是否表示一个枚举
  • boolean isInterface():返回此class对象是否表示一个接口
  • boolean isInstance(Object obj):判断obj是否是此class对象的实例,该方法可以完全代替instanceof操作符

    public interface Colorable {

     public void value();
    

    }

    public class ClassInfo {

    public static void main(String[] args) throws NoSuchMethodException, SecurityException {
        Class<Colorable> cls=Colorable.class;
        System.out.println(cls.getMethod("value"));
        System.out.println(cls.isAnnotation());
        System.out.println(cls.isInterface());
    }
    

    }

结果

public abstract void com.em.Colorable.value()
false
true

  3.4.3 访问成员变量

通过Class对象的getFields()方法和getField()方法可以获取该类包含的所有成员变量和指定成员变量。Field提供如下方法读取或设置成员变量值

  • getXxx(Object
    obj):获取Object对象的成员变量值。此处的Xxx对应8种基本类型,如果该成员变量类型时引用类型,则取消get后面的Xxx。
  • setXxx(Object obj,Xxx
    val):将obj对象的该成员变量设置成val值。此处的Xxx对应8种基本类型,如果该成员变量类型时引用类型,则取消set后面的Xxx。

3.4.4 操作数组

在java.lang.reflect包下还提供了一个Array类,Array对象可以代表所有的数组。程序可以通过使用该类来创建数组,操作数组元素等。

Array提供如下方法

  • static Object newInstance(Class<?>ComponentType,int…
    length):创建一个具有指定的元素类型,指定维度的新数组
  • static xxx getXxx(Object array,int
    index):返回数组array的第index个元素。此处的xxx对应8种基本类型,如果数组元素是引用类型,则该方法变为get(Object
    array,int index)。
  • static void setXxx(Object array,int index,Object
    val):将数组array的第index个元素设置为val。此处的xxx对应8种基本类型,如果数组元素是引用类型,则该方法变为set(Object
    array,int index,Object val)。

 

Java8中新增的方法参数反射

  • int getParameterCount():获取该构造器或方法的形参个数
  • Parameter[] getParameters():获取该构造器或方法的所有形参
  • getModifiers():获取修饰该形参的修饰符
  • String getName():获取形参名
  • Type getParameterizedType():获取带泛型的形参类型
  • Class<?>getType():获取形参类型
  • boolean isNamePresent():该方法返回该类的class文件中是否包含了方法的形参名信息
  • boolean isVarArgs():该方法用于判断该参数是否为个数可变的形参

    public class Test {

    public void getInfo(String str,List<String>list){
        System.out.println("成功");
    }
    

    }

    public class ClassInfo {

    public static void main(String[] args) throws NoSuchMethodException, SecurityException {
        Class<Test> cls=Test.class;
        Method med=cls.getMethod("getInfo", String.class,List.class);
        System.out.println(med.getParameterCount());
        Parameter[] params=med.getParameters();
        System.out.println(params.length);
        for(Parameter par:params){
            System.out.println(par.getName());
            System.out.println(par.getType());
            System.out.println(par.getParameterizedType());
        }
    }
    

    }

结果

2
2
arg0
class java.lang.String
class java.lang.String
arg1
interface java.util.List
java.util.List<java.lang.String>

反射生成对象

  • 使用Class对象的newInstance()方法创建Class对象的实例,该方法要求要有默认构造器(比较常用)
  • 先使用Class对象获取指定的Constructor对象,在调用Constructor对象的newInstance()方法来创建该Class对象对应类的实例

反射调用方法

  • Object invoke(Object obj,Object...args):该方法中的obj是执行该方法的主调,后面的args是执行该方法时传入该方法的实参

    public class Test {

    public Test(String str) {
        System.out.println(str);
    }
    public void getInfo(String str){
        System.out.println(str);
    }
    

    }

    public class ClassInfo {

    public static void main(String[] args) throws Exception {
        Class<Test> cls=Test.class;
        Constructor<Test>construct=cls.getConstructor(String.class);
        Test test=construct.newInstance("初始化");
        Method med=cls.getMethod("getInfo", String.class);
        med.invoke(test, "调用方法成功");
    }
    

    }

结果

初始化
调用方法成功

接下来看官仔细看下面的栗子

public class Test {

    public Test(String str) {
        System.out.println(str);
    }
    //私有方法
    private void getInfo(String str){
        System.out.println(str);
    }
}

public class ClassInfo {

    public static void main(String[] args) throws Exception {
        Class<Test> cls=Test.class;
        Constructor<Test>construct=cls.getConstructor(String.class);
        Test test=construct.newInstance("初始化");
      //为啥使用这个方法呢?
        Method med=cls.getDeclaredMethod("getInfo", String.class);
      //为啥使用这个方法呢?
        med.setAccessible(true);
        med.invoke(test, "调用方法成功");
    }

}

结果

初始化
调用方法成功

setAccessible(boolean
flag):将值设为true,指示该Method在使用是应该取消Java语言的访问权限检查

访问成员变量值

  • getXxx(Object obj):获取obj对象的该成员变量的值。此处的Xxx对应8种基本类型,如果该成员变量的类型是引用类型的,则去掉Xxx部分
  • setXxx(Object obj,Xxx val):将obj对象的该成员变量设置为val值。此处的Xxx对应8中基本类型,如果该成员变量的类型是引用类型,则取消set后面的Xxx

以上两个方法可以方法所有的成员变量,包括private的私有成员变量

public class Test {
    private int num;

    public Test(String str) {
        System.out.println(str);
    }
    private void getInfo(String str){
        System.out.println(str);
    }
    public int getNum() {
        return num;
    }
    public void setNum(int num) {
        this.num = num;
    }

}

public class ClassInfo {

    public static void main(String[] args) throws Exception {
        Class<Test> cls=Test.class;
        Constructor<Test>construct=cls.getConstructor(String.class);
        Test test=construct.newInstance("初始化");
        Method med=cls.getDeclaredMethod("getInfo", String.class);
        med.setAccessible(true);
        med.invoke(test, "调用方法成功");
        Field fld=cls.getDeclaredField("num");
        fld.setAccessible(true);
        fld.setInt(test, 12);
        System.out.println(fld.getInt(test));
    }

}

结果

初始化
调用方法成功
12

操作数组

java.lang.reflect包下有一个Array类,其可以动态创建数组

static Object newInstance(Class<?>componentType,int...length):创建一个具有指定的元素类型、指定维度的新数组

static xxx getXxx(Object array,int index):返回array数组中第index个元素。其中xxx是各种基本数据类型,如果数组元素是引用类型,则该方法变为get()

static void setXxx(Object array,int index,xxx val):将array数组中低index
个元素的值设为val,其中xxx是各种基本数据类型,如果数组元素是引用类型,则该方法变为set()

public class ArrayInfo {

    public static void main(String[] args) {
        Object arrays=Array.newInstance(String.class, 3);
        Array.set(arrays, 0, "第一个");
        Array.set(arrays, 1, "第二个");
        Array.set(arrays, 2, "第三个");
        System.out.println(Array.get(arrays, 2));
    }
}
You can leave a response, or trackback from your own site.

Leave a Reply

网站地图xml地图