ZT文萃

hashCode的作用

      要想了解一个方法的内在原理，我们首先需要明白它是干什么的，也就是这个方法的作用。在讲解数组时（java提高篇（十八）------数组），我们提到数组是java中效率最高的数据结构，但是“最高”是有前提的。第一我们需要知道所查询数据的所在位置。第二：如果我们进行迭代查找时，数据量一定要小，对于大数据量而言一般推荐集合。

      在Java集合中有两类，一类是List，一类是Set他们之间的区别就在于List集合中的元素师有序的，且可以重复，而Set集合中元素是无序不可重 复的。对于List好处理，但是对于Set而言我们要如何来保证元素不重复呢？通过迭代来equals()是否相等。数据量小还可以接受，当我们的数据量 大的时候效率可想而知（当然我们可以利用算法进行优化）。比如我们向HashSet插入1000数据，难道我们真的要迭代1000次，调用1000次 equals()方法吗？hashCode提供了解决方案。怎么实现？我们先看hashCode的源码(Object)。

public native int hashCode();

      它是一个本地方法，它的实现与本地机器有关，这里我们暂且认为他返回的是对象存储的物理位置（实际上不是，这里写是便于理解）。当我们向一个集合中添加某 个元素，集合会首先调用hashCode方法，这样就可以直接定位它所存储的位置，若该处没有其他元素，则直接保存。若该处已经有元素存在，就调用 equals方法来匹配这两个元素是否相同，相同则不存，不同则散列到其他位置（具体情况请参考（Java提高篇（）-----HashMap））。这样 处理，当我们存入大量元素时就可以大大减少调用equals()方法的次数，极大地提高了效率。

      所以hashCode在上面扮演的角色为寻域（寻 找某个对象在集合中区域位置）。hashCode可以将集合分成若干个区域，每个对象都可以计算出他们的hash码，可以将hash码分组，每个分组对应 着某个存储区域，根据一个对象的hash码就可以确定该对象所存储区域，这样就大大减少查询匹配元素的数量，提高了查询效率。

hashCode对于一个对象的重要性

      hashCode重要么？不重要，对于List集合、数组而言，他就是一个累赘，但是对于HashMap、HashSet、HashTable而言，它变 得异常重要。所以在使用HashMap、HashSet、HashTable时一定要注意hashCode。对于一个对象而言，其hashCode过程就 是一个简单的Hash算法的实现，其实现过程对你实现对象的存取过程起到非常重要的作用。

      在前面LZ提到了HashMap和HashTable两种数据结构，虽然他们存在若干个区别，但是他们的实现原理是相同的，这里我以HashTable为例阐述hashCode对于一个对象的重要性。

      一个对象势必会存在若干个属性，如何选择属性来进行散列考验着一个人的设计能力。如果我们将所有属性进行散列，这必定会是一个糟糕的设计，因为对象的 hashCode方法无时无刻不是在被调用，如果太多的属性参与散列，那么需要的操作数时间将会大大增加，这将严重影响程序的性能。但是如果较少属相参与 散列，散列的多样性会削弱，会产生大量的散列“冲突”，除了不能够很好的利用空间外，在某种程度也会影响对象的查询效率。其实这两者是一个矛盾体，散列的 多样性会带来性能的降低。

      那么如何对对象的hashCode进行设计，LZ也没有经验。从网上查到了这样一种解决方案：设置一个缓存标识来缓存当前的散列码，只有当参与散列的对象改变时才会重新计算，否则调用缓存的hashCode，这样就可以从很大程度上提高性能。

      在HashTable计算某个对象在table[]数组中的索引位置，其代码如下：

int index = (hash & 0x7FFFFFFF) % tab.length;

      为什么要&0x7FFFFFFF？因为某些对象的hashCode可能会为负值，与0x7FFFFFFF进行与运算可以确保index为一个正 数。通过这步我可以直接定位某个对象的位置，所以从理论上来说我们是完全可以利用hashCode直接定位对象的散列表中的位置，但是为什么会存在一个 key-value的键值对，利用key的hashCode来存入数据而不是直接存放value呢？这就关系HashTable性能问题的最重要的问 题:Hash冲突！

      我们知道冲突的产生是由于不同的对象产生了相同的散列码，假如我们设计对象的散列码可以确保99.999999999%的不重复，但是有一种绝对且几乎不 可能遇到的冲突你是绝对避免不了的。我们知道hashcode返回的是int，它的值只可能在int范围内。如果我们存放的数据超过了int的范围呢？这 样就必定会产生两个相同的index，这时在index位置处会存储两个对象，我们就可以利用key本身来进行判断。所以具有相索引的对象，在该 index位置处存在多个对象，我们必须依靠key的hashCode和key本身来进行区分。

hashCode与equals

      在Java中hashCode的实现总是伴随着equals，他们是紧密配合的，你要是自己设计了其中一个，就要设计另外一个。当然在多数情况下，这两个 方法是不用我们考虑的，直接使用默认方法就可以帮助我们解决很多问题。但是在有些情况，我们必须要自己动手来实现它，才能确保程序更好的运作。

      对于equals，我们必须遵循如下规则：

      对称性：如果x.equals(y)返回是“true”，那么y.equals(x)也应该返回是“true”。

      反射性：x.equals(x)必须返回是“true”。

      类推性：如果x.equals(y)返回是“true”，而且y.equals(z)返回是“true”，那么z.equals(x)也应该返回是“true”。

      一致性：如果x.equals(y)返回是“true”，只要x和y内容一直不变，不管你重复x.equals(y)多少次，返回都是“true”。

      任何情况下，x.equals(null)，永远返回是“false”；x.equals(和x不同类型的对象)永远返回是“false”。

      对于hashCode，我们应该遵循如下规则：

      1. 在一个应用程序执行期间，如果一个对象的equals方法做比较所用到的信息没有被修改的话，则对该对象调用hashCode方法多次，它必须始终如一地返回同一个整数。

      2. 如果两个对象根据equals(Object o)方法是相等的，则调用这两个对象中任一对象的hashCode方法必须产生相同的整数结果。

      3. 如果两个对象根据equals(Object o)方法是不相等的，则调用这两个对象中任一个对象的hashCode方法，不要求产生不同的整数结果。但如果能不同，则可能提高散列表的性能。

      至于两者之间的关联关系，我们只需要记住如下即可：

      如果x.equals(y)返回“true”，那么x和y的hashCode()必须相等。

      如果x.equals(y)返回“false”，那么x和y的hashCode()有可能相等，也有可能不等。

      理清了上面的关系我们就知道他们两者是如何配合起来工作的。先看下图：

      整个处理流程是：

      1、判断两个对象的hashcode是否相等，若不等，则认为两个对象不等，完毕，若相等，则比较equals。

      2、若两个对象的equals不等，则可以认为两个对象不等，否则认为他们相等。

      实例：

public class Person {     private int age;     private int sex;    //0：男，1：女     private String name;      private final int PRIME = 37;      Person(int age ,int sex ,String name){         this.age = age;         this.sex = sex;         this.name = name;     }      /** 省略getter、setter方法 **/      @Override     public int hashCode() {         System.out.println("调用hashCode方法...........");          int hashResult = 1;         hashResult = (hashResult + Integer.valueOf(age).hashCode() + Integer.valueOf(sex).hashCode()) * PRIME;         hashResult = PRIME * hashResult + ((name == null) ? 0 : name.hashCode());          System.out.println("name:"+name +" hashCode:" + hashResult);          return hashResult;     }      /**      * 重写hashCode()      */     public boolean equals(Object obj) {         System.out.println("调用equals方法...........");          if(obj == null){             return false;         }         if(obj.getClass() != this.getClass()){             return false;         }         if(this == obj){             return true;         }          Person person = (Person) obj;          if(getAge() != person.getAge() || getSex()!= person.getSex()){             return false;         }          if(getName() != null){             if(!getName().equals(person.getName())){                 return false;             }         }         else if(person != null){             return false;         }         return true;     } }

      该Bean为一个标准的Java Bean，重新实现了hashCode方法和equals方法。

public class Main extends JPanel {      public static void main(String[] args) {         Set<Person> set = new HashSet<Person>();          Person p1 = new Person(11, 1, "张三");         Person p2 = new Person(12, 1, "李四");         Person p3 = new Person(11, 1, "张三");         Person p4 = new Person(11, 1, "李四");          //只验证p1、p3         System.out.println("p1 == p3? :" + (p1 == p3));         System.out.println("p1.equals(p3)?:"+p1.equals(p3));         System.out.println("-----------------------分割线--------------------------");         set.add(p1);         set.add(p2);         set.add(p3);         set.add(p4);         System.out.println("set.size()="+set.size());     } }

       运行结果如下：

      从上图可以看出，程序调用四次hashCode方法，一次equals方法，其set的长度只有3。add方法运行流程完全符合他们两者之间的处理流程。

       在开始电子邮件开发前：我们需要明白一下几个概念：电子邮件系统、邮件服务器、电子邮件、邮件客户端软件、邮件传输协议、电子邮件的传输过程。

       电子邮件系统

       与 传统的邮政服务相类似，电子邮件系统由电子邮局、电子邮件发送、接收系统组成。发送者和接收者通过电子邮件发送、接收系统来发送和接收电子邮件，他们实际 上是运行在计算机上的邮件客户端程序。电子邮局起着一个桥梁的作用，它实际上是运行在服务器上的邮件服务器程序。电子邮件的处理流程也和邮政服务相类似。

       邮件服务器

       邮件服务器是一种用来负责电子邮件收发管理的设备。在Internet上提供了大量的电子邮件服务器，如：126、163、hotmail…。

       电子邮件服务器主要提供的功能：

           1、  接收用户投递的邮件。

           2、  将用户投递进来的邮件转发给目标邮件服务器。

           3、  接收其他电子邮件服务器转发来的邮件并该邮件存储到其管理的用户邮中。

           4、  为前来读取邮件的用户提供读取邮件的服务。

       邮 件服务器构成了电子邮件系统的核心。每个收信人都有一个位于某个邮件服务器上的邮箱(mailbox)。Bob的邮箱用于管理和维护已经发送给他的邮件消 息。一个邮件消息的典型旅程是从发信人的用户代理开始，邮件发信人的邮件服务器，中转到收信人的邮件服务器，然后投递到收信人的邮箱中。当Bob想查看自 己的邮箱中的邮件消息时，存放该邮箱的邮件服务器将以他提供的用户名和口令认证他。Alice的邮件服务器还得处理Bob的邮件服务器出故障的情况。如果 Alice的邮件服务器无法把邮件消息立即递送到Bob的邮件服务器，Alice的服务器就把它们存放在消息队列(message queue)中，以后再尝试递送。这种尝试通常每30分钟左右执行一次：要是过了若干天仍未尝试成功，该服务器就把这个消息从消息队列中去除掉，同时以另 一个邮件消息通知发信人(即Alice)。

       电子邮件

       电子邮件是一种通过网络实现相互传送和接收信息的现代化通信方式。它是—种用电子手段提供信息交换的通信方式，是Internet应用最广的服务，通过网络的电子邮件系统，用户可以用非常低廉的价格，以非常快速的方式，与世界上任何一个角落的网络用户联系，这些电子邮件可以是文字、图像、声音等各种方式。同时，用户可以得到大量免费的新闻、专题邮件，并实现轻松的信息搜索。

       电子邮件由信封和内容两个部分组成。信封又称邮件头，电子邮件服务器根据信封上的信心来传递邮件的。内容称为邮件体，它用于提供邮件的具体内容。

       Internet上的电子邮件地址全球唯一，其格式为“邮箱名@邮件服务器域名”。域（邮件域）是电子邮件服务器的基本管理单位，邮件服务以域为基础，每个邮箱对应一个用户。其中邮件服务器域名必须是已注册的DNS域名，并且必须要与MX(邮件交换机)记录匹配。DNS用于将域名、主机名解析为IP地址。MX记录指向该域名的邮件服务器主机记录，为邮件服务专用。

       邮件客户端软件

       邮件客户端软件负责与邮件服务器通讯，主要用于帮助用户将邮件发送给SMTP服务器和POP3/IMAP邮件服务器读取用户的电子邮件。邮件客户端软件通常集撰写、发送、接收邮件于一体。

       电子邮箱

       每一个电子邮件服务器之上都可以开始多个电子邮箱，电子邮箱也称之为E-Mail地址。它类似于现实生活中的通讯地址，用户通过它接受别人发来的电子邮件和向别人发送电子邮件。

       电子邮箱的获得需要在电子邮件服务器上进行申请，确切的说，电子邮箱其实就是用户在邮件服务器上申请的一个账户。邮件服务器把接收到的邮件保持到为某个账户所分配的邮箱空间中，用户通过其申请的用户名和密码登陆到邮件服务器上查看该地址已经收到的电子邮件。

       电子邮件的传输过程

       电子邮件系统采用客户/服务器模式。电子邮件传送需要用到以下3个重要模块：

       MUA（Mail User Agent，邮件用户代理）：用户通过它与电子邮件服务器打交道。MUA实际上就是邮件客户端软件。

       MTA（Mail Transfer Agent，邮件传输代理）：它主要负责处理所有接收和发送的邮件，为MUA或者MTA提供邮件发送服务，接收其他MTA发送过来的邮件。

       MDA（Mail Delivery Agent，邮件投递代理）：它负责邮件本地投递。当MTA决定某邮件发送本地用户时，MTA将邮件交给MDA程序进行分发，也就是说投递到用户的。

       具体的传递过程如下：

            1、  发件人利用MUA将邮件发送给MTA。

            2、 MTA收到邮件后判断收件人是不是本地账户，如果是本地账户，交由MDA投送到该账户的邮箱中，完成发送过程，跳到第5步。如果不是则执行下一步骤。

            3、 MTA根据其邮件中继转发设置来决定如何转发邮件。

            4、  最终目的的MTA将受到的交给他的MDA处理，有MDA将邮件投递到收件人的邮箱中。

            5、  收件人利用MUA通过POP/IMAP协议连接到邮箱所在的服务器，请求查看自己的收件箱是否有邮件，如果有邮件，将会通过它传送个收件人的MUA。

       注意：提示邮件访问服务的是POP或者IMAP服务器软件，而并非当初收下邮件的MTA，两者的角色是分离的。

       邮件传输协议

       电子邮件服务传输主要是用到以下3中网络协议

        SMTP(简单邮件传输协议)

       SMTP是Simple Mail Transfer Protocol。标准TCP端口是25。MUA将邮件发送到MTA，MTA将邮件发送给下一个MTA，都是要使用SMTP。SMTP的目标是可靠高效地传送邮件，它独立于传送子系统而且仅要求一条可以保证传送数据单元顺序的通道。

       SMTP是一个“单向”的协议，它不能用户从其他邮件服务器收取邮件。它本身是采用客户/服务器模式，负责发送邮件的SMTP进程就是SMTP客户端，负责接收邮件的SMTP进程就是SMTP服务器。一个完整的SMTP通信过程主要包括建立连接、传送邮件、释放连接三个过程。

       建立连接：首先由发件人将要发送的邮件发送到邮件缓存，SMTP客户端定期扫描邮件缓存，一旦发现有邮件，就与SMTP服务器建立TCP连接，然后发送HRLLO命令以附上发送方的主机名。

       传送邮件：SMTP客户端使用MAIL命令开始传送邮件，该命令提供发件人的地址；然后执行RCPT命令，并提供收件人地址；最后执行DATA命令传送邮件内容。

       释放连接：邮件传送完毕后，SMTP客户端发送OUT命令请求关闭TCP连接。

         POP（邮局协议）

         POP是Post Office Protocol。标准TCP端口为110。主要用于电子邮件的接收。MUA经由POP协议连接到MTA的用户收件箱，以读取或下载用户在收件箱中邮件。

    目前用的较多的POP协议是POP3。POP3使用 TCP 作为传输协议。

       IMAP（Internet信息访问协议）

       IMAP是Internet Message Access Protocol。标准TCP端口为143，它也是让MUA从MTA收取邮件。目标球IMAP协议的版本为IMAP4。

       POP和IMAP两者都可以用于收取邮件，都是采用客户/服务器模式，两者最主要的区别就在于他们检索邮件的方式不同。使用POP时，邮件驻留在服务器中个，一旦接收邮件，邮件都从服务器上下载到用户计算机上。而IMAP则能够然该用户了解到服务器上存储邮件的情况，已下载的邮件仍然滞留在服务器中，以便于实现邮件归档和共享。

      首先来看看浅拷贝和深拷贝的定义：

      浅拷贝：使用一个已知实例对新创建实例的成员变量逐个赋值，这个方式被称为浅拷贝。

      深拷贝：当一个类的拷贝构造方法，不仅要复制对象的所有非引用成员变量值，还要为引用类型的成员变量创建新的实例，并且初始化为形式参数实例值。这个方式称为深拷贝

      也就是说浅拷贝只复制一个对象，传递引用，不能复制实例。而深拷贝对对象内部的引用均复制，它是创建一个新的实例，并且复制实例。

      对于浅拷贝当对象的成员变量是基本数据类型时，两个对象的成员变量已有存储空间，赋值运算传递值，所以浅拷贝能够复制实例。但是当对象的成员变量是引用数据类型时，就不能实现对象的复制了。

      存在一个对象Person，代码如下：

public class Person {     private String name;     private String sex;     private int age;          public Person(String name,String sex,int age){         this.name = name;         this.sex = sex;         this.age = age;     }          public Person(Person p){                   //拷贝构造方法，复制对象         this.name = p.name;         this.sex = p.sex;         this.age = p.age;     } }

      上面的对象Person有三个成员变量。name、sex、age。两个构造方法。第二个的参数为该对象，它称为拷贝构造方法，它将创建的新对象初始化为形式参数的实例值，通过它可以实现对象复制功能。

      又有一个对象Asian,如下：

public class Asian {     private String skin;     Person person;          public Asian(String skin,Person person){         this.skin = skin;         this.person = person;                    //引用赋值     }      public Asian(Asian asian){                 //拷贝构造方法，复制对象         this(asian.skin,asian.person);                } }

      上面对象也存在着两个成员变量，skin 和Person对象

      对于person对象有如下：

Person p1 = new Person("李四","mam",23);   Person p2 = new Person(P1);

      当调用上面的语句时。P2对象将会对P1进行复制。执行情况如下如下图：

      对于Asian对象有：

Asian a1 = new Asian("yellow",new Person("李四","mam",23)); Asian a2 = new Asian(a1);

      如下图：

      当a1执行某条可以改变该值的语句时，那么a1将会通过这个语句也可以改变a2对象的成员变量

      如果执行以下语句：a2.name = new Person(a1.name)

      这时将会创建一个新的Person对象

      如下图：

转帖：

     今天朋友问我String的内容是真的不可变吗？我肯定告诉他是的？因为在我的主观意识里String就是一个不可变的对象。于是他给我发了这段程序：

public class StringTest {     public static void main(String[] args) throws Exception {         String a = "chenssy";         System.out.println("a = " + a);         Field a_ = String.class.getDeclaredField("value");         a.setAccessible(true);         char[] value=(char[])a.get(a);         value[4]='_';   //修改a所指向的值         System.out.println("a = " + a);     } }

      看到这个简单的程序，我笑了，你这不是从底层来修改String的值么？从这里来理解String的值肯定是可以改变的啦（我们应该始终相信String的不可变性）！接着他再给我一段程序：

public class StringTest {     public static void main(String[] args) throws Exception {         String a = "chenssy";         String b = "chenssy";         String c = new String("chenssy");         System.out.println("--------------修改前值-------------------");         System.out.println("a = " + a);         System.out.println("b = " + b);         System.out.println("c = " + c);         //修改String的值         Field a_ = String.class.getDeclaredField("value");         a_.setAccessible(true);         char[] value=(char[])a_.get(a);         value[4]='_';   //修改a所指向的值                  System.out.println("--------------修改后值-------------------");         System.out.println("a = " + a);         System.out.println("b = " + b);         System.out.println("chenssy");         System.out.println("c = " + c);     } }

      乍看这程序是异常的简单，无非就是赋值、改值、输出嘛！可能你现在就会毫不犹豫的说太简单了结果就是……。但是！！你的毫不犹豫会害死你，而且你的结果很可能错误。那么运行结果是什么呢？

--------------修改前值------------------- a = chenssy b = chenssy c = chenssy --------------修改后值------------------- a = chen_sy b = chen_sy chen_sy c = chen_ssy

      修改前值很容易理解，但是修改后值呢？是不是有点儿不理解呢？你可能会问：为什么System.out.println("chenssy");的结果会是chen_ssy，System.out.println("c = " + c);也是chen_ssy呢？

      要明白这个其实也比较简单，掌握一个知识点：字符串常量池。

      我们知道字符串的分配和其他对象分配一样，是需要消耗高昂的时间和空间的，而且字符串我们使用的非常多。JVM为了提高性能和减少内存的开销，在实例化字 符串的时候进行了一些优化：使用字符串常量池。每当我们创建字符串常量时，JVM会首先检查字符串常量池，如果该字符串已经存在常量池中，那么就直接返回 常量池中的实例引用。如果字符串不存在常量池中，就会实例化该字符串并且将其放到常量池中。由于String字符串的不可变性我们可以十分肯定常量池中一定不存在两个相同的字符串（这点对理解上面至关重要）。

      我们再来理解上面的程序。

      String a = "chenssy";

      String b = "chenssy";

      a、b和字面上的chenssy都是指向JVM字符串常量池中的”chenssy”对象，他们指向同一个对象。

      String c = new String("chenssy");

      new关键字一定会产生一个对象chenssy（注意这个chenssy和上面的chenssy不同），同时这个对象是存储在堆中。所以上面应该产生了两 个对象：保存在栈中的c和保存堆中chenssy。但是在Java中根本就不存在两个完全一模一样的字符串对象。故堆中的chenssy应该是引用字符串 常量池中chenssy。所以c、chenssy、池chenssy的关系应该是：c--->chenssy--->池chenssy。整个 关系如下：

      通过上面的图我们可以非常清晰的认识他们之间的关系。所以我们修改内存中的值，他变化的是所有。

      总结：虽然a、 b、c、chenssy是不同的对象，但是从String的内部结构我们是可以理解上面的。String c = new String("chenssy");虽然c的内容是创建在堆中，但是他的内部value还是指向JVM常量池的chenssy的value，它构造 chenssy时所用的参数依然是chenssy字符串常量。

      为了让各位充分理解常量池，特意准备了如下一个简单的题目：

String a = "chen"; String b = a + new String("ssy");

当磁盘大小超过标准时会有报警提示，这时如果掌握df和du命令是非常明智的选择。

    df可以查看一级文件夹大小、使用比例、档案系统及其挂入点，但对文件却无能为力。
    du可以查看文件及文件夹的大小。

    两者配合使用，非常有效。比如用df查看哪个一级目录过大，然后用df查看文件夹或文件的大小，如此便可迅速确定症结。

    下面分别简要介绍

    df命令可以显示目前所有文件系统的可用空间及使用情形，请看下列这个例子：

    参数 -h 表示使用「Human-readable」的输出，也就是在档案系统大小使用 GB、MB 等易读的格式。

    上面的命令输出的第一个字段（Filesystem）及最后一个字段（Mounted on）分别是档案系统及其挂入点。我们可以看到 /dev/sda1 这个分割区被挂在根目录下。

    接下来的四个字段 Size、Used、Avail、及 Use% 分别是该分割区的容量、已使用的大小、剩下的大小、及使用的百分比。 FreeBSD下，当硬盘容量已满时，您可能会看到已使用的百分比超过 100%，因为 FreeBSD 会留一些空间给 root，让 root 在档案系统满时，还是可以写东西到该档案系统中，以进行管理。

