代理的概念：用一个角色来代替另一个角色完成某些特定的功能。（引用某大神对代理的理解的原话，个人感觉很贴切）。

代理需要有三种角色：1、接口角色，2、代理对象角色（概念中的一个角色），3、被代理对象。（注意，代理对象和被代理对象必须实现相同的接口。个人理解，不懂对不对，请高手指正）

静态代理比较好理解，说白了就是两个实现类A和B实现同一个接口，我们可以定义类A为代理类，而类B为被代理类。A类在实现接口的同时还新增了一些处理方法，而这些方法就是在对目标对象方法进行调用之前进行的处理。

相关阅读：

接口：
package spring.proxy;
public interface UserManager
{
public String getUser(int userID);

public void delUser(int userID);

public void modifyUser(String userID,String password);
}

实现类B

package spring.proxy;
public class UserManagerImpl implements UserManager
{
@Override
public void delUser(int userID)
{
System.out.println("delUser------");
}
@Override
public String getUser(int userID)
{
System.out.println("getUser------");
return ""+userID;
}
@Override
public void modifyUser(String userID, String password)
{
System.out.println("modifyUser------");
}
}

实现类A（代理类）

package spring.proxy;
public class UserManagerImplProxy implements UserManager
{
private UserManager userManager;

public UserManagerImplProxy(UserManager userManager)
{
this.userManager = userManager;
}

@Override
public void delUser(int userID)
{
checkMethod();
userManager.delUser(userID);
}
@Override
public String getUser(int userID)
{
checkMethod();
String user = userManager.getUser(userID);
return user;
}
@Override
public void modifyUser(String userID, String password)
{
checkMethod();
userManager.modifyUser(userID, password);
}

//新增处理方法
public void checkMethod()
{
System.out.println("checkMethod-------");
}
}

客户端测试类
package spring.proxy;
public class Client
{
public static void main(String[] args)
{
UserManagerImplProxy proxy = new UserManagerImplProxy(new UserManagerImpl());
proxy.delUser(1);
}
}

测试结果：
checkMethod-------
delUser------

动态代理：
动态代理需要实现jdk的一个接口：java.lang.reflect.InvocationHandler
新建一个类实现该接口，
package spring.proxy;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
public class DynamicProxy implements InvocationHandler
{
private Object targetObject;

//根据目标对象创建代理
public Object createProxyInstance(Object targetObject)
{
this.targetObject = targetObject;
return Proxy.newProxyInstance(targetObject.getClass().getClassLoader(),
targetObject.getClass().getInterfaces(), this);
}
@Override
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable
{
checkMethod();
Object obj = method.invoke(targetObject, args);
return obj;
}

//新增处理功能
public void checkMethod()
{
System.out.println("checkMethod-------");
}
}

测试类：
package spring.proxy;
public class Client
{
public static void main(String[] args)
{
DynamicProxy dynamicProxy = new DynamicProxy();

UserManager userManager = (UserManager) dynamicProxy.createProxyInstance(new UserManagerImpl());//该类UserManagerImpl是静态代理的实现类A，该类实现接口UserManager
userManager.getUser(1);
}
}

测试结果：
checkMethod-------
getUser------