三种动态代理方式

一、建立Interface 

 

 

public interface IUserDao {  
    void save();  
}  

 

二、建立实现类

 

 

public class UserDao implements IUserDao {  
  
    @Override  
    public void save() {  
        // TODO Auto-generated method stub  
        System.out.println("我是原始方法，不要改变我哈");  
    }  
  
}

 

  

三、建立静态代理

 

 

public class UserDaoStaticProxy  implements IUserDao{  
    private IUserDao userDao;  
    public UserDaoStaticProxy (IUserDao userDao) {  
        this.userDao = userDao;  
    }  
    @Override  
    public void save() {  
        // TODO Auto-generated method stub  
        System.out.println("我是静态代理，启动前");  
        this.userDao.save();  
        System.out.println("我是静态代理，关闭前");  
    }  
      
}  

 

四、建立动态代理

//给全部的dao建立动态代理对象  
  
public class UserDaoDynamicProxy {  
    //维护一个目标对象  
    private Object targetObject;  
    public UserDaoDynamicProxy(Object target){  
        this.targetObject = target;  
    }  
    public Object getProxyInstance(){  
        return Proxy.newProxyInstance(  
                targetObject.getClass().getClassLoader(),  
                targetObject.getClass().getInterfaces(),   
                new InvocationHandler() {  
              
            @Override  
            public Object invoke(Object proxy, Method method, Object[] args)  
                    throws Throwable {  
                // TODO Auto-generated method stub  
                System.out.println("我是动态代理，开启事务");  
                  
                //执行目标对象方法  
                Object returnValue = method.invoke(targetObject, args);  
                  
                System.out.println("我是动态代理，关闭事务");  
                return returnValue;  
            }  
        });  
    }  
}  

 

五、建立Cglib代理

 

public class UserDaoCglibProxy implements MethodInterceptor{  
    //维护目标对象  
    private Object targetObject;  
    public UserDaoCglibProxy(Object target){  
        this.targetObject = target;  
    }  
      
    //给目标对象建立代理对象  
    public Object getProxyInstance(){  
        //工具类  
        Enhancer enhancer = new Enhancer();  
        //设置父类  
        enhancer.setSuperclass(targetObject.getClass());  
        //设置回调函数  
        enhancer.setCallback(this);  
        //建立子类  
        return enhancer.create();  
    }  
      
    @Override  
    public Object intercept(Object obj, Method method, Object[] args,  
            MethodProxy arg3) throws Throwable {  
        System.out.println("我是CGLIB代理对象，启动事务");  
        Object returnValueObject = method.invoke(targetObject, args);  
        System.out.println("我是CGLIB代理对象，关闭事务");  
        return returnValueObject;  
    }  
      
      
}  

 

六、建立测试类

public class App {  
  
    public static void main(String[] args) {  
        // TODO Auto-generated method stub  
        IUserDao userDao = new UserDao();  
        //静态代理对象  
//      1）能够作到在不修改目标对象的功能前提下，对目标对象功能扩展。  
//      2）缺点：  
//          --》  由于代理对象，须要与目标对象实现同样的接口。因此会有不少代理类，类太多。  
//          --》  一旦接口增长方法，目标对象与代理对象都要维护。  
        UserDaoStaticProxy proxy = new UserDaoStaticProxy(userDao);  
        proxy.save();  
          
        System.out.println("\n------------------------\n");  
        //动态代理对象  
//      1）代理对象，不须要实现接口；  
//      2）代理对象的生成，是利用JDKAPI， 动态的在内存中构建代理对象(须要咱们指定建立 代理对象/目标对象 实现的接口的类型；);  
//      3)  动态代理， JDK代理， 接口代理；  
//      代理对象不须要实现接口，可是目标对象必定要实现接口；不然不能用动态代理！  
//      static Object newProxyInstance(  
//              ClassLoader loader,       指定当前目标对象使用类加载器  
//               Class<?>[] interfaces,     目标对象实现的接口的类型  
//              InvocationHandler h       事件处理器  
//              )    
        IUserDao userDao2 = (IUserDao) new UserDaoDynamicProxy(userDao).getProxyInstance();  
        userDao2.save();  
          
        System.out.println("\n------------------------\n");  
        //Cglib代理，也叫作子类代理。在内存中构建一个子类对象从而实现对目标对象功能的扩展。  
//      JDK的动态代理有一个限制，就是使用动态代理的对象必须实现一个或多个接口。若是想代理没有实现接口的类，就可使用CGLIB实现。  
//      1) 须要引入cglib – jar文件， 可是spring的核心包中已经包括了cglib功能，因此直接引入spring-core-3.2.5.jar便可。  
//      2）引入功能包后，就能够在内存中动态构建子类  
//      3）代理的类不能为final， 不然报错。  
//      4） 目标对象的方法若是为final/static, 那么就不会被拦截，即不会执行目标对象额外的业务方法  
        IUserDao userDao3 = (IUserDao) new UserDaoCglibProxy(userDao).getProxyInstance();  
        userDao3.save();  
        //总结  
//      在Spring的AOP编程中，  
//      若是加入容器的目标对象有实现接口，用JDK代理；  
//      若是目标对象没有实现接口，用Cglib代理；  
  
    }  
  
}  

 

打印结果：

 

我是静态代理，启动前
我是原始方法，不要改变我哈
我是静态代理，关闭前

------------------------

我是动态代理，开启事务
我是原始方法，不要改变我哈
我是动态代理，关闭事务

------------------------

我是CGLIB代理对象，启动事务
我是原始方法，不要改变我哈
我是CGLIB代理对象，关闭事务