在新的项目中公司在平台内部系统间使用Thrift通讯，都没有听说过。然后听同事说，是跨语言Socket通讯的开源组件。

功能及特点

1.跨平台和语言的Socket通讯组件。

2.根据伪代码的结构语言定义对象和服务结构，然后生成各语言的代码和接口

3.各语言根据组件提供的库，编写客户端和服务器端程序。服务器端实现接口并编写业务逻辑。

4.服务器端支持多种序列化方式（Binary，Compact，JSON等）和多种服务器实现

太晚了，以后在完善，先贴代码了

本测试使用WINDOW环境和JAVA语言

1.下载和安装

下载地址：http://thrift.apache.org

下载最新版本，当前0.7.0

2.建立测试工程

普通JAVA工程，目录如下：

src

+ org.acooly.thrift.demo.client  客户端代码

+ org.acooly.thrift.demo.generalcode 通过thrift工具生成的代码

+ org.acooly.thrift.demo.server 服务器端代码

lib

+拷贝前面ant编译后的build/lib下的jar和编译生成的thrift-x.x.x.jar

tools

+ thrift.exe 前面下载的

+ thriftdemo.thrift 伪代码

3.编写伪代码文件*.thrift

Java代码  

1. namespace java org.acooly.thrift.demo.generalcode  
2.   
3. struct Contact{  
4.     1:i32 id  
5.     2:string name  
6.     3:i64 birthday  
7.     4:string phoneNo  
8.     5:string ipAddress  
9.     6:map<string,string> props  
10. }  
11.   
12. service ContactManager{  
13.   void save(1:Contact contact)  
14.   void remove(1:i32 id)  
15.   list<Contact> getAll();  
16.   list<Contact> query(1:map<string,string> conditions)  
17. }  

4.生成代码

cmd模式进入 tools目录，运行

thrift.exe -gen java thriftdemo.thrift

运行成功后，在本目录会生成gen-java目录，拷贝该目录下生成的代码到工程中对应的包。

5.服务器代码和实现业务逻辑

实现业务逻辑

Java代码  

1. package org.acooly.thrift.demo.server;  
2.   
3. import java.util.ArrayList;  
4. import java.util.Calendar;  
5. import java.util.List;  
6. import java.util.Map;  
7.   
8. import org.acooly.thrift.demo.generalcode.Contact;  
9. import org.acooly.thrift.demo.generalcode.ContactManager;  
10. import org.apache.thrift.TException;  
11.   
12. public class ContactManagerImpl implements ContactManager.Iface{  
13.   
14.     public List<Contact> getAll() throws TException {  
15.         List<Contact> contacts = new ArrayList<Contact>();  
16.         contacts.add(new Contact(1,"zhangpu",Calendar.getInstance().getTimeInMillis(),"1389612222","192.168.2.1",null));  
17.         return contacts;  
18.     }  
19.   
20.     public List<Contact> query(Map<String, String> conditions) throws TException {  
21.         List<Contact> contacts = new ArrayList<Contact>();  
22.         contacts.add(new Contact(1,"zhangpu",Calendar.getInstance().getTimeInMillis(),"1389612222","192.168.2.1",null));  
23.         return contacts;  
24.     }  
25.   
26.     public void remove(int id) throws TException {  
27.         System.out.println("invoke: remove,id = " + id);  
28.     }  
29.   
30.     public void save(Contact contact) throws TException {  
31.         System.out.println("invoke: save,contact = " + contact);  
32.           
33.     }  
34.   
35.       
36.       
37. }  

 编写服务器代码

Java代码  

1. package org.acooly.thrift.demo.server;  
2.   
3. import org.acooly.thrift.demo.generalcode.ContactManager;  
4. import org.acooly.thrift.demo.generalcode.ContactManager.Iface;  
5. import org.apache.thrift.protocol.TCompactProtocol;  
6. import org.apache.thrift.protocol.TCompactProtocol.Factory;  
7. import org.apache.thrift.server.TServer;  
8. import org.apache.thrift.server.TSimpleServer;  
9. import org.apache.thrift.server.TServer.Args;  
10. import org.apache.thrift.transport.TServerSocket;  
11.   
12. public class ThriftServer {  
13.   
14.     public static void main(String[] args) throws Exception{  
15.         TServerSocket serverSocket = new TServerSocket(8111);  
16.         ContactManager.Processor<Iface> processor = new ContactManager.Processor<Iface>(new ContactManagerImpl());  
17.         Factory factory = new TCompactProtocol.Factory();  
18.         Args ag = new Args(serverSocket);  
19.         ag.outputProtocolFactory(factory);  
20.         ag.inputProtocolFactory(factory);  
21.         ag.processor(processor);  
22.         TServer server = new TSimpleServer(ag);  
23.         server.serve();  
24.     }  
25.       
26. }  

