BlogJava-ZT文萃-随笔分类-中间件

谈谈hashCode

ZT文萃 — Sat, 03 May 2014 22:23:00 GMT

下文转帖自：

http://www.cnblogs.com/chenssy/p/3651218.html

版权归作者所有。

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 set = new HashSet();          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方法运行流程完全符合他们两者之间的处理流程。

ZT文萃 2014-05-04 06:23 发表评论

转帖：Java邮件开发-----电子邮件的基本概念介绍

ZT文萃 — Sat, 03 May 2014 22:19:00 GMT

下文来自：

http://www.cnblogs.com/chenssy/archive/2012/12/09/2809874.html

版权归作者所有。

电子邮件用于网上的信心传递和交流，它是最重要的Internet服务之一。据统计Internet有30%的业务是电子邮件有关的。同时我们也不可否认它在我们的日常生活、工作办公方面扮演着很重要的角色。譬如：许多办公自动化项目(OA)中都要附带发送邮件的功能，如果还要使用OutLook等手工方式就不适合，在这个高速的时代，我们需要提供工作效率，让工作能够自动化。同时在许多网站中也都需要附带发送邮件的功能：给新注册的用户发送一封包含其注册信息的欢迎E-Mail、将网站的最新活动信息通过E-Mail发送给所有的注册会员等等。

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

电子邮件系统

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

邮件服务器

邮件服务器是一种用来负责电子邮件收发管理的设备。在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则能够然该用户了解到服务器上存储邮件的情况，已下载的邮件仍然滞留在服务器中，以便于实现邮件归档和共享。

ZT文萃 2014-05-04 06:19 发表评论

转帖：渐析java的浅拷贝和深拷贝

ZT文萃 — Sat, 03 May 2014 22:15:00 GMT

转载自：

http://www.cnblogs.com/chenssy/p/3308489.html

版权归作者所有。

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

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

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

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

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

存在一个对象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);

New Asian(a1)执行Asian类的拷贝构造方法，由于对象赋值是引用赋值。使得a1和a2引用同一个对象

如下图：

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

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

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

如下图：

ZT文萃 2014-05-04 06:15 发表评论

转帖：再解Java中的String

ZT文萃 — Sat, 03 May 2014 22:10:00 GMT

转帖：

http://www.cnblogs.com/chenssy/p/3695271.html

版权归作者所有。

今天朋友问我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");

创建了几个String对象？？

ZT文萃 2014-05-04 06:10 发表评论

Class的getResource方法

ZT文萃 — Fri, 02 May 2014 07:48:00 GMT

Class的getResource方法，实际上是靠调入这个类的ClassLoader的getResource方法来实现的，如果调入这个类的ClassLoader是原生的BootStrap ClassLoader，这个ClassLoader是用C++写成的，在Java中没有相对应的物件。这时候的实现靠的是ClassLoader的静态方法getSystemResource。

只有当使用Class类的getResource方法的时候，才会有下面介绍的那种算法。

这种算法就是说，如果你指定的路径以/开头，那么就是从ClassPath的起点开始寻找这个路径。如果直接以某个名字开头，那么就是从当前包名的目录为起点开始寻找。
所以大家如果用过hibernate就知道，有些表示类到数据库表的映射关系的xml文件就和这个类的class文件放在一起，这样它就直接使用这个类.class.getResource方法来得到这个xml文件。

而在使用ClassLoader的getResource方法的时候，永远是以Classpath为直接起点开始寻找资源的。不用担心从什么包开始寻找的问题。

用Class.getResource不加/就是从当前包开始找，用ClassLoader.getResource不加/就是直接从Classpath的起点开始寻找。

当然，如果觉得麻烦，你定位资源的时候全部都使用/开头的方式就好了

ZT文萃 2014-05-02 15:48 发表评论

Class.getResource()

ZT文萃 — Fri, 02 May 2014 07:34:00 GMT

查找带有给定名称的资源,查找给定类相关的资源的规则是通过定义类的 class loader 实现的。此方法委托给此对象的类加载器。如果此对象通过引导类加载器加载，则此方法将委托给 ClassLoader.getSystemResource(java.lang.String)。

在委托前，使用下面的算法从给定的资源名构造一个绝对资源名：

如果 name 以 '/' 开始，则绝对资源名是 '/' 后面的 name 的一部分。
否则，绝对名具有以下形式：
```
   modified_package_name/name 
```
其中 modified_package_name 是此对象的包名，该名用 '/' 取代了 '.' ('\u002e')。

Class.getResource(""); 获取classpath

Class.getResource("JMF.class"); 代表获取相于类路径当前包下的SendService.class的类路径.

/D:/bak/upload/upload/WebRoot/WEB-INF/classes/jmf/JMF.class-------->打印出的结果

Class.getResource("/jmf/WebCamSwing.class"); /jmf/WebCamSwing.class->代表相于类路径的绝对路径

file:/D:/bak/upload/upload/WebRoot/WEB-INF/classes/jmf/JMF.class -------->打印出的结果

我们怎么获得Object的类路径:

Class.getResource("/java/lang/Object.class") 因为Object是通过引导类加载器 (BootStrapClassLoader)加载的,所以此方法通过系统类加载器来查找资料, 所以我们要指定类的绝对路径/java/lang /Object.class

public java.net.URL getResource(String name) {
        name = resolveName(name);
        ClassLoader cl = getClassLoader0();
        if (cl==null) {
            // A system class.
            return ClassLoader.getSystemResource(name);
        }
        return cl.getResource(name);
    }

我们来看看如何通过系统类加载器来查找Object:

Class.getClassLoader().getSystemResource("java/lang/Object.class")

打印出来的结果多是:

jar:file:/E:/Program/Java/jdk1.5.0_15/jre/lib/rt.jar!/java/lang/Object.class

为什么getResource("")前面要加"/",而getSystemResource("")前面不用加呢?

private String resolveName(String name) {
        if (name == null) {
            return name;
        }
        if (!name.startsWith("/")) {
            Class c = this;
            while (c.isArray()) {
                c = c.getComponentType();
            }
            String baseName = c.getName();
            int index = baseName.lastIndexOf('.');
            if (index != -1) {
                name = baseName.substring(0, index).replace('.', '/')
                    +"/"+name;
            }
        } else {
            name = name.substring(1);
        }
        return name;
    }

其实最后还是要把"/"去掉的...

ZT文萃 2014-05-02 15:34 发表评论

Apache Common HttpClient使用之七种武器

ZT文萃 — Wed, 26 Feb 2014 10:10:00 GMT

http://laohuang.iteye.com/blog/55613

1.拳头之Get/Post
拳头是最基本的一重武器，也是最重要的，好比练武之人必须先扎稳马步。

java 代码

HttpClient httpclient=new HttpClient();//创建一个客户端，类似打开一个浏览器
GetMethod getMethod=new GetMethod("http://www.blablabla.com");//创建一个get方法，类似在浏览器地址栏中输入一个地址
int statusCode=httpclient.executeMethod(getMethod);//回车——出拳！
System.out.println("response=" + getMethod.getResponseBodyAsString());//察看拳头命中情况，可以获得的东西还有很多，比如head, cookies等等
getMethod.releaseConnection();//释放，记得收拳哦

2.孔雀翎之支持https

如何支持https?

java 代码

static{
Protocol easyhttps = new Protocol("https", new EasySSLProtocolSocketFactory(), 443);
Protocol.registerProtocol("https", easyhttps);
}

在执行具体的http method之前，暗中将https协议注册一把，如孔雀翎暗藏玄机，毙敌于无形。记住，官方的binary发行版本没有ssl的contribute包，方法一是下载源代码版本来打造你的孔雀翎。

3.多情环之cookies
常道人老多情，其实是记忆太多，所以情之所至，正如cookies甜心，无论你走到那，总把你牵挂：

java 代码

HttpClient httpclient=new HttpClient();
httpclient.getParams().setCookiePolicy(CookiePolicy.RFC_2109);//RFC_2109是支持较普遍的一个，还有其他cookie协议
HttpState initialState = new HttpState();
Cookie cookie=new Cookie();
cookie.setDomain("www.balblabla.com");
cookie.setPath("/");
cookie.setName("多情环");
cookie.setValue("多情即无情");
initialState.addCookie(cookie);
httpclient.setState(initialState);
...

4.离别钩之解构cookies
多情环的反面即离别钩，钩出，敌之身体某个部件即要与身体别离，端的是无情：

java 代码

...//执行了某些get/post方法后
Cookie[] cookies = httpclient.getState().getCookies();
System.out.println("Present cookies: ");
for (int i = 0; i < cookies.length; i++) {//循环结构零部件
System.out.println(" - " + cookies[i].toExternalForm());
System.out.println(" - domain=" + cookies[i].getDomain());
System.out.println(" - path=" + cookies[i].getPath());
...
}

5.霸王抢之post参数
枪，长兵器之王，诸多名将均使一杆或金或银命名的名枪，比如岳飞。post方法在提交参数对时,犹如灵蛇出洞：

java 代码

PostMethod postMethod = new PostMethod("http://www.saybot.com/postme");
NameValuePair[] postData = new NameValuePair[2];
postData[0] = new NameValuePair("武器", "枪");
postData[1] = new NameValuePair("什么枪", "神枪");
postMethod.addParameters(postData);
...//出枪吧

6.七星碧玉刀之支持代理(proxy)
代理，非常重要，尤其在局域网横行的年头，没有代理，你在公司上不了QQ，没有代理，google不了网页快照，代理之威，可比七星碧玉刀，无刀，在局域网和开发当中，一切白搭：

java 代码

HttpClient httpclient=new HttpClient();
httpClient.getHostConfiguration().setProxy("192.168.0.1", 9527);
httpClient.getParams().setAuthenticationPreemptive(true);//重要！！！告诉httpclient，使用抢先认证，否则你会收到“你没有资格”的恶果
/*
这一步也至关重要，MyProxyCredentialsProvider实现了org.apache.commons.httpclient.auth.CredentialsProvider接口，
返回代理的credential(username/password)*/
httpClient.getParams().setParameter(CredentialsProvider.PROVIDER, new MyProxyCredentialsProvider());
httpClient.getState().setProxyCredentials(
new AuthScope("192.168.0.1",
AuthScope.ANY_PORT, //任意端口哦，可要小心
AuthScope.ANY_REALM),//任意域哦，可要小心
new UsernamePasswordCredentials("username",//proxy的用户名
"password"));//proxy的密码

...

7.长生剑之天下第一
看httpclient的官方文档：jakarta.apache.org/commons/httpclient/userguide.html
看Hilton网友写的小葵花宝典笔记：www.cnjm.net/tech/article1155.html
通读后，你会有种拔剑四顾心茫然的高手感觉。

