关于代理模式

最新推荐文章于 2021-07-26 09:23:03 发布

原创最新推荐文章于 2021-07-26 09:23:03 发布 · 327 阅读

1 ·

CC 4.0 BY-SA版权

文章标签：

#设计模式

初出茅庐专栏收录该内容

10 篇文章

订阅专栏

Java代理模式核心思想：我不行就找别人不勉强自己

Java中典型的代理模式：SpringAOP HIbernate数据查询

代理模式分类：静态代理和动态代理

静态代理：

聚合方式：将目标类作为代理类的成员变量使用构造器将目标类注入要求代理类和目标类实现相同接口




//公共接口
package com.briup.Proxy.Static;

public interface car {
    public void drive();
}

//目标类（被代理了）

package com.briup.Proxy.Static;

public class OrdinaryCar implements  car {
    @Override
    public void drive() {
        System.out.println("开车");
    }
}


//代理类
package com.briup.Proxy.Static;

public class ProxyCar implements car {
//引用目标对象
    private car c;

    public ProxyCar(car c) {
        this.c = c;
    }
    @Override
    public void drive() {
//目标对象的操作
          c.drive();
//对代理类额外做的操作（对目标类功能的扩展）
        System.out.println("边开车边唱歌");
    }

}



//测试类代码
public class Test {
    public static void main(String[] args) {
        car ordinaryCar = new OrdinaryCar();
        car proxyCar = new ProxyCar(ordinaryCar);
        proxyCar.drive();
    }
}

继承方式: 通过子类继承父类的方式进行功能的扩展（不建议使用）

//子类实现
package com.briup.Proxy.Static;

public class ProxyCar_2 extends OrdinaryCar {

    
    @Override
    public void drive() {
        System.out.println("开车前不喝酒");
        super.drive();
        System.out.println("边开车边喝酒");
    }

}
//测试类

package com.briup.Proxy.Static;

public class Test {
    public static void main(String[] args) {
        ProxyCar_2 proxyCar_2 = new ProxyCar_2();
        proxyCar_2.drive();
    }
}

动态代理

jdk动态代理：代理类和目标类需要实现同一接口（是SpringAOP的优先选择）使用JDK提供的类实现代理模式主要的类有Proxy InvoktionHandler


//接口：
package com.briup.Proxy.dynamic.JDK;

public interface Update {
    public void one();
    public void two();
}


//目标类

package com.briup.Proxy.dynamic.JDK;

public class UpdateImp implements  Update{
    @Override
    public void one() {
        System.out.println("one");

    }

    @Override
    public void two() {
        System.out.println("two");
    }
}

//JDK动态代理类

package com.briup.Proxy.dynamic.JDK;

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

public class ProxyJDK implements InvocationHandler {
    private Object target;

    public ProxyJDK(Object target) {
        this.target = target;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] objects) throws Throwable {
        System.out.println("开车之前先考驾照");
        Object invoke = method.invoke(target, objects);
        System.out.println("开车之后喝点小酒");
        return invoke;
    }
}

//测试类
public class Test {
    public static void main(String[] args) {
        car ordinaryCar = new OrdinaryCar();
           car car= (com.briup.Proxy.Static.car) Proxy.newProxyInstance(Test.class.getClassLoader(),
                        new Class[]{car.class}, new ProxyJDK(ordinaryCar));
     car.drive();
        UpdateImp updateImp = new UpdateImp();
        Update up= (Update) Proxy.newProxyInstance(Test.class.getClassLoader(),
                new Class[]{Update.class},new ProxyJDK(updateImp));
        up.one();
        up.two();

    }
}

Cglib动态代理：代理类和目标类不需要实现相同接口

Cglib代理是功能最为强大的一种代理方式，因为其不仅解决了静态代理需要创建多个代理类的问题，还解决了jdk代理需要被代理对象实现某个接口的问题。对于需要代理的类，如果能为其创建一个子类，并且在子类中编写相关的代理逻辑，因为“子类 instanceof 父类”，因而在进行调用时直接调用子类对象的实例，也可以达到代理的效果。Cglib代理的原理实际上是动态生成被代理类的子类字节码，由于其字节码都是按照jvm编译后的class文件的规范编写的，因而其可以被jvm正常加载并运行。这也就是Cglib代理为什么不需要为每个被代理类编写代理逻辑的原因。这里需要注意的是，根据Cglib实现原理，由于其是通过创建子类字节码的形式来实现代理的，如果被代理类的方法被声明final类型，那么Cglib代理是无法正常工作的，因为final类型方法不能被重写

依赖导入：

 <dependency>
            <groupId>cglib</groupId>
            <artifactId>cglib</artifactId>
            <version>2.2.2</version>
        </dependency>

代码实现：




//目标类沿用JDK代理的例子

//Cglib代理类
package com.briup.Proxy.dynamic.Cglib;


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

import java.lang.reflect.Method;

public class CglibProxy implements MethodInterceptor {
    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        System.out.println("代理之前");
        Object o1 = methodProxy.invokeSuper(o, objects);
        System.out.println("代理之后");
        return o1;
    }
}

//测试类
package com.briup.Proxy.dynamic.Cglib;

import com.briup.Proxy.dynamic.JDK.UpdateImp;
import net.sf.cglib.proxy.Enhancer;

public class Test {
    public static void main(String[] args) {
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(UpdateImp.class);
        enhancer.setCallback(new CglibProxy());
        UpdateImp up= (UpdateImp) enhancer.create();
        up.one();

    }
}

代理模式的优缺点：

优点：