新建一个接口interface
public interface CommonInterface {void print(String string);
}

创建被代理对象类（目标类），需要实现interface
public class Target implements CommonInterface {public void print(String string) {System.out.println("this is CommonInterface and param is "+ string);}
}

创建代理类，需要实现interface
public class ProxyClass implements CommonInterface {// 静态代理的静态就体现在这里，把被代理的类对象硬编码。private Target target = new Target();public void print(String string) {System.out.println("before target");target.print(string);System.out.println("after target");}
}

测试类
public class Main {public static void main(String[] args) {ProxyClass proxyClass = new ProxyClass();proxyClass.print("wangwang");}
}

打印结果：

before target

this is CommonInterface and param is wangwang

after target

新建一个接口interface
public interface CommonInterface {int caculate(int a);
}

创建被代理对象类（目标类），需要实现interface
public class Target implements CommonInterface {public int caculate(int a) {return a * 2;}
}

创建代理类，需要实现interface
public class DynamicProxy implements InvocationHandler {private Object target = null;public DynamicProxy(Object target) {this.target = target;}public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {Object result = null;// 调用目标的方法result = method.invoke(target,args);// 方法增强，增加新的功能逻辑if(result != null){Integer res = (Integer)result;res += 5;result = res;}return result;}
}

测试类
public class Main {public static void main(String[] args) {// 1、创建目标对象Target target = new Target();// 2、创建handler对象DynamicProxy dynamicProxy = new DynamicProxy(target);///3、创建代理对象CommonInterface proxy = (CommonInterface)Proxy.newProxyInstance(target.getClass().getClassLoader(),target.getClass().getInterfaces(),dynamicProxy);System.out.println(proxy.caculate(2));}
}

数据结果：9

注：Proxy.newProxyInstance()方法接受三个参数：
ClassLoader loader : 指定当前目标对象使用的类加载器,获取加载器的方法是固定的
Class<?>[] interfaces : 指定目标对象实现的接口的类型,使用泛型方式确认类型
InvocationHandler : 指定动态处理器，执行目标对象的方法时,会触发事件处理器的方法

虽然相对于静态代理，动态代理大大减少了我们的开发任务，同时减少了对业务接口的依赖，降低了耦合度。但是还是有一点点小小的遗憾之处，那就是它始终无法摆脱仅支持interface代理的桎梏，因为它的设计注定了这个遗憾。回想一下那些动态生成的代理类的继承关系图，它们已经注定有一个共同的父类叫Proxy。Java的继承机制注定了这些动态代理类们无法实现对class的动态代理，原因是多继承在Java中本质上就行不通。有很多条理由，人们可以否定对 class代理的必要性，但是同样有一些理由，相信支持class动态代理会更美好。接口和类的划分，本就不是很明显，只是到了Java中才变得如此的细化。如果只从方法的声明及是否被定义来考量，有一种两者的混合体，它的名字叫抽象类。实现对抽象类的动态代理，相信也有其内在的价值。此外，还有一些历史遗留的类，它们将因为没有实现任何接口而从此与动态代理永世无缘。如此种种，不得不说是一个小小的遗憾。但是，不完美并不等于不伟大，伟大是一种本质，Java动态代理就是佐例。

引入cglib依赖
<dependency><groupId>cglib</groupId><artifactId>cglib</artifactId><version>3.1</version>
</dependency>

被代理的类

public class OldMethod {public void print(){System.out.println("hello world");}
}

代理过程，实现接口MethodInterceptor
public class  CglibProxy implements MethodInterceptor {public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {System.out.println("before cglib");Object result = methodProxy.invokeSuper(o, objects);System.out.println("after cglib");return result;}
}

测试类
public class CglibProxyTest {public static void main(String[] args) {Enhancer enhancer = new Enhancer();enhancer.setSuperclass(OldMethod.class);enhancer.setCallback(new CglibProxy());OldMethod cglibProxy = (OldMethod)enhancer.create();cglibProxy.print();}
}

输入结果：

before cglib
hello world
after cglib

       CGLIB创建的动态代理对象比JDK创建的动态代理对象的性能更高，但是CGLIB创建代理对象时所花费的时间却比JDK多得多。所以对于单例的对象，因为无需频繁创建对象，用CGLIB合适，反之使用JDK方式要更为合适一些。同时由于CGLib由于是采用动态创建子类的方法，对于final修饰的方法无法进行代理。