    du：查询文件或文件夹的磁盘使用空间

    如果当前目录下文件和文件夹很多，使用不带参数du的命令，可以循环列出所有文件和文件夹所使用的空间。这对查看究竟是那个地方过大是不利的，所以得指定 深入目录的层数，参数：--max-depth=，这是个极为有用的参数！如下，注意使用“*”，可以得到文件的使用空间大小.

    提醒：一向命令比linux复杂的FreeBSD，它的du命令指定深入目录的层数却是比linux简化，为 -d。

    值得注意的是，看见一个针对du和df命令异同的文章：《du df 差异导致文件系统误报解决》。

    du 统计文件大小相加
    df  统计数据块使用情况

    如果有一个进程在打开一个大文件的时候,这个大文件直接被rm 或者mv掉，则du会更新统计数值，df不会更新统计数值,还是认为空间没有释放。直到这个打开大文件的进程被Kill掉。

    如此一来在定期删除 /var/spool/clientmqueue下面的文件时，如果没有杀掉其进程，那么空间一直没有释放。

    使用下面的命令杀掉进程之后，系统恢复。
    fuser -u /var/spool/clientmqueue

http://www.yayu.org/look.php?id=162

查看linux文件目录的大小和文件夹包含的文件数

    统计总数大小

    du -sh xmldb/

    du -sm * | sort -n //统计当前目录大小 并安大小 排序

    du -sk * | sort -n

    du -sk * | grep guojf //看一个人的大小

    du -m | cut -d "/" -f 2 //看第二个/ 字符前的文字

    查看此文件夹有多少文件 /*/*/* 有多少文件

    du xmldb/

    du xmldb/*/*/* |wc -l

    40752

    解释：

    wc [-lmw]

    参数说明：

    -l :多少行

    -m:多少字符

    -w:多少字

http://linux.chinaitlab.com/command/734706.html

Linux:ls以K、M、G为单位查看文件大小

#man ls

……

-h, --human-readable

                print sizes in human readable format (e.g., 1K 234M 2G)

……

# ls

cuss.war    nohup.out

# ls -l

total 30372

-rw-r--r--    1 root root 31051909 May 24 10:07 cuss.war

-rw-------    1 root root          0 Mar 20 13:52 nohup.out

# ls -lh

total 30M

-rw-r--r--    1 root root 30M May 24 10:07 cuss.war

-rw-------    1 root root     0 Mar 20 13:52 nohup.out

# ll -h

total 30M

-rw-r--r--    1 root root 30M May 24 10:07 cuss.war

-rw-------    1 root root     0 Mar 20 13:52 nohup.out

现提供两种方法： 
方法一： 
如果你用过Toolkit(java.awt.Toolkit)类，这将是一件很简单的事情： 
Toolkit tk=Toolkit.getDefaultToolkit() 
Image image=tk.createImage("image.gif"); /*image.gif是你的图标*/ 
this.setIconImage(image); 

注意：这个图标一定要是好用的图标。

就这么简单，看看，已经变成你自己的图标了。Toolkit是个很有用类的，提供很多对窗口默认行为的修改，下面随便提一下，怎么把默认的鼠标图标改成你自己的图标： 
Toolkit tk=Toolkit.getDefaultToolkit(); 
Image img=tk.getImage("mouse.gif"); /*mouse.gif是你的图标*/ 
Cursor cu=tk.createCustomCursor(img,new Point(10,10),"stick"); 
this.setCursor(cu); 

方法二： 
用到ImageIcon类和setIconImage方法。 
import javax.swing.*; 
public class A extends JFrame { 
    String image = new String("face.gif"); //建立一个字符串保存要用的图标的路径，关于java的路径请参考其它文档 
    ImageIcon test = new ImageIcon(image); //建立一个ImageIcon类，产生setIconImage()方法需要的Image数据 

    public A() { 
        super("演示自定义标题栏的图标的方法"); 
        this.setIconImage(test.getImage()); //设置标题栏的图标为face.gif 
        this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);        
        this.show(); 
        //this.setTitle("sdfsdf"); 
        this.setSize(400,200); 
    } 
    public static void main(String[] args) { 
        A jIcon = new A();       
    } 
} 

此法本人再次简化为两条语句： 
import javax.swing.*; 
public class A extends JFrame { 
    ImageIcon test = new ImageIcon(new String(face.gif));//第一句 
    public A() { 
        super("演示自定义标题栏的图标的方法"); 
        this.setIconImage(test.getImage()); //第二句 
         this.setSize(400,200); 
        this.show(); 
} 
    public static void main(String[] args) { 
        A jIcon = new A();       
    } 
}

创办5年、50个人的小公司值160亿美元！

是FaceBook疯了还是你不够“疯”？

【巨头狂野搏命移动端】

今晨重磅消息，美国社交网络老大Facebook收购WhatsApp，一个员工50人、其中32名是工程师的 小公司。为此，Facebook付出了总金额160亿美元“现金+股票”的昂贵代价。此外，还承诺给创始人团队30亿美元的四年行权限制股，加上期权交易 规模将达190亿美元。

WhatsApp是一个跨平台通讯应用，创办于2009年。界面朴素简洁，没有任何花哨的功能，核心功能就是帮助用户收发消息。简单说，有点像简化版的微信。

目前其月活跃用户达4.5亿（其中70%每天登录），每天新增用户100万，每天发送消息达到全球电信的短信数量，每天有10亿张照片、2亿条音频消息、1亿条视频消息通过该软件传输。

因此，这对致力于“连结人与信息”的Facebook来说，是一个极大威胁。很简单，要么战胜你，要么买下你。这和脸谱2012年收购图片分享应用Instagram的逻辑一致，在社交网络这个核心领域，脸谱绝不会允许他人染指。

更重要的是，从WhatsApp、Instagram到最近风靡美国年轻人的snapshot，都是为移动而生的应用。实际上，移动互联网的发展速度远远超过桌面互联网，巨头们正疯狂地买公司、买人，否则一不小心就会被干掉。

【每个员工值20亿】

然而，在这笔轰动全球的交易中，真正让我激动的是人的价值。

即使不包含30亿美元的期权价值，仅按立即支付的160亿美金收购价计算，按最新汇率，WhatsApp一个员工值20亿人民币，20亿！

两年前，当FaceBook斥资10亿美金收购只有13个人的Instgram时，他们该处的价格是一个人大约一亿美金。现在，价格翻了3倍。

这对一直重视“看得见的资产”的中国人来说，几乎是不可想象的。许多传统老板会想，就这么几个小屁孩敢要几十亿美金，疯了？这种思维定势有时很难扭转，看走眼的还包括现在如日中天的腾讯CEO马化腾。

当年，Instagram估值还不到1亿美金时腾讯曾有机会投资。当时Instagram只有几个人，在一个靠 近海边的房子办公。就是一层玻璃，外面都看得见，扔个砖头就可以把里面的电脑全拿走了。腾讯某副总裁看着说，这个公司不太靠谱吧，才几个人。后来，腾讯不 得不估值8亿美金时跟投。

这就是人的价值，只要拥有创新能力的人做出一个创新产品，他们足以撬动整个地球。

【人是科技第一生产力】

NOP男装创始人刘爽认为管理分为两种：管人管事，选择哪种不取决于领导者意志，而取决于企业行业类型。管事型 企业的代表是制造业和零售业，比如富士康和沃尔玛，人人都是螺丝钉，不需要你创新，需要的是你的执行效率。而管人型企业的代表是高科技和互联网，比如微软 和谷歌，其产品和服务的研发改良依赖于员工个人的创造力创新力。

如果想做一个产品服务高度依托互联网经济和体验经济的软硬件一体式品牌公司，那就应该选择管人和众智。落到具体就是有边界的制度，无边界的沟通。

当年，邓小平同志以无畏的政治勇气和理论高度，说出了一句名言：“科技是第一生产力”。这句话，激励了整整几代中国人。它让人们看到了科技的价值、知识的价值，也是现在长盛不衰的知识经济的动力。

现在，我想说：人是科技的第一生产力。不重视人的价值，不尊重人的需求，不解放人的生产力，必将被互联网时代快速淘汰。

请扪心自问。

（更多深度，扫描下方二维码后看历史文章）

作者简介：一个IPO专业户、超级自媒体。我信仰互联网，因为它实现了人和一切的自由连接，这是3代人必经的命运。微博@互联网信徒王冠雄，微信wang-guanxiong。见人所之未见，每一条都对得起关注！

手动命令行运行该脚本的时候，可以正常运行java程序，但是使用crontab定时任务，貌似就不起效果了，很是郁闷哪，查原因哪，分析可能原因：

 1)是否当前用户对此shell脚本没有可执行权限，通过ls -lrt /apps/service/mtk/checking/run.sh查看脚本是有可执行，但是有执行权限呀-rwxr-xr-x

 2)既然单独运行脚本没问题，那会不会是定时的问题呢？于是写了一个简单的输出的shell脚本通过定时也是没问题的。说明还是脚本的问题。

后来上网查了下，想到可能是脚本中环境变量的原因，因为通过crontab运行脚本，是以root用户，而不是当前用户，于是cat /etc/profile查看环境变量，然后修改脚本如下：

export显示导出为用户环境变量的环境变量
以上这种jar包是通过eclipse工具export导出，不包含MANIFEST.MF文件，如果使用打包工具Ant，我们可以在打包默认的build.xml文件中设置Class-Path
将第三方jar包加入manifest.mf文件中，且指定程序主类
在build.xml中添加如下内容：

另外，在create manifest文件时，加上：

这样运行ant，打成的jar包中MANIFEST.MF中内容如下：

这样在shell脚本中就不需要指定程序所需要的jar包了，也就不存在环境变量设置的恼人问题。比较正规的也是这么操作的。
这样在shell中就直接运行jar包就行了：java -jar 主程序.jar -Xmx1024m -Xms1024m -Xmn512m，多好多方便~

　　Java代码

　　//伪代码

　　long startTime=System.currentTimeMillis();   //获取开始时间

　　doSomeThing();  //测试的代码段

　　long endTime=System.currentTimeMillis(); //获取结束时间

　　System.out.println("程序运行时间： "+(end-start)+"ms");

　　//伪代码

　　long startTime=System.currentTimeMillis();   //获取开始时间

　　doSomeThing();  //测试的代码段

　　long endTime=System.currentTimeMillis(); //获取结束时间

　　System.out.println("程序运行时间： "+(end-start)+"ms");

　　第二种是以纳秒为单位计算的。

　　Java代码

　　//伪代码

　　long startTime=System.nanoTime();   //获取开始时间

　　doSomeThing();  //测试的代码段

　　long endTime=System.nanoTime(); //获取结束时间

　　System.out.println("程序运行时间： "+(end-start)+"ns");

　　//伪代码

　　long startTime=System.nanoTime();   //获取开始时间

　　doSomeThing();  //测试的代码段

　　long endTime=System.nanoTime(); //获取结束时间

　　System.out.println("程序运行时间： "+(end-start)+"ns");

下文转载自：

Java'中的几种Look and Feel
1、Metal风格 (默认)
String lookAndFeel = "javax.swing.plaf.metal.MetalLookAndFeel";
UIManager.setLookAndFeel(lookAndFeel);
2、Windows风格
String lookAndFeel = "com.sun.java.swing.plaf.windows.WindowsLookAndFeel";
UIManager.setLookAndFeel(lookAndFeel);
3、Windows Classic风格
String lookAndFeel = "com.sun.java.swing.plaf.windows.WindowsClassicLookAndFeel";
UIManager.setLookAndFeel(lookAndFeel);
4、Motif风格
String lookAndFeel = "com.sun.java.swing.plaf.motif.MotifLookAndFeel";
UIManager.setLookAndFeel(lookAndFeel);
5、Mac风格 (需要在相关的操作系统上方可实现)
String lookAndFeel = "com.sun.java.swing.plaf.mac.MacLookAndFeel";
UIManager.setLookAndFeel(lookAndFeel);
6、GTK风格 (需要在相关的操作系统上方可实现)
String lookAndFeel = "com.sun.java.swing.plaf.gtk.GTKLookAndFeel";
UIManager.setLookAndFeel(lookAndFeel);
7、可跨平台的默认风格
String lookAndFeel = UIManager.getCrossPlatformLookAndFeelClassName();
UIManager.setLookAndFeel(lookAndFeel);
8、当前系统的风格
String lookAndFeel = UIManager.getSystemLookAndFeelClassName();
UIManager.setLookAndFeel(lookAndFeel);

在Java中让用户能够动态地更改应用的外观，可以给用户更好地体验，具体的实现方式是：
1，先使用UIManager.setLookAndFeel(String s)方法设定对应的外观
2，再使用SwingUtilities.updateComponentTreeUI(Component c)方法立刻更新应用的外观
这两个类均在javax.swing包中

http://www.ibm.com/developerworks/cn/websphere/library/techarticles/1303_qiuxl_liberty/1303_qiuxl_liberty.html

介绍

WebSphere Liberty Profile Server 介绍

Liberty 是一款全新的轻量级应用服务器， 具有以下几个方面的特点：

1. 高 模块化——该功能允许用户根据自己应用程序的需求启用或者禁用相关的 feature（所谓 feature，在这里指的是运行应用程序所需要的各种资源的支持。比如，应用程序用到了 JSP，我们就需要启动 JSP 这个 feature，如果不在需要此 feature，就可以将其禁用。通过这种模块化的控制，我们可以按需启动不同的 feature，包括 JSP, Servlet, JPA 等等，这种控制是实现轻量级应用服务器的基础）。
2. 轻量级—— Liberty 采用了多种技术进行瘦身和优化（主要是 OSGi 的应用），与传统的 WAS 相比，极大的减少了运行时的内存消耗。
3. 高动态性——由于采用了 OSGi 的架构，程序员在开发的时候，可以动态修改配置文件，应用程序以及服务器的运行时信息，这些修改都是实时生效的，不需要重启服务器。
4. 快速——由于采用了高模块化的设计，Liberty 应用服务器会“按需启动”，自身消耗的系统资源很少，对执行任务的反应时间也非常短，例如，一般来说 Liberty 的启动时间小于 5 秒。
5. 配置简单——在整个开发过程中，用户只需要和一个配置文件（server.xml）打交道，而且配置的使用也非常灵活。

WebSphere eXtreme Scale 介绍

WebSphere eXtreme Scale 以内存网格的方式运行，动态处理、分区、复制和管理数以万计服务器上的应用程序数据和业务逻辑。提供事务完整性和透明的故障恢复功能，从而确保高可用性、 高可靠性和一致的响应时间。它可以监控和管理自己，支持扩大和缩小，可以自动从故障恢复。极大的扩大了应用程序可以支持的用户数量。用更少的时间服务更多 的用户，或者在规定的、可接受的响应时间内为更多的用户提供服务。

回页首

前提

• 安装 Oracle 或者 IBM JDK，并配置好环境变量。
• 如果使用 Eclipse，请安装 WebSphere Application Server V8.5 Liberty Profile Developer Tools

回页首

安装配置

安装 IBM HTTP 服务器及插件

本文将使用 IBM 安装管理器来在测试机 A 中安装 IBM HTTP 服务器以及插件。

• 下载并安装 IBM Installation Manager 1.5.2 或以上版本
• 下载添加安装路径到 IBM 安装管理器
• 选中 IBM HTTP 服务器以及插件

图 1. 安装成功界面

安装 Liberty

Liberty 支持两种安装方式：运行 JAR 文件、使用安装管理器安装。本文将介绍如何使用运行 JAR 文件安装 Liberty 服务器。在此例中，将会在测试机 A、B 和 C 上安装 Liberty 服务器。

1. 下载 wlp-developers-8.5.0.0.jar 文件到本地机器。
2. 打开命令行，找到下载的 jar 文件，例如 C:\Liberty。
3. 执行 java -jar wlp-developers-8.5.0.0.jar。
4. 设定安装路径完成安装。

图 2. Liberty 安装界面

安装 WebSphere eXtreme Scale

WebSphere eXtreme Scale 支持两种安装方式：运行 JAR 文件、使用安装管理器安装。本文将介绍如何使用运行 JAR 文件安装 WebSphere eXtreme Scale 插件。在此例中，将会在测试机 A 上安装 WebSphere eXtreme Scale 插件。

1. 下载 wxs-wlp_850.jar 文件到本地机器。
2. 打开命令行，找到下载的 jar 文件，例如 C:\Liberty。
3. 执行 java -jar wlp-developers-8.5.0.0.jar。
4. 设定安装路径完成安装。

图 3. WebSphere eXtreme Scale 安装界面

创建 Liberty 服务器

1. 进入 Liberty 安装目录下的 bin 文件夹
2. 执行服务器创建命令 server create 服务器名称（例如：Test001）

在本文中将会在测试机 A、B 和 C 上创建三个 Liberty 服务器实例，分别命名为 Test001，Test002 和 Test003.

图 4. Liberty 服务器创建界面

在 wlp_home/usr/servers 目录下看到以服务器命名的文件夹则表示创建成功。

图 5. 服务器创建成功界面

配置 Liberty 服务器

为每个 Liberty 服务器添加两个新功能（在 Liberty 中运行嵌入式 XS 服务器，使用 XS 存储 HTTP 会话）到 server.xml。添加代码如下：

清单 1. Feature 添加示例

    <!-- Enable features -->      <featureManager>          <feature>jsp-2.2</feature>          <feature>localConnector-1.0</feature>          <feature>eXtremeScale.web-1.0</feature>          <feature>eXtremeScale.server-1.0</feature>      </featureManager>

更改 server.xml 中 HTTP 默认端口，可以在 Test002 中使用 9080 端口，在 Test003 中使用 9081 端口。因为不同的服务器在不同的测试机上，此处我们使用默认端口 9080 不会产生冲突。添加代码如下：

清单 2. HTTP 端口修改示例

 <httpEndpoint host="*"                httpPort="9080"                httpsPort="9443"                id="defaultHttpEndpoint">

添加 WXS 配置文件到 Liberty 服务器，并将 Test001 作为 Catalog 服务器。Test002 和 Test003 不需要作为 Catalog 服务器，所以 <xsServer> 标签的 isCatalog 属性设定为“false”。添加代码如下：

清单 3. XS Server 配置示例

    <!-- Configuration for XS Server -->      <xsServer isCatalog="true"                listenerPort="2809"                serverName="Server1"/>      <!-- Configuration for XS HTTP Session data storage -->   <xsWebApp catalogHostPort="localhost:2809"            objectGridType="REMOTE"            replicationInterval="0"            reuseSessionId="true"            securityEnabled="true"            sessionTableSize="0"/>

在 Test001 服务器目录下创建“grids”文件夹，导入 XML 配置文件 deployment.xml 和 objectgrid.xml

deployment.xml 文件代码如下：

清单 4. deployment.xml 示例

 <?xml version="1.0" encoding="UTF-8"?>   <deploymentPolicy xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  xsi:schemaLocation="http://ibm.com/ws/objectgrid/   deploymentPolicy ../deploymentPolicy.xsd" 	 xmlns="http://ibm.com/ws/objectgrid/deploymentPolicy">   <objectgridDeployment objectgridName="session">   <mapSet name="sessionMapSet"              numberOfPartitions="47"              minSyncReplicas="0"              maxSyncReplicas="0"              maxAsyncReplicas="1"              developmentMode="false"              placementStrategy="FIXED_PARTITIONS">          <map ref="objectgridSessionMetadata"/>          <map ref="objectgridSessionAttribute.*"/>          <map ref="objectgridSessionTTL.*"/>      </mapSet>   </objectgridDeployment>   </deploymentPolicy>

清单 5. objectgrid.xml 示例

 <?xml version="1.0" encoding="UTF-8"?>   <objectGridConfig xmlns:xsi="http://www.w3.org/2001/   XMLSchema-instance" xsi:schemaLocation="http://ibm.com/ws/   objectgrid/config ../objectGrid.xsd" xmlns="http://ibm.com/ws/objectgrid/config">   <objectGrids>      <objectGrid name="session" txTimeout="30">          <bean id="ObjectGridEventListener"                className="com.ibm.ws.xs.   sessionmanager.SessionHandleManager"/>          <backingMap name="objectgridSessionMetadata"                      pluginCollectionRef="objectgridSessionMetadata"                      readOnly="false"                      lockStrategy="PESSIMISTIC"                      ttlEvictorType="LAST_ACCESS_TIME"                      timeToLive="3600"                      copyMode="COPY_TO_BYTES"/>          <backingMap name="objectgridSessionAttribute.*"                      template="true"                      readOnly="false"                      lockStrategy="PESSIMISTIC"                      ttlEvictorType="NONE"                      copyMode="COPY_TO_BYTES"/>          <backingMap name="objectgridSessionTTL.*"                      template="true"                      readOnly="false"                      lockStrategy="PESSIMISTIC"                      ttlEvictorType="LAST_ACCESS_TIME"                      timeToLive="3600"                      copyMode="COPY_TO_BYTES"/>      </objectGrid>   </objectGrids>   <backingMapPluginCollections>      <backingMapPluginCollection id="objectgridSessionMetadata">   <bean id="MapEventListener"        className="com.ibm.ws.xs.sessionmanager.MetadataMapListener"/>      </backingMapPluginCollection>   </backingMapPluginCollections>   </objectGridConfig>

在三个 Liberty 服务器中添加 <httpSession> 标签，使 Liberty 的会话管理器使用相同的会话 ID，添加代码如下：

清单 6. httpSession 重用设定示例

 <! — Configuration for httpSession resuse -->   <httpSession idReuse="true"/>

Test002 和 Test003 不需要配置 XS 服务器，将设定 isCatalog 为"false"， 同时 Test002 和 Test003 不需要创建“grids”文件夹。

为方便起见，在此我们将 Test001、Test002 和 Test003 导入到 Eclipse（Indigo Service Release 2）。

图 6. Liberty 服务器导入界面

创建部署测试程序

新建 Web Project，命名为 testApp

在 WebContent 文件夹下创建 index.jsp 文件，文件代码如下：

清单 7. Index.jsp 页面代码示例

 <%@page contentType="text/html" pageEncoding="UTF-8"%>   <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">     <html>   <head>   <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">   <title> 在 Liberty 集群中共享内存网格数据 </title>   </head>   <body>   <h1> 在 Liberty 集群中共享内存网格数据测试页面 !</h1>   <%   Integer count;   Object obj_Count = session.getAttribute("COUNT");   if (obj_Count != null) {   count = (Integer) obj_Count;   count = count + 1;   } else {   count = 1;   }   session.setAttribute("COUNT", count);   %>   <h3> 计数器会在每次页面加载时加 1</h3>   <h3><font color="#FF0000"> 计数器  = <%=count%></font></h3>   <h4><font color="#FF0000"><b> 页面服务器 :   <%= System.getProperty("wlp.server.name") %></b></font></h4>   <br/>  页面生成时间 = <%=new java.util.Date().toString()%><br/>   <br/>   </body>   </html>

将 testApp 分别部署到 Test002 和 Test003，

图 7. 测试程序部署界面

启动 Test001 ，Test002 和 Test003 服务器

可 以使用命令行启停 Liberty 服务器。例如在 Liberty 的安装目录的 bin 文件夹下执行 server start Test001 来启动 Test001 服务器。将测试程序直接拷贝应用程序（例如 war 文件）到 dropins 目录，当 Liberty 启动的时候，就会自动扫描，然后启动文件夹内的应用程序。前提是在启动前要配置好 server.xml 中关于应用程序的相关信息，代码如下：

清单 8. 应用程序部署示例

