深入理解Java动态代理

文章目录

• 深入理解代理对象
• 如何为一个Java对象创建一个代理对象

动态代理就是一个中介，把我们想执行的代码给它，在不侵入原有代码的情况下，能够完整执行下去。

比如下图：

在不动eat()方法的情况下想要加入右边两行代码，我们就可以交给 代理对象进行实现。

深入理解代理对象

J哥有两个方法-技能，唱歌和跳舞，但是他不想管收钱、场地、话筒这些活，于是他找了一个经理人—代理对象。

这个代理人需要和J哥有相同的方法，当别人来找J哥的时候，就直接找代理对象了解价钱即可。代理对象和J哥都会继承相同的接口，从而保证他们的方法能够一样。

如何为一个Java对象创建一个代理对象

ProxyUtil.java:

package com.linghu.util;

import com.linghu.bean.BigStart;
import com.linghu.proxy.Star;

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

/**
 * @author 令狐荣豪
 * @version 1.0
 */
public class ProxyUtil {

    /**
     * 给一个明星的对象创建代理,这个相当于一个工具类
     * @param bigStart 被代理的明星对象-J哥
     * @return 返回给明星创建的代理
     */
    public static Star createProxy(BigStart bigStart){
      Star star= (Star) Proxy.newProxyInstance(
              ProxyUtil.class.getClassLoader(),/** 指定用哪个类加载器生成代理类*/
              new Class[]{Star.class},/** 指定接口，让代理去代理接口中的方法，有哪些方法？*/
              new InvocationHandler() {/** 第三个参数用匿名内部类，指定代理对象要干什么事情，这里替J哥收钱*/
                  /**
                   *
                   * @param proxy 代理的对象-就是start代理的对象，一般不会用它
                   *
                   * @param method 跟反射有关，表示要运行的方法-sing，他是通过反射得到的
                   *
                   * @param args 调用sing方法时传入的实参-String name-歌曲的名称-基尼太美
                   *
                   * @return
                   * @throws Throwable
                   */
                  @Override
                  public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                     /** 前置准备工作：*/
                      if ("sing".equals(method.getName())){
                          System.out.println("准备话筒、收钱");
                      }else if ("dance".equals(method.getName())){
                          System.out.println("准备场地、收钱");
                      }

                      /** 去找大明星给你唱歌或者跳舞,这里的调用用到了反射*/
                      return method.invoke(bigStart,args);
                  }
              }
      );
      return star;
    }
}

package com.linghu.test;

import com.linghu.bean.BigStart;
import com.linghu.proxy.Star;
import com.linghu.util.ProxyUtil;

/**
 * @author 令狐荣豪
 * @version 1.0
 */
public class ProxyTest {
    public static void main(String[] args) {
        /**
         * 外面的人想要大明星唱歌：
         * 1、获取代理对象，找明星代理
         * 2、调用代理的唱歌方法
         * */

        //1、获取代理对象，找明星代理
        BigStart start = new BigStart("鸡哥");//生成一个明星对象
        Star proxy = ProxyUtil.createProxy(start);//再生成明星对象的代理对象

        //2、调用代理的唱歌方法
        String thankyou = proxy.sing("只因你太美");//返回谢谢
        System.out.println(thankyou);

        //3、调用代理的跳舞方法
        proxy.dance();
    }
}

package com.linghu.bean;

import com.linghu.proxy.Star;

/**
 * @author 令狐荣豪
 * @version 1.0
 */
public class BigStart implements Star {
    private String name;

    //唱歌
    public String sing(String name){
        System.out.println(this.name+"正在唱"+name);
        return "谢谢";
    }
    //跳舞
    public void dance(){
        System.out.println(this.name+"正在跳");
    }

    public BigStart() {
    }

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

    public String getName() {
        return name;
    }

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

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

public interface Star {
    //我们可以把想要代理的方法定义在接口中,要代理的方法就是代理！

    //唱歌
    public String sing(String name);
    //跳舞
    public void dance();
}