java 的反射机制

一：介绍

1.大纲

　　#1

　　允许程序在执行期间，调用反射API取得任何类的内部信息，并且可以直接操作任何对象的内部属性和方法。

 　　#2

　　学习反射，需要掌握的知识点：

　　　　*实例化class类

　　　　*获取类的完整结构

　　　　*通过反射调用类的属性和方法

　　　　*动态代理

2.涉及到的一些API

　　java.lang.Class                             类

　　java.lang.reflect.Field　　　 　   属性

　　java.lang.reflect.Method　　  　 方法

　　java.lang.reflect.Constructor　   构造器

二：简单反射的小示例（可以直接看后面的内容）

1.新建要反射的类Person

　　这个要被反射的类中不含有父类，接口，注解等额外的部分，只是一个特别简单的可以被用来反射的类，用来做演示。

package demo2;
public class Person1 {
    //这里为了说明反射，权限为public
    public String name;
    //这里为了说明反射，做对比，权限为private
    private int age;
    
    public Person1() {
        super();
    }
    public Person1(String name) {
        super();
        this.name = name;
    }
    public Person1(int age) {
        super();
        this.age = age;
    }
    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 "Person1 [name=" + name + ", age=" + age + "]";
    }
    //两个普通的方法
    //不带参数的函数
    public void show(){
        System.out.println("this is person class");
    }
    //带参数的函数
    public void diaplay(String nation){
        System.out.println("contry is "+nation);
    }
    
}

2.反射的测试

　　这个部分包括建立反射源

　　通过反射设置属性

　　通过反射调用方法函数

package demo2;

import java.lang.reflect.Field;
import java.lang.reflect.Method;

public class Test1 {

    public static void main(String[] args)throws Exception {
        reflectMethod();
    }
    public static void reflectMethod()throws Exception{
        //产生对应的类
        Class clazz=Person1.class;
        Person1 p=(Person1)clazz.newInstance();
        System.out.println(p);
        System.out.println("-------------------------");
        
        //设置public权限的属性
        Field f=clazz.getField("name");
        f.set(p, "zhangsan");
        System.out.println(p);
        System.out.println("-------------------------");
        
        //设置private权限的属性
        Field f1=clazz.getDeclaredField("age");
        f1.setAccessible(true);//增加访问权限
        f1.set(p, 90);
        System.out.println(p);
        System.out.println("-------------------------");
        
        //调用不带参数的函数方法
        Method m=clazz.getMethod("show");
        m.invoke(p);
        System.out.println("-------------------------");
        
        //调用带参数的函数方法
        Method m1=clazz.getMethod("diaplay",String.class);
        m1.invoke(p, "China");
    }
}

3.运行结果

　　

-----------------------------------------------------------------------------------------------#反射重点#---------------------------------------------------------------------------------------------------

三：实现Class类的四种实现方式（所有反射的基础源头---class类的获取）

1.介绍四种方式获取要反射类的class文件

　　*用运行时类本身的.class获取

　　*通过运行时类的对象的获取

　　*以class的静态方法获取

　　*通过类的加载器获取

2.程序

package demo2;

import org.junit.Test;

public class Test2 {
    @Test
    public void classMethod() throws ClassNotFoundException{
        //通过类的class文件
        Class c1=Person1.class;
        System.out.println(c1);
        
        //通过运行时类的对象获取class文件
        Person1 p=new Person1();
        Class c2=p.getClass();
        System.out.println(c2);
        
        //通过class的静态方法
        String name="demo2.Person1";
        Class c3=Class.forName(name);
        System.out.println(c3);
        
        //通过类的加载器获得class
        ClassLoader classLoader=this.getClass().getClassLoader();
        Class c4=classLoader.loadClass(name);
        System.out.println(c4);
    }

}

3.运行结果

　　结果看到：四种方式都可以获得class类。

　　

四：类的加载器（解释一下上面方式四中类的加载器，次要内容）

 1.介绍

　　

