Java动态代理 - InvocationHandler - Proxy

参考博客

代码github地址

一：准备工作：

            1.定义接口类（一个或者多个）

            2.定义接口实现类，实现一个或者多个接口

二：实现动态代理

            自定义一个代理类实现InvocationHandler接口

                  关键点：

                             A：这个实现类中包含要代理的目标类（都是基于接口的）

                             B：定义一个包含代理目标类的有参构造函数

                             C：实现InvocationHandler接口的invoke方法（在里面可以添加字节想添加的业务）

三：使用这个代理类

            1.创建一个实现代理目标类接口的实现类实例

            2.获取刚刚创建的实现类实现的接口字节码数组

            3.利用自定义代理类的构造函数创建一个动态代理

            4.利用Proxy类的newProxyInstance方法创建一个代理目标类接口

            5.现在就可以调用接口的方法了

四：实例

     0 基础类：

     

package com.roger.pojo;

import lombok.Data;
import lombok.ToString;

@Data
@ToString
public class User {

    private Long id;
    private String name;
    private int age;
}

    1.定义接口     

package com.roger.service;

import com.roger.pojo.User;

public interface UserService {

    User findById(Long id);
}

    2. 定义接口实现类

package com.roger.service.impl;

import com.roger.pojo.User;
import com.roger.service.UserService;

public class UserServiceImpl implements UserService {

    @Override
    public User findById(Long id) {
        User user = new User();
        user.setId(id);
        return user;
    }
}

     3.自定义的动态代理类

package com.roger.proxy;

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

public class MyInvocationHandler implements InvocationHandler {

    private Object target;

    public MyInvocationHandler(Object target) {
        this.target = target;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("调用代理类方法之前执行");
        Object result = method.invoke(target,args);
        System.out.println("调用代理类方法之后执行");
        return result;
    }


    /**
     * 生成代理对象
     * @return
     */
    public Object getProxy(){
        ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
        Class<?>[] clazzInterface = target.getClass().getInterfaces();
        return Proxy.newProxyInstance(classLoader,clazzInterface,this);
    }
}

      4.客户端调用

package com.roger;

import com.roger.pojo.User;
import com.roger.proxy.MyInvocationHandler;
import com.roger.service.UserService;
import com.roger.service.impl.UserServiceImpl;

public class JdkProxyMain {

    public static void main(String[] args) {
        UserService userService = new UserServiceImpl();

        MyInvocationHandler handler = new MyInvocationHandler(userService);

        UserService proxy =(UserService) handler.getProxy();

        User user = proxy.findById(20L);
        System.out.println("result = " + user);
    }
}

五：静态代理和动态代理的本质区别

       静态代理：需要开发人员在项目中为每一个目标类写一个代理类

      动态代理：项目在运行时，Jvm自动在内存中为目标类生成一个代理类

六：Jdk动态代理类和CGLIB动态代理的区别

        Jdk动态代理是基于实现目标类所实现的所有接口类创建代理类对象，通过反射调用目标类的方法

       CGLIB动态代理是基于ASM字节码技术通过继承目标类创建代理对象，直接调用父类（目标类）方法