七种武器，打完收工！

ZT文萃 2014-02-26 18:10 发表评论

httpclient的一些学习心得

ZT文萃 — Wed, 26 Feb 2014 10:08:00 GMT

转载自：

http://wallimn.iteye.com/blog/540566

最近忙于一个项目，了解下httpclient，在这里总结出来，和大家一起学习分享，希望各位朋友提出宝贵的意见。

首先介绍一下项目的背景：
目标：把国内一家保险公司的“ＷＥＢ一账通”改成“ＷＡＰ一账通”。
资源：客户不提供任何的webservice接口。

本项目中用到的第三方组件是apache的httpclient，一个非常强大的网页抓取工具（抓这个字用得可能不太好），　这里和大家
一起讨论下httpclient的一些常用用法和要注意的地方。

本文引用的资源列表：

httpclient入门： http://www.ibm.com/developerworks/cn/opensource/os-httpclient/
httpclient证书导入：http://www.blogjava.net/happytian/archive/2006/12/22/89447.html
httpclient高级认识：http://laohuang.iteye.com/blog/55613
httpclient官方文档：http://hc.apache.org/httpcomponents-client/index.html
httpclient资源关闭：http://www.iteye.com/topic/234759

上面的文章写得很好，看完之后也就知道怎么用httpclient这个很好的工具了，但是在这里还是补充一些比较重要的东西，也是项目中经
常碰到的问题。

首先要注意的有以下几点：
1、httpclient连接后资源释放问题很重要，就跟我们用database connection要释放资源一样。
2、https网站采用ssl加密传输，证书导入要注意。
3、做这样的项目最好先了解下http协义，比如302,301,200,404返回代码的含义（这是最基本的）,cookie,session的机制。
4、httpclient的redirect状态默认是自动的，这在很大程度上给开发者很大的方便（如一些授权获得cookie），但是有时要手动管理下，比如
　　有时会遇到CircularRedirectException异常，出现这样的情况是因为返回的头文件中location值指向之前重复(端口号可以不同)地址，导致可能会出现死
循环递归重定向，这时可以手动关闭:method.setFollowRedirects(false)
5、有的网站会先判别用户的请求是否是来自浏览器，如不是，则返回不正确的文本，所以用httpclient抓取信息时在头部加入如下信息：
header.put("User-Agent", "Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1; SV1; QQDownload 1.7; .NET CLR 1.1.4322; CIBA; .NET CLR 2.0.50727)");
6、当post请求提交数据时要改变默认编码，不然的话提交上去的数据会出现乱码。重写postMethod的setContentCharSet()方法就可以了：

下面写一个通用类来处理request请求返回的文本:

Java代码

/*
* HttpRequestProxy.java
*
* Created on November 3, 2008, 9:53 AM
*/
package cn.com.mozat.net;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
import org.apache.commons.httpclient.Header;
import org.apache.commons.httpclient.HttpClient;
import org.apache.commons.httpclient.HttpException;
import org.apache.commons.httpclient.HttpMethod;
import org.apache.commons.httpclient.NameValuePair;
import org.apache.commons.httpclient.SimpleHttpConnectionManager;
import org.apache.commons.httpclient.methods.GetMethod;
import org.apache.commons.httpclient.methods.PostMethod;
import cn.com.mozat.exception.CustomException;
/**
*
* @author bird email:lihongfu-84@163.com
*
* 2008-11-4 09:49:48
*/
public class HttpRequestProxy{
//超时间隔
private static int connectTimeOut = 60000;
//让connectionmanager管理httpclientconnection时是否关闭连接
private static boolean alwaysClose = false;
//返回数据编码格式
private String encoding = "UTF-8";
private final HttpClient client = new HttpClient(new SimpleHttpConnectionManager(alwaysClose));
public HttpClient getHttpClient(){
return client;
}
/**
* 用法：
* HttpRequestProxy hrp = new HttpRequestProxy();
* hrp.doRequest("http://www.163.com",null,null,"gbk");
*
* @param url 请求的资源ＵＲＬ
* @param postData POST请求时form表单封装的数据没有时传null
* @param header request请求时附带的头信息(header) 没有时传null
* @param encoding response返回的信息编码格式没有时传null
* @return response返回的文本数据
* @throws CustomException
*/
public String doRequest(String url,Map postData,Map header,String encoding) throws CustomException{
String responseString = null;
//头部请求信息
Header[] headers = null;
if(header != null){
Set entrySet = header.entrySet();
int dataLength = entrySet.size();
headers= new Header[dataLength];
int i = 0;
for(Iterator itor = entrySet.iterator();itor.hasNext();){
Map.Entry entry = (Map.Entry)itor.next();
headers[i++] = new Header(entry.getKey().toString(),entry.getValue().toString());
}
}
//post方式
if(postData!=null){
PostMethod postRequest = new PostMethod(url.trim());
if(headers != null){
for(int i = 0;i < headers.length;i++){
postRequest.setRequestHeader(headers[i]);
}
}
Set entrySet = postData.entrySet();
int dataLength = entrySet.size();
NameValuePair[] params = new NameValuePair[dataLength];
int i = 0;
for(Iterator itor = entrySet.iterator();itor.hasNext();){
Map.Entry entry = (Map.Entry)itor.next();
params[i++] = new NameValuePair(entry.getKey().toString(),entry.getValue().toString());
}
postRequest.setRequestBody(params);
try {
responseString = this.executeMethod(postRequest,encoding);
} catch (CustomException e) {
throw e;
} finally{
postRequest.releaseConnection();
}
}
//get方式
if(postData == null){
GetMethod getRequest = new GetMethod(url.trim());
if(headers != null){
for(int i = 0;i < headers.length;i++){
getRequest.setRequestHeader(headers[i]);
}
}
try {
responseString = this.executeMethod(getRequest,encoding);
} catch (CustomException e) {
e.printStackTrace();
throw e;
}finally{
getRequest.releaseConnection();
}
}
return responseString;
}
private String executeMethod(HttpMethod request, String encoding) throws CustomException{
String responseContent = null;
InputStream responseStream = null;
BufferedReader rd = null;
try {
this.getHttpClient().executeMethod(request);
if(encoding != null){
responseStream = request.getResponseBodyAsStream();
rd = new BufferedReader(new InputStreamReader(responseStream,
encoding));
String tempLine = rd.readLine();
StringBuffer tempStr = new StringBuffer();
String crlf=System.getProperty("line.separator");
while (tempLine != null)
{
tempStr.append(tempLine);
tempStr.append(crlf);
tempLine = rd.readLine();
}
responseContent = tempStr.toString();
}else
responseContent = request.getResponseBodyAsString();
Header locationHeader = request.getResponseHeader("location");
//返回代码为302,301时，表示页面己经重定向，则重新请求location的url，这在
//一些登录授权取cookie时很重要
if (locationHeader != null) {
String redirectUrl = locationHeader.getValue();
this.doRequest(redirectUrl, null, null,null);
}
} catch (HttpException e) {
throw new CustomException(e.getMessage());
} catch (IOException e) {
throw new CustomException(e.getMessage());
} finally{
if(rd != null)
try {
rd.close();
} catch (IOException e) {
throw new CustomException(e.getMessage());
}
if(responseStream != null)
try {
responseStream.close();
} catch (IOException e) {
throw new CustomException(e.getMessage());
}
}
return responseContent;
}
/**
* 特殊请求数据,这样的请求往往会出现redirect本身而出现递归死循环重定向
* 所以单独写成一个请求方法
* 比如现在请求的url为：http://localhost:8080/demo/index.jsp
* 返回代码为302 头部信息中location值为:http://localhost:8083/demo/index.jsp
* 这时httpclient认为进入递归死循环重定向，抛出CircularRedirectException异常
* @param url
* @return
* @throws CustomException
*/
public String doSpecialRequest(String url,int count,String encoding) throws CustomException{
String str = null;
InputStream responseStream = null;
BufferedReader rd = null;
GetMethod getRequest = new GetMethod(url);
//关闭httpclient自动重定向动能
getRequest.setFollowRedirects(false);
try {
this.client.executeMethod(getRequest);
Header header = getRequest.getResponseHeader("location");
if(header!= null){
//请求重定向后的ＵＲＬ，count同时加1
this.doSpecialRequest(header.getValue(),count+1, encoding);
}
//这里用count作为标志位，当count为0时才返回请求的ＵＲＬ文本,
//这样就可以忽略所有的递归重定向时返回文本流操作，提高性能
if(count == 0){
getRequest = new GetMethod(url);
getRequest.setFollowRedirects(false);
this.client.executeMethod(getRequest);
responseStream = getRequest.getResponseBodyAsStream();
rd = new BufferedReader(new InputStreamReader(responseStream,
encoding));
String tempLine = rd.readLine();
StringBuffer tempStr = new StringBuffer();
String crlf=System.getProperty("line.separator");
while (tempLine != null)
{
tempStr.append(tempLine);
tempStr.append(crlf);
tempLine = rd.readLine();
}
str = tempStr.toString();
}
} catch (HttpException e) {
throw new CustomException(e.getMessage());
} catch (IOException e) {
throw new CustomException(e.getMessage());
} finally{
getRequest.releaseConnection();
if(rd !=null)
try {
rd.close();
} catch (IOException e) {
throw new CustomException(e.getMessage());
}
if(responseStream !=null)
try {
responseStream.close();
} catch (IOException e) {
throw new CustomException(e.getMessage());
}
}
return str;
}
public static void main(String[] args) throws Exception{
HttpRequestProxy hrp = new HttpRequestProxy();
Map header = new HashMap();
header.put("User-Agent", "Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1; SV1; QQDownload 1.7; .NET CLR 1.1.4322; CIBA; .NET CLR 2.0.50727)");
String str = hrp.doRequest(
"http://www.cma-cgm.com/en/eBusiness/Tracking/Default.aspx?BolNumber=GZ2108827",
null, header,null);
System.out.println(str.contains("row_CRXU1587647"));
// System.out.println(str);
}
}

ZT文萃 2014-02-26 18:08 发表评论

Java程序运行时间的计算

ZT文萃 — Fri, 14 Feb 2014 01:51:00 GMT

http://blog.163.com/kevinlee_2010/blog/static/16982082020112710557998/

第一种是以毫秒为单位计算的。

　　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");

ZT文萃 2014-02-14 09:51 发表评论

java中计算两个时间差

ZT文萃 — Fri, 14 Feb 2014 01:49:00 GMT

http://china.gmail.cn/html/38/63638-41467.html

javaz中对日期时间的处理比较多，代码中列出了3中日期时间计算差值的方法。

比如：现在是2004-03-26 13：31：40
过去是：2004-01-02 11：30：24
我现在要获得两个日期差，差的形式为：XX天XX小时XX分XX秒

