java动态代理（JDK和CGLIB）笔记

动态代理：为一堆interface或类的实现提供统一的执行通道，从含义上就像局域网电脑通过代理上网一样，走统一的通道，代理控制通道，自然可以在通道里加上自定义实现，例如像AOP切面，日志等。

JDK的动态代理只能对接口实现，代理类需要实现InvocationHandler 接口。

一、接口

public interface UserService {
    User addUser();
    void editUser(User user);
    int deleteUser(int userId);
}

//假设有这么一个User类
public class User {
    private Integer userId;
    private String userName;
    private String password;

    public Integer getUserId() {
        return userId;
    }

    public void setUserId(Integer userId) {
        this.userId = userId;
    }

    public String getUserName() {
        return userName;
    }

    public void setUserName(String userName) {
        this.userName = userName;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    @Override
    public String toString() {
        return "User{" +
                "userId=" + userId +
                ", userName='" + userName + '\'' +
                ", password='" + password + '\'' +
                '}';
    }
}

二、接口的实现

public class UserServiceImpl implements UserService {
    @Override
    public User addUser() {
        User user = new User();
        user.setUserId(1);
        user.setUserName("userTest");
        user.setPassword("123456");
        System.out.println("------> add user");
        return user;
    }

    @Override
    public void editUser(User user) {
        System.out.println("------> edit user:" +user);
    }

    @Override
    public int deleteUser(int userId) {
        System.out.println("------> delete user:"+userId);
        return 1;
    }
}

三、JDK代理类实现InvocationHandler

public class ProxyHandler implements InvocationHandler {

    //被代理对象
    private Object proxied;

    public ProxyHandler(Object proxied) {
        this.proxied = proxied;
    }

    private void beforeInvoke(String msg)
    {
        System.out.println("-------> beforInvoke:"+msg);
    }

    private void afterInvoke(String msg)
    {
        System.out.println("-------> afterInvoke:"+msg);
    }

    private String convertArgs(Object[] args)
    {
        if(args==null || args.length==0)
        {
            return null;
        }
        StringBuilder sb= new StringBuilder();
        for(Object object : args)
        {
            sb.append(object.toString());
        }

        return sb.toString();
    }

    //proxy是代理对象，可以想象成代理服务器
    //proxied是被代理对象，可以想象成局域网里的PC
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

        beforeInvoke("proxy name:"+proxy.getClass().getName());
        beforeInvoke("proxied name:"+proxied.getClass().getName());
        beforeInvoke( "args:"+convertArgs(args));
        Object o = method.invoke(proxied,args);
        afterInvoke("result:"+o);
        return o;
    }
}

四、使用，实现原理是反射

public class Main {

    public static void main(String[] args) {
        UserService userService = new UserServiceImpl();
        UserService proxyUserService = (UserService) Proxy.newProxyInstance(
                UserService.class.getClassLoader(),
                new Class[]{UserService.class},
                new ProxyHandler(userService)
        );

        User user = proxyUserService.addUser();

        proxyUserService.editUser(user);

        proxyUserService.deleteUser(user.getUserId());

    }
}

五、结果：符合预期的输出

六、简化一下写法，代理类的生成方式

public class DynamicProxy implements InvocationHandler {
    private Object proxied;

    private void beforeInvoke(String msg)
    {
        System.out.println("-------> beforInvoke:"+msg);
    }

    private void afterInvoke(String msg)
    {
        System.out.println("-------> afterInvoke:"+msg);
    }

    private String convertArgs(Object[] args)
    {
        if(args==null || args.length==0)
        {
            return null;
        }
        StringBuilder sb= new StringBuilder();
        for(Object object : args)
        {
            sb.append(object.toString());
        }

        return sb.toString();
    }

　　//在这里就把代理对象创建出来
    public Object getProxyObject(Object proxied) {
        this.proxied = proxied;
        return Proxy.newProxyInstance(
                this.proxied.getClass().getClassLoader(),
                this.proxied.getClass().getInterfaces(),
                this
        );
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        beforeInvoke("proxy name:"+proxy.getClass().getName());
        beforeInvoke("proxied name:"+proxied.getClass().getName());
        beforeInvoke( "args:"+convertArgs(args));
        Object o = method.invoke(proxied,args);
        afterInvoke("result:"+o);
        return o;
    }
}

//main
public class Main {

    public static void main(String[] args) {

        System.out.println("##############");

        System.out.println("-------> second call:");

        UserService userService = (UserService) new DynamicProxy().getProxyObject(new UserServiceImpl());
        User user1 = userService.addUser();
        userService.editUser(user1);
        userService.deleteUser(user1.getUserId());
    }
}

六、使用cglib动态代理

cglib可以代理非接口类，但是因为其实现原理是继承，所以无法代理被代理类中final方法，也无法代理final修饰的类。

代理类需要实现MethodInterceptor 接口

    <dependencies>
        <dependency>
            <groupId>cglib</groupId>
            <artifactId>cglib</artifactId>
            <version>3.2.8</version>
        </dependency>

    </dependencies>

public class CglibDynamicProxy implements MethodInterceptor {
    private Object proxied;

    //Generate a new class if necessary and uses the specified callbacks (if any) to create a new object instance.
    //Uses the no-arg constructor of the superclass.
    //动态生成一个新的类，使用父类的无参构造方法创建一个指定了特定回调的代理实例
    public Object getProxyObject(Object proxied)
    {
        this.proxied = proxied;
        //增强器，动态代码生成器
        Enhancer enhancer = new Enhancer();
        //回调方法
        enhancer.setCallback(this);
        //设置生成类的父类类型
        enhancer.setSuperclass(proxied.getClass());
        //动态生成字节码并返回代理对象
        return enhancer.create();
    }

    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {

        beforeInvoke("Object:"+o.getClass().getName());
        beforeInvoke("method:"+method.getName());
        beforeInvoke("args:"+convertArgs(objects));
        beforeInvoke("methodProxy:"+methodProxy.getSignature());
        Object result = methodProxy.invoke(this.proxied,objects);
        afterInvoke("result:"+result);
        return result;
    }

    private void beforeInvoke(String msg)
    {
        System.out.println("-------> beforInvoke:"+msg);
    }

    private void afterInvoke(String msg)
    {
        System.out.println("-------> afterInvoke:"+msg);
    }

    private String convertArgs(Object[] args)
    {
        if(args==null || args.length==0)
        {
            return null;
        }
        StringBuilder sb= new StringBuilder();
        for(Object object : args)
        {
            sb.append(object.toString());
        }

        return sb.toString();
    }
}

main:

public class Main {

    public static void main(String[] args) {

        System.out.println("##############");

        System.out.println("-------> 4 call:");
        UserService service4 = (UserService)new CglibDynamicProxy().getProxyObject(new UserServiceImpl());
        User user4 = service4.addUser();
        service4.editUser(user4);
        service4.deleteUser(user4.getUserId());

    }
}