JAVA动态代理（拦截器）

该实例是模拟安全性检查

 

被代理对象接口定义

 public interface UserManager {
     public void aadUser(User user);
     public void deleteById(int id);
     public void updateUser(User user);
     public User findById(int id);
 }

 

被代理对象接口实现

 public class UserManagerImp implements UserManager {
     @Override
     public void aadUser(User user) {
         System.out.println("----------addUser------------");
     }
     @Override
     public void deleteById(int id) {
         System.out.println("----------deleteById------------");
     }
     @Override
     public User findById(int id) {
         System.out.println("----------findById------------");
         return null;
     }
     @Override
     public void updateUser(User user) {
         System.out.println("----------updateUser------------");
     }
 }

 

 定义一个user对象

 public class User {
     private int id;
     private String name;
     private int age;
     public String getName() {
         return name;
     }
     public void setName(String name) {
         this.name = name;
     }
     public int getAge() {
         return age;
     }
     public void setAge(int age) {
         this.age = age;
     }
     public int getId() {
         return id;
     }
     public void setId(int id) {
         this.id = id;
     }
 }

 

 继承InvocationHandler接口

 package hb.proxy;

 import java.lang.reflect.InvocationHandler;
 import java.lang.reflect.Method;
 import java.lang.reflect.Proxy;

 /*
  * 1、动态代理类一定要实现InvocationHandler接口，就要实现invoke()方法
  */
 public class SecurityHandler implements InvocationHandler {
     private Object targetObject;
     /*
      * 下面方法是得到代理对象，如果得不到代理对象，这个效果也是没有作用的
      * 最后一个参数是InvocationHandler接口，这也是为什么动态代理对象一定要实现这个接口的原因
      * 得到的代理对象会执行invoke()方法
      */
     public Object newProxy(Object targetObject){
         this.targetObject = targetObject;
         //得到代理对象的方法，这个是反射机制里面的对象方法
         return Proxy.newProxyInstance(targetObject.getClass().getClassLoader(),
                                       targetObject.getClass().getInterfaces(),
                                       this);
     }
     /*
      * 在代理对象之前做业务处理，然后再做对象定义的方法，因此最后要返回代理的对象
      */
     @Override
     public Object invoke(Object proxcy, Method method, Object[] args)
             throws Throwable {
         if("aadUser".equals(method.getName())){
             System.out.println("method is aadUser");
             checkSecurity();
         }else{
             System.out.println("method is nod aadUser");
         }
         return method.invoke(this.targetObject, args);
     }

     public void checkSecurity(){
         System.out.println("-----------checkSecurity()----------");
     }
 }

 

 

 测试代码

 public class TestMain{
     public static void main(String[] args) {
         //产生一个安全代理的对象方法
         SecurityHandler handler = new SecurityHandler();
         //得到一个已经被代理的对象
         UserManager userManager = (UserManager)handler.newProxy(new UserManagerImp());

         User user = new User();
         user.setAge(23);
         user.setId(1);
         user.setName("huangbiao");
         //被代理对象做数据业务之前会先调用invoke()方法
         userManager.aadUser(user);
     }
 }