java的三种代理方式-静态代理、jdk动态代理、cglib动态代理

测试无代理、静态代理、jdk动态代理、cglib动态代理

package com.insect.proxy;

import org.springframework.cglib.proxy.Enhancer;
import org.springframework.cglib.proxy.MethodInterceptor;
import org.springframework.cglib.proxy.MethodProxy;

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

public class test {
    public static void main(String[] args) {
        User user = new User();
        user.setPassword("1");
        user.setUsername("1");
        //无代理测试
        {
            UserServiceImpl userService = new UserServiceImpl();
            System.err.println("无代理+++++++++++"+userService.getClass().getName());
            userService.addUser(user);
            userService.delete(1);
        }
        //静态代理测试
        {
            UserServiceImplStaticProxy userServiceImplStaticProxy = new UserServiceImplStaticProxy();
            System.err.println("静态代理+++++++++++"+userServiceImplStaticProxy.getClass().getName());
            userServiceImplStaticProxy.addUser(user);
            userServiceImplStaticProxy.delete(1);
        }
        //jdk动态代理 通过实现原对象的接口生成增强对象
        {
            UserServiceImpl userService = new UserServiceImpl();
            /**
             * ClassLoader:类加载器  java程序执行  编写源码 .java->编译 .class ---类加载器---  -> jvm 执行
             *              jvm虚拟机会针对每一个class文件  分配一个ClassLoader
             *      作用：
             *          1、加载class文件到jvm虚拟机
             *          2、生成该文件对应的Class对象（类对象），从而创建实体类对象
             *
             *      代理类不会被分配类加载器，但是可以借用其他类的加载器，实现程序的运行
             *
             * interface：原始类实现的接口
             * invocationHandler：额外的功能
             */

            //业务增强的逻辑代码
            InvocationHandler invocationHandler = new InvocationHandler() {
                /**
                 * Object proxy：代表生成的代理对象
                 * Method method：原始类中被调用的方法
                 * Object[] args：调用方法的参数列表
                 * 返回值 Object：原始类方法的返回值
                 */
                @Override
                public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                    System.err.println("jdk-"+method.getName()+"-before");
                    Object invoke = method.invoke(userService, args);
                    System.err.println("jdk-"+method.getName()+"-before");
                    return invoke;
                }
            };
            //创建动态代理对象 userService  $proxy
            UserService userServiceFromJdk = (UserService) Proxy.newProxyInstance(test.class.getClassLoader(), userService.getClass().getInterfaces(), invocationHandler);
            System.err.println("jdk动态代理+++++++++++"+userServiceFromJdk.getClass().getName());
            userServiceFromJdk.addUser(user);
            userServiceFromJdk.delete(1);

        }
        //cglib动态代理 通过继承原对象生成增强对象
        {
            UserServiceImpl userService = new UserServiceImpl();
            Enhancer enhancer = new Enhancer();
            //设置相关参数
            enhancer.setClassLoader(test.class.getClassLoader());
            enhancer.setSuperclass(userService.getClass());
            //Callback增强的业务，类似jdk中的invoke方法
            MethodInterceptor methodInterceptor = new MethodInterceptor() {
                @Override
                public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
                    System.err.println("cglib-"+method.getName()+"-before");
                    Object invoke = method.invoke(userService,objects);
                    System.err.println("cglib-"+method.getName()+"-after");
                    return invoke;
                }
            };
            enhancer.setCallback(methodInterceptor);
            //通过enhancer创建代理对象
            UserServiceImpl userServiceFromCglib = (UserServiceImpl)enhancer.create();
            System.err.println("cglib动态代理+++++++++++"+userServiceFromCglib.getClass().getName());
            userServiceFromCglib.addUser(user);
            userServiceFromCglib.delete(1);
        }
    }
}

输出

下边有对应的实体类，需要就继续往下看

无代理+++++++++++com.insect.proxy.UserServiceImpl
service核心业务：添加用户对象com.insect.proxy.User@355da254
service核心业务：一个用户对象被删除,id = 1
静态代理+++++++++++com.insect.proxy.UserServiceImplStaticProxy
static-addUser-before
service核心业务：添加用户对象com.insect.proxy.User@355da254
static-addUser-after
static-delete-before
service核心业务：一个用户对象被删除,id = 1
static-delete-after
jdk-toString-before
jdk-toString-before
jdk动态代理+++++++++++com.sun.proxy.$Proxy0
jdk-addUser-before
service核心业务：添加用户对象com.insect.proxy.User@355da254
jdk-addUser-before
jdk-delete-before
service核心业务：一个用户对象被删除,id = 1
jdk-delete-before
cglib动态代理+++++++++++com.insect.proxy.UserServiceImpl$$EnhancerByCGLIB$$a189f706
cglib-addUser-before
service核心业务：添加用户对象com.insect.proxy.User@355da254
cglib-addUser-after
cglib-delete-before
service核心业务：一个用户对象被删除,id = 1
cglib-delete-after

用户类

package com.insect.proxy;

public class User {
    private String username;
    private String password;

    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;
    }
}

用户接口

package com.insect.proxy;

public interface UserService {
    boolean addUser(User user);
    Integer delete(Integer id);
}

被代理的实现类

package com.insect.proxy;

public class UserServiceImpl implements UserService{
    @Override
    public boolean addUser(User user) {
        System.err.println("service核心业务：添加用户对象"+user);
        return false;
    }

    @Override
    public Integer delete(Integer id) {
        System.err.println("service核心业务：一个用户对象被删除,id = "+id);
        return null;
    }
}

静态代理类

package com.insect.proxy;

//静态代理
public class UserServiceImplStaticProxy implements UserService{
    private UserServiceImpl userService= new UserServiceImpl();
    @Override
    public boolean addUser(User user) {
        System.err.println("static-addUser-before");
        boolean b = userService.addUser(user);
        System.err.println("static-addUser-after");
        return b;
    }

    @Override
    public Integer delete(Integer id) {
        System.err.println("static-delete-before");
        Integer i = userService.delete(id);
        System.err.println("static-delete-after");
        return i;
    }
}

参考博客 https://blog.csdn.net/weixin_43723296/article/details/125666513