6.客户端代码

Java代码  

1. package org.acooly.thrift.demo.client;  
2.   
3. import java.util.Calendar;  
4. import java.util.List;  
5.   
6. import org.acooly.thrift.demo.generalcode.Contact;  
7. import org.acooly.thrift.demo.generalcode.ContactManager;  
8. import org.apache.thrift.protocol.TCompactProtocol;  
9. import org.apache.thrift.protocol.TProtocol;  
10. import org.apache.thrift.transport.TSocket;  
11. import org.apache.thrift.transport.TTransport;  
12.   
13.   
14. public class ThriftClient {  
15.   
16.     public static void main(String[] args) throws Exception{  
17.           
18.         TTransport transport = new TSocket("localhost",8111);  
19.         TProtocol protocol = new TCompactProtocol(transport);  
20.         ContactManager.Client client = new ContactManager.Client(protocol);  
21.         transport.open();  
22.           
23.         List<Contact> list = client.getAll();  
24.         System.out.println(list);  
25.           
26.         client.save(new Contact(1,"zhangpu",Calendar.getInstance().getTimeInMillis(),"1389612222","192.168.2.1",null));  
27.           
28.         client.remove(1);  
29.         transport.close();  
30.     }  
31. }  

7.启动和测试运行

1.运行ThriftServer

2.运行ThriftClient

ThriftServer输出：

invoke: save,contact = Contact(id:1, name:zhangpu, birthday:1308591769148, phoneNo:1389612222, ipAddress:192.168.2.1, props:null)
invoke: remove,id = 1

ThriftClient输出：

[Contact(id:1, name:zhangpu, birthday:1308591769131, phoneNo:1389612222, ipAddress:192.168.2.1, props:null)]

1、索引中最常见的就是B树索引，B树索引的实现与二叉查找树相似，但是B的意思不是binary，而是balance（平衡）。 

2、B树索引上的每个结点都是一个块，有叶子块和分支块之分。块中的数据包括各个索引以及一个rowid。走索引查询时，会按照树的分支将需要查询数据路径上的相应的分支块和叶子块读到内存。 

3、B树索引不存在非唯一性条目，在一个非唯一性索引中，Oracle会把rowid作为一个额外的列追加到键上，使得键唯一。非唯一性索引，会先按索引键值排序，然后按rowid升序排序。 

4、B树索引时高度平衡的，大多数情况，B树索引的高度都是2或3，即使索引数百万行记录也是如此。这说明，一般情况，在索引中找到键值只需2到3次IO（2到3个数据块）。 

5、通常有两种使用索引的方法： 
 （1）索引用于访问表中的行，访问表中很少一部分行。 
这是DBA给的经验值： 
小表(记录数小于10000行的表)：筛选比例<10%； 
大表：(筛选返回记录数)<(表总记录数*单条记录长度)/10000/16 
      单条记录长度≈字段平均内容长度之和+字段数*2 
（2）索引用于回答一个查询，索引中的信息足够回答整个查询。

6、不能视图加索引，视图只是存储了一种查询，具体的访问还是要访问基表。

7、B树索引不会存储null的条目。

8、外键上要加索引，否则容易造成死锁。

9、组合索引，查询时只使用单一或没有加上全部的索引条件的查询。

10、count查询默认是会走B树索引的，但是如果索引建在可能为null的字段上，则不会走索引查询（因为B树索引不能允许null，使用索引查出的count和使用表查询出来的count可能1出现不一致情况）。

11、索引列上使用函数或使用数据类型转化函数，将会不走索引查询。

12、优化器拒绝使用索引查询，优化器绝大多数时候是英明的，不要贸然强制使用索引。

13、没有将最有差别的列放在索引最前面会使索引更小或更有效率的说法，实际上，如果使用索引键压缩，情况恰恰相反（即把没有差别的列放在索引最前面最优的做法）。

下面内容来源于Quora上的 一个提问，问题是使用Redis需要避免的五个问题。而回答中超出了五个问题的范畴，描述了五个使用Redis的注意事项。如果你在使用或者考虑使用Redis，可能你可以学习一下下面的一些建议，避免一下提到的问题。

1.使用key值前缀来作命名空间

虽然说Redis支持多个数据库（默认32个，可以配置更多），但是除了默认的0号库以外，其它的都需要通过一个额外请求才能使用。所以用前缀作为命名空间可能会更明智一点。

另外，在使用前缀作为命名空间区隔不同key的时候，最好在程序中使用全局配置来实现，直接在代码里写前缀的做法要严格避免，这样可维护性实在太差了。

2.创建一个类似 ”registry” 的key用于标记key使用情况

为了更好的管理你的key值的使用，比如哪一类key值是属于哪个业务的，你通常会在内部wiki或者什么地方创建一个文档，通过查询这个文档，我们能够知道Redis中的key都是什么作用。

