Java静态和动态代理学习笔记

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

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

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

相关阅读：

Java动态代理的学习

Java中利用动态代理,生成“空”对象的例子

Java动态代理简单实现

接口：
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------