普通代理的缺点是要针对每个接口和实现类写一个代理类，动态代理从代码上简化了此项工作。
在JDK中通过继承InvocationHandler 实现动态代理，根据一个实现类自动生成一个继承了该实现类接口的实现对象，并可以自定义在接口方法执行前后的操作。
一、接口定义
package com.casic.test.JdkProxy;
public interface UserService {
// 添加用户
public void addUser();
// 删除用户
public void deleteUser();
// 查询用户
public void queryUsers();
}
二、实现类定义
package com.casic.test.JdkProxy;
public class UserServiceImpl implements UserService {
public void addUser() {
System.out.println("添加 一个用户 ");
}
public void deleteUser() {
System.out.println("删除一个用户 ");
}
public void queryUsers() {
System.out.println("查询所有用户 ");
}
}
三、代理类定义
package com.casic.test.JdkProxy;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
/**
* 继承InvocationHandler 实现动态代理
* @author ht
*/
public class LogProxy implements InvocationHandler{
// 源对象
private Object target;
// 使用构造函数传入源对象
public LogProxy(Object target) {
this.target = target;
}
/**
* 获取代理的实例，根据构造方法中传入的源对象，生成一个代理对象
* 生成的代理对象同样实现了源对象的继承的接口方法
* @return
*/
public Object CreateProxyInstance(){
return Proxy.newProxyInstance(//
getClass().getClassLoader(),//
this.target.getClass().getInterfaces(), this);
}
/**
* 重写此方法使得代理对象能够执行源对象所有方法
* 并且可以在执行前后做其他的操作
*/
public Object invoke(Object proxy,//
Method method, Object[] args) throws Throwable{
System.out.println("=========开始执行================");
/*源对象方法的执行，target 为源对象，args 为源对象的参数*/
Object result = method.invoke(target, args);
System.out.println("=========执行完毕================");
return result;
}
}
四、代理类调用
package com.casic.test.JdkProxy;
import org.junit.Test;
public class UserServiceTest {
@Test
public void test() {
UserService userService = new UserServiceImpl();
userService = (UserService) //
new LogProxy(userService).CreateProxyInstance();
userService.addUser();
}
}