java计算时间差及比较时间大小
比如：现在是2004-03-26 13：31：40
过去是：2004-01-02 11：30：24
我现在要获得两个日期差，差的形式为：XX天XX小时XX分XX秒

方法一：
DateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

try
{
Date d1 = df.parse("2004-03-26 13:31:40");
Date d2 = df.parse("2004-01-02 11:30:24");
long diff = d1.getTime() - d2.getTime();
long days = diff / (1000 * 60 * 60 * 24);
}
catch (Exception e)
{
}

方法二： SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
java.util.Date now = df.parse("2004-03-26 13:31:40");
java.util.Date date=df.parse("2004-01-02 11:30:24");
long l=now.getTime()-date.getTime();
long day=l/(24*60*60*1000);
long hour=(l/(60*60*1000)-day*24);
long min=((l/(60*1000))-day*24*60-hour*60);
long s=(l/1000-day*24*60*60-hour*60*60-min*60);
System.out.println(""+day+"天"+hour+"小时"+min+"分"+s+"秒");

方法三：
SimpleDateFormat dfs = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
java.util.Date begin=dfs.parse("2004-01-02 11:30:24");
java.util.Date end = dfs.parse("2004-03-26 13:31:40");
long between=(end.getTime()-begin.getTime())/1000;//除以1000是为了转换成秒

long day1=between/(24*3600);
long hour1=between%(24*3600)/3600;
long minute1=between%3600/60;
long second1=between%60/60;
System.out.println(""+day1+"天"+hour1+"小时"+minute1+"分"+second1+"秒");

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

java 比较时间大小

String s1="2008-01-25 09:12:09";
String s2="2008-01-29 09:12:11";
java.text.DateFormat df=new java.text.SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
java.util.Calendar c1=java.util.Calendar.getInstance();
java.util.Calendar c2=java.util.Calendar.getInstance();
try
{
c1.setTime(df.parse(s1));
c2.setTime(df.parse(s2));
}catch(java.text.ParseException e){
System.err.println("格式不正确");
}
int result=c1.compareTo(c2);
if(result==0)
System.out.println("c1相等c2");
else if(result<0)
System.out.println("c1小于c2");
else
System.out.println("c1大于c2");

ZT文萃 2014-02-14 09:49 发表评论

在 Liberty 集群中共享内存网格数据

ZT文萃 — Mon, 20 Jan 2014 04:59:00 GMT

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

介绍

WebSphere Liberty Profile Server 介绍

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

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

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

图 2. Liberty 安装界面

安装 WebSphere eXtreme Scale

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

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

图 3. WebSphere eXtreme Scale 安装界面

创建 Liberty 服务器

进入 Liberty 安装目录下的 bin 文件夹
执行服务器创建命令 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 添加示例

                    jsp-2.2          localConnector-1.0          eXtremeScale.web-1.0          eXtremeScale.server-1.0

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

清单 2. HTTP 端口修改示例

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

清单 3. XS Server 配置示例

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

deployment.xml 文件代码如下：

清单 4. deployment.xml 示例

清单 5. objectgrid.xml 示例

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

清单 6. httpSession 重用设定示例

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"%>                  在 Liberty 集群中共享内存网格数据           在 Liberty 集群中共享内存网格数据测试页面 !
   <%   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);   %>    计数器会在每次页面加载时加 1
    计数器  = <%=count%>
    页面服务器 :   <%= System.getProperty("wlp.server.name") %>
   
  页面生成时间 = <%=new java.util.Date().toString()%>

将 testApp 分别部署到 Test002 和 Test003，

图 7. 测试程序部署界面

启动 Test001 ，Test002 和 Test003 服务器

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

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

配置 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 代码示例

将合并后的 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 计数器增加界面

参考资料

ZT文萃 2014-01-20 12:59 发表评论

websphere liberty 装配部署

ZT文萃 — Fri, 17 Jan 2014 06:19:00 GMT

websphere liberty 安装部署

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文件并打开,加入””即可完成部署,删除这句话即可完成卸载，即便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

ZT文萃 2014-01-17 14:19 发表评论

新一代轻量级应用服务器 — WebSphere Liberty Profile Server 介绍

ZT文萃 — Mon, 13 Jan 2014 03:11:00 GMT

http://www.ibm.com/developerworks/cn/websphere/library/techarticles/1207_zhuxl_liberty/1207_zhuxl_liberty.html

2012 年 6 月 15 日，IBM 正式发布了 WebSphere Application Server V8.5 版本（简称 WAS V8.5）。WebSphere Liberty Profile Server（简称 Liberty）是 WAS V8.5 中最主要的新特性，它是一个基于 OSGi 内核，高模块化，高动态性的轻量级 WebSphere 应用服务器，其安装极为简单（解压即可）、启动非常快、占用很少的磁盘和内存空间，支持 Web、mobile 和 OSGi 应用的开发，旨在提高开发人员的生产效率。

在本文中，我们将详细介绍什么是 Liberty 以及如何使用 Liberty 快速的开发和部署应用，使读者迅速的掌握这一全新的轻量级应用服务器。

0 评论：

朱修磊, 软件工程师, IBM

2012 年 7 月 19 日

内容

什么是 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 文件

                        jsp-2.2

这个 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 服务器可以利用属性导入共享的配置文件；又比如配置文件的内容非常多而且繁杂，我们就可以将其中的内容分别写在不同的配置文件中（称为不同的配置文件片段），同样利用将这些片段文件导入到主配置文件中，运行时会负责去实时的解析这些片段文件。

应用部署

在 Liberty 中部署应用也是非常简单的事情，打开你的 Liberty 安装目录 \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，实现打印当前时间的功能。步骤如下：

打开 Eclipse，选择 File > New > Web>Dynamic Web Project
设置如下属性值：
1. Project name: Demo
2. Target runtime: WebSphere Application Server V8.5 Liberty Profile
图 14. 创建动态 Web 工程
点击 Next 两次，然后点击 Finish，完成工程的创建。
此时，你可以在左侧的资源导航页面看到刚刚创建完成的 Demo 工程，展开工程就可以看到一些默认创建的资源。
右击 Src 目录，选择 New > Class
设置如下属性值：
1. Package: com.date.demo
2. Name: DateProvider
图 15. 创建 java 文件
点击 Finish

编辑如下代码到 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() 用来获得当前时间。

右击 Src，选择 New > Servlet
设置如下属性值
1. Java package: com.date.demo
2. Class name: DatePrintServlet
图 16. 创建 Servlet 文件
点击 Finish，完成创建。

编辑如下内容到 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   }    }

在左侧导航栏选择 DatePrintServlet，点击右键 Run As > Run on Server , 如下图：
图 17. 选择 Liberty 服务器
点击 Finish，Liberty 开发工具将会为我们部署上面的 Demo 程序，并启动 Liberty 服务器。从 console 的日志里我们可以看到如下描述：

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

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

图 18. Demo 运行页面

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

清单 5. server.xml

                        jsp-2.2          localConnector-1.0

其中：

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

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

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

用来指定和应用本身相关的属性，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 软件下载与技术交流群组，参与在线交流。

ZT文萃 2014-01-13 11:11 发表评论

websphere application server v8.5 liberty profile试用

ZT文萃 — Fri, 10 Jan 2014 10:36:00 GMT

IBM邀请我们公司试用websphere application server v8.5 liberty profile,因此经理让我下载下来安装,测试一下,正好我正对这个新东西也挺感兴趣的,所以在此把过程记录下来.

一、简介
Liberty profile是WAS V8.5的一个新特性，它代表WAS服务器上的App正常运行必须的一组运行时环境集合,这个环境是可以动态配置的。简单说Liberty profile就是WAS8.5的精简版，具有占用空间少、启动速度快、调试方便、完全支持JavaEE、App无缝移植到WAS8.5等特性，特别适合开发测试阶段使用。

二、安装,部署

1.前提：
确保计算机上正确安装了JDK1.6或以上版本，Eclipse3.7或以上版本（可选）。
2.安装Liberty profile
将下载得到的Zip包was4d-20111202-0614.zip，解压到磁盘任意目录下，无误后安装完毕。可以参照根目录下的readme.txt文件，掌握Liberty profile的基本配置管理。在这里假设Liberty profile的安装目录为。
3.创建server实例
Liberty profile继承了WAS的profile特性，即运行时环境可以以实例的形式单独动态配置，实例之间互不影响。因此，进入cmd模式下 cd bin ,然后was4d.bat create myserver，这样就创建了一个名称为myserver的运行时环境实例，其磁盘路径为\usr \servers\myserver，我们开发的App可以部署到myserver目录下的dropins文件夹中运行，供外界访问。
4.安装Liberty profile Eclipse开发插件
在Eclipse Marketplace中键入websphere，在随后的结果列表中找到websphere application server v8.5 liberty profile beta一项，点击install安装，完毕后重启Eclipse。
5.在Eclipse中引用myserver实例
在Eclipse 中的Server视图中右击 New-Server,在弹出框中选择IBM- websphere application server v8.5 liberty profile beta,然后根据提示选择myserver实例即可，无误完毕后会在Server视图中出现websphere application server v8.5 liberty profile beta at localhost 一项，右击websphere application server v8.5 liberty profile beta at localhost选择start，此时Console视图会出现myserver启动日志，“The feature update is complete after …”表示启动成功。
6.开发App
在Eclipse中新建一个简单的Java Web App 命名为hello-app，在其index.jsp页面中输入hello world即可。
7.App部署和卸载
部署和卸载行为可以在两个地方发生,一个是server.xml配置文件中,另一个是dropins目录.
(1) 在 myserver目录下找到server.xml文件并打开,加入””即可完成部署,删除这句话即可完成卸载，即便myserver处于运行状态也可以这样操作，因为server.xml是可以即时更新的，所做的修改能够马上生效。相对于tomcat这是Liberty profile的一个优势，当tomcat的server.xml内容被修改修改时必须重启才能生效。这种部署方式适用于开发阶段。
(2) 直接将war包扔进myserver目录下的dropins文件夹中即可完成部署，删除此war包机完成卸载，这种部署适用于实施阶段。
8.访问App
在浏览器中键入http://localhost:9080/hello-app/index.jsp，页面显示hello world，说明App部署成功，运行正常。

三、Liberty,Tomcat6,was比较
Tomcat 和was的比较很简单,一个开源一个商用,开源的Tomcat小巧,灵活适合做开发测试,商用的was它提供了一个平台，你可以基于各种增值功能、使用 Process Server、MQ等等更先进而稳定的架构来构建应用.对于并发,高性能访问的处理能力会更强.
由于Liberty profile 是 was 的简易版本,所以Liberty profile只适合开发相对比较简单的App,而这个App可以无缝移植到WAS上.