与之结合，一个推荐的做法是，在Redis里面保存一个registry值，这个值的名字可以类似于 __key_registry__ 这样的，这个key对应的value就是你文档的位置，这样我们在使用Redis的时候，就能通过直接查询这个值获取到当前Redis的使用情况了。

3.注意垃圾回收

Redis是一个提供持久化功能的内存数据库，如果你不指定上面值的过期时间，并且也不进行定期的清理工作，那么你的Redis内存占用会越来越大，当有一天它超过了系统可用内存，那么swap上场，离性能陡降的时间就不远了。所以在Redis中保存数据时，一定要预先考虑好数据的生命周期，这有很多方法可以实现。

比如你可以采用Redis自带的过期时间为你的数据设定过期时间。但是自动过期有一个问题，很有可能导致你还有大量内存可用时，就让key过期去释放内存，或者是内存已经不足了key还没有过期。

如果你想更精准的控制你的数据过期，你可以用一个ZSET来维护你的数据更新程度，你可以用时间戳作为score值，每次更新操作时更新一下score，这样你就得到了一个按更新时间排序序列串，你可以轻松地找到最老的数据，并且从最老的数据开始进行删除，一直删除到你的空间足够为止。

4.设计好你的Sharding机制

Redis目前并不支持Sharding，但是当你的数据量超过单机内存时，你不得不考虑Sharding的事（注意：Slave不是用来做Sharding操作的，只是数据的一个备份和读写分离而已）。

所以你可能需要考虑好数据量大了后的分片问题，比如你可以在只有一台机器的时候就在程序上设定一致性hash机制，虽然刚开始所有数据都hash到一台机器，但是当你机器越加越多的时候，你就只需要迁移少量的数据就能完成了。

5.不要有个锤子看哪都是钉子

当你使用Redis构建你的服务的时候，一定要记住，你只是找了一个合适的工具来实现你需要的功能。而不是说你在用Redis构建一个服务，这是很不同的，你把Redis当作你很多工具中的一个，只在合适使用的时候再使用它，在不合适的时候选择其它的方法。

Android应用自动更新功能的代码实现

由于Android项目开源所致，市面上出现了N多安卓软件市场。为了让我们开发的软件有更多的用户使用，我们需要向N多市场发布，软件升级后，我们也必须到安卓市场上进行更新，给我们增加了工作量。因此我们有必要给我们的Android应用增加自动更新的功能。

既然实现自动更新，我们首先必须让我们的应用知道是否存在新版本的软件，因此我们可以在自己的网站上放置配置文件，存放软件的版本信息：

在这里我使用的是XML文件，方便读取。由于XML文件内容比较少，因此可通过DOM方式进行文件的解析：

通过parseXml()方法，我们可以获取服务器上应用的版本、文件名以及下载地址。紧接着我们就需要获取到我们手机上应用的版本信息：

通过该方法我们获取到的versionCode对应AndroidManifest.xml下android:versionCode。android:versionCode和android:versionName两个属性分别表示版本号，版本名称。versionCode是整数型，而versionName是字符串。由于versionName是给用户看的，不太容易比较大小，升级检查时，就可以检查versionCode。把获取到的手机上应用版本与服务器端的版本进行比较，应用就可以判断处是否需要更新软件。

处理流程

处理代码

效果图

检查模拟器SDCARD是否存在下载文件：

1、选择一个jQuery框架，如：

/*!
 * jQuery.myPlugin
 *
 * @version  1.0.0
 * @date     2014/07/16
 * @author   Lime
 * @license  
 */
(function (jQuery) {

	//定义你的属性名myPlugin
    jQuery.fn.myPlugin = function (options) { 
		
		//替换默认参数
        var options = jQuery.extend({}, jQuery.fn.myPlugin.defaults, options);
        
		//使用return this.each运用在多个控件上并实现链式操作 
        return this.each(function () {
              //在这里实现你的方法
        });
    };

    //使用暴露方式设置插件默认参数，这对于让插件的使用者更容易用较少的代码覆盖和修改插件默认设置
    jQuery.fn.myPlugin.defaults = {
    };

})(jQuery);

 2、添加引用编写好的插件

 首先给你的插件起个名，推荐命名方法为：jquery.[插件名].js，如上面可以命名为jquery.myPlugin.js

 然后在你的项目里添加引用<script src="jquery.myPlugin.js" type="text/javascript"></script>，当然在这之前你必须要引用jquery库。

3、插件的使用

<script type="text/javascript"> 
	$(document).ready(function () { 
		$("#div1").myPlugin(); 
	}); </script> 

 有木有发现简直简单到爆啊，是的，就这么简单！

附：select下拉绑定jQuery插件

