[ ExtJS3.x 範例代碼 ] Ext.grid.GridPanel : 動態選擇 PageSize

參考自 這裡
View:
在 Ext.grid.GridPanel 上面添加 item 讓用戶可以動態選擇 Page Size: (demo)


Code:

view plaincopy to clipboardprint?

1. Ext.onReady(function(){    
2.     Ext.BLANK_IMAGE_URL = '../js/ext-3.4.0/resources/images/default/s.gif';  
3.     Ext.QuickTips.init();    
4.     Ext.form.Field.prototype.msgTarget = 'qtip';//統一指定錯誤訊息提示方式    
5.     var limit = 5;  
6.       
7.     var combo = new Ext.form.ComboBox({    
8.         name : 'perpage',    
9.         width: 40,    
10.         store: new Ext.data.ArrayStore({    
11.         fields: ['id'],    
12.         data  : [    
13.             [limit],    
14.             ['10'],    
15.             ['15']    
16.             ]    
17.         }),    
18.         
19.         mode : 'local',    
20.         value: limit,    
21.         listWidth     : 40,    
22.         triggerAction : 'all',    
23.         displayField  : 'id',    
24.         valueField    : 'id',    
25.         editable      : false,    
26.         forceSelection: true    
27.     });  
28.       
29.       
30.       
31.     combo.on('select', function(combo, record) {    
32.         pageBar.pageSize = parseInt(record.get('id'), 10);    
33.         pageBar.cursor = 0;    
34.         store.load({params:{start: pageBar.cursor, limit: pageBar.pageSize}});  
35.     }, this);  
36.   
37.     var store = new Ext.data.Store({//配置分組數據集    
38.         autoLoad :{params : {start : 0,limit : limit}},    
39.         reader: new Ext.data.JsonReader(),    
40.         proxy : new Ext.data.HttpProxy({    
41.             url : 'jsonServer.jsp'    
42.         })    
43.     });      
44.       
45.     var pageBar = new Ext.PagingToolbar({//分頁工具欄    
46.         store : store,    
47.         pageSize : limit,    
48.         displayInfo : true,    
49.         displayMsg : '第 {0} 條到 {1} 條，一共 {2} 條',    
50.         emptyMsg : "沒有數據",  
51.         items   :    [    
52.                       '-',    
53.                       'Per Page: ',    
54.                       combo    
55.                   ]   
56.     });  
57.                   
58.     var grid2 = new Ext.grid.GridPanel({    
59.             id : 'myGridID2',  
60.         title : '表格數據分頁',    
61.         viewConfig: {forceFit: true},  
62.         width:800,    
63.         height:500,    
64.         frame:true,   
65.         renderTo: null,  
66.         tbar : pageBar,  
67.         store: store,    
68.         columns: [//配置表格列    
69.             new Ext.grid.RowNumberer(),//表格行號組件    
70.             {header: "id", width: 80, dataIndex: 'personId', sortable: true},    
71.             {header: "姓名", width: 100, dataIndex: 'personName', sortable: true},    
72.             {header: "年齡", width: 100, dataIndex: 'personAge', sortable: true}    
73.         ]    
74.     });               
75.                       
76.       
77.       
78.     var win = new Ext.Window({  
79.         title: 'Index',  
80.         closable: false,  
81.         height:600,  
82.         width: 650,  
83.         bodyStyle: 'padding:10px',  
84.         contentEl: 'content',  
85.         autoScroll: true,  
86.         collapsible: true,  
87.         draggable: true,  
88.         maximizable: true,  
89.         items: [grid2]  
90.     });  
91.     win.show();  
92.          
93. });  

This message was edited 1 time. Last update was at 29/01/2013 17:49:32

[Linux 文章收集] 替 Linux 新增硬碟（磁碟分割、格式化與掛載）