Tomcat6 与 Liberty profile的比较，红色为各自的优势

Tomcat6 Liberty profile

占用空间 27MB 56MB

启动时间 996ms 1600ms

配置复杂度较复杂,配置文件较多很简单,可以无配置文件

Server.xml
即时更新不支持,需重启生效支持,即时生效

运行环境
多实例不支持,灵活性较差支持,灵活性较高

Java EE
规范支持不支持serverlet3.0支持serverlet3.0
支持jpa2.0 支持jpa2.0
不支持EJB 不支持EJB

四、总结
之前开发WAS应用时,如果这个App不依赖于容器,我们通常的做法是在Tomcat中开发测试,在WAS中部署运行,而部署时App的配置文件必定要做相应的修改,比如JNDI。
现在不用了，我们有了Liberty profile----WAS的一组运行时环境，它与Tomcat一样免费，轻巧，快速，灵活，而且开发的应用不做任何修改就能移植到WAS上。
相对于与Tomcat6，Liberty profile支持最新的JavaEE规范，增加了很多功能更加强大，使用非常方便的特性，所以Liberty profile比Tomcat更优秀，即便App不是基于WAS也可以使用Liberty profile进行开发测试。

ZT文萃 2014-01-10 18:36 发表评论

新一代轻量级应用服务器 — WebSphere Liberty Profile Server 介绍

ZT文萃 — Fri, 10 Jan 2014 10:31:00 GMT

http://www.ibm.com/developerworks/cn/websphere/library/techarticles/1207_zhuxl_liberty/1207_zhuxl_liberty.html

在本文中，我们将详细介绍什么是 Liberty 以及如何使用 Liberty 快速的开发和部署应用，使读者迅速的掌握这一全新的轻量级应用服务器。

0 评论：

朱修磊, 软件工程师, IBM

2012 年 7 月 19 日

内容

什么是 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 支持与多种开发工具的结合：

支持在 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 工程师的支持，则需要支付额外的费用。

回页首

初探 WebSphere Liberty Profile Server

快速安装

在线安装 Liberty 开发工具

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

图 1. 安装 Liberty 开发工具

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

创建 Liberty 服务器

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

图 3. 选择 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 文件

                        jsp-2.2

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

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

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

图 8. Features 列表

简化服务器配置

灵活的服务器配置

图 9. 灵活配置

应用部署

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

图 10. 应用部署目录

动态加载模块

图 11. 动态化加载

运行时动态更新

图 12. 动态更新

新型的软件部署方式

图 13. 集中管理 Liberty 服务器

Liberty 之于开发人员

回页首

与主流 WEB 容器的对比

表 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 应用

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

打开 Eclipse，选择 File > New > Web>Dynamic Web Project
设置如下属性值：
1. Project name: Demo
2. Target runtime: WebSphere Application Server V8.5 Liberty Profile
图 14. 创建动态 Web 工程
点击 Next 两次，然后点击 Finish，完成工程的创建。
此时，你可以在左侧的资源导航页面看到刚刚创建完成的 Demo 工程，展开工程就可以看到一些默认创建的资源。
右击 Src 目录，选择 New > Class
设置如下属性值：
1. Package: com.date.demo
2. Name: DateProvider
图 15. 创建 java 文件
点击 Finish

编辑如下代码到 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() 用来获得当前时间。

右击 Src，选择 New > Servlet
设置如下属性值
1. Java package: com.date.demo
2. Class name: DatePrintServlet
图 16. 创建 Servlet 文件
点击 Finish，完成创建。

编辑如下内容到 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   }    }

在左侧导航栏选择 DatePrintServlet，点击右键 Run As > Run on Server , 如下图：
图 17. 选择 Liberty 服务器
点击 Finish，Liberty 开发工具将会为我们部署上面的 Demo 程序，并启动 Liberty 服务器。从 console 的日志里我们可以看到如下描述：

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

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

图 18. Demo 运行页面

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

清单 5. server.xml

                        jsp-2.2          localConnector-1.0

其中：

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

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

回页首

总结

参考资料

学习

访问 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 最新的产品工具包。

ZT文萃 2014-01-10 18:31 发表评论

WebSphere Application Server V8.5 常见问题及解答

ZT文萃 — Fri, 10 Jan 2014 03:31:00 GMT

WebSphere Application Server V8.5 的最重要的新特性是新的 Liberty Profile 以及智能管理。本 FAQ 为您汇集了关于 WAS V8.5 的问题集锦，从智能管理、 Liberty Profile、性能等方面帮助您解答您使用过程中可能遇到的问题。

Liberty 和 tWAS是两个产品吗？目前 tWAS和 Liberty 所支持的功能有什么不同？

Liberty 作为 WAS V8.5 发布的一部分，和 tWAS 作为两个单独的介质供用户使用。在功能上 Liberty 是 tWAS 的一个子集。tWAS 是一个完整的 J2EE 服务器，支持 J2EE 规范，而 liberty 目前只支持 Web, OSGi 和 Mobile 应用的开发。

Liberty 是如何提供给用户的？是以插件的形式吗？

Liberty 是以一个单独的运行时环境提供给用户的。用户下载 Liberty 的安装介质后解压缩即可作为运行时环境部署应用。同时 Liberty 可以很好的跟开发工具如 Eclipse、RAD 等结合使用，有很好的开发者体验。

Liberty 有哪些优点？

简单安装（可以通过 IM 进行安装，或者直接下载免安装版本）
快速启动
灵活的配置（只需要在 server.xml 文件里面进行配置即可）
实时更新（采用 OSGi 架构，server 不需重启，更改即可生效）
动态加载，Liberty 对所支持的功能特性实施动态加载的机制，即当使用某些特性的时候才将该特性相关的类加载的运行时当中。

Liberty 是否支持文件夹形式的 bundle 应用？

Liberty 目前不支持文件夹形式的 bundle 应用，但是支持将 EBA 格式的 OSGi 应用解压安装，应用名称的格式应为 xxx.eba。

Liberty 采用动态加载的方式，那么当新添加特性时，Liberty 服务器是否会重启？

当添加新的功能特性时，功能特性动态生效，Liberty 服务器不会被自动重启。

在 Liberty 上开发的应用能直接迁移到 tWAS 上进行使用吗？需要做什么修改吗？

用 Liberty 开发的应用可以无缝地迁移到 tWAS 上面，不需要对应用进行修改，只需要在 tWAS 对数据源等应用所需要的资源做相应的设置即可。

Liberty 上部署应用有两种方式，即 Monitored Directory 和 Configuration，两种方式有什么不同？

通过 Monitored Directory 的方式，用户只需把应用放在特定目录下面，Liberty 会自动去检查到该应用，然后自动帮助用户进行安装。

而通过 Configuration 的方式，Liberty 不会自动去进行安装，用户需要手动去进行安装，比如通过命令行或者 Eclipse 开发平台。

相比较与 Tomcat，开发者选择 Liberty 的原因将会是什么？ Liberty 会带来哪些新体验 ?

内容
对比项	Tomcat	Liberty
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 可动态加载或卸载对应的特性包
OSGi 编程模型支持	否	是，支持 Blue Print 1.0, WAB 1.0
开发工具	支持 Eclipse	支持 Eclipse, IBM Rational Application Developer
性能	一般	与传统 WAS 具有相同的核心代码，性能好
支持的操作系统	Linux, Windows	Linux, Windows, AIX, Mac, HP-UX, Solaris, iSeries, zSeries
配置文件	多个配置文件，更新后需重启服务器	一个配置文件，更新后及时生效，无需重启
可移植性	您可以利用 IBM Application Migration Toolkit 将 Tomcat 上开发的应用快速移植到 WebSphere 应用服务器。反之，则不然。	Liberty 和传统 WAS 对编程模型和标准的支持一致。在 Liberty 上开发的应用可以直接运行在传统 WAS 之上。
社区	http://tomcat.apache.org 有开发人员和用户的邮件列表，没有官方支持，有时回复不够及时。	http://wasdev.net，可以与开发人员直接交流
文档	官方文档涵盖内容有限，但网络上相关内容（包括：blog，技术文章等）广泛。	http://wasdev.net 上提供下载地址、文档、视频、音频、样本引用等。
长期战略优势	一般用于开发环境，生产环产应用的比较少。支持的并发度不高，可扩展性不强。	Liberty 与传统 WAS 共享同一代码，天生具有其高效稳定的特点。开发 - 测试 - 生产切换零代价。可扩展性高，支持多个 server 间的负载均衡和故障恢复。

Liberty 高速缓冲可以由 eXtreme Scale 提供吗？

可以，Liberty 可以和 eXtreme Scale 进行集成带来高速缓存的特性。

Liberty 支持 IBM iSeries 吗？

支持，在 IBM iSeries 上的使用和在其他平台上相同。

用户可以在 Eclipse 中管理 Liberty 吗？比如启动和停止？

可以，在 Eclipse 控制台的 Servers 标签中，展开您的 Liberty 下拉列表，会显示出当前部署在该应用服务器上的全部应用，右击某一应用，可以进行相关的启 / 停 / 移除操作，参见截图

但是在运行时环境里面，暂时不支持启动和停止某一个特定的应用。

Liberty 能在 mobile 的设备上做开发（比如 ipad）吗？

目前不支持这样做，但是 Liberty 支持在 MAC 系统上进行开发。

Liberty 是如何自动添加所需的功能特性的？

在开发环境，即 Eclipse+WDT+Liberty runtime 时，Liberty 可以自动为应用添加所需的特性。此功能是 WDT 来实现的，其会自动扫描应用，判断应用所采用的编程模型，然后为应用添加相应的功能支持。

如果直接使用 Liberty runtime 部署应用，Liberty 是不会自动为应用添加所需的特性的。

Liberty 如何处理不同的应用 /server 的端口冲突？

通过在 Liberty 的运行时环境下面的 bootstrap.properties 和 server.xml 两个文件进行相应的配置，该项配置需要重启 Liberty。参考信息中心进行配置。

除了 Liberty 之外，还有其他产品是基于 OSGi 架构的？

Liberty 是完全基于 OSGi 的产品，其在构建中完全遵循了 OSGi 的编程模型规范。在应用服务器领域暂时还没有发现其他的产品也完全采用 OSGi 的编程模型进行构建。

当启用某个 Liberty 的特性时，Liberty 是及时动态的加载属于该特性的 JAR 包，还是在 Liberty 启动的时候就已经加载，只是此时才开始使用？

一般来说，根据 bundle 的 Bundle-ActivationPolicy 值来确定是立刻启动 bundle 还是按需启动 bundle（lazy）。但是在 Liberty 中，大多数 bundle 都没有设定这个值，默认的行为就是当 Liberty 启动的时候 bundle 会被立即启动，但是，我们需要说明的是：