 <application id="testApp"               location="testApp.war"               name="testApp"               type="war"/>

配置 HTTP 服务器

为 Test002 和 Test003 生成 plugin-cfg.xml 配置文件。在此使用 JAVA 的 jconsole 生成配置文件

在 JAVA 的安装目录的 bin 文件夹下运行 jconsole。

图 8. Jconsole 启动命令界面

图 9. Jconsole 启动界面

选择之前创建的 Liberty 服务器，连接

在 MBeans 标签下点击 generateDefaultPluginConfig 方法生成配置文件 .

图 10. 配置文件生成界面

合并 Test002 和 Test003 的 plugin-cfg.xml 配置文件。文件代码如下，其中的 IP 分别为测试机 B 和 C 的 IP。

清单 9. plugin-cfg.xml 代码示例

 <?xml version="1.0" encoding="UTF-8"?>   <!-- This config file was generated by plugin's merge tool v1.0.0.2 on 2012.10.16 at   16:03:42 CST -->   <Config ASDisableNagle="false"          AcceptAllContent="false"         AppServerPortPreference="HostHeader"          ChunkedResponse="false"         FIPSEnable="false"          IISDisableNagle="false"          IISPluginPriority="High"         IgnoreDNSFailures="false"          RefreshInterval="60"         ResponseChunkSize="64"          SSLConsolidate="false"         SSLPKCSDriver="REPLACE"          SSLPKCSPassword="REPLACE"         TrustedProxyEnable="false"          VHostMatchingCompat="false">      <Log LogLevel="Error" Name=".\logs\defaultServer\http_plugin.log"/>      <Property Name="ESIEnable" Value="true"/>      <Property Name="ESIMaxCacheSize" Value="1024"/>      <Property Name="ESIInvalidationMonitor" Value="false"/>      <Property Name="ESIEnableToPassCookies" Value="false"/>      <Property Name="PluginInstallRoot" Value="."/>      <!-- Server Clusters -->      <ServerCluster CloneSeparatorChange="false"                     GetDWLMTable="false"                    IgnoreAffinityRequests="true"                     LoadBalance="Round Robin"                    Name="Shared_2_Cluster_0"                     PostBufferSize="64"                     PostSizeLimit="-1"                    RemoveSpecialHeaders="true"                     RetryInterval="60">          <Server CloneID="Server3CloneID"             ConnectTimeout="0" ExtendedHandshake="false"             MaxConnections="-1" Name="Server3"             ServerIOTimeout="900" WaitForContinue="false">            <Transport Hostname="9.115.75.85"                       Port="9081"                       Protocol="http"/>          </Server>          <Server CloneID="Server2CloneID"                 ConnectTimeout="0"                  ExtendedHandshake="false"                 MaxConnections="-1"                  Name="Server2"                 ServerIOTimeout="900"                  WaitForContinue="false">                <Transport Hostname="9.111.97.74"                           Port="9081"                           Protocol="http"/>           </Server>           <PrimaryServers>               <Server Name="Server3"/>               <Server Name="Server2"/>           </PrimaryServers>      </ServerCluster>      <!-- Virtual Host Groups -->      <VirtualHostGroup Name="/cell/sharedCell_2/vHostGroup/shared_host_0">          <VirtualHost Name="*:443"/>          <VirtualHost Name="*:80"/>          <VirtualHost Name="*:9080"/>          <VirtualHost Name="*:9081"/>      </VirtualHostGroup>      <!-- URI Groups -->      <UriGroup Name="/cell/sharedCell_2/application/   default_host_defaultServer_default_node_Cluster_URIs">          <Uri AffinityCookie="JSESSIONID"              AffinityURLIdentifier="jsessionid"               Name="/test/*"/>      </UriGroup>      <!-- Routes -->      <Route ServerCluster="Shared_2_Cluster_0"            UriGroup="/cell/sharedCell_2/application/   default_host_defaultServer_default_node_Cluster_URIs"              VirtualHostGroup="/cell/sharedCell_2/vHostGroup/shared_host_0"/>   </Config>

将合并后的 plugin-cfg.xml 配置文件拷贝到 IBM HTTP 服务器上。

下边所示代码到 http.conf 文件使 plugin-cfg.xml 配置文件生效

清单 10. plugin-cfg.xml 生效示例

 LoadModule was_ap22_module "path\to\mod_was_ap22_http.dll"  WebSpherePluginConfig "path\to\plugin-cfg.xml"

回页首

测试

访问测试程序

启动 HTTP 服务器以及 Test001、Test002 和 Test003。在测试机 A 上打开浏览器，访问 http://localhost/testApp/ 可以看到 Test002 访问界面或者 Test003 访问界面。这依赖于 HTTP 服务器将请求发送到 Test002 还是 Test003。

图 11. Test002 访问界面

图 12. Test003 访问界面

以第一次访问 Test002 为例，此时如果 Test002 发生故障停机了（在此手动停掉 Test002），当再次访问 http://localhost/testApp/ 时，HTTP 服务器会将请求发送到 Test003，如图 13 所示。但此时计数器并没有还原，由于两个服务器共享内存网格数据，所以计数器在首次访问 Test003 的时候已经在 Test002 的基础上加了一。

图 13. Test003 计数器增加界面

参考资料

这篇文章主要是参考了http://blog.csdn.net/jiangkai_nju/article/details/7338177这个博客，要看详细的内容可以参考这个博客进行学习研究，但是我觉得在以下的一些基本可以满足我们的文件传输要求了。

scp是linux中功能最强大的文件传输命令，可以实现从本地到远程以及远程到本地的轻松文件传输操作。下面简单的讲解一些关于scp命令的操作，给有用的人一些参考：

首先是本地到远程的操作：操作的格式如下

scp local_file remote_username@remote_ip:remote_folder

或者

scp local_file remote_username@remote_ip:remote_file

或者

scp local_file remote_ip:remote_folder

或者

scp local_file remote_ip:remote_file

第1,2个指定了用户名，命令执行后需要再输入密码，第1个仅指定了远程的目录，文件名字不变，第2个指定了文件名；

第3,4个没有指定用户名，命令执行后需要输入用户名和密码，第3个仅指定了远程的目录，文件名字不变，第4个指定了文件名；

* 例子：

scp /home/space/music/1.mp3 root@www.cumt.edu.cn:/home/root/others/music

scp /home/space/music/1.mp3 root@www.cumt.edu.cn:/home/root/others/music/001.mp3

scp /home/space/music/1.mp3 www.cumt.edu.cn:/home/root/others/music

scp /home/space/music/1.mp3 www.cumt.edu.cn:/home/root/others/music/001.mp3

* 复制目录：

* 命令格式：

scp -r local_folder remote_username@remote_ip:remote_folder

或者

scp -r local_folder remote_ip:remote_folder

第1个指定了用户名，命令执行后需要再输入密码；

第2个没有指定用户名，命令执行后需要输入用户名和密码；

* 例子：

scp -r /home/space/music/ root@www.cumt.edu.cn:/home/root/others/

scp -r /home/space/music/ www.cumt.edu.cn:/home/root/others/

上面 命令 将 本地 music 目录 复制 到 远程 others 目录下，即复制后有 远程 有 ../others/music

2、是实现从远程到本地的文件传输操作：

从 远程 复制到 本地，只要将 从 本地 复制到 远程 的命令 的 后2个参数 调换顺序 即可；

例如：

scp root@www.cumt.edu.cn:/home/root/others/music /home/space/music/1.mp3

scp -r www.cumt.edu.cn:/home/root/others/ /home/space/music/

最简单的应用如下 :

scp 本地用户名 @IP 地址 : 文件名 1 远程用户名 @IP 地址 : 文件名 2

[ 本地用户名 @IP 地址 :] 可以不输入 , 可能需要输入远程用户名所对应的密码 .

可能有用的几个参数 :

-v 和大多数 linux 命令中的 -v 意思一样 , 用来显示进度 . 可以用来查看连接 , 认证 , 或是配置错误 .

-C 使能压缩选项 .

-P 选择端口 . 注意 -p 已经被 rcp 使用 .

-4 强行使用 IPV4 地址 .

-6 强行使用 IPV6 地址 .

Linux scp命令的使用方法应该可以满足大家对Linux文件和目录的复制使用了。

websphere application server liberty  部署

下载地址

http://www.ibm.com/developerworks/cn/downloads/ws/wasdevelopers/

1.IBM WebSphere Application Server Liberty for Developers

   was.repo.8550.liberty.developers.ilan.zip  (112M)

2.Installation Manager 1.6.2 for Windows 64-bit ---看实际情况下载

agent.installer.win32.win32.x86_64_1.6.2000.20130301_2248.zip  (135M)

完成下载后，先安装 IBM Installation Manager，安装后让重启 IBM Installation Manager，点击“存储库”选择

was.repo.8550.liberty.developers.ilan.zip解压后的文件repository.config

然后就开始安装了...

安装好后。

启动websphere   liberty ：

C:\Users\xxx>"C:\Program Files\IBM\WebSphere\Liberty\bin\server.bat" start    正在启动服务器 defaultServer。    服务器 defaultServer 已启动。

 App部署和卸载 

 myserver目录即C:\Program Files\IBM\WebSphere\Liberty\usr\servers\defaultServer\

部署和卸载行为可以在两个地方发生,一个是server.xml配置文件中,另一个是dropins目录.
(1) 在myserver目录下找到server.xml文件并打开,加入”<application id="hello-app" location="hello-app.war" name="hello-app" type="war"/>”即可完成部署,删除这句话即可完成卸载，即便myserver处于运行状态也可以这样操作，因为server.xml是 可以即时更新的，所做的修改能够马上生效。相对于tomcat这是Liberty profile的一个优势，当tomcat的server.xml内容被修改修改时必须重启才能生效。这种部署方式适用于开发阶段。
(2) 直接将war包扔进myserver目录下的dropins文件夹中即可完成部署，删除此war包机完成卸载，这种部署适用于实施阶段。
(3)访问App
在浏览器中键入http://localhost:9080/hello-app/index.jsp，页面显示hello world，说明App部署成功，运行正常。

参考：

http://blog.csdn.net/qiaoyupeng/article/details/7226303

什么是 WebSphere Liberty Profile Server ？

Liberty 是一款全新的轻量级应用服务器，它将用户的良好开发体验作为最主要的出发点。其主要特点和内容包括：

• 高 模块化——该功能允许用户根据自己应用程序的需求启用或者禁用相关的 feature（所谓 feature，在这里指的是运行应用程序所需要的各种资源的支持。比如，应用程序用到了 JSP，我们就需要启动 JSP 这个 feature，如果不在需要此 feature，就可以将其禁用。通过这种模块化的控制，我们可以按需启动不同的 feature，包括 JSP, Servlet, JPA 等等，这种控制是实现轻量级应用服务器的基础）。
• 轻量级—— Liberty 采用了多种技术进行瘦身和优化（主要是 OSGi 的应用），与传统的 WAS 相比，极大的减少了运行时的内存消耗。
• 高动态性——由于采用了 OSGi 的架构，程序员在开发的时候，可以动态修改配置文件，应用程序以及服务器的运行时信息，这些修改都是实时生效的，不需要重启服务器。
• 快速——由于采用了高模块化的设计，Liberty 应用服务器会“按需启动”，自身消耗的系统资源很少，对执行任务的反应时间也非常短，例如，一般来说 Liberty 的启动时间小于 5 秒。
• 配置简单——在整个开发过程中，用户只需要和一个配置文件（server.xml）打交道，而且配置的使用也非常灵活。

尽 管 Liberty 与传统 WAS 相比只是一个“小块头”，但是在 Web 和 OSGi 应用程序的开发上，Liberty 与传统 WAS 完全保持一致，在 Liberty 上开发的程序，可以直接移植到传统 WAS 上，不需要做任何的改变。相比传统 WAS 的庞大，Liberty 在为用户提供良好的开发体验上遥遥领先。

作为应用服务器，Liberty 支持与多种开发工具的结合：

• 支持在 Rational Application Developer 中使用 Liberty，推荐在企业级应用开发中使用这种方式，因为这种方式支持最大范围的编程模型以及 Cloud。
• 支 持在 Eclipse 3.6(Helios) 或者 3.7(Indigo) 中使用 Liberty, 需要从 Eclipse Marketplace 安装 WebSphere Application Server V8.5 Developer Tools for Eclipse 或者 WebSphere Application Server V8.5 Liberty Profile Developer Tools for Eclipse。在 Eclipse 中使用 Liberty 是完全免费的，当然，如果你需要得到 IBM 工程师的支持，则需要支付额外的费用。

同时，Liberty 服务器也支持多种主流的操作系统平台，包括 Windows、Linux、Unix、z/OS 以及 Mac OS 等。Liberty 既可以用在开发环境中，也可以用于产品环境（Mac OS 除外）。Liberty 同时支持 Oracle 和 IBM JDK，支持的最低版本分别是：Oracle Java™ 6 update 26 和 IBM Java 6.0 (J9 2.6) SR 1。

回页首

初探 WebSphere Liberty Profile Server

快速安装

在 本文中我们主要介绍 Eclipse 与 Liberty 的结合使用，在开始搭建 Liberty 的开发环境前，读者需要自行下载和安装 Oracle 或者 IBM JDK，并配置好环境变量，这是 Liberty 能正常运行的必要条件。如果是以开发为目的，那么使用 Liberty 以及 Liberty 工具是完全免费的，并且没有时间限制。

在线安装 Liberty 开发工具

打开 Eclipse，依次点击 Help > Eclipse MarketPlace，在出现的页面搜索栏里输入 websphere，并点击搜索。

图 1. 安装 Liberty 开发工具

在 搜索结果中会看到如上红色方框标注的工具，其中 WebSphere Application Server V8.5 Liberty Profile Developer Tools 是 WebSphere Application Server V8.5 Developer Tools 的子集，对于搭建 Liberty 开发环境，直接安装前者就可以，如果读者还需要将 Eclipse 与传统的 WAS 结合使用，那么就需要安装后一个工具。在本文中，我们直接安装 WebSphere Application Server V8.5 Liberty Profile Developer Tools。在安装过程结束后，需要重启 Eclipse。待 Eclipse 重启后，选择 Servers 视图，右击新建一个服务器，出现如下图所示，则表明 Liberty 开发工具已经成功安装

图 2. 验证 Liberty 开发工具安装成功

创建 Liberty 服务器

在安装好 Liberty 开发工具后，我们需要在 Eclipse 中创建 Liberty 服务器，接着图 2 所示，选择 WebSphere Application Server V8.5 Liberty Profile，点击 Next

图 3. 选择 Liberty 的安装位置

在 上图中，我们需要指定 Liberty 服务器的安装位置，对于如何下载 Liberty 服务器，有两种选择：1. 访问 wasdev.net 站点，下载 Liberty 的安装文件，Liberty 安装文件只有不到 50M，下载成功后只需要解压该文件到磁盘的任何一个位置即可完成 Liberty 的安装，“解压即安装”，安装 Liberty 就是如此简单。然后，点击 Browser 选择 Liberty 的安装位置，即可继续创建 Liberty 服务器；2. 直击点击上图的 Download or install，安装提示进行操作，只需要几分钟就可以在线下载并安装一个全新的 Liberty 服务器。在这里我们需要指出的是，您也可以选择直接使用 Liberty 服务器，而不是将其与 Eclipse 搭配起来使用，直接解压下载的 Liberty 到任意目录，就可以使用了。点击 Next，因为 Liberty 默认是没有创建服务器的，所以可以得到下图

图 4. 空白的 Liberty 服务器

点击 New，创建你的第一个 Liberty 服务器

图 5. 创建 Liberty 服务器

为你的 Liberty 任意指定一个名字，点击 Finish 完成创建。在 Servers 视图中，我们将看到创建好的 DemoServer。

图 6. Liberty 服务器概览

从上图中我们可以看到 DemoServer 是停止状态，右键 DemoServer，选择 Start 启动 Liberty 服务器，在 Console 视图中检查 log，可以看到 Liberty 已经正常启动。

清单 1. Liberty 启动日志

 Launching DemoServer (wlp-1.0.0.20120428-1251/websphere-kernel_1.0.0)   on Java HotSpot(TM) Client VM, version 1.7.0_01-b08 (en_US)   [AUDIT   ] CWWKE0001I: The server DemoServer has been launched.   [AUDIT   ] CWWKZ0058I: Monitoring dropins for applications.   [AUDIT   ] CWWKF0011I: The server DemoServer is ready to run a smarter planet.

在上图中，双击 Server Configuration，可以看到如下配置文件（server.xml）。

清单 2. 初始的 server.xml 文件

 <server description="new server">       <!-- Enable features -->      <featureManager>          <feature>jsp-2.2</feature>      </featureManager>       <httpEndpoint id="defaultHttpEndpoint"                   host="localhost"                   httpPort="9080"                   httpsPort="9443" />    </server>

这个 server.xml 就是 Liberty 服务器中唯一的配置文件，我们在开发过程中对应用程序或者 Liberty 运行时的配置都是在这个文件中完成。在默认情况下，Liberty 已经启用了 JSP 功能，我们可以动态的根据应用的需求为 Liberty 增加各种功能支持，方法如下：

在 server.xml 编辑窗口下方，选择 Design 模式，

图 7. 图形化编辑配置文件

选择左侧 Feature Manager，然后选择右侧 Add，出现下图列表，根据需要添加相应的功能支持。

图 8. Features 列表

当 然，读者也可以直接手工编辑 server.xml，手动添加需要的 Feature，但是要注意遵循 Liberty 配置文件的编写规范。到此，我们已经成功的安装了 Liberty 服务器，并搭建好了 Liberty 服务器的开发环境。开始我们的例子程序之前，下文首先向读者更深层次的介绍 Liberty 的功能特性。

简化服务器配置

在 Liberty 中，和用户打交道的只有一个配置文件 server.xml。关于应用程序或者服务器运行时的所有配置都是在这一个文件中完成的，简化了服务器的配置，也减轻了程序员的负担。我们可以在 Eclipse 中直接编辑该文件，修改内容会实时生效。这个配置文件是可以被导出，也可以被不同的服务器共享。

灵活的服务器配置

图 9. 灵活配置

对 于配置文件的使用是非常灵活的，例如：如果有很多个 Liberty 都需要用到同一个配置文件，那么可以将该文件单独导出，存放在一个共享的位置，单个的 Liberty 服务器可以利用 <incluse /> 属性导入共享的配置文件；又比如配置文件的内容非常多而且繁杂，我们就可以将其中的内容分别写在不同的配置文件中（称为不同的配置文件片段），同样利用 <include /> 将这些片段文件导入到主配置文件中，运行时会负责去实时的解析这些片段文件。

应用部署

在 Liberty 中部署应用也是非常简单的事情，打开你的 Liberty 安装目录 <Liberty_Install_dir>\usr\servers\server_name ，可以看到如下目录结构 :

图 10. 应用部署目录

在 上图中 apps 和 dropins 是两个存放安装的应用的文件夹，我们可以通过 Eclipse 部署应用到 Liberty，应用文件将被放在 apps 下面（这个是应用部署的默认目录，也可以通过配置，将应用文件部署到其他任何位置）。我们也可以直接拷贝应用程序（例如 war 文件）到 dropins 目录，当 Liberty 启动的时候，就会自动扫描上面的两个文件夹，然后启动文件夹内的应用程序。当然，启动应用前，要确保已经配置好 server.xml 里的相关信息。

动态加载模块

图 11. 动态化加载

与 传统 WAS 不同的是，Liberty 并不是一个静态的服务器，它是动态的，可以根据应用程序的需要动态加载相应的模块。这些模块是以“feature”来定义的，比如 JSP, Servlet 等，都是不同的 feature。可以将 feature 看作是一个独立的模块，它由一到多个 OSGi bundle 组成，共同来完成某一个特定的任务。这些 feature 可是随时被添加和移除，而不需要重启服务器，正是得益于这样的动态化设计，Liberty 无论在启动时间还是反应时间上都更胜一筹，为程序员带来了快速的开发体验。

运行时动态更新

图 12. 动态更新

Liberty 为我们提供了一个可以动态实时更新的运行时，无论你是修改了应用程序，还是修改配置文件都会实时的被 Liberty 检测到，并立即更新运行时到最新状态，无需重启 Liberty 服务器。新的 feature 可以被随时的添加到 server.xml 中，运行时为负责实时启动相应的功能模块，这一切都与程序员来说都是透明的。例如：我们首先启动 Liberty 服务器，然后将一个 JSP 应用放到 dropins 目录里，如果你没有在 server.xml 中启动 JSP 功能，那么该应用就不会被启动。你将会得到一个警告信息，提示你应该首先启用 JSP 功能，然后该应用才会被实时的启动。同样，如果你将 JSP 功能从 server.xml 中移除，该应用也会被立刻停止。

新型的软件部署方式

图 13. 集中管理 Liberty 服务器

当 我们使用 Liberty 开发完应用程序后，Liberty 为我们提供了一个全新的软件部署方式，我们可以将 Liberty 服务器和应用程序一起打包为 ZIP 文件，然后将这个 ZIP 传输到需要部署软件的服务器上直接解压即可。为了支持适合云端和大规模应用的部署，WebSpere（传统 WAS）还提供了集中管理部署的功能（需要安装 WAS ND 版本），使用该功能可以将我们事先打好的 ZIP 包远程的传输到多个服务器上，在传送完成后，WAS 还会负责解压和安装。另外，WAS 的集中管理功能还提供了远程启动、停止和卸载 Liberty 服务器的功能。

Liberty 之于开发人员

对于开发人员来说，Liberty 的出现是一个十分振奋人心的消息。首先，Liberty 作为一个轻量级的应用服务器，和 Eclipse 可以完美的结合，其最重要的特性就是关注程序员的开发体验，包括快速的下载、安装和环境搭建，在开发过程中，实时的应用更新而无需重启服务器，这些都会极 大的提高程序员的开发效率；其次，在开发，测试和部署应用的过程中，Liberty 都极其友好和方便，其与传统 WAS 的完全兼容，也为应用程序的迁移提供了有力的保障。

回页首

与主流 WEB 容器的对比

从某种程度上来讲，目前，Liberty 与 Tomcat 处在同一个产品层次上，我们从功能特性、使用体验以及标准支持上对这两个服务器进行了对比，从中，我们可以看出 Liberty 在轻量级服务器中所具有的独特优势：

表 1. Liberty VS Tomcat

对比项	Tomcat	Liberty
大小	<30M	<50M
启动速度	<5s	<5s
Java EE 标准支持	JSP 2.2, Servlet 3.0, JSTL 1.2 用户需要添加相关的 jar 包来实现对其它标准的支持	JSP 2.2, Servlet 3.0, JSF 2.0, JSTL 1.2, JPA 2.0, JDBC 4.0, JAX-RS 1.0, JNDI 1.0, Bean Validation 1.0, SSL 1.0, Security 1.0, Web Security 1.0, JMX 1.0 可动态加载或卸载对应的 feature
OSGi 编程模型	否	是，支持 Blue Print 1.0, WAB 1.0
开发工具	支持 Eclipse	支持 eclipse, IBM Rational Application Developer
支持的操作系统	Linux, Windows	Linux, Windows, AIX, Mac, HP-UX, Solaris, iSeries, zSeries
性能	一般	与传统 WAS 具有相同的核心代码，性能好
应用程序热部署	支持	支持
配置文件	多个配置文件，更新后需重启服务器	一个配置文件，更新后及时生效，无需重启
可移植性	您可以利用 IBM Application Migration Toolkit 将 Tomcat 上开发的应用快速移植到 WebSphere 应用服务器。反之，则不然。	Liberty 和传统 WAS 对编程模型和标准的支持一致。在 Liberty 上开发的应用可以直接运行在传统 WAS 之上
文档	官方文档涵盖内容有限，但网络上相关内容（包括：blog，技术文章等）广泛。	http://wasdev.net 上提供下载地址、文档、视频、音频、样本引用等。还有 WAS 的信息中心也有大量文档可供参考阅读。
社区	http://tomcat.apache.org 有 dev 和 user mailing list，没有官方支持，有时回复不够及时。	http://wasdev.net，可以与开发人员直接交流
长期战略优势	一般用于开发环境，生产环产能用的比较少。支持的并发度不高，可扩展性不强。	Liberty 与传统 WAS 共享同一代码，天生具有其高效稳定的特点。开发 - 测试 - 生产切换零代价。可扩展性高，支持多个 server 间的负载均衡和故障恢复。

回页首

Demo：使用 Eclipse 和 Liberty 开发 Web 应用

通 过上面的介绍，相信大家对 Liberty 已经有了一个大概的认识，接下来我们通过一个 Demo 来向大家展示如何使用 Liberty 和 Eclipse 开发 Web 应用。开始 Demo 之前，请大家根据上文的介绍，搭建自己的 Liberty 开发环境，并安装好 JDK 并且配置好环境变量。

Demo 程序很简单，包含一个 Servlet，实现打印当前时间的功能。步骤如下：

1. 打开 Eclipse，选择 File > New > Web>Dynamic Web Project
2. 设置如下属性值：
   1. Project name: Demo
   2. Target runtime: WebSphere Application Server V8.5 Liberty Profile