來源自 這裡 
Preface: 
最近要替我的 Linux Server 增加一顆硬碟，一般若是在安裝 Linux 時就將硬碟裝上去的話，就可以直接在安裝時設定好硬碟的格式化與掛載，但若是後來要加掛新的硬碟，就要自己動手設定了. 

分割硬碟: 
新的硬碟應該是沒有任何分割的，所以要先用 fdisk 來分割硬碟，但是要分割新硬碟之前，要先搞清楚新的硬碟是哪一顆，弄錯可就慘了！先用 df 來看一下目前系統硬碟的使用情形 

# df -h
Filesystem Size Used Avail Use% Mounted on
/dev/sda1 440G 46G 372G 12% /
none 5.9G 260K 5.9G 1% /dev
none 5.9G 0 5.9G 0% /dev/shm
none 5.9G 64K 5.9G 1% /var/run
none 5.9G 0 5.9G 0% /var/lock
none 5.9G 0 5.9G 0% /lib/init/rw
/dev/sdb1 459G 198M 435G 1% /data1

而剛剛裝上去的新硬碟在這裡是看不到的，因為我們都還沒開始分割，接著在看看 /dev 下面所有的硬碟情況: 

# ls /dev/[sh]d*
/dev/sda /dev/sda1 /dev/sda2 /dev/sda5 /dev/sdb /dev/sdb1 /dev/sdc

這樣一比較就知道新的硬碟是 /dev/sdc 這顆，再用 fdisk 確認一下: 

# fdisk -l /dev/sdc
Disk /dev/sdc: 2000.4 GB, 2000398934016 bytes
255 heads, 63 sectors/track, 243201 cylinders
Units = cylinders of 16065 * 512 = 8225280 bytes
Sector size (logical/physical): 512 bytes / 512 bytes
I/O size (minimum/optimal): 512 bytes / 512 bytes
Disk identifier: 0x40bab849
Device Boot Start End Blocks Id System

看起來沒問題，沒有任何磁碟分割表的資訊，接著開始分割，首先進入 fdisk: 

# fdisk /dev/sdc

fdisk 是一個互動模式的分割工具，輸入 m 按 Enter 可以顯示各種指令的說明. 首先我們要新增一個分割區，步驟如下: 

1. 新增分割區，輸入 n 按 Enter。
2. 選擇要建立 extended 還是 primary partition，因為我的硬碟全部只要一個分割區，所以我選 primary，輸入 p 按 Enter。
3. 選擇 Partition number，primary 分割區最多可以有四個，隨便選都可以，不過建議選 1，免得以後看起來很奇怪，輸入 1 按 Enter。
4. 輸入開始的 cylinder，用預設值就可以了，直接按 Enter。
5. 輸入結束的 cylinder，若是要用最大的容量，就直接按 Enter，若是要指定分割區的大小，就用 +size{K,M,G} 的形式指定，例如指定為 100G 的大小就輸入 +100G 再按 Enter。
6. 最後將分割表寫入硬碟，輸入 w 再按 Enter。

以上整個過程看起來就像這樣: 
 

若是要離開 fdisk 就輸入 q 按 Enter 就可以了. 接著再用 fdisk 確認分割區: 

# fdisk -l /dev/sdc
Disk /dev/sdc: 2000.4 GB, 2000398934016 bytes
255 heads, 63 sectors/track, 243201 cylinders
Units = cylinders of 16065 * 512 = 8225280 bytes
Sector size (logical/physical): 512 bytes / 512 bytes
I/O size (minimum/optimal): 512 bytes / 512 bytes
Disk identifier: 0x40bab849
Device Boot Start End Blocks Id System
/dev/sdc1 1 243201 1953512001 83 Linux

最下面一行就是新的分割資訊，看起來沒什麼問題了，接著就要來格式化硬碟. 

格式化（Format）硬碟: 
現在新的 Linux 應該大都是用 Ext4 的檔案格式，若是較舊的 Linux 可能會用 Ext3，不過操作方法都大同小異. Linux 下格式化就用 mkfs 這個指令就可以: 

