JDK动态代理原理:只能代理接口,不能代理类问题

/**
 *
 * People 真实对象的接口包含两个方法
 *
 */
public interface People {
    voidsayHello(String msg);
 
    voidsayBye(String msg);
}
 
真实对象接口的具体实现
 
/**
 *
 *Student
 * 真实对象接口的实现
 */
public class Student implements People {
 
    @Override
    public void sayHello(String msg) {
      System.out.println("Hello "+msg);
    }
 
    @Override
    public void sayBye(String msg) {
        System.out.println("ByeBye "+msg);
    } 
}

/**
 *
 *StaticProxy
 * 代理对象，控制对真实对象的访问控制
 */
public class StaticProxy implements People {
    //真实对象，客户端不能直接访问
    private Peoplepeople;
   
    publicStaticProxy(){
        this.people=new Student();
    }
 
    @Override
    public void sayHello(String msg) {
        booleanfriendFlag=true;
        if(friendFlag){
            people.sayHello(msg);
        }
        System.out.println("记录访问日志");
      
    }
 
    @Override
    public void sayBye(String msg) {
        booleanfriendFlag=true;
        if(friendFlag){
            people.sayBye(msg);
        }
        System.out.println("记录访问日志");
    }
}

public class Test_Demo {
    public static void main(String[] args) {
        //创建静态代理对象
        StaticProxy proxy = new StaticProxy();
        //调用静态代理对象方法
        proxy.sayHello("nihao");
        proxy.sayBye("zaijian");       
    }
}

public interface Car {
    public void run();
    public void laba(String str);
}

public class BenChi implements Car {
    @Override
    public void run() {
        System.out.println("奔驰启动快");
    }
    @Override
    public void laba(String str) {
        System.out.println("过路口要减速鸣笛"+str);
    }
}

public class P_Class implements InvocationHandler {
    private Car car;
    public P_Class(Car car){
        this.car = car;
    }
    public Car createProxy(){
        Car car_proxy = (Car) Proxy.newProxyInstance(car.getClass().getClassLoader(), 
                car.getClass().getInterfaces(), this);
        return car_proxy;
    }
 
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        if("run".equals(method.getName())){
            System.out.println("开车不喝酒，喝酒不开车");
            method.invoke(car, args);
            System.out.println("安全伴我行");
            System.out.println(proxy.getClass().getName());            
        }
        return null;
    }
}

public class Test_Demo {
    public static void main(String[] args) {
        Car benchi = new BenChi();
        Car benchi_proxy = new P_Class(benchi).createProxy();
        benchi_proxy.run();
        benchi.laba("dididididi");    
    }
}

/**
     * 
     * 通过Proxy动态生成一个代理实例
     *return:Object
     */
    public Object getProxy(){
        /*
         * Proxy.newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h)

注意：loader类加载器用于加载代理类的字节码；interfaces为代理类需要实现的接口；h为代理对象实际调用的方法即invoke方法。
         * 第一个参数的作用就是 获取当前类的类加载器,作用是用来生成类的
         * 第二个参数是获取真实对象的所有接口    获取所有接口的目的是用来生成代理的,因为代理要实现所有的接口
         * 第三个参数是 调用处理器  这里传入调用处理器，是因为生成代理实例需要 调用处理器    为什么需要调用处理器，因为生成的代理不能直接调用真实对象的方法,而是通过调用处理器来调用真实对象的方法，具体就是通过上面定义的P_Class重写父类InvocationHandler的invoke方法
         */
       return  Proxy.newProxyInstance(this.getClass().getClassLoader(), target.getClass().getInterfaces(), this );
    }
}

Proxy.newProxyInstance(this.getClass().getClassLoader(),target.getClass().getInterfaces(),this );

public static Object newProxyInstance(ClassLoader loader,
                                          Class<?>[] interfaces,
                                          InvocationHandler h)
        throws IllegalArgumentException
    {
      
     
        Class<?> cl = getProxyClass(loader, interfaces);
       
// Class[] constructorParams =
         { InvocationHandler.class };
 
            Constructor cons = cl.getConstructor(constructorParams);
            return cons.newInstance(new Object[] { h });
        } 

Class<?> cl =getProxyClass(loader, interfaces);

   byte[] proxyClassFile = ProxyGenerator.generateProxyClass(

                    proxyName, interfaces);