// 接口类
public interface OrderService {
    OrderDto createOrder(OrderDto orderDto);
}
// 实现类
public class OrderServiceImpl implements OrderService {
    @Override
    public OrderDto createOrder(OrderDto orderDto) {
        System.out.println("OrderServiceImpl#createOrder !!!");
        return null;
    }
}
// mian 方法
public static void main(String[] args) {
    OrderServiceImpl orderServiceImpl = new OrderServiceImpl();
    OrderService orderService = (OrderService)Proxy
        .newProxyInstance(OrderServiceHandler.class.getClassLoader(), orderServiceImpl.getClass().getInterfaces(),
                          (o, method, args1) -> {
                              System.out.println("before !!!");
                              Object invoke = method.invoke(orderServiceImpl, args1);
                              System.out.println("after  !!!");
                              return invoke;
                          });
    orderService.createOrder(new OrderDto());
}

before !!!
OrderServiceImpl#createOrder !!!
after  !!!

public static Object newProxyInstance(ClassLoader loader,
                                      Class<?>[] interfaces,
                                      InvocationHandler h)
    throws IllegalArgumentException
    {
        // ....
        // 查找或者生成代理类
        Class<?> cl = getProxyClass0(loader, intfs);
        // 使用代理类构造函数实例化对象
        try {
            if (sm != null) {
                checkNewProxyPermission(Reflection.getCallerClass(), cl);
            }
            final Constructor<?> cons = cl.getConstructor(constructorParams);
            final InvocationHandler ih = h;
            if (!Modifier.isPublic(cl.getModifiers())) {
                AccessController.doPrivileged(new PrivilegedAction<Void>() {
                    public Void run() {
                        cons.setAccessible(true);
                        return null;
                    }
                });
            }
            return cons.newInstance(new Object[]{h});
        } catch (IllegalAccessException|InstantiationException e) {
            throw new InternalError(e.toString(), e);
        } catch (InvocationTargetException e) {
            Throwable t = e.getCause();
            if (t instanceof RuntimeException) {
                throw (RuntimeException) t;
            } else {
                throw new InternalError(t.toString(), t);
            }
        } catch (NoSuchMethodException e) {
            throw new InternalError(e.toString(), e);
        }
    }

/**
 * Generate a proxy class.  Must call the checkProxyAccess method
 * to perform permission checks before calling this.
 */
private static Class<?> getProxyClass0(ClassLoader loader,
                                       Class<?>... interfaces) {
    if (interfaces.length > 65535) {
        throw new IllegalArgumentException("interface limit exceeded");
    }
    // If the proxy class defined by the given loader implementing
    // the given interfaces exists, this will simply return the cached copy;
    // otherwise, it will create the proxy class via the ProxyClassFactory
    return proxyClassCache.get(loader, interfaces);
}

public Class<?> apply(ClassLoader loader, Class<?>[] interfaces) {
            Map<Class<?>, Boolean> interfaceSet = new IdentityHashMap<>(interfaces.length);
            for (Class<?> intf : interfaces) {
            // ... 
            /*
             * Choose a name for the proxy class to generate.
             */
            long num = nextUniqueNumber.getAndIncrement();
            String proxyName = proxyPkg + proxyClassNamePrefix + num;
      // 通过接口生成代理类
            byte[] proxyClassFile = ProxyGenerator.generateProxyClass(
                proxyName, interfaces, accessFlags);
            try {
                return defineClass0(loader, proxyName,
                                    proxyClassFile, 0, proxyClassFile.length);
            } catch (ClassFormatError e) {
                /*
                 * A ClassFormatError here means that (barring bugs in the
                 * proxy class generation code) there was some other
                 * invalid aspect of the arguments supplied to the proxy
                 * class creation (such as virtual machine limitations
                 * exceeded).
                 */
                throw new IllegalArgumentException(e.toString());
            }
        }

// 没有接口的实现类
public class OrderService {
    public OrderDto createOrder(OrderDto orderDto) {
        System.out.println("OrderService#createOrder !!!");
        return null;
    }
}
// main 方法
public static void main(String[] args) {
    OrderService orderService = new OrderService();
    Enhancer enhancer = new Enhancer();
    enhancer.setSuperclass(orderService.getClass());
    enhancer.setCallback((MethodInterceptor)(obj, method, args1, proxy) -> {
        System.out.println("before !!!!");
        Object o = proxy.invokeSuper(obj, args1);
        System.out.println("after  !!!!");
        return o;
    });
    OrderService orderServiceProxy = (OrderService) enhancer.create();
    orderServiceProxy.createOrder(new OrderDto());
}

before !!!!
OrderService#createOrder !!!
after  !!!!