Java反射和动态代理(详解)

1、反射

1.1 反射的概述

是在运行状态中,不用创建对象就能够调用任意一个类的所有属性和方法;

1.2 反射作用

反射都是从class字节码文件中获取的内容。

  • 获取class字节码文件的对象

  • 利用反射如何获取构造方法(创建对象)

  • 利用反射如何获取成员变量(赋值,获取值)

  • 利用反射如何获取成员方法(运行)

1.3 获取字节码文件对象的方式

  1. Class这个类里面的静态方法forName(“全类名”)(最常用)

  2. 通过class属性获取,一般更多的是当做参数进行传递

  3. 通过对象获取字节码文件对象,当我们已经有了这个类的对象时,才可以使用。

public class ReflectDemo {
    public static void main(String[] args) throws ClassNotFoundException {
        //1. 第一种方式
        //全类名 : 包名 + 类名
        Class clazz1 = Class.forName("com.ya.reflect.demo01.Student");

        //2. 第二种方式
        Class clazz2 = Student.class;

        //3.第三种方式
        Student s = new Student();
        Class clazz3 = s.getClass();

        System.out.println(clazz1 == clazz2);
        System.out.println(clazz2 == clazz3);
    }
}
 
  

1.4 字节码文件和字节码文件对象

java文件(源代码阶段):就是编写的java代码。

字节码文件(加载阶段):就是通过java文件编译之后的class文件(是在硬盘上真实存在的,用眼睛能看到的)

字节码文件对象(运行阶段):当class文件加载到内存之后,虚拟机自动创建出来的对象。这个对象里面至少包含了:构造方法,成员变量,成员方法。

反射获取的是字节码文件对象,这个对象在内存中是唯一的。

1.5 获取构造方法

规则:

  • get表示获取

  • Declared表示私有

  • 最后的s表示所有,复数形式

  • 如果当前获取到的是私有的,必须要临时修改访问权限setAccessible(true),否则无法使用

public class ReflectDemo {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException {

        //1.获取class字节码文件对象
        Class clazz = Class.forName("com.ya.reflect.demo02.Student");

        //2.获取构造方法
        // 2.1 返回所有公共构造方法对象的数组
        System.out.println("-----返回所有公共构造方法对象的数组----");
        Constructor[] con1 = clazz.getConstructors();
        for (Constructor con : con1) {
            System.out.println(con);
        }

        // 2.2 返回所有构造方法对象的数组
        System.out.println("-------返回所有构造方法对象的数组------");
        Constructor[] con2 = clazz.getDeclaredConstructors();
        for (Constructor con : con2) {
            System.out.println(con);

        }

        // 2.3 返回所有构造方法对象的数组
        System.out.println("-------返回单个公共构造方法对象------");
        Constructor con3 = clazz.getConstructor(String.class);
        System.out.println(con3);
        //2.4 获取指定的空参构造
        System.out.println("-------获取指定的空参构造------");
        Constructor con4 = clazz.getConstructor();
        System.out.println(con4);


        // 2.5 返回所有构造方法对象的数组
        System.out.println("-------返回单个构造方法对象------");
        Constructor con5 = clazz.getDeclaredConstructor(String.class,int.class);
        System.out.println(con5);


        System.out.println("-----获取构造方法的权限修饰符(返回整数)--------");
        // 返回的是整数,public 1,private 2,protected 4,abstract 1024
        int modifiers = con5.getModifiers();
        System.out.println(modifiers);

        System.out.println("-----获取构造方法的参数--------");
        Parameter[] parameters = con5.getParameters();
        for (Parameter parameter : parameters) {
            System.out.println(parameter);
        }

        System.out.println("--------创建对象-----------");
        //暴力反射:表示临时取消权限校验
        con5.setAccessible(true);   // 如果这个权限修饰符是私有的,就要取消权限校验
        Student stu = (Student) con5.newInstance("张三", 23);
        System.out.println(stu);
    }
}

1.6 获取构造方法并创建对象

public class ReflectDemo02 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException {
        
        //需求1:获取空参,并创建对象(所创建的对象的属性是默认值)
        //1.获取整体的字节码文件对象
        Class clazz = Class.forName("com.ya.reflect.demo02.Student");
        //2.获取空参的构造方法
        Constructor con = clazz.getConstructor();
        //3.利用空参构造方法创建对象
        Student stu = (Student) con.newInstance();
        System.out.println(stu);

