静态代理和动态代理分析

 **

 _### 静态代理举例：_ 
** 

```
package class类;

interface Hello {
    void morning(String name);
}

 public class HelloWorld implements Hello {

	 public void morning(String name) {
	        System.out.println("Good morning, " + name);

Hello hello = new HelloWorld();
hello.morning("Bob");
}
}

```
分析：这就是我们常用的编写代码的静态代理方式，先定义接口，再编写实现类，最后创建实例，转型为接口并调用

 _###  **动态代理举例：_ 


```
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
public class Main {
    public static void main(String[] args) {
        InvocationHandler handler = new InvocationHandler() {
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                System.out.println(method);
                if (method.getName().equals("morning")) {
                    System.out.println("Good morning, " + args[0]);
                }
                return null;
            }
        };
        Hello hello = (Hello) Proxy.newProxyInstance(
            Hello.class.getClassLoader(), // 传入ClassLoader
            new Class[] { Hello.class }, // 传入要实现的接口
            handler); // 传入处理调用方法的InvocationHandler
        hello.morning("Bob");
    }
}

interface Hello {
    void morning(String name);
}

```
分析：在运行期动态创建一个interface实例的方法如下：

定义一个InvocationHandler实例，它负责实现接口的方法调用；
通过Proxy.newProxyInstance()创建interface实例，它需要3个参数：
使用的ClassLoader，通常就是接口类的ClassLoader；
需要实现的接口数组，至少需要传入一个接口进去；
用来处理接口方法调用的InvocationHandler实例。
将返回的Object强制转型为接口。