类的加载与反射

JVM和类

同一个JVM的所有线程、所有变量都处于同一个进程里，它们都使用该JVM进程的内存区。

JVM进程终止条件：

1、程序运行到最后正常结束

2、程序运行到使用System.exit()或Runtime.getRuntime().exit()代码处结束程序

3、程序执行过程中遇到未捕获的异常或错误而结束

4、程序所在平台强制结束了JVM进程

由上可知，当Java程序运行结束时，JVM进程结束，该进程在内存中的状态将会丢失。

类的加载

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

类加载指的是将类的class文件读入内存，并为之创建一个java.lang.Class对象，即当程序中使用任何类时，系统都会为之建立一个java.lang.Class对象

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

类的加载由类加载器完成，类加载通常由JVM提供。JVM提供的类加载器称为系统类加载器。

开发者可以通过继承ClassLoader基类来创建自己的类加载器

记载类的来源：

1、从本地文件系统加载class文件

2、从JAR包加载class文件

3、通过网络加载class文件

4、把一个Java源文件动态编译，并执行加载

Java虚拟机规范允许系统预先加载某些类

类的连接

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

（1）验证：验证阶段用于检验被加载的类是否有正确的内部结构，并和其他类协调一致

（2）准备：类准备阶段负责为类的变量分配内存，并设置默认的初始值

（3）解析：将类的二进制数据中的符号引用替换成直接引用

类的初始化

虚拟机负责对类进行初始化，主要对类变量进行初始化。

声明变量时指定初始值，静态初始化块都将被当成类的初始化语句，JVM会按这些语句在程序中的排列顺序依次执行它们。

package com.edu.ynu.java.learn.nio;

public class Test
{




    static
    {
//        使用静态初始化块为变量b指定初始值
        b = 6;
        System.out.println("---------------------------------");
    }
    static int a = 5;
    static int b = 9;
    static int c;
    public static void main(String[] args)
    {
        System.out.println(Test.b);
    }
}

按照初始化顺序上述的代码的执行结果为9;

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

1、假如这个类还没有被加载和连接，则程序先加载并连接该类

2、假如该类的直接父类还没有被初始化，则先初始化其直接父类

3、假如类中有初始化语句，则系统依次执行这些初始化语句

当执行第2步骤时，系统对直接父类的初始化步骤也遵循此步骤1~3;如果该直接父类又有直接父类，则系统再次重复这三个步骤，依次类推。

类初始化的时机

当java程序首次通过6种方式类使用某个类或接口时，系统就会初始化该类或接口

1、创建类的实例。为某个类创建实例的方式包括：使用new操作符来创建实例，通过反射来创建实例，通过序列化的方式来创建实例

2、通过某个类的方法（静态方法）

3、访问某个类或接口的类变量，或为该类变量赋值

4、使用反射方式来强制创建某个类或接口对应的java.lang.Class对象。例如：Class.forName("Person")

5、初始化某个类的子类。当初始化某个类的子类时，该子类的所有父类都会被初始化

6、直接使用java.exe命令来运行某个主类。当运行某个主类时，程序会先初始化该主类

注意：对于final型的类变量，如果该类变量的值在编译时就可以确定下来，那么这个变量相当于“宏变量”，Java编译器会在编译时直接把这个变量出现的地方替换成它的值，因此即使程序使用该静态变量，也不会导致该类的初始化。

反之，如果final修饰的类变量的值不能在编译时确定下来，则必须等到运行时才可以确定该类变量的值，如果通过该类来访问它的类变量，则会导致该类被初始化。

 //采用系统当前时间为static final类变量赋值

static final String compileConstant=System.currentTimeMillis()+""; 

  当使用ClassLoader类的loadClass()方法来加载某个类时，该方法只是加载该类，并不会执行该类的初始化。使用Class的forName()静态方法才会导致强制初始化该类

package com.edu.ynu.java.learn.reflect;

class Tester
{
    static
    {
        System.out.println("Tester类的静态初始化块...");
    }
}

public class ClassLoaderTest
{
    public static void main(String[] args)
    {
        ClassLoader classLoader = ClassLoader.getSystemClassLoader();
        //下面语句仅仅是加载Tester类
        try
        {
            classLoader.loadClass("com.edu.ynu.java.learn.reflect.Tester");
        } catch (ClassNotFoundException e)
        {
            e.printStackTrace();
        } finally
        {
        }
        System.out.println("系统加载Tester类");
//        下面语句才会初始化Tester类
        try
        {
            Class.forName("com.edu.ynu.java.learn.reflect.Tester");
        } catch (ClassNotFoundException e)
        {
            e.printStackTrace();
        }
    }
}

类加载器

类加载器负责将.class文件(可能在磁盘上，也可能在网络上)加载到内存上，并为之生成对应的java.lang.Class对象。

一个载入JVM的类也有一个唯一的标识，其包括你全限定类名和其类加载器作为其唯一标识。其中全限定类名(包括包名和类名)

例如，包名为pg,一个名为Person的类，类加载器ClassLoader的实例k1负责加载，其在JVM中表示为(Person、pg、k1)

意味着不同的加载器，加载同一个的类，他们所加载的类也是完全不同、互补兼容的

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

1、Bootstrap ClassLoader：根类加载器

2、Extension ClassLoader：拓展类加载器

3、System ClassLoader：系统类加载器

