Java静态代理、动态代理

静态代理：

在Java中常见的使用静态模式的例子就是Thread、Runnable

1：定义一个接口表示想要做的事情(接口是核心后面的两个类都需要实现它)

public interface Hello {
    void sayHello();

    void sayGoodbye(String name);
}

2：定义一个实现类

public class Person implements Hello {
    @Override
    public void sayHello() {//我们只关注sayHell方法
        System.out.println("hello my world");
    }

    @Override
    public void sayGoodbye(String name) {

    }
}

该类就跟平时开启一个新的线程向new Thread()方法传入的new Runnable(){...}是一样的只不过这里是使用的匿名内部类的形式。

3：声明代理类

public class Proxy implements Hello {
    private Hello hello;

    /**
     * 在构造方法中要求传入一个Hello类型的对象
     * 这里通过向上转型的方式来接收
     * @param hello
     */
    public Proxy(Hello hello) {
        this.hello = hello;
    }

    @Override
    public void sayHello() {
        /**
         * 在hello.sayHello()之前跟之后可以做相应的扩展
         */
        System.out.println("before sayHello");
        hello.sayHello();
        System.out.println("after sayHello");
    }

    @Override
    public void sayGoodbye(String name) {

    }
}

这三步下来就是Java的静态代理，要是是自己的写的代码的话可以直接就在person类中的sayHello方法全部实现但是如果Person是第三方的东西我们不一定能够修改别人的源码。

静态代理是

动态代理：

1：核心还是定义接口

public interface IHello {
    void sayHello();

    IHello introduce(String str);
}

2：定义实现类

public class Man implements IHello {
    @Override
    public void sayHello() {
        System.out.println("hello I am a man");
    }

    @Override
    public IHello introduce(String str) {
        System.out.println(str);
        return null;
    }
}

3：代理类

public class ProxyInstance {
    private IHello iHello;

    //首先在构造方法中我们需要一个IHello类型的对象
    public ProxyInstance(IHello iHIHelloello) {
        this.iHello = iHello;
    }

    public Object newInstance() {
        //Proxy的静态方法newProxyInstance会返回一个代理实例对象
        //三个参数第一个表示用哪一个类加载器去加载代理对象，第二个是代理类需要实现哪些接口，第三个就是InvocationHandler
        //其中InvocationHandler采用匿名内部类的形式重新了invoke方法，invoke方法也是三个参数其中method是我们要执行的方法args就是方法的参数
        //proxy就是代理实例对象
        return Proxy.newProxyInstance(iHello.getClass().getClassLoader(), iHello.getClass().getInterfaces(), (proxy, method, args) -> {
            if (method.getName().contains("sayHello")) {
                System.out.println("before");
                method.invoke(iHello, args);
                System.out.println("after");
            } else if (method.getName().contains("introduce")) {
                method.invoke(iHello, args);
                return proxy;
            }
            return null;
        });
    }
}

4：测试

 Man man = new Man();//首先new了一个man对象，Man实现类IHello接口
        ProxyInstance proxyInstance = new ProxyInstance(man);//ProxyInstance的构造方法中传入man对象
        /**
         * 调用ProxyInstance的newInstance方法通过强转得到IHello类型的实例对象
         * 实际上我们得到的这个实例是一个继承了Proxy类并实现了IHello接口的对象所以这里才能够强转为IHello类型
         */
        IHello iHello = (IHello) proxyInstance.newInstance();
        /**
         * 这里调用sayHello方法实际上只会转发到InvocationHandler的invoke方法中
         * 1：这也就是为什么在ProxyInstance的构造方法中会把实现了IHello接口的Man对象传入
         * 2：接口IHello的introduce方法需要返回IHello类型的对象，其实在Man类当中我们返回的是null但是跟它没有关系
         * 因为这里调用代理类的introduce方法实际上只会转发到InvocationHandler的invoke方法中而在invoke方法中通过method的name做了判断
         * 如果不是introduce方法就返回null，是的话就返回代理类的实例对象proxy。
         */
        iHello.sayHello();
        System.out.println("\n");
        iHello.introduce("hello").introduce("world");

5：结果

before
hello I am a man
after


hello
world

6：通过以下写法动态代理给我个人的感觉就是首先写一个接口，然后通过动态代理的方式产生一个该接口类型的对象，并且可以拦截(或者说扩展)它的方法

    IHello hello = (IHello) Proxy.newProxyInstance(IHello.class.getClassLoader(), new Class[]{IHello.class}, (proxy, method, args1) -> {
            System.out.println("动态代理");
            return null;
        });
        hello.sayHello();

以上内容主要是平时自己的一些理解所以可能很多地方并不严谨