/*!
 * jQuery.selectDataBind
 *
 * @version  1.0.0
 * @date     2014/07/16
 * @author   Lime<zhrjin@163.com>
 * @license  
 */
(function (jQuery) {
    jQuery.fn.selectDataBind = function (options) {
        var options = jQuery.extend({}, jQuery.fn.selectDataBind.defaults, options);
        return this.each(function () {
            var jOption = options.options;
            var jVaule = options.values;
            var bEmpty = options.empty;
            var j = 0;
            if (bEmpty) {
                this.options[0] = new Option("", "");
                j++;
            }
            for (var i = 0; i < jOption.length; i++) {
                var objOption = new Option(jOption[i], jVaule[i]);
                this.options[j++] = objOption;
            }
        });
    };
    jQuery.fn.selectDataBind.defaults = {
        options: [],
        values: [],
        empty: true
    };
})(jQuery);

Java代码  

1. <div style="width:500px;background:#cccccc;height:0px;">  
2. <div id="right" style="width:380%;height:100%;float:left;border:1px solid #265492;">left</div>  
3. <div id="left" style="width:60%;;float:left;background:#376037;">  
4. right<br>  
5. right<br>  
6. right<br>  
7. right<br>  
8. right<br>  
9. right<br>  
10. right<br>  
11. </div>  
12. </div>  
13. <script type="text/javascript">  
14. <!--   
15. var a=document.getElementById("left");  
16. var b=document.getElementById("right");  
17. if(a.clientHeight<b.clientHeight){  
18.   a.style.height=b.clientHeight+"px";  
19. }else{   
20.   b.style.height=a.clientHeight+"px";  
21. }  
22. -->  
23. </script>  

Java代码  

1. <div class="endArea">  
2. <div class="col1">第一列　左边正文</div>  
3. <div class="col3">第二列　右边<br /><br /><br /><br /><br /><br /><br /><br /><br /><br /><br />字字</div>  
4. <div class="col2">第三列　中间图片</div>  
5. <div class="clear"></div>  
6. </div>  

Java代码  

