模拟ORM实物延迟加载的应用分销模式

.Entitytity在NET中 Framework 和 java里面的 Hibernate都是ORM架构，两者都采用延时加载，延时加载是为了提高性能，在减轻服务器内存工作压力方面发挥着重要作用。延迟加载是指只有在第一次使用某个物体的方法或特性时才能复位物体线。延迟加载是指在第一次使用某个物体的方法或特性时，只复位物体线。延迟加载适用于建立大成本对象。如下所示，我选择分销模式来模拟一个简单的延迟加载的例子。

首先，我重新定义了一个叫IOperation的插口，定义如下：

 1 public interface IOperation
 2 {
 3     /// 

 4     /// 由衍生类完成的叙述信息声明的方法。
 5     /// 
 6     void Describe();
 7     /// 

 8     /// 声明销毁订单信息的操作，实际上由派生类操作
 9     /// 
10     void DestoryOrder();
11 }

     然后定义两个dao层，Product类和order类，各表示两个相互关联的实体线，将Order类自变量注入Product类，用于在Product类中使用Order类实例。让Product类完成IOperate插口。让Product类完成IOperate插口。

Product类定义如下：

 1 public class Product : IOperation
 2 {
 3     private Order _order;
 4     public Product()
 5     {
 6         Console.WriteLine(>>逐步复位Product类别...");
 7         Stopwatch sw = new Stopwatch();
 8         sw.Start();
 9         this._order = new Order();
10         sw.Stop();
11         Console.WriteLine(>>复位Product类。时间：{0}秒”， sw.ElapsedMilliseconds / 1000);
12     }
13     public void Describe()
14     {
15         Console.WriteLine(>>Product叙述:我的实例是Product，实施Describe方法。");
16     }
17     public void DestoryOrder()
18     {
19         Console.WriteLine(">>Product.DestoryOrder()方法开始实施...");
20         if (_order != null)
21         {
22             ///使用Order类Destroy实例法来销毁自己。
23             _order.Destroy();
24             Console.WriteLine(">>Product.DestoryOrder()实施方式。");
25         }
26     }
27 }

Order类定义如下： 

 1 public class Order
 2 {
 3     public Order()
 4     {
 5         Console.WriteLine(>>逐渐复位Order...");
 6         System.Threading.Thread.Sleep(5000);
 7         Console.WriteLine(>>复位Order类。");
 8     }
 9 
10     public void Destroy()
11     {
12         Console.WriteLine(">> Order 已销毁。");
13     }
14 }

然后在源程序中启用:

 1 static void Main(string[] args)
 2 {
 3     Console.WriteLine(==========================================);
 4     Product p = new Product();
 5     p.Describe();
 6     Console.WriteLine(============================================);
 7     Product p2 = new Product();
 8     p2.DestoryOrder();
 9     Console.ReadKey();
10 }

检测结果如下：

      从图中中，不难发现，使用Describe()复位Product5秒有问题吗？再看看上面的Describe()方法的完成，简单导出一句话，怎么用5秒？再看看Product的对象，在复位Product类的实例时，也复位了Order类，但我的Describe()方法并没有使用Order类的所有方法和特点，导致不必要的运行内存成本，也没有使用复位Order类的实例，形成了废物目标。

      如何解决这个问题？

      如何解决这个问题？所以这个地方要用代理。代理是什么？简单来说，代理就是创建一个与被调用目标具有相同功能的类别(这个相同的功能通常由插口标准)，可以在这个类别中使用被调用对象的方法，也可以为被调用方定制新的应用方法。让我们来看看代理商的建立。

首先，我创建了一个名为ProxyProduct的代理类别，使其能够实现IOperate插口，定义如下：

 1public class ProxyProduct : IOperation
 2{
 3    private IOperation entity;
 4
 5    public ProxyProduct(IOperation entity)
 6    {
 7        Console.WriteLine(>>逐步复位ProxyProductt...");
 8        Stopwatch sw = new Stopwatch();
 9        sw.Start();
10        this.entity = entity;
11        sw.Stop();
12        Console.WriteLine(>>复位ProxyProduct。时间：{0}秒”， sw.ElapsedMilliseconds / 1000);
13    }
14    /// 

在源程序中测试：

检测结果如下：

      从图中可以看出，启用Describe()方法需要0秒，启用DestoryOrder()方法时，复位代理类需要0秒，复位Product需要5秒，所以实施DestroyOrder()方法总共需要5秒。这样的结局是令人满意的，使用代理成功地实现了“使用谁的方式，复位谁；不使用不复位”的想法。这样的结局是令人满意的，使用代理成功地实现了“谁使用，谁复位；不使用不复位”的想法。在这种情况下，如果我总是只调整describe()，那么我总是花0秒，而不会造成额外的成本，这将对性能调整有很大的帮助。

      摘要：分销模式的应用之一：对于一些需要非常昂贵的对象，我们可以使用代理让对象在第一次使用方法或特征时建立案例，而不使用方法或特征永远不会建立案例。优点：性能调整，降低运输成本。

 ==================================================================================================================

插口：IOperate

实现类：ProductBean

 1 public class ProductBean implements IOperate {
 2     private OrdersBean ordersBean;
 3 
 4     /**
 5      * ProductBean类初始化实例
 6      */
 7     public ProductBean() {
 8         System.out.println(>>逐渐初始ProductBean...");
 9         long startTime = System.currentTimeMillis();
10         this.ordersBean = new OrdersBean();
11         long endTime = System.currentTimeMillis();
12         System.out.println(>>初始化ProductBean。用时："   (endTime - startTime) / 1000   "秒");
13     }
14 
15     public void describe() {
16         System.out.println(>>describe叙述:我是Productbean类，describe()实施。");
17     }
18 
19     public void destroyOrder() {
20         System.out.println(>>开始实施ProductBeand.destroyOrder()方式...");
21         if (this.ordersBean != null) {
22             this.ordersBean.destroy();
23             System.out.println(">>ProductBean.destroyOrder()实施方式。");
24         }
25     }
26 }
dao层：OrderBean

 1 public class OrdersBean {
 2     public OrdersBean() {
 3         System.out.println(>>OrderBean逐步初始化...");
 4         InitOrder();
 5         System.out.println(>>初始化OrderBean进行。");
 6     }
 7 
 8     /**
 9      * 订单信息的初始化
10      */
11     private void InitOrder() {
12         try {
13             // 加载交易数据，在这里模拟模拟需要3秒。
14             Thread.sleep(5000);
15         } catch (Exception e) {
16             e.printStackTrace();
17         }
18     }
19     
20     public void destroy() {
21         System.out.println(">> Order 已消毁。");
22     }
23 }
代理商类：ProxyProductBean

 1 public class ProxyProductBean implements IOperate {
 2     private IOperate bean;
 3 
 4     public ProxyProductBean(IOperate bean) {
 5         System.out.println(>>初始ProxyProductBean...");
 6         long startTime = System.currentTimeMillis();
 7         this.bean = bean;
 8         long endTime = System.currentTimeMillis();
 9         System.out.println(>>初始化ProxyProductBean。用时："   (endTime - startTime) / 1000   "秒");
10     }
11 
12     public void describe() {
13         System.out.println(>>describe叙述:我是ProxyProductBean，describe()实施。");
14     }
15 
16     public void destroyOrder() {
17         System.out.println(>>开始实施ProxyProductBean.destroyOrder()方式...");
18         if (bean == null) {
19             bean = new ProductBean();
20             bean.destroyOrder();
21             System.out.println(>>实施ProxyProductBean.destroyOrder()方式进行。");
22         }
23     }
24 }
测试类：
 1 public class Test {
 2     public static void main(String[] args) {
 3         System.out.println(======================================================);
 4         ProductBean productBean = new ProductBean();
 5         productBean.describe();
 6         System.out.println(===========使用代理类使用describe()方法==============;
 7         IOperate description = (IOperate) (new ProxyProductBean(null));
 8         description.describe();
 9         System.out.println(===========不使用代理类使用cascadeoperate()方式==============);
10         ProductBean productBean = new ProductBean();
11         productBean.destroyOrder();
12         System.out.println(===========使用代理类使用cascadeoperate()方式==============);
13         IOperate description = (IOperate) (new ProxyProductBean(null));
14         description.destroyOrder();
15     }
16 }