Spring动态代理

前言

什么是动态代理？动态代理与静态代理的区别？
动态代理和静态代理的角色属性都一样，但是动态代理的代理类是动态实现的，不是我们自己写好的。

角色：

抽象角色：一般会使用接口或者抽象类来解决

真实角色：被代理的角色

代理角色：代理真实角色，代理真实角色后，我们一般会做一些附属操作

客户：访问代理对象的人!

动态代理分为三大类

1. 基于接口的动态代理：jdk动态代理
2. 基于类的动态代理：cglib
3. java字节码实现：javassist

下面我们重点讲jdk原生的动态代理。

jdk动态代理

我们需要了解两个类

Proxy

提供了创建动态代理类和实例的静态方法，它也是由这些方法创建的所有动态代理类的超类

InvocationHandler

是由代理实例的调用处理程序实现的接口

InvocationHandle

只有一个方法

Proxy：

简而言之就是，Proxy提供方法，InvocationHandle调用和实现方法。

下面我们做测试。

测试

我们这里建立一个demo

Client（用户）

package com.cjh.demo04;

import com.cjh.demo02.UserService;
import com.cjh.demo02.UserServicelmpl;

import java.lang.reflect.InvocationHandler;

public class Client {
    public static void main(String[] args) {
        //真实角色
        UserServicelmpl userService = new UserServicelmpl();

        //代理角色：不存在
        ProxyInvocationHandler pih = new ProxyInvocationHandler();
        //设置要代理的对象
        pih.setTarget(userService);

        //动态生成代理类
        UserService proxy = (UserService) pih.getProxy();
        proxy.add();
    }
}

被代理的对象

UserServicelmpl

package com.cjh.demo02;

public class UserServicelmpl implements UserService{
    public void add(){
        System.out.println("增加了一名用户");
    }
    public void delate(){
        System.out.println("删除了一名用户");
    }
    public void update(){
        System.out.println("修改了一名用户");
    } public void query(){
        System.out.println("查找用户");
    }


}

被代理对象的接口

UserService

package com.cjh.demo02;

public interface UserService {
    public void add();
    public void delate();
    public void update();
    public void query();
}

动态代理

ProxyInvocationHandler

package com.cjh.demo04;


import com.cjh.demo03.Rent;

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

//等一下我们会使用这个类，自动生成代理类！
public class ProxyInvocationHandler implements InvocationHandler {

    /*
    Foo f = (Foo) Proxy.newProxyInstance(Foo.class.getClassLoader(),
            new Class<?>[] { Foo.class },
            handler);

            */


    //被代理的接口
    private Object target;

    public void setTarget(Object target) {
        this.target = target;
    }

    //生成得到代理类，只需要改变rent
    public Object getProxy(){
        return Proxy.newProxyInstance(this.getClass().getClassLoader(),
                target.getClass().getInterfaces(),this);
    }

    //处理代理实例并返回结果
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

        //动态代理的本质就是使用反射机制
        log(method.getName());//通过反射来打印出方法名
        Object result = method.invoke(target, args);
        return result;
    }
//这里再写一个日志的方法，额外的功能
    public void log(String msg){
        System.out.println("执行了"+msg+"方法");
    }
}

这里除了下面多了一个日志的方法，其他都属于模板，可以自定义增加功能。

动态代理模板

package com.cjh.demo04;


import com.cjh.demo03.Rent;

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

//等一下我们会使用这个类，自动生成代理类！
public class ProxyInvocationHandler implements InvocationHandler {

    /*
    Foo f = (Foo) Proxy.newProxyInstance(Foo.class.getClassLoader(),
            new Class<?>[] { Foo.class },
            handler);

            */


    //被代理的接口
    private Object target;

    public void setTarget(Object target) {
        this.target = target;
    }

    //生成得到代理类，只需要改变rent
    public Object getProxy(){
        return Proxy.newProxyInstance(this.getClass().getClassLoader(),
                target.getClass().getInterfaces(),this);
    }

    //处理代理实例并返回结果
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

        //动态代理的本质就是使用反射机制
        Object result = method.invoke(target, args);
        return result;
    }

}

区别

与静态代理不同，在这个实例中，我们没有自己去创建代理类，取而代之的是一个建立一个动态代理类，让动态代理类自己去生成静态代理类，不需要我们分别根据不同需求创建静态代理。
这样多个角色可以用同一个代理类，开发效率变高