个人中心
gpt4 book ai didi

Java静态代理与动态代理案例详解

转载 作者：qq735679552 更新时间：2022-09-29 22:32:09 27 4
gpt4 key购买 nike

CFSDN坚持开源创造价值，我们致力于搭建一个资源共享平台，让每一个IT人在这里找到属于你的精彩世界.

这篇CFSDN的博客文章Java静态代理与动态代理案例详解由作者收集整理，如果你对这篇文章有兴趣，记得点赞哟.

代理模式

代理模式（Proxy）：为其他对象提供一个代理以控制对这个对象的访问。

主要解决：在直接访问对象时带来的问题，比如说：要访问的对象在远程的机器上。在面向对象系统中，有些对象由于某些原因（比如对象创建开销很大，或者某些操作需要安全控制，或者需要进程外的访问），直接访问会给使用者或者系统结构带来很多麻烦，我们可以在访问此对象时加上一个对此对象的访问层.

代理模式的元素是：共同接口、代理对象、目标对象.

代理模式的行为：由代理对象执行目标对象的方法、由代理对象扩展目标对象的方法.

代理模式的宏观特性：对客户端只暴露出接口，不暴露它以下的架构.

好处多多：中间隔离了一层，更加符合开闭原则 。

UML图 。

Java静态代理与动态代理案例详解

创建一个接口

?
1
2
3
4
5
6
7
8
9
10
/**
  * @Author: Promsing
  * @Date: 2021/4/3 - 8:25
  * @Description: 买车的接口
  * @version： 1.0
  */
public interface BuyCar {
 
     public void buyCar();
}

创建一个实现类

?
1
2
3
4
5
6
7
8
9
10
11
12
13
/**
  * @Author: Promsing
  * @Date: 2021/4/3 - 8:25
  * @Description: 实现类
  * @version： 1.0
  */
public class BuyCarImpl implements BuyCar {
 
     @Override
     public void buyCar() {
         System.out.println( "我要买车~~~啦啦啦" );
     }
}

静态代理：

创建一个代理类 。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
/**
  * @Author: Promsing
  * @Date: 2021/4/3 - 8:26
  * @Description: 代理类
  * @version： 1.0
  */
public class BuyCarProxy implements BuyCar{
     private BuyCar buyCar;
     //注意事final修饰的关键字 不可修改
     //构造函数注入，需要被代理的对象
     public  BuyCarProxy( final BuyCar buyCar) {
         this .buyCar = buyCar;
     }
     //静态代理- 的实现方式
     @Override
     public void buyCar() {
         System.out.println( "不贷款，全款！买车前的准备~~~" );
         buyCar.buyCar();
         System.out.println( "买完车了，出去浪~~~" );
     }
}

客户端调用 。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
/**
  * @Author: Promsing
  * @Date: 2021/4/3 - 8:36
  * @Description: 客户端调用
  * @version： 1.0
  */
public abstract class ProxyTest implements BuyCar {
     public static void main(String[] args) {
         System.out.println( "-+-+-+正常调用-+-+-+" );
         BuyCar car= new BuyCarImpl();
         car.buyCar();
 
         System.out.println( "-+-+-+使用静态代理-+-+-+" );
         BuyCar proxy= new BuyCarProxy(car);
         proxy.buyCar();
     }
}
-+-+-+正常调用-+-+-+
我要买车~~~啦啦啦
 
-+-+-+使用静态代理-+-+-+
不贷款，全款！买车前的准备~~~
我要买车~~~啦啦啦
买完车了，出去浪~~~

动态代理：

基于接口的动态代理类 。

特点：字节码随用随创建，随用随加载 。

作用：在不修改源码的基础上对方法增强 。

涉及的类：JDK官方提供的Proxy 。

如何创建代理对象：使用Proxy类中的newProxyInstance方法 。

创建代理对象的要求：被代理类至少实现一个接口 。

newProxyInstance方法的参数 。

   ClassLoader：类加载器，同于加载被代理对象字节码 。

   Class[]：字节码数组---用于让代理对象和被代理对象拥有相同的方法 。

   InvocationHandler：用于提供被增强的代码 。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
