挂羊头卖狗肉--代理的二三事

反射

提到反射就不得不说类加载的过程，在Java代码运行的过程中，并不是只有new对象一种方式；

类加载

类加载的过程

作用：将.class文件加载到虚拟机中的过程；

类加载的时机：

• 创建类的实例（对象）
• 调用类的类方法
• 访问类或者接口的类变量，或者为该类变量赋值
• 使用反射方式来强制创建某个类或接口对应的java.lang.Class对象
• 初始化某个类的子类
• 直接使用java.exe命令来运行某个主类

过程：

如图示从左到右，以及每步做的工作；

类加载器的分类

我们也可以进行继承加载器，建立自己的类加载器，是系统类加载器的子类，但是用途不大；

package invoke;

import java.io.InputStream;

public class MyClassLoder extends ClassLoader {
    public MyClassLoder(ClassLoader parent) {
        super(parent);
    }

    public MyClassLoder() {
    }

    @Override
    public InputStream getResourceAsStream(String name) {
        return super.getResourceAsStream(name);
    }
}

package invoke;


public class ClassLoderTest {
    public static void main(String[] args) {
        ClassLoader systemClassLoader = ClassLoader.getSystemClassLoader();// 系统类加载器
        ClassLoader parent = systemClassLoader.getParent();//平台类加载器
        ClassLoader parent1 = parent.getParent();//启动类加载器
        //ClassLoader parent2 = parent1.getParent();//空指针异常
        System.out.println(systemClassLoader);
        System.out.println(parent);
        System.out.println(parent1);
        //System.out.println(parent2);
        MyClassLoder myClassLoder = new MyClassLoder();
        ClassLoader parent2 = myClassLoder.getParent(); // 系统类加载器
        System.out.println(parent2);
    }
}

类加载的双亲委派模型

前置：

类加载过程时，虚拟机肯定要保证加载进来的类是唯一的，那么怎么保证呢？

双亲委派：

如果一个类加载器收到了类加载请求，它并不会自己先去加载，而是把这个请求委托给父类的加载器去执行，如果父类加载器还存在其父类加载器，则进一步向上委托，依次递归，请求最终将到达顶层的启动类加载器，如果父类加载器可以完成类加载任务，就成功返回，倘若父类加载器无法完成此加载任务，子加载器才会尝试自己去加载，这就是双亲委派模式

简单来说：类加载器收到一个类加载请求，他会先去找自己的父类加载器去执行，父类加载器执行无法加载，子类才会尝试去加载；

test.properties

xingming=xiaoming
nianling=23

package invoke;

import java.io.IOException;
import java.io.InputStream;
import java.util.Properties;

public class ClassLoderTest02 {
    public static void main(String[] args) throws IOException {
        ClassLoader systemClassLoader = ClassLoader.getSystemClassLoader();
        InputStream resourceAsStream = systemClassLoader.getResourceAsStream("test.properties");
        Properties properties = new Properties();
        properties.load(resourceAsStream);
        System.out.println(properties);// {nianling=23, xingming=xiaoming}
        resourceAsStream.close();
    }
}

针对初学者，在这里会发现文件和代码联系起来了，是不是很好玩，不过具体的可以看流的具体讲解，这里不展开了；

反射的概念

反射机制：

反射是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；
对于任意一个对象，都能够调用它的任意属性和方法；
这种动态获取信息以及动态调用对象方法的功能称为Java语言的反射机制。

获取class类对象的三种方式

• 类名.class属性
• 对象名.getClass()方法
• Class.forName(全类名)方法

常用API

大类	方法名	作用
构造方法	Constructor<?>[] getConstructors()	返回所有公共构造方法对象的数组
构造方法	Constructor<?>[] getDeclaredConstructors()	返回所有构造方法对象的数组
构造方法	Constructor getConstructor(Class<?>… parameterTypes)	返回单个公共构造方法对象
构造方法	Constructor getDeclaredConstructor(Class<?>… parameterTypes)	返回单个构造方法对象
反射创建对象	T newInstance(Object…initargs)	根据指定的构造方法创建对象
暴力反射	setAccessible(boolean flag)	设置为true,表示取消访问检查
获取方法	Method[] getMethods()	返回所有公共成员方法对象的数组，包括继承的
获取方法	Method[] getDeclaredMethods()	返回所有成员方法对象的数组，不包括继承的
获取方法	Method getMethod(String name, Class<?>… parameterTypes)	返回单个公共成员方法对象
获取方法	Method getDeclaredMethod(String name, Class<?>… parameterTypes)	返回单个成员方法对象
反射运行方法	Object invoke(Object obj, Object… args)	运行方法

测试

package invoke;

public class Student {
    private String name;
    private Integer age;

    public Student() {
        System.out.println("空构造方法执行");
    }

    public Student(String name, Integer age) {
        System.out.println("全参构造方法执行");
        this.name = name;
        this.age = age;
    }