liberty 中对于 bundle 的使用采用的 DS 的方式（声明服务），bundle 与 bundle 之间是通过服务的调用来实现的，只有当去主动请求一个服务时，该服务的 bundle 提供者才会被加载，所以，当采用服务的管理模式后，我们并不需要特别在意 bundle 的加载方式。
在 liberty 中，只有很少的 bundle 设定了 Bundle-ActivationPolicy 值，此刻，这些 bundle 会根据值的设定选择立刻或者按需启动。

ZT文萃 2014-01-10 11:31 发表评论

dom4j解析xml字符串实例

ZT文萃 — Fri, 22 Nov 2013 13:00:00 GMT

来自：

http://www.cnblogs.com/macula/archive/2011/07/27/2118003.html

DOM4J

与利用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 = "" + "" + "dom4j解析一个例子" 167                 + "" + "" 169                 + "" + "0" + "" 170                 + "1000" + "36242519880716" 171                 + "
" + "" + ""; 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  *  10  *          11  *            DBTest 12  *             13  *             14  *                 15  *              16  *            org.gjt.mm.mysql.Driver 17  *             test 18  *            test2012 19  *            10 20  *            10 21  *            2 22  *            10 23  *            SELECT 1+1 24  *          25  *  26  * 27  * 示例2——节点属性： 28  *  29  *          30  *            Everyday Italian 31  *            Giada De Laurentiis 32  *            2005 33  *            30.00 34  *          35  * 36  *          37  *  38  * 39  * @param configFile 40  * @return 41  * @throws Exception 42  */ 43 public static List> parseDBXML(String configFile) throws Exception { 44     List> dbConnections = new ArrayList>(); 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 rootIter = connections.elementIterator(); 51     while (rootIter.hasNext()) { 52         Element connection = rootIter.next(); 53         Iterator childIter = connection.elementIterator(); 54         Map connectionInfo = new HashMap(); 55         List 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 }

ZT文萃 2013-11-22 21:00 发表评论

Dom4j中XPath的使用参考

ZT文萃 — Fri, 22 Nov 2013 12:56:00 GMT

转自：http://txy920.blog.163.com/blog/static/1494427820095922212262/

关键字：dom4j xpath

获取Document
- SAXReader saxReader = new SAXReader();
- Document document = saxReader.read(FileUtil.getFileInputStream(fileName));
查询Element
- String xpath ="/composites/composite[@type='onDelete']";//查询属性type='ondDelete'的composite
- List composites = document.selectNodes(xpath);
xpath语法

选取节点

XPath 使用路径表达式在 XML 文档中选取节点。节点是通过沿着路径或者 step 来选取的。

下面列出了最有用的路径表达式：

表达式描述

nodename	选取此节点的所有子节点
/	从根节点选取
//	从匹配选择的当前节点选择文档中的节点，而不考虑它们的位置
.	选取当前节点
..	选取当前节点的父节点
@	选取属性

实例

在下面的表格中，我们已列出了一些路径表达式以及表达式的结果：

路径表达式结果

bookstore	选取 bookstore 元素的所有子节点
/bookstore	选取根元素 bookstore 注释：假如路径起始于正斜杠( / )，则此路径始终代表到某元素的绝对路径！
bookstore/book	选取所有属于 bookstore 的子元素的 book 元素。
//book	选取所有 book 子元素，而不管它们在文档中的位置。
bookstore//book	选择所有属于 bookstore 元素的后代的 book 元素，而不管它们位于 bookstore 之下的什么位置。
//@lang	选取所有名为 lang 的属性。

谓语（Predicates）

谓语用来查找某个特定的节点或者包含某个指定的值的节点。

谓语被嵌在方括号中。

实例

在下面的表格中，我们列出了带有谓语的一些路径表达式，以及表达式的结果：

路径表达式结果

/bookstore/book[1]	选取属于 bookstore 子元素的第一个 book 元素。
/bookstore/book[last()]	选取属于 bookstore 子元素的最后一个 book 元素。
/bookstore/book[last()-1]	选取属于 bookstore 子元素的倒数第二个 book 元素。
/bookstore/book[position()<3]	选取最前面的两个属于 bookstore 元素的子元素的 book 元素。
//title[@lang]	选取所有拥有名为 lang 的属性的 title 元素。
//title[@lang='eng']	选取所有 title 元素，且这些元素拥有值为 eng 的 lang 属性。
/bookstore/book[price>35.00]	选取所有 bookstore 元素的 book 元素，且其中的 price 元素的值须大于 35.00。
/bookstore/book[price>35.00]/title	选取所有 bookstore 元素中的 book 元素的 title 元素，且其中的 price 元素的值须大于 35.00。

选取未知节点

XPath 通配符可用来选取未知的 XML 元素。

通配符描述

*	匹配任何元素节点
@*	匹配任何属性节点
node()	匹配任何类型的节点

实例

在下面的表格中，我们列出了一些路径表达式，以及这些表达式的结果：

路径表达式结果

/bookstore/*	选取 bookstore 元素的所有子节点
//*	选取文档中的所有元素
//title[@*]	选取所有带有属性的 title 元素。

选取若干路径

通过在路径表达式中使用“|”运算符，您可以选取若干个路径。

实例

在下面的表格中，我们列出了一些路径表达式，以及这些表达式的结果：

路径表达式结果

//book/title \| //book/price	选取所有 book 元素的 title 和 price 元素。
//title \| //price	选取所有文档中的 title 和 price 元素。
/bookstore/book/title \| //price	选取所有属于 bookstore 元素的 book 元素的 title 元素，以及文档中所有的 price 元素。

XPath 轴

轴可定义某个相对于当前节点的节点集。

轴名称结果

ancestor	选取当前节点的所有先辈（父、祖父等）
ancestor-or-self	选取当前节点的所有先辈（父、祖父等）以及当前节点本身
attribute	选取当前节点的所有属性
child	选取当前节点的所有子元素。
descendant	选取当前节点的所有后代元素（子、孙等）。
descendant-or-self	选取当前节点的所有后代元素（子、孙等）以及当前节点本身。
following	选取文档中当前节点的结束标签之后的所有节点。
namespace	选取当前节点的所有命名空间节点
parent	选取当前节点的父节点。
preceding	选取文档中当前节点的开始标签之前的所有节点。
preceding-sibling	选取当前节点之前的所有同级节点。
self	选取当前节点。

位置路径表达式

位置路径可以是绝对的，也可以是相对的。

绝对路径起始于正斜杠( / )，而相对路径不会这样。在两种情况中，位置路径均包括一个或多个步，每个步均被斜杠分割：

绝对位置路径：

/step/step/...

相对位置路径：

step/step/...

每个步均根据当前节点集之中的节点来进行计算。

步（step）包括：

轴（axis）

定义所选节点与当前节点之间的树关系

节点测试（node-test）

识别某个轴内部的节点

零个或者更多谓语（predicate）

更深入地提炼所选的节点集

步的语法：

轴名称::节点测试[谓语]

实例

例子结果

child::book	选取所有属于当前节点的子元素的 book 节点
attribute::lang	选取当前节点的 lang 属性
child::*	选取当前节点的所有子元素
attribute::*	选取当前节点的所有属性
child::text()	选取当前节点的所有文本子节点
child::node()	选取当前节点的所有子节点
descendant::book	选取当前节点的所有 book 后代
ancestor::book	选择当前节点的所有 book 先辈
ancestor-or-self::book	选取当前节点的所有book先辈以及当前节点（假如此节点是book节点的话）
child::*/child::price	选取当前节点的所有 price 孙。

XPath 运算符

下面列出了可用在 XPath 表达式中的运算符：

运算符描述实例返回值

\|	计算两个节点集	//book \| //cd	返回所有带有 book 和 ck 元素的节点集
+	加法	6 + 4	10
-	减法	6 - 4	2
*	乘法	6 * 4	24
div	除法	8 div 4	2
=	等于	price=9.80	如果 price 是 9.80，则返回 true。如果 price 是 9.90，则返回 fasle。
!=	不等于	price!=9.80	如果 price 是 9.90，则返回 true。如果 price 是 9.80，则返回 fasle。
<	小于	price<9.80	如果 price 是 9.00，则返回 true。如果 price 是 9.90，则返回 fasle。
<=	小于或等于	price<=9.80	如果 price 是 9.00，则返回 true。如果 price 是 9.90，则返回 fasle。
>	大于	price>9.80	如果 price 是 9.90，则返回 true。如果 price 是 9.80，则返回 fasle。
>=	大于或等于	price>=9.80	如果 price 是 9.90，则返回 true。如果 price 是 9.70，则返回 fasle。
or	或	price=9.80 or price=9.70	如果 price 是 9.80，则返回 true。如果 price 是 9.50，则返回 fasle。
and	与	price>9.00 and price<9.90	如果 price 是 9.80，则返回 true。如果 price 是 8.50，则返回 fasle。
mod	计算除法的余数	5 mod 2	1

参考：

http://itren.iteye.com/blog/163901

ZT文萃 2013-11-22 20:56 发表评论

java文件读写操作大全

ZT文萃 — Wed, 20 Nov 2013 08:46:00 GMT

转自http://blog.sina.com.cn/s/blog_4a9f789a0100ik3p.html