# mkfs -t ext4 /dev/sdc1

其中 -t 選項可以指定檔案系統，若是 Ext3 的話就指定為 -t ext3。等他跑完，硬碟的格式化就完成了，其輸出大約相這樣: 
 

接著就剩下掛載（mount）硬碟的工作了. 

掛載（mount）硬碟: 
在 Linux 下面的磁碟掛載設定都是寫在 /etc/fstab 中，而傳統的寫法是使用 /dev/sda1 這樣的方式指定磁碟，但是若是當磁碟更換安裝的順序時，原本的 /dev/sda1 有可能就會變成 /dev/sdb1，有時候光是分清楚哪顆是哪顆就夠頭痛的了. 

現在新的方式都是使用 UUID 來指定磁碟的，所以 /etc/fstab 看起來會像這樣: 
 

硬碟的 UUID 就像是它的身分證字號，每一顆硬碟都可不同的 UUID，使用 UUID 來指定磁碟就不會因為安裝的順序不同而產生變化，這樣做的好處是若是當磁碟常常要拔來拔去時，系統管理者不用再去更改 fstab 的設定，系統會自動尋找對應的 UUID 來掛載，很方便！ 

以 Ubuntu Linux 為例，基本上在安裝好系統時，/etc/fstab 中預設就是使用 UUID 來指定磁碟，但是若要自己增加一顆新的硬碟時，要如何來指定 UUID 呢？其實很簡單，就是利用 blkid 這個指令，它可以列出所有磁碟的 UUID: 

# sudo blkid
/dev/sda1: UUID="684530e1-df5c-48d7-b3e4-eb0d47054877" TYPE="ext4"
/dev/sda5: UUID="35ddf35e-87de-4ab0-88d1-2a654d36b19a" TYPE="swap"
/dev/sdb1: UUID="9746f325-1c82-4c04-b447-b5c596eea6c1" TYPE="ext4"
/dev/sdc1: UUID="146d3bb3-e351-45c8-ac84-42534ce51d29" TYPE="ext4"

所以現在就是依樣畫葫蘆，把新的硬碟資訊寫進 /etc/fstab 中，在 /etc/fstab 加入下面這行: 

UUID=146d3bb3-e351-45c8-ac84-42534ce51d29 /data2 ext4 defaults 0

這樣就大功告成了，下次重開機時，系統就會把新的硬碟掛載至 /data2，若要馬上測試掛載硬碟設定是否正確，可以使用 mount: 

# mount /dev/sdc1 /data2

再用 df -h 看一下，就知道有沒有問題了. 使用 UUID 掛載硬碟，只要設定一次，以後就不用煩惱掛載的問題了，真方便 

Supplement: 
* 鳥哥私房菜: 第八章、Linux 磁碟與檔案系統管理 

系統管理員很重要的任務之一就是管理好自己的磁碟檔案系統，每個分割槽不可太大也不能太小， 太大會造成磁碟容量的浪費，太小則會產生檔案無法儲存的困擾。此外，我們在前面幾章談到的檔案權限與屬性中， 這些權限與屬性分別記錄在檔案系統的哪個區塊內？這就得要談到 filesystem 中的 inode 與 block 了。 在本章我們的重點在於如何製作檔案系統，包括分割、格式化與掛載等...

* 格式化存儲裝置成為 Ext2/Ext3/Ext4 檔案系統 
* [Linux 小學堂] 柏青哥 SuSE Linux : Section 5.2 - 磁碟分割、格式化及掛載

[ Java 套件 ] JSON-lib - How to use json-lib

