JAVA复习——静态代理、动态代理

package com.atguigu.Reflection;

/**静态代理测试
 * @auther Elding_xrl
 * @create 2020-07-07-15:00
 */
interface Cloth {
     
     void clothdosmthing();
}

//代理类
class colthFactory implements Cloth{
     

    private Cloth cf;

    public colthFactory(Cloth cf){
     
        this.cf = cf;
    }

    @Override
    public void clothdosmthing() {
     
        System.out.println("代理开始");

        cf.clothdosmthing();

        System.out.println("代理结束");
    }
}

//被代理类

class NikeFactory implements Cloth{
     


    @Override
    public void clothdosmthing() {
     
        System.out.println("耐克制造");
    }
}




public class StaticProxyTest {
     
    public static void main(String[] args) {
     
        Cloth cff = new colthFactory(new NikeFactory());//编译时就已经确定了被代理类和代理类，所以是静态的
        cff.clothdosmthing();
    }


}

动态代理

package com.atguigu.Reflection;

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

/**
 * @auther Elding_xrl
 * @create 2020-07-07-15:38
 */
interface Man {
     
    String bilef();

    void eat();
}


//被代理类
class Superman implements Man{
     


    @Override
    public String bilef() {
     
        return "I am SuperMan";
    }

    @Override
    public void eat() {
     
        System.out.println("我是DC的BUG存在");
    }
}

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

class ProxyFactory {
     

    public static Object getInstance(Object obj){
     

        MyinvocationHandler handler = new MyinvocationHandler(obj);
        //解决问题一
        return Proxy.newProxyInstance(obj.getClass().getClassLoader(),obj.getClass().getInterfaces(),handler);
    }


}
//InvocationHandler解决问题二
class MyinvocationHandler implements InvocationHandler{
     

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

    public MyinvocationHandler(Object obj){
     
        this.obj = obj;
    }

    //当我们通过代理类的对象，调用方法a时，就会自动的调用如下的方法：invoke()
    //将被代理类要执行的方法a的功能声明在invoke()方法中

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
     
        //method:即为代理类对象调用的方法，此方法也就作为了被代理类对象要调用的方法
        //obj：被代理类对象
        Object invoke = method.invoke(obj, args);
        //从上述方法的返回值就作为当前类中的invoke()的返回值。
        return invoke;
    }
}



public class ProxyTest {
     

    public static void main(String[] args) {
     
        Superman superman = new Superman();
        //ProxyFactory：代理类对象
        Man o = (Man) ProxyFactory.getInstance(superman);
        //当通过代理类的对象调用方法时，会自动的调用被代理类中同名的方法
        System.out.println(o.bilef());
        o.eat();

        System.out.println("******************************");

        NikeFactory nike = new NikeFactory();

        Cloth cf = (Cloth) ProxyFactory.getInstance(nike);

        cf.clothdosmthing();
    }
}

AOP:面向切面编程，通过预编译方式和运行期间动态代理实现程序功能的统一维护的一种技术

动静结合（在动态代理MyinvocationHandler 的invoke方法中增加固定代码的运行）