1. .endArea{margin:0 auto; width:960px; background:url(http://cimg2.163.com/cnews/img07/end_n_bg1.gif); clear:both;}  
2. .endArea .col1{float:left; width:573px; }  
3. .endArea .col2{float:left; width:25px; }  
4. .endArea .col3{float:right; width:362px;}  

Java代码  

1. <html>  
2. <head>  
3. <meta http-equiv="Content-Type" content="text/html; charset=gb2312" />  
4. <title>Div高度自适应</title>  
5. <style type="text/css">  
6. #wrap{overflow:hidden;}  
7. #sidebar_left,#sidebar_right{padding-bottom:100000px;margin-bottom:-100000px;}  
8. </style>  
9. </head>  
10. <body>  
11. <div id="wrap" style="width:300px; background:#FFFF00;">  
12. <div id="sidebar_left" style="float:left;width:100px; background:#777;">居左</div>  
13. <div id="sidebar_mid" style="float:left;width:100px; background:#999;">  
14. 居中<br />  
15. 居中<br />  
16. 居中<br />  
17. 居中<br />  
18. 居中<br />  
19. 居中<br />  
20. 居中<br />  
21. </div><div id="sidebar_right" style="float:right;width:100px; background:#888;">居右</div></div>  
22. </body>  
23. </html>  

一、数值类型：

    下面是PostgreSQL所支持的数值类型的列表和简单说明：

   1. 整数类型：
    类型smallint、integer和bigint存储各种范围的全部是数字的数，也就是没有小数部分的数字。试图存储超出范围以外的数值将导致一个错误。常用的类型是integer，因为它提供了在范围、存储空间和性能之间的最佳平衡。一般只有在磁盘空间紧张的时候才使用smallint。而只有在integer的范围不够的时候才使用bigint，因为前者(integer)绝对快得多。 

    2. 任意精度数值：
    类型numeric可以存储最多1000位精度的数字并且准确地进行计算。因此非常适合用于货币金额和其它要求计算准确的数量。不过，numeric类型上的算术运算比整数类型或者浮点数类型要慢很多。
    numeric字段的最大精度和最大比例都是可以配置的。要声明一个类型为numeric的字段，你可以用下面的语法：
    NUMERIC(precision,scale)
    比如数字23.5141的精度为6，而刻度为4。
    在目前的PostgreSQL版本中， decimal和 numeric是等效的。
    
    3. 浮点数类型：
    数据类型real和double是不准确的、牺牲精度的数字类型。不准确意味着一些数值不能准确地转换成内部格式并且是以近似的形式存储的，因此存储后再把数据打印出来可能显示一些缺失。
    
   4. Serial(序号)类型：
    serial和bigserial类型不是真正的类型，只是为在表中设置唯一标识做的概念上的便利。
    CREATE TABLE tablename (
        colname  SERIAL
    );
    等价于
    CREATE SEQUENCE tablename_colname_seq;
    CREATE TABLE tablename(
        colname integer DEFAULT  nextval('tablename_colname_seq') NOT NULL
    );
    这样，我们就创建了一个整数字段并且把它的缺省数值安排为从一个序列发生器取值。应用了一个NOT NULL约束以确保空值不会被插入。在大多数情况下你可能还希望附加一个UNIQUE或者PRIMARY KEY约束避免意外地插入重复的数值，但这个不是自动发生的。因此，如果你希望一个序列字段有一个唯一约束或者一个主键，那么你现在必须声明，就像其它数据类型一样。
    还需要另外说明的是，一个serial类型创建的序列在其所属字段被删除时，该序列也将被自动删除，但是其它情况下是不会被删除的。因此，如果你想用同一个序列发生器同时给几个字段提供数据，那么就应该以独立对象的方式创建该序列发生器。 

二、字符类型：

    下面是PostgreSQL所支持的字符类型的列表和简单说明：

    SQL 定义了两种基本的字符类型，varchar(n)和char(n)，这里的n是一个正整数。两种类型都可以存储最多n个字符长的字串，试图存储更长的字串到这些类型的字段里会产生一个错误，除非超出长度的字符都是空白，这种情况下该字串将被截断为最大长度。如果没有长度声明，char等于char(1)，而varchar则可以接受任何长度的字串。
     MyTest=> CREATE TABLE testtable(first_col varchar(2));
    CREATE TABLE
     MyTest=> INSERT INTO testtable VALUES('333');   --插入字符串的长度，超过其字段定义的长度，因此报错。
    ERROR:  value too long for type character varying(2)
    --插入字符串中，超出字段定义长度的部分是空格，因此可以插入，但是空白符被截断。
     MyTest=> INSERT INTO testtable VALUES('33 ');   
    INSERT 0 1
    MyTest=> SELECT * FROM testtable;
     first_col
    -----------
     33
    (1 row)
    这里需要注意的是，如果是将数值转换成char(n)或者varchar(n)，那么超长的数值将被截断成n个字符，而不会抛出错误。
    MyTest=> select 1234::varchar(2);
     varchar
    ---------
     12
    (1 row)
    最后需要提示的是，这三种类型之间没有性能差别，只不过是在使用char类型时增加了存储尺寸。虽然在某些其它的数据库系统里，char(n)有一定的性能优势，但在PostgreSQL里没有。在大多数情况下，应该使用text或者varchar。
    
三、日期/时间类型：

    下面是PostgreSQL所支持的日期/时间类型的列表和简单说明：

    1. 日期/时间输入:
    任何日期或者时间的文本输入均需要由单引号包围，就象一个文本字符串一样。
    1). 日期:
    以下为合法的日期格式列表：

    2). 时间：
    以下为合法的时间格式列表：

    3). 时间戳：
    时间戳类型的有效输入由一个日期和时间的联接组成，后面跟着一个可选的时区。因此，1999-01-08 04:05:06和1999-01-08 04:05:06 -8:00都是有效的数值。
   
   2. 示例：
    1). 在插入数据之前先查看datestyle系统变量的值：
    MyTest=> show  datestyle;
     DateStyle
    -----------
     ISO, YMD
    (1 row)
    2). 创建包含日期、时间和时间戳类型的示例表：
    MyTest=> CREATE TABLE testtable (id integer, date_col date, time_col time, timestamp_col timestamp);
    CREATE TABLE
    3). 插入数据：
    MyTest=> INSERT INTO testtable(id,date_col) VALUES(1,  DATE'01/02/03');  --datestyle为YMD
    INSERT 0 1
    MyTest=> SELECT id, date_col FROM testtable;
     id   |  date_col
    ----+------------
      1  | 2001-02-03
    (1 row)
    
    MyTest=> set datestyle =  MDY;
    SET
    MyTest=> INSERT INTO testtable(id,date_col) VALUES(2,  DATE'01/02/03');  --datestyle为MDY
    INSERT 0 1
    MyTest=> SELECT id,date_col FROM testtable;
     id   |  date_col
    ----+------------
      1  | 2001-02-03
      2  | 2003-01-02  

    MyTest=> INSERT INTO testtable(id,time_col) VALUES(3,  TIME'10:20:00');  --插入时间。
    INSERT 0 1
    MyTest=> SELECT id,time_col FROM testtable WHERE time_col IS NOT NULL;
     id   | time_col
    ----+----------
      3   | 10:20:00
    (1 row)

     MyTest=> INSERT INTO testtable(id,timestamp_col) VALUES(4,  DATE'01/02/03'); 
    INSERT 0 1
    MyTest=> INSERT INTO testtable(id,timestamp_col) VALUES(5,  TIMESTAMP'01/02/03 10:20:00');
    INSERT 0 1
    MyTest=> SELECT id,timestamp_col FROM testtable WHERE timestamp_col IS NOT NULL;
     id   |    timestamp_col
    ----+---------------------
      4  | 2003-01-02 00:00:00
      5  | 2003-01-02 10:20:00
    (2 rows)

