JAVA中的代理技术（静态代理和动态代理）

            //
             方法 1: 该方法用于获取指定代理对象所关联的调用处理器
            static
             InvocationHandler getInvocationHandler(Object proxy) 


            //
             方法 2：该方法用于获取关联于指定类装载器和一组接口的动态代理类的类对象
            static
             Class getProxyClass(ClassLoader loader, Class[] interfaces) 


            //
             方法 3：该方法用于判断指定类对象是否是一个动态代理类
            static
            boolean
             isProxyClass(Class cl) 


            //
             方法 4：该方法用于为指定类装载器、一组接口及调用处理器生成动态代理类实例
            static
             Object newProxyInstance(ClassLoader loader, Class[] interfaces, 
InvocationHandler h)
        

            //
             该方法负责集中处理动态代理类上的所有方法调用。第一个参数既是代理类实例，第二个参数是被调用的方法对象,
            第三个方法是调用参数。调用处理器根据这三个参数进行预处理或分派到委托类实例上反射执行
Object invoke(Object proxy, Method method, Object[] args)

            package
             newjava;

            import
             java.lang.reflect.InvocationHandler;

            import
             java.lang.reflect.Method;

            import
             java.lang.reflect.Proxy;

            //
            普通对象和代理对象都要实现的接口
            interface
             PersonInterface
{
    
            void
             meeting();
}

            //
            普通对象
            class Person implements PersonInterface
{
    @Override
    publicvoid meeting() {
        System.out.println("meeting...");
    }    
}
//代理处理器class PersonHander implements InvocationHandler
{
    Person person;
    PersonHander(Person p)
    {
        person = p;
    }
    @Override
    public Object invoke(Object proxy, Method method, Object[] args)
            throws Throwable {
        //进行前后织入if (method.getName().equals("meeting"))
        {
            System.out.println("good morning before metting");
            Object obj =  method.invoke(person, args);
            System.out.println("good afternoon after metting");
            return obj;
        }
        returnnull;
    }
    
}
//测试类publicclass ProxyTest {
    publicstaticvoid main(String[] args)
    {
        //普通对象
        Person p = new Person();
        //创建代理对象
        PersonInterface personProxy = (PersonInterface) Proxy.newProxyInstance(
                p.getClass().getClassLoader(),
                p.getClass().getInterfaces(),
                new PersonHander(p));
        //调用被代理后的方法        personProxy.meeting();
    }
}