Bootstrap ClassLoader被称为引导（也称为原始或根）类加载器，它负责加载Java的核心类。在Sun的JVM中，当执行java.exe命令时，使用-Xbootclasspath选项或使用-D选项指定sun.boot.class.path系统属性值可以指定加载附加的类

package com.edu.ynu.java.learn.reflect;

import java.net.URL;

public class BootstrapTest
{
    public static void main(String[] args)
    {
        URL[] urls = sun.misc.Launcher.getBootstrapClassPath().getURLs();

        for (int i = 0; i < urls.length; i++)
        {
            System.out.println(urls[i].toExternalForm());
        }
    }
}

Extension Classloader被称为拓展类加载器，负责加载JRE的拓展目录（%JAVA_HOME%/jre/lib/ext或者由java.ext.dirs系统属性指定的目录）中JAR包的类。通过这种方式，就可以为Java拓展核心类以外的新功能，只要把自己开发的类打包成JAR文件然后放入JAVA_HOME/jre/lib/ext路径即可。

System Classloader被称为系统(也称为应用)类加载器，它负责在JVM启动时加载来自java命令的-classpath选项、java.class.path系统属性，或CLASSPATH环境变量所指定的JAR包和类路径。

程序可以通过ClassLoader的静态方法getSystemClassLoader()来获取系统类加载器。

如果没有特别指定，用户的自定义的类加载器都已此加载器为父类加载器。

类加载器的机制

1、全盘负责：当一个类加载器负责加载某个Class时，该Class所依赖的和引用的其他Class也将由该类加载器负载载入，除非显示使用另外一个类加载器来载入

2、父类委托。先让parent(父)类加载器试图加载该Class,只有在父类加载器无法加载该类时才尝试从自己路径中加载该类。

3、缓存机制：缓存机制将会保证所有的加载过的Class都会被缓存，当程序中需要使用某个Class时，类加载器先从缓存区中搜寻该Class,只有当缓存区中不存在该Class对象时，系统才会读取该类对应的二进制数据，并将其转换层Class对象，存入缓存区中。因此修改了Class后，必须重新启动JVM,程序所做的修改才会生效。

除了可以使用Java提供的类加载器之外，开发者还可以实现自己的类加载器

package com.edu.ynu.java.learn;

import java.io.IOException;
import java.net.URL;
import java.util.Enumeration;

public class ClassLoaderPropTest
{
    public static void main(String[] args)
    {
        ClassLoader systemLoader = ClassLoader.getSystemClassLoader();
        System.out.println("系统类加载器：" + systemLoader);
        /**
         * 获取系统类加载器的加载路径---通常由CLASSPATH环境变量指定
         * 如果操作系统没有指定CLASSPATH环境变量，则默认以当前路径作为系统类加载器路径
         */
        try
        {
            Enumeration<URL> em1 = systemLoader.getResources("");
            while (em1.hasMoreElements())
            {
                System.out.println(em1.nextElement());
            }
            ClassLoader extensionLader = systemLoader.getParent();
            System.out.println("拓展类加载器： " + extensionLader);
            System.out.println("拓展类加载器的加载路径：" + System.getProperty("java.ext.dirs"));
            System.out.println("拓展类加载器parent:" + extensionLader.getParent());
        } catch (IOException e)
        {
            e.printStackTrace();
        } finally
        {

        }

    }
}

程序运行的结果：

Connected to the target VM, address: '127.0.0.1:6420', transport: 'socket'
系统类加载器：sun.misc.Launcher$AppClassLoader@14dad5dc
file:/D:/development/developSpace/javaworkspace/JavaBase/java_learning/Excluded/production/java_learning/
拓展类加载器： sun.misc.Launcher$ExtClassLoader@3fb4f649
拓展类加载器的加载路径：D:\development\developTools\jdk1.8\jre\lib\ext;C:\WINDOWS\Sun\Java\lib\ext
拓展类加载器parent:null
Disconnected from the target VM, address: '127.0.0.1:6420', transport: 'socket'

由上面的运行结果可以看到，拓展类加载器的父加载器是null，并不是返回根类加载器，这是因为根类加载器并没有继承ClassLoader抽象类，所以拓展类加载器的getParent()方法返回null，但实际上，拓展类加载器的父类加载器是根类加载器，只是根类加载器并不是Java实现的，程序通常无须访问根类加载器，因此访问拓展类加载器的父类加载器时返回null.

从运行结果可以看出，系统类加载器是AppClassLoader的实例，拓展类加载器是ExtClassLoader的实例，实际上这两个类都是URLClassLoader类的实例

类加载器加载Class需要经过的步骤：

1、检查此Classs是否载入过(即在缓存区中是否有此Class)，如果有则直接进入第8步，否则接着执行第2步。

2、如果父类加载器不存在(如果没有父类加载器，则要么parent一定是根类加载器，要么本身就是根类加载器),则跳到第4步执行，如果父类加载器存在，则接着执行第3步。

3、请求使用父类加载器载入目标类，如果成功载入则跳到第8步，否则接着执行第5步

4、请求使用根类加载器来载入目标类，如果成功则跳到第8步，否则跳到第7步

5、当前类加载器蚕食寻找Class文件(从与此ClassLoader相关的类路径中寻找)，如果找到则执行第6步，如果找不到则跳转到第7步

6、从文件中载入Class,成功载入后跳到第8步

