首页 > 代码库 > 设计模式——动态代理前戏——何为静态代理

设计模式——动态代理前戏——何为静态代理

2024-09-06 18:28:12   208人阅读

1：在明白动态代理之前必须明白什么是静态代理？

　　静态代理就是在不破坏原来类的包装基础上，为类添加新的功能？如果说一个功能的被不同类利用的多种方式的实现。

比如刚开始想要实现记录demo消耗时间的的方法，我们会这么做：

 1 package com.hone.proxy;
 2 
 3 import java.util.Random;
 4 //定义一个方法用于计算程序运行，并且休眠一段时间后所需要的时间。
 5 public class Tank0 {
 6     public static void main(String[] args) {
 7         Long start=System.currentTimeMillis();
 8         System.out.println("Tank  moving...........");
 9         
10         try {
11             Thread.sleep(new Random().nextInt(1000));
12         } catch (InterruptedException e) {
13             e.printStackTrace();
14         }
15         Long end=System.currentTimeMillis();
16         System.out.println("消耗的时间"+(end-start));
17     }
18 }

但是假如，我们还有其他的类需要实现这个功能用于计算运行的时间呢，因此是否可以提取出count方法，将count制作成一个接口，让每个类都实现count接口，共享其中的方法。让需要实现的tank，car类都实现Countable接口，实现里面的功能。

1 package com.hone.proxy;
2 
3 public interface Countable {
4     void count();
5 }

 

 1 package com.hone.proxy;
 2 import java.util.Random;
 3 //让Tank类实现Countable接口，实现里面的方法
 4 public class Tank implements Countable{
 5 
 6     @Override
 7     public void count() {
 8         Long start=System.currentTimeMillis();
 9         System.out.println("Tank  moving...........");
10         try {
11             Thread.sleep(new Random().nextInt(1000));
12         } catch (InterruptedException e) {
13             e.printStackTrace();
14         }
15         Long end=System.currentTimeMillis();
16         System.out.println("消耗的时间"+(end-start));
17     }
18 ｝

 同时car类中也有count（）方法，那么就可以用聚合的方式来实现car中的方法，而不需要在重新修改原来Tank的方法，

 1 package com.hone.proxy;
 2 
 3 import java.util.Random;
 4 
 5 /*
 6  * 利用聚合来处理tank的问题
 7  */
 8 public class car implements Countable{
15     Countable t=new Tank();
16 
17     @Override
18     public void count() {
19         Long start=System.currentTimeMillis();
20         System.out.println("Tank  moving...........");
21         try {
22             Thread.sleep(new Random().nextInt(1000));
23         } catch (InterruptedException e) {
24             e.printStackTrace();
25         }
26         Long end=System.currentTimeMillis();
27         System.out.println("消耗的时间"+(end-start));
28         
29     }
30 }

 

 

1 package com.hone.proxy;
2 
3 public class Test {
4     public static void main(String args[]){
5 
6     Countable c=new car();     //这里只需要山里面car就可以了，同时如果类比较多的话，也可用object统一配置
7     c.count();
8     }
9 }

 

这里面car类就完全实现了tank类的方法，这里面extends也可以实现同样的功能，但是extends的可扩展型太差。而且对于大量实现相同功能的类来说，代理+聚合的方法具有重要的意义，避免了一直实例化对象。

但是。。。静态代理本身也有很多弊端，不如这里面无论怎么样都得实例化对象，同时，如果方法改了或者或者说接口改了，是不是又得重新写接口呢？写类的实现呢？

因此，，，下次我们来引入动态处理。

设计模式——动态代理前戏——何为静态代理


联系
我们