參考自 這裡
Preface:
最近要把視窗程式轉為 Web 介面的網頁, 因為該視窗程式包含蠻多服務, 所以想把 local 端的服務改成遠端呼叫的 web service. 如此該 Web 程式就可以專職顯示與人機互動. (即 MVC 中的 V=View). 在考慮 web service 間溝通的傳輸協定打算使用 json 格式, 故 survey 到 JSON-lib 這套 Java 的套件. 它的好處是可以直接將你已經用 Java 建立的物件 (map, bean etc) 直接轉為 json, 省掉你自己 coding 在 Java 世界與 json 世界中的轉換代碼, 相當方便. 下面將舉幾個範例提供後續使用參考.

Dependency and transformation limitation:
你要是用 JSON-lib 可以到 這裡下載 library, 但使用該 library 有下面相依性也要一併加入 classpath:
* jakarta commons-lang 2.5

The standard Java libraries fail to provide enough methods for manipulation of its core classes. Apache Commons Lang provides these extra methods...

* jakarta commons-beanutils 1.8.0

Most Java developers are used to creating Java classes that conform to the JavaBeans naming patterns for property getters and setters. It is natural to then access these methods directly, using calls to the corresponding getXxx and setXxx methods. However, there are some occasions where dynamic access to Java object properties (without compiled-in knowledge of the property getter and setter methods to be called) is needed...

* jakarta commons-collections 3.2.1

The Java Collections Framework was a major addition in JDK 1.2. It added many powerful data structures that accelerate development of most significant Java applications. Since that time it has become the recognised standard for collection handling in Java...

* jakarta commons-logging 1.1.1

When writing a library it is very useful to log information. However there are many logging implementations out there, and a library cannot impose the use of a particular one on the overall application that the library is a part of...

* ezmorph 1.0.6

EZMorph is simple java library for transforming an Object to another Object...

需要注意的是上面對應的版本訊息, 如果你使用太新的版本, 可能會有不相容的問題.

再來是可以從 Java 世界到 json 世界的物件也不是每個都可以, 下面有個清單說明那些物件可以自由在兩端轉換:


接著就來看一些範例.

Working with arrays and collections:
首先我們要來看看如何在 Java 世界將 Collections 如 array 轉為 JSONArray 物件. 很直覺的是直接呼叫 JSONArray.fromObject() 方法就搞定:

view plaincopy to clipboardprint?

1. package demo;  
2.   
3. import java.util.ArrayList;  
4. import java.util.List;  
5.   
6. import net.sf.json.JSONArray;  
7.   
8. public class Ex1 {  
9.     public static void main(String[] args) {  
10.         // 1.1) 建立 array  
11.         boolean[] boolArray = new boolean[]{true,false,true};  
12.         // 1.2) 轉換 Java 世界的 array 到  JSON 世界的 JSONArray  
13.         JSONArray jsonArray = JSONArray.fromObject(boolArray);  
14.         // 1.3) 檢查結果   
15.         System.out.printf("\t[Info] jsonArray=%s\n", jsonArray);  // prints [true,false,true]   
16.   
17.         // 2.1) 建立 List 物件並添加元素.  
18.         List list = new ArrayList();    
19.         list.add( "first" );    
20.         list.add( "second" );    
21.         // 2.2) 轉換 Java 世界的 List 到 JSON 世界的 JSONArray  
22.         JSONArray jsonArray2 = JSONArray.fromObject( list );    
23.         // 2.3) 檢查結果  
24.         System.out.printf("\t[Info] jsonArray2=%s\n", jsonArray2); // prints ["first","second"]      
25.       
26.         // 3.1) 透過 JSON 字串建立 JSONArray 物件.  
27.         JSONArray jsonArray3 = JSONArray.fromObject( "['json','is','easy']" );  
28.         // 3.2) 檢查結果  
29.         System.out.printf("\t[Info] jsonArray3=%s\n", jsonArray3);   // prints ["json","is","easy"]           
30.     }  
31. }  

執行結果:

[Info] jsonArray=[true,false,true]
[Info] jsonArray2=["first","second"]
[Info] jsonArray3=["json","is","easy"]