7、抛出ClassNotFoundException异常

8、返回对应的java.lang.Class对象

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

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

JVM中除根类加载器之外的所有类加载器都是ClassLoader子类的实例，开发者可以通过拓展ClassLoader的子类，并重写该ClassLoader所包含的方法来实现自定义的类加载器。

ClassLoader类重要的方法

> loadClass(String name,boolean resolve)：该方法为ClassLoader的入口点，根据指定名称来加载类，系统就是调用ClassLoader的该方法来获取指定类对应的Class对象

>findClasss(String name)：根据指定名称来查找类

需要实现自定义的ClassLoader，则可以通过重写上述的方法来来实现，推荐使用findClass()方法，而不是重写loadClass()方法。

loadClass()方法的执行步骤如下：

1、用findLoadedClass(String)来检查是佛已经加载类，如果已经加载则直接返回

2、在父类加载器上调用loadClass()方法。如果父类加载器为null，则使用根类加载器来加载

3、调用findClass(String)方法查找类

因此，如果重写loadClass()方法，则需要重写父类委托、缓冲机制两种策略，而重写findClass()方法可以避免上述步骤

Class defineClass(String name,byte[] b,int off,int len)，该方法负责将指定流泪的字节码文件(即Class文件，如Hello.class)读入自己数组byte[]中，并把它转换为Class对象，该字节码文件可以源于文件、网络等。该方法是final的，并且管理JVM的许多复杂的实现，它负责将字节码分析成运行时数据结构，并校验有效性等。

自定义的ClassLoader案例:

package com.edu.ynu.java.learn.reflect;

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

public class CompileClassLoader extends ClassLoader
{
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, IllegalAccessException
    {
        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);
    }

    private byte[] getBytes(String filename)
    {
        File file = new File(filename);
        long len = file.length();
        byte[] raw = new byte[(int) len];
        try (FileInputStream fin = new FileInputStream(file);)
        {
//            一次读取Class文件的全部二进制数
            int r = fin.read(raw);
            if (r != len)
            {
                throw new IOException("无法读取全部文件：" + r + "!=" + len);

            }
        } catch (FileNotFoundException e)
        {
            e.printStackTrace();
        } catch (IOException e)
        {
            e.printStackTrace();
        } finally
        {

        }
        return raw;
    }
    //重写ClassLoader的findClass方法

    //    定义编译指定Java文件的方法
    private boolean compile(String javaFile) throws IOException
    {
        System.out.println("CompileClassLoader:正在编译 " + javaFile + "...");
//        调用系统的javac命令
        Process p = Runtime.getRuntime().exec("javac " + javaFile);
        try
        {
            p.waitFor();
        } catch (InterruptedException e)
        {
            System.out.println(e);
            e.printStackTrace();
        }
        //获取javac线程的退出值
        int ret = p.exitValue();
//        返回编译是否成功
        return ret == 0;
    }

    @Override
    protected Class<?> findClass(String name) throws ClassNotFoundException
    {
        Class classs = null;
        //将包路径中的点(.)替换成斜线(/)
        String fileStub = name.replace(".", "/");
        String javaFilename = fileStub + ".java";
        String classFilename = fileStub + ".class";
        File javaFile = new File(javaFilename);
        File classFile = new File(classFilename);
        if ((javaFile.exists() && (!classFile.exists())) || (javaFile.lastModified() > classFile.lastModified()))
        {
            try
            {
                if (!compile(javaFilename) || !classFile.exists())
                {
                    throw new ClassNotFoundException("ClassNotFoundException" + javaFilename);
                }
            } catch (IOException e)
            {
                e.printStackTrace();
            }
        }
//        如果Class文件存在,系统负责将该文件转换成Class对象
        if (classFile.exists())
        {
            byte[] raw = getBytes(classFilename);
            classs = defineClass(name, raw, 0, raw.length);
        }
        if (classs == null)
        {
            throw new ClassNotFoundException(name);
        }
        return classs;
    }
}

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

1、执行代码前自动验证数字签名

2、根据用户提供的密码解密代码，从而可以实现代码混淆器来避免反编译*.class文件

3、根据用户需求来动态的加载类

4、根据应用需求把其他数据以字节码的形式加载到应用中

URLClassLoader类

Java为ClassLoader提供了一个URLClassLoader实现类，该类是系统系统类加载器和拓展类加载器的父类(此处的父类，就是指类与类之间的继承关系)

URLClassLoader既可以从本地文件系统获取二进制文件来加载类，也可以从远程主机获取二进制文件来加载类

在应用程序中可以直接使用URLClassLoader加载类，URLClassLoader类提供的构造器如下:

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

>URLClassLoader(URL[] urls,ClassLoader parent):使用指定的父类加载器创建一个ClassLoader对象,其他功能与前一个构造器相同

一旦得到了URLClassLoader对象之后，就可以调用该对象的loadClass()方法来加载指定类。

package com.edu.ynu.java.learn.reflect;

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

public class URLClassLoaderTest
{
    private static Connection conn;

