JDK动态代理

---

创建接口

/**
 * 接口
 */
public interface UserDao {

    public void addUser();

    public void deleteUser();

    public void update();

    public void select();
}

创建接口实现类 --> 真实对象

/**
 * 真实对象
 */
public class UserDaoImpl implements UserDao {
    @Override
    public void addUser() {
        System.out.println("添加用户信息");
    }

    @Override
    public void deleteUser() {
        System.out.println("删除用户信息");
    }

    @Override
    public void update() {
        System.out.println("修改用户信息");
    }

    @Override
    public void select() {
        System.out.println("查询用户信息");
    }
}

代理类 --> 暂时没有，由代理类调用处理程序动态生成

增强方法

/**
* 增强方法
*/
public class MyLog {
   public void start(String msg) {
       System.out.println("开始执行" + msg + "方法");
   }

   public void end(String msg) {
       System.out.println(msg + "执行结束");
   }
}

代理类的调用处理程序

1. 实现InvocationHandler接口
2. 声明一个对象（用于注入被代理的对象）
3. 利用构造方法，将真实对象注入
4. 实现invoke方法
5. 在 invoke 方法中执行真实对象的方法，并且可以进行增强
6. 可在调用处理程序添加获取代理对象的方法（工具方法）

/**
* JDK代理
*/
public class JDKDynamicProxy implements InvocationHandler {

   //真实对象
   private Object target;

   public JDKDynamicProxy() {
   }

   //利用构造函数，将真实对象注入
   public JDKDynamicProxy(Object target) {
       this.target = target;
   }

   @Override
   public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
       //在真实对象的方法执行前后，可以进行增强操作
       MyLog log = new MyLog();
       log.start(method.getName());

       //执行真实对象的方法
       Object res = method.invoke(target, args);

       log.end(method.getName());

       return res;
   }

   //获取代理对象的工具方法
   public Object getProxy() {
       /**
        * Proxy.newProxyInstance(userDao.getClass().getClassLoader(), userDao.getClass().getInterfaces(), handler);
        * 参数一：真实对象（被代理的那个对象）的类加载器
        * 参数二：真实对象实现的接口
        * 参数三：实现InvocationHandler的对象
        */
       return Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), this);
   }
}

测试

1. 创被代理的真实对象
2. 代理对象的调用程序 --> 将真实对象注入
3. 获取代理对象
4. 代理对象为真实对象进行代理

public class MyTest {
    public static void main(String[] args) {
        //创建被代理的真实对象
        UserDao userDao = new UserDaoImpl();

        //代理对象的调用程序
        JDKDynamicProxy handler = new JDKDynamicProxy(userDao);
        //获取代理对象
        /**
         * Proxy.newProxyInstance(userDao.getClass().getClassLoader(), userDao.getClass().getInterfaces(), handler);
         * 参数一：真实对象（被代理的那个对象）的类加载器
         * 参数二：真实对象实现的接口
         * 参数三：实现InvocationHandler的对象
         */
        //若未在调用处理程序创建工具方法，则须下行代码创建代理对象
        //UserDao proxy = (UserDao) Proxy.newProxyInstance(userDao.getClass().getClassLoader(), userDao.getClass().getInterfaces(), handler);
        UserDao proxy = (UserDao) handler.getProxy();
        proxy.addUser();
        proxy.deleteUser();
        proxy.update();
        proxy.select();
    }
}

---

在来一个真实对象

public class UserDaoMySQLImpl implements UserDao {
    @Override
    public void addUser() {
        System.out.println("MySQL添加用户信息");
    }

    @Override
    public void deleteUser() {
        System.out.println("MySQL删除用户信息");
    }

    @Override
    public void update() {
        System.out.println("MySQL修改用户信息");
    }

    @Override
    public void select() {
        System.out.println("MySQL查询用户信息");
    }
}

复用代理对象调用处理程序

直接测试

public class MySQLTest {
    public static void main(String[] args) {
        UserDaoMySQLImpl userDaoMySQL = new UserDaoMySQLImpl();
        JDKDynamicProxy handler = new JDKDynamicProxy(userDaoMySQL);
        UserDao proxy = (UserDao) handler.getProxy();
        proxy.addUser();
        proxy.deleteUser();
        proxy.update();
        proxy.select();

        System.out.println("---------------------------------------");
        UserDaoImpl userDao = new UserDaoImpl();
        JDKDynamicProxy handler1 = new JDKDynamicProxy(userDao);
        UserDao proxy1 = (UserDao) handler1.getProxy();
        proxy1.addUser();
    }
}