java静态代理和动态代理

动态代理和静态代理最大的区别在于，静态需要自己手动写，动态是运行时动态生成的。就如说，静态代理接口又增加一个方法，你还需要再动代理类，而动态的就不用。所有的方法都可以享受增加的功能。（吃饭前，吃饭后）

静态代理

1，目标类和代理类都继承同一个接口

2，代理类有目标类的一个引用

3，在实现方法中增强功能

代码如下

接口：

package xxxx;

public interface Eat {
void eat();
}

目标类：

package xxxx;

public class People implements Eat {

@Override
public void eat() {
// TODO Auto-generated method stub
System.out.println("吃饭");
}

}

代理类：

package xxxx;

public class Proxy implements Eat{
private Eat eat;

public Proxy(Eat eat) {
super();
this.eat = eat;
}

@Override
public void eat() {
System.out.println("吃饭前");
eat.eat();
System.out.println("吃饭后");
}

}

测试：

package xxxx;

public class Test {
public static void main(String[] args) {
new Proxy(new People()).eat();
}
}

结果：

吃饭前

吃饭

吃饭后

动态代理

1，目标类实现接口

2，再需要一个类实现InvocationHandler接口（注意，这个不是代理类，而是通过这个类生产代理类，不要搞混），同样需要目标类的实例引用

3，实现InvocationHandler接口invoke方法

接口：

package com.proxy;

public interface  Eat {
void eat();
void xx();
}

目标类：

package com.proxy;

public class People implements Eat{

@Override
public void eat() {
// TODO Auto-generated method stub
System.out.println("吃中午饭");
}

@Override
public void xx() {
// TODO Auto-generated method stub
System.out.println("xxxxx");
}

}

动态代理类：

package com.proxy;

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

public class DynamicTest implements InvocationHandler{
private People people;

public DynamicTest(People people) {
this.people = people;
}

@Override
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
System.out.println("吃饭前");
method.invoke(people, args);
System.out.println("吃饭后");
return null;
}

}

测试

package com.proxy;

import java.lang.reflect.Proxy;

public class MainTest {
public static void main(String[] args) {
People p=new People();
DynamicTest dy =new DynamicTest(p);

Eat e=(Eat)Proxy.newProxyInstance(p.getClass().getClassLoader(), p.getClass().getInterfaces(), dy);
//      e.eat();
e.xx();
}
}

结果：

吃饭前

吃饭

吃饭后