    public static Connection getConn(String url, String user, String pass)
    {
        if (conn == null)
        {
            try
            {
                URL[] urls = {new URL("file:D:\\development\\developData\\ali-repository\\mysql\\mysql-connector-java\\5.1.39\\mysql-connector-java-5.1.39.jar")};
                URLClassLoader myurlClassLoader = new URLClassLoader(urls);
                Driver driver = (Driver) myurlClassLoader.loadClass("com.mysql.jdbc.Driver").newInstance();
                Properties properties = new Properties();
                properties.setProperty("user", user);
                properties.setProperty("password", pass);
                conn = driver.connect(url, properties);

            } catch (MalformedURLException e)
            {
                e.printStackTrace();
            } catch (IllegalAccessException e)
            {
                e.printStackTrace();
            } catch (InstantiationException e)
            {
                e.printStackTrace();
            } catch (ClassNotFoundException e)
            {
                e.printStackTrace();
            } catch (SQLException e)
            {
                e.printStackTrace();
            }
        }
        return conn;
    }

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

此处的URL可以以file:为前缀，表明从本地文件系统加载；可以以http:为前缀，表明从互联网通过HTTP 访问来加载;也可以以ftp:为前缀,表明从互联网通过FTP访问来加载

通过反射查看类信息

 JAVA程序中很多对象都会出现两种类型：编译时类型和运行时类型，例如：Person p=new Student();代码将会生成一个p变量该变量在编译时类型为Person，运行时类型为Student。另外还会存在程序在运行时接收到外部传入的一个对象，该对象的编译时类型是Object,但程序又需要调用该对象的运行时的类型的方法。

解决该问题的方法如下：

1、第一种做法是假设在编译时和运行时都知道类型的具体给信息。在这种情况下，可以先使用instanceof运算符进行判断，再利用强制类型转换将其转换成运行时类型的变量。

2、采用反射依靠运行时信息来发现该对象和类的真实信息。

获得Class对象

每个类被加载之后，系统就会为该类生成一个对应的Class对象，通过该Class对象接可以访问JVM中的这个类。Java程序中或的Class对象的方式：

》使用Class类的forName(String className)静态方法。该方法需要将传入字符串参数，该字符串参数为类的全限定类名(完整的报名)

》调用某个类的class属性类获取该类对应的Class对象。例如，Person.class将会返回Person类对应的Class对象

》调用某个对象额getClass()方法。

相比于第一种方法，第二种方式如下两种优势：

1、代码更安全。程序在编译阶段就可以检查需要访问的Class对象是否存在

2、程序性能更好。因为这种方式无须调用方法费，所以性能更好

因此，尽可能的使用第二种方式来获取指定类的Class对象

从Class中获取信息

Class类提供额大量的实例方法类获取该Class对象所对应的类的构造函数，方法，属性，类上包含的Annotation，内部类，实现的接口，继承的父类，修饰符、所在包、类名，也可以判断该类是否为接口，枚举，注解等

package com.edu.ynu.java.learn.reflect;

import java.lang.annotation.Annotation;
import java.lang.annotation.Repeatable;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.reflect.Constructor;
import java.lang.reflect.Method;
import java.util.Arrays;


//    定义可重复注解
@Repeatable(Annos.class)
@interface Anno
{
}

@Retention(value = RetentionPolicy.RUNTIME)
@interface Annos
{
    Anno[] value();
}

//    使用4个注解修改该类
@SuppressWarnings(value = "unchecked")
@Deprecated
//    使用重复注解修改该类
@Anno
@Anno
public class ClassTest
{
    private ClassTest()
    {

    }


    public ClassTest(String name)
    {
        System.out.println("执行有参宿的构造器");
    }

    public static void main(String[] args) throws NoSuchMethodException, ClassNotFoundException
    {
        Class<ClassTest> clazz = ClassTest.class;
        //获取该class对象所对应的类的全部构造器

        Constructor[] constructors = clazz.getDeclaredConstructors();
        System.out.println("ClassTest的全部构造器如下:");
        for (Constructor c : constructors)
        {
            System.out.println(c);
        }
//        获取该Class对象所对应类的全部public方法
        Method[] mtds = clazz.getMethods();
        System.out.println("ClassTest的全部public方法如下：");
        for (Method md : mtds)
        {
            System.out.println(md);
        }
//        获取该Class对象对应类的指定方法
        System.out.println("ClassTest里带一个字符串参数的info方法为：" + clazz.getMethod("info", String.class));
//        获取该Class对象所对应类的全部注解
        Annotation[] annotations = clazz.getAnnotations();
        System.out.println("ClassTest的全部Annotation如下：");
        for (Annotation annotation : annotations)
        {
            System.out.println(annotation);
        }
        System.out.println("该Class元素上的@SuppressWarnings注解为:" + Arrays.toString(clazz.getAnnotationsByType(SuppressWarnings.class)));
        System.out.println("该Class元素上的@Anno注解为:" + Arrays.toString(clazz.getAnnotationsByType(Anno.class)));
        //获取该Class对象所对应的类的全部内部类
        Class<?>[] inners = clazz.getDeclaredClasses();
        System.out.println("ClassTest的全部内部类如下:");
        for (Class c : inners)
        {
            System.out.println(c);
        }
//        使用Class.forName()方法加载ClassTest的Inner内部类
        Class inClazz = Class.forName("com.edu.ynu.java.learn.reflect.ClassTest$Inner");
//        通过getDeclaringClass()访问该类所在的外部类
        System.out.println("inClazz对应的外部类为:" + inClazz.getDeclaringClass());
        System.out.println("ClassTest的包为: " + clazz.getPackage());
        System.out.println("ClassTest的父类为: " + clazz.getSuperclass());
    }