2.程序验证

package demo2;
import org.junit.Test;
public class Test3 {
    @Test
    public void show(){
        //systemClassLoader
        ClassLoader c1=ClassLoader.getSystemClassLoader();
        System.out.println(c1);
        
        //ExterSionClassLoader
        ClassLoader c2=c1.getParent();
        System.out.println(c2);
        
        //null(这一个类加载器不会被获取)
        ClassLoader c3=c2.getParent();
        System.out.println(c3);
        
    }
}

3.运行结果

　　

4.在方式四种使用的是哪一个加载器（程序验证）

package demo2;
import org.junit.Test;
public class Test4 {
    @Test
    public void method(){
        String name="demo2.Person1";
        ClassLoader classLoader=this.getClass().getClassLoader();
        System.out.println(classLoader);
    }
}

5.运行结果

　　

 五：创建运行时类对象（class文件的基础上）

1.要求

　　要反射的类中有空参的构造器（最好是这样）

　　构造器的权限为public

2.程序实现解释

package demo2;
public class Test5 {
    public static void main(String[] args)throws Exception {
        Class c=Person1.class;
        Object obj=c.newInstance();
        Person1 p=(Person1)obj;
        System.out.println(p);
    }
}

3.运行结果

　　

六：重新构建复杂的即将被反射的类

1.构建复杂的类对象

　　包含:

　　　　*父类

　　　　*多接口

　　　　*注解

　　　　*内部类

　　　　*异常

首先是父类：

package com.at.java;

public class Creature<T>{
    public double weight;
    public void breath(){
        System.out.println("呼吸");
    }
}

自定义接口：

package com.at.java;

import java.io.Serializable;
public interface MyInterface extends Serializable{

}

自定义注解：

package com.at.java;
import static java.lang.annotation.ElementType.CONSTRUCTOR;
import static java.lang.annotation.ElementType.FIELD;
import static java.lang.annotation.ElementType.LOCAL_VARIABLE;
import static java.lang.annotation.ElementType.METHOD;
import static java.lang.annotation.ElementType.PARAMETER;
import static java.lang.annotation.ElementType.TYPE;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Target({TYPE, FIELD, METHOD, PARAMETER, CONSTRUCTOR, LOCAL_VARIABLE})
@Retention(RetentionPolicy.RUNTIME)
public @interface MyAnnotation {
    String value();
}

反射的类：

package com.at.java;

@MyAnnotation(value = "atguigu")
public class Person extends Creature<String> implements Comparable,MyInterface{
    public String name;
    private int age;
    int id;
    public Person() {
        super();
    }
    public Person(String name) {
        super();
        this.name = name;
    }
    private Person(String name, int age) {
        super();
        this.name = name;
        this.age = age;
    }
    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;
    }
    
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    @MyAnnotation(value = "abc123")
    public void show(){
        System.out.println("this is person");
    }
    
    private Integer display(String nation,Integer i) throws Exception{
        System.out.println("国籍：" + nation);
        return i;
    }
    @Override
    public String toString() {
        return "Person [name=" + name + ", age=" + age + "]";
    }
    @Override
    public int compareTo(Object o) {
        // TODO Auto-generated method stub
        return 0;
    }
    
    public static void info(){
        System.out.println("信息");
    }
    
    class Bird{
        
    }
    
}

七：获取以及调用类的属性

　　包括：

　　　　*所有属性的获取

　　　　*指定属性的调用

1.获取对应类运行时的属性

　　包括两种;

　　　　*getFields():只能获取到运行时类中及其父类中声明为public的属性

　　　　*getDeclaredFields():获取运行时类本身声明的所有的属性

