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

代理需要有三种角色：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------