氟塑料離心泵www.buybeng.com
          

          jquery教程http://www.software8.co/wzjs/jquery/
          
			
          
				
					
	
          
		
          
			對于java的樹形結構的抽象與拓展
		
          
		
          近來幾日，在學習hibernate，在做練習的時候，想做一個樹形結構出來，比如組織架構，于是開始動手去嘗試，首先是利用hibernate自己的方式做一棵樹，于是開始動手構建persisten object，代碼如下：
           
          Java代碼  
          1. package com.zq.po;  
          2.   
          3. import javax.persistence.*;  
          4. import java.util.List;  
          5.   
          6.   
          7. @Entity  
          8. @Table(name = "t_modual")  
          9. public class Modual2 {  
          10.     private long dbid;  
          11.     private String nane;  
          12.     private String url;  
          13.     private Modual2 parent;  
          14.     private List<Modual2> children;  
          15.   
          16.     public Modual2() {  
          17.     }  
          18.     @Id  
          19.     @GeneratedValue(strategy = GenerationType.IDENTITY)  
          20.     public long getDbid() {  
          21.         return dbid;  
          22.     }  
          23.   public void setDbid(long dbid) {  
          24.         this.dbid = dbid;  
          25.     }  
          26.   
          27.     public String getNane() {  
          28.         return nane;  
          29.     }  
          30.   
          31.     public void setNane(String nane) {  
          32.         this.nane = nane;  
          33.     }  
          34.   
          35.     public String getUrl() {  
          36.         return url;  
          37.     }  
          38.   
          39.     public void setUrl(String url) {  
          40.         this.url = url;  
          41.     }  
          42.     @ManyToOne  
          43.     @JoinColumn(name = "parent_id")  
          44.     public Modual2 getParent() {  
          45.         return parent;  
          46.     }  
          47.     public void setParent(Modual2 parent) {  
          48.        this.parent = parent;  
          49.     }  
          50.     @OneToMany(mappedBy = "parent",cascade = CascadeType.ALL,fetch = FetchType.EAGER)  
          51.     public List<Modual2> getChildren() {  
          52.         return children;  
          53.     }  
          54.   
          55.     public void setChildren(List<Modual2> children) {  
          56.         this.children = children;  
          57.     }  
          58. }  
                 然后利用代碼聲生成結構，但是這樣一來，生成的表中，parent_id是強制關聯自己表的主鍵的，感覺這樣不是很靈活，于是就想著，把外鍵約束去掉，轉而在程序里控制好，這樣靈活性提高了。想想在工作中遇到的樹形結構的表設計中，也沒有加入外鍵約束，所以我就開始構建一個沒有外鍵約束的樹形結構。
                經過思考，我決定使用如下的方式實現：抽象出一個BaseTree來，里面有主鍵，父親節點的ID，父親節點的對象和兒子節點的集合，這基本上是所有樹形結構都共有的特性，所以抽象出來，讓其他的樹去繼承，然后讓程序員更加關注本樹的業務字段。抽象出來的BaseTree代碼如下：   
           
          Java代碼  
          1. package com.zq.po;  
          2.   
          3. import java.util.List;  
          4.   
          5.   
          6. public class BaseTree<T> {  
          7.     private long dbid;  
          8.     private long parentId;  
          9.     private T parent;  
          10.     private List<T> children;  
          11.   
          12.    public long getDbid() {  
          13.         return dbid;  
          14.     }  
          15.   
          16.     public void setDbid(long dbid) {  
          17.         this.dbid = dbid;  
          18.     }  
          19.   
          20.     public long getParentId() {  
          21.         return parentId;  
          22.     }  
          23.   
          24.     public void setParentId(long parentId) {  
          25.         this.parentId = parentId;  
          26.     }  
          27.   
          28.     public T getParent() {  
          29.         return parent;  
          30.     }  
          31.   
          32.     public void setParent(T parent) {  
          33.         this.parent = parent;  
          34.     }  
          35.   
          36.     public List<T> getChildren() {  
          37.         return children;  
          38.   }  
          39.   
          40.     public void setChildren(List<T> children) {  
          41.         this.children = children;  
          42.     }  
          43. }  
                   然后再創建一棵樹，讓他繼承BaseTree，但是需要重寫主鍵和父節點ID這兩個屬性，因為需要把他們映射到數據庫里面去，代碼如下：
           
          Java代碼  
          1. package com.zq.po;  
          2.   
          3. import javax.persistence.*;  
          4. import java.util.List;  
          5.   
          6.   
          7. @Entity  
          8. @Table(name="t_orga")  
          9. public class Organization  extends BaseTree<Organization>{  
          10.     private long dbid;  
          11.     private long parentId;  
          12.     private String name;  
          13.     private int count;  
          14.     //private Organization parent;  
          15.     //private List<Organization> children;  
          16.   
          17.     public Organization() {  
          18.     }  
          19.     @Id  
          20.     @GeneratedValue(strategy = GenerationType.IDENTITY)  
          21.     public long getDbid() {  
          22.         return dbid;  
          23.     }  
          24.   
          25.     public void setDbid(long dbid) {  
          26.         this.dbid = dbid;  
          27.     }  
          28.   
          29.     public String getName() {  
          30.         return name;  
          31.     }  
          32.   
          33.     public void setName(String name) {  
          34.         this.name = name;  
          35.     }  
          36.   
          37.     public int getCount() {  
          38.         return count;  
          39.     }  
          40.   
          41.     public void setCount(int count) {  
          42.         this.count = count;  
          43.     }   
          44.     public long getParentId() {  
          45.         return parentId;  
          46.     }  
          47.   
          48.     public void setParentId(long parentId) {  
          49.         this.parentId = parentId;  
          50.     }  
          51.     /*@Transient 
          52.     public Organization getParent() { 
          53.         return parent; 
          54.     } 
          55.  
          56.     public void setParent(Organization parent) { 
          57.         this.parent = parent; 
          58.     } 
          59.     @Transient 
          60.     public List<Organization> getChildren() { 
          61.         return children; 
          62.     } 
          63.  
          64.     public void setChildren(List<Organization> children) { 
          65.         this.children = children; 
          66.     }*/  
          67. }  
                這樣，模型就出來了，創建出來的表結構如下圖：完全沒有了外鍵約束符合要求：
                 

           
                  雖然是模型和表都整出來了，但是有一個問題，當我們把所有的樹節點都查詢出來的時候，他們自身只有一個父節點的ID，想訪問他的父節點或者是孩子節點，需要拿著該節點的主鍵查孩子節點或者拿著patentId查父親節點，很是麻煩，于是就想著整一個工具類，把全查出來的節點的父親和兒子都匹配上，目前只是完成了全部節點的匹配，以后還會完成某一個節點的匹配。建了一個工具類，代碼如下：
           
          Java代碼  
          1. public class BaseTreeUtil extends BaseTree {  
          2.     private BaseTree baseTree1;  
          3.     private BaseTree baseTree2;  
          4.   
          5.     public List allInit(List param)  {  
          6.         //找老子  
          7.         for (int i = 0; i < param.size(); i++) {  
          8.             baseTree1 = (BaseTree) param.get(i);  
          9.             if (baseTree1.getParentId() == -1) {  
          10.                 break;  
          11.             } else {  
          12.                 for (int j = 0; j < param.size(); j++) {  
          13.                     baseTree2 = (BaseTree) param.get(j);  
          14.                     if (baseTree2.getDbid() == baseTree1.getParentId()) {  
          15.                         baseTree2.setParent(baseTree1);  
          16.                     }  
          17.                 }  
          18.             }  
          19.         }  
          20.         //找兒子  
          21.         for (int k = 0; k < param.size(); k++) {  
          22.             baseTree1 = (BaseTree) param.get(k);  
          23.             List<BaseTree> sons = new ArrayList<BaseTree>();  
          24.             for (int l = 0; l < param.size(); l++) {  
          25.                 baseTree2 = (BaseTree) param.get(l);  
          26.                 if (baseTree1.getDbid() == baseTree2.getParentId()) {  
          27.                     sons.add(baseTree2);  
          28.                 }  
          29.             }  
          30.             baseTree1.setChildren(sons);  
          31.         }  
          32.         return param;  
          33.     }  
          34.   
          35. }  
                這樣就是把查出來的節點做循環，先是給每個節點的找到父親節點，然后在給每個節點去找兒子節點。
               附上一段測試代碼（片段）：
          Java代碼  
          1. public static void print(Organization orga, int level) {  
          2.      String show = "";  
          3.      for (int i = 0; i < level; i++) {  
          4.          show += "----";  
          5.      }  
          6.      System.out.println(show + orga.getName());  
          7.      level++;  
          8.      for (Organization children : orga.getChildren()) {  
          9.          print(children, level);  
          10.      }  
          11.  }  
          12.  @Test  
          13.  public void testSelect02() {  
          14.      Session session = this.before();  
          15.      Transaction tx = session.beginTransaction();  
          16.   
          17.      Query query =session.createQuery("from Organization ");  
          18.      List<Organization> list=query.list();  
          19.      List list2= new BaseTreeUtil().allInit(list);  
          20.   
          21.      print((Organization)list2.get(0), 0);  
          22.   
          23.      this.after(tx);  
          24.   
          25.   
          26.  }  
              不好意思，忘記附上表的數據了，補上：


           
            最后測試的結果如下：
           

           

           到此，基本的功能都已經實現了，剩下需要做的有如下幾個：
                  1、晚上BaseTreeUtil的功能
                  2、把以上內容應用到DAO層的編寫中，整合到spring進行測試
            后續工作的總結寫在下次日志中。
          原文鏈接：          http://www.software8.co/wzjs/java/3335.html
          
		
          
			posted on 2013-03-13 17:33 你爸是李剛 閱讀(1925) 評論(0)  編輯  收藏  
		
          
	
          
	
	


	


          
	    
    




          





          


          

	
          
		
          
				
		
	
		
          
		
		
          只有注冊用戶登錄后才能發表評論。
          
		
          
			
		
          
			
		
          
		
		
          
		


          

		          		
		
          
		
          			
		
		
		
		
          
		
          
		
		
          
		
          
			網站導航:
		
		
          
		
          
			
		
          	
		
          
			 
		
          
		
          
			
		
          
		
          
			
				
		
          		
	
          	

          



          

				
			
          
			
          
				
					
          
	
          
		
          <2013年3月>
          
	
          日一二三四五六
          242526272812
          3456789
          10111213141516
          17181920212223
          24252627282930
          31123456
          

          

					

          導航
          

					

          統計
          
	
					
					

          常用鏈接
          


          留言簿
          


		
          隨筆檔案
          
		
				
			
	
		
          文章檔案
          
		
				
			
	
		
          技術網站
          
		
				
			
	
		
          行業網站
          
		
				
			
	



          搜索
          



          最新評論
	
          



          閱讀排行榜
          



          評論排行榜
          


				
			
          			
			

	

          
  
          
    站長網
    氟塑料離心泵
    注塑機
    液晶廣告機
  
          

          
    







          
        
	




主站蜘蛛池模板：
纳雍县|
奉贤区|
通许县|
乐平市|
都安|
昌黎县|
佳木斯市|
中方县|
萝北县|
大荔县|
太仆寺旗|
江永县|
亚东县|
牙克石市|
屏南县|
遵义市|
墨脱县|
乐业县|
习水县|
南丰县|
天镇县|
武安市|
黎平县|
如皋市|
巴马|
濮阳县|
永川市|
宝应县|
富平县|
贵溪市|
石柱|
阿城市|
台江县|
静乐县|
沂南县|
麦盖提县|
招远市|
汝城县|
陆良县|
库车县|
大同市|