    //    定义一个无参数的info方法
    public void info()
    {
        System.out.println("执行无参数的info方法");
    }

    //    定义一个有一个参数的info方法
    public void info(String str)
    {
        System.out.println("执行有参数的info方法" + ",其str参数值:" + str);
    }

    class Inner
    {

    }
}

值得指出的是:虽然定义的ClassTest类时使用了@SuppressWarning注解，但程序运行时无法分析出该类里包含的该注解，这是因为@SuppressWarnings使用了@Retention(value=SOURCE)修改，这表明@SupressWarings只能保存在源代码级别上，而通过ClassTest.class获取该类的运行时Class对象，所以程序无法访问到@SuppressWarning注解

对于只能在源代码上保留的注解，使用运行时获得的Class对象无法访问该注解

Java8新增的方法参数反射

Java 8在java.lang.reflect包下新增了一个Executable抽象基类，该对象代表可执行的类成员，该类派生了Constructor,Method两个子类

该类提供了如下方法：

1、isVarArgs()方法判断该方法或构造器是否包含数量可变的形参

2、getModifiers()方法获取该方法后构造器的修饰符

3、int getParameterCount()：获取该构造器或方法的形参个数

4、Parameter[] getParameters()：获取该构造器或方法的所有形参

Parameter是Java8中新加入的API，该类提供了大量方法来获取参数信息

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

package com.edu.ynu.java.learn.reflect;

import java.lang.reflect.Method;
import java.lang.reflect.Parameter;
import java.util.List;

class Test
{
    public void replace(String str, List<String> list)
    {

    }
}

public class MethodParameterTest
{
    public static void main(String[] args) throws NoSuchMethodException
    {
//     获取String类
        Class<Test> clazz = Test.class;
//        获取String类的带两个参数的replace()方法
        Method replace = clazz.getMethod("replace", String.class, List.class);
        System.out.println("replace方法参数个数: " + replace.getParameterCount());
        Parameter[] parameters = replace.getParameters();
        int index = 1;
        for (Parameter p : parameters)
        {
            if (p.isNamePresent())
            {
                System.out.println("---第" + index + "个参数信息---");
                System.out.println("参数名:" + p.getName());
                System.out.println("形参类型:" + p.getType());
                System.out.println("泛型类型：" + p.getParameterizedType());
            }
        }
    }
}

需要使用如下命令来编译该程序：

 javac -parameters -d . MethodParameterTest.java 

使用反射生成并操作对象

创建对象

1、使用class对象的newInstance()方法来创建Classs对象对应类的实例，执行newInstance()方法实际上是利用默认构造器来创建该类的实例

2、先使用Class对象获取指定的Constructor对象，再调用Constructor对象的newInstance()方法来创建该Class对象对应的类的实例。

示例程序

package com.edu.ynu.java.learn.reflect;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.util.HashMap;
import java.util.Map;
import java.util.Properties;

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

    public static void main(String[] args)
    {
        ObjectPoolFactory opf = new ObjectPoolFactory();
        opf.initPool("a.txt");
        System.out.println(opf.getObject("Date"));
        System.out.println(opf.getObject("JFrame"));
    }

    //    定义一个创建对象的方法，该方法只要传入一个字符串类名，程序可以根据该类名生成Java对象
    private Object createObject(String className) throws ClassNotFoundException, IllegalAccessException, InstantiationException
    {
        Class<?> clazz = Class.forName(className);
        return clazz.newInstance();
    }

    /**
     * 该方法根据指定来初始化对象池，它会根据配置文件来创建对象
     *
     * @param fileName
     */
    public void initPool(String fileName)
    {
        try (FileInputStream fis = new FileInputStream(fileName);)
        {
            Properties properties = new Properties();
            properties.load(fis);
            for (String name : properties.stringPropertyNames())
            {
//                每取出一个key-value对,就根据value创建一个对象，调用createObject()创建对象,并将对象添加到对象池中
                objectPool.put(name, createObject(properties.getProperty(name)));
            }
        } catch (FileNotFoundException e)
        {
            e.printStackTrace();
        } catch (IOException e)
        {
            System.out.println("读取" + fileName + "异常");
            e.printStackTrace();
        } catch (IllegalAccessException e)
        {
            e.printStackTrace();
        } catch (InstantiationException e)
        {
            e.printStackTrace();
        } catch (ClassNotFoundException e)
        {
            e.printStackTrace();
        }
    }

    public Object getObject(String name)
    {
//        从objectPool中取出指定name对应的对象
        return objectPool.get(name);
    }
}

其中a.txt文件配置如下：

 Date=java.util.Date

JFrame=javax.swing.JFrame 

Spring就是采用XML配置文件的方式，创建对象的

利用Constructor对象创建Java对象的步骤如下：

1、获取该类的Class对象

2、利用Class对象的getConstructor()方法来获取指定的构造器

3、调用Constructor的newInstance()方法来创建Java对象

程序案例：

package com.edu.ynu.java.learn.reflect;

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;

public class CreateJFrame
{
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException
    {
//        获取JFrame对应的Class对象
        Class<?> jframeClass = Class.forName("javax.swing.JFrame");
//        获取JFrame中带一个字符串参数的构造器
        Constructor constructor = jframeClass.getConstructor(String.class);
        Object object = constructor.newInstance("反射创建的窗口");
        System.out.println(object);
    }
}