/**
  * @Author: Promsing
  * @Date: 2021/4/3 - 9:09
  * @Description: 描述 形容
  * @version： 1.0
  */
public class DynamicProxy implements InvocationHandler {
     private BuyCar object;
 
     public DynamicProxy( BuyCar object) {
         this .object = object;
     }
 
     /**
      *
      * @param proxy  代理对象的引用
      * @param method 当前执行的方法
      * @param args 当前执行方法所需的参数
      * @return 和被代理对象方法有相同的返回值
      * @throws Throwable
      */
     @Override
     public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
         System.out.println( "不贷款，全款！买车前的准备~~~" );
         Object result = method.invoke(object, args);
         System.out.println( "买完车了，出去浪~~~" );
         return result;
     }
}

客户端 。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
public static void main(String[] args) {
    
       System.out.println( "-+-+-+使用基于接口的代理-+-+-+" );
       //方式1、如不写动态代理类DynamicProxy，可以在这里使用内部类
       //声明一个final修饰的对象
      /*
       final BuyCarImpl car=new BuyCarImpl();
       BuyCar proxy=(BuyCar)Proxy.newProxyInstance(car.getClass().getClassLoader(), car.getClass().getInterfaces(), new InvocationHandler() {
           @Override
           public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
               System.out.println("不贷款，全款！买车前的准备~~~");
               Object result = method.invoke(car, args);
               System.out.println("买完车了，出去浪~~~");
               return result;
           }
       });
       proxy.buyCar();
       */
 
       //方式2、使用DynamicProxy类
       //声明一个final修饰的对象
       final BuyCarImpl car= new BuyCarImpl();
       BuyCar proxy=(BuyCar)Proxy.newProxyInstance(car.getClass().getClassLoader(), car.getClass().getInterfaces(), new DynamicProxy(car));
       proxy.buyCar();
   }

基于子类的动态代理 。

特点：字节码随用随创建，随用随加载 。

作用：在不修改源码的基础上对方法增强 。

涉及的类：第三方cglib提供的Enhancer 。

如何创建代理对象：使用Enhancer类中create方法 。

创建代理对象的要求：被代理类不能是最终类 。

newProxyInstance方法的参数 。

   Class：用于被指定代理对象的字节码 。

   InvocationHandler：用于提供增强的方法 。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
public static void main(String[] args) {
 
        //使用基于子类的动态代理
        //需要引入Jar包--cglib 本案例使用cglib3.3.0
        System.out.println( "-+-+-+使用基于子类的代理-+-+-+" );
        final BuyCarImpl car= new BuyCarImpl();
         BuyCar proxy=  (BuyCar)Enhancer.create(car.getClass(), new MethodInterceptor() {
            @Override
            public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
                System.out.println( "不贷款，全款！买车前的准备~~~" );
                Object result = method.invoke(car, args);
                System.out.println( "买完车了，出去浪~~~" );
                return result;
 
            }
        });
         proxy.buyCar();
    }

到此这篇关于Java静态代理与动态代理案例详解的文章就介绍到这了,更多相关Java静态代理与动态代理内容请搜索我以前的文章或继续浏览下面的相关文章希望大家以后多多支持我！ 。

原文链接：https://blog.csdn.net/promsing/article/details/115411648 。

最后此篇关于Java静态代理与动态代理案例详解的文章就讲到这里了,如果你想了解更多关于Java静态代理与动态代理案例详解的内容请搜索CFSDN的文章或继续浏览相关文章，希望大家以后支持我的博客！ 。

27 4 0
文章推荐： Java之Jackson使用案例详解
文章推荐： Java8的Stream()与ParallelStream()的区别说明
文章推荐： Java中16条的代码规范
文章推荐： 基于JDK8-lambda表达式四种forEach性能对比
qq735679552
个人简介

我是一名优秀的程序员,十分优秀！

滴滴打车优惠券免费领取
滴滴打车优惠券
Copyright 2021 - 2024 cfsdn All Rights Reserved 蜀ICP备2022000587号
广告合作:1813099741@qq.com 6ren.com