一.获得控制台用户输入的信息

     public String getInputMessage() throws IOException...{
         System.out.println("请输入您的命令∶");
         byte buffer[]=new byte[1024];
         int count=System.in.read(buffer);
         char[] ch=new char[count-2];//最后两位为结束符，删去不要
         for(int i=0;i             ch[i]=(char)buffer[i];
         String str=new String(ch);
         return str;
     }
     可以返回用户输入的信息，不足之处在于不支持中文输入，有待进一步改进。

     二.复制文件
     1.以文件流的方式复制文件

     public void copyFile(String src,String dest) throws IOException...{
         FileInputStream in=new FileInputStream(src);
         File file=new File(dest);
         if(!file.exists())
             file.createNewFile();
         FileOutputStream out=new FileOutputStream(file);
         int c;
         byte buffer[]=new byte[1024];
         while((c=in.read(buffer))!=-1)...{
             for(int i=0;i                 out.write(buffer[i]);
         }
         in.close();
         out.close();
     }
     该方法经过测试，支持中文处理，并且可以复制多种类型，比如txt，xml，jpg，doc等多种格式

     三.写文件

     1.利用PrintStream写文件

     public void PrintStreamDemo()...{
         try ...{
             FileOutputStream out=new FileOutputStream("D:/test.txt");
             PrintStream p=new PrintStream(out);
             for(int i=0;i<10;i++)
                 p.println("This is "+i+" line");
         } catch (FileNotFoundException e) ...{
             e.printStackTrace();
         }
     }
     2.利用StringBuffer写文件
public void StringBufferDemo() throws IOException......{
         File file=new File("/root/sms.log");
         if(!file.exists())
             file.createNewFile();
         FileOutputStream out=new FileOutputStream(file,true);
         for(int i=0;i<10000;i++)......{
             StringBuffer sb=new StringBuffer();
             sb.append("这是第"+i+"行:前面介绍的各种方法都不关用,为什么总是奇怪的问题 ");
             out.write(sb.toString().getBytes("utf-8"));
         }
         out.close();
     }
     该方法可以设定使用何种编码，有效解决中文问题。
四.文件重命名

     public void renameFile(String path,String oldname,String newname)...{
         if(!oldname.equals(newname))...{//新的文件名和以前文件名不同时,才有必要进行重命名
             File oldfile=new File(path+"/"+oldname);
             File newfile=new File(path+"/"+newname);
             if(newfile.exists())//若在该目录下已经有一个文件和新文件名相同，则不允许重命名
                 System.out.println(newname+"已经存在！");
             else...{
                 oldfile.renameTo(newfile);
             }
         }
     }

五.转移文件目录
     转移文件目录不等同于复制文件，复制文件是复制后两个目录都存在该文件，而转移文件目录则是转移后，只有新目录中存在该文件。

     public void changeDirectory(String filename,String oldpath,String newpath,boolean cover)...{
         if(!oldpath.equals(newpath))...{
             File oldfile=new File(oldpath+"/"+filename);
             File newfile=new File(newpath+"/"+filename);
             if(newfile.exists())...{//若在待转移目录下，已经存在待转移文件
                 if(cover)//覆盖
                     oldfile.renameTo(newfile);
                 else
                     System.out.println("在新目录下已经存在："+filename);
             }
             else...{
                 oldfile.renameTo(newfile);
             }
         }
     }
     六.读文件
     1.利用FileInputStream读取文件

     public String FileInputStreamDemo(String path) throws IOException...{
         File file=new File(path);
         if(!file.exists()||file.isDirectory())
             throw new FileNotFoundException();
         FileInputStream fis=new FileInputStream(file);
         byte[] buf = new byte[1024];
         StringBuffer sb=new StringBuffer();
         while((fis.read(buf))!=-1)...{
             sb.append(new String(buf));
             buf=new byte[1024];//重新生成，避免和上次读取的数据重复
         }
         return sb.toString();
     }
2.利用BufferedReader读取

     在IO操作，利用BufferedReader和BufferedWriter效率会更高一点


     public String BufferedReaderDemo(String path) throws IOException...{
         File file=new File(path);
         if(!file.exists()||file.isDirectory())
             throw new FileNotFoundException();
         BufferedReader br=new BufferedReader(new FileReader(file));
         String temp=null;
         StringBuffer sb=new StringBuffer();
         temp=br.readLine();
         while(temp!=null)...{
             sb.append(temp+" ");
             temp=br.readLine();
         }
         return sb.toString();
     }

     3.利用dom4j读取xml文件


     public Document readXml(String path) throws DocumentException, IOException...{
         File file=new File(path);
         BufferedReader bufferedreader = new BufferedReader(new FileReader(file));
         SAXReader saxreader = new SAXReader();
         Document document = (Document)saxreader.read(bufferedreader);
         bufferedreader.close();
         return document;
     }
     七.创建文件(文件夹)

1.创建文件夹
     public void createDir(String path)...{
         File dir=new File(path);
         if(!dir.exists())
             dir.mkdir();
     }
2.创建新文件
     public void createFile(String path,String filename) throws IOException...{
         File file=new File(path+"/"+filename);
         if(!file.exists())
             file.createNewFile();
     }
     八.删除文件(目录)
1.删除文件
     public void delFile(String path,String filename)...{
         File file=new File(path+"/"+filename);
         if(file.exists()&&file.isFile())
             file.delete();
     }
2.删除目录
要利用File类的delete()方法删除目录时，必须保证该目录下没有文件或者子目录，否则删除失败，因此在实际应用中，我们要删除目录，必须利用递归删除该目录下的所有子目录和文件，然后再删除该目录。
     public void delDir(String path)...{
         File dir=new File(path);
         if(dir.exists())...{
             File[] tmp=dir.listFiles();
             for(int i=0;i                 if(tmp[i].isDirectory())...{
                     delDir(path+"/"+tmp[i].getName());
                 }
                 else...{
                     tmp[i].delete();
                 }
             }
             dir.delete();
         }
     }
From zhuocheng (cnblogs.com/zhuocheng)

ZT文萃 2013-11-20 16:46 发表评论

Linux查看文件的最初创建时间

ZT文萃 — Thu, 24 Oct 2013 06:17:00 GMT

http://article.pchome.net/content-1409199.html

在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 *查看这个目录所有文件的状态。

ZT文萃 2013-10-24 14:17 发表评论

Linux命令行下常用svn命令

ZT文萃 — Fri, 18 Oct 2013 06:01:00 GMT

http://soft.chinabyte.com/os/291/11696291.shtml

1、Linux命令行下将文件checkout到本地目录

　　svn checkout path(path是服务器上的目录)

　　例如：svn checkout svn://192.168.1.1/pro/domain

　　简写：svn co

　　2、Linux命令行下往版本库中添加新的文件

　　svn add file

　　例如：svn add test.php(添加test.php)

　　svn add *.php(添加当前目录下所有的php文件)

　　3、Linux命令行下将改动的文件提交到版本库

　　svn commit -m “LogMessage“ [-N] [--no-unlock] PATH(如果选择了保持锁，就使用–no-unlock开关)

　　例如：svn commit -m “add test file for my test“ test.php

　　简写：svn ci

　　4、Linux命令行下的加锁/解锁

　　svn lock -m “LockMessage“ [--force] PATH

　　例如：svn lock -m “lock test file“ test.php

　　svn unlock PATH

　　5、Linux命令行下更新到某个版本

　　svn update -r m path

　　例如：

　　svn update如果后面没有目录，默认将当前目录以及子目录下的所有文件都更新到最新版本。

　　svn update -r 200 test.php(将版本库中的文件test.php还原到版本200)

　　svn update test.php(更新，于版本库同步。如果在提交的时候提示过期的话，是因为冲突，需要先update，修改文件，然后清除svn resolved，最后再提交commit)

　　简写：svn up

　　6、Linux命令行下查看文件或者目录状态

　　1)svn status path(目录下的文件和子目录的状态，正常状态不显示)

　　【?：不在svn的控制中;M：内容被修改;C：发生冲突;A：预定加入到版本库;K：被锁定】

　　2)svn status -v path(显示文件和子目录状态)

　　第一列保持相同，第二列显示工作版本号，第三和第四列显示最后一次修改的版本号和修改人。

　　注：svn status、svn diff和 svn revert这三条命令在没有网络的情况下也可以执行的，原因是svn在本地的.svn中保留了本地版本的原始拷贝。

　　简写：svn st

　　7、Linux命令行下删除文件

　　svn delete path -m “delete test fle“

　　例如：svn delete svn://192.168.1.1/pro/domain/test.php -m “delete test file”

　　或者直接svn delete test.php 然后再svn ci -m ‘delete test file‘，推荐使用这种

　　简写：svn (del, remove, rm)

　　8、Linux命令行下查看日志

　　svn log path

　　例如：svn log test.php 显示这个文件的所有修改记录，及其版本号的变化

　　9、Linux命令行下查看文件详细信息

　　svn info path

　　例如：svn info test.php

　　10、Linux命令行下比较差异

　　svn diff path(将修改的文件与基础版本比较)

　　例如：svn diff test.php

　　svn diff -r m:n path(对版本m和版本n比较差异)

　　例如：svn diff -r 200:201 test.php

　　简写：svn di

　　11、Linux命令行下将两个版本之间的差异合并到当前文件

　　svn merge -r m:n path

　　例如：svn merge -r 200:205 test.php(将版本200与205之间的差异合并到当前文件，但是一般都会产生冲突，需要处理一下)

　　12、Linux命令行下SVN 帮助

　　svn help

　　svn help ci

　　以上是常用命令，下面写几个不经常用的

　　13、Linux命令行下版本库下的文件和目录列表

　　svn list path

　　显示path目录下的所有属于版本库的文件和目录

　　简写：svn ls

　　14、Linux命令行下创建纳入版本控制下的新目录

　　svn mkdir: 创建纳入版本控制下的新目录。

　　用法: 1、mkdir PATH…

　　2、mkdir URL…

　　创建版本控制的目录。

　　1、每一个以工作副本 PATH 指定的目录，都会创建在本地端，并且加入新增调度，以待下一次的提交。

　　2、每个以URL指定的目录，都会透过立即提交于仓库中创建.在这两个情况下，所有的中间目录都必须事先存在。

　　15、Linux命令行下恢复本地修改

　　svn revert: 恢复原始未改变的工作副本文件 (恢复大部份的本地修改)。revert:

　　用法: revert PATH…

　　注意: 本子命令不会存取网络，并且会解除冲突的状况。但是它不会恢复被删除的目录

　　16、Linux命令行下代码库URL变更

　　svn switch (sw): 更新工作副本至不同的URL。

　　用法: 1、switch URL [PATH]

　　2、switch –relocate FROM TO [PATH...]

　　1、更新你的工作副本，映射到一个新的URL，其行为跟“svn update”很像，也会将服务器上文件与本地文件合并。这是将工作副本对应到同一仓库中某个分支或者标记的方法。

　　2、改写工作副本的URL元数据，以反映单纯的URL上的改变。当仓库的根URL变动(比如方案名或是主机名称变动)，但是工作副本仍旧对映到同一仓库的同一目录时使用这个命令更新工作副本与仓库的对应关系。

　　17、Linux命令行下解决冲突

　　svn resolved: 移除工作副本的目录或文件的“冲突”状态。

　　用法: resolved PATH…

　　注意: 本子命令不会依语法来解决冲突或是移除冲突标记;它只是移除冲突的相关文件，然后让 PATH 可以再次提交。

　　18、Linux命令行下输出指定文件或URL的内容。

　　svn cat 目标[@版本]…如果指定了版本，将从指定的版本开始查找。

　　svn cat -r PREV filename > filename (PREV 是上一版本,也可以写具体版本号,这样输出结果是可以提交的)

ZT文萃 2013-10-18 14:01 发表评论

svn co

ZT文萃 — Fri, 18 Oct 2013 03:29:00 GMT

http://blog.163.com/wb_zhaoyuwei/blog/static/183075439201301535012961/

首先需要知道一点， svn co 只能check 目录，不能co文件；如果需要co文件，需要用 svn export;