调用方法

调用方法的步骤：

1、通过Class对象的getMethods()方法或者getMethod()方法来获取全部方法方法或指定的方法

2、通过Method对象的invoke()方法,实现方法调用

invoke()方法的签名如下：

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

package com.edu.ynu.java.learn.reflect;


import java.io.FileInputStream;
import java.io.FileNotFoundException;
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 static void main(String[] args) throws IllegalAccessException, ClassNotFoundException, InstantiationException, NoSuchMethodException, InvocationTargetException
    {
        ExtendedObjectPoolFactory eopf = new ExtendedObjectPoolFactory();
        eopf.init("extObj.txt");
        eopf.initPool();
        eopf.initProperty();
        System.out.println(eopf.getObject("a"));

    }

    //    从指定属性文件中初始化Properties对象
    public void init(String fileName)
    {
        try (FileInputStream fis = new FileInputStream(fileName))
        {
            config.load(fis);
        } catch (FileNotFoundException e)
        {
            e.printStackTrace();
        } catch (IOException e)
        {
            System.out.println("读取" + fileName + "异常");
            e.printStackTrace();
        }
    }

    //    定义一个创建对象的方法,该方法只要传入一个字符串类名，程序可以根据类名生成Java对象
    private Object createObject(String className) throws ClassNotFoundException, IllegalAccessException, InstantiationException
    {
//        根据字符串来获取对应的Class对象
        Class<?> classs = Class.forName(className);
//        使用clazz对应的类默认构造器创建实例
        return classs.newInstance();
    }

    public void initPool() throws IllegalAccessException, InstantiationException, ClassNotFoundException
    {
        for (String name : config.stringPropertyNames())
        {
//            每取出一个key-value对，如果key中不包含百分号(%),这就表明是根据value来创建一个对象
//            调用createObject创建对象,并将对象添加到对象池中
            if (!name.contains("%"))
            {
                objectPool.put(name, createObject(config.getProperty(name)));
            }
        }
    }

    //    该方法将会根据属性文件来调用指定对象的setter方法
    public void initProperty() throws NoSuchMethodException, InvocationTargetException, IllegalAccessException
    {
        for (String name : config.stringPropertyNames())
        {
            //每取出一对key-value对,如果key中包含百分号(%)即可认为该key用于控制调用对象的setter方法设置值
//            %前半为对象名,后半控制setter方法
            if (name.contains("%"))
            {
                String[] objAndProp = name.split("%");
//                取出调用setter方法的参数值
                Object target = getObject(objAndProp[0]);
//                获取setter方法名:set+"首字母大写"+剩下部分
                String mtdName = "set" + objAndProp[1].substring(0, 1).toUpperCase() + objAndProp[1].substring(1);
                Class<?> targetClass = target.getClass();
                Method method = targetClass.getMethod(mtdName, String.class);
                //通过Method的invoke方法执行setter方法，将config.getProperty(name)的值作为调用setter方法的参数
                method.invoke(target, config.getProperty(name));
            }
        }
    }

    public Object getObject(String name)
    {
//        从objectPool中取出指定的name对应的对象
        return objectPool.get(name);
    }
}

其中extObj.txt内容如下：

 a=javax.swing.JFrame

b=javax.swing.JLabel

a%title=Test_Title 

Spring框架就是通过这种方式将成员变量的以及依赖对象等都放在配置文件中进行管理的，从而是实现了较好的解耦，这也是Spring框架的IoC的秘密

当通过Method的invoke()方法来调用对应的方法时，Java会要求程序必须有调用该方法的权限。如果程序确实需要调用某个对象的private方法，则可以先调用Method对象的setAccessible()方法

setAccessible()方法签名如下：

1、setAccessible(boolean flag)：将Method对象的accessible设置为指定的布尔值。

      值为true，指示该Method在使用时应该取消Java语言的访问权限检查；

      值为false，则指示该Method在使用时要实施Java语言的访问权限检查

实际上，setAccessible()方法并不属于Method，而是属于它的父类AccessibleObject。因此Method、Constructor、Field都可调用该方法，从而实现通过反射来调用private方法、private构造器和private成员变量。

访问成员变值

通过Class对象的getFields()或getField()方法可以获得该类所包含的全部成员变量或指定成员变量

1、getXxx(Object obj):获取obj对象的该成员变量的值。此处的Xxx对应8中基本类型,如果该成员变量是引用类型,则取消get后面的Xxx。

2、setXxx(Object obj,Xxx val):将obj对象的该成员变量设置为val值。此处的Xxx对应8中基本类型,如果该成员变量是引用类型,则取消get后面的Xxx。

 

package com.edu.ynu.java.learn;

import java.lang.reflect.Field;

public class FieldTest
{
    public static void main(String[] args) throws NoSuchFieldException, IllegalAccessException, InstantiationException
    {
        //创建一个Person对象
//        Person p = new Person();
//        获取Person类对应的Class对象 通过下面两种方法都可以创建的Person对象
        Class<Person> personClass = Person.class;
        Person p = personClass.newInstance();
//        使用getDeeclaredField()方法表明可获取各种访问控制符的成员变量
        Field nameField = personClass.getDeclaredField("name");
//        设置通过反射访问该成员变量的是取消权限检查
        nameField.setAccessible(true);
//        通过set()方法为p对象的name成员变量的设置值
        nameField.set(p, "leo");

        Field ageField = personClass.getDeclaredField("age");
        ageField.setAccessible(true);
        ageField.set(p, 123);

        System.out.println(p);

    }
}