四、布尔类型：

    PostgreSQL支持标准的SQL boolean数据类型。boolean只能有两个状态之一：真(True)或 假(False)。该类型占用1个字节。
    "真"值的有效文本值是：
    TRUE
    't'
    'true'
    'y'
    'yes'
    '1'
    而对于"假"而言，你可以使用下面这些：
    FALSE
    'f'
    'false'
    'n'
    'no'
    '0'
　 见如下使用方式：
    MyTest=> CREATE TABLE testtable (a boolean, b text);
    CREATE TABLE
    MyTest=> INSERT INTO testtable VALUES(TRUE, 'sic est');
    INSERT 0 1
    MyTest=> INSERT INTO testtable VALUES(FALSE, 'non est');
    INSERT 0 1
    MyTest=> SELECT * FROM testtable;
     a  |    b
    ---+---------
     t  | sic est
     f  | non est
    (2 rows)    
    MyTest=> SELECT * FROM testtable WHERE a;
     a  |    b
    ---+---------
     t  | sic est
    (1 row)    
    MyTest=> SELECT * FROM testtable WHERE a = true;
     a  |    b
    ---+---------
     t  | sic est
    (1 row)
    
五、位串类型：

    位串就是一串1和0的字串。它们可以用于存储和视觉化位掩码。我们有两种类型的SQL位类型：bit(n)和bit varying(n); 这里的n是一个正整数。bit类型的数据必须准确匹配长度n; 试图存储短些或者长一些的数据都是错误的。类型bit varying数据是最长n的变长类型；更长的串会被拒绝。写一个没有长度的bit等效于bit(1)，没有长度的bit varying相当于没有长度限制。
    针对该类型，最后需要提醒的是，如果我们明确地把一个位串值转换成bit(n)，那么它的右边将被截断或者在右边补齐零，直到刚好n位，而不会抛出任何错误。类似地，如果我们明确地把一个位串数值转换成bit varying(n)，如果它超过n位，那么它的右边将被截断。 见如下具体使用方式：    
    MyTest=> CREATE TABLE testtable (a bit(3), b bit varying(5));
    CREATE TABLE
    MyTest=> INSERT INTO testtable VALUES ( B'101',  B'00');
    INSERT 0 1
    MyTest=> INSERT INTO testtable VALUES ( B'10',  B'101');
    ERROR:  bit string length 2 does not match type bit(3)
    MyTest=> INSERT INTO testtable VALUES ( B'10':: bit(3),  B'101');
    INSERT 0 1
    MyTest=> SELECT * FROM testtable;
      a  |  b
    -----+-----
     101 | 00
     100 | 101
    (2 rows)
     MyTest=> SELECT  B'11':: bit(3);
     bit
    -----
     110
    (1 row)