   图 14. 创建动态 Web 工程

   
3. 点击 Next 两次，然后点击 Finish，完成工程的创建。

   此时，你可以在左侧的资源导航页面看到刚刚创建完成的 Demo 工程，展开工程就可以看到一些默认创建的资源。

4. 右击 Src 目录，选择 New > Class
5. 设置如下属性值：
   1. Package: com.date.demo
   2. Name: DateProvider

   图 15. 创建 java 文件

   
6. 点击 Finish
7. 编辑如下代码到 DateProvider.java

   清单 3. DateProvider.java

    package com.date.demo;    import java.util.Date;    public class DateProvider {    public String getDate() {   // TODO Auto-generated method stub   return new Date().toString();   }   }

   该文件只包含一个方法，getDate() 用来获得当前时间。

8. 右击 Src，选择 New > Servlet
9. 设置如下属性值
   1. Java package: com.date.demo
   2. Class name: DatePrintServlet

   图 16. 创建 Servlet 文件

   
10. 点击 Finish，完成创建。
11. 编辑如下内容到 DatePrintServlet.java

    清单 4. DatePrintServlet.java

     package com.date.demo;    import java.io.IOException;   import javax.servlet.ServletException;   import javax.servlet.annotation.WebServlet;   import javax.servlet.http.HttpServlet;   import javax.servlet.http.HttpServletRequest;   import javax.servlet.http.HttpServletResponse;    /**   * Servlet implementation class DatePrintServlet   */   @WebServlet("/DatePrintServlet")   public class DatePrintServlet extends HttpServlet {   private static final long serialVersionUID = 1L;            /**       * @see HttpServlet#HttpServlet()       */      public DatePrintServlet() {          super();          // TODO Auto-generated constructor stub      }   /**   * @see HttpServlet#doGet(HttpServletRequest request, HttpServletResponse response)   */   protected void doGet(HttpServletRequest request, HttpServletResponse response)    throws ServletException, IOException {   // TODO Auto-generated method stub   DateProvider dateProvider=new DateProvider();   response.getWriter().println(dateProvider.getDate());   }    /**   * @see HttpServlet#doPost(HttpServletRequest request, HttpServletResponse response)   */   protected void doPost(HttpServletRequest request, HttpServletResponse response)   throws ServletException, IOException {   // TODO Auto-generated method stub   }    }

12. 在左侧导航栏选择 DatePrintServlet，点击右键 Run As > Run on Server , 如下图：

    图 17. 选择 Liberty 服务器

    
13. 点击 Finish，Liberty 开发工具将会为我们部署上面的 Demo 程序，并启动 Liberty 服务器。从 console 的日志里我们可以看到如下描述：

[AUDIT ] CWWKZ0001I: Application Demo started in 1.235 seconds.

表明 Demo 应用已经成功部署了，同时，在 Eclipse 自带的浏览器里可以看到如下页面信息：

图 18. Demo 运行页面

让我们回过头来看看 server.xml 里面的内容：

清单 5. server.xml

 <server description="new server">       <!-- Enable features -->      <featureManager>          <feature>jsp-2.2</feature>          <feature>localConnector-1.0</feature>       </featureManager>       <httpEndpoint host="localhost" httpPort="9080" httpsPort="9443"      id="defaultHttpEndpoint"/>       <applicationMonitor updateTrigger="mbean"/>       <application id="Demo" location="Demo.war" name="Demo" type="war"/>   </server>

其中：

<feature /> 包含了应用程序中所用到的功能包，如果你启用了 jsp-2.2，那么 Liberty 默认支持对 Servlet 3.0。

<httpEndpoint /> 指定了 HTTP 访问的端口，我们可以在这里改变默认的端口。

<applicationMonitor /> 用来配置对应用程序的监控模式，updateTrigger 属性是用来控制动态更新的，通过 Liberty 工具部署应用时 updateTrigger 的值设置为 mbean，当我们直接把应用程序拖进 dropins 时，需要将 updateTrigger 设为 polled，当然，如果我们不需要应用的动态更新功能，可以将这个值设为 disabled.

<application /> 用来指定和应用本身相关的属性，id 和 name 是应用的唯一标识，type 指定了应用的类型，location 指定应用所在的位置，默认是在 apps 目录里面，我们可以通过配置修改这个默认设置。

回页首

总结

通 过上面的介绍，相信读者已经对 WAS V8.5 最重要的特性 Liberty 有了一个全面的认识，作为新一代轻量级应用服务器，Liberty 采用了和传统 WAS 相同的代码，继承了传统 WAS 的优点，无论在性能上还是在稳定性上都优越于其他同类产品。Liberty 无论是在开发环境中还是在产品环境中，都具有其他产品不可比拟的优势。我们有理由相信，在追求开发效率和软件质量的今天，每一个程序员都会很快的接受这个 WAS 家族的“小块头”。

参考资料

学习

• 访问 WebSphere Application Server V8.5 信息中心 了解更多关于 WAS 的信息。
• 访问 wasdev.net 主页 学习更多 Liberty 的知识，并直接和开发人员进行交流。
• 访问 WebSphere Developer Tools V8.5 信息中心 学习更多 WDT 的知识。
• IBM developerWorks 中国 WebSphere 专区：为使用 WebSphere 产品的开发人员准备的技术信息和资料。这里提供产品下载、how-to 信息、支持资源以及免费技术库，包含 2000 多份技术文章、教程、最佳实践、IBM Redbook 和在线产品手册。

获得产品和技术

• 最受欢迎的 WebSphere 试用软件下载：下载关键 WebSphere 产品的免费试用版。
• IBM developerWorks 软件下载资源中心：IBM deveperWorks 最新的软件下载。
• IBM developerWorks 工具包：下载关键 WebSphere 最新的产品工具包。

讨论

• 加入 developerWorks 中文社区，developerWorks 社区是一个面向全球 IT 专业人员，可以提供博客、书签、wiki、群组、联系、共享和协作等社区功能的专业社交网络社区。
• 加入 IBM 软件下载与技术交流群组，参与在线交流。

什么是 WebSphere Liberty Profile Server ？

Liberty 是一款全新的轻量级应用服务器，它将用户的良好开发体验作为最主要的出发点。其主要特点和内容包括：

• 高 模块化——该功能允许用户根据自己应用程序的需求启用或者禁用相关的 feature（所谓 feature，在这里指的是运行应用程序所需要的各种资源的支持。比如，应用程序用到了 JSP，我们就需要启动 JSP 这个 feature，如果不在需要此 feature，就可以将其禁用。通过这种模块化的控制，我们可以按需启动不同的 feature，包括 JSP, Servlet, JPA 等等，这种控制是实现轻量级应用服务器的基础）。
• 轻量级—— Liberty 采用了多种技术进行瘦身和优化（主要是 OSGi 的应用），与传统的 WAS 相比，极大的减少了运行时的内存消耗。
• 高动态性——由于采用了 OSGi 的架构，程序员在开发的时候，可以动态修改配置文件，应用程序以及服务器的运行时信息，这些修改都是实时生效的，不需要重启服务器。
• 快速——由于采用了高模块化的设计，Liberty 应用服务器会“按需启动”，自身消耗的系统资源很少，对执行任务的反应时间也非常短，例如，一般来说 Liberty 的启动时间小于 5 秒。
• 配置简单——在整个开发过程中，用户只需要和一个配置文件（server.xml）打交道，而且配置的使用也非常灵活。

尽 管 Liberty 与传统 WAS 相比只是一个“小块头”，但是在 Web 和 OSGi 应用程序的开发上，Liberty 与传统 WAS 完全保持一致，在 Liberty 上开发的程序，可以直接移植到传统 WAS 上，不需要做任何的改变。相比传统 WAS 的庞大，Liberty 在为用户提供良好的开发体验上遥遥领先。

作为应用服务器，Liberty 支持与多种开发工具的结合：

• 支持在 Rational Application Developer 中使用 Liberty，推荐在企业级应用开发中使用这种方式，因为这种方式支持最大范围的编程模型以及 Cloud。
• 支 持在 Eclipse 3.6(Helios) 或者 3.7(Indigo) 中使用 Liberty, 需要从 Eclipse Marketplace 安装 WebSphere Application Server V8.5 Developer Tools for Eclipse 或者 WebSphere Application Server V8.5 Liberty Profile Developer Tools for Eclipse。在 Eclipse 中使用 Liberty 是完全免费的，当然，如果你需要得到 IBM 工程师的支持，则需要支付额外的费用。

同时，Liberty 服务器也支持多种主流的操作系统平台，包括 Windows、Linux、Unix、z/OS 以及 Mac OS 等。Liberty 既可以用在开发环境中，也可以用于产品环境（Mac OS 除外）。Liberty 同时支持 Oracle 和 IBM JDK，支持的最低版本分别是：Oracle Java™ 6 update 26 和 IBM Java 6.0 (J9 2.6) SR 1。

回页首

初探 WebSphere Liberty Profile Server

快速安装

在 本文中我们主要介绍 Eclipse 与 Liberty 的结合使用，在开始搭建 Liberty 的开发环境前，读者需要自行下载和安装 Oracle 或者 IBM JDK，并配置好环境变量，这是 Liberty 能正常运行的必要条件。如果是以开发为目的，那么使用 Liberty 以及 Liberty 工具是完全免费的，并且没有时间限制。

在线安装 Liberty 开发工具

打开 Eclipse，依次点击 Help > Eclipse MarketPlace，在出现的页面搜索栏里输入 websphere，并点击搜索。

图 1. 安装 Liberty 开发工具

在 搜索结果中会看到如上红色方框标注的工具，其中 WebSphere Application Server V8.5 Liberty Profile Developer Tools 是 WebSphere Application Server V8.5 Developer Tools 的子集，对于搭建 Liberty 开发环境，直接安装前者就可以，如果读者还需要将 Eclipse 与传统的 WAS 结合使用，那么就需要安装后一个工具。在本文中，我们直接安装 WebSphere Application Server V8.5 Liberty Profile Developer Tools。在安装过程结束后，需要重启 Eclipse。待 Eclipse 重启后，选择 Servers 视图，右击新建一个服务器，出现如下图所示，则表明 Liberty 开发工具已经成功安装

图 2. 验证 Liberty 开发工具安装成功

创建 Liberty 服务器

在安装好 Liberty 开发工具后，我们需要在 Eclipse 中创建 Liberty 服务器，接着图 2 所示，选择 WebSphere Application Server V8.5 Liberty Profile，点击 Next

图 3. 选择 Liberty 的安装位置

在 上图中，我们需要指定 Liberty 服务器的安装位置，对于如何下载 Liberty 服务器，有两种选择：1. 访问 wasdev.net 站点，下载 Liberty 的安装文件，Liberty 安装文件只有不到 50M，下载成功后只需要解压该文件到磁盘的任何一个位置即可完成 Liberty 的安装，“解压即安装”，安装 Liberty 就是如此简单。然后，点击 Browser 选择 Liberty 的安装位置，即可继续创建 Liberty 服务器；2. 直击点击上图的 Download or install，安装提示进行操作，只需要几分钟就可以在线下载并安装一个全新的 Liberty 服务器。在这里我们需要指出的是，您也可以选择直接使用 Liberty 服务器，而不是将其与 Eclipse 搭配起来使用，直接解压下载的 Liberty 到任意目录，就可以使用了。点击 Next，因为 Liberty 默认是没有创建服务器的，所以可以得到下图

图 4. 空白的 Liberty 服务器

点击 New，创建你的第一个 Liberty 服务器

图 5. 创建 Liberty 服务器

为你的 Liberty 任意指定一个名字，点击 Finish 完成创建。在 Servers 视图中，我们将看到创建好的 DemoServer。

图 6. Liberty 服务器概览

从上图中我们可以看到 DemoServer 是停止状态，右键 DemoServer，选择 Start 启动 Liberty 服务器，在 Console 视图中检查 log，可以看到 Liberty 已经正常启动。

清单 1. Liberty 启动日志

 Launching DemoServer (wlp-1.0.0.20120428-1251/websphere-kernel_1.0.0)   on Java HotSpot(TM) Client VM, version 1.7.0_01-b08 (en_US)   [AUDIT   ] CWWKE0001I: The server DemoServer has been launched.   [AUDIT   ] CWWKZ0058I: Monitoring dropins for applications.   [AUDIT   ] CWWKF0011I: The server DemoServer is ready to run a smarter planet.

在上图中，双击 Server Configuration，可以看到如下配置文件（server.xml）。

清单 2. 初始的 server.xml 文件

 <server description="new server">       <!-- Enable features -->      <featureManager>          <feature>jsp-2.2</feature>      </featureManager>       <httpEndpoint id="defaultHttpEndpoint"                   host="localhost"                   httpPort="9080"                   httpsPort="9443" />    </server>

这个 server.xml 就是 Liberty 服务器中唯一的配置文件，我们在开发过程中对应用程序或者 Liberty 运行时的配置都是在这个文件中完成。在默认情况下，Liberty 已经启用了 JSP 功能，我们可以动态的根据应用的需求为 Liberty 增加各种功能支持，方法如下：

在 server.xml 编辑窗口下方，选择 Design 模式，

图 7. 图形化编辑配置文件

选择左侧 Feature Manager，然后选择右侧 Add，出现下图列表，根据需要添加相应的功能支持。

图 8. Features 列表

当 然，读者也可以直接手工编辑 server.xml，手动添加需要的 Feature，但是要注意遵循 Liberty 配置文件的编写规范。到此，我们已经成功的安装了 Liberty 服务器，并搭建好了 Liberty 服务器的开发环境。开始我们的例子程序之前，下文首先向读者更深层次的介绍 Liberty 的功能特性。

简化服务器配置

在 Liberty 中，和用户打交道的只有一个配置文件 server.xml。关于应用程序或者服务器运行时的所有配置都是在这一个文件中完成的，简化了服务器的配置，也减轻了程序员的负担。我们可以在 Eclipse 中直接编辑该文件，修改内容会实时生效。这个配置文件是可以被导出，也可以被不同的服务器共享。

灵活的服务器配置

图 9. 灵活配置

对 于配置文件的使用是非常灵活的，例如：如果有很多个 Liberty 都需要用到同一个配置文件，那么可以将该文件单独导出，存放在一个共享的位置，单个的 Liberty 服务器可以利用 <incluse /> 属性导入共享的配置文件；又比如配置文件的内容非常多而且繁杂，我们就可以将其中的内容分别写在不同的配置文件中（称为不同的配置文件片段），同样利用 <include /> 将这些片段文件导入到主配置文件中，运行时会负责去实时的解析这些片段文件。

应用部署

在 Liberty 中部署应用也是非常简单的事情，打开你的 Liberty 安装目录 <Liberty_Install_dir>\usr\servers\server_name ，可以看到如下目录结构 :

图 10. 应用部署目录

在 上图中 apps 和 dropins 是两个存放安装的应用的文件夹，我们可以通过 Eclipse 部署应用到 Liberty，应用文件将被放在 apps 下面（这个是应用部署的默认目录，也可以通过配置，将应用文件部署到其他任何位置）。我们也可以直接拷贝应用程序（例如 war 文件）到 dropins 目录，当 Liberty 启动的时候，就会自动扫描上面的两个文件夹，然后启动文件夹内的应用程序。当然，启动应用前，要确保已经配置好 server.xml 里的相关信息。

动态加载模块

图 11. 动态化加载

与 传统 WAS 不同的是，Liberty 并不是一个静态的服务器，它是动态的，可以根据应用程序的需要动态加载相应的模块。这些模块是以“feature”来定义的，比如 JSP, Servlet 等，都是不同的 feature。可以将 feature 看作是一个独立的模块，它由一到多个 OSGi bundle 组成，共同来完成某一个特定的任务。这些 feature 可是随时被添加和移除，而不需要重启服务器，正是得益于这样的动态化设计，Liberty 无论在启动时间还是反应时间上都更胜一筹，为程序员带来了快速的开发体验。

运行时动态更新

图 12. 动态更新

Liberty 为我们提供了一个可以动态实时更新的运行时，无论你是修改了应用程序，还是修改配置文件都会实时的被 Liberty 检测到，并立即更新运行时到最新状态，无需重启 Liberty 服务器。新的 feature 可以被随时的添加到 server.xml 中，运行时为负责实时启动相应的功能模块，这一切都与程序员来说都是透明的。例如：我们首先启动 Liberty 服务器，然后将一个 JSP 应用放到 dropins 目录里，如果你没有在 server.xml 中启动 JSP 功能，那么该应用就不会被启动。你将会得到一个警告信息，提示你应该首先启用 JSP 功能，然后该应用才会被实时的启动。同样，如果你将 JSP 功能从 server.xml 中移除，该应用也会被立刻停止。

新型的软件部署方式

图 13. 集中管理 Liberty 服务器

当 我们使用 Liberty 开发完应用程序后，Liberty 为我们提供了一个全新的软件部署方式，我们可以将 Liberty 服务器和应用程序一起打包为 ZIP 文件，然后将这个 ZIP 传输到需要部署软件的服务器上直接解压即可。为了支持适合云端和大规模应用的部署，WebSpere（传统 WAS）还提供了集中管理部署的功能（需要安装 WAS ND 版本），使用该功能可以将我们事先打好的 ZIP 包远程的传输到多个服务器上，在传送完成后，WAS 还会负责解压和安装。另外，WAS 的集中管理功能还提供了远程启动、停止和卸载 Liberty 服务器的功能。

Liberty 之于开发人员

对于开发人员来说，Liberty 的出现是一个十分振奋人心的消息。首先，Liberty 作为一个轻量级的应用服务器，和 Eclipse 可以完美的结合，其最重要的特性就是关注程序员的开发体验，包括快速的下载、安装和环境搭建，在开发过程中，实时的应用更新而无需重启服务器，这些都会极 大的提高程序员的开发效率；其次，在开发，测试和部署应用的过程中，Liberty 都极其友好和方便，其与传统 WAS 的完全兼容，也为应用程序的迁移提供了有力的保障。

回页首

与主流 WEB 容器的对比

从某种程度上来讲，目前，Liberty 与 Tomcat 处在同一个产品层次上，我们从功能特性、使用体验以及标准支持上对这两个服务器进行了对比，从中，我们可以看出 Liberty 在轻量级服务器中所具有的独特优势：

表 1. Liberty VS Tomcat

对比项	Tomcat	Liberty
大小	<30M	<50M
启动速度	<5s	<5s
Java EE 标准支持	JSP 2.2, Servlet 3.0, JSTL 1.2 用户需要添加相关的 jar 包来实现对其它标准的支持	JSP 2.2, Servlet 3.0, JSF 2.0, JSTL 1.2, JPA 2.0, JDBC 4.0, JAX-RS 1.0, JNDI 1.0, Bean Validation 1.0, SSL 1.0, Security 1.0, Web Security 1.0, JMX 1.0 可动态加载或卸载对应的 feature
OSGi 编程模型	否	是，支持 Blue Print 1.0, WAB 1.0
开发工具	支持 Eclipse	支持 eclipse, IBM Rational Application Developer
支持的操作系统	Linux, Windows	Linux, Windows, AIX, Mac, HP-UX, Solaris, iSeries, zSeries
性能	一般	与传统 WAS 具有相同的核心代码，性能好
应用程序热部署	支持	支持
配置文件	多个配置文件，更新后需重启服务器	一个配置文件，更新后及时生效，无需重启
可移植性	您可以利用 IBM Application Migration Toolkit 将 Tomcat 上开发的应用快速移植到 WebSphere 应用服务器。反之，则不然。	Liberty 和传统 WAS 对编程模型和标准的支持一致。在 Liberty 上开发的应用可以直接运行在传统 WAS 之上
文档	官方文档涵盖内容有限，但网络上相关内容（包括：blog，技术文章等）广泛。	http://wasdev.net 上提供下载地址、文档、视频、音频、样本引用等。还有 WAS 的信息中心也有大量文档可供参考阅读。
社区	http://tomcat.apache.org 有 dev 和 user mailing list，没有官方支持，有时回复不够及时。	http://wasdev.net，可以与开发人员直接交流
长期战略优势	一般用于开发环境，生产环产能用的比较少。支持的并发度不高，可扩展性不强。	Liberty 与传统 WAS 共享同一代码，天生具有其高效稳定的特点。开发 - 测试 - 生产切换零代价。可扩展性高，支持多个 server 间的负载均衡和故障恢复。

回页首

Demo：使用 Eclipse 和 Liberty 开发 Web 应用

通 过上面的介绍，相信大家对 Liberty 已经有了一个大概的认识，接下来我们通过一个 Demo 来向大家展示如何使用 Liberty 和 Eclipse 开发 Web 应用。开始 Demo 之前，请大家根据上文的介绍，搭建自己的 Liberty 开发环境，并安装好 JDK 并且配置好环境变量。

Demo 程序很简单，包含一个 Servlet，实现打印当前时间的功能。步骤如下：

1. 打开 Eclipse，选择 File > New > Web>Dynamic Web Project
2. 设置如下属性值：
   1. Project name: Demo
   2. Target runtime: WebSphere Application Server V8.5 Liberty Profile

   图 14. 创建动态 Web 工程

   
3. 点击 Next 两次，然后点击 Finish，完成工程的创建。

   此时，你可以在左侧的资源导航页面看到刚刚创建完成的 Demo 工程，展开工程就可以看到一些默认创建的资源。

4. 右击 Src 目录，选择 New > Class
5. 设置如下属性值：
   1. Package: com.date.demo
   2. Name: DateProvider

   图 15. 创建 java 文件

   
6. 点击 Finish
7. 编辑如下代码到 DateProvider.java

   清单 3. DateProvider.java

    package com.date.demo;    import java.util.Date;    public class DateProvider {    public String getDate() {   // TODO Auto-generated method stub   return new Date().toString();   }   }

   该文件只包含一个方法，getDate() 用来获得当前时间。

8. 右击 Src，选择 New > Servlet
9. 设置如下属性值
   1. Java package: com.date.demo
   2. Class name: DatePrintServlet

   图 16. 创建 Servlet 文件

   
10. 点击 Finish，完成创建。
11. 编辑如下内容到 DatePrintServlet.java

    清单 4. DatePrintServlet.java

     package com.date.demo;    import java.io.IOException;   import javax.servlet.ServletException;   import javax.servlet.annotation.WebServlet;   import javax.servlet.http.HttpServlet;   import javax.servlet.http.HttpServletRequest;   import javax.servlet.http.HttpServletResponse;    /**   * Servlet implementation class DatePrintServlet   */   @WebServlet("/DatePrintServlet")   public class DatePrintServlet extends HttpServlet {   private static final long serialVersionUID = 1L;            /**       * @see HttpServlet#HttpServlet()       */      public DatePrintServlet() {          super();          // TODO Auto-generated constructor stub      }   /**   * @see HttpServlet#doGet(HttpServletRequest request, HttpServletResponse response)   */   protected void doGet(HttpServletRequest request, HttpServletResponse response)    throws ServletException, IOException {   // TODO Auto-generated method stub   DateProvider dateProvider=new DateProvider();   response.getWriter().println(dateProvider.getDate());   }    /**   * @see HttpServlet#doPost(HttpServletRequest request, HttpServletResponse response)   */   protected void doPost(HttpServletRequest request, HttpServletResponse response)   throws ServletException, IOException {   // TODO Auto-generated method stub   }    }

12. 在左侧导航栏选择 DatePrintServlet，点击右键 Run As > Run on Server , 如下图：

    图 17. 选择 Liberty 服务器

    
13. 点击 Finish，Liberty 开发工具将会为我们部署上面的 Demo 程序，并启动 Liberty 服务器。从 console 的日志里我们可以看到如下描述：

[AUDIT ] CWWKZ0001I: Application Demo started in 1.235 seconds.

表明 Demo 应用已经成功部署了，同时，在 Eclipse 自带的浏览器里可以看到如下页面信息：

图 18. Demo 运行页面

让我们回过头来看看 server.xml 里面的内容：

清单 5. server.xml

 <server description="new server">       <!-- Enable features -->      <featureManager>          <feature>jsp-2.2</feature>          <feature>localConnector-1.0</feature>       </featureManager>       <httpEndpoint host="localhost" httpPort="9080" httpsPort="9443"      id="defaultHttpEndpoint"/>       <applicationMonitor updateTrigger="mbean"/>       <application id="Demo" location="Demo.war" name="Demo" type="war"/>   </server>

其中：

<feature /> 包含了应用程序中所用到的功能包，如果你启用了 jsp-2.2，那么 Liberty 默认支持对 Servlet 3.0。

<httpEndpoint /> 指定了 HTTP 访问的端口，我们可以在这里改变默认的端口。

<applicationMonitor /> 用来配置对应用程序的监控模式，updateTrigger 属性是用来控制动态更新的，通过 Liberty 工具部署应用时 updateTrigger 的值设置为 mbean，当我们直接把应用程序拖进 dropins 时，需要将 updateTrigger 设为 polled，当然，如果我们不需要应用的动态更新功能，可以将这个值设为 disabled.

<application /> 用来指定和应用本身相关的属性，id 和 name 是应用的唯一标识，type 指定了应用的类型，location 指定应用所在的位置，默认是在 apps 目录里面，我们可以通过配置修改这个默认设置。

回页首

总结

通 过上面的介绍，相信读者已经对 WAS V8.5 最重要的特性 Liberty 有了一个全面的认识，作为新一代轻量级应用服务器，Liberty 采用了和传统 WAS 相同的代码，继承了传统 WAS 的优点，无论在性能上还是在稳定性上都优越于其他同类产品。Liberty 无论是在开发环境中还是在产品环境中，都具有其他产品不可比拟的优势。我们有理由相信，在追求开发效率和软件质量的今天，每一个程序员都会很快的接受这个 WAS 家族的“小块头”。

参考资料

学习

• 访问 WebSphere Application Server V8.5 信息中心 了解更多关于 WAS 的信息。
• 访问 wasdev.net 主页 学习更多 Liberty 的知识，并直接和开发人员进行交流。
• 访问 WebSphere Developer Tools V8.5 信息中心 学习更多 WDT 的知识。
• IBM developerWorks 中国 WebSphere 专区：为使用 WebSphere 产品的开发人员准备的技术信息和资料。这里提供产品下载、how-to 信息、支持资源以及免费技术库，包含 2000 多份技术文章、教程、最佳实践、IBM Redbook 和在线产品手册。

获得产品和技术

• 最受欢迎的 WebSphere 试用软件下载：下载关键 WebSphere 产品的免费试用版。
• IBM developerWorks 软件下载资源中心：IBM deveperWorks 最新的软件下载。
• IBM developerWorks 工具包：下载关键 WebSphere 最新的产品工具包。

我们小散户做的是政策面大指标里 的个股，不是整个政策面里的所有股。看业绩，看基本面，看政策都不如看个股快要拉升的时机。好指标里显示个股拉升前的习惯和成交量的数据，好指标的确像温 度计一样记录了39度是发烧，0度以下要结冰的事实。熊市里有涨的可以赚钱的个股，牛市里有跌的能套人的个股。能有一个更好的指标让大家在牛市里多赚一点 钱，在熊市里少赔一点钱，就值得了。

一.选股指标.

次日涨停
W1:=C=HHV(C,20);
W2:=BARSLAST(W1);
W3:=IF(W2>0,REF(C,W2),REF(C,W2));
W4:=CROSS(C,REF(W3,1));
W4 AND COUNT(W4,5)=1;
黄转紫选股
DIFF:=EMA(DCLOSE,12)-EMA(DCLOSE,26);
DEA:=EMA(DIFF,9);
MACD:=(DIFF-DEA)*2;
紫柱:MACD<0 AND MACD>REF(MACD,1) AND REF(MACD,1)<REF(MACD,2);

低位金叉选股
DIFF:=EMA(DCLOSE,12)-EMA(DCLOSE,26);
DEA:=EMA(DIFF,9);
MACD:=(DIFF-DEA)*2;
低位金叉:CROSS(DIFF,DEA) AND DIFF<-0.1;

二次金叉选股
DIFF:=EMA(DCLOSE,12)-EMA(DCLOSE,26);
DEA:=EMA(DIFF,9);
MACD:=(DIFF-DEA)*2;
JCCOUNT:=COUNT(CROSS(DIFF,DEA),BARSLAST(DEA>=0));
二次金叉:CROSS(DIFF,DEA) AND DEA<0 AND COUNT(JCCOUNT=2,21)=1;
绝地反弹
（1）
VAR1:=REF(LOW,1);
VAR2:=SMA(ABS(LOW-VAR1),13,1)/SMA(MAX(LOW-VAR1,0),13,1)*100;
VAR3:=EMA(IF(CLOSE*1.2,VAR2*13,VAR2/13),13);
VAR4:=LLV(LOW,34);
VAR5:=HHV(VAR3,34);
VAR6:=IF(LLV(LOW,55),1,0);
VAR7:=EMA(IF(LOW<=VAR4,(VAR3+VAR5*2)/2,0),3)/618*VAR6;
XL1:=MA(LOW,2)*0.96;
XL2:=MA(LOW,26)*0.85;
XL3:=REF(XL1,1)<XL2 AND REF(XL1,1)<XL1 AND REF(XL1,1)<REF(XL1,2);
启动:=IF(XL3,0,VAR7*3),COLORRED;
XG:启动>25;

（2）

BACKSET( (REF(CLOSE,1)<REF(OPEN,1) AND
CLOSE>OPEN AND ABS(CLOSE-REF(CLOSE,1))/CLOSE<0.002),2);
A2:=FILTER(A1<=V3,10);
ND CAPITAL<300000000
REF(V,1) = LLV(V,4) AND V >=REF(V,1)
HHV(V,3)=REF(V,1) AND HHV(V,5)=REF(V,1) AND HHV(V,21)=REF(V,1)
AND V >=REF(V,1)
01>0 AND T02>0;

1.三线粘合
M:=1;
M5:=MA(CLOSE,5);
M10:=MA(CLOSE,10);
M20:=MA(CLOSE,20);
K1:=MAX(MAX(M5,M10),MAX(M10,M20));
K2:=MIN(MIN(M5,M10),MIN(M10,M20));
A:=MAX(M5,MAX(M10,M20))/MIN(M5,MIN(M10,M20))<1+0.03*M;
A1:=(K1/K2-1)<0.005;
A2:=(K1/K2-1)<0.005;
A3:=V>REF(V,1)*1.5 AND V>MA(V,5);
XG:A AND A1 AND A2 AND A3 AND C>O AND V> REF(V,1) AND CAPITAL<=300000000;

2.三条线粘合
N1:=5;N2:=10;N3:=20;M:=1;
MA1:=MA(C,N1);MA2:=MA(C,N2);MA3:=MA(C,N3);
A3:=V>REF(V,1)*1.5 AND V>MA(V,5);
MAX(MA1,MAX(MA2,MA3))/MIN(MA1,MIN(MA2,MA3))<1+0.01*M
AND C>O AND V> REF(V,1) AND FINANCE(7)<=300000000
AND A3 AND CAPITAL<=300000000;

3.均线粘合
M:=1;
M5:=MA(CLOSE,5);
M10:=MA(CLOSE,10);
M20:=MA(CLOSE,20);
K1:=MAX(MAX(M5,M10),MAX(M10,M20));
K2:=MIN(MIN(M5,M10),MIN(M10,M20));
A:=MAX(M5,MAX(M10,M20))/MIN(M5,MIN(M10,M20))<1+0.01*M;
A1:=(K1/K2-1)<0.005;
A2:=(K1/K2-1)<0.005;
A3:=V>REF(V,1)*1.5 AND V>MA(V,5);
XG:A AND A1 AND A2 AND A3 ;
3. 金叉选股指标
快线:=EMA(EMA(EMA(EMA(CLOSE,2),2),2),2);
慢线:=EMA(REF(快线,1),2);
A3:=V>REF(V,1)*1.5 AND V>MA(V,5);
XG:CROSS(快线,慢线) AND C>O AND
V>=MA(V,21) AND V> REF(V,1) AND CAPITAL<=300000000 ;
4.角度
MA5:=MA(C,5);
MA10:=MA(C,10);
MA20:=MA(C,20);
V0:CROSS(MA5,MA10) AND CROSS(MA10,MA20) AND
CROSS(MA5,MA20) ;
IF(角度MA3>45 AND 角度MA5>40 AND 角度MA10>10
AND 角度MA20>20 AND MA(C,135)>REF(MA(C,135),1),
1,0),COLOR00FF00
1.聚宝盆

DIFF:=EMA(CLOSE,SHORT)-EMA(CLOSE,LONG);
DEA:=EMA(DIFF,M);
MACD2:=2*(DIFF-DEA);
HHV(MACD2,4)<0 AND MACD2>REF(MACD2,1) AND REF(MACD2,1)<REF(MACD2,2) AND REF(MACD2,2)<REF
(MACD2,3);
2.强势股
{SJXXG四均线选股}
MA3:=MA(C,3);
MA5:=MA(C,5);
MA10:=MA(C,10);
MA20:=MA(C,20);
V0:=MA(C,3)>REF(MA(C,3),1) AND MA(C,5)>REF(MA(C,5),1) AND C>MA(C,3)
AND MA(C,3)>MA(C,5) ; {均线C,MA3,MA5多头排列并向上；}
角度MA3:=ATAN((MA3/REF(MA3,1)-1)*100)*180/3.1416;
角度MA5:=ATAN((MA5/REF(MA5,1)-1)*100)*180/3.1416;
角度MA10:=ATAN((MA10/REF(MA10,1)-1)*100)*180/3.1416;
角度MA20:=ATAN((MA20/REF(MA20,1)-1)*100)*180/3.1416;
选股MA20:IF(角度MA3>45 AND 角度MA5>45 AND 角度MA10>60 AND 角度MA20>45 AND MA(C,250)>REF(MA(C,250),1),
1,0),COLOR00FF00;
{设计思路：
1.3日均线角度大于45度；
2:5日均线角度大于45度；
3:10日均线角度大于60度；
4.20日均线角度大于45度；
5.MA250向上；};
3。紫色冲关
(1).
CROSS( CLOSE,MA(C,30))
AND CLOSE>MA(C,22) AND CLOSE>MA(C,30)AND
COUNT(MA(CLOSE,13)>REF(MA(CLOSE,13),1),1)
AND COUNT(MA(CLOSE,8)>REF(MA(CLOSE,8),1),1)
AND COUNT(MA(CLOSE,20)>REF(MA(CLOSE,20),1),1)
AND CLOSE/OPEN>1.015
AND DYNAINFO(37)>0.2% COLORLIBLUE;

(2).
QSXS:=MA(CLOSE,8)>REF(MA(CLOSE,8),1) AND MA(CLOSE,3)>REF(MA(CLOSE,3),1) AND MA(CLOSE,5)>REF(MA(CLOSE,5),1);
DXJC:=CROSS(CLOSE,MA(C,21)) AND CLOSE>MA(C,13) AND CLOSE/OPEN>1.015;
HSL:=VOL/CAPITAL*100;
选股:QSXS AND DXJC AND HSL>2;

(3).
{SJXXG四均线选股}
MA3:=MA(C,1);
MA5:=MA(C,3);
MA10:=MA(C,5);
MA20:=MA(C,10);
V0:=MA(C,1)>REF(MA(C,1),0.5) AND MA(C,3)>REF(MA(C,3),0.5) AND C>MA(C,1)
AND MA(C,1)>MA(C,1) ; {均线C,MA3,MA5,MA10,MA20多头排列并向上；}
角度MA3:=ATAN((MA3/REF(MA3,1)-1)*100)*180/3.1416;
角度MA5:=ATAN((MA5/REF(MA5,1)-1)*100)*180/3.1416;
角度MA10:=ATAN((MA10/REF(MA10,1)-1)*100)*180/3.1416;
角度MA20:=ATAN((MA20/REF(MA20,1)-1)*100)*180/3.1416;
选股MA20:IF(角度MA3>50 AND 角度MA5>40 AND 角度MA10>30
AND 角度MA20>20 AND MA(C,250)>REF(MA(C,250),1),
1,0),COLOR00FF00;
{设计思路：
1.1日均线角度大于40度；
2:3日均线角度大于40度；
3:5日均线角度大于50度；
4.10日均线角度大于40度；
5.MA135向上；};

(4).
{SJXXG四均线选股}
MA3:=MA(C,5);
MA5:=MA(C,10);
MA10:=MA(C,15);
MA20:=MA(C,20);
V0:=MA(C,5)>REF(MA(C,10),1) AND MA(C,10)>REF(MA(C,15),1)
AND MA(C,15)>MA(C,20) ; {均线C,MA3,MA5多头排列并向上；}
角度MA3:=ATAN((MA3/REF(MA3,1)-1)*100)*180/3.1416;
角度MA5:=ATAN((MA5/REF(MA5,1)-1)*100)*180/3.1416;
角度MA10:=ATAN((MA10/REF(MA3,1)-1)*100)*180/3.1416;
角度MA20:=ATAN((MA20/REF(MA5,1)-1)*100)*180/3.1416;
选股MA20:IF(角度MA3>42 AND 角度MA5>25 AND 角度MA10>15 AND 角度MA20>10
AND MA(C,135)>REF(MA(C,135),1),
1,0),COLOR00FF00;
{设计思路：
1.3日均线角度大于30度；
2:5日均线角度大于40度；
3:10日均线角度大于45度；
4.20日均线角度大于40度；
5.MA135向上；};

(5).5日最底

V5:=LLV(V,5);
QSXS:=MA(CLOSE,5)>REF(MA(CLOSE,5),1) AND MA(CLOSE,8)>REF(MA(CLOSE,8),1)
AND MA(CLOSE,21)>REF(MA(CLOSE,21),1);
DXJC:=CROSS(CLOSE,MA(C,21)) AND CLOSE>MA(C,21) AND CLOSE/OPEN>1.015;
HSL:=VOL/CAPITAL*100;
选股:V5 AND QSXS AND DXJC AND HSL>2;
1....{蓄势待发}
V0:=EMA(C,5);
EMA10:=EMA(C,10);
EMA20:=EMA(C,20);
EMA30:=EMA(C,30);
EMA60:=EMA(C,60);
M1:=1000*EMA10/EMA60<=1015 AND 1000*EMA10/EMA60>=975;
M2:=1000*EMA20/EMA60<=1020 AND 1000*EMA20/EMA60>=980;
M3:=1000*EMA30/EMA60<=1015 AND 1000*EMA30/EMA60>=985;
M4:=M1 AND M2 AND M3 AND CROSS(V0,EMA10);
M5:=M1 AND M2 AND M3 AND CROSS(V0,EMA30);
T1:=1000*EMA10/EMA30<=1010 AND 1000*EMA10/EMA30>=990;
T2:=1000*EMA20/EMA30<=1010 AND 1000*EMA20/EMA30>=990;
T3:=T1 AND T2 AND CROSS(V0,EMA10);
T4:=T1 AND T2 AND CROSS(V0,EMA30);
M4 OR M5 OR T3 OR T4;

2.短线之王
VAR1:=(-100)*(HHV(HIGH,3)-CLOSE)/(HHV(HIGH,3)-LLV(LOW,3));
CROSS(VAR1,-87) AND OPEN<MA(CLOSE,5) AND CLOSE>=1.099*REF(CLOSE,1) AND INDEXC>0.98*REF(INDEXC,1) AND CLOSE<=1.47*LLV
(CLOSE,58);

3.枪挑小梁王
W1:=C=HHV(C,20);
W2:=BARSLAST(W1);
W3:=IF(W2>0,REF(C,W2),REF(C,W2));
W4:=CROSS(C,REF(W3,1));
枪挑小梁王:W4 AND COUNT(W4,5)=1;

4.短线之王
VAR1:=(-100)*(HHV(HIGH,3)-CLOSE)/(HHV(HIGH,3)-LLV(LOW,3));
CROSS(VAR1,-87) AND OPEN<MA(CLOSE,5) AND CLOSE>=1.099*REF(CLOSE,1) AND INDEXC>0.98*REF(INDEXC,1) AND CLOSE<=1.47*LLV
(CLOSE,58);
5.财务突破选股
{财务突破选股公式-创幻闲云孤鹤－通信达专用}
年认同价:=MA(C,240);
价格中枢:=(SUM(年认同价,0)/(BARSSINCE(年认同价>0)+239));
箱顶:=价格中枢*1.2;
箱底:=价格中枢*0.8;
毛利润率:=FINANCE(21)/FINANCE(20);
成长价值:=年认同价*(1+毛利润率);
收益价值:=年认同价+FINANCE(33);
回调认同:=EMA(EXPMA(C,20),13);
多头:=(回调认同>REF(回调认同,1))AND(成长价值>REF(成长价值,1))AND(收益价值>REF(收益价值,1))AND(DYNAINFO(7)>0);
回调条件:=COUNT(C<回调认同,5)>=3;
回调突破:=(REF(C,1)<=REF(回调认同,1))AND(C>回调认同)AND(回调条件)AND 多头;
成长条件:=COUNT(C<成长价值,5)>=3;
成长突破:=(REF(C,1)<=REF(成长价值,1))AND(C>成长价值)AND(成长条件)AND 多头;
收益条件:=COUNT(C<收益价值,5)>=3;
收益突破:=(REF(C,1)<=REF(收益价值,1))AND(C>收益价值)AND(收益条件)AND 多头;
箱底条件:=COUNT(C<箱底,5)>=3;
箱底突破:=(REF(C,1)<=REF(箱底,1))AND(C>箱底)AND(箱底条件)AND 多头;
价格条件:=COUNT(C<价格中枢,5)>=3;
价格突破:=(REF(C,1)<=REF(价格中枢,1))AND(C>价格中枢)AND(价格条件)AND 多头;
箱顶条件:=COUNT(C<箱顶,5)>=3;
箱顶突破:=(REF(C,1)<=REF(箱顶,1))AND(C>箱顶)AND(箱顶条件)AND 多头;
突破买点:(回调突破+成长突破+收益突破+箱底突破+价格突破+箱顶突破);

6.横盘是银

VAR1:=(CLOSE-LLV(LOW,9))/(HHV(HIGH,9)-LLV(LOW,9))*100;
VAR2:=SMA(VAR1,3,1);
VAR3:=SMA(VAR2,3,1);
VAR4:=EMA(CLOSE,12)-EMA(CLOSE,26);
VAR5:=EMA(VAR4,9);
VAR6:=2*(VAR4-VAR5);
COUNT(CROSS(VAR2,VAR3),2)>=1 AND COUNT(CROSS(VAR6,0),5)>=1 AND MA(CLOSE,5)>MA(CLOSE,10) AND MA(CLOSE,10)>MA(CLOSE,20) AND
CLOSE>MA(CLOSE,5);
{“短线是银”的使用说明：
此组合选择比较简单，初学者易于掌握，短线有一定可操作性与准确性。但只适合于3天内的短线炒作，不能确定长期趋势。
选股设置：
2日内KD金叉，5日内MACD金叉，均线5日，10日，20日多头排列，收盘价涨过5日均线。};
7.黑马起步选股1
VAR5:=EMA(SMA((CLOSE-LLV(LOW,100))/(HHV(HIGH,100)-LLV(LOW,100))*100,8,1),3);
选股:CROSS(VAR5,15) OR CROSS(VAR5,20) OR CROSS(VAR5,25);

8.起攀选股
{起攀选股}
VAR6:=(2*C+H+L)/4;
VAR7:=LLV(L,27);
VAR8:=HHV(H,27);
攀登:=EMA((VAR6-VAR7)/(VAR8-VAR7)*100,13)-50;
金山:=EMA(0.618*REF(攀登,1)+0.382*攀登,3);
起攀:CROSS(攀登,金山) AND C/REF(C,1)>1.02;
{根据起攀图指标改编,这是精简后的指标};
9.中短波选股
{中短波选股}
HZ:=EMA(CLOSE,13);
短波:=EMA(HZ,1);
中波:=EMA(HZ,26);
均线148天:=EMA(C,148);
成本:=SUM(AMOUNT,0)/SUM(VOL,0)/100;
HZ2:=EMA(HZ,8);
CROSS(短波,HZ2);
{结合中短波主图使用};
10.黑马摇篮之大
{黑马摇篮之大黑马}
SS1:=(LOW+HIGH+CLOSE*2)/4;
SS2:= MA(SS1,4);
SS3:=HHV(SS2,10);
SS4:=MA(SS3,3);
SS5:=1.25*SS4-0.25*SS3;
XKKJ:=IF(SS5>SS3,SS3,SS5);
FF1:=LLV(SS2,10);
FF2:=MA(FF1,3);
FF3:=1.25*FF2-0.25*FF1;
DKKJ:=IF(FF3<FF1,FF1,FF3);
MA13:=MA(C,13);
ZDHM:=CROSS(C,DKKJ) AND CROSS(C,MA13) AND CROSS(C,XKKJ);
ZHM:=CROSS(C,MA13) AND CROSS(C,XKKJ);
大黑马:ZDHM OR ZHM;
11.黑马摇篮之小
{黑马摇篮之小黑马}
A:=(3*CLOSE+LOW+OPEN+HIGH)/6;
D1:=(20*A+19*REF(A,1)+18*REF(A,2)+17*REF(A,3)+16*REF(A,4)+15*REF(A,5)+14*REF(A,6)
+13*REF(A,7)+12*REF(A,8)+11*REF(A,9)+10*REF(A,10)+9*REF(A,11)+8*REF(A,12)
+7*REF(A,13)+6*REF(A,14)+5*REF(A,15)+4*REF(A,16)+3*REF(A,17)+2*REF(A,18)+
REF(A,20))/211;
D2:=EMA(D1,2);
D3:=EMA(D2,2);
K1:=EMA(D3,2);
小黑马:CROSS(D1,K1);
12.蓄势待发
{蓄势待发}
V0:=EMA(C,5);
EMA10:=EMA(C,10);
EMA20:=EMA(C,20);
EMA30:=EMA(C,30);
EMA60:=EMA(C,60);
M1:=1000*EMA10/EMA60<=1015 AND 1000*EMA10/EMA60>=975;
M2:=1000*EMA20/EMA60<=1020 AND 1000*EMA20/EMA60>=980;
M3:=1000*EMA30/EMA60<=1015 AND 1000*EMA30/EMA60>=985;
M4:=M1 AND M2 AND M3 AND CROSS(V0,EMA10);
M5:=M1 AND M2 AND M3 AND CROSS(V0,EMA30);
T1:=1000*EMA10/EMA30<=1010 AND 1000*EMA10/EMA30>=990;
T2:=1000*EMA20/EMA30<=1010 AND 1000*EMA20/EMA30>=990;
T3:=T1 AND T2 AND CROSS(V0,EMA10);
T4:=T1 AND T2 AND CROSS(V0,EMA30);
M4 OR M5 OR T3 OR T4;
13.四线粘合
{四线粘合}
V0:=EMA(C,5);
V1:=EMA(C,10);
V2:=EMA(C,15);
V3:=EMA(C,30);
V4:=EMA(C,60);
M1:=1000*V1/V4<=1015 AND 1000*V1/V4>=975;
M2:=1000*V2/V4<=1020 AND 1000*V2/V4>=980;
M3:=1000*V3/V4<=1015 AND 1000*V3/V4>=985;
M4:=M1 AND M2 AND M3 AND CROSS(V0,V1);
M5:=M1 AND M2 AND M3 AND CROSS(V0,V3);
M4 OR M5;

14.拉升在即
{拉升在即}
ABV:=MA(SUM(IF(CLOSE>REF(CLOSE,1),VOL,IF(CLOSE<REF(CLOSE,1),-VOL,0)),0)/25000,2);
M1:=EMA(ABV,12);
M2:=EMA(ABV,26);
MTM:=CLOSE-REF(CLOSE,1);
MMS:=((100)*(EMA(EMA(MTM,6),6)))/(EMA(EMA(ABS(MTM),6),6));
MMM:=((100)*(EMA(EMA(MTM,12),12)))/(EMA(EMA(ABS(MTM),12),12));
MML:=((100)*(EMA(EMA(MTM,26),26)))/(EMA(EMA(ABS(MTM),26),26));
A:=((VOL)/(CAPITAL))*(100);
S:=((MA(A,30))/(MA(INDEXA,10)))*(MA(INDEXA,60));
Y:=((MA(A,120))/(MA(INDEXA,10)))*(MA(INDEXA,60));
X:=1;
拉升在即:S<X AND Y<X AND MMS>MML AND ABV>M1 AND CROSS(S,Y);

15.HMYZ黑马易找

VAR1:=MA(CLOSE,5);
VAR2:=MA(CLOSE,10);
VAR3:=MA(CLOSE,30);
VAR4:=MA(CLOSE,60);
VAR5:=EMA(COST(85),7);
VAR6:=EMA(COST(15),7);
VAR7:=SUM(CLOSE*VOL*100,4)/SUM(VOL*100,4);
VAR8:=INTPART(VAR7*100)/100;
VAR9:=SUM(CLOSE*VOL*100,7)/SUM(VOL*100,7);
VARA:=INTPART(VAR9*100)/100;
VARB:=SUM(CLOSE*VOL*100,28)/SUM(VOL*100,28);
VARC:=INTPART(VARB*100)/100;
VARD:=EMA(CLOSE,5)-EMA(CLOSE,10);
VARE:=EMA(VARD,9);
VARF:=(-100)*(HHV(CLOSE,5)-CLOSE)/(HHV(CLOSE,5)-LLV(LOW,5))+100;
VAR10:=(-100)*(HHV(CLOSE,10)-CLOSE)/(HHV(CLOSE,10)-LLV(LOW,10))+100;
VAR11:=(-100)*(HHV(CLOSE,20)-CLOSE)/(HHV(CLOSE,20)-LLV(LOW,20))+100;
VAR12:=(-100)*(HHV(CLOSE,30)-CLOSE)/(HHV(CLOSE,30)-LLV(LOW,30))+100;
VAR13:=REF(VARE,1);
VAR14:=VARE;
VAR15:=VAR14-VAR13;
VAR16:=REF(VARD,1);
VAR17:=VARD;
VAR18:=VAR17-VAR16;
VAR19:=OPEN;
VAR1A:=CLOSE;
黑马易找选股: VAR19<=VAR1 AND VAR19<=VAR2 AND VAR19<=VAR3 AND VAR1A>=VAR1 AND VAR1A>=VARC AND VAR15>0 AND VAR18>0;
16.黑马起步选股2
VAR5:=EMA(SMA((CLOSE-LLV(LOW,100))/(HHV(HIGH,100)-LLV(LOW,100))*100,8,1),3);
选股:CROSS(VAR5,30) OR CROSS(VAR5,35) OR CROSS(VAR5,40);
17.黑马起步选股1
VAR5:=EMA(SMA((CLOSE-LLV(LOW,100))/(HHV(HIGH,100)-LLV(LOW,100))*100,8,1),3);
选股:CROSS(VAR5,15) OR CROSS(VAR5,20) OR CROSS(VAR5,25);
二。主图指标
三。三线买卖
快线:EMA(EMA(EMA(EMA(CLOSE,2),2),2),2),LINETHICK2,COLOR0000FF;
慢线:EMA(REF(快线,1),2),LINETHICK2,COLOR00FFFF;
总趋势:EMA(EMA(EMA(EMA(EMA(CLOSE,55),2),2),2),2),LINETHICK2,COLORFF00FF;
HIGHN:=10;LOWN:=10;HIGHDISPLAY:=0;LOWDISPLAY:=0;ZGDISPLAY:=0;MADISPLAY:=0;
AA:=REF(H,HIGHN)=HHV(H,2*HIGHN+1);
QY:=BACKSET(AA,HIGHN+1);
CC:=FILTER(QY,HIGHN) AND H=HHV(H,HIGHN+1);
DRAWICON(CC,H*1.02,2);
DDD:=BARSLAST(CC);
GDTS:=IF(CC,CURRBARSCOUNT,0);
DINGBU:=IF(DDD,REF(H,DDD),H);{顶部}
DINGBUTS:=IF(DDD,REF(GDTS,DDD),GDTS);
DINGBU1:=REF(DINGBU,DDD+1);
GDCS1:=CONST(DINGBUTS);
DINGBUTS1:=REF(DINGBUTS,DDD+1);
GDCS2:=CONST(DINGBUTS1);
DINGBU2:=REF(DINGBU1,DDD+1);
MM:=IF(CURRBARSCOUNT>GDCS2,0,1);
高点压力:DRAWLINE(CURRBARSCOUNT=GDCS2,H,CURRBARSCOUNT=GDCS1,H,1) COLORGREEN,LINETHICK2;
DRAWLINE(CURRBARSCOUNT=GDCS2,H,ISLASTBAR,REF(H,GDCS2-1),1),COLOR0055FF,POINTDOT;
DRAWLINE(CURRBARSCOUNT=GDCS1,H,ISLASTBAR,REF(H,GDCS1-1),1),COLORYELLOW,POINTDOT;
AA1:=REF(L,LOWN)=LLV(L,2*LOWN+1);
QY1:=BACKSET(AA1,LOWN+1);
CC1:=FILTER(QY1,LOWN) AND L=LLV(L,LOWN+1);
DRAWICON(CC1,L*0.98,1);
DD1:=BARSLAST(CC1);
DDTS:=IF(CC1,CURRBARSCOUNT,0);
YDB:=IF(DD1,REF(L,DD1),L);
DDTS1:=IF(DD1,REF(DDTS,DD1),DDTS);
DDCS1:=CONST(DDTS1);
ZDB:=REF(YDB,DD1+1);
DDTS2:=REF(DDTS1,DD1+1);
DDCS2:=CONST(DDTS2);
低点支撑:DRAWLINE(CURRBARSCOUNT=DDCS2,L,CURRBARSCOUNT=DDCS1,L,1) COLORRED,LINETHICK2;
ZGSTAR:=(高点压力+低点支撑)/2;
ZGEND:=CONST((高点压力+低点支撑)/2);
STARDAY:=IF(DDCS2<GDCS2,DDCS2,GDCS2);
中轨:DRAWLINE(CURRBARSCOUNT=STARDAY,ZGSTAR,ISLASTBAR,ZGEND,1),COLORFF55BB,LINETHICK2;
DRAWLINE(CURRBARSCOUNT=DDCS1,L,ISLASTBAR,REF(L,DDCS1-1),1),COLORMAGENTA,POINTDOT,;
DRAWLINE(CURRBARSCOUNT=DDCS2,L,ISLASTBAR,REF(L,DDCS2-1),1),COLORCYAN,POINTDOT;
四。3线粘合
MA3:EMA(C,3),linethick2; MA5:EMA(C,5),linethick2; MA7:EMA(C,7),linethick2; MA14:EMA(C,14),linethick1,STICK; MA114:EMA
(C,14),linethick2; DRAWICON (cross(MA3,MA7),L*0.985,1);
五.三线乾坤

快线:EMA(EMA(EMA(EMA(CLOSE,2),2),2),2),LINETHICK2,COLOR0000FF;
慢线:EMA(REF(快线,1),2),LINETHICK2,COLOR00FFFF;
总趋势:EMA(EMA(EMA(EMA(EMA(CLOSE,55),2),2),2),2),LINETHICK2,COLORFF00FF;
A1:=REF(H,8)=HHV(H,2*8+1);
B1:=FILTER(A1,8);
C1:=BACKSET(B1,8+1);
D1:=FILTER(C1,8);{高点}
R11:=BACKSET(ISLASTBAR,BARSLAST(D1)+1); S11:=R11>REF(R11,1);
DRAWLINE(D1,H,S11,H,1),COLORBLUE;
A2:=REF(L,8)=LLV(L,2*8+1);
B2:=FILTER(A2,8);
C2:=BACKSET(B2,8+1);
D2:=FILTER(C2,8);{低点}
T11:=BACKSET(ISLASTBAR,BARSLAST(D2)+1); U11:=T11>REF(T11,1);
DRAWLINE(D2,L,U11,L,1),COLORBLUE;
M:=INTPART(3*8/5);
A12:=REF(H,M)=HHV(H,2*M+1);
B12:=FILTER(A12,M);
C12:=BACKSET(B12,M+1);
D12:=FILTER(C12,M);{高点}
R112:=BACKSET(ISLASTBAR,BARSLAST(D12)+1); S112:=R112>REF(R112,1);
DRAWLINE(D12,H,S112,H,1),COLORRED;
A22:=REF(L,M)=LLV(L,2*M+1);
B22:=FILTER(A22,M);
C22:=BACKSET(B22,M+1);
D22:=FILTER(C22,M);{低点}
T112:=BACKSET(ISLASTBAR,BARSLAST(D22)+1); U112:=T112>REF(T112,1);
DRAWLINE(D22,L,U112,L,1),COLORRED;
VAR1111:=BACKSET(REF(HIGH,2)=HHV(HIGH,5),3);
VAR2222:=CROSS(VAR1111,0.9);
VAR3333:=BACKSET(REF(LOW,2)=LLV(LOW,5),3);
VAR4444:=CROSS(VAR3333,0.9);
压力:= REF(HIGH,BARSLAST(VAR2222));
STICKLINE(CLOSE,REF(HIGH,BARSLAST(VAR2222)),REF(HIGH,BARSLAST(VAR2222)),0.5,1),COLOREA91B5,LINETHICK3;
支撑:= REF(LOW,BARSLAST(VAR4444));
STICKLINE(CLOSE,REF(LOW,BARSLAST(VAR4444)),REF(LOW,BARSLAST(VAR4444)),0.5,1),COLOR00B4FF,LINETHICK3;
下档线:=(((CLOSE - LLV(LOW,13)) / (HHV(HIGH,13) - LLV(LOW,13))) * 100);
RRRSV:=SMA(下档线,3,1);
KKK:=SMA(RRRSV,3,1);
DDD:=((3 * RRRSV) - (2 * KKK));
JJ12:=(((CLOSE - LLV(LOW,55)) / (HHV(HIGH,55) - LLV(LOW,55))) * 100);
RSV24:=SMA(JJ12,3,1);
K24:=SMA(RSV24,3,1);
D24:=((3 * RSV24) - (2 * K24));
压力2:=IF(CROSS(D24,DDD),HIGH,REF(HIGH,BARSLAST(CROSS(D24,DDD)))),COLORFFFFFF;
底部:=LLV(HIGH,30),COLOR00FF00;
DRAWICON(L<=支撑 AND H>支撑,L,0);
DRAWICON(H>=压力 AND L<压力,H,0);
DRAWICON(CROSS(快线,慢线),L*0.95,5);
DRAWICON(CROSS(慢线,快线),H*1.05,6);
三。副图指标

1。黄金坑
DIFF:=EMA(CLOSE,SHORT)-EMA(CLOSE,LONG);
DEA:=EMA(DIFF,M);
MACD2:=2*(DIFF-DEA);
(CLOSE<0 AND CROSS(DIFF,0),H*1.3),COLOR000080,NODRAW;
(CLOSE<0 AND CROSS(MACD2,0),H*1.3),COLOR000080,NODRAW;
(CLOSE<0 AND CROSS(0,DIFF),H*1.3),COLOR808080,NODRAW;
(CLOSE<0 AND CROSS(0,MACD2),H*1.3),COLOR808080,NODRAW;
DU0:=CROSS(DIFF,0);
UD0:=CROSS(0,DIFF);
TDU0:=BARSLAST(DU0);
TUD0:=BARSLAST(UD0);
DU3:=REF(DU0,1);
UD3:=REF(UD0,1);
TDU3:=BARSLAST(DU3);
TUD3:=BARSLAST(UD3);
UDGLINE:=IF(TDU3<TUD3,REF(HHV(HIGH,2),TDU3),REF(LLV(LOW,2),TUD3));
JDU0:=REF(CLOSE,1)<=REF(UDGLINE,1) AND CLOSE>UDGLINE AND TDU0<TUD0;
JUD0:=REF(CLOSE,1)>=REF(UDGLINE,1) AND CLOSE<UDGLINE AND TUD0<TDU0;
JDU1:=JDU0 AND COUNT(JDU0,TDU0)=1;
JUD1:=JUD0 AND COUNT(JUD0,TUD0)=1;
JDU2:=JDU1 AND REF(BARSLAST(JUD1),1)<REF(BARSLAST(JDU1),1);
JUD2:=JUD1 AND REF(BARSLAST(JUD1),1)>REF(BARSLAST(JDU1),1);
JDU3:=JDU1 AND REF(BARSLAST(JUD1),1)>REF(BARSLAST(JDU1),1);
JUD3:=JUD1 AND REF(BARSLAST(JUD1),1)<REF(BARSLAST(JDU1),1);
BSLINE:=IF(BARSLAST(JDU2)<BARSLAST(JUD2),IF(REF(CROSS(0,MACD2),1),LLV(LOW,2),REF(LLV(LOW,2),BARSLAST(REF(CROSS
(0,MACD2),1)))),IF(REF(CROSS(MACD2,0),1),HHV(HIGH,2),REF(HHV(HIGH,2),BARSLAST(REF(CROSS(MACD2,0),1)))));
STICKLINE(MACD2>=0,0,MACD2,2,1),COLOR0000FF;
STICKLINE(MACD2>=0 AND MACD2<REF(MACD2,1),0,MACD2,2,0),COLOR0000FF;
STICKLINE(MACD2<0,0,MACD2,2,0),COLORFFFF00;
STICKLINE(MACD2<0 AND MACD2>REF(MACD2,1),0,MACD2,2,1),COLORFFFF00;
DIF:DIFF,LINETHICK2,COLOR0000FF;
MACD:DEA,COLORFF0000;
DEF:MACD2,LINETHICK0,COLORFFFF00;
STICKLINE(CLOSE>0,0,0,2,0),COLOR808080;
DEFUT:=BARSLAST(CROSS(MACD2,0));
DEFDT:=BARSLAST(CROSS(0,MACD2));
DEFUL:=IF(MACD2>=0,HHV(MACD2,DEFUT+1),REF(HHV(MACD2,DEFUT+1),DEFDT+1));
DEFDL:=IF(MACD2<0,LLV(MACD2,DEFDT+1),REF(LLV(MACD2,DEFDT+1),DEFUT+1));
DEFU2L:=REF(DEFUL,DEFUT+1);
DEFD2L:=REF(DEFDL,DEFDT+1);
DRAWICON(LLV(MACD2,4)>0 AND MACD2<REF(MACD2,1) AND REF(MACD2,1)>REF(MACD2,2) AND REF(MACD2,2)>REF(MACD2,3),MACD2,2);
DRAWICON(HHV(MACD2,4)<0 AND MACD2>REF(MACD2,1) AND REF(MACD2,1)<REF(MACD2,2) AND REF(MACD2,2)<REF(MACD2,3),MACD2,1);
DRAWICON((JUD1 OR BARSLAST(JDU1)>BARSLAST(JUD1)) AND MACD2>=0 AND REF(MACD2,1)<REF(DEFU2L,1) AND MACD2>DEFU2L,MACD2,5);
DRAWICON((JDU1 OR BARSLAST(JDU1)<BARSLAST(JUD1)) AND MACD2<0 AND REF(MACD2,1)>REF(DEFD2L,1) AND MACD2<DEFD2L,MACD2,3);
VAR111:=JDU1 OR BARSLAST(JDU1)<BARSLAST(JUD1);
VAR112:=HHV(MACD2,4)<0 AND MACD2>REF(MACD2,1) AND REF(MACD2,1)<REF(MACD2,2) AND REF(MACD2,2)<REF(MACD2,3);
2.资金流向
DIFF:=EMA(CLOSE,SHORT)-EMA(CLOSE,LONG);
DEA:=EMA(DIFF,M);
MACD2:=2*(DIFF-DEA);
(CLOSE<0 AND CROSS(DIFF,0),H*1.3),COLOR000080,NODRAW;
(CLOSE<0 AND CROSS(MACD2,0),H*1.3),COLOR000080,NODRAW;
(CLOSE<0 AND CROSS(0,DIFF),H*1.3),COLOR808080,NODRAW;
(CLOSE<0 AND CROSS(0,MACD2),H*1.3),COLOR808080,NODRAW;
DU0:=CROSS(DIFF,0);
UD0:=CROSS(0,DIFF);
TDU0:=BARSLAST(DU0);
TUD0:=BARSLAST(UD0);
DU3:=REF(DU0,1);
UD3:=REF(UD0,1);
TDU3:=BARSLAST(DU3);
TUD3:=BARSLAST(UD3);
UDGLINE:=IF(TDU3<TUD3,REF(HHV(HIGH,2),TDU3),REF(LLV(LOW,2),TUD3));
JDU0:=REF(CLOSE,1)<=REF(UDGLINE,1) AND CLOSE>UDGLINE AND TDU0<TUD0;
JUD0:=REF(CLOSE,1)>=REF(UDGLINE,1) AND CLOSE<UDGLINE AND TUD0<TDU0;
JDU1:=JDU0 AND COUNT(JDU0,TDU0)=1;
JUD1:=JUD0 AND COUNT(JUD0,TUD0)=1;
JDU2:=JDU1 AND REF(BARSLAST(JUD1),1)<REF(BARSLAST(JDU1),1);
JUD2:=JUD1 AND REF(BARSLAST(JUD1),1)>REF(BARSLAST(JDU1),1);
JDU3:=JDU1 AND REF(BARSLAST(JUD1),1)>REF(BARSLAST(JDU1),1);
JUD3:=JUD1 AND REF(BARSLAST(JUD1),1)<REF(BARSLAST(JDU1),1);
BSLINE:=IF(BARSLAST(JDU2)<BARSLAST(JUD2),IF(REF(CROSS(0,MACD2),1),LLV(LOW,2),REF(LLV(LOW,2),BARSLAST(REF(CROSS
(0,MACD2),1)))),IF(REF(CROSS(MACD2,0),1),HHV(HIGH,2),REF(HHV(HIGH,2),BARSLAST(REF(CROSS(MACD2,0),1)))));
STICKLINE(MACD2>=0,0,MACD2,2,1),COLOR0000FF;
STICKLINE(MACD2>=0 AND MACD2<REF(MACD2,1),0,MACD2,2,0),COLOR0000FF;
STICKLINE(MACD2<0,0,MACD2,2,0),COLORFFFF00;
STICKLINE(MACD2<0 AND MACD2>REF(MACD2,1),0,MACD2,2,1),COLORFFFF00;
DIF:DIFF,LINETHICK2,COLOR0000FF;
MACD:DEA,COLORFF0000;
DEF:MACD2,LINETHICK0,COLORFFFF00;
STICKLINE(CLOSE>0,0,0,2,0),COLOR808080;
DEFUT:=BARSLAST(CROSS(MACD2,0));
DEFDT:=BARSLAST(CROSS(0,MACD2));
DEFUL:=IF(MACD2>=0,HHV(MACD2,DEFUT+1),REF(HHV(MACD2,DEFUT+1),DEFDT+1));
DEFDL:=IF(MACD2<0,LLV(MACD2,DEFDT+1),REF(LLV(MACD2,DEFDT+1),DEFUT+1));
DEFU2L:=REF(DEFUL,DEFUT+1);
DEFD2L:=REF(DEFDL,DEFDT+1);
DRAWICON(LLV(MACD2,4)>0 AND MACD2<REF(MACD2,1) AND REF(MACD2,1)>REF(MACD2,2) AND REF(MACD2,2)>REF(MACD2,3),MACD2,2);
DRAWICON(HHV(MACD2,4)<0 AND MACD2>REF(MACD2,1) AND REF(MACD2,1)<REF(MACD2,2) AND REF(MACD2,2)<REF(MACD2,3),MACD2,1);
DRAWICON((JUD1 OR BARSLAST(JDU1)>BARSLAST(JUD1)) AND MACD2>=0 AND REF(MACD2,1)<REF(DEFU2L,1) AND MACD2>DEFU2L,MACD2,5);
DRAWICON((JDU1 OR BARSLAST(JDU1)<BARSLAST(JUD1)) AND MACD2<0 AND REF(MACD2,1)>REF(DEFD2L,1) AND MACD2<DEFD2L,MACD2,3);
VAR111:=JDU1 OR BARSLAST(JDU1)<BARSLAST(JUD1);
VAR112:=HHV(MACD2,4)<0 AND MACD2>REF(MACD2,1) AND REF(MACD2,1)<REF(MACD2,2) AND REF(MACD2,2)<REF(MACD2,3);

3. 变色MACD
（1）
DIFIF1:=EMA(CLOSE,12) - EMA(CLOSE,26);
DEAEA1:=EMA(DIFIF1,9);
MACD1:=2*(DIFIF1-DEAEA1),STICK;
MACD2:=EMA(MACD1,3);
STICKLINE(MACD1>MACD2 AND MACD1>0,0,MACD1,1,0),COLORRED;
STICKLINE(MACD1>MACD2 AND MACD1<0,0,MACD1,1,0),COLORGREEN;
STICKLINE(MACD1<MACD2,0,MACD1,1,0),COLORCBCBC0;
STICKLINE(MACD1>=0 OR MACD1<=0,0,0,50,1),COLORWHITE;
DIFIF1,COLOR33FF33,LINETHICK2;
DEAEA1,COLORYELLOW,LINETHICK2;
MACD:MACD1,NODRAW,COLORMAGENTA;
强:IF(DIFIF1>=DEAEA1,DIFIF1,DRAWNULL),COLORRED,LINETHICK2;
弱:IF(DEAEA1>=DIFIF1,DEAEA1,DRAWNULL),COLORFF9900,LINETHICK2;
DRAWICON(CROSS(DIFIF1,DEAEA1),DIFIF1+0.1,1);
DRAWICON(CROSS(DEAEA1,DIFIF1),-0.5,2);
DRAWTEXT(CROSS(DIFIF1,DEAEA1),DIFIF1,'○'),LINETHICK2, COLORYELLOW;
（2）
DIFIF1:=EMA(CLOSE,12) - EMA(CLOSE,26);
DEAEA1:=EMA(DIFIF1,9);
MACD1:=2*(DIFIF1-DEAEA1),STICK;
MACD2:=EMA(MACD1,3);
STICKLINE(MACD1>MACD2 AND MACD1>0,0,MACD1,1,0),COLORRED;
STICKLINE(MACD1>MACD2 AND MACD1<0,0,MACD1,1,0),COLORGREEN;
STICKLINE(MACD1<MACD2,0,MACD1,1,0),COLORCBCBC0;
STICKLINE(MACD1>=0 OR MACD1<=0,0,0,50,1),COLORWHITE;
DIFIF1,COLOR33FF33,LINETHICK2;
DEAEA1,COLORYELLOW,LINETHICK2;
MACD:MACD1,NODRAW,COLORMAGENTA;
强:IF(DIFIF1>=DEAEA1,DIFIF1,DRAWNULL),COLORRED,LINETHICK2;
弱:IF(DEAEA1>=DIFIF1,DEAEA1,DRAWNULL),COLORFF9900,LINETHICK2;
DRAWICON(CROSS(DIFIF1,DEAEA1),DIFIF1+0.1,1);
DRAWICON(CROSS(DEAEA1,DIFIF1),-0.5,2);
DRAWTEXT(CROSS(DIFIF1,DEAEA1),DIFIF1,'○'),LINETHICK2, COLORYELLOW;

ALTER TABLE CIBCMS. T_TOL_CUST_VALIDADDR ADD COLUMN NVIPCORE_CFM_CNT BIGINT DEFAULT 0;

COMMENT ON COLUMN CIBCMS.T_TOL_CUST_VALIDADDR.NVIPCORE_CFM_CNT IS '已确认非VIP核心客户数量'

xml读取异常Invalid byte 1 of 1-byte UTF-8 sequence

说简单点当你解析别人的xml格式出现这个错误可能就是别人在生成xml时没有保存为utf-8的字符编码格式。

在中文版的window下java的默认的编码为GBK，也就是所虽然我们标识了要将xml保存为utf-8格式但实际上文件是以GBK格式来保存的，所以这也就是为什么能够我们使用GBK、GB2312编码来生成xml文件能正确的被解析，而以UTF-8格式生成的文件不能被xml解析器所解析的原因。

xml解析时遇到的编码异常：

1、最简单就是把<?xml version="1.0" encoding="UTF-8"?>改成<?xml version="1.0" encoding="gbk"?>

2、或者把xml打开另存的时候把字符集改为UTF-8后保存

3、在代码解析的时候先把xml重新写一遍

4、直接dom4j读取的时候用io来读，修改字符编码

1. FileInputStream in = new FileInputStream(new File(fileName));  
2. Reader read = new InputStreamReader(in,"gbk");  
3. Document document = reader.read(read);

    与利用DOM、SAX、JAXP机制来解析xml相比，DOM4J 表现更优秀，具有性能优异、功能强大和极端易用使用的特点，只要懂得DOM基本概念，就可以通过dom4j的api文档来解析xml。dom4j是一套开 源的api。实际项目中，往往选择dom4j来作为解析xml的利器。

先来看看dom4j中对应XML的DOM树建立的继承关系

针对于XML标准定义，对应于图2-1列出的内容，dom4j提供了以下实现：

同时，dom4j的NodeType枚举实现了XML规范中定义的node类型。如此可以在遍历xml文档的时候通过常量来判断节点类型了。

常用API

class org.dom4j.io.SAXReader

• read  提供多种读取xml文件的方式，返回一个Domcument对象

interface org.dom4j.Document

• iterator  使用此法获取node
• getRootElement  获取根节点

interface org.dom4j.Node

• getName  获取node名字，例如获取根节点名称为bookstore
• getNodeType  获取node类型常量值，例如获取到bookstore类型为1——Element
• getNodeTypeName  获取node类型名称，例如获取到的bookstore类型名称为Element

interface org.dom4j.Element

• attributes  返回该元素的属性列表
• attributeValue  根据传入的属性名获取属性值
• elementIterator  返回包含子元素的迭代器
• elements  返回包含子元素的列表

interface org.dom4j.Attribute

• getName  获取属性名
• getValue  获取属性值

interface org.dom4j.Text

• getText  获取Text节点值

interface org.dom4j.CDATA

• getText  获取CDATA Section值

interface org.dom4j.Comment

• getText  获取注释 

实例一：

  1 //先加入dom4j.jar包    2 import java.util.HashMap;   3 import java.util.Iterator;   4 import java.util.Map;   5    6 import org.dom4j.Document;   7 import org.dom4j.DocumentException;   8 import org.dom4j.DocumentHelper;   9 import org.dom4j.Element;  10   11 /**     12 * @Title: TestDom4j.java  13 * @Package   14 * @Description: 解析xml字符串  15 * @author 无处不在  16 * @date 2012-11-20 下午05:14:05  17 * @version V1.0     18 */  19 public class TestDom4j {  20   21     public void readStringXml(String xml) {  22         Document doc = null;  23         try {  24   25             // 读取并解析XML文档  26             // SAXReader就是一个管道，用一个流的方式，把xml文件读出来  27             //   28             // SAXReader reader = new SAXReader(); //User.hbm.xml表示你要解析的xml文档  29             // Document document = reader.read(new File("User.hbm.xml"));  30             // 下面的是通过解析xml字符串的  31             doc = DocumentHelper.parseText(xml); // 将字符串转为XML  32   33             Element rootElt = doc.getRootElement(); // 获取根节点  34             System.out.println("根节点：" + rootElt.getName()); // 拿到根节点的名称  35   36             Iterator iter = rootElt.elementIterator("head"); // 获取根节点下的子节点head  37   38             // 遍历head节点  39             while (iter.hasNext()) {  40   41                 Element recordEle = (Element) iter.next();  42                 String title = recordEle.elementTextTrim("title"); // 拿到head节点下的子节点title值  43                 System.out.println("title:" + title);  44   45                 Iterator iters = recordEle.elementIterator("script"); // 获取子节点head下的子节点script  46   47                 // 遍历Header节点下的Response节点  48                 while (iters.hasNext()) {  49   50                     Element itemEle = (Element) iters.next();  51   52                     String username = itemEle.elementTextTrim("username"); // 拿到head下的子节点script下的字节点username的值  53                     String password = itemEle.elementTextTrim("password");  54   55                     System.out.println("username:" + username);  56                     System.out.println("password:" + password);  57                 }  58             }  59             Iterator iterss = rootElt.elementIterator("body"); ///获取根节点下的子节点body  60             // 遍历body节点  61             while (iterss.hasNext()) {  62   63                 Element recordEless = (Element) iterss.next();  64                 String result = recordEless.elementTextTrim("result"); // 拿到body节点下的子节点result值  65                 System.out.println("result:" + result);  66   67                 Iterator itersElIterator = recordEless.elementIterator("form"); // 获取子节点body下的子节点form  68                 // 遍历Header节点下的Response节点  69                 while (itersElIterator.hasNext()) {  70   71                     Element itemEle = (Element) itersElIterator.next();  72   73                     String banlce = itemEle.elementTextTrim("banlce"); // 拿到body下的子节点form下的字节点banlce的值  74                     String subID = itemEle.elementTextTrim("subID");  75   76                     System.out.println("banlce:" + banlce);  77                     System.out.println("subID:" + subID);  78                 }  79             }  80         } catch (DocumentException e) {  81             e.printStackTrace();  82   83         } catch (Exception e) {  84             e.printStackTrace();  85   86         }  87     }  88   89     /**  90      * @description 将xml字符串转换成map  91      * @param xml  92      * @return Map  93      */  94     public static Map readStringXmlOut(String xml) {  95         Map map = new HashMap();  96         Document doc = null;  97         try {  98             // 将字符串转为XML  99             doc = DocumentHelper.parseText(xml);  100             // 获取根节点 101             Element rootElt = doc.getRootElement();  102             // 拿到根节点的名称 103             System.out.println("根节点：" + rootElt.getName());  104  105             // 获取根节点下的子节点head 106             Iterator iter = rootElt.elementIterator("head");  107             // 遍历head节点 108             while (iter.hasNext()) { 109  110                 Element recordEle = (Element) iter.next(); 111                 // 拿到head节点下的子节点title值 112                 String title = recordEle.elementTextTrim("title");  113                 System.out.println("title:" + title); 114                 map.put("title", title); 115                 // 获取子节点head下的子节点script 116                 Iterator iters = recordEle.elementIterator("script");  117                 // 遍历Header节点下的Response节点 118                 while (iters.hasNext()) { 119                     Element itemEle = (Element) iters.next(); 120                     // 拿到head下的子节点script下的字节点username的值 121                     String username = itemEle.elementTextTrim("username");  122                     String password = itemEle.elementTextTrim("password"); 123  124                     System.out.println("username:" + username); 125                     System.out.println("password:" + password); 126                     map.put("username", username); 127                     map.put("password", password); 128                 } 129             } 130  131             //获取根节点下的子节点body 132             Iterator iterss = rootElt.elementIterator("body");  133             // 遍历body节点 134             while (iterss.hasNext()) { 135                 Element recordEless = (Element) iterss.next(); 136                 // 拿到body节点下的子节点result值 137                 String result = recordEless.elementTextTrim("result");  138                 System.out.println("result:" + result); 139                 // 获取子节点body下的子节点form 140                 Iterator itersElIterator = recordEless.elementIterator("form");  141                 // 遍历Header节点下的Response节点 142                 while (itersElIterator.hasNext()) { 143                     Element itemEle = (Element) itersElIterator.next(); 144                     // 拿到body下的子节点form下的字节点banlce的值 145                     String banlce = itemEle.elementTextTrim("banlce");  146                     String subID = itemEle.elementTextTrim("subID"); 147  148                     System.out.println("banlce:" + banlce); 149                     System.out.println("subID:" + subID); 150                     map.put("result", result); 151                     map.put("banlce", banlce); 152                     map.put("subID", subID); 153                 } 154             } 155         } catch (DocumentException e) { 156             e.printStackTrace(); 157         } catch (Exception e) { 158             e.printStackTrace(); 159         } 160         return map; 161     } 162  163     public static void main(String[] args) { 164  165         // 下面是需要解析的xml字符串例子 166         String xmlString = "<html>" + "<head>" + "<title>dom4j解析一个例子</title>" 167                 + "<script>" + "<username>yangrong</username>" 168                 + "<password>123456</password>" + "</script>" + "</head>" 169                 + "<body>" + "<result>0</result>" + "<form>" 170                 + "<banlce>1000</banlce>" + "<subID>36242519880716</subID>" 171                 + "</form>" + "</body>" + "</html>"; 172  173         /* 174          * Test2 test = new Test2(); test.readStringXml(xmlString); 175          */ 176         Map map = readStringXmlOut(xmlString); 177         Iterator iters = map.keySet().iterator(); 178         while (iters.hasNext()) { 179             String key = iters.next().toString(); // 拿到键 180             String val = map.get(key).toString(); // 拿到值 181             System.out.println(key + "=" + val); 182         } 183     } 184  185 }

实例二：

 1 /**  2  * 解析包含有DB连接信息的XML文件  3  * 格式必须符合如下规范：  4  * 1. 最多三级，每级的node名称自定义；  5  * 2. 二级节点支持节点属性，属性将被视作子节点；  6  * 3. CDATA必须包含在节点中，不能单独出现。  7  *  8  * 示例1——三级显示：  9  * <db-connections> 10  *         <connection> 11  *            <name>DBTest</name> 12  *            <jndi></jndi> 13  *            <url> 14  *                <![CDATA[jdbc:mysql://localhost:3306/db_test?useUnicode=true&characterEncoding=UTF8]]> 15  *             </url> 16  *            <driver>org.gjt.mm.mysql.Driver</driver> 17  *             <user>test</user> 18  *            <password>test2012</password> 19  *            <max-active>10</max-active> 20  *            <max-idle>10</max-idle> 21  *            <min-idle>2</min-idle> 22  *            <max-wait>10</max-wait> 23  *            <validation-query>SELECT 1+1</validation-query> 24  *         </connection> 25  * </db-connections> 26  * 27  * 示例2——节点属性： 28  * <bookstore> 29  *         <book category="cooking"> 30  *            <title lang="en">Everyday Italian</title> 31  *            <author>Giada De Laurentiis</author> 32  *            <year>2005</year> 33  *            <price>30.00</price> 34  *         </book> 35  * 36  *         <book category="children" title="Harry Potter" author="J K. Rowling" year="2005" price="$29.9"/> 37  * </bookstore> 38  * 39  * @param configFile 40  * @return 41  * @throws Exception 42  */ 43 public static List<Map<String, String>> parseDBXML(String configFile) throws Exception { 44     List<Map<String, String>> dbConnections = new ArrayList<Map<String, String>>(); 45     InputStream is = Parser.class.getResourceAsStream(configFile); 46     SAXReader saxReader = new SAXReader(); 47     Document document = saxReader.read(is); 48     Element connections = document.getRootElement(); 49  50     Iterator<Element> rootIter = connections.elementIterator(); 51     while (rootIter.hasNext()) { 52         Element connection = rootIter.next(); 53         Iterator<Element> childIter = connection.elementIterator(); 54         Map<String, String> connectionInfo = new HashMap<String, String>(); 55         List<Attribute> attributes = connection.attributes(); 56         for (int i = 0; i < attributes.size(); ++i) { // 添加节点属性 57             connectionInfo.put(attributes.get(i).getName(), attributes.get(i).getValue()); 58         } 59         while (childIter.hasNext()) { // 添加子节点 60             Element attr = childIter.next(); 61             connectionInfo.put(attr.getName().trim(), attr.getText().trim()); 62         } 63         dbConnections.add(connectionInfo); 64     } 65  66     return dbConnections; 67 }

　　一、引入

　　二、经历了就能理解

　　三、读书要分级

　　四、只读经典

　　五、别吝惜你动笔的那点时间

　　六、再提笔记

　　七、大学课程之授课方法

　　八、我是怎么泡图书馆的

　　一、引入

　　看到这个题目的时候你可能会感到有点好笑：“这还用问，看书就是把书看了一遍呗..” 没错，我们从小到大就是这样想的，也是这样看书的，信手拈来一本叫作"书"的东西，从头到尾就开看了！随时年龄的增长，我们的“阅历”也多了起来了，但你 是不是也有和我一样的感觉——书是读了不少，真正入脑的，能融入自己思想的内容却少之又少，而且随着年头的增加，你越来越不记得自己读过这些书，更不用提 书里到底大概是些什么内容了！这就是我们长久以来的读书方式。。。 你会不会也这样想，如果我能把我从小到大读过的书都能记下来形成自己的思想，那我现在得多牛啊！是呢，我也常常这样想！于是为了让自己更有思想，就去读更 多的书，然后在短短的几年，或者只是几个月，甚至仅仅是几天以后，生活的琐事会渐渐把你关于那些书的缓存挤掉，你的大脑又变成了一块被重新格式化的硬盘， 那些书又与你无关了。

　　说实话，我曾经就是这种情况，并且被其深深的困扰过，花了大量的时间去阅读，但是在脑子里留下的却是星星点点的零碎的内容，于是很快这些零星的 内容也会悄悄的跑掉，剩下的只有一个好笑的自欺欺人的解释——这本书我读过。。。就这样，我骗了自己二十几年，这二十几年里，不管是教科书，还是小人书， 不管是专业书，还是小说，真是读了不少书啊！我花了多少时间在这件事上面呢，少说也有二十年吧，可是，要问我对哪本书的内容真的印象最深的，真的很难回答 的出来，更别说去吸取书的精华了。估计和我一样有这样困扰的人肯定很多。你是吗？

　　二、经历了就能理解

　　我经常会想难道我就真的没有从读书中受益过吗？当然有！“咳，咳。。”我要写条sql去数据库里查一下，数据库里垃圾有点多，估计得花点时 间，“select * from lifecycle where benefit from reading ——>execute!"  (一分钟。。。二分钟。。。五分钟。。十五分钟过去了，数据终于出来了，垃圾数据把系统性能拖的太慢了，是需要作作调优的时候了)，好了，你很幸运，系统 没有宕掉，下面这些数据留给你们参考：

　　1、我自认为英语水平还凑合，几次重要的升学考试和就业面试中，都没有在英语这块栽过跟头，由于后来集中学习日语的原因，英语过了CET-6后 就很少碰，这个原因我下面会解释。现在很多学生中为英语发愁的不在少数，往往其他各科成绩都很好偏偏英语不能达标，错失了好的升学机会。我回顾自己从小学 英语的经历，总有一个点在那闪光，那是我学习英语的转折点。那时是小学四年级，学校刚刚开设英语课，那时和其他的孩子一样，我的英语成绩不怎么样，很吃 力。我老爸对我的学习比较严格，当他发现我的英语不行的时候，他开始跟我急了，那时我也真怕他，当老子就是威武啊~我爸是高中毕业，他那时的外语水平差不 多也就是我四五年级的那个水平的，但是他还是选择了硬顶上来！他拿出课本让我逐句的翻译对话，我还大概记得那对话的内容：

　　A：what's this?

　　B: it's a pen.

　　A: what's that?

　　B: it's a pencile.

　　A: and what's this?

　　B: it's a pencilebox.

　　A: can you spell it ?

　　B: yes.p-e-n-c-i-l-e-b-o-x,pencilebox.

　　A: thank you.

　　B: your welcome.

　　熟悉吧？后来还有很多学者指责我国小学英语教材的落俗套，以致学生跟人对话只会说“what's this” “How are you? fine, thank you. and you?” 之类的，这些我们都暂且不谈。就说我那段时间是怎么被老爸蹂躏的吧。。。

　　当时有好多的对话内容我翻译不出来，于是就被无情的鄙视了，并且死规定，以后每天晚上都要默写课文、单词！我那时是真怕他呀，为了应付这一关我 是想出了一堆的作蔽手段，小抄、写手上、写桌面上。。。都用过了，每天像过堂一样的接受蹂躏，给我幼小的心灵带来沉重的压力，就这么坚持了有多半年。于 是，后面的事情你们都猜到了，我的英语成绩上来了，随便找出来一篇课文来我都能熟悉的背出来，得到了来自各方面的肯定和鼓励，回头想想，这都是对心理体验 非常好的正能量，直到今天，我都能对英语有信心。从这件事里我总结出一个关键词：“折腾”。

　　2、高考的经历。对于都经历过高考的人们，这个艰辛的过程我就不再多多描绘了，地球人都知道的。我在这想说的是，在这个备考的过程中对我进步影 响最大的一个方面，这也是我高考制胜的法宝。那时我有幸和一名来自山东的转校生(也叫高考移民)同桌，他是我高中时期最好的朋友之一，就是他的学习习惯深 深的影响了我，他后来考上了中国公安大学，现在是国家保密机构的人员了，国家机密不多说。他有一个什么习惯呢？做笔记！

　　你看到这可能在笑，“原来就是作笔记啊，这谁不知道，谁不作笔记啊”，没错，我们从小都会要求作笔记，有时候我们也会假意的去作一些笔记，但很多的时候是东记一笔，西记一笔，记完就忘了，也找不见了。我说的记笔记不是这种情况。

　　在高考那个大环境下，每天我们都会被大量的习题淹没，多的时候每天要做十几张卷子，那时真是麻木了。我的这个朋友就习惯把每次做完的试卷都从头 到尾做个总结，把自己不知道的盲点记在一个本子上，随时翻看。我尝试了这个学习方法后，收效非常大，通过自己的实践也对做笔记有了更深的理解，下面说说我 的理解：

　　（1）做笔记一定要找个厚点的本子，品质要好，但不要过于花哨的，简约的最好。因为你要能预见，当你养成这个好习惯以后，你遇到什么新的东西都 想往上面记几笔，如果页数太少了，你又要换个新本，这样就会对你的知识系统产生分隔，你会更偏向于经常翻看新的本子，旧的本子就被你束之高阁起来了，渐渐 那些你曾经领悟的东西又会变的模糊。

　　（2）请勿分门别类的记笔记。拿高考这几门课举例，那时我有很多同学的作法是数学一个本，语文一个本，英语一个本，化学一个本。。。基本上是一 门课一个笔记本，分门别类，互不干扰。这样并不是最佳的解决方案。我们俩当时的做法就是所有的内容都记到一个本子上，不分科，新的内容就直接追加到旧的内 容的后面，形式上也不要记的太整齐，形式可以多样，圈圈点点，勾勾叉叉，这样更容易在你的大脑里形成再深的印象，我称之为“草稿式笔记”，比条理清晰的 “流水式”笔记效果好的多。

　　（3）经常翻看。记笔记其实是对大脑缓存的一个整理，就好比你存在计算机内存里的内容永远是不稳定的，而你一旦写入硬盘，这个安全性就提高了几 个数量级（对于程序员的你，道理不解释）。同样的道理，你今天对一个问题理解了，但不表明你两天后返回来还能理解到那个程度，最好的办法就是把这个你理解 的问题用自己说话的方式记录下来，并且随时翻看。可以说，只要你的这个本子不丢，你就永远能保持对这个问题的新鲜的理解。以至后来，每每月考、期中、期 末、摸底的所有考试中，我都只需要拿出笔记本来从头到尾翻看几遍，不再需要看书和资料了，很大程度上增强了我的信心，因为没有记在本子上的对我来说都是 “常识”了，所有平时的要点都囊括在笔记本里面了。如果你身边有面临高考的考生的话，请推荐给他们，这个方法会在高考中给他们很大的帮助。

　　3、学日语的经历。说来比较幸运，有机会能在大学里系统的学习一门二外。能在大学里学习一门外语确实是很有意义的一件事情，因为我们学习英语的 战线已经有十几年了，但成果不是太显著，而二外作为一门你有选择的有主动性的去学习的一门语言，如果你肯花心思，进步是很快的。我是从大三开始系统学习日 语的，那时刚考完六级，算是完成了阶段性的目标，于是转向日语的学习，恰好赶上学校与某一日企有合作的项目，很幸运的和同专业的几十名同学一起开始学日 语。当时是一个中教讲语法，一个日本外教讲口语，因为学时较紧，所以基本上日语课占用了所有专业课之外的所有课时，一周要上20几个课时的日语。这个过程 持续了一年多。在这一过程中对我来说受益最大的仍然是大量的笔记。“草稿式笔记”又一次发挥了它的神奇效果，我记了两个厚本子，记录了我整个学习语言的过 程，从浅到深，翻翻笔记就能清晰地回忆起自己是怎么一路走过来的。当我有一段时间没有接触日语的时候，如果我想找回一些日语的感觉，我第一选择就是从头到 尾的把笔记本看一遍，一遍看完后我仿佛就回到了以前学习日语时的状态，就像计算机一键还原一样，只有笔记能起到这个作用。

　　P.S. 顺便说明一下我为什么学日语的时候就很少去碰英语的东西。语言这东西学的多了真的是容易混，能精通好几国语言的人真的是值得敬佩，这种敬佩不仅仅是语言学 习本身。学了两年的日语以后，口语之类的都练的比较熟悉，因为有外教环境，所以大家平时聊天沟通都得到了很好的锻炼。但是有一次做英语面试的时候，我发现 了一个很严重的问题，我竟然不能说出一整句表达清楚的英文介绍，每句话都不自觉的往外蹦日语，呵呵，英语的思维完全被日语给抑制住了。于是我发现，这两种 语言冲突了，不过为了更好的学日语我就把英语放下了，直接最近的工作需要才再次捡起来，不过还好，把日语先放一放，英语自然就不受影响了。

　　4、目前的工作。几个月前换工作到了现在这家外企，外企宽松的环境和人性化的制度让我很快喜欢上了这里，于是我抱定决心要在这里稳定下来，干出 一番事业。从第一天入职我就领到了一个印有公司LOGO的笔记本，现在三个月时间吧，这个本子已经基本用完了。在这个本子上不仅有工作上的事 情，meeting，需求讨论，还有大量的读书笔记，内容十分丰富，但都充实的记录了我的每天的轨迹。这本笔记同样比较“草稿”，但我能真正理解它，它就 像我的一部分大脑一样，我现在走到哪里都会带着这个本子，班车上、轻轨上有大量的时间，拿出本子就好像和自己在对话一样，无比的踏实与充实。

　　三、读书要分级

　　古人早就说过“开卷有益”，在信息大爆炸的现代社会里，获取知识和信息的方式变的越来越多元化，网络的兴起让知识变的廉价，理想的说一根网线可 以得到这个地球上你想知道的一切。请大家和我一起思考一个问题，不论是以什么样的形式，游戏也好，电影也好，看新闻，刷微博也好，我们的最终目的到底是想 干什么。我的观点是，所有的这些行为总结起来，终极目的只有一个——获取信息。

　　回想在还没有Internet的时代里，人们主要获取信息的途径就是读书，这是那时的人们能想到的最直接的选择。而今天的我们选择就多了起来， 读书看起来好像是最慢的一种获取知识的方式了。但是，选择多了就一定是好事吗？科学家证实（我也不知道哪个科学家），选择越多效率越差，因为这增加了你决 策的时间和后悔的理由。先说上网吧，很简单的道理，大家都会经常体验到的，如果你想在网上集中做一件事情，往往是很难的，你会受到来自各个方面的干扰，各 种“信息噪声”向你扑面而来，你常常会被另外的“新鲜”信息中断思路，比如QQ右下角讨厌的重大新闻浮动窗。再比如，如果想在电脑上踏下心来看一本PDF 版的技术书也是很难的，开始可能还好，看上十页二十页以后，眼酸，想睡，看过什么没太深的印象，想干别的，效率很差，我就是这种情况，对需要用电脑阅读的 大段的内容都有抵触的情绪。所以我避免用电脑看一些需要系统理解的东西，因为人有一种心理，就是对于我感到过抵触或厌倦的东西都不想再碰，所以我尽量不用 这种方式去触及那些本身应该对我有很大意义的内容，我怕因为一时的不耐烦导致与这些经典失之交臂。 我的习惯做法还是去阅读实体的书，这给人的感觉是完全不一样的，书的厚度是你可以真切感觉到的，而且，看实体书更容易深入内容，这可能因为人类一直以来的 习惯都是以书为载体来学习，这促成了人脑的进化，人脑也更习惯这种传统的方式。

　　这部分的标题叫“读书要分级”，什么叫分级呢，就是读书的深度。

　　走进任何一家图书馆，你可能都有冲动要把这里的书全部读掉，可是这显然不现实。

　　电视剧《士兵突击》里许三多在团部的知识问答竞赛时，团长问他是怎么知道这么多知识的，许三多说“我这人笨，不知道应该看什么，我就跑到图书 馆，从A开始看，现在才看到D”（大概是这意思，是不是D记不清了）。你说这种人真有吗？有，肯定有，但是这只能是个童话，对于一个现代化的大型图书馆来 说，你就是光把A看完这辈子恐怕也不够用的。所以，面对浩瀚的书海，有选择的读一些经典之作才是明智之举。并不是每一本书对于我们的成长都是至关重要的， 这里有经典，也充斥着垃圾。如果你花了两年读了一堆垃圾书，这样非但无益，反而会害了你。就像老罗曾经说的，他年轻的时候金庸的武侠小说非常火，很多的个 体书商不知名的武侠作者出版的武侠书都署金庸的名，因为那时没有目录嘛，什么“飞雪连天射白鹿， 笑书神侠倚碧鸳”，当时不知道，所以怎么把金庸的书挑出来，很难。

　　那怎么把经典的挑出来呢？这就要借助网络了，豆瓣读书是个不错的地方，这里都是一群爱读书的人，你要看的书在这里基本都能找得到，看过的读者会 留下一些感想，如果评价太烂的话，你就应该果断放弃读这本书的想法，因为这可能会浪费你的时间，并且害了你。扯远了，下面开始分级。

　　第一级：经典中的经典——能奉为经典的著作不多，对于我们计算机这个领域，耳熟能详的经典也就是那一百多本吧，对于读这些书的态度就应该给予足 够的重视，记笔记是必须的，因为这些思想需要与你的思想融合起来，形成你的理解，从而发挥经典的作用，因为大部分经典之所以长盛不衰就是因为它们都是授人 以渔的。

　　第二级：技术类专著——这部分就是指那些资深技术专家，或在某个技术领域比较有建树的行业专家写的书，你选择这些书的目的性更强一些，往往是为 了更深入的了解一种技术或行业而选择的，这部分你当然也要细读，因为技术的难度你更应该用笔记来梳理思路，形成整个技术的框架，这里面应该包括更多的细 节，以助于以后翻阅的时候能理解的更深入。当然，你可以分章节来笔记，这样可以将一个大目标分割成小目标来激励自己去逐项完成。

　　第三级：技术基础类——有一些书目涉及的是你已经熟悉的技术领域但比较基础的内容，这些书的内容对你的技术水平来说比较基础，但你也不要忽视这 样的基础书，这里面可能还有你没有吸收过的精髓也说不定。“温故而知新”，永远不要轻视基础，同样拿出你的本子，翻开新页，标上今天的日期，把这书中讲到 的你意识模糊的内容记到你的本子里吧，可能你会发现，你要记的东西还真是不少呢。

　　第四级：技术周边类——比如《程序员》杂志、技术博客，这一类的资料也不要看过就扔，不要相信你是过目不忘的大师，你大脑的缓存是有限的，你必须要保存到硬盘！所以拿出你的本！

　　第五级：娱乐类——这部分与你的工作没有直接关系，属于你生活的部分，这部分的智慧更多，但是可能会和技术有冲突，所以如果你需要记笔记，请不要记到你记技术和工作的本子上。

　　四、只读经典

　　代码真的能改变世界，当然代码也正在改变着世界。程序员的时间是很宝贵的，我们不是这个星球上最聪明的一类人，但我们绝对是最有智慧的一类人。呱唧呱唧~

　　我们花了大量的时间去做需求，去Design，去Coding，去Testing，留给我们自己的时间却总是那么少，除去日常生活起居的时间， 陪女朋友的时间，上下班的时间，留下读书的时间就没什么了，哦，对，忘了把你打Dota的时间算里了，这还哪有时间看书啊！！？？

　　当程序员的没有不勤奋的，不勤奋的干不了程序员。所以书还是要看的，怎么看，只读经典。

　　关于什么是经典你自己决定咯，在这个圈里吃饭的，对技术都有很强的敏感性，坏书进不了你的眼，好书也一定逃不掉。

　　五、别吝惜你动笔的那点时间

　　说了这么多，你可能已经意识到做笔记的重要性了，其实事实真的是这样。

　　你是否听说过某某大师一生做了几百本的读书笔记这些事，我以前一直有疑惑，他做笔记都是在干嘛呀？都记什么呀，有什么好记的？后来我真正开始做 笔记以后，我才真正理解了这件事，原来大师之所以能成为大师，真的都不是一朝一夕的工夫，这需要持之以恒的坚持和坚定，这内心得多强大呀。你要知道，那几 百本的笔记不只是笔记本那么简单，那些都是思想的沉淀，思想本来是抽象飘渺的，笔记这种形式让思想有了重量和形态，这种思想被组织，重构，索引，最终印到 大脑里形成一座庞大的知识仓库。

　　很惭愧，我们国人没有记笔记的这个好习惯，而与我们相对的日本的整体国民，基本上都有记笔记的这个习惯，这是很可怕的。我的日语老师宫竹老师， 她随身都会带有一个笔记本，随时记录所有她认为应该去记的东西，在很多方面我真的非常敬佩她，比如，我们当时有三个专业的大约二百名学生都上她的课，她能 记住所有这些人的姓名，包括中文的和翻译成日文假名的，还不仅如此，其他不学日语的同学，只要与她做过自我介绍的甚至只有一面之缘的，她下次见面一定能叫 出那人的名字，从没出过错。你以为这是她的记性好吗？绝对不是，这源于她记录的习惯，她不当面去记这些人的名字，但她私下肯定去写进本子里。光写进去就万 事大吉了吗，不回头翻看怎么能记得住？这就是笔记的力量。关于日本人的很多好习惯，希望我以后有机会能发篇博客整体谈一下。

　　正所谓磨刀不误砍柴功，记笔记可能会影响你读一本书的速度，但它不会让你白读，如果你读书的目的不是想在你脑子里留下点什么的话还不如去看电视 剧，读书就是为了长知识长学问长见识，就是为了将别人好的思想吸取过来，转化成自己的思想体系的一部分，当然，你应该有批判接受这些信息的能力，人云亦云 的完全接受也是不合时宜的。

　　我有一个心愿，我渴望能有一天在公交、地铁里看到大家翻看的全是自己的笔记本，而不是一人拿着一个手机在那看微博傻笑！

　　六、再提笔记

     对于《到底怎么样才叫看书——上篇》中所提到的内容，得到了各位博友们的普遍认同我感到很高兴，说实话，从小到大我也就认真做过那几次笔记，但是却都印象深刻，并且对以后的影响也很深远，在走了很多的弯路以后，渐渐才发现这其中的道理来。

     正所谓“学而不思则惘”，学的目的当然不是形式上好看，当然，我们从小受应试教育的影响太深，花了太多的时间和精力去学一些根本用不到的东西，这种“形 式”上的学确实也是没有办法。但庆幸的是我们都挺过来了，大学的教育毕竟也是自己完成的，自主性提高了很多，但仍然有很多的在校大学生不清楚自己以后的方 向是什么，大学四年里都是迷茫的，等到工作了一年两年以后，才突然顿悟——原来我在大学里浪费这么多宝贵的时光！如果你还是在校研究生，你会发现那些工作 几年再回去读研的学生中，学习的自主性和目的性有多强，因为他们已经深深的追悔过那段时光，并且看到了未来努力的方向在哪里。这些道理是一直在学校里的人 很难体会的，一切都是“失去了才会珍惜”。

     读书是一个很费时的过程，一本普通的书300多页很正常，软件类的书里1000多页的大部头著作也很常见。不同于小说是纯叙事性的不需要太多的理解，计 算机的书都是需要用大脑去分析和理解的，所以注定了读这些书的速度都不会很快。比如一本300页的书，你用工作之外的时间一共读了7天，实际上到第七天的 时候，你对第一天和第二天所读过的东西已经印象模糊了，这时你会意识到这点并立即返回来再看一遍第一天和第二天的东西吗？很多人不会的，人只会更乐意往前 看，直到看到最后一页才长嘘一口气，“终于看完了”！ 于是将书放下，即使以后的几天里，书就摆在那你也想不起来再拿起来翻几下。又过了7天，上周读的内容已经完全印象模糊了。又过了一个月，只有书名还能记 得。。。

     所以，我们花了大量的时间读书，却效果不大，读了后面的扔了前面的，一遍一遍在重复同样的过程，整个过程里，唯独让我们理解最深的时候，就是在阅读的那个 过程当中，那一瞬间的我们对大脑的记忆力保持高度的自信，偏执地认为，将来不论哪个时间，我都将理解到这个程度！事实上，恰恰相反，这只是一个短期的记忆 而已，只能维持几天甚至几小时，就像是硬盘一样，你今天删除了一个文件，第二天作数据恢复仍可以找回来，但两个月以后数据恢复就再也找不回来了，因为新的 文件已经覆盖了那个位置，记忆的信息被冲掉了。笔记的作用更像是一块移动硬盘，你可以在你认为这文件有用的时候，把它转移到移动硬盘里，即使本机硬盘上的 文件被冲掉，你也可以随时读取移动硬盘里的内容。

　　你虽然花了时间去读了一本书，但对于这本书可能是你的，也可能不是你的，但如果你对它作了笔记，这本书就百分之百会是你的了。有效读书的过程应该是这样的：

　　读书的目的其实最终目的就是形成自己的理解并长期驻存在大脑中，而笔记这个环节是达到这个最终目的最关键的一步。

　　七、大学课程之授课方法

     大家都经历过大学，我对大学的感悟最大的就是，每一门课学的最明白的时候就是考试之前的那一周。因为有一个考试的期限在那，就逼着自己在那天之前必须得把课本啃完，把内容梳理出来，这大约只需要一周或更少的几天时间，取决于老师哪天通知考试。

    后来我就常常这样想，大学的课程如果是先考试后上课是不是效率会高很多呢？大学生都有很强的自学能力，突击考试的能力都非常强，几天时间把一门从未学过的 课考个及格应该问题都不大，这就造成了大家平时上课不用功，只等考试突击的号角吹响才进入学习状态。 如果先考试呢，给大家定个及格线，不及格的算挂科，那大家就会玩命的自学一遍，把考试过掉，这时已经对课程的内容理解的比较深刻了，接下来再从头到尾上一 遍课，这就很少会出现有学生因为听不懂而不去听的情况了，大家都会变得愿意听课，并且理解会更进一步，皆大欢喜！可惜啊，大学四年那些课程的价值都为应付 考试而大大缩水了。。   

　　八、我是怎么泡图书馆的

　　上大学时看到有人说过一句话，“在学校要好好利用图书馆的资源，等你工作以后哪有这么大的图书馆给你用啊！”当时对这句话的印象很深刻，但遗憾 的是，那时并不会泡图书馆，也没有那么深得意识到图书馆的资源是多么得难能可贵。很多真相都是工作以后才后知后觉的，这其实说明了一个道理，人的认知永远 都是只局限于眼前，几年以后回头想想以前的想法只会感到当时是如此幼稚和缺乏思考。

     大家都知道，计算机的书籍一般都比较贵，靠完全买书去提高技术，成本上实在太高。还有一个事实要承认，买来的很多书都想不起来看。在买书时，往往我们都会 有一种冲动，并且有一种心理在作祟——我得到了这本书，就学到了这门技术! 于是，在这样的冲动之下，花了很多冤枉钱买了很多书成了摆设，而技术却没有半点长进。

     所以关于买书，我有两点心得和大家分享：

     1、能不买就不买。 这不是说鼓励大家不读书，反而是为了更有效的读书。古人早就给我们总结了“书非借不能读”，已经是自己的书往往不想读，自认为书就一直在那，我什么时候想 读都能读啊，于是一直没有读。而借来的书，因为有期限要还给人家，你就不得不抽出点时间来把它读完，这样才是真的去读了。并且，如果你是按照上面的流程图 中画的那样作了笔记的话，这本书你虽然形式上是还了，但你却真正的拥有了这本书，永远的拥有了。

     2、三思而后买。 如果这本书你周围借不到，你又想读的话，请在买书之前给自己几天时间的准备。准备什么呢？你应该从各个方面了解一下这书的内容，质量，评价等等，并且能列 出这书非买不可的几个理由，计划一下你拿到这书后的阅读计划等等。为什么要作这些准备呢，这其实是在强化你读书的动机，动机越强你读书的动力越大，效果也 越好，那这本书才不会白读，更不会白买。我给自己的硬性规定是，从我有买书想法的那天起，往后推一周的时间，如果我还是很想买，那就毫不犹豫的出手了！

     3、买了书赶紧看。当你拿到一本新书的时候，这时是你对这本书兴趣最大的时候，也是最冲动的时候，这时候应该尽量的拿出一大块的时间来把这本书一口气看 完，这样能最大程度的激活这本书的价值，而如果一旦搁置下来，下次再翻开它就不一定是什么时候了。“一鼓作气，再而衰，三而竭”，读书也是同样的道 理。    

　　对我们程序员来说，图书馆仍然是最好的资源，不但全面而且免费，还能制定一个期限督促自己完成学习，一举N得。我是爱泡图书馆的，而且经常是从 早泡到晚上关门，有时是看图书馆的书，有时候也只是看自己的书，因为图书馆里环境最能让人心静下来，学习看书的效率都很高。不过，我也常常碰到很多过来看 书但是明显是瞎看的读者，这很大程度上还是在浪费时间。举几例：

　　1、没有看书的重点，从书架上一取就是五六本，甚至十几本，这时的心理好像是“我拿的多，看的多，学的多，知道的就多”，其实这是完全自欺欺人 的。《上篇》中提到了，一个现代化的图书馆里，你是不可能把每本书都看过来的，你的生命太有限了。像这些取书的人，最后只能是翻翻这个，再翻翻那个，每一 本书都不会看超过五分钟，最后原原本本又抱回来了，白白浪费了生命中的几十分钟，却还感到莫名的充实。。。。 我的方式是只取一本，并且这一本一定是我之前在豆瓣上查看过相关评论的，我认为这本书值得去读才去拿来读的，并且，如果这本书真的是好书，是一定要一口气 看完的，绝不中途去抓另一本书来看，这会严重的影响理解的连续性。

　　2、小情侣一起来看书的，完全是浪费时间，并且也影响他人。因为两个人一起来的就会有一种“说话有底气”的心理，所以坐在那就会不自觉的聊天说 话，而不顾周围人的感受，这样的读者我也很不喜欢。所以如果你想带女朋友一起去泡图书馆，请一定要注意别人的感受，那里不是打情骂俏的地方，你去了目的就 是学习，如果有必要可以和女朋友商量分开学习，这样两个人都能充分的利用好在图书馆的那点时间看点东西。

　　3、到图书馆来玩手机的。这部分人很多，抱一堆书过去，然后拿出手机来上网发短信听歌的，也许是把书当成了一种心理安慰。这种人也是不应该出现在图书馆的。 

　　这其实就是一个动机的问题，动机不纯永远也不可能做到专注。当然，也不能要求人人都有这种专注的性格，也许人家就是来休闲消遣的，没有太多的想 法，这也没错。 对于我来说，因为图书馆离住处不是很近，需要花一定的时间成本到达那个地方，所以，我会对在那的每一分钟都比较珍惜，都是自己选择的嘛， 总得为自己负点责嘛，所以我一般会将手机关机，并且一直坐到图书馆关门才收拾东西往回走。

　　最后，《到底怎么样才叫看书》的两篇总算写完了，谢谢各位的支持！对文中偏颇的地方，纯属个人见解，请大家批判接受。

　　2、一件事交给我我应付一下，很容易应付，应付完了之后不觉得是在浪费生命吗？一件事你可以把它做到 60 分，你可以做的很轻松，做完了你每天重复每天干三个小时活就完了，然后你天天上班没事，然后你回家三十亩地一头牛老婆孩子热炕头，但你怎么进步呢？人的进 步离开了学校之后，学习不再是上课也不是读书，通过你在工作中通过你做事情做项目积累自己的经验，跟很多人打交道。因为我有不服输的性格，再普通的事我要 做的比别人好，大家做的很普通我要做的跟大家不一样，要做到超出大家想象要花很多时间很多努力，但我最后发现我的收获最大的，因为我下了功夫，你的收获和 你的投入是成正比的。

　　3、如果你混日子，对不起，实际上你是混自己，在很多大的公司混的很多，你能黑老板多少钱吗？你一年年薪 10 万，中低层收入你在单位混 10 年也就混老板 100 万，对很多公司来说有人混我 100 万对公司伤害不了哪去，可是你十年不好好工作，荒废了十年，十年可能突然有一天公司倒闭了，或者发现你这个混混把你开掉了，你怎么办呢？你觉得你有竞争力 吗？这个社会除非你有一个好爸爸，或者你有一个家族，这个不在咱们考虑之列，这不是我的哲学。

　　4、你只要是白手打天下，你最后发现在社会上，这个社会越来越公正，我认为机会还是很多，你不要天天去愤青，去骂别人，至少有了互联网有了 IT，你看丁磊、马化腾、李彦宏都是平头百姓，他们在这个行业能成功，说明什么？说明只要你努力你也有机会成功，百度、谷歌还有 QQ 的很多员工，我们不提李彦宏，不提大佬们。他们公司很多员工参与这件事也很成功，有很多在北京买车、买房有成就感，这些东西靠什么？还是靠你能力的积累。

　　5、我觉得在公司，真不喜欢这个公司，不喜欢老板，赶快辞职，一分钟也别见到他，我就这个风格。何必为了老板的错误耗费自己的生命，如果你今天 决定你又不离开在公司做工作，我觉得你应该把工作做好。有人说有几种问题，我有个性我不爱干这个，我说大哥，个性是成功人士的专利，你成功你当然觉得有个 性，别人看着你，你没有成功之前个性能换房子吗？如果个性能换房子，我比你有个性，我们全家有个性，但它换不了一个房子。

在Linux中，没有文件创建时间的概念。只有文件的访问时间、修改时间、状态改变时间。也就是说不能知道文件的创建时间。但如果文件创建后就没有 修改过，修改时间=创建时间;如果文件创建后，状态就没有改变过，那么状态改变时间=创建时间;如果文件创建后，没有被读取过，那么访问时间=创建时间， 这个基本不太可能。

与文件相关的几个时间：

1、访问时间，读一次这个文件的内容，这个时间就会更新。比如对这个文件使用more命令。ls、stat命令都不会修改文件的访问时间。

2、修改时间，对文件内容修改一次，这个时间就会更新。比如：vi后保存文件。ls -l列出的时间就是这个时间。

3、状态改变时间。通过chmod命令更改一次文件属性，这个时间就会更新。查看文件的详细的状态、准确的修改时间等，可以通过stat命令 文件名。

比如： [jing@zhjh c]$ stat temp.c

引用:

File: 'temp.c'

Size: 66 Blocks: 8 IO Block: 4096 u4e00u822cu6587u4ef6

Device: 807h/2055d Inode: 1191481 Links: 1

Access: (0664/-rw-rw-r--) Uid: ( 500/ jing) Gid: ( 500/ jing)

Access: 2008-03-12 20:19:45.000000000 0800

Modify: 2008-03-12 20:19:45.000000000 0800

Change: 2008-03-12 20:19:45.000000000 0800

说明：Access访问时间。Modify修改时间。Change状态改变时间。可以stat *查看这个目录所有文件的状态。