        System.out.println("----------------------------------");

        //需求2:获取带参构造,并创建对象
        //1.获取整体的字节码文件对象
        Class clazz2 = Class.forName("com.ya.reflect.demo02.Student");
        //2.获取有参构造方法
        Constructor con2 = clazz2.getDeclaredConstructor(String.class, int.class);
        //3.临时修改构造方法的访问权限(暴力反射)
        con2.setAccessible(true);
        //4.直接创建对象
        Student stu2 = (Student) con2.newInstance("zhangsan", 23);
        System.out.println(stu2);
    }
}

1.7 获取成员变量并获取值和修改值

public class ReflectDemo {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException, IllegalAccessException {
        //1.获取class字节码文件的对象
        Class clazz = Class.forName("com.ya.reflect.demo03.Student");
        //2.获取所有的成员变量
        System.out.println("-----获取所有的成员变量----");
        Field[] fields = clazz.getDeclaredFields();
        for (Field field : fields) {
            System.out.println(field);
        }
        //3.获取单个的成员变量
        System.out.println("-----获取单个的成员变量----");
        Field fieldName = clazz.getDeclaredField("name");
        System.out.println(fieldName);
        System.out.println("-----获取成员变量的数据类型----");
        Class type = fieldName.getType();
        System.out.println(type);
        System.out.println("-----获取成员变量记录的值----");
        Student student = new Student("zhangsan", 23, "男");
        fieldName.setAccessible(true);
        String value = (String) fieldName.get(student);
        System.out.println(value);
        System.out.println("-----修改对象里面记录的值---");
        fieldName.set(student,"lisi");
        System.out.println(student);
    }
}

1.8 获取成员方法

public class ReflectDemo {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException {
       
        //1. 获取class字节码文件对象
        Class clazz = Class.forName("com.ya.reflect.demo04.Student");

        //2. 获取里面所有的方法对象(包含父类中所有的公共方法)
        System.out.println("-------获取里面所有的方法对象(包含父类中所有的公共方法)-----");
        Method[] methods = clazz.getMethods();
        for (Method method : methods) {
            System.out.println(method);
        }
        // 3. 获取里面所有的方法对象(不能获取父类的,但是可以获取本类中私有的方法)
        System.out.println("--获取里面所有的方法对象(不能获取父类的,但是可以获取本类中私有的方法)--");
        Method[] declaredMethods = clazz.getDeclaredMethods();
        for (Method declaredMethod : declaredMethods) {
            System.out.println(declaredMethod);
        }
        // 4.获取指定的单一方法
        System.out.println("-------获取指定的单一方法-----");
        Method eatMethod = clazz.getDeclaredMethod("eat", String.class);
        System.out.println(eatMethod);

        // 5.获取方法的修饰符(返回整数)
        System.out.println("-------获取方法的修饰符(返回整数)-----");
        int modifiers = eatMethod.getModifiers();
        System.out.println(modifiers);

        // 6.获取方法的名字
        System.out.println("-------获取方法的名字-----");
        String eatMethodName = eatMethod.getName();
        System.out.println(eatMethodName);

        // 7.获取方法的形参
        System.out.println("-------获取方法的形参-----");
        Parameter[] parameters = eatMethod.getParameters();
        for (Parameter parameter : parameters) {
            System.out.println(parameter);
        }

        //8.获取方法的抛出的异常
        System.out.println("-------获取方法的抛出的异常-----");
        Class[] exceptionTypes = eatMethod.getExceptionTypes();
        for (Class exceptionType : exceptionTypes) {
            System.out.println(exceptionType);
        }
    }
}

1.9 获取成员方法并运行

public class ReflectDemo {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, InvocationTargetException, IllegalAccessException {
        //1. 获取class字节码文件对象
        Class clazz = Class.forName("com.ya.reflect.demo04.Student");
        //2. 获取指定的单一方法
        Method eatMethod = clazz.getDeclaredMethod("eat", String.class); 
        // 3. 方法运行
        System.out.println("-------方法运行-----");
        Student student = new Student();
        eatMethod.setAccessible(true);
        String result = (String) eatMethod.invoke(student, "汉堡包");
        System.out.println(result);
    }
}

2. 动态代理

2.1 动态代理好处