class Person
{
    private String name;
    private int age;

    @Override
    public String toString()
    {
        return "Person{" + "name='" + name + '\'' + ", age=" + age + '}';
    }


}

操作数组

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

package com.edu.ynu.java.learn.reflect;

import java.lang.reflect.Array;

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

        Object array = Array.newInstance(String.class, 10);
//        设置索引为5,6的值
        Array.set(array, 5, "java编程思想");
        Array.set(array, 7, "java并发编程的艺术");
//        依次取出array数组中index为5、6的元素的值
        Object book1 = Array.get(array, 5);
        Object book2 = Array.get(array, 7);

//        输出array数组中index为5,7的元素
        System.out.println(book1);
        System.out.println(book2);
    }
}

稍微复杂的Array创建的三维数组的案例

package com.edu.ynu.java.learn.reflect;

import java.lang.reflect.Array;

public class ArrayTest2
{
    public static void main(String[] args)
    {
        Object array = Array.newInstance(String.class, 3, 4, 10);
//        获取array数组中index为2的元素,该元素应该是二维数组
        Object arrObj = Array.get(array, 2);
        Array.set(arrObj, 2, new String[]{"Java编程思想", "Java并发编程的艺术", "Effective java", "简洁之道"});
//        获取arrObj数组中index为3的元素,该元素应该是一维数组
        Object anArray = Array.get(arrObj, 3);
        Array.set(anArray, 9, "疯狂的python讲义");
        String[][][] castArray = (String[][][]) array;
        System.out.println(castArray[2][3][9]);
        System.out.println(castArray[2][2][0]);
        System.out.println(castArray[2][2][1]);
        System.out.println(castArray[2][2][2]);
        System.out.println(castArray[2][2][3]);

    }
}

使用反射生成JDK动态代理

Proxy提供了用于创建动态代理类和代理对象的静态方法，它也是所有动态代理类的父类。如果在程序中为一个或多个接口动态地生成实现类，就可以使用Proxy来创建动态代理类;如果需要为一个或多个接口动态的创建实例。也可以使用Proxy来创建动态代理实例。

package com.edu.ynu.java.learn.reflect;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

interface Person
{
    void walk();

    void sayHello(String name);
}

class MyInvokationHandler implements InvocationHandler
{
    /**
     * 执行动态代理的所有方法时,都会白替换成执行如下的invoke方法
     *
     * @param proxy  代表动态代理对象
     * @param method 代表正在执行的方法
     * @param args   代表调用目标方法时传入的实参
     * @return
     * @throws Throwable
     */
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable
    {
        System.out.println("----正在执行的方法：" + method);
        if (args != null)
        {
            System.out.println("下面是执行该方法时传入的实参为：");
            for (Object val : args)
            {
                System.out.println(val);
            }
        }
        else
        {
            System.out.println("调用该方法没有实参！");
        }
        return null;
    }
}

public class ProxyTest
{
    public static void main(String[] args)
    {
//        创建一个InvocationHandler对象
        InvocationHandler handler = new MyInvokationHandler();
//        使用指定的InvocationHandler来生成一个动态代理对象
        Person person = (Person) Proxy.newProxyInstance(Person.class.getClassLoader(), new Class[]{Person.class}, handler);
//        调用动态代理对象的walk()和sayHello()方法
        person.walk();
        person.sayHello("飞科剃须刀");
    }
}

运行结果如下：

----正在执行的方法：public abstract void com.edu.ynu.java.learn.reflect.Person.walk()
调用该方法没有实参！
----正在执行的方法：public abstract void com.edu.ynu.java.learn.reflect.Person.sayHello(java.lang.String)
下面是执行该方法时传入的实参为：
飞科剃须刀

不管程序是执行代理对象的walk()方法，还是执行代理对象的sayHello()方法，实际上都是执行InvocationHandler对象的invoke()方法

动态代理和AOP

在实际软件开发中，通常会存在相同的代码段重复出现的情况，在这种情况下，通常有两种做法

1、将相同的代码段“复制”,"粘贴"方式贴到不同位置

2、将相同的代码段独立出来，然后在不同的地方调用的相同的代码段

对于第一种方式，存在如果需要更改的代码，则任何被粘贴的地方都需要修改

对于第二种方式，存在公共代码块脱离了，需要的代码的地方与代码公共的地方耦合了，

而最理想的效果是：方法既能执行公共代码块，同时又无须以硬编码的方式直接调用公共代码块，对于JDK中的动态代理方法能够达到如下效果

package com.edu.ynu.java.learn.Proxy;

public interface Dog
{
    //    info()方法声明
    void info();

    //    run()方法声明
    void run();
}

package com.edu.ynu.java.learn.Proxy;

public class GunDog implements Dog
{
    //实现info()方法,仅仅打印一个字符串
    @Override
    public void info()
    {
        System.out.println("我是一个猎狗");
    }

    //    实现run()方法
    @Override
    public void run()
    {
        System.out.println("我奔跑迅速");
    }
}

package com.edu.ynu.java.learn.Proxy;

public class DogUtil
{
    public void method1()
    {
        System.out.println("======模拟第一个通用方法=====");
    }

    public void method2()
    {
        System.out.println("=====模拟第二个通用方法======");
    }
}