From Beans & Maps to JSON:
如果是 key/value pairs 的形式, 則可以參考下面將 java 世界中的 Map 轉為 JSON 世界的 JSONObject 物件. 透過方法 JSONObject.fromObject() 可以完成這個轉換, 甚至你可以將自製的類別傳入該方法, 它會透過反射取出 getter/setter 對應的 key/value pairs 幫你生成對應 JSONObject:

view plaincopy to clipboardprint?

1. package demo;  
2.   
3. import java.util.List;  
4. import java.util.ArrayList;  
5. import java.util.HashMap;  
6. import java.util.Map;  
7.   
8. import net.sf.json.JSONFunction;  
9. import net.sf.json.JSONObject;  
10.   
11. public class Ex2 {  
12.     public static class MyBean  
13.     {  
14.         private String name = "json";    
15.         private int pojoId = 1;    
16.         private char[] options = new char[]{'a','f'};    
17.         private String func1 = "function(i){ return this.options[i]; }";    
18.         private JSONFunction func2 = new JSONFunction(new String[]{"i"},"return this.options[i];");  
19.         private List choices = new ArrayList();  
20.           
21.         public MyBean()  
22.         {  
23.             choices.add("Choice1");  
24.             choices.add("Choice2");  
25.         }  
26.         public MyBean(String name, int pid, char[] opts, String func1, JSONFunction func2, List choices)  
27.         {  
28.             this.name = name;  
29.             this.pojoId = pid;  
30.             this.options = opts;  
31.             this.func1 = func1;  
32.             this.func2 = func2;           
33.             this.choices = choices;  
34.         }                 
35.           
36.         public String getName() {  
37.             return name;  
38.         }  
39.         public void setName(String name) {  
40.             this.name = name;  
41.         }  
42.         public int getPojoId() {  
43.             return pojoId;  
44.         }  
45.         public void setPojoId(int pojoId) {  
46.             this.pojoId = pojoId;  
47.         }  
48.         public char[] getOptions() {  
49.             return options;  
50.         }  
51.         public void setOptions(char[] options) {  
52.             this.options = options;  
53.         }  
54.         public String getFunc1() {  
55.             return func1;  
56.         }  
57.         public void setFunc1(String func1) {  
58.             this.func1 = func1;  
59.         }  
60.         public JSONFunction getFunc2() {  
61.             return func2;  
62.         }  
63.         public void setFunc2(JSONFunction func2) {  
64.             this.func2 = func2;  
65.         }  
66.         public List getChoices() {  
67.             return choices;  
68.         }  
69.         public void setChoices(List choices) {  
70.             this.choices = choices;  
71.         }                 
72.     }  
73.   
74.     public static void main(String[] args) {  
75.         Map map = new HashMap();    
76.         map.put( "name", "json" );    
77.         map.put( "bool", Boolean.TRUE );    
78.         map.put( "int", new Integer(1) );    
79.         map.put( "arr", new String[]{"a","b"} );    
80.         map.put( "func", "function(i){ return this.arr[i]; }" );    
81.             
82.         // 1) 轉換 Java 世界的 Map 物件到 JSON 世界的 JSONObject 物件.  
83.         JSONObject jsonObject = JSONObject.fromObject(map);    
84.         System.out.printf("\t[Info] jsonObject=%s\n", jsonObject);    
85.   
86.         // 2) 轉換 Java 世界的 Bean 物件到 JSON 世界的 JSONObject 物件.  
87.         JSONObject jsonObject2 = JSONObject.fromObject(new MyBean());    
88.         System.out.printf("\t[Info] jsonObject2=%s\n", jsonObject2);          
89.     }  
90.   
91. }  

執行結果:

[Info] jsonObject={"arr":["a","b"],"int":1,"name":"json","func":function(i){ return this.arr[i]; },"bool":true}
[Info] jsonObject2={"choices":["Choice1","Choice2"],"func1":function(i){ return this.options[i]; },...,"options":["a","f"],"pojoId":1}