    public String getName() {
        System.out.println("获取name");
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getAge() {
        System.out.println("获取age");
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    public void methodTest(){
        System.out.println("测试反射执行");
    }

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

package invoke;

import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

public class InvokeTest {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, InstantiationException, IllegalAccessException, InvocationTargetException {
        method01();
    }

    private static void method01() throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InstantiationException, InvocationTargetException {
        Class<?> aClass = Class.forName("invoke.Student");
        Student student = (Student)aClass.newInstance();//空构造方法执行
        Method getName = aClass.getMethod("getName");//获取name
        Method getMethod = aClass.getMethod("methodTest");//测试反射执行
        getName.invoke(student);
        getMethod.invoke(student);
        Method[] declaredMethods = aClass.getDeclaredMethods();
        for (Method declaredMethod : declaredMethods) {
            System.out.println(declaredMethod);
        }
    }
}

动态代理

动态代理主要是在不改类代码的情况下，对实现某一接口的类的某些方法增强

接口

package dongtaidaili;

public interface PeopleInterface {
    void eat(String food);
    void play(String name);
}

实现类

package dongtaidaili;

public class People implements PeopleInterface{
    private String name;
    private String food;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getFood() {
        return food;
    }

    public void setFood(String food) {
        this.food = food;
    }

    public void eat(String food) {
        System.out.println("吃"+food);
    }

    public void play(String name) {
        System.out.println("玩"+name);
    }
}

测试方法

package dongtaidaili;

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

public class Demo01 {
    public static void main(String[] args) {
        final People people = new People();
        people.eat("奶酪");//吃奶酪
        people.play("散步");//玩散步
        PeopleInterface peoProxy = (PeopleInterface)Proxy.newProxyInstance(People.class.getClassLoader(),
                new Class[]{PeopleInterface.class},
                /*
                 * * @param proxy     代理对象，这个位置的代理对象是给系统使用
                 * @param method    目标方法的封装对象
                 * @param args      调用目标方法传递的实参
                 * @return          表示目标方法的返回值，一定要在该方法内部，把调用目标方法获得的返回值return出去，否则外界无法获取该值
                 */
                new InvocationHandler() {
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        if("play".equals(method.getName())){
                            System.out.println("太极");
                            return null;
                        }else {
                            return method.invoke(people,args);
                        }
                    }
                });
        peoProxy.eat("花生");//吃花生
        peoProxy.play("跆拳道");// 太极
    }
}

带出参的返回

上面的接口和类出参为String 不在写了

package dongtaidaili;

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

public class Demo01 {
    public static void main(String[] args) {
        final People people = new People();
        //people.eat("奶酪");//吃奶酪
        //people.play("散步");//玩散步
        PeopleInterface peoProxy = (PeopleInterface) Proxy.newProxyInstance(People.class.getClassLoader(),
                new Class[]{PeopleInterface.class},
                /*
                 * * @param proxy     代理对象，这个位置的代理对象是给系统使用
                 * @param method    目标方法的封装对象
                 * @param args      调用目标方法传递的实参
                 * @return          表示目标方法的返回值，一定要在该方法内部，把调用目标方法获得的返回值return出去，否则外界无法获取该值
                 */
                new InvocationHandler() {
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        Object result = null;

                        try {
                            if ("play".equals(method.getName())) {
                                System.out.println(args[0]);//  吃花生   比如加入参日志
                                System.out.println("太极");
                                result = method.invoke(people, args);
                                System.out.println(result); // 跆拳道   比如出参日志
                            }

                         else {
                                result = method.invoke(people, args);
                            }
                        } catch (
                                Exception e) {
                            e.printStackTrace();
                        }

                        return result;
                    }
                });
        String invokeValue = peoProxy.eat("花生");//吃花生
        System.out.println("---------------------------------------");
        String resultValue = peoProxy.play("跆拳道");// 太极
        //System.out.println("普通return" + invokeValue);
        System.out.println(resultValue);
    }
}

cglib代理

cglib代理是对没有实现接口的类的某些方法增强

类

package cglib;

public class Student {
    private String name;
    private String school;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getSchool() {
        return school;
    }

    public void setSchool(String school) {
        this.school = school;
    }

    public String name(String name){
        System.out.println(name);
        return name;
    }
}

cglib增强

package cglib;

import org.easymock.cglib.proxy.Enhancer;
import org.easymock.cglib.proxy.MethodInterceptor;
import org.easymock.cglib.proxy.MethodProxy;

import java.lang.reflect.Method;

public class StudentCglibProxy {
    public static Student createStudentCglibProxy(Class clazz){
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(clazz);
        // 回调方法
        enhancer.setCallback(new MethodInterceptor() {
            /**
             *
             * @param proxyObject       代理对象
             * @param targetMethod      目标方法
             * @param args              目标方法调用时传递的实参
             * @param methodProxy       代理方法(增强后的方法)
             * @return                  目标方法的返回值
             * @throws Throwable
             */
            public Object intercept(Object proxyObject, Method targetMethod, Object[] args, MethodProxy methodProxy) throws Throwable {
                //通过调用父类的方法实现对原始方法的调用
                // 用错了，可以会掉子类对象的代理方法（递归，没有出口）
                Object ret = methodProxy.invokeSuper(proxyObject, args);
                //后置增强内容，与JDKProxy区别：JDKProxy仅对接口方法做增强，cglib对所有方法做增强，包括Object类中的方法
                if(targetMethod.getName().equals("name")) {
                    System.out.println("小明同学");
                }
                return ret;
            }
        });
        //使用Enhancer对象创建对应的对象
        return (Student) enhancer.create();
    }
}

test

package cglib;

public class Test10 {
    public static void main(String[] args) {
        Student studentCglibProxy = StudentCglibProxy.createStudentCglibProxy(Student.class);
        String name = studentCglibProxy.name("小红");
        System.out.println(name);
    }
}

装饰着模式–挂羊头卖狗肉

各个代理的应用场景图示