动态代理和静态代理最大的区别在于,静态需要自己手动写,动态是运行时动态生成的。就如说,静态代理接口又增加一个方法,你还需要再动代理类,而动态的就不用。所有的方法都可以享受增加的功能。(吃饭前,吃饭后)
静态代理
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();
}
}
结果:
吃饭前
吃饭
吃饭后