From JSON to Beans:
既然能從 Java 世界轉換到 JSON 世界, 自然也能從 JSON 世界轉換回來 Java 世界. 可以透過 JSONObject.toBean() 方法完成 JSONObject->DynaBean 轉換:

view plaincopy to clipboardprint?

1. package demo;  
2.   
3. import static org.junit.Assert.assertEquals;  
4. import java.util.List;  
5. import net.sf.json.JSONArray;  
6. import net.sf.json.JSONObject;  
7. import org.apache.commons.beanutils.PropertyUtils;  
8. import org.junit.Test;  
9. import demo.Ex2.MyBean;  
10.   
11. public class Ex3 {  
12.     public static class MyBean  
13.     {  
14.         private String name = "name";  
15.         private int id = 1;  
16.         public String getName() {  
17.             return name;  
18.         }  
19.         public void setName(String name) {  
20.             this.name = name;  
21.         }  
22.         public int getId() {  
23.             return id;  
24.         }  
25.         public void setId(int id) {  
26.             this.id = id;  
27.         }     
28.           
29.         @Override  
30.         public boolean equals(Object o)  
31.         {  
32.             if(o instanceof MyBean)  
33.             {  
34.                 MyBean bean = (MyBean)o;  
35.                 if(bean.name.equals(name) && bean.id == id) return true;  
36.             }  
37.             return false;  
38.         }  
39.     }  
40.   
41.     @Test  
42.     public void test() throws Exception{  
43.         // 1) Convert to DynaBean:  
44.         String json = "{name=\"json\",bool:true,int:1,double:2.2,func:function(a){ return a; },array:[1,2]}";    
45.         JSONObject jsonObject = JSONObject.fromObject(json);    
46.         Object bean = JSONObject.toBean( jsonObject );    
47.         assertEquals( jsonObject.get( "name" ), PropertyUtils.getProperty( bean, "name" ) );    
48.         assertEquals( jsonObject.get( "bool" ), PropertyUtils.getProperty( bean, "bool" ) );    
49.         assertEquals( jsonObject.get( "int" ), PropertyUtils.getProperty( bean, "int" ) );    
50.         assertEquals( jsonObject.get( "double" ), PropertyUtils.getProperty( bean, "double" ) );    
51.         assertEquals( jsonObject.get( "func" ), PropertyUtils.getProperty( bean, "func" ) );    
52.         List expected = JSONArray.toList( jsonObject.getJSONArray( "array" ) );           
53.         assertEquals("List size=2", 2, expected.size());  
54.           
55.         // 2) Convert to MyBean:  
56.         MyBean bean2 = new MyBean();    
57.         JSONObject jsonObject2 = JSONObject.fromObject(bean2);  
58.         MyBean tbean = (MyBean)JSONObject.toBean(jsonObject2, MyBean.class);  
59.         assertEquals(bean2, tbean);       
60.     }  
61. }  

上面使用 JUnit4 撰寫 TestCase, 執行結果應該 All-pass. 有了以上的說明與範例, 相信接下來應用應該就不成問題, 更多的使用與教學可以參考 這裡.

Supplement:
* JUnit4 Annotations : Test Examples and Tutorial

JUnit4 Annotations are single big change from JUnit 3 to JUnit 4 which is introduced in Java 5. With annotations creating and running a JUnit test becomes more easy and more readable, but you can only take full advantage of JUnit4 if you know the correct meaning of annotations used on this version and how to use them while writing tests...

* JSON in Java

Here provides briefly review on each classes you may used in JSON-lib...

* Blog of toright> Java JSON API 教學 – Json-lib

JSON為輕量級的資料表示格式，比起 XML 鬆散許多且不需要定義描述檔，JSON網站 http://json.org/ ...

This message was edited 20 times. Last update was at 21/01/2013 14:10:34