package com.at.java;
import java.lang.reflect.Field;
public class Test1 {
    public static void main(String[] args){
        get1();
        System.out.println("###################");
        get2();
    }
    /**
     * getFields():只能获取到运行时类中及其父类中声明为public的属性
     */
    public static void get1(){
        Class clazz=Person.class;
        Field[] f=clazz.getFields();
        for(int i=0;i<f.length;i++){
            System.out.println(f[i].getName());
        }
    }
    /**
     * getDeclaredFields():获取运行时类本身声明的所有的属性
     */
    public static void get2(){
        Class clazz=Person.class;
        Field[] f=clazz.getDeclaredFields();
        for(Field ff:f){
            System.out.println(ff.getName());
        }
    }
}

2.运行结果

　　使用###进行将两种方式进行隔离。

　　

3.获取对应类运行时的属性的各个部分的内容

　　主要包括：

　　　　*权限

　　　　*变量名

　　　　*变量名

package com.at.java;

import java.lang.reflect.Field;
import java.lang.reflect.Modifier;

public class Test2 {

    public static void main(String[] args) {
        get2();

    }
    /**
     * getDeclaredFields():获取运行时类本身声明的所有的属性的各个部分
     */
    public static void get2(){
        Class clazz=Person.class;
        Field[] f=clazz.getDeclaredFields();
        for(Field ff:f){
            //属性权限
            int num=ff.getModifiers();
            String str=Modifier.toString(num);
            System.out.print(str+"	");
            
            //属性类型
            Class type=ff.getType();
            System.out.print(type.getName()+"	");
            
            //属性变量名
            System.out.println(ff.getName());
        }
    }

}

4.运行结果

　　

5.调用设置指定属性

　　注意点事权限问题

package com.at.java;

import java.lang.reflect.Field;

public class Test6 {
    public static void main(String[] args)throws Exception {
        Class clazz=Person.class;
        /**
         * 属性权限为public
         */
        Field name = clazz.getField("name");
        Person p = (Person)clazz.newInstance();
        //将运行时类的指定的属性赋值
        name.set(p,"Jerry");
        System.out.println(p);
        //将运行时类的指定的属性赋值后再取出
        System.out.println("name="+name.get(p));
        
        System.out.println("########################");
        /**
         * 属性权限为private
         */
        Field age = clazz.getDeclaredField("age");
        age.setAccessible(true);//由于属性权限修饰符的限制，需要在操作前使得此属性可被操作。
        age.set(p,10);
        System.out.println(p);
        
        System.out.println("#######################");
        /**
         * 属性的权限为默认default
         * 这个set时不需要setAccessible(true)。
         */
        Field id = clazz.getDeclaredField("id");
        id.set(p,3);
        System.out.println(p);
    }
}

6.运行结果

　　

八：获取与调用对应类运行时的方法

　　包括两种：

　　　　*获取所有方法

　　　　*调用指定方法

1.获取对应类运行时的方法

 　　包括两种：

　　　　*getMethods():获取运行时类及其父类中所有的声明为public的方法

　　　　*getDeclaredMethods():获取运行时类本身声明的所有的方法

package com.at.java;
import java.lang.reflect.Method;
public class Test3 {
    public static void main(String[] args) {
        get1();
        System.out.println("#############");
        get2();
    }
    /**
     * getMethods():获取运行时类及其父类中所有的声明为public的方法
     */
    public static void get1(){
        Class clazz=Person.class;
        Method[] m=clazz.getMethods();
        for(Method mm: m){
            System.out.println(mm.getName());
        }
    }
    /**
     * getDeclaredMethods():获取运行时类本身声明的所有的方法
     */
    public static void get2(){
        Class clazz=Person.class;
        Method[] m=clazz.getDeclaredMethods();
        for(Method mm:m){
            System.out.println(mm.getName());
        }
    }
}

2.运行结果

　　

3.获取对应类运行时的方法的各个部分

　　包括：

　　　　*注解

　　　　*权限

　　　　*返回类型

　　　　*方法名

　　　　*参数列表

　　　　*异常类型

package com.at.java;

import java.lang.annotation.Annotation;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;

