springAOP指的是在spring中的AOP,什么是AOP,相对于java中的面向对象(oop),在面向对象中一些公共的行为,像日志记录,权限验证等如果都使用面向对象来做,会在每个业务方法中都写上重复的代码,造成代码的冗余。而AOP指的是面向切面编程,定义一个切面,用切面去切相应的方法,就可以织入相关的逻辑。面向切面编程使用代理模式

一、代理模式

代理模式作为23种经典设计模式之一,其比较官方的定义为“为其他对象提供一种代理以控制对这个对象的访问”,简单点说就是,之前A类自己做一件事,在使用代理之后,A类不直接去做,而是由A类的代理类B来去做。代理类其实是在之前类的基础上做了一层封装。java中有静态代理、JDK动态代理、CGLib动态代理的方式。静态代理指的是代理类是在编译期就存在的,相反动态代理则是在程序运行期动态生成的,

二、静态代理

静态代理,简单点来说就是在程序运行之前,代理类和被代理类的关系已经确定。静态代理的实现方式一般有以下几个步骤,首先要定义一个公共的接口,供代理类和被代理类实现,如下

复制代码
package cn.com.staticProxy;
/**
 * * 
*<p>Title: IUserDao</p>
* <p>Description:公共的接口</p>
* <p>Company: </p>
* @author Administrator
* @date 2019年4月24日 下午4:15:12
 */
public interface IUserDao {

    void save();
    void find();
}
复制代码

然后是代理类和被代理类,先看被代理类,

复制代码
package cn.com.staticProxy;

public class UserDao implements IUserDao{
/**
 * 被代理类或者叫代理目标类
 */
    @Override
    public void save() {
        // TODO Auto-generated method stub
        
        System.out.println("模拟保存用户");
        
    }

    @Override
    public void find() {
        // TODO Auto-generated method stub
        System.out.println("模拟查找用户");
        
    }

}
复制代码

从被代理类上可以看到,被代理类要做的就是save和find操作,如果不使用代理模式,那么我们的使用方式则是直接使用,如下

复制代码
package cn.com.staticProxy;
/**
 * * 
*<p>Title: Test2</p>
* <p>Description:直接使用被代理类 </p>
* <p>Company: </p>
* @author Administrator
* @date 2019年4月24日 下午4:18:39
 */
public class Test2 {

    public static void main(String[] args) {
        // TODO Auto-generated method stub

        IUserDao udp=new UserDao();
        udp.save();
        System.out.println("-------------------");
        udp.find();
    }

}
复制代码

通过测试方法,可以得出执行方法的结果如下,

模拟保存用户
-------------------
模拟查找用户

 

下面看代理类,

复制代码
package cn.com.staticProxy;

public class UserDaoProxy implements IUserDao {

    private UserDao ud = new UserDao();

    @Override
    public void save() {
        // TODO Auto-generated method stub

        System.out.println("代理操作,开启事务");
        ud.save();
        System.out.println("代理操作,关闭事务");
    }

    @Override
    public void find() {
        // TODO Auto-generated method stub
        System.out.println("代理操作,开启事务");
        ud.find();
        System.out.println("代理操作,关闭事务");
    }

}
复制代码

可以看到代理类的实现逻辑是在代理类中持有一个被代理类的实例,通过被代理类实例调用被代理对象的方法,另外在方法之前前后均可加入其它的方法处理逻辑,

最后,看使用代理类的测试方法,

复制代码
package cn.com.staticProxy;

public class Test {

    public static void main(String[] args) {
        // TODO Auto-generated method stub

        IUserDao udp=new UserDaoProxy();
        udp.save();
        System.out.println("-------------------");
        udp.find();
    }

}
复制代码

返回的执行结果如下,

复制代码
代理操作,开启事务
模拟保存用户
代理操作,关闭事务
-------------------
代理操作,开启事务
模拟查找用户
代理操作,关闭事务
复制代码

对比,使用静态代理和不使用静态代理,可以发现使用了代理之后,可以在被代理方法的执行前或后加入别的代码,实现诸如权限及日志的操作。

但,静态代理也存在一定的问题,如果被代理方法很多,就要为每个方法进行代理,增加了代码维护的成本。有没有其他的方式可以减少代码的维护,那就是动态代理。

三、JDK动态代理

JDK提供了动态代理的方式,可以生成代理类,被代理类和接口沿用静态代理中的IUserDao和UserDao,UserDao为被代理类,下面看代理类,

复制代码
package cn.com.dynamicProxy;

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

import cn.com.staticProxy.IUserDao;
import cn.com.staticProxy.UserDao;
/**
 * * 
*<p>Title: DynamicProxy</p>
* <p>Description: 动态代理类</p>
* <p>Company: </p>
* @author Administrator
* @date 2019年4月24日 下午4:35:00
 */
public class DynamicProxy implements InvocationHandler{
    //被代理类的实例
    private IUserDao iud=null;

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        // TODO Auto-generated method stub
        Object result=null;
        System.out.println("开始JDK动态代理");
        method.invoke(iud, args);
        System.out.println("结束JDK动态代理");
        return result;
    }
    //构造方法
    public DynamicProxy(IUserDao iud){
        this.iud=iud;
    }
    
}
复制代码

