Java动态代理的理解

/*定义一个业务接口*/
public interface Count {  
    // 查看账户方法  
    public void queryCount();  
    // 修改账户方法  
    public void updateCount();    
}

/*定义一个委托类，实现该业务接口*/
public class CountImpl implements Count {  
    @Override  
    public void queryCount() {  
        System.out.println("查看账户方法...");  
    }  
    @Override  
    public void updateCount() {  
        System.out.println("修改账户方法...");   
    }  
}  

/*定义一个静态代理类，对委托类countIml进行代理*/
public class CountProxy implements Count {  
    private CountImpl countImpl;    
    /** 
     * 覆盖默认构造器 
     *  
     * @param countImpl 
     */  
    public CountProxy(CountImpl countImpl) {  
        this.countImpl = countImpl;  
    }   
    @Override  
    public void queryCount() {  
        System.out.println("事务处理之前");  
        // 调用委托类的方法;  
        countImpl.queryCount();  
        System.out.println("事务处理之后");  
    }  
    @Override  
    public void updateCount() {  
        System.out.println("事务处理之前");  
        // 调用委托类的方法;  
        countImpl.updateCount();  
        System.out.println("事务处理之后");  
    }  
}  

public class TestCount {  
    public static void main(String[] args) {  
        CountImpl countImpl = new CountImpl();  
        CountProxy countProxy = new CountProxy(countImpl);  
        countProxy.updateCount();  
        countProxy.queryCount();  
  
    }  
} 

public interface InvocationHandler { 
    public Object invoke(Object proxy,Method method,Object[] args) throws Throwable; 
} 

public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h)throws IllegalArgumentException 
//参数说明： 
//ClassLoader loader：类加载器 
//Class<?>[] interfaces：得到全部的接口 
//InvocationHandler h：得到InvocationHandler接口的子类实例 

    public interface TargetInterface {  
        public int targetMethodA(int number);  
        public int targetMethodB(int number);  
    }  

    public class ConcreteClass implements TargetInterface{  
      
        public int targetMethodA(int number) {  
            System.out.println("开始调用目标类的方法targetMethodA...");  
            System.out.println("操作-打印数字:"+number);  
            System.out.println("结束调用目标类的方法targetMethodA...");  
            return number;  
        }  
          
        public int targetMethodB(int number){  
            System.out.println("开始调用目标类的方法targetMethodB...");  
            System.out.println("操作-打印数字:"+number);  
            System.out.println("结束调用目标类的方法targetMethodB...");  
            return number;  
        }  
      
    }  

    public class ProxyHandler implements InvocationHandler{  
        private Object concreteClass;  
          
        public ProxyHandler(Object concreteClass){  
            this.concreteClass=concreteClass;  
        }  
      
        public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {  
            System.out.println("proxy:"+proxy.getClass().getName());  
            System.out.println("method:"+method.getName());  
            System.out.println("args:"+args[0].getClass().getName());  
              
            System.out.println("Before invoke method...");  
            Object object=method.invoke(concreteClass, args);//普通的Java反射代码,通过反射执行某个类的某方法  
            System.out.println("After invoke method...");  
            return object;  
        }  
      
    }  

    public class DynamicProxyExample {  
        public static void main(String[] args){  
             ConcreteClass c=new ConcreteClass();//元对象(被代理对象)  
             InvocationHandler ih=new ProxyHandler(c);//代理实例的调用处理程序。  
             //创建一个实现业务接口的代理类,用于访问业务类(见代理模式)。  
             //返回一个指定接口的代理类实例，该接口可以将方法调用指派到指定的调用处理程序，如ProxyHandler。  
             TargetInterface targetInterface=(TargetInterface)Proxy.newProxyInstance(c.getClass().getClassLoader(),c.getClass().getInterfaces(),ih);  
             //调用代理类方法,Java执行InvocationHandler接口的方法.  
             int i=targetInterface.targetMethodA(5);  
             System.out.println(i);  
             System.out.println();  
             int j=targetInterface.targetMethodB(15);  
             System.out.println(j);  
        }  
    }