【动态代理】

静态代理

基于接口实现动态代理

ITeacherDao

public interface ITeacherDao {
    public void teach();
}

TeacherDao 目标对象

import com.cao.demo05.ITeacherDao;

public class TeacherDao implements ITeacherDao {

    @Override
    public void teach() {
        System.out.println("老师在上课");
    }
}

ProxyFactory

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

public class ProxyFactory {
    //维护一个目标对象
    private Object target;
    //对target初始化
    public ProxyFactory(Object target) {
        this.target = target;
    }
    /*
    * 给目标对象生成代理对象
    * Proxy.newProxyInstance(ClassLoader loader,Class<?>[] interfaces,InvocationHandler h)
    * 1.ClassLoader loader:指定目标对象的类加载器，获取加载器的方法固定（从target获得）
    * 2.Class<?>[] interfaces：目标对象实现的接口类型（从target获得）
    * 3.InvocationHandler h：1.增加所需事务，2.反射机制获取目标对象方法，执行目标对象方法
    * */
    public Object getProxyInstance(){
        return Proxy.newProxyInstance(target.getClass().getClassLoader(),
                target.getClass().getInterfaces(),
                new InvocationHandler() {
                    @Override
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        log(method.getName());
                        //反射机制调用目标对象的方法，执行该方法
                        Object invoke = method.invoke(target, args);
                        return invoke;
                    }
                }
                );
    }
    //新增事务
    public void log(String methodName){
        System.out.println("执行了"+methodName+"方法");
    }
}

Client

public class Client {
    public static void main(String[] args) {
        //创建目标对象，必须为接口类型
        ITeacherDao teacherDao = new TeacherDao();
		//给目标对象创建接口对象，强制转换为接口类型
        ITeacherDao proxyInstance = (ITeacherDao) new ProxyFactory(teacherDao).getProxyInstance();
        //内存中动态生成了代理对象
		//System.out.println(proxyInstance);
		//通过代理对象执行增加的事务及target的方法
        proxyInstance.teach();
    }
}