六、数组：

    1. 数组类型声明：
    1). 创建字段含有数组类型的表。
    CREATE TABLE sal_emp (
        name            text,
        pay_by_quarter  integer [] --还可以定义为 integer[4]或 integer ARRAY[4]
    );
    2). 插入数组数据：
    MyTest=# INSERT INTO sal_emp VALUES ('Bill', '{11000, 12000, 13000, 14000}');
    INSERT 0 1
    MyTest=# INSERT INTO sal_emp VALUES ('Carol',  ARRAY[21000, 22000, 23000, 24000]);
    INSERT 0 1
    MyTest=# SELECT * FROM sal_emp;
     name  |      pay_by_quarter
    --------+---------------------------
     Bill     | {11000,12000,13000,14000}
     Carol  | {21000,22000,23000,24000}
    (2 rows)    

    2. 访问数组：
    和其他语言一样，PostgreSQL中数组也是通过下标数字(写在方括弧内)的方式进行访问，只是PostgreSQL中数组元素的下标是从1开始n结束。
    MyTest=# SELECT pay_by_quarter[3] FROM sal_emp;
     pay_by_quarter
    ----------------
              13000
              23000
    (2 rows)
    MyTest=# SELECT name FROM sal_emp WHERE pay_by_quarter[1] <> pay_by_quarter[2];
     name
    ------
     Bill
     Carol
    (2 rows)
    PostgreSQL中还提供了访问数组范围的功能，即ARRAY[脚标下界:脚标上界]。
    MyTest=# SELECT name,pay_by_quarter [1:3] FROM sal_emp;
     name  |   pay_by_quarter
    --------+---------------------
     Bill     | {11000,12000,13000}
     Carol  | {21000,22000,23000}
    (2 rows)
    
    3. 修改数组：
    1). 代替全部数组值：
     --UPDATE sal_emp SET pay_by_quarter =  ARRAY[25000,25000,27000,27000] WHERE name = 'Carol'; 也可以。
    MyTest=# UPDATE sal_emp SET pay_by_quarter = '{31000,32000,33000,34000}' WHERE name = 'Carol';
    UPDATE 1
    MyTest=# SELECT * FROM sal_emp;
     name  |      pay_by_quarter
    --------+---------------------------
     Bill     | {11000,12000,13000,14000}
     Carol  | {31000,32000,33000,34000}
    (2 rows)
    2). 更新数组中某一元素：
    MyTest=# UPDATE sal_emp SET pay_by_quarter[4] = 15000 WHERE name = 'Bill';
    UPDATE 1
     MyTest=# SELECT * FROM sal_emp;
     name  |      pay_by_quarter
    --------+---------------------------
     Carol  | {31000,32000,33000,34000}
     Bill     | {11000,12000,13000,15000}
    (2 rows)
    3). 更新数组某一范围的元素：
    MyTest=# UPDATE sal_emp SET pay_by_quarter[1:2] = '{37000,37000}' WHERE name = 'Carol';
    UPDATE 1
    MyTest=# SELECT * FROM sal_emp;
     name  |      pay_by_quarter
    --------+---------------------------
     Bill     | {11000,12000,13000,15000}
     Carol  | {37000,37000,33000,34000}
    (2 rows)
    4). 直接赋值扩大数组：
    MyTest=# UPDATE sal_emp SET pay_by_quarter[5] = 45000 WHERE name = 'Bill';
    UPDATE 1
    MyTest=# SELECT * FROM sal_emp;
     name  |         pay_by_quarter
    --------+---------------------------------
     Carol  | {37000,37000,33000,34000}
     Bill     | {11000,12000,13000,15000,45000}
    (2 rows)

    4. 在数组中检索：
    1). 最简单直接的方法：
    SELECT * FROM sal_emp WHERE pay_by_quarter[1] = 10000 OR
                            pay_by_quarter[2] = 10000 OR
                            pay_by_quarter[3] = 10000 OR
                            pay_by_quarter[4] = 10000;    
    2). 更加有效的方法：
    SELECT * FROM sal_emp WHERE 10000 =  ANY (pay_by_quarter);  --数组元素中有任何一个等于10000，where条件将成立。
    SELECT * FROM sal_emp WHERE 10000 =  ALL (pay_by_quarter);  --只有当数组中所有的元素都等于10000时，where条件才成立。

七、复合类型：

    PostgreSQL中复合类型有些类似于C语言中的结构体，也可以被视为Oracle中的记录类型，但是还是感觉复合类型这个命名比较贴切。它实际上只是一个字段名和它们的数据类型的列表。PostgreSQL允许像简单数据类型那样使用复合类型。比如，表字段可以声明为一个复合类型。
    1. 声明复合类型:
    下面是两个简单的声明示例：
    CREATE TYPE complex  AS (
        r double,
        i double
    );   
    CREATE TYPE inventory_item  AS (
        name           text,
        supplier_id   integer,
        price            numeric
    );
    和声明一个数据表相比，声明类型时需要加AS关键字，同时在声明TYPE时不能定义任何约束。下面我们看一下如何在表中指定复合类型的字段，如：
    CREATE TABLE on_hand (
        item       inventory_item,
        count    integer
    );
    最后需要指出的是，在创建表的时候，PostgreSQL也会自动创建一个与该表对应的复合类型，名字与表字相同，即表示该表的复合类型。
    
    2. 复合类型值输入：
    我们可以使用文本常量的方式表示复合类型值，即在圆括号里包围字段值并且用逗号分隔它们。你也可以将任何字段值用双引号括起，如果值本身包含逗号或者圆括号，那么就用双引号括起，对于上面的inventory_item复合类型的输入如下：
    '("fuzzy dice",42,1.99)'
    如果希望类型中的某个字段为NULL，只需在其对应的位置不予输入即可，如下面的输入中price字段的值为NULL，
    '("fuzzy dice",42,)'
    如果只是需要一个空字串，而非NULL，写一对双引号，如：
    '("",42,)'
    在更多的场合中PostgreSQL推荐使用ROW表达式来构建复合类型值，使用该种方式相对简单，无需考虑更多标识字符问题，如：
    ROW('fuzzy dice', 42, 1.99)
    ROW('', 42, NULL)
    注：对于ROW表达式，如果里面的字段数量超过1个，那么关键字ROW就可以省略，因此以上形式可以简化为：
    ('fuzzy dice', 42, 1.99)
    ('', 42, NULL)
    
    3. 访问复合类型：
    访问复合类型中的字段和访问数据表中的字段在形式上极为相似，只是为了对二者加以区分，PostgreSQL设定在访问复合类型中的字段时，类型部分需要用圆括号括起，以避免混淆，如：
    SELECT (item).name FROM on_hand WHERE (item).price > 9.99;
    如果在查询中也需要用到表名，那么表名和类型名都需要被圆括号括起，如：
    SELECT (on_hand.item).name FROM on_hand WHERE (on_hand.item).price > 9.99;
    
    4. 修改复合类型：
    见如下几个示例：
    --直接插入复合类型的数据，这里是通过ROW表达式来完成的。
    INSERT INTO on_hand(item) VALUES(ROW("fuzzy dice",42,1.99));
    --在更新操作中，也是可以通过ROW表达式来完成。
    UPDATE on_hand SET item = ROW("fuzzy dice",42,1.99) WHERE count = 0;
    --在更新复合类型中的一个字段时，我们不能在SET后面出现的字段名周围加圆括号，
    --但是在等号右边的表达式里引用同一个字段时却需要圆括号。
    UPDATE on_hand SET item.price = (item).price + 1 WHERE count = 0;
    --可以在插入中，直接插入复合类型中字段。
    INSERT INTO on_hand (item.supplier_id, item.price) VALUES(100, 2.2);

