java 动态代理 自我学习笔记

代理设计模式的原理

      代理设计模式的原理：使用一个代理将对象包装起来，然后用该代理对象取代原始对象。任何对原始对象的调用都要通过代理。代理对象决定是否以及何时将方法调用转到原始对象上。

 

静态代理

    静态代理：特征是代理类和目标对象的类都是在编译期间确定下来，不利于程序的扩展。同时，每一个代理类只能为一个接口服务，这样一来程序中必然产生过多的代理。最好可以通过一个代理类完成全部的代理功能。

   

package com.sgl.proxy;

/**
 * 静态代理举例
 *
 * @author not_simple
 * @version 1.0
 * @date 2020/5/15 11:37
 */

interface ClothFactory{

    void produceCloth();

}

//代理类
class ProxyClothFactory implements ClothFactory{

    private ClothFactory factory;

    public ProxyClothFactory(ClothFactory factory){
        this.factory = factory;
    }

    @Override
    public void produceCloth() {
        System.out.println("代理工厂做了一些准备工作");

        factory.produceCloth();

        System.out.println("代理工厂做了一些后续的收尾工作");
    }
}

//被代理类
class NikeClothFactory implements ClothFactory{

    @Override
    public void produceCloth() {
        System.out.println("Nike工厂生产了一批运动服");
    }
}

public class StaticProxyTest {
    public static void main(String[] args) {
        //创建被代理类的对象
        ClothFactory nikeClothFactory = new NikeClothFactory();
        //创建代理类的对象
        ClothFactory proxyClothFactory = new ProxyClothFactory(nikeClothFactory);
        //调用方法
        proxyClothFactory.produceCloth();
    }
}

 

 

动态代理：

        动态代理：当想要给实现了某个接口的类中的方法，加一些额外的处理。比如说加日志，加事务等。可以给这个类创建一个代理，故名思议就是创建一个新的类，这个类不仅包含原来类方法的功能，而且还在原来的基础上添加了额外处理的新类。这个代理类并不是定义好的，是动态生成的。具有解耦意义，灵活，扩展性强。

动态代理实现：

      动态代理实现： 首先必须定义一个接口，还要有一个InvocationHandler(将实现接口的类的对象传递给它)处理类。再有一个工具类Proxy(习惯性将其称为代理类，因为调用他的newInstance()可以产生代理对象,其实他只是一个产生代理对象的工具类）。利用到InvocationHandler，拼接代理类源码，将其编译生成代理类的二进制码，利用加载器加载，并将其实例化产生代理对象，最后返回。

    

package com.sgl.proxy;

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

/**
 * 动态代理的举例
 *
 * @author not_simple
 * @version 1.0
 * @date 2020/5/15 14:41
 */

interface Human{
    String getBelief();

    void eat(String food);

}

//被代理类
class SuperMan implements  Human {

    @Override
    public String getBelief() {
         return "I believe I can fly!";
    }

    @Override
    public void eat(String food) {
        System.out.println("我喜欢吃" + food);
    }

}

//动态代理的应用：Spring的AOP，加事务，加权限，加日志。
class HumanUtil {

    public void  prepareMethod(){
        System.out.println("代理类 在被代理类方法执行之前,  执行了一些准备操作");
    }

    public void  endMethod(){
        System.out.println("代理类 在被代理类方法执行之前后,  执行了一些收尾操作");
    }
}


/*
要想实现动态代理，需要解决的问题？
问题1：如何根据加载到内存中的被代理类，动态的创建一个代理类
问题2：当通过代理类的对象调用方法a，如何动态的去调用被代理类的同名方法a

 */

//代理类工厂
class ProxyFactory{

    //调用此方法，返回一个代理类的对象 ，解决问题一
    public static Object getProxyInstance(Object obj){
        MyInvocationHandler handler =new MyInvocationHandler();

        handler.bind(obj);

        return Proxy.newProxyInstance(obj.getClass().getClassLoader(),obj.getClass().getInterfaces(),handler);
    }
}

class MyInvocationHandler implements InvocationHandler{

    private Object object;  //需要使用被代理类的对象进行赋值

     void bind(Object obj){
        this.object = obj;//赋值为被代理类
    }

    //当我们通过代理类的对象调用方法a时，就回自动的调用如下的方法：invoke()
    //将被代理类要执行的方法a的功能就声明在invoke()中
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        HumanUtil util =new HumanUtil();

        util.prepareMethod();
         //method: 即为代理类对象调用的方法，此方法也就作为了被代理类对象要调用的方法
        //obj:被代理类的对象
        Object returnValue = method.invoke(object, args);

        util.endMethod();

        //上述方法的返回值就作为当前类中的invoke（）的返回值。
        return returnValue;
    }
}


public class ProxyTest {
    public static void main(String[] args) {
        SuperMan superMan = new SuperMan();
        //ProxyFactory:代理类的对象
        Human proxyInstance = (Human) ProxyFactory.getProxyInstance(superMan);
        proxyInstance.eat("鸡蛋");

        System.out.println("------------------");
        System.out.println(proxyInstance.getBelief());


        System.out.println();
        System.out.println("---------test2---------");


        ClothFactory nikeClothFactory = new NikeClothFactory();
        ClothFactory  proxyClothFactory = (ClothFactory) ProxyFactory.getProxyInstance(nikeClothFactory);
        proxyClothFactory.produceCloth();

    }

}

 

动态代理的应用

      动态代理的应用：Spring的AOP，加事务，加权限，加日志。