动态代理demo

首先定义一个接口：

class interface Istar(){
	void dance();
	void sing();
}

然后定义一个类实现这个接口：

class Stars implements Istar(){
private String name;
public Stars(String name){
this.name = name;
	}
public void setName(String name){
this.name = name;
}
public String getName(){
	return name;
}
//重写方法
public void dance(){
	System.out.println(getName+"跳一支舞");
}
public void sing(){
System.out.pritln(getName+"唱一首歌");
}
}

这时，需要一个代理类来实现对star类的动态代理，即定义一个代理类

public class StarNewProxy implement InvocationHandle{
private Object object;
public StarNewProxy(Object o){
	this.object = o;
}
public Boolean runBefore(Method method){
System.out.println("拦截到一个请求");
if(method.getName().equals("dance")){
	System.out.println("明星受伤了，不能跳舞");
	return false;
}else{
	System.out.println(method.getName()+"跳了一支舞");
	return true;
}
}
pulic void runAfter(Method method){
	System.out,println(method.getName()+"代理类请求完毕");
}
	@Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        if (!RunBefore(method)){
            return null;
		}else{
            Object result = method.invoke(object, args);
            RunAfter(method);
            return result;
}
    }
}

实现InvocationHandler接口，重写invoke方法，其中的method.invoke即是执行这个方法，除此之外还可以在执行这个方法前和方法后定义一些其他的操作，有点类似于AOP的思想。

接下来我们实现一个测试类

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

public class Test {
    public static void main(String[] args) {
        Istart istars = new Stars("Frank");
        InvocationHandler starsNewProxy = new StarsNewProxy(istars);
        Istart prox = (Istart) Proxy.newProxyInstance(istars.getClass().getClassLoader(),istars.getClass().getInterfaces(),starsNewProxy);
        prox.dance();
//        prox.sing();
    }
    }