Spring-Aop-动态代理-JDK动态代理

动态代理

作用:通过代理类，获得操作类中的方法的权限，从而可以在指定的代码块中加入目标代码，让逻辑更具有灵活性。
JDK的动态代理

代理类Proxy:
Proxy源码：

**Proxy.newProxyInstance()**方法返回的是一个代理类
参数:
loader:表示代理类的类加载器
interfaces:表示代理类实现的接口
h:作用为执行代理类指定的方法(调用原来哪个方法，代理类就执行哪个方法)
这里需要强调的是InvocationHandler这个参数
查看InvocationHandler源代码


这个接口中有invoke方法，这个方法的主要作用就是能够调用代理对象中的方法。
invoke()方法中有三个参数
proxy:代理对象
methor:需要执行的方法
args:其他参数

实例:
有一个接口UserDao,里面有add和update两个方法

public interface UserDao {
    public int add(int a,int b);
    public String update(String id);
}

UserDao的实现类UserDaoImpl

public class UserDaoImpl implements UserDao {
    @Override
    public int add(int a, int b) {
        System.out.println("add方法被执行了...");
        return a+b;
    }

    @Override
    public String update(String id) {
        System.out.println("update方法被执行了...");
        return id;
    }
}

接口实现类的代理类

public class JDKProxy {

    public static void main(String[] args) {
        UserDaoImpl userDao = new UserDaoImpl();
        Class[] interfaces = {UserDao.class};
        //创建接口的实现类的代理对象
        //使用匿名内部类
//        Proxy.newProxyInstance(JDKProxy.class.getClassLoader(), interfaces, new InvocationHandler() {
//            @Override
//            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
//                return null;
//            }
//        });
        UserDao newProxyInstance = (UserDao)Proxy.newProxyInstance(JDKProxy.class.getClassLoader(), interfaces, new UserDaoProxy(userDao));
        int result = newProxyInstance.add(1, 2);
        System.out.println("result："+result);

    }
}

//创建接口实现类的代理对象
class UserDaoProxy implements InvocationHandler{
    //因为创建的是实现类的代理对象，所以需要把实现类作为参数传递过来
    //把创建的UserDaoImpl传递过来
    //有参构造进行传递
    private Object object;
    public UserDaoProxy(Object obj){
        this.object=obj;
    }
    //增强的逻辑
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println(proxy.getClass());
        //方法之前
        System.out.println("方法之前执行......"+method.getName()+"传递的参数..."+ Arrays.toString(args));
        //被增强的方法执行
        Object invoke = method.invoke(object, args);
        //方法之后
        System.out.println("方法之后执行......"+object);
        return invoke;
    }
}

实例分析:
实现JDK动态代理，首先就要有一个接口，且这个接口有一个实现类，JDK的动态代理就是要代理这个实现类。
此时就要用到Proxy代理类，里面有一个方法newPorxyInstance(classLoader,interfaces,InvocationHandler)
通过这个方法可以得到一个代理类，classLoader为类加载器(并没有指明只能是类加载器，可以是其他类的类加载器),interfaces为代理类实现的接口(也就是实现类实现了哪些接口),invocationHandler得到的是一个代理类执行方法返回的结果
invocationHandler里面有一个invoke(porxy,method,args)方法，proxy为代理类，method表示所要执行的方法,args表示其他参数
在invoke方法里面，我们可以在被代理方法(原来的方法，如：add())前面或者后面加上自己添加的逻辑代码，从而使逻辑更加完善，更加灵活。这个就是我们使用动态代理的目的，动态的在方法内部加入代码块。