svn co 的用法经常有两种：

第一种：直接 svn co http://svnserver/mypro/trunk

此时，会在你的当前目录下，增加一个 trunk文件夹； svn的trunk文件的内容，在trunk文件夹中。

第二种： svn co http://svnserver/mypro/trunk code

此时，会在你的当前目录下，增加一个 code的文件夹， svn的trunk的文件的内容，在code中。

ZT文萃 2013-10-18 11:29 发表评论

在Bugzilla中通过SMTP发通知邮件

ZT文萃 — Fri, 27 Sep 2013 10:40:00 GMT

From:
http://www.cnitblog.com/201/archive/2011/05/25/74069.html

在Bugzilla中通过SMTP发通知邮件
Posted on 2011/04/05 by admin

Bugzilla 4.0注册验证通知等邮件可以通过SendMail之类的来发送，配置也很简单，但是它发出去的邮件后缀地址是localhost.localdomain之类的地址，会被一些邮箱拦截，从而收不到邮件。所以通过SMTP来发邮件还是很必要的。
文档上说的配置SMTP也很简单，但是我在配置的时候遇到几个问题，在此记录下来
1、The new value for smtp_username is invalid: SMTP Authentication is not available. Run checksetup.pl for more details.
这是我在Bugzilla中Create New Account的时候发验证邮件时产生的，这个的原因是Perl有个模块没有安装，安装下就可以了
sudo perl install-module.pl Authen::SASL
自己先可以通过$ ./checksetup.pl –check-modules查看下已经安装了哪些模块
只要安装好，上述的这个问题就解决了

所以再次试着注册一个用户，提示邮件发送成功了，于是下面的问题产生了

2、提示邮件成功发送，但是实际邮件没有发送出去，因为我填的邮箱没有收到邮件
在这里我原先是开启了use_mailer_queue这个功能
于是我选择使用Test模式(Parameters -> Email -> mail_delivery_method -> SMTP)再发了一次，mailer.testfile木有邮件

网络上有人和我是一样的问题，发不出去邮件，我参看这里http://hi.baidu.com/ever__love/blog/item /62473a9772800846d0135e2c.html的方法，把use_mailer_queue关闭(Parameters -> Email -> use_mailer_queue -> Off)，再试着发送一次，果真mailer.testfile当中有邮件了

这样就基本定位到问题use_mailer_queue没有正常工作

于是又把use_mailer_queue开启
执行下面的命令
$ $BUGZILLA_HOME/jobqueue.pl check
Configuration looks okay
jobqueue.pl running – pid 5317
9 jobs in the queue.

看起来似乎正常，但是提示9 jobs in the queue，并且这个数目一直没有减少，这说明邮件几乎都被堵塞在这里了，而并没有发出去

于是又Debug发现
$ $BUGZILLA_HOME/jobqueue.pl -f -d restart
Killing 9657
Starting up…
TheSchwartz::work_once found no jobs
TheSchwartz::work_once found no jobs

几乎神了，这里又说没有错误，那到底是哪里出问题了呢？
目前无解，求解ING。。。

UPDATE 后来经过分析解决了此问题
虽然debug jobqueue出来的信息开头几个没有发现什么异常，但是经过很多个“TheSchwartz::work_once found no jobs”之后出来一些错误信息，如下：
……
TheSchwartz::work_once found no jobs
TheSchwartz::work_once found no jobs
TheSchwartz::work_once found no jobs
…….
TheSchwartz::work_once found no jobs
TheSchwartz::work_once found no jobs
TheSchwartz::work_once found no jobs
TheSchwartz::work_once got job of class ‘Bugzilla::Job::Mailer’
Working on Bugzilla::Job::Mailer …
Use of uninitialized value $hostname in concatenation (.) or string at Bugzilla/Mailer.pm line 153.
job failed. considering retry. is max_retries of 725 >= failures of 5?
job failed: There was an error sending mail from ‘bugzilla_admin@’ to
‘xxxxx@aol.com’:Can’t call method “address” on an undefined value at
lib/Email/Send/SMTP.pm line 25.
TheSchwartz::work_once found no jobs
……
TheSchwartz::work_once found no jobs
TheSchwartz::work_once got job of class ‘Bugzilla::Job::Mailer’
Working on Bugzilla::Job::Mailer …
Use of uninitialized value $hostname in concatenation (.) or string at Bugzilla/Mailer.pm line 153.
job failed. considering retry. is max_retries of 725 >= failures of 5?
job failed: There was an error sending mail from ‘bugzilla_admin@’ to
‘xxxxxx@gmail.com’:Can’t call method “address” on an undefined value
at lib/Email/Send/SMTP.pm line 25.
TheSchwartz::work_once found no jobs
……
TheSchwartz::work_once found no jobs

……是我省略掉了很多这样相同的状态

看起来这个jobqueue当中的任务不是立即就执行了的，它可能是经过某种算法才执行的
否则不应该出现第一个就是“TheSchwartz::work_once found no jobs”，到后面才有任务执行的

并且进一步发现这些任务队列都是放在数据库当中的一张表(ts_job)中的，任务成功一个就把它从这张表中删除

不过此时问题还没有解决，认真看下错误，并且看了指出的错误地方的源代码，觉得应该是mailfrom填错了，可能我这里填的不完整

又打开SMTP的调试开关(Parameters -> Email -> smtp_debug -> On)，这样能看到更多的详细信息，基本觉得问题就在这了

于是我填写了标准的邮件格式“username@example.com”之后再试，邮件还不没有发出去，jobqueue的的数量又增加了一个，
看来可能前面的这些包含错误信息的队列已经将后面的阻塞了，于是我试着将ts_job表当中的数据删除
truncate table ts_job; // 反正我这里是直接truncate掉了的，我不知道这里delete和truncate有没有区别

再次注册了一遍，看到后台输出通知邮件发送成功的信息，如下：
TheSchwartz::work_once found no jobs
TheSchwartz::work_once got job of class ‘Bugzilla::Job::Mailer’
Working on Bugzilla::Job::Mailer …
Net::SMTP>>> Net::SMTP(2.31)
Net::SMTP>>> Net::Cmd(2.29)
Net::SMTP>>> Exporter(5.63)
Net::SMTP>>> IO::Socket::INET(1.31)
Net::SMTP>>> IO::Socket(1.31)
Net::SMTP>>> IO::Handle(1.28)
Net::SMTP=GLOB(0xb79ce68)<<< 220 esmtp4.qq.com Esmtp QQ Mail Server
Net::SMTP=GLOB(0xb79ce68)>>> EHLO localhost.localdomain
Net::SMTP=GLOB(0xb79ce68)<<< 250-esmtp4.qq.com
Net::SMTP=GLOB(0xb79ce68)<<< 250-PIPELINING
Net::SMTP=GLOB(0xb79ce68)<<< 250-SIZE 52428800
Net::SMTP=GLOB(0xb79ce68)<<< 250-AUTH LOGIN PLAIN
Net::SMTP=GLOB(0xb79ce68)<<< 250-AUTH=LOGIN
Net::SMTP=GLOB(0xb79ce68)<<< 250 8BITMIME
Net::SMTP=GLOB(0xb79ce68)>>> AUTH LOGIN
……
Net::SMTP=GLOB(0xb79ce68)<<< 235 Authentication successful
Net::SMTP=GLOB(0xb79ce68)>>> MAIL FROM:
Net::SMTP=GLOB(0xb79ce68)<<< 250 Ok
Net::SMTP=GLOB(0xb79ce68)>>> RCPT TO:
Net::SMTP=GLOB(0xb79ce68)<<< 250 Ok
Net::SMTP=GLOB(0xb79ce68)>>> DATA
Net::SMTP=GLOB(0xb79ce68)<<< 354 End data with .
Net::SMTP=GLOB(0xb79ce68)>>> From: xxxxxx@qq.com
Net::SMTP=GLOB(0xb79ce68)>>> To: xxxxxx@gmail.com
Net::SMTP=GLOB(0xb79ce68)>>> Subject: Bugzilla: confirm account creation
Net::SMTP=GLOB(0xb79ce68)>>> X-Bugzilla-Type: admin
Net::SMTP=GLOB(0xb79ce68)>>> X-Bugzilla-URL:
Net::SMTP=GLOB(0xb79ce68)>>> Auto-Submitted: auto-generated
Net::SMTP=GLOB(0xb79ce68)>>> Content-Type: text/plain; charset=”UTF-8″
Net::SMTP=GLOB(0xb79ce68)>>> MIME-Version: 1.0
Net::SMTP=GLOB(0xb79ce68)>>> Date: Tue, 05 Apr 2011 16:05:23 +0800
Net::SMTP=GLOB(0xb79ce68)>>>
Net::SMTP=GLOB(0xb79ce68)>>> Bugzilla has received a request to create a user account
Net::SMTP=GLOB(0xb79ce68)>>> using your email address (xxxxxx@gmail.com).
Net::SMTP=GLOB(0xb79ce68)>>>
Net::SMTP=GLOB(0xb79ce68)>>> To continue creating an account using this email address, visit the
Net::SMTP=GLOB(0xb79ce68)>>> following link by April 8, 2011 at 16:05 CST:
Net::SMTP=GLOB(0xb79ce68)>>>
Net::SMTP=GLOB(0xb79ce68)>>> token.cgi?t=FegLL6OpYM&a=request_new_account
Net::SMTP=GLOB(0xb79ce68)>>> PRIVACY NOTICE: Bugzilla is an open bug tracking system. Activity on most
Net::SMTP=GLOB(0xb79ce68)>>> bugs, including email addresses, will be visible to the public. We recommend
……
Net::SMTP=GLOB(0xb79ce68)>>> .
Net::SMTP=GLOB(0xb79ce68)<<< 250 Ok: queued as
Net::SMTP=GLOB(0xb79ce68)>>> QUIT
Net::SMTP=GLOB(0xb79ce68)<<< 221 Bye
job completed
TheSchwartz::work_once found no jobs

到QQ Mail也看到发送成功的邮件，在Gmail也收到了邮件，到此才算基本成功。

Parameters -> Email里面我的基本几项数据如下
mailfrom : xxxxxx@qq.com // 出现问题就是这里填的不标准
use_mailer_queue : on
smtpserver : smtp.qq.com
smtp_username : xxxxxx@qq.com
smtp_password : ******

如果mail_delivery_method你选择SendMail或者Test，那么SMTP相关的参数就可以不用填了，如果你是通过SSL加密的SMTP链接，应该是要新装插件了

P.S. 关于use_mailer_queue的信息请挪步http://www.bugzilla.org/releases/4.0/release-notes.html#v34_feat_async

ZT文萃 2013-09-27 18:40 发表评论

