1. 动态代理，原理不多说了，网上理论很多，直接上代码。

动态代理方式,增强类通过实现InvocationHandler来增强目标类方法.
采用实现接口的方式使增强类依旧可以继承其他类或实现其他接口.

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

//  .动态代理模式
public class Count {

    public static void main(String[] args) {
        SayProxy proxy = new SayProxy(new SayImpl());
        // .获取代理对象
        SayImpl newProxyInstance =(SayImpl) Proxy.newProxyInstance(proxy.getClass().getClassLoader(), proxy
                .getClass().getInterfaces(), proxy);
        // .调用方法（此处方法已经被增强过了）
        newProxyInstance.say();
    }
}

interface Say {
    void say();
}

class SayImpl implements Say {
    @Override
    public void say() {
        System.out.println("我是原本的方法体！");
    }
}

// .代理类，实现增强。
class SayProxy implements InvocationHandler {

    private Object object;

    /**
     * 创建一个新的实例 SayProxy,根据传入类不同，实现动态代理。
     */

    public SayProxy(Object object) {
        this.object = object;
    }

    /**
     * 实现增强
     */
    @Override
    public Object invoke(Object proxy, Method method, Object[] args)
            throws Throwable {
        System.out.println("我已经前置增强完了");
        
        method.invoke(proxy, args);
        System.out.println("我已经后置增强完了");
        return null;
    }

}

2. Cglib的实现：

需要为代理类指定父类.

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

import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;

//  .动态代理模式
public class Count {

    public static void main(String[] args) {
        SayImpl sayImpl = new SayImpl();
        SayProxy proxy = new SayProxy(sayImpl);
        Enhancer enhancer = new Enhancer(); // 创建加强器，用来创建动态代理类
        enhancer.setSuperclass(sayImpl.getClass()); // 为加强器指定要代理的业务类（即：为下面生成的代理类指定父类）
        // 设置回调：对于代理类上所有方法的调用，都会调用CallBack，而Callback则需要实现intercept()方法进行拦
        enhancer.setCallback(proxy);
        SayImpl SayImplProxy = (SayImpl)enhancer.create();
        SayImplProxy.say();
    }
}

interface Say {
    void say();
}

class SayImpl implements Say {
    @Override
    public void say() {
        System.out.println("我是原本的方法体！");
    }
}

// .代理类，实现增强。
class SayProxy implements MethodInterceptor {

    private Object object;

    /**
     * 创建一个新的实例 SayProxy,根据传入类不同，实现动态代理。
     */

    public SayProxy(Object object) {
        this.object = object;
    }

    @Override
    public Object intercept(Object arg0, Method arg1, Object[] arg2,
            MethodProxy arg3) throws Throwable {
        System.out.println("前置增强");
        arg3.invokeSuper(arg0, arg2); // 调用业务类（父类中）的方法
        System.out.println("后置增强");
        return null;
    }

}