静态代理和jdk动态代理

静态代理

核心思想：让代理角色帮助真实角色来完成一件事；

作用：可以增添相应的业务逻辑，真实角色完成自己的业务逻辑，代理角色帮助真实角色完成业务需求；

特点：代理角色和真实角色实现同一个接口；

举例：

public interface Demo1 {
    public void  marry();

}

public class You implements Demo1 {

    @Override
    public void marry() {
        System.out.println("我要结婚了");
    }
}

public class WeddingCompany implements Demo1 {
    private Demo1 demo1;
    public  WeddingCompany(Demo1 demo1){
        this.demo1=demo1;
    }
    @Override
    public void marry() {
        System.out.println("结婚了 结婚了");
        demo1.marry();
        System.out.println("新郎不是我");
    }
}

public class StaticProxyDemo {
    public static void main(String[] args) {
   You you=new You();
   WeddingCompany weddingCompany=new WeddingCompany(you);
   weddingCompany.marry();

    }
}

动态代理

 Jdk动态代理:
 *          是在程序的执行过程中,通过反射产生的代理对象!
 *        java.lang.reflect.Proxy
 *        jdk动态代理特点:
 *              基于接口实现的
 *        cglib动态代理
 *              基于类实现
 *
 *
 * Proxy
 *        public static Object newProxyInstance(

                                  ClassLoader loader,   参数1:实现的接口的类加载器
 *                               Class<?>[] interfaces,       参数2:基于接口的字节码文件对象数组
 *                               nvocationHandler h)         参数3:是接口InvocationHandler :代理的处理程序
 *                                throws IllegalArgumentException
 *                                                                  参数3是一个接口:自定一个类实现这个接口
 *                                                                  重写这个接口中的
 *                  Object invoke(Object proxy,Method method,Object[] args)throws Throwable

接口： 

public interface Dog {
 
     void eat();
}

          委托类

public class WhiteDog implements Dog{
    @Override
    public void eat() {
        System.out.println("狗吃骨头");
    }
}

         代理类

public class ProxyHandler implements InvocationHandler {
 
    private Object dog;
 
    public ProxyHandler(Object dog){
        this.dog = dog;
    }
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        return method.invoke(dog,args);
    }
}

         测试

public class Test {
 
    public void testProxy(){
 
        WhiteDog whiteDog = new WhiteDog();
        Dog dog = (Dog) Proxy.newProxyInstance(Dog.class.getClassLoader(),
                new Class[]{Dog.class},new ProxyHandler(whiteDog));
        dog.eat();
 
 
    }
 
    public static void main(String[] args) {
        Test t = new Test();
        t.testProxy();
    }

动态代理和静态代理的区别：1、静态代理只代理一个类，而动态代理是代理接口下的多个实现类 2、静态代理在编译时就知道要代理的类，而动态代理是在运行期动态生成的代理类。3 、动态代理类不需要实现接口，但是委托类还是需要实现接口。