package com.edu.ynu.java.learn.Proxy;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;

public class MyInvokationHandler implements InvocationHandler
{
    private Object target;

    public void setTarget(Object target)
    {
        this.target = target;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable
    {
        DogUtil du = new DogUtil();
        du.method1();
        System.out.println(proxy.getClass());
        Object result = method.invoke(target, args);
        du.method2();
        return result;
    }
}

package com.edu.ynu.java.learn.Proxy;

import java.lang.reflect.Proxy;

public class MyProxyFactory
{
    public static Object getProxy(Object target)
    {
        MyInvokationHandler handler = new MyInvokationHandler();
        handler.setTarget(target);
        return Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), handler);
    }
}

package com.edu.ynu.java.learn.Proxy;



public class Test
{
    public static void main(String[] args)
    {
        Dog target=new GunDog();
        Dog dog= (Dog)MyProxyFactory.getProxy(target);
        dog.info();
        dog.run();
    }
}

反射和泛型

从JDk 5以后，Java的Class类增加了泛型功能，从而允许使用泛型来限制Class类，例如，String.class的类型实际上是Class<String>。如果Class对应的类暂时未知，则使用Class<?>。通过在反射中使用泛型，可避免使用反射生成的对象需要强制类型转换

使用Class<T>泛型可以避免使用强制类型你给转换

ackage com.edu.ynu.java.learn.reflect;

public class CrazyitObjectFactory
{
    public static Object getInstance(String clsName)
    {
        try
        {
            Class cls = Class.forName(clsName);
            return cls.newInstance();
        } catch (ClassNotFoundException e)
        {
            e.printStackTrace();
        } catch (IllegalAccessException e)
        {
            e.printStackTrace();
        } catch (InstantiationException e)
        {
            e.printStackTrace();
        }
        return null;
    }
}

 获取实例后需要强制类型转换

Date d=(Date)Crazyit.getInstance("java.util.Date"); 

甚至出现如下代码：

 JFrame f=(JFrame)Crazyit.getInstance("java.util.Date"); 

如果将上面的CrazyitObjectFactory工厂类改写成泛型的Class,程序可以变为

package com.edu.ynu.java.learn.reflect;

import javax.swing.*;
import java.util.Date;

public class CrazyitObjectFactory2
{
    public static <T> T getInstance(Class<T> cls)
    {
        try
        {
            return cls.newInstance();
        } catch (InstantiationException e)
        {
            e.printStackTrace();
        } catch (IllegalAccessException e)
        {
            e.printStackTrace();
        }
        return null;
    }

    public static void main(String[] args)
    {
        //获取实例后无需类型转换
        Date d = CrazyitObjectFactory2.getInstance(Date.class);
        JFrame f = CrazyitObjectFactory2.getInstance(JFrame.class);
    }
}

示范泛型的优势，可以对Array的newInstance()方法进行包装

package com.edu.ynu.java.learn.reflect;

import java.lang.reflect.Array;

public class CrazyitArray
{
    public static <T> T[] newInstance(Class<T> compponentType, int length)
    {
        return (T[]) Array.newInstance(compponentType, length);
    }

    public static void main(String[] args)
    {
//        创建一维数组
        String[] arr = CrazyitArray.newInstance(String.class, 10);
//        创建二维数组
        int[][] intArr = CrazyitArray.newInstance(int[].class, 5);
        arr[5] = "疯狂Java讲义";
//        初始化二维数组
        intArr[1] = new int[]{23, 12};
        System.out.println(arr[5]);
        System.out.println(intArr[1][0]);
    }
}

使用反射来获取泛型信息

为了获得指定成员变量的泛型类型，应先使用如下方法来获取成员变量的泛型类型

 //获得成员变量f的泛型类型

Type gType=f.getGenericType(); 

然后将Type对象强制在类型转换为ParameterizedType对象，ParameterType代表被参数化的类型

package com.edu.ynu.java.learn.reflect;

import java.lang.reflect.Field;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.Map;

public class GenericTest
{
    private Map<String, Integer> score;

    public static void main(String[] args) throws NoSuchFieldException
    {
        Class<GenericTest> classs = GenericTest.class;
        Field field = classs.getDeclaredField("score");
//        直接使用getType()取出类型只对普通类型的成员变量有效
        Class<?> a = field.getType();
//        下面将看到仅输出java.util.Map
        System.out.println("score的类型是:" + a);
//        获取成员变量f的泛型类型
        Type gType = field.getGenericType();
//        如果gType类型是ParameterizedType对象
        if (gType instanceof ParameterizedType)
        {
//            强制类型转换
            ParameterizedType pType = (ParameterizedType) gType;
//            获取原始类型
            Type rType = pType.getRawType();
            System.out.println("原始类型是:" + rType);
//            取得泛型类型的泛型参数
            Type[] tArgs = pType.getActualTypeArguments();
            System.out.println("泛型信息是:");
            for (int i = 0; i < tArgs.length; i++)
            {
                System.out.println("第" + i + "个泛型类型是:" + tArgs[i]);
            }
        }
        else
        {
            System.out.println("获取泛型类型出错!");
        }
    }
}

Type也是java.lang.reflect包下的一个接口，该接口代表所有类型的公共高级接口，Class是Type接口的实现类。Type包括原始类型，参数化类型、数组类型、类型变量和基本类型。