动态代理模式

代理(Proxy)是一种设计模式,提供了对目标对象另外的访问方式;即通过代理对象访问目标对象.这样做的好处是:可以在目标对象实现的基础上,增强额外的功能操作,即扩展目标对象的功能.
这里使用到编程中的一个思想:不要随意去修改别人已经写好的代码或者方法,如果需改修改,可以通过代理的方式来扩展该方法,

JDK动态代理模式

需要用到的类:

• 一个实现invocationHandle接口的代理类
• 需要代理的接口
• 接口的实现类

代理的接口:

//媒婆
public class Meipo implements InvocationHandler {
    
    private Person target; //被代理对象的引用作为一个成员变量保存下来了
    
    //获取被代理人的个人资料
    public Object getInstance(Person target) throws Exception{
        this.target = target;
        Class clazz = target.getClass();
        System.out.println("被代理对象的class是:"+clazz);
        return Proxy.newProxyInstance(clazz.getClassLoader(), clazz.getInterfaces(), this);
    }
    

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        
        System.out.println("我是媒婆：" + "得给你找个异性才行");
        System.out.println("开始进行海选...");
        System.out.println("------------");
        
        //调用的时候
        method.invoke(this.target, args);
        System.out.println("------------");
        System.out.println("如果合适的话，就准备办事");
        
        return null;
    }

}

接口类:

public interface Person { 
    //寻找真爱、相亲
    void findLove();  
}

具体实现类 -> 被代理类

//小星星、单身
public class XiaoXingxing implements Person {

    @Override
    public void findLove() {
        System.out.println("高富帅");
        System.out.println("有房有车的");
        System.out.println("身高要求180cm以上，体重70kg");
    }
 
    //回顾一下，满足代理模式应用场景的三个必要条件，穷取法
    //1、两个角色：执行者、被代理对象
    //2、注重过程，必须要做，被代理对象没时间做或者不想做（怕羞羞），不专业
    //3、执行者必须拿到被代理对象的个人资料（执行者持有被代理对象的引用）
}

具体测试:

        // 这里获取拿到具体的实现类,通过Meipo这个类进行代理拿到具体的接口对象进行嗲用
    Person obj = (Person)new Meipo().getInstance(new XiaoXingxing());
    System.out.println(obj.getClass());
        // 当
    obj.findLove();

总结

代理对象不需要实现接口,但是目标对象一定要实现接口,否则不能用动态代理

Cglib代理

1. 实现MethodInterceptor接口

ublic class GPMeipo implements MethodInterceptor{

    //疑问？
    //好像并没有持有被代理对象的引用
    public Object getInstance(Class clazz) throws Exception{
        
        Enhancer enhancer = new Enhancer();
        //把父类设置为谁？
        //这一步就是告诉cglib，生成的子类需要继承哪个类
        enhancer.setSuperclass(clazz);
        //设置回调
        enhancer.setCallback(this);
        
        //第一步、生成源代码
        //第二步、编译成class文件
        //第三步、加载到JVM中，并返回被代理对象
        return enhancer.create();
    }
    
    //同样是做了字节码重组这样一件事情
    //对于使用API的用户来说，是无感知
    @Override
    public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) 
throws Throwable {
        System.out.println("我是GP媒婆：" + "得给你找个异性才行");
        System.out.println("开始进行海选...");
        System.out.println("------------");
        //这个obj的引用是由CGLib给我们new出来的
        //cglib new出来以后的对象，是被代理对象的子类（继承了我们自己写的那个类）
        //OOP, 在new子类之前，实际上默认先调用了我们super()方法的，
        //new了子类的同时，必须先new出来父类，这就相当于是间接的持有了我们父类的引用
        //子类重写了父类的所有的方法
        //我们改变子类对象的某些属性，是可以间接的操作父类的属性的
        proxy.invokeSuper(obj, args);
        System.out.println("------------");
        System.out.println("如果合适的话，就准备办事");
        return null;
    }

}

具体被代理对象:

public class Moumoumou{
    public void findLove(){
        System.out.println("肤白貌美大长腿");
    }
}

测试类:

try {
            Moumoumou obj = (Moumoumou)new GPMeipo().getInstance(Moumoumou.class);
            obj.findLove();
        } catch (Exception e) {
            e.printStackTrace();
        }

总结

Cglib代理,也叫作子类代理,它是在内存中构建一个子类对象从而实现对目标对象功能的扩展.
JDK的动态代理有一个限制,就是使用动态代理的对象必须实现一个或多个接口,如果想代理没有实现接口的类,就可以使用Cglib实现.

Cglib是一个强大的高性能的代码生成包,它可以在运行期扩展java类与实现java接口.它广泛的被许多AOP的框架使用,例如Spring AOP和synaop,为他们提供方法的interception(拦截)
Cglib包的底层是通过使用一个小而块的字节码处理框架ASM来转换字节码并生成新的类.不鼓励直接使用ASM,因为它要求你必须对JVM内部结构包括class文件的格式和指令集都很熟悉.

Cglib子类代理实现方法:

1. 需要引入cglib的jar文件,但是Spring的核心包中已经包括了Cglib功能,所以直接引入pring-core-3.2.5.jar即可.
2. 引入功能包后,就可以在内存中动态构建子类
3. 代理的类不能为final,否则报错
4. 目标对象的方法如果为final/static,那么就不会被拦截,即不会执行目标对象额外的业务方法.

另外一个小的知识点:
Spring中使用AOP代理的时候会分为JDK和Cglib两种代理方式取决的方式就和上面的相关:

• 当目标类对象有实现接口的采用JDK代理
• 没有实现接口,就是普通类的时候采用Cglib