public class Test4 {

    public static void main(String[] args) {
        get2();
    }
    /**
     * 注解 权限修饰符 返回值类型 方法名 形参列表 异常
     */
    public static void get2(){
        Class clazz = Person.class;
        Method[] m2 = clazz.getDeclaredMethods();
        for(Method m : m2){
            //1.注解
            Annotation[] ann = m.getAnnotations();
            for(Annotation a : ann){
                System.out.println(a);
            }
            
            //2.权限修饰符
            String str = Modifier.toString(m.getModifiers());
            System.out.print(str + " ");
            
            //3.返回值类型
            Class returnType = m.getReturnType();
            System.out.print(returnType.getName() + " ");
            
            //4.方法名
            System.out.print(m.getName() + " ");
            
            //5.形参列表
            System.out.print("(");
            Class[] params = m.getParameterTypes();
            for(int i = 0;i < params.length;i++){
                System.out.print(params[i].getName() + " args-" + i + " ");
            }
            System.out.print(")");
            
            //6.异常类型
            Class[] exps = m.getExceptionTypes();
            if(exps.length != 0){
                System.out.print("throws ");
            }
            for(int i = 0;i < exps.length;i++){
                System.out.print(exps[i].getName() + " ");
            }
            System.out.println();
        }
    }
}

4.运行结果

　　

5.调用指定方法

package com.at.java;
import java.lang.reflect.Method;
public class Test7 {
    public static void main(String[] args) throws Exception{
        Class clazz = Person.class;
        Person p = (Person)clazz.newInstance();
        /**
         * public
         */
        Method m1 = clazz.getMethod("show");
        Object returnVal = m1.invoke(p);
        System.out.println(returnVal);    //因为返回值为void，所以打印为null
        
        Method m2 = clazz.getMethod("toString");
        Object returnVal1 = m2.invoke(p); //因为返回值为string，所以这样调用不会有什么现象
        System.out.println(returnVal1);   //没有现象，所以打印就是打印返回值
                
        /**
         * private
         * 同时，这是带参数的函数
         */
        Method m4 = clazz.getDeclaredMethod("display",String.class,Integer.class);
        m4.setAccessible(true);
        Object value = m4.invoke(p,"CHN",10);
        System.out.println(value);
        
        /**
         * static 方法，单独提出来
         */
        Method m3 = clazz.getMethod("info");
        m3.invoke(Person.class);
    }
}

6.运行结果

　　

 

九：获取构造器

　　包括：

　　　　*所有的构造器

　　　　*调用指定的构造器

1.获取所有的构造器

package com.at.java;
import java.lang.reflect.Constructor;
public class Test8 {
    public static void main(String[] args) throws Exception{
        String className = "com.at.java.Person";
        Class clazz = Class.forName(className);
        /**
         * 获取所有的构造器
         */
        Constructor[] cons = clazz.getDeclaredConstructors();
        for(Constructor c : cons){
            System.out.println(c);
        }
    }
}

2.运行结果

　　

3.调用指定的构造器

package com.at.java;
import java.lang.reflect.Constructor;
public class Test9 {
    public static void main(String[] args)throws Exception{
        String className = "com.at.java.Person";
        Class clazz = Class.forName(className);
        /**
         * 调用String，int的构造器
         */
        Constructor cons = clazz.getDeclaredConstructor(String.class,int.class);
        cons.setAccessible(true);
        Person p = (Person)cons.newInstance("罗伟",20);
        System.out.println(p);
    }
}

4.运行结果

 　　

十：获取其他的内容（父类，接口，注解，包，）

1.程序

package com.at.java;
import java.lang.annotation.Annotation;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import org.junit.Test;

public class Test10 {
    //6.获取注解
        @Test
        public void test6(){
            Class clazz = Person.class;
            Annotation[] anns = clazz.getAnnotations();
            for(Annotation a : anns){
                System.out.println(a);
            }
        }
        