bugzilla安装过程，已验证成功！

ZT文萃 — Fri, 27 Sep 2013 06:18:00 GMT

From:

http://hi.baidu.com/najftulhmndgswr/item/6d8ba9f0d02e9004d89e7294

本文安装过程主要参考：

http://www.bugzilla.org/docs/3.6/en/html/installation.html

http://www.thegeekstuff.com/2010/05/install-bugzilla-on-linux/

安装流程：

1. 先检测下 Perl是否安装了

$ perl -v
如果没有安装，下载安装

2. 安装一个数据库，推荐使用 MySQL

$ mysql -V
如果没有安装的话，用 apt-get即可，server和client都装下。
在装 mysql-server的时候会提示输入 password，记住，再后面创建数据库的时候会用到。

3. 安装apache２

apt-get install 即可。

测试apache2是否正常：

在浏览器的URL栏输入: http://localhost 或者　 http://127.0.0.1;
只要出现：　It works!
表示服务器已经正常启动。

４. 下载并安装　Bugzilla　

下载 Bugzilla 3.6.1，地址：　http://www.bugzilla.org/download/

下载后在　/var/www/目录下解压，然后进入目录

１）Perl 模块的安装

a)首先查看下缺少的模块

bash# ./checksetup.pl --check-modules　

b)然后利用这个命令将所缺模块安装上

bash# perl install-module.pl

必须安装的模块有这些：

1. CGI (3.21)
2. Date::Format (2.21)
3. DateTime (0.28)
4. DateTime::TimeZone (0.71)
5. DBI (1.41)
6. DBD::mysql (4.00) if using MySQL
7. Digest::SHA (any)
8. Email::Send (2.00)
9. Email::MIME (1.861)
10. Email::MIME::Encodings (1.313)
11. Email::MIME::Modifier (1.442)
12. Template (2.22)
13. URI (any)

如果未安装模块太多,可以执行下列命令，全体安装：
（注意：由于安装模块的时候会有权限问题，所以在执行下列命令前，
sudo chmod 777 -R bugzilla-3.6.1）

bash# /usr/bin/perl install-module.pl --all

（关于DateTime::TimeZone 模块安装失败的问题，请参考此网站的最后回复，Build）
http://www.experts-exchange.com/OS/Linux/Q_25111007.html
需要自己下载DateTIme模块，然后重新编译，在解压目录 perl Build.PL,然后按照上面网站所说！！！

2)成功装完后，生成本地config

bash# ./checksetup.pl

bash# vi ./localconfig
修改：　$db_pass = 'akaedu';
修改： $webservergroup = 'www-data';
保存退出

3)之后在mysql数据库中加入信息

bash# mysql -u root -p　
（如果这里要输入密码一直过不去，请参考
http://hi.baidu.com/ever__love/blog/item/1c9b3c19cd0866f7af5133c7.html）

mysql> GRANT SELECT, INSERT,
UPDATE, DELETE, INDEX, ALTER, CREATE, LOCK TABLES,
CREATE TEMPORARY TABLES, DROP, REFERENCES ON bugs.*
TO bugs@localhost IDENTIFIED BY 'akaedu';

mysql> FLUSH PRIVILEGES;
mysql> quit;

mysql的命令必须都以分号结束。

4) 再次安装

bash# ./checksetup.pl

如果上述一切正常，这次安装过程中将提示你输入　邮箱，真名，密码。
邮箱是你登录bugzilla的root用户名，密码就是密码。

5. 配置apache的config，与bugzilla的index链接

bash# vi /etc/apache2/apache2.conf

在内部添加这样一段：

AddHandler cgi-script .cgi
Options +Indexes +ExecCGI
DirectoryIndex index.cgi
AllowOverride Limit

然后重启apache2

bash# /etc/init.d/apache2 restart

6. 到这里应该就能正常访问bugzilla的主页了

URL: http://localhost/bugzilla (如果不行，就把bugzilla的版本号加上)
就会看到如下图像，表示正常登录bugzilla了。

大功告成

进入后，选一个 “File a bug”，然后输入root用户名(邮箱)以及密码就正常登录，可以使用了。
目前遗留问题，无法注册普通用户，因为注册时候会发送确认信件，发送显示成功（没有报错），但目标信件收不到，不知是哪里出了问题。TODO！

上述邮件发送问题已经解决了！！！

解决方法：
感觉应该是 bugzilla的设置问题，在bugzilla网页上登录后，点击上端菜单中的
Administration, 然后选择 Parameters, 在左侧栏中选择E-mail，然后在 mail_delivery_method中选择 Test，虽然你点击了发送邮件，但会被bugzilla自己截获，存入 data/mailer.testfile文件中。如果发不出邮件，可以选择Test，在data/mailer.testfile文件中如果有信息，那说明邮件服务器有问题，但如果此文件中没有信息，那就说明有别的问题。
我发送邮件显示正常，但目标收不到邮件，检查 data/mailer.testfile文件，发现是空的。之前用telnet smtp测试，能正常连通smtp.163.com，思来想去，应该就是bugzilla的设置问题。这个不成功的版本是在同时电脑上测试的，我自己的已经成功，只不过过程中修改的东西太多，不知如何调试了。于是乎我就想到了diff，网页上的配置信息对应到源码中，就是 data/params文件，于是我将我的文件与我同事电脑上的这个文件进行了diff，其中有一项 use_mailer_queue。不成功： 'use_mailer_queue' => '1', 成功的'use_mailer_queue' => 0, 于是将不成功的修改为 0，结果再尝试Test， data/mailer.testfile中已经有信息了，将 mail_delivery_method修改为SMTP，也能正常发送邮件了！

ZT文萃 2013-09-27 14:18 发表评论

Tomcat下使用war包发布项目

ZT文萃 — Thu, 19 Sep 2013 05:04:00 GMT

From：

http://blog.csdn.net/wy818/article/details/7240294

ZT文萃 2013-09-19 13:04 发表评论

Java MessageFormat.format格式化字符串大括号以及单引号问题

ZT文萃 — Tue, 17 Sep 2013 04:35:00 GMT

http://blog.csdn.net/jeamking/article/details/7226656

在MessageFormat.format方法中组装jason数据字符串：{code:"w1",des:"w2"}，起止分别有左大括号和右大括号。方法是将单引号把大括号包含起来。如下：

String responseTemplate = "'{'code:\"{0}\",des:\"{1}\"'}'";

System.out.println(MessageFormat.format(responseTemplate, "w1","w2"));

如果格式化字符串中包含单引号，处理方法是用2个单引号进行转义：

String responseTemplate = "'{'code:''{0}'',des:''{1}'''}'";
System.out.println(MessageFormat.format(responseTemplate, "w1","w2"));

处理结果：{code:'w1',des:'w2'}

ZT文萃 2013-09-17 12:35 发表评论

java保留两位小数

ZT文萃 — Tue, 17 Sep 2013 04:22:00 GMT

java保留两位小数问题：

方式一：

四舍五入
double   f   =   111231.5585;
BigDecimal   b   =   new   BigDecimal(f);
double   f1   =   b.setScale(2,   BigDecimal.ROUND_HALF_UP).doubleValue();
保留两位小数
---------------------------------------------------------------

方式二：

java.text.DecimalFormat df =new java.text.DecimalFormat("#.00");
df.format(你要格式化的数字);

例：new java.text.DecimalFormat("#.00").format(3.1415926)

#.00 表示两位小数 #.0000四位小数以此类推...

方式三：

double d = 3.1415926;

String result = String .format("%.2f");

%.2f %. 表示小数点前任意位数 2 表示两位小数格式后的结果为f 表示浮点型

方式四：

NumberFormat ddf1=NumberFormat.getNumberInstance() ;

void setMaximumFractionDigits(int digits)
digits 显示的数字位数
为格式化对象设定小数点后的显示的最多位,显示的最后位是舍入的

import java.text.* ;
import java.math.* ;
class TT
{
public static void main(String args[])
{ double x=23.5455;
NumberFormat ddf1=NumberFormat.getNumberInstance() ;

ddf1.setMaximumFractionDigits(2);
String s= ddf1.format(x) ;
System.out.print(s);
}
}

ZT文萃 2013-09-17 12:22 发表评论

BlogJava-ZT文萃-随笔分类-中间件

谈谈hashCode

hashCode的作用

hashCode对于一个对象的重要性

hashCode与equals

转帖：Java邮件开发-----电子邮件的基本概念介绍

转帖：渐析java的浅拷贝和深拷贝

转帖：再解Java中的String

Class的getResource方法

Class.getResource()

Apache Common HttpClient使用之七种武器

httpclient的一些学习心得

Java程序运行时间的计算

java中计算两个时间差

在 Liberty 集群中共享内存网格数据

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

介绍

WebSphere Liberty Profile Server 介绍

WebSphere eXtreme Scale 介绍

前提

安装配置

安装 IBM HTTP 服务器及插件

图 1. 安装成功界面

安装 Liberty

图 2. Liberty 安装界面

安装 WebSphere eXtreme Scale

图 3. WebSphere eXtreme Scale 安装界面

创建 Liberty 服务器

图 4. Liberty 服务器创建界面

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

配置 Liberty 服务器

清单 1. Feature 添加示例

清单 2. HTTP 端口修改示例

清单 3. XS Server 配置示例

清单 4. deployment.xml 示例

清单 5. objectgrid.xml 示例

清单 6. httpSession 重用设定示例

图 6. Liberty 服务器导入界面

创建部署测试程序

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

在 Liberty 集群中共享内存网格数据测试页面 !

计数器会在每次页面加载时加 1

计数器 = <%=count%>

页面服务器 : <%= System.getProperty("wlp.server.name") %>

图 7. 测试程序部署界面

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

配置 HTTP 服务器

图 8. Jconsole 启动命令界面

图 9. Jconsole 启动界面

图 10. 配置文件生成界面

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

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

测试

访问测试程序

图 11. Test002 访问界面

图 12. Test003 访问界面

图 13. Test003 计数器增加界面

参考资料

websphere liberty 装配 部署

新一代轻量级应用服务器 — WebSphere Liberty Profile Server 介绍

什么是 WebSphere Liberty Profile Server ？

初探 WebSphere Liberty Profile Server

快速安装

图 1. 安装 Liberty 开发工具

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

图 3. 选择 Liberty 的安装位置

图 4. 空白的 Liberty 服务器

图 5. 创建 Liberty 服务器

图 6. Liberty 服务器概览

清单 1. Liberty 启动日志

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

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

图 8. Features 列表

简化服务器配置

灵活的服务器配置

图 9. 灵活配置

应用部署

图 10. 应用部署目录

动态加载模块

图 11. 动态化加载

websphere liberty 装配部署