无侵入式的给方法增强功能。调用者(BitStar)–>代理(ProxyUtil)–>对象(Star)

2.2 动态代理三要素

  • 接口:代理对象,被代理类和代理类都需要实现这个接口(本例是Star)

  • 代理类:通过Proxy类动态生成的代理类(本例是ProxyUtil)

  • 被代理类:代理类实例,它会代替被代理对象处理方法调用(本例是BigStar)

注:代理可以增强或者拦截的方法都在接口中,接口需要写在newProxyInstance的第二个参数里。

2.3 动态代理简单实现

//代理对象
public interface Star {
	//可以把所有想要被代理的方法定义在接口当中
    //唱歌
    public abstract String sing(String name);
    //跳舞
    public abstract void dance();
}
//被代理类
public class BigStar implements Star{
    private String name;

    public BigStar() {
    }
    public BigStar(String name) {
        this.name = name;
    }
    //唱歌
    @Override
    public String sing(String name){
        System.out.println(this.name + "正在唱" + name);
        return "谢谢";
    }
    //跳舞
    @Override
    public void dance(){
        System.out.println(this.name + "正在跳舞");
    }
    
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String toString() {
        return "BigStar{name = " + name + "}";
    }
}


//代理类
// 创建代理   java.lang.reflect.Proxy类:提供了为对象产生代理对象的方法
public static Object newProxyInstance(ClassLoader loader, Class[] interfaces, InvocationHandler h)
参数一:用于指定用哪个类加载器,去加载生成的代理类
参数二:指定接口,这些接口用于指定生成的代理有哪些方法
参数三:用来指定生成的代理对象要干什么事情
   
public class ProxyUtil {

    /**
     *  形参:被代理的明星对象
     *  返回值:给明星创建的代理
     */
    public static Star createProxy(BigStar bigStar){
        // 创建代理
        // 这个代码没有显示实现Star接口,但通过 JDK动态代理机制 隐式地为生成的代理类添加了Star接口的实现,从而可以看作实现了Star接口
        Star star = (Star) Proxy.newProxyInstance(
                ProxyUtil.class.getClassLoader(),//参数一:用于指定用哪个类加载器,去加载生成的代理类
                new Class[]{Star.class},//参数二:指定接口,这些接口用于指定生成的代理有哪些方法
                new InvocationHandler() {	//参数三:用来指定生成的代理对象要干什么事情
                    @Override
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        /**
                         * 参数一:代理的对象,即star变量引用的对象
                         * 参数二:要运行的方法,sing,dance
                         * 参数三:调用sing方法时,传递的实参
                         */
                        if("sing".equals(method.getName())){
                            System.out.println("准备话筒,收钱");
                        }else if("dance".equals(method.getName())){
                            System.out.println("准备场地,收钱");
                        }
                        //去找大明星开始唱歌或者跳舞
                        //代码的表现形式:调用大明星里面唱歌或者跳舞的方法
                        return method.invoke(bigStar,args);
                    }
                }
        );
        return star;
    }
}

//代理测试
public class Test {
    public static void main(String[] args) {
        //1. 获取代理的对象
        BigStar bigStar = new BigStar("鸡哥");
        Star proxy = ProxyUtil.createProxy(bigStar);

        //2. 调用唱歌的方法
        String result = proxy.sing("只因你太美");
        System.out.println(result);
    }
}

2.4 动态代理扩展

动态代理,还可以拦截方法。比如:在这个故事中,经纪人作为代理,如果别人让邀请大明星去唱歌,打篮球,经纪人就增强功能。但是如果别人让大明星去扫厕所,经纪人就要拦截,不会去调用大明星的方法。

public class ProxyUtil {
    public static Star createProxy(BigStar bigStar){
        public static Object newProxyInstance(ClassLoader loader, Class[] interfaces, InvocationHandler h)
        Star star = (Star) Proxy.newProxyInstance(
                ProxyUtil.class.getClassLoader(),
                new Class[]{Star.class},
                new InvocationHandler() {
                    @Override
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        if("cleanWC".equals(method.getName())){
                            System.out.println("拦截,不调用大明星的方法");
                            return null;
                        }
                        //如果是其他方法,正常执行
                        return method.invoke(bigStar,args);
                    }
                }
        );
        return star;
    }
}

你可能感兴趣的:(java,开发语言)