代理模式

/**
 * 目标接口
 */
public interface IUserDao {
    public void save();
    public void update();
}

/**
 * 目标类*/
public class UserDao implements IUserDao {
    @Override
    public void save() {
        System.out.println("保存用户");
    }
    @Override
    public void update() {
        System.out.println("更新用户");
    }
}

// AOP编程- 静态代理写法
    @Test
    public void test2() {
        // 目标对象
        IUserDao userDao = new UserDao();
        // 代理类对象
        IUserDao userProxy = new MyUserDaoProxy(userDao);
        // 使用代理类的方法
        userProxy.save();
        userProxy.update();
    }

/**
 * 代理类（静态代理）
 * 静态代理类写法步骤：
 * 1）编写一个代理类，实现目标接口（和目标对象一样的接口）
 * 2）创建或者传入目标类对象
 * 3) 重写或者增强目标类的方法
 */
public class MyUserDaoProxy implements IUserDao{
    private IUserDao target;
    public MyUserDaoProxy(IUserDao target){
        this.target  = target;
    }
    @Override
    public void save() {
        System.out.println("记录日志");
        target.save();
    }
    @Override
    public void update() {
        System.out.println("记录日志");
        target.update();
    }
}

// AOP编程- 动态代理写法
    @Test
    public void test3() {
        // 目标对象
        IUserDao userDao = new UserDao();
        // 从工具类获取代理类对象
        IUserDao userProxy = (IUserDao)ProxyUtil.getProxy(userDao);
        System.out.println(userProxy.getClass());
        // 使用代理类的方法
        userProxy.save();
        userProxy.update();
    }

/**
 * 动态代理类生成工具
 */
public class ProxyUtil {
    /**
     * 用于生成（动态）代理类
     * @param target 目标类对象
     * @return 生成后的代理类对象
     */
    public static Object getProxy(final Object target){
        return Proxy.newProxyInstance(
                target.getClass().getClassLoader(),// 类加载器。和目标对象的类加载器一致了！ 
                target.getClass().getInterfaces(), //接口列表，和目标对象的接口一致了！
                //匿名内部类
                new InvocationHandler() {
                    //该方法在每次调用代理类的方法时都会执行！
                    @Override
                    public Object invoke(Object proxy, Method method, Object[] args)
                            throws Throwable {
                        //System.out.println("=========="+method.getName());
                        System.out.println("记录日志");
                        //调用目标类的方法
                        /**
                         * 参数一：执行方法的对象
                         * 参数二：方法的参数列表
                         */
                        Object result = method.invoke(target, args);
                        return result;
                    }
                }
                );
    }
}

// AOP编程- 子类代理写法
    @Test
    public void test4() {
        // 目标对象
        UserDao2 userDao = new UserDao2();
        // 从工具类获取代理类对象
        UserDao2 userProxy = (UserDao2)SubProxyUtil.getProxy(userDao);
        System.out.println(userProxy.getClass());
        // 使用代理类的方法
        userProxy.save();
        userProxy.update();
    }

/**
 * 生成子类代理类对象的工具
 */
public class SubProxyUtil {
    /**
     * 生成某个类的子类对象
     * @param target 目标类（目标类可以不用接口）
     * @return 子类代理对象
     */
    public static Object getProxy(final Object target){
        //创建Enhancer对象
        Enhancer eh = new Enhancer();
        //设置父类
        eh.setSuperclass(target.getClass());
        //设置代理后的处理程序（类似Proxy的InvocationHandler）
        eh.setCallback(new MethodInterceptor() {
            //每次代理的方法调用都会执行
            @Override
            public Object intercept(Object arg0, Method method, Object[] args,
                    MethodProxy arg3) throws Throwable {
                //System.out.println("========"+method.getName());
                System.out.println("记录日志");
                //调用目标类的方法
                method.invoke(target, args);
                return null;
            }
        });
        //创建子类代理对象
        return eh.create();
    }
}