java动态创建代理对象

代理模式在开发过程中有着众多好处，现在我先给大家首先介绍什么是代理模式，以及java的中代理模式的使用，最后再看代理模式的概念作用等自然就会明白了

1.动态创建代理对象

》》》》》》代理模式的字面意思，就是代理一个类，即被代理对象，让代理对象可
以有代理对象的功能或同时能够加强这个功能的，当然他还有其他作用

package ceom.proxy.test;

//Proxy，相当于工具类，帮助我们创建代理对象
import java.lang.reflect.Proxy;

//下面三个分别是  Proxy.newProxyInstance的三个参数
//person 实现接口，即马上要被代理的对象
import com.proxy.demo1.Person;

//work 接口内 有两个方法  go  和 have 方法
import com.proxy.demo1.Work;

//PersonPorxy实现处理类invocationhandler
import com.proxy.demo1.PersonPorxy;

public class test {
    public static void main(String[] args) {
        Person person = new Person();
        person.go();
        person.have();

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

         Work proxyperson= (Work)Proxy.newProxyInstance(Work.class.getClassLoader(),new Class[]{Work.class},new PersonPorxy());

        proxyperson.go();
        proxyperson.have();
    }
}

• newProxyInstance的参数说明
  第一个参数：要被代理对象的加载器
  第二个参数：被代理对象实现的接口的.class，必须是数组结构（原因是一个被代理对象即类 可以实现多个接口类）
  第三个参数：实现InvocationHandler接口的一个类（这是干嘛的呢？可能很多人不理解，可是你想想，Proxy.newProxyInstance 返回的就是一个 代理对象 ，他实现了被代理对象person的work接口 ，同时加强了person类的方法，那么如何加强person方法的方法呢？请看下面的PersonPorxy类吧）

package com.proxy.demo1;

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

public class PersonPorxy implements InvocationHandler{
    Person person=new Person();




	 /**
     * Proxy.newProxyInstance创造出的代理对象
     * 执行接口里的方法都会执行invoke，
     * @param proxy		这个参数是代理对象方法，暂放有时间再研究，
     * 					不过这不需要里用不到
     * @param method	被代理对象的方法，照着this理解，被代理对象
     * 					使用哪个方法，method就是谁
     * @param args		被代理对象方法的参数
     * @return			返回被代理对象的方法执行后的返回值
     * @throws Throwable
     */
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

//        //1.获取方法名
//        String methodName = method.getName();
//        //2.获取方法所在的类的名称
//        String className = method.getDeclaringClass().getName();
//        //3.组合key
//        String key=className+"."+methodName;
        //4.diao
        System.out.println("                                    ");
        
        System.out.println("方法名字:"+method.getName()+";\n"+"class全限定类名："+method.getDeclaringClass().getName());

		Object obj=null;
		
		//从这你应该可以知道 
		//可以通过method.getName获取的方法名的不同
		//来有针对性的来强化代理方法，
        if (method.getName()=="go"){
            System.out.println("这是高级的人");
             obj= method.invoke(person, args);
            System.out.println("开车上班");

            return obj ;
        }
        //返回的method.invoke就是 test类里的method方法 go（） 和have（）
        obj = method.invoke(person, args);
        System.out.println("                                    ");
        return obj;
    }
}

输出结果

下面贴出用到的Person和work类

Person类

package com.proxy.demo1;

public class Person implements Work {


    public void go() {
        System.out.println("走路上班");
    }

    public void have() {
        System.out.println("吃米饭");
    }
}

Work

package com.proxy.demo1;

public interface Work {
    public void go();
    public void have();
}

下面是硬概念，再看一下吧

代理模式：

作用：

为其他对象提供一种代理以控制对这个对象的访问。

在某些情况下，一个对象不适合或者不能直接引用另一个对象，而代理对象可以在客户端和目标对象之间起到中介作用。

其特征是代理与委托类有同样的接口。

代理模式是常用的设计模式。

功能：

代理类不仅仅是一个隔离客户端和委托类的中介。

我们还可以借助代理类再次增加一些功能，而不需要修改原有代码。符合开闭原则。

代理类主要为委托类处理消息、过滤消息、把消息转发给委托类、以及事后处理工作。

代理类与委托类之间会存在关联关系，一个代理类的对象与一个委托类的对相关联。

代理类的对象本身并不实现服务，而是通过委托类的对象的方法来提供特定的服务。

其实：就是真正的业务功能还是由委托类来实现，但是在实现业务之前的一些公共服务，例如在项目开发中忘记了加入缓冲、日志等的功能。后期想加入，就可以使用代理来实现而没有必要打开已经封装好的委托类。

分类：

代理可以分为两种：静态代理、动态代理。（我上面的是动态创建）