• 准备工作：

1. 从 Spring官网下载STS（如果没有STS）。

    

• 体验步骤：

1. 创建Spring Roo基础项目

2. 生成持久层

   根 据ROO的提示输入jpa setup再按ctrl+space，很遗憾这个快捷键已经被输入法切换占用，不能借助提示输入命令，但我们可以打开ROO命令向导，这里我们输入jpa 可以查到这条命令的用法，根据提示增加provider和database选项来完成命令。

    

   1	jpa setup --provider HIBERNATE --database H2_IN_MEMORY

   命令执行后我们可以看到新增加或更新以下内容：

   1）增加database.properties文件

   2）增加persistence.xml文件

   3）更新applicationContext.xml问价

   4）更新Maven依赖

   接 着再次输入hint，ROO会提示我们创建实体，我们再次打开命令向导，敲入entity，向导提示class参数是必须的，这里我们输入Card作为我 们要创建的Class，然后按Finish，ROO就会自动帮我们在顶层包下生成Card实体类，同时还会生成AspectJ的相关类，这些类主要给 ROO使用，可以先不必理会。

    

   我们假设一张卡有卡号，客户号和余额三个属性，目前Card类没有任何属性，显然不能 满足我们的需求，再次输入hint命令，ROO提示使用field命令给实体增加属性，我们依赖使用命令向导来添加这三个属性，值得注意的是可选项，有些 验证的可选项我们可以直接使用。糟糕，field命令执行不成功，原来comment的值需要加双引号.field命令很强大，如果表有关联，我们可以使 用field reference命令向导来完成。

   接 着使用repository jpa命令向导来创建一个实现CRUD操作的简单Repository，这个命令很神奇，ROO会自动使用AspectJ和Spring Data来完成基本的CRUD操作实现，而CardRepository类只是加简单的注解@RooJpaRepository(domainType = Card.class)，不再需要任何实现，虽然简单方便，但也可以看出项目已经跟ROO绑定。

    

   至此我们完成了一个简单的持久层，使用命令向导还是挺方便的。

3. 生成服务层

   再 次使用hint命令，ROO可以增加更多实体或者field，或者创建Web MVC Controller等，但没有服务层相关提示，我们可以使用命令向导，输入service，选择service type来创建服务接口CardService和实现类CardServiceImpl，命令执行后ROO也会自动生成相关的AspectJ类来维护 Repositoryde的CRUD调用，所以我们只需要再增加其它特殊操作就可以了。

4. 生成展示层

   使用刚 才ROO提示的“web mvc setup”命令来初始化Web MVC,该命令会增加Spring MVC的支持，以及实体的操作页面、国际化、主题等支持。当然该命令要结合Controller的创建命令使用，打开命令向导，输入"web"，选 择"web mvc all"命令来为所有实体生成Controller。至此一个基本的MVC应用已经成形，可以马上“Run on server”试试效果。

   太棒了，基本的CRUD都支持了。

5. 生成安全支持

   在从命令向导输入"security"，选择"security setup"，然后点击Finish，该命令将为我们生成一个登陆页面和基本的验证信息，太神奇了，赶快也试试吧！

• 小结：

第 一次使用还是蛮顺手，非常适合创建简单测试项目，ROO脚本可以保存成文件，这样下次直接执行就可以自动创建一个同样的项目了，另外ROO还提供了很多插 件可以帮忙简化更多开发工作，有待进一步探索，还有一点就是项目维护问题，既然代码都是自动生成的，免不了重构，不知道重构支持如何，继续考察。