需要实现JDK中的InvocationHandler接口,实现其中的invoke方法,在此方法中通过反射的方式调用被代理类的方法,可以在方法执行前或后进行别的处理,下面看测试代码

复制代码
package cn.com.dynamicProxy;

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

import cn.com.staticProxy.IUserDao;
import cn.com.staticProxy.UserDao;

public class Test2 {

    public static void main(String[] args) {
        // TODO Auto-generated method stub

        UserDao ud=new UserDao();
        
        DynamicProxy dp=new DynamicProxy(ud);
        
        //生成代理对象
        IUserDao iud=(IUserDao)Proxy.newProxyInstance(ud.getClass().getClassLoader(), ud.getClass().getInterfaces(), dp);
        iud.save();
        System.out.println("--------------");
        iud.find();
        
    }

    
}
复制代码

在测试代码中通过Proxy类的newProxyInstance方法,生成代理类的实例iud,需要三个参数,第一个为被代理类的类加载器,第二个为被代理类实现的接口,第三个则为invocationHandler的实现类,这样就生成了代理对象,然后通过代理对象调用方法执行结果如下,

复制代码
开始JDK动态代理
模拟保存用户
结束JDK动态代理
--------------
开始JDK动态代理
模拟查找用户
结束JDK动态代理
复制代码

另外,由于第三个参数为一个接口,还可以使用匿名内部类的方式进行书写,其实现代码如下,

复制代码
package cn.com.dynamicProxy;

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

import cn.com.staticProxy.IUserDao;
import cn.com.staticProxy.UserDao;

public class Test {

    public static void main(String[] args) {
        // TODO Auto-generated method stub

        //被代理类的实例
        UserDao ud = new UserDao();

        IUserDao iud = (IUserDao) Proxy.newProxyInstance(ud.getClass().getClassLoader(), ud.getClass().getInterfaces(),
                new InvocationHandler() {

                    @Override
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        // TODO Auto-generated method stub

                        Object result = null;
                        if ("find".equals(method.getName())) {
                            result = method.invoke(ud, args);
                        } else {
                            System.out.println("开始JDK代理");
                            result = method.invoke(ud, args);
                            System.out.println("结束JDK代理");
                        }

                        return result;
                    }
                });
        //使用代理类调用方法
        iud.find();
        System.out.println("----------------");
        iud.save();
    }

}
复制代码

执行结果如下,

复制代码
模拟查找用户
----------------
开始JDK代理
模拟保存用户
结束JDK代理
复制代码

从上面可以看出代理类是由Proxy这个类通过newProxyInstance方法动态生成的,生成对象后使用“实例调用方法”的方式进行方法调用,那么代理类的被代理类的关系只有在执行这行代码的时候才会生成,因此成为动态代理。

JDK的动态代理也存在不足,即被代理类必须要有实现的接口,如没有接口则无法使用JDK动态代理(从newProxyInstance方法的第二个参数可得知,必须传入被代理类的实现接口),那么需要使用CGLib动态代理。

四、CGLib动态代理

CGLib动态代理是一个第三方实现的动态代理类库,不要求被代理类必须实现接口,它采用的是继承被代理类,使用其子类的方式,弥补了被代理类没有接口的不足,

要使用CGLib必须要引入第三方类库,我这里使用的类库如下,

要使用CGLib代理需要实现其MethodInterceptor接口,

复制代码
package cn.com.cglib;

import java.lang.reflect.Method;

import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;

public class MyMethodInterceptor implements MethodInterceptor {

    @Override
    public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
        // TODO Auto-generated method stub
        
        System.out.println("开始CGLib动态代理");
        Object object=proxy.invokeSuper(obj, args);
        System.out.println("结束CGLib动态代理");
        return object;
    }

}
复制代码

其,测试代码如下,

复制代码
package cn.com.cglib;

import cn.com.staticProxy.UserDao;
import net.sf.cglib.proxy.Enhancer;

public class Test {

    public static void main(String[] args) {
        // TODO Auto-generated method stub

        Enhancer enhancer=new Enhancer();
        enhancer.setSuperclass(UserDao.class);
        enhancer.setCallback(new MyMethodInterceptor());
        //生成代理类
        UserDao ud=(UserDao) enhancer.create();
        ud.save();
System.out.println("----------------"); ud.find(); } }
复制代码

可以看出使用Enhancer生成代理类,需要设置被代理类,也就是父类(从这里可以看出是使用继承,生成的子类),设置回调方法。

复制代码
开始CGLib动态代理
模拟保存用户
结束CGLib动态代理
--------------------
开始CGLib动态代理
模拟查找用户
结束CGLib动态代理
复制代码

在设置回调enhancer.setCallback的时候需要传入MethodInterceptor的实例,这里可以使用匿名内部类的方式,可参照上面的。

五、总结

对静态代理、JDK动态代理、CGLib动态代理做一个总结,静态代理的维护成本比较高,有一个被代理类就需要创建一个代理类,而且需要实现相同的接口。JDK动态代理模式和CGLib动态代理的区别是JDK动态代理需要被代理类实现接口,而CGLib则是生成被代理类的子类,要求被代理类不能是final的,因为final类无法被继承。

下次会基于springAOP梳理相关内容。

 

转载于:https://www.cnblogs.com/teach/p/10763845.html