        //5.获取所在的包
        @Test
        public void test5(){
            Class clazz = Person.class;
            Package pack = clazz.getPackage();
            System.out.println(pack);
        }
        
        //4.获取实现的接口
        @Test
        public void test4(){
            Class clazz = Person.class;
            Class[] interfaces = clazz.getInterfaces();
            for(Class i : interfaces){
                System.out.println(i);
            }
        }
        
        //3*.获取父类的泛型
        @Test
        public void test3(){
            Class clazz = Person.class;
            Type type1 = clazz.getGenericSuperclass();
            
            ParameterizedType param = (ParameterizedType)type1;
            Type[] ars = param.getActualTypeArguments();
            
            System.out.println(((Class)ars[0]).getName());
        }
        
        //2.获取带泛型的父类
        @Test
        public void test2(){
            Class clazz = Person.class;
            Type type1 = clazz.getGenericSuperclass();
            System.out.println(type1);
        }
        
        //1.获取运行时类的父类
        @Test
        public void test1(){
            Class clazz = Person.class;
            Class superClass = clazz.getSuperclass();
            System.out.println(superClass);
        }
}

2.运行结果

　　

十一：动态代理

1.静态代理

/**
 * 静态代理模式
 */
package com.at.java1;
//接口
interface ClothFactory{
    void productCloth();
}

//被代理类
class NikeClothFactory implements ClothFactory{
    @Override
    public void productCloth() {
        System.out.println("Nike");
    }    
    public void productCloth2() {
        System.out.println("Nike2");
    }
}

//代理类
class ProxyFactory implements ClothFactory{
    //引用
    ClothFactory cf;
    public ProxyFactory(ClothFactory cf){  //创建代理类的对象时，实际传入一个被代理类的对象
        this.cf = cf;
    }
    
    @Override
    public void productCloth() {
        System.out.println("一共$1000");
        cf.productCloth();                 //实际在代理类中执行的还是被代理类的方法
    }
    
}

public class TestClothProduct {
    public static void main(String[] args) {
        NikeClothFactory nike = new NikeClothFactory();
        ProxyFactory proxy = new ProxyFactory(nike);     //将被代理类传入代理类中
        proxy.productCloth();
    }
}

2.运行结果

　　

3.动态代理

/**
 * 动态代理
 */
package com.at.java1;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
//接口
interface Subject {
    void action();
}
//被代理类
class RealSubject implements Subject {
    public void action() {
        System.out.println("我是被代理类，记得要执行我哦！");
    }
}

//代理类
//动态代理都要实现接口InvocationHandler
class MyInvocationHandler implements InvocationHandler {
    Object obj;
    //①给被代理的对象实例化②返回一个代理类的对象
    public Object blind(Object obj) {
        this.obj = obj;
        return Proxy.newProxyInstance(obj.getClass().getClassLoader(), obj
                .getClass().getInterfaces(), this);
    }
    
    //当通过代理类的对象发起对被重写的方法的调用时，都会转换为对如下的invoke方法的调用
    @Override
    public Object invoke(Object proxy, Method method, Object[] args)throws Throwable {        
        Object returnVal = method.invoke(obj, args);
        return returnVal;
    }
}

public class TestProxy {
    public static void main(String[] args) {
        RealSubject real = new RealSubject();
        MyInvocationHandler handler = new MyInvocationHandler();
        //动态的返回一个同样实现了real所在类实现的接口Subject的代理类的对象。
        Object obj = handler.blind(real);
        Subject sub = (Subject)obj;
        sub.action();
    }
}

4.运行结果

　　

十二：动态代理与静态代理的区别

　　2017.12.21，今天查看了一下他们之间的区别，在这篇文章中解释的挺好的，就没有重新整理，直接粘贴一下链接。

　　http://blog.csdn.net/hejingyuan6/article/details/36203505。

　　在这篇文章中，这一段比我上面的程序写的更好理解：