动态的代理

1.什么是动态代理？

无侵入式的给代码增加额外的功能

2.代理长什么样子？

代理里面就是对象需要被代理的方法

3.java通过什么来保证代理的样子？

通过接口保证，后面的对象和代理都需要实现同一个接口

接口中就是要被代理的所有方法

动态代理的过程

第一步:

创建一个JavaBean的明星对象，我们就称之他为鸡哥，这个对象面有唱歌和跳舞的方法

package com.bdqn.practiceProxy;

public class BigStar implements Star{
    private String name;


    public BigStar() {
    }

    public BigStar(String name) {
        this.name = name;
    }

    public String sing(String name){
        System.out.println(this.name+"正在唱"+name);
        return "谢谢";
    }

    public void dance(){
        System.out.println(this.name+"正在跳舞");
    }

    public String getName() {
        return name;
    }

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

第二步，创建接口，接口名为Star，通过接口来保证代理的样子，后面的对象和代理都需要实这同一接口

package com.bdqn.practiceProxy;

public interface Star {
    public abstract String sing(String name);

    public abstract void dance();
}

第三步:

为对象创建一个代理，代理可以帮对象分担一些任务，无侵入式的代码额外地给对象添加功能

/*
 * 类的作用
 * 就是用来创建一个代理
 *
 *
 * */
public class ProxyUtil {
/*
* 方法的作用:
* 给一个明星的对象，创建一个代理
*
*
* 需求:
* 外面的人想要大明星唱一首歌
* 1.获取代理的对象
* 代码对象=ProxyUtil.createProxy(大明星的对象)
* 2.再调用代理的唱歌方法
* 代理对象。唱歌的方法()
*
* */

    public static Star createProxy(BigStar bigStar){//代理的参数填的是需要添写的对象
//        public static Object newProxyInstance(ClassLoader loader,Class<?>[] interfaces, InvocationHandler h);
        //参数一:用于指定哪个类加载器，去加载生成的代理类
        //什么是类加载器?
        //就是我们java在运行地时候，需要有一个人把那个字节码文件加载到内核当中，那么是谁去加载的呢？类加载器去加载
        //理解就是类加载把字节码加载到内存当中
        //参数二:指定接口,这些接口用于指定生成代理长什么样子，也就是有哪些方法
        //参数三:用来指定生成的代理对象要干什么事情

        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 {
                        /*
                        * 参数1:代码的对象
                        * 参数2:要运行的方法sing
                        * 参数3:调用sing方法时，传递的实参
                        * */
                        if("sing".equals(method.getName())){
                            System.out.println("准备话筒，收钱");
                        }else if("dance".equals(method.getName())){
                            System.out.println("准备场地，收钱");
                        }
                        return method.invoke(bigStar,args);//invoke的第一个参数是对象，第二个参数是方法的实参
                    }
                }
        );

     return star;
    }


}

第四步，创建一个测试类，用这个测试类去获取代理对象，然后再调用唱歌和跳舞的方法

package com.bdqn.practiceProxy;

public class Test {
    public static void main(String[] args) {
        /*
         * 需求:
         * 外面的人想要大明星唱一首歌
         * 1.获取代理的对象
         * 代码对象=ProxyUtil.createProxy(大明星的对象)
         * 2.再调用代理的唱歌方法
         * 代理对象。唱歌的方法()
         *
         * */
        //获取代理对象
        BigStar bigStar=new BigStar("鸡哥");
        Star starProxy = ProxyUtil.createProxy(bigStar);
        //调用唱歌的方法
        String result = starProxy.sing("只因你太美");
        System.out.println(result);
        //调用跳舞的方法
        starProxy.dance();
    }
}

打印出来的结果:

准备话筒，收钱
鸡哥正在唱只因你太美
谢谢
准备场地，收钱
鸡哥正在跳舞

1.java提供了什么API帮我们创建代理？

2.newIProxyInstance方法在创建代理时，需要几个参数，每一个参数的含义是什么？

三个参数

第一个参数的含义是：用于指定哪个类加载器，去加载生成的代理类

第二个参数的含义是：指定实现接口,这些接口用于指定生成代理长什么样子，也就是有哪些方法

第三个参数的含义是：参数三:用来指定生成的代理对象要干什么事情

3.通过invokeHandler的invoke方法指定代理干的事时，这个invoke会被谁调用，要接哪几个参数

 代理调用方法时底层会调用invoke这个方法

public Object invoke(Object proxy, Method method, Object[] args){}

* 参数1:代码的对象
* 参数2:要运行的方法sing
* 参数3:调用sing方法时，传递的实参

4.什么时候才会用到代理

当要给某个对象额外添加功能时，却又不想动对象之前的原代码，那就需要用到代理

使用到代理的话就会无侵入式地给代码添加额外的功能