java代理概念

代理的概念

　　动态代理技术是整个java技术中最重要的一个技术，它是学习java框架的基础，不会动态代理技术，那么在学习Spring这些框架时是学不明白的。

　　动态代理技术就是用来产生一个对象的代理对象的。在开发中为什么需要为一个对象产生代理对象呢？
　　举一个现实生活中的例子：歌星或者明星都有一个自己的经纪人，这个经纪人就是他们的代理人，当我们需要找明星表演时，不能直接找到该明星，只能是找明星的代理人。比如刘德华在现实生活中非常有名，会唱歌，会跳舞，会拍戏，刘德华在没有出名之前，我们可以直接找他唱歌，跳舞，拍戏，刘德华出名之后，他干的第一件事就是找一个经纪人，这个经纪人就是刘德华的代理人(代理)，当我们需要找刘德华表演时，不能直接找到刘德华了(刘德华说，你找我代理人商谈具体事宜吧!)，只能是找刘德华的代理人，因此刘德华这个代理人存在的价值就是拦截我们对刘德华的直接访问！
　　这个现实中的例子和我们在开发中是一样的，我们在开发中之所以要产生一个对象的代理对象，主要用于拦截对真实业务对象的访问。那么代理对象应该具有什么方法呢？代理对象应该具有和目标对象相同的方法

　　所以在这里明确代理对象的两个概念：
　　　　1、代理对象存在的价值主要用于拦截对真实业务对象的访问。
　　　　2、代理对象应该具有和目标对象(真实业务对象)相同的方法。刘德华(真实业务对象)会唱歌，会跳舞，会拍戏，我们现在不能直接找他唱歌，跳舞，拍戏了，只能找他的代理人(代理对象)唱歌，跳舞，拍戏，一个人要想成为刘德华的代理人，那么他必须具有和刘德华一样的行为(会唱歌，会跳舞，会拍戏)，刘德华有什么方法，他(代理人)就要有什么方法，我们找刘德华的代理人唱歌，跳舞，拍戏，但是代理人不是真的懂得唱歌，跳舞，拍戏的，真正懂得唱歌，跳舞，拍戏的是刘德华，在现实中的例子就是我们要找刘德华唱歌，跳舞，拍戏，那么只能先找他的经纪人，交钱给他的经纪人，然后经纪人再让刘德华去唱歌，跳舞，拍戏。

二、java中的代理

2.1、"java.lang.reflect.Proxy"类介绍

　　现在要生成某一个对象的代理对象，这个代理对象通常也要编写一个类来生成，所以首先要编写用于生成代理对象的类。在java中如何用程序去生成一个对象的代理对象呢，java在JDK1.5之后提供了一个"java.lang.reflect.Proxy"类，通过"Proxy"类提供的一个newProxyInstance方法用来创建一个对象的代理对象，如下所示：

1 static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h) 

　　newProxyInstance方法用来返回一个代理对象，这个方法总共有3个参数，ClassLoader loader用来指明生成代理对象使用哪个类装载器，Class<?>[] interfaces用来指明生成哪个对象的代理对象，通过接口指定，InvocationHandler h用来指明产生的这个代理对象要做什么事情。所以我们只需要调用newProxyInstance方法就可以得到某一个对象的代理对象了。

2.2、编写生成代理对象的类

　　在java中规定，要想产生一个对象的代理对象，那么这个对象必须要有一个接口，所以我们第一步就是设计这个对象的接口，在接口中定义这个对象所具有的行为(方法)

　　1、定义对象的行为接口

 

/**
 *@ClassName Person
 * @Description 代理接口
 */
public interface Person{
    /**
     * @Method sing
     * @Description 唱歌
     * @param name
     * @return
     */
    String sing(String name);

    /**
     * @Mathod dance
     * @Description 跳舞
     * @param name
     * @return
     */
    String dance(String name);
}

 

　　2.真实对象类（刘德华真实类）

/**
 * @ClassName LiuDeHua
 * @Desrition 刘德华实现Person类实现唱歌，跳舞行为
 */
public class LiuDeHua implements Person{
    @Override
    public String sing(String name) {
        System.out.println("刘德华唱"+name+"歌");
        return "歌唱完了";
    }

    @Override
    public String dance(String name) {
        System.out.println("刘德华跳"+name+"w舞蹈");
        return "舞蹈跳完了";
    }
}

　　3.代理类（刘德华代理人）

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

/**
 * @ClassName LuiDeHuaProxy
 * @Desrition 这个类实现刘德华代理类
 */
public class LuiDeHuaProxy {
    //设计一个类变量实现这个代理类代理的真实对象类
    private Person person = new LiuDeHua();

    public Person getProxy() {
        //生成一个对象的代理对象
        return (Person) Proxy.newProxyInstance(LuiDeHuaProxy.class.getClassLoader()/*代理类的加载*/
                , person.getClass().getInterfaces()/*Class对象数组，实现接口对象*/,
                new InvocationHandler()/*调用处理器*/ {
            /**
             * InvocationHandler接口只定义了一个invoke方法，因此对于这样的接口，我们不用单独去定义一个类来实现该接口，
             * 而是直接使用一个匿名内部类来实现该接口，new InvocationHandler() {}就是针对InvocationHandler接口的匿名实现类
             * 在invoke方法编码指定返回的代理对象干的工作
             * proxy : 把代理对象自己传递进来
             * method：把代理对象当前调用的方法传递进来
             * args:把方法参数传递进来
             *
             * 当调用代理对象的person.sing("冰雨");或者 person.dance("江南style");方法时，
             * 实际上执行的都是invoke方法里面的代码，
             * 因此我们可以在invoke方法中使用method.getName()就可以知道当前调用的是代理对象的哪个方法
             */
                    @Override
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        if (method.getName().equals("sing")) {
                            //如果调用的是代理人对象的sing方法
                            System.out.println("我是刘德华的代理人，要找刘德华唱歌需要一百万！！");
                            //已经交钱，代理人自己不会唱歌就只能找刘德华唱歌了
                            //代理对象调用真实目标对象的sing方法去处理用户请求
                            return method.invoke(person, args);
                        }
                        if(method.getName().equals("dance")){
                            //如果调用的是代理人对象的dance方法
                            System.out.println("我是刘德华的代理人，要找刘德华跳舞需要一百万！！");
                            //已经交钱，代理人自己不会跳舞就只能找刘德华跳舞了
                            //代理对象调用真实目标对象的dance方法去处理用户请求
                            return method.invoke(person, args);
                        }
                        return null;
                    }
                });
    }
}

　　4.测试

public class Test {
    public static void main(String[] args){
        LuiDeHuaProxy luiDeHuaProxy = new LuiDeHuaProxy();
        Person person = luiDeHuaProxy.getProxy();
        System.out.println(person.sing("大海"));
        System.out.println(person.dance("啊啊"));
    }
}

 

转载于:https://www.cnblogs.com/x-ll123/p/7800993.html