BlogJava-.№爱の冰封-文章分类-J2EE

大型B/S系统的并发问题

冰封的爱 — Tue, 22 Apr 2008 06:03:00 GMT

一个小型的网站，比如个人网站，可以使用最简单的html静态页面就实现了，配合一些图片达到美化效果，所有的页面均存放在一个目录下，这样的网站对系统架构、性能的要求都很简单，随着互联网业务的不断丰富，网站相关的技术经过这些年的发展，已经细分到很细的方方面面，尤其对于大型网站来说，所采用的技术更是涉及面非常广，从硬件到软件、编程语言、数据库、WebServer、防火墙等各个领域都有了很高的要求，已经不是原来简单的html静态网站所能比拟的。
　　
　　大型网站，比如门户网站。在面对大量用户访问、高并发请求方面，基本的解决方案集中在这样几个环节：使用高性能的服务器、高性能的数据库、高效率的编程语言、还有高性能的Web容器。但是除了这几个方面，还没法根本解决大型网站面临的高负载和高并发问题。
　　
　　上面提供的几个解决思路在一定程度上也意味着更大的投入，并且这样的解决思路具备瓶颈，没有很好的扩展性，下面我从低成本、高性能和高扩张性的角度来说说我的一些经验。
　　
　　1、HTML静态化
　　其实大家都知道，效率最高、消耗最小的就是纯静态化的html页面，所以我们尽可能使我们的网站上的页面采用静态页面来实现，这个最简单的方法其实也是最有效的方法。但是对于大量内容并且频繁更新的网站，我们无法全部手动去挨个实现，于是出现了我们常见的信息发布系统CMS，像我们常访问的各个门户站点的新闻频道，甚至他们的其他频道，都是通过信息发布系统来管理和实现的，信息发布系统可以实现最简单的信息录入自动生成静态页面，还能具备频道管理、权限管理、自动抓取等功能，对于一个大型网站来说，拥有一套高效、可管理的CMS是必不可少的。
　　
　　除了门户和信息发布类型的网站，对于交互性要求很高的社区类型网站来说，尽可能的静态化也是提高性能的必要手段，将社区内的帖子、文章进行实时的静态化，有更新的时候再重新静态化也是大量使用的策略，像Mop的大杂烩就是使用了这样的策略，网易社区等也是如此。
　　
　　同时，html静态化也是某些缓存策略使用的手段，对于系统中频繁使用数据库查询但是内容更新很小的应用，可以考虑使用html静态化来实现，比如论坛中论坛的公用设置信息，这些信息目前的主流论坛都可以进行后台管理并且存储再数据库中，这些信息其实大量被前台程序调用，但是更新频率很小，可以考虑将这部分内容进行后台更新的时候进行静态化，这样避免了大量的数据库访问请求。
　　
　　2、图片服务器分离
　　大家知道，对于Web 服务器来说，不管是Apache、IIS还是其他容器，图片是最消耗资源的，于是我们有必要将图片与页面进行分离，这是基本上大型网站都会采用的策略，他们都有独立的图片服务器，甚至很多台图片服务器。这样的架构可以降低提供页面访问请求的服务器系统压力，并且可以保证系统不会因为图片问题而崩溃，在应用服务器和图片服务器上，可以进行不同的配置优化，比如apache在配置ContentType的时候可以尽量少支持，尽可能少的LoadModule，保证更高的系统消耗和执行效率。
　　
　　3、数据库集群和库表散列
　　大型网站都有复杂的应用，这些应用必须使用数据库，那么在面对大量访问的时候，数据库的瓶颈很快就能显现出来，这时一台数据库将很快无法满足应用，于是我们需要使用数据库集群或者库表散列。
　　
　　在数据库集群方面，很多数据库都有自己的解决方案，Oracle、Sybase等都有很好的方案，常用的MySQL提供的Master/Slave也是类似的方案，您使用了什么样的DB，就参考相应的解决方案来实施即可。
　　
　　上面提到的数据库集群由于在架构、成本、扩张性方面都会受到所采用DB类型的限制，于是我们需要从应用程序的角度来考虑改善系统架构，库表散列是常用并且最有效的解决方案。我们在应用程序中安装业务和应用或者功能模块将数据库进行分离，不同的模块对应不同的数据库或者表，再按照一定的策略对某个页面或者功能进行更小的数据库散列，比如用户表，按照用户ID进行表散列，这样就能够低成本的提升系统的性能并且有很好的扩展性。sohu的论坛就是采用了这样的架构，将论坛的用户、设置、帖子等信息进行数据库分离，然后对帖子、用户按照板块和ID进行散列数据库和表，最终可以在配置文件中进行简单的配置便能让系统随时增加一台低成本的数据库进来补充系统性能。
　　
　　4、缓存
　　缓存一词搞技术的都接触过，很多地方用到缓存。网站架构和网站开发中的缓存也是非常重要。这里先讲述最基本的两种缓存。高级和分布式的缓存在后面讲述。
　　架构方面的缓存，对Apache比较熟悉的人都能知道Apache提供了自己的缓存模块，也可以使用外加的Squid模块进行缓存，这两种方式均可以有效的提高Apache的访问响应能力。
　　网站程序开发方面的缓存，Linux上提供的Memory Cache是常用的缓存接口，可以在web开发中使用，比如用Java开发的时候就可以调用MemoryCache对一些数据进行缓存和通讯共享，一些大型社区使用了这样的架构。另外，在使用web语言开发的时候，各种语言基本都有自己的缓存模块和方法，PHP有Pear的Cache模块，Java就更多了，.net不是很熟悉，相信也肯定有。
　　
　　5、镜像
　　镜像是大型网站常采用的提高性能和数据安全性的方式，镜像的技术可以解决不同网络接入商和地域带来的用户访问速度差异，比如ChinaNet和EduNet之间的差异就促使了很多网站在教育网内搭建镜像站点，数据进行定时更新或者实时更新。在镜像的细节技术方面，这里不阐述太深，有很多专业的现成的解决架构和产品可选。也有廉价的通过软件实现的思路，比如Linux上的 rsync等工具。
　　
　　6、负载均衡
　　负载均衡将是大型网站解决高负荷访问和大量并发请求采用的终极解决办法。
　　负载均衡技术发展了多年，有很多专业的服务提供商和产品可以选择，我个人接触过一些解决方法，其中有两个架构可以给大家做参考。
　　硬件四层交换
　　第四层交换使用第三层和第四层信息包的报头信息，根据应用区间识别业务流，将整个区间段的业务流分配到合适的应用服务器进行处理。　第四层交换功能就象是虚IP，指向物理服务器。它传输的业务服从的协议多种多样，有HTTP、FTP、NFS、Telnet或其他协议。这些业务在物理服务器基础上，需要复杂的载量平衡算法。在IP世界，业务类型由终端TCP或UDP端口地址来决定，在第四层交换中的应用区间则由源端和终端IP地址、TCP和UDP端口共同决定。
　　在硬件四层交换产品领域，有一些知名的产品可以选择，比如Alteon、F5等，这些产品很昂贵，但是物有所值，能够提供非常优秀的性能和很灵活的管理能力。Yahoo中国当初接近2000台服务器使用了三四台Alteon就搞定了。
　　
　　软件四层交换
　　大家知道了硬件四层交换机的原理后，基于OSI模型来实现的软件四层交换也就应运而生，这样的解决方案实现的原理一致，不过性能稍差。但是满足一定量的压力还是游刃有余的，有人说软件实现方式其实更灵活，处理能力完全看你配置的熟悉能力。
　　软件四层交换我们可以使用Linux上常用的LVS来解决，LVS就是Linux Virtual Server，他提供了基于心跳线heartbeat的实时灾难应对解决方案，提高系统的鲁棒性，同时可供了灵活的虚拟VIP配置和管理功能，可以同时满足多种应用需求，这对于分布式的系统来说必不可少。

冰封的爱 2008-04-22 14:03 发表评论

定义一个内部类的比较器，比较两个对象并且进行排序

冰封的爱 — Wed, 02 Jan 2008 02:30:00 GMT

// 内部类定义一个比较器

public class ContentComparator implements Comparator {
  public int compare(Object o1, Object o2) {
   MedicineCountForm c1 = (MedicineCountForm)o1;
   MedicineCountForm c2 = (MedicineCountForm)o2;
   String tm1 = String.valueOf(c1.getCount());
   String tm2 = String.valueOf(c2.getCount());
   if (Integer.parseInt(tm1) > Integer.parseInt(tm2))
    return -1;
   else if (Integer.parseInt(tm1) < Integer.parseInt(tm2))
    return 1;
   else
    return 0;
  }
}

冰封的爱 2008-01-02 10:30 发表评论

Spring+hibernate+DWR整合

冰封的爱 — Fri, 12 Oct 2007 03:17:00 GMT

摘要: 首先，建一个web project,然后添加对hibernate和spring的支持，我们使用的是hibernate3.1和spring2.0,然后导入dwr.jar和commons-pool-1.3.jar(不知道myeclipse怎么搞的，添加Spring功能支持的时候就有了commons-dbcp.jar，居然没有其依赖的commons-pool-x.jar，只好单独添加了，另外，... 阅读全文

冰封的爱 2007-10-12 11:17 发表评论

获得汉字拼音首字母(java版)

冰封的爱 — Tue, 09 Oct 2007 01:04:00 GMT

摘要: public class ChineseCharacterUtil { public ChineseCharacterUtil() { } public static void... 阅读全文

冰封的爱 2007-10-09 09:04 发表评论

根据拼音首字母查询人名(C#版)

冰封的爱 — Sun, 30 Sep 2007 02:33:00 GMT

摘要: using System; namespace Test { class Class1 { /** *//**//// <... 阅读全文

冰封的爱 2007-09-30 10:33 发表评论

java开源项目

冰封的爱 — Fri, 07 Sep 2007 00:47:00 GMT

摘要: Spring Framework 【Java开源 J2EE框架】 Spring 是一个解决了许多在J2EE开发中常见的问题的强大框架。 Spring提供了管理业务对象的一致方法并且鼓励了注入对接口编程而不是对类编程的良好习惯。Spring的架构基础是基于使用JavaBean属性的 Inversion of Control容器。然而，这仅仅是完整图景中的一部分：Sp... 阅读全文

冰封的爱 2007-09-07 08:47 发表评论

在 Java 应用程序中计划重复执行的任务(转)

冰封的爱 — Mon, 06 Aug 2007 05:30:00 GMT

摘要: 介绍 Java 语言中 Timer 类的一种简洁用法所有类型的 Java 应用程序一般都需要计划重复执行的任务。企业应用程序需要计划每日的日志或者晚间批处理过程。一个 J2SE或者 J2ME 日历应用程序需要根据用户的约定计划闹铃时间。不过，标准的调度类 Timer 和 TimerTask 没有足够的灵活性，无法支持通常需要的计划任务类型。在本文中，Java 开发人员 Tom White 向您... 阅读全文

冰封的爱 2007-08-06 13:30 发表评论

如何使用ejb3持久化中callback

冰封的爱 — Mon, 30 Jul 2007 03:20:00 GMT

CallBack在EJb3 spec中不过是一小章节，似乎不是很引人注意，刚开始，也没有引起我们的多少注意，然而，在开发中，当我们实际运用它来解决问题的时候，发现它的实际作用还是很大的。其实，从根本来说，CallBack相当于ORM Engine和用户设计的Domain Model(可持久话的模型）之间一道天然的钩子，通过它，设计者可以放入很多类似横切面的关注点。下面给出一个真实的例子：
银行需要对涉及帐务每一个操作实行录入，复核机制。假设操作涉及实体有Customer,Account。录入纪录实体为InputRecord, 复核纪录为:ConfirmRecord.用户为User。
初步设计时，这些类的骨干代码为:

        @Entity
class User{
@Id
long id=-1;
String userName;
String passwordHex;
}
@Entity
class Customer{
@Id
long id=-1;
String name;
@OneToOne
InputRecord inputRecord;
@OneToOne
ConfirmRecord confirmRecord;
}
@Entity
class Account{
@Id
long id=-1;
String accountName;
String accountNo;
@OneToOne
InputRecord inputRecord;
@OneToOne
ConfirmRecord confirmRecord;
}
//Not a persistence Entity
abstract class OperationRecord{
@Id
long id=-1;
@ManyToOne
User user;
Date date;
}
@Entity
class InputRecord extends OperationRecord{
//nothing ,just define a concrete class and table
}
@Entity
class ConfirmRecord extends OperationRecord{
//nothing ,just define a concrete class and table
}

上面这段代码有几点需要说明一下：
1） OperationRecord没有声明为Entity，这里没有用到继承策略，因为对象继承与数据库之间的映射并不是很好，在一般设计中，我是很少使用它的，继承和数据共享两者是没有什么关联的，因为在内存中，他们的实例始终是互补相干的数据副本，单纯从数据来说，分别对应到不同的表中来存储就是最好的映射，而行为的继承在JVM中可以得到完全的体现。基于这个认识，InputRecord，ConfirmRecord仅仅起表明类型的作用。
2）从Account,Customer的代码中可以看出InputRecord，ConfirmRecord域是重复出现的，而且从需求来看，会有更多的实体需要这两个Field，从1)的分析中，很自然而然的抽取一个基类出来：

    abstract class ConfirmableEntity{
@OneToOne
InputRecord inputRecord;
@OneToOne
ConfirmRecord confirmRecord;
}
class Customer extends ConfirmableEntity{
}

到这里，一个对需求的思考同时也出现了，在什么地方纪录操作记录呢？ AOP? TemplateMethod? 很多种可选的方案。然而，从代码量和简洁性来说，CallBack是好的。采用CallBack的基本骨干代码如下：

    abstract class ConfirmableEntity{
@PostPersist
public void registerInputRecord(){
//retrieve current user
User currentUser = UserHolder.getCurrentUser();
//create an inputRecord for current User
InputRecord inputRec = new InputRecord(currentUser);
setInputRecord(inputRec);
}
}

所有的需要录入复核得实体只要继承自这个ConfirmableEntity，不仅获得数据，同样获得了相应的行为。这么一段代码对于他们来说基本上时透明的。（有点类似AOP？）上面的代码中，UserHolder是一个非常有意思的设计，用户的保持一般有不同的需求，在Web中有Session，而在别的应用中就不一定使用这样的机制了，但不管如何，我们总归有在领域层提出获取当前操作用户的需求，一个很简单的设计会让很多事情变得简单，可以把UserHolder当作一个隔离领域层和具体App层用户管理的接口，大家如果对它得出现比较有诧异的话可以再具体讨论一下.

值得一说的是，这样的设计对于以后的可扩展也带来了巨大的影响，比如，用户提出需求：对于已经复核得操作纪录不能再被修改，删除。那么我们只要再在ConfirmableEntity上写一个CallBack即可：

    abstract class ConfirmableEntity{
@PostPersist
public void registerInputRecord(){
//retrieve current user
User currentUser = UserHolder.getCurrentUser();
//create an inputRecord for current User
InputRecord inputRec = new InputRecord(currentUser);
setInputRecord(inputRec);
}
@PreUpdate
@PreRemove
public void check(){
if(getConfirmRecord()!=null && getConfirmRecord().getId()>0 )
throw new SecurityException("can not update/remove confirmed record");
}
}

冰封的爱 2007-07-30 11:20 发表评论

EJB3 QL查询

冰封的爱 — Mon, 30 Jul 2007 03:11:00 GMT

EJB3 QL查询

EJB3的查询语言是一种和SQL非常类似的中间性和对象化查询语言。它可以被编译成不同的底层数据库能接受的SQL，从而屏蔽不同数据库的差异，确保用EJB3 QL查询语言编写的代码可在不同的数据库上运行。比起EJB 2.1的查询语言，EJB3可以运行期构造，支持多态，远远比EJB 2.1的查询更灵活和功能强大。在程序中使用EJB3 QL可以使用大写(SELECT)或者小写(select)，但不要大小写(比如:Select)混合使用。

Query接口

javax.persistence.Query是EJB3查询操作的接口。进行查询，首先要通过EntityManager 获得Query对象。

public Query createQuery(String ejbqlString);

下面我们做一个最简单的查询，查询所有的com.redsoft.samples.Order类。

final Query query = entityManager.createQuery( "select o from Order o");
final List result = query.getResultList();
final Iterator iterator = result.iterator();
while( iterator.hasNext() ){
//　处理Order
}

注意"from Order"。"Order"在EJB3查询中称为com.redsoft.samples.Order类的abstract schema Type。查询Entity在EJB3 QL中都是针对Entity的Abstract Schema Type进行查询。在同一个EntityManagerFactory中，不允许同时有两个Abstract Schema Type相同的Entity类。比如不允许同时有com.redsoft.samples.Order和com.redsoft.foo.Order。　　

Query返回一个List的集合结果，我们可以用Iterator或者List.get( int )的方法来获得每个符合条件的Entity。Liberator EJB3 Persistence运行环境的Query查询在构造Query的时候的只是把EJB3 QL编译成相应的SQL，但并不执行。只有当应用代码第一次调用Iterator.next(),Iterator.hasNext()或者List.get( int )方法的时候,编译后的SQL才会被真正的执行。

在Liberator EJB3 Persistence运行环境返回的结果集合中，并不保存所有的结果，而只是保持一个指向JDBC ResultSet或者缓存ResultSet的一个行(row)指针。只有当用户确实需要获得Entity实例的时候，才会从ResultSet中获取数据并填充到Entity实例中返回给应用。

如果查询结果结合中包含所有符合条件的Entity, Liberator EJB3 Persistence运行环境默认会自动缓存每次查询的结果。这样下次同样的查询操作就无需访问数据库，而直接从缓存中返回结果集合。但如果在下次查询操作之前，有针对被缓存的Entity类进行update/insert/delete操作，则缓存的结果集合会自动被清空，这样下次查询就会从数据库获得数据，确保查询总是获得正确的结果，避免缓存脏数据。

有时候查询会返回海量的数据。Liberator EJB3运行环境采用了自适应的弱引用POJO管理机制，可以处理海量的数据。在我们的测试中和客户的环境可以处千万级别的数据量。但在处理大数据量的时候，注意关闭对集合结果的缓存。

// 假设返回的结果数量巨大
final Query query = entityManager.createQuery( "select o from Order o");
// 关闭对查询结果的缓存
query.setHint( Constants.QUERY_RESULT_CACHE, "false");
final List result = query.getResultList();
final Iterator iterator = result.iterator();
// 这里我们可以处理海量的数据
while( iterator.hasNext() ){
//　处理Order
}

简单查询

下面是一个简单查询的例子，可以看到和SQL的使用方法很类似。

final Query query = entityManager.createQuery( "select o from Order o where o.id = 1");
final Query query = entityManager.createQuery( "select o from Order o where o.id = 1 and o.confirm = 'true' ");
final Query query = entityManager.createQuery( "select o from Order o where o.id = 1 or o.customer = 'foo' ");
// address是Order类上的一个对象变量属性，Address有一个streetNumber的属性
final Query query = entityManager.createQuery( "select o from Order o where o.address.streetNumber >= 123" );

注意条件语句中查询的是Entity的属性，属性的名字需要和Entity中的属性变量名字一致。

使用参数查询

参数查询也和SQL中的参数查询类似。EJB3 QL支持两种方式的参数定义方式: 命名参数和位置参数。在同一个查询中只允许使用一种参数定义方式。

命名参数:

final Query query = entityManager.createQuery( "select o from Order o where o.id = :myId");
// 设置查询中的参数
query.setParameter( "myId", 2 );
// 可以使用多个参数
final Query query = entityManager.createQuery( "select o from Order o where o.id = :myId and o.customer = :customerName" );
// 设置查询中的参数
query.setParameter( "myId", 2 );
query.setParameter( "customerName", "foo" );

注意不允许在同一个查询中使用两个相同名字的命名参数。

位置参数：

final Query query = entityManager.createQuery( "select o from Order o where o.id = ?1");
// 设置查询中的参数
query.setParameter( 1, 2 );// 1表示第一个参数，2是参数的值
//或者
final Query query = entityManager.createQuery( "select o from Order o where o.id = ?1").setParameter( 1, 2 );
// 可以使用多个参数
final Query query = entityManager.createQuery( "select o from Order o where o.id = ?1 and o.customer = ?2" );
// 设置查询中的参数
query.setParameter( 1, 2 );
query.setParameter( 2, "foo" );

如果在未来需要在不同的EJB3 运行环境中运行，请使用位置参数，保证应用是可移植的。

排序(order by)

下面是一个简单查询的例子，可以看到和SQL的使用方法很类似。"ASC"和"DESC"分别为升序和降序，如果不显式注明，EJB3 QL中默认为asc升序。

// 不注明的话，默认为asc为升序,
final Query query = entityManager.createQuery( "select o from Order o order by o.id");
final Query query = entityManager.createQuery( "select o from Order o order by o.address.streetNumber desc");// desc为降序
final Query query = entityManager.createQuery( "select o from Order o order by o.id, o.address.streetNumber");

查询部分属性

在前面的例子中，都是对针对Entity类的查询，返回的也是被查询的Entity类的实体。EJB3 QL也允许我们直接查询返回我们需要的属性，而不是返回整个Entity。在一些Entity中属性特别多的情况，这样的查询可以提高性能。

// 直接查询我们感兴趣的属性(列）
final Query query = entityManager.createQuery( "select o.id, o.customerName, o.address.streetNumber from Order o order by o.id");
// 集合中的不再是Order,而是一个Object[]对象数组
final List result = query.getResultList();
// 第一个行
Object[] row = result.get( 0 );
// 数组中的第一个值是id
int id = Integer.parseInt( row[0].toString() );
String customerName = row[1].toString();
String streetNumber = Integer.parseInt( row[2].toString() );

查询中使用构造器(Constructor)

EJB3 QL支持将查询的属性结果直接作为一个java class的构造器参数，并产生实体作为结果返回。

// 我们把需要的三个属性作为一个class( OrderHolder )的构造器参数，并使用new函数。
Query query = entityManager.createQuery("select new com.redsoft.ejb3.dummy.OrderHolder (   o.id, o.vender, o.partNumber  )  FROM Order AS o");
// 集合中的结果是OrderHolder
List result = query.getResultList();

该java class不需要是Entity Class。NEW要求java class使用全名。

聚合查询(Aggregation)

象大部分的SQL一样,EJB3 QL也支持查询中的聚合函数。目前EJB QL支持的聚合函数包括：

AVG
SUM
COUNT
MAX
MIN

final Query query = entityManager.createQuery( "select MAX( o.id ) from Order where o.customerName='foo'");
// 如果我们知道结果是单个，我们可以用getSingleResult()获得结果
final Object result = query.getSingleResult();
// 由于Order中id的类型为long,
final Long max = (Long)result;
// 在一些数据库中max函数返回的结果的类型不一定于id对应的列的类型相符，更安全的方式可以采用string来转型
fina long max = Long.parseLong( result.toString() );

聚合函数也可以作为被查询的一个属性返回。

// 返回所有的订单的生产厂商和他们的订单价值总额
final Query query
= entityManager.createQuery( "select o.vender, sum(o.amount) FROM Order o　group by o.vender");");

和SQL一样，如果聚合函数不是select...from的唯一一个返回列，需要使用"GROUP BY"语句。"GROUP BY"应该包含select语句中除了聚合函数外的所有属性。

// 返回所有的订单的生产厂商的的名字，货物号码和每种货物的订单价值总额
// 注意group by后面必须包含o.vender和o.partNumber
final Query query
= entityManager.createQuery( "select o.vender, o.partNumber, sum(o.amount) FROM Order o　group by o.vender，o.partNumber");

如果还需要加上查询条件，需要使用"HAVING"条件语句而不是"WHERE"语句。

// 返回所有的订单的生产厂商是"foo"的货物号码和每种货物的订单价值总额
// 这里"having o.vender = 'foo'为条件
final Query query
= entityManager.createQuery( "select o.vender, o.partNumber, sum(o.amount) FROM Order o　
group by o.vender，o.partNumber having o.vender='foo'");

在"HAVING"语句里可以跟"WHERE"语句一样使用参数。

// 返回所有的订单的生产厂商是"foo"的货物号码和每种货物的订单价值总额
// 这里"having o.vender = 'foo'为条件
final Query query
= entityManager.createQuery( "select o.vender, o.partNumber, sum(o.amount) FROM Order o　
group by o.vender，o.partNumber having o.vender=?1");
query.setParameter( 1, "foo" );
final List result = query.getResultList();

关联(join)

在EJB3 QL中，大部分的情况下，使用对象属性都隐含了关联(join)。例如在以下查询中：

final Query query = entityManager.createQuery( "select o from Order o
where o.address.streetNumber=2000 order by o.id");

当这个句EJB3 QL编译成以下的SQL时就会自动包含了关联,EJB3 QL编译成SQL时关联默认取左关联(left join)。

select o.id, o.vender, o.partNumber, o.amount, addressTable.id, addressTable.streetNumber
from orderTable as o left join addressTable where addressTable.streetNumber = 2000

但在一些情况下，我们仍然需要对关联做精确的控制。因此EJB3 QL仍然支持和SQL中类似的关联语法：

left out join/left join
inner join
left join/inner join fetch

left join, left out join等义，都是允许符合条件的右边表达式中的Entiies为空。

// 返回所有地址为2000的Order纪录，不管Order中是否有OrderItem
final Query query = entityManager.createQuery( "select o from Order o
left join o.orderItems where o.address.streetNumber=2000 order by o.id");

由于EJB3 QL默认采用left join。这样的查询和以下的EJB3 QL其实是等价的。

// 返回所有地址为2000的Order纪录，不管Order中是否有OrderItem
final Query query = entityManager.createQuery( "select o from Order o
where o.address.streetNumber=2000 order by o.id");

需要显式使用left join/left outer join的情况会比较少。

inner join要求右边的表达式必须返回Entities。

// 返回所有地址为2000的Order纪录，Order中必须有OrderItem
final Query query = entityManager.createQuery( "select o from Order o
inner join o.orderItems where o.address.streetNumber=2000 order by o.id");

left/left out/inner join fetch提供了一种灵活的查询加载方式来提高查询的性能。在默认的查询中，Entity中的集合属性默认不会被关联，集合属性默认是缓加载( lazy-load )。

``` // 默认EJB3 QL编译后不关联集合属性变量(orderItems)对应的表
final Query query = entityManager.createQuery( "select o from Order o
inner join o.orderItems where o.address.streetNumber=2000 order by o.id");
final List result = query.getResultList();
// 这时获得Order实体中orderItems( 集合属性变量 )为空
final Order order = (Order)result.get( 0 )
// 当应用需要时，EJB3 Runtime才会执行一条SQL语句来加载属于当前Order的OrderItems
Collection orderItems = order.getOrderItems();

这样的查询性能上有不足的地方。为了查询N个Order，我们需要一条SQL语句获得所有的Order的原始/对象属性，但需要另外N条语句获得每个Order的orderItems集合属性。为了避免N+1的性能问题，我们可以利用join fetch一次过用一条SQL语句把Order的所有信息查询出来。

// 返回所有地址为2000的Order纪录，Order中必须有OrderItem
final Query query = entityManager.createQuery( "select o from Order o
inner join fetch o.orderItems where o.address.streetNumber=2000 order by o.id");

由于使用了fetch,这个查询只会产生一条SQL语句，比原来需要N+1条SQL语句在性能上有了极大的提升。

比较Entity

在查询中使用参数查询时，参数类型除了String, 原始数据类型( int, double等)和它们的对象类型( Integer, Double等),也可以是Entity的实例。

final Query query = entityManager.createQuery( "select o from Order o where o.address = ?1 order by o.id");
final Address address = new Address( 2001, "foo street", "foo city", "foo province" );
// 直接把address对象作为参数。
query.setParameter( 1, address );

批量更新(Batch Update)

EJB3 QL支持批量更新。

Query query = managerNew.createQuery("update Order as o set o.vender=:newvender,  o.partNumber='fooPart' where o.vender = 'foo'");
query.setParameter("newvender", "barVender");
// update的记录数
int result = query.executeUpdate();

批量删除(Batch Remove)

EJB3 QL支持批量删除。

Query query = managerNew.createQuery("DELETE FROM Order");
int result = query.executeUpdate();
Query query = managerNew.createQuery("DELETE FROM Order AS o WHERE o.vender='redsoft'");
int result = query.executeUpdate();

使用操作符NOT

// 查询所有vender不等于"foo"的Order
Query query = managerNew.createQuery("SELECT FROM Order AS o WHERE not(o.vender='foo')");
List result = query.getResultList();
// 删除所有vender不等于"foo"的Order
Query query = managerNew.createQuery("DELETE FROM Order AS o WHERE not(o.vender='foo')");
int result = query.executeUpdate();

使用操作符BETWEEN

// 查询所有价值amount在５和10之间的(包含5,10)的Order
Query query = managerNew.createQuery("select o FROM Order AS o left join o.orderItems ot where o.amount BETWEEN 5 AND 10 order by o.vender desc");
List result = query.getResultList();

使用操作符IN

// 查询所有vender是"foo1", "foo2"或者"foo3"的Order
Query query = managerNew.createQuery("select o FROM Order AS o left join o.orderItems ot where o.vender in ( 'foo1', 'foo2', 'foo3' ) order by o.vender desc");
List result = query.getResultList();

使用操作符LIKE

// 查询所有vender以字符串"foo"开头的Order
Query query = managerNew.createQuery("select o FROM Order as o where o.vender like 'foo%' order by o.vender desc");
List result = query.getResultList();
// 查询所有vender以字符串"foo"结尾的Order
Query query = managerNew.createQuery("select o FROM Order as o where o.vender like '%foo' order by o.vender desc");
List result = query.getResultList();
// 可以结合NOT一起使用，比如查询所有vender不以以字符串"foo"结尾的Order
Query query = managerNew.createQuery("select o FROM Order as o where o.vender not like '%foo' order by o.vender desc");
List result = query.getResultList();
// 可以结合escape使用，比如查询所有vender以"foo"开始的Order并忽略'3'字符。
// 如果vender是"foo1", "foo2", "foo3"符合这个条件, 另外"3foo1", "f3oo4"也符合条件。
Query query = managerNew.createQuery("select o FROM Order as o where o.vender like '%foo' escape '3' order by o.vender desc");
List result = query.getResultList();

使用操作符IS NULL

// 查询所有没有地址的Order
Query query = managerNew.createQuery("select o FROM Order as o where o.address is null");
List result = query.getResultList();
// 查询所有地址非空的Order
Query query = managerNew.createQuery("select o FROM Order as o where o.address is not null");
List result = query.getResultList();

使用操作符IS EMPTY

IS EMPTY是针对集合属性(Collection)的操作符。可以和NOT一起使用。

// 查询orderItems集合为空的Order
Query query = managerNew.createQuery("select o FROM Order o where o.orderItems is empty by o.vender desc");
List result = query.getResultList();
// 查询orderItems集合非空的Order
Query query = managerNew.createQuery("select o FROM Order o where o.orderItems is not empty by o.vender desc");
List result = query.getResultList();

使用操作符EXISTS

[NOT]EXISTS需要和子查询配合使用。

Query query = manager.createQuery("select o FROM Order o where exists (select o from Order o where o.partNumber=?1) order by o.vender desc");
query.setParameter(1, "partNumber");
Query query = manager.createQuery("select o FROM Order o where o.vender='partNumber' and not exists (select o from Order o where o.partNumber=?1) order by o.vender desc");
query.setParameter(1, "partNumber");

使用操作符ALL/SOME/ANY

Query query = managerNew.createQuery("select emp from EmployeeA emp where emp.salary > all ( select m.salary from Manager m where m.department = emp.department)");
List result = query.getResultList();
Query query = managerNew.createQuery("select emp from EmployeeA emp where emp.salary > any ( select m.salary from Manager m where m.department = emp.department)");
List result = query.getResultList();
Query query = managerNew.createQuery("select emp from EmployeeA emp where emp.salary > some ( select m.salary from Manager m where m.department = emp.department)");
List result = query.getResultList();

字符串函数

EJB3 QL定义了内置函数方便使用。这些函数的使用方法和SQL中相应的函数方法类似。EJB3 QL中定义的字符串函数包括：

CONCAT　字符串拼接
SUBSTRING　字符串截取
TRIM 去掉空格
LOWER　转换成小写
UPPER　装换成大写
LENGTH 字符串长度
LOCATE 字符串定位

// concat将参数中的两个字符串并结成一个字符串,这里firstName是"foo", lastName是"bar"
Query query = entityManager.createQuery("select concat( o.owner.firstName, o.owner.lastName ) FROM Order AS o left outer join o.orderItems as oi where o.owner.firstName='foo'");
List result = query.getResultList();
assertEquals("foobar", result.get(0).toString());
// firstName是"fooBar",结果应该返回"oo"
Query query = entityManager.createQuery("select o.vender,substring( o.owner.firstName, 1, 3 ), o.owner.info.age FROM Order AS o left outer join o.orderItems as oi where o.owner.firstName='charles'");
List result = query.getResultList();
Object[] row1 = (Object[]) result.get(0);
assertEquals("oo", row1[1].toString());
// 获得"ar"在firstName中地起始位置
Query query = managerNew.createQuery("SELECT emp.firstName , emp.salary , locate( emp.firstName, 'ar') FROM EmployeeA as emp where emp.firstName='charles1111'");
List result = query.getResultList();

计算函数

EJB3 QL中定义的计算函数包括：

ABS　绝对值
SQRT 平方根
MOD 取余数
SIZE 取集合的数量

Query query = entityManager.createQuery("select o.vender, size( o.orderItems ) FROM Order o  where o.owner.firstName = 'charles' group by o.vender order by o.vender desc");
List result = query.getResultList();
// 函数也可以用在条件中
Query query = managerNew.createQuery("select o.vender, sum(o.amount) FROM Order AS o left join o.orderItems ot group by o.vender having size(o.orderItems) = 0 or lower( o.vender ) = 'foo' order by o.vender desc");
List result = query.getResultList();
// 取余数
Query query = managerNew.createQuery("select mod( o.owner.info.age, 10 ) FROM Order o where exists ( select o from Order o where o.partNumber= :name ) and o.vender='order1' and exists ( select o from Order o where o.amount= :name1 ) order by o.vender desc");

子查询

子查询可以用于WHERE和HAVING条件语句中。

Query query = managerNew.createQuery("select emp from EmployeeA as emp where ( select count(m) from Manager as m where m.department = emp.department) > 0 ");
List result = query.getResultList();

冰封的爱 2007-07-30 11:11 发表评论

mssql2000数据库使用备份还原造成的孤立用户和对象名‘XX’无效的解决办法

冰封的爱 — Tue, 24 Jul 2007 01:58:00 GMT

在使用数据库的过程中，经常会遇到数据库迁移或者数据迁移的问题，或者有突然的数据库损坏，这时需要从数据库的备份中直接恢复。但是，此时会出现问题，这里说明几种常见问题的解决方法。
一、孤立用户的问题
    比如，以前的数据库的很多表是用户test建立的，但是当我们恢复数据库后，test用户此时就成了孤立用户，没有与之对应的登陆用户名，哪怕你建立了一个test登录用户名，而且是以前的用户密码，用该用户登录后同样没办法操作以前属于test的用户表。
这个问题有两种办法解决。
    先说解决的前提条件。
    首先，要用备份文件还原数据库，我们这里的数据库名为testdb，里面有属于用户test的用户表。这个很容易了操作了，不多讲了，在企业管理器中很方便可以恢复。恢复后，就产生了孤立用户test。
    然后，用sa用户或者具有DBA权限的用户登录，创建一个test数据库登录用户，密码随便设置了，也可以和以前的保持一致。我们用它来对应孤立的test用户。
下面就有两种操作方法了，第一种就是改变对象的属主，第二种就是使登录用户和数据库的孤立用户对应起来。先说第一种方法。
1、修改对象属主
    就是将原本属于数据库用户test的用户表，修改为属于dbo的用户表；然后修改test登录用户的数据库为testdb,就可以直接使用test登录用户登录后对该数据库进行操作了。
使用的存储过程
sp_changeobjectowner [ @objname = ] 'object' , [ @newowner = ] 'owner'
参数说明
[ @objname = ] 'object'
当前数据库中现有表、视图、用户定义函数或存储过程的名称。object 是 nvarchar(776)，没有默认值。如果架构及其所有者具有相同的名称，则 object 可由现有对象所有者限定，格式为 existing_owner.object。
[ @newowner=] 'owner '
将成为对象的新所有者的安全帐户的名称。owner 的数据类型为 sysname，没有默认值。owner 必须是可访问当前数据库的有效数据库用户、服务器角色、Microsoft Windows 登录名或 Windows 组。如果新所有者是没有对应数据库级主体的 Windows 用户或 Windows 组，则将创建数据库用户。
实例：
以下示例将 authors 表的所有者更改为 dbo。
EXEC sp_changeobjectowner 'authors', 'dbo';
GO
    这个方法有个最大的缺点就是，当表的数量非常多，而且还有存储过程或者触发器之类的修改起来会非常麻烦，需要一个一个修改，所以，不提倡使用。现在有一个批量修改的存储过程。点击下载此sql文件-批量修改的存储过程或参考我的另一篇文章ms sql批量修改权限
  2、使登录用户和数据库的孤立用户对应起来
    其实我们建立了同样名称的数据库登录用户后，数据库中的表我们照样不能使用时因为sid的不同，就是系统登录表和数据库用户表中的用户名相同，单是sid字段，数据库中的还是以前旧系统的sid值，所以我们就要把它对应成我们新建的，数据库靠sid来识别用户。
    这里可以使用存储过程sp_change_users_login。它有三种动作，分别是report，update_one和auto_fix。
    运行sp_change_users_login 'report'，系统会列出当前数据库的孤立用户数。
    我们只需要选择当前数据库为testdb，然后运行
    sp_change_users_login 'update_one','test','test'
    系统就会提示修复了一个孤立用户。
    如果没有建立test的登录用户，还可以用
sp_change_users_login 'Auto_Fix', 'test', NULL, 'testpassword'
来创建一个登录用户名为test，密码为testpassword的用户与之对应。

    好了，到这里通常情况下，数据库对象得到访问问题已经解决了。如果有多个数据库中有同一个用户的数据表，只需要选择不同的数据库，执行update_one的那个就行了。

二、对象名 ‘xxxx’ 无效的问题

    这里可能会有人遇到对象名 ‘xxxx’无效的问题。系统表却不会产生这个问题，而用户表还要加上用户名，然后是表明才能访问，比如select * from author,会说对象名 author 无效，而用select * from test.author就可以访问，这个是用户首选身份的问题。

    解决很简单，就是察看test登录用户是否具有dba的权限或者系统管理的权限，有的话去掉就行了。
    因为如果用户有dba身份，那么它登陆后的默认表空间是dbo的系统表空间，所以去掉了之后，就会以正常的test表空间访问数据表了。

冰封的爱 2007-07-24 09:58 发表评论

JDK1.5新特性之Java Generics

冰封的爱 — Fri, 20 Jul 2007 08:49:00 GMT

摘要: 1 直观印象在JDK1.5之前的版本中，对于一个Collection类库中的容器类实例，可将任意类型对象加入其中（都被当作Object实例看待）；从容器中取出的对象也只是一个Object实例，需要将其强制转型为期待的类型，这种强制转型的运行时正确性由程序员自行保证。例如以下代码片断： &n... 阅读全文

冰封的爱 2007-07-20 16:49 发表评论

在 JBoss 4.0.5GA 上使用应用程序自己的 log4j 配置

冰封的爱 — Fri, 20 Jul 2007 08:44:00 GMT

1. 把 D:\jboss-4.0.5.GA\server\default\conf 里面的 log4j.xml 改名为 jboss-log4j.xml

2. 编辑 D:\jboss-4.0.5.GA\server\default\conf 里面的 jboss-service.xml 找到

   <mbean code="org.jboss.logging.Log4jService"
      name="jboss.system:type=Log4jService,service=Logging"
      xmbean-dd="resource:xmdesc/Log4jService-xmbean.xml">
      <attribute name="ConfigurationURL">resource:log4j.xmlattribute>

      <attribute name="Log4jQuietMode">trueattribute>

      <attribute name="RefreshPeriod">60attribute>
   mbean>

把 resource:log4j.xml 改为 resource:jboss-log4j.xml

3. 在自己的应用程序的 WEB-INF 目录中添加一个 jboss-web.xml 内容如下

xml version="1.0" encoding="UTF-8"?>
<jboss-web>
  <class-loading java2ClassLoadingCompliance="false">
  <loader-repository>
      ConfigTest:loader=ConfigTest.war
      <loader-repository-config>java2ParentDelegation=false
      loader-repository-config>
   loader-repository>
class-loading>
jboss-web>

4. 把 log4j.jar 加到 build-path 中

5. 在自己的应用程序的 WEB-INF 目录中添加一个 log4j.properties 内容如下：

#Global variable definition
LOG_LEVEL=DEBUG
LOG_FILE1=D:/jboss-4.0.5.GA/server/default/log/configtest1.log
LOG_FILE2=D:/jboss-4.0.5.GA/server/default/log/configtest2.log

# com.microsoft Logger
log4j.logger.org.stephencat.test=${LOG_LEVEL}, logfile1
log4j.additivity.org.stephencat.test=false

# com.microsoft Logger
log4j.logger.org.stephencat.cat=${LOG_LEVEL}, logfile2
log4j.additivity.org.stephencat.cat=false

# Console Appender Definition
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%-5p %c(%t) %x:%m%n
#log4j.appender.stdout.layout.ConversionPattern=%-5p:[%d{MM/dd HH:mm:ss,SSS}] %c(%t) %x:%m%n

# File Appender Definition
log4j.appender.logfile1=org.apache.log4j.DailyRollingFileAppender
log4j.appender.logfile1.File=${LOG_FILE1}
log4j.appender.logfile1.DatePattern='.'yyyy-MM-dd
log4j.appender.logfile1.layout=org.apache.log4j.PatternLayout
log4j.appender.logfile1.layout.ConversionPattern=%-5p:[%d{ISO8601}] %c(%t) %x:%m%n

# File Appender Definition
log4j.appender.logfile2=org.apache.log4j.DailyRollingFileAppender
log4j.appender.logfile2.File=${LOG_FILE2}
log4j.appender.logfile2.DatePattern='.'yyyy-MM-dd
log4j.appender.logfile2.layout=org.apache.log4j.PatternLayout
log4j.appender.logfile2.layout.ConversionPattern=%-5p:[%d{ISO8601}] %c(%t) %x:%m%n

这里分别定义了两个命名控件：
logfile1 对应命名空间（Java 代码中的 package）org.stephencat.test.*
logfile2 对应命名空间 org.stephencat.cat.*

6. 建立一个用于初始化的 InitServlet ，配置如下方法：

    /**
     * Initialization of the servlet.

     *
     * @throws ServletException if an error occure
     */
    public void init(ServletConfig config) throws ServletException {
        // Put your code here
        String isRelativePosition = config.getInitParameter("relativePosition");
        String logConfiguration = config.getInitParameter("logConfiguration");
        String root = "";
        if(isRelativePosition.equals("true")){
            root = config.getServletContext().getRealPath("/");
        }
        PropertyConfigurator.configure(root + logConfiguration);
    }

在 web.xml 配置这个 Servlet 的初始化参数（声明 log4j.properties 的位置）和启动优先级：

  <servlet>
    <description>This is the description of my J2EE componentdescription>
    <display-name>This is the display name of my J2EE componentdisplay-name>
    <servlet-name>InitServletservlet-name>
    <servlet-class>org.stephencat.test.InitServletservlet-class>
    <init-param>
        <param-name>relativePositionparam-name>
        <param-value>trueparam-value>
    init-param>
    <init-param>
        <param-name>logConfigurationparam-name>
        <param-value>WEB-INF/log4j.propertiesparam-value>
    init-param>
    <load-on-startup>1load-on-startup>
  servlet>

7. 在 org.stephencat.test.TestServlet （映射为 /test）中加入：

static Logger log = Logger.getLogger(TestServlet.class.getName());

8. 在 org.stephencat.cat.Test2Servlet（映射为 /test2）中加入：

static Logger log = Logger.getLogger(Test2Servlet.class.getName());

9. 重新启动 JBoss ，会出现如下错误消息：

11:53:21,549 ERROR [STDERR] log4j:ERROR A "org.jboss.logging.appender.FileAppend
er" object is not assignable to a "org.apache.log4j.Appender" variable.
11:53:21,549 ERROR [STDERR] log4j:ERROR The class "org.apache.log4j.Appender" wa
s loaded by
11:53:21,549 ERROR [STDERR] log4j:ERROR [WebappClassLoader
  delegate: false
  repositories:
    /WEB-INF/classes/
----------> Parent Classloader:
java.net.FactoryURLClassLoader@dcc4e2
] whereas object of type
11:53:21,549 ERROR [STDERR] log4j:ERROR "org.jboss.logging.appender.FileAppender
" was loaded by [org.jboss.system.server.NoAnnotationURLClassLoader@a97b0b].
11:53:21,549 ERROR [STDERR] log4j:ERROR Could not instantiate appender named "FI
LE".

这是因为自己的 log4j.jar 与 JBoss 的 log4jService 有点冲突，但这段错误消息实际上可以忽略

10. 访问以下网址：

http://localhost/..../test

http://localhost/..../test2

将分别在以下日志文件中输出日志内容：

D:/jboss-4.0.5.GA/server/default/log/configtest1.log
D:/jboss-4.0.5.GA/server/default/log/configtest2.log

文件名和物理路径可在 log4j.properties 中修改。

冰封的爱 2007-07-20 16:44 发表评论

Oracle PL/Sql循序渐进全面学习教程

冰封的爱 — Fri, 20 Jul 2007 06:58:00 GMT

摘要: 课程一 PL/SQL 基本查询与排序本课重点： 1、写SELECT语句进行数据库查询 2、进行数学运算 3、处理空值 4、使用别名ALIASES 5、连接列 6、在SQL PLUS中编辑缓冲，修改SQL SCRIPT... 阅读全文

冰封的爱 2007-07-20 14:58 发表评论

JBoss 4.0.2集群指南(二)----建立JMS集群服务

冰封的爱 — Fri, 20 Jul 2007 06:55:00 GMT

JBoss 4.0.2集群指南(二)

建立JMS集群服务

bromon原创　请尊重版权

　　本问讲解如何在jboss 4.0.2中建立jms消息集群服务器，本文以《jboss 4.0.2集群指南》为基础，请参照阅读。（http://blog.yam.com/bromon/archives/454467.html）

　　Jms集群的意义在于提升系统在处理消息时的并发能力，建立这样的集群，有三个步骤：

1、配置jms消息持久化所使用的数据库
2、配置分布式的jndi环境
3、配置分布式jms

　　在jboss4.0.2中，系统采用hibernate的方式来保存消息，所以能够兼容hibernate支持的所有数据库。Jboss默认采用hsql，在我们的例子中，将使用oracle9.2。首先需要配置连接到数据库的jndi数据源。方法是把doc\examples\jca下的oracle-ds.xml文件拷贝到server\all\farm下，并且修改其中的参数，保证数据库能够正确连接。Cluster启动后，该文件能够通过jboss的farm服务，自动拷贝到其他集群节点，并且自动部署。假设jndi数据源的名称为：GlobalDS将doc\examples\jms下的oracle-jdbc3-service.xml文件拷贝到server\all\deploy-hasingleton\jms目录下，并且删除该目录下的hsqldb-jdbc2-service.xml。修改oracle-jdbc3-service.xml，在56行左右指定name的值为数据源的名字：GlobalDS。这样系统会使用该数据源来保存jms消息。

使用如下命令启动boss: run –c all

启动完成后，正常情况下会发现oracle数据库中多出了三张表：
1、Jms_message_log  该表用于保存所有未处理的点对点消息，表结构是：
　　　 Messageid   消息id
　　　Destination  目的地
　　　Txid   事务id
　　　Txop   消息操作类型(a为新增，d为删除)
　　　Messageblob  消息内容

2、JMS_REFERENCE_LOG 用于保存所有未处理的topic消息，表结构是：
　　　Messageid
　　　Destination
　　　Txid
　　　Txop
　　　Messageblob
　　　Redelivered 消息是否被重发

3、JMS_TRANSACTION_LOG 用于保存处理消息过程中的一些重要的事务

　　需要注意的是，jboss 3.2之后就不在支持以文件形式保存消息，虽然这样最会比数据库操作快一倍以上。Jboss官方的解释是，使用文件会让系统不可靠。

　　客户端在发送jms消息的时候，首先需要向app server查询jndi，在jbosscluster中，jndi是作为一个分布式的singleton出现的。每个节点除了有自己的jndi环境以外，整个cluster还具有一些全局的jndi，客户端在进行jndi查询的时候，只需要向这个全局的jndi进行查询，cluster如果在全局jndi中找不到对应的jndi对象，就会按次序向每个节点询问，看他们的本地jndi中是否有匹配的对象，如果有则返回给客户，如果所有的节点都没有，则抛出异常。所有以all方式启动的jboss，都会打开1100端口，这个端口是全局jndi的入口，所有节点都是如此。

　　分布式的jndi有的节点有主次的区别，第一个启动的jboss是主服务器，它会保存所有的全局jndi，其他的节点如果收到客户查询jndi的请求后，都会向主服务器请求数据。如果主服务器不幸down掉，那么次节点会发现这个变化，然后启动自己的jndi环境，取代主服务器提供服务。

　　下面是配置jms的jndi，打开server\all\deploy-hasingleton\jms下的jbossmq-destinations-

service.xml文件，增加一个名为test的destination，如下：
name="jboss.mq.destination:service=Queue,name=test">

name="DestinationManager">jboss.mq:service=DestinationManager

　　为了预防主服务器down了之后丢失该jndi，所以最好在每个节点都进行这个配置。

　　在jboss 4.0.2的默认配置下，是不支持消息bean的集群的，要达到这个目的，必须下载一个jar包才能实现，可以从这里获得: http://blog.yam.com/bromon/archives/489460.html

　　得到这个jar文件后，将它命名为cdot-jbossx.jar　文件放到server\all\deploy\jms下。下面编写消息bean，它的功能很简单，接收到来自test队列的消息后，打印消息id。

public class TestJmsBean
implements MessageDrivenBean, MessageListener {
MessageDrivenContext messageDrivenContext;
public void ejbCreate() {
System.out.println("消息bean创建");
}

public void ejbRemove() {
}

public void onMessage(Message msg) {
    try
    {
      System.out.println(msg.getJMSMessageID());
    }catch(Exception e)
    {
      e.printStackTrace();
    }
}

public void setMessageDrivenContext(MessageDrivenContext messageDrivenContext) {
this.messageDrivenContext = messageDrivenContext;
}
}

　　把这个消息bean部署到server\all\farm目录下，它会被自动拷贝到cluster的其它节点，并且被自动部署，你会

看到如下部署信息：

　　上面显示通过farm的方式，部署了一个名为GlobalDS的连接池，以及一个名为TestJms的消息bean。

下面写个客户端来测试一下：

SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
      Properties p = new Properties();
      p.put(Context.INITIAL_CONTEXT_FACTORY,
            "org.jnp.interfaces.NamingContextFactory");
      p.put(Context.URL_PKG_PREFIXES, "jboss.naming:org.jnp.interfaces");
      p.put(Context.PROVIDER_URL, "172.16.0.116:1100"); // 全局jndi入口
      InitialContext ctx = new InitialContext(p);
      QueueConnectionFactory qcf = (QueueConnectionFactory) ctx.lookup(
          "ConnectionFactory");
      QueueConnection conn = qcf.createQueueConnection();

      Queue q = (Queue) ctx.lookup("queue/test");//查询名为test的destination
      QueueSession session = conn.createQueueSession(false,
          QueueSession.AUTO_ACKNOWLEDGE);
      conn.start();
      QueueSender sender = session.createSender(q);
      for (int i = 0; i < 10000; i++) {
        TextMessage tm = session.createTextMessage(sdf.format(new Date()));
        sender.send(tm, DeliveryMode.PERSISTENT, 4, 0);//发送持久化消息
        System.out.print("第" + i);
      }

      conn.stop();
      session.close();
      conn.close();

　　执行一下，可以看到每个节点都创建了若干个消息bean，同时在处理消息，任意关闭一个次服务器，系统会自动fail over。查看Jms_message_log数据表，里面没有任何数据，表示所有的消息都已经被处理。
Jboss的jms cluster功能与webspheremq比较起来，是非常简陋的，可以配置的地方也很少，毕竟是免费的东西。Jboss的论坛上透露，在jboss 6.0中将会有全新的jbossmessaging服务，不知要等到何年何月。针对这个cluster，我做过简单的测试，800万左右的消息数量，无一丢失，应该说还算比较可靠。响应时间也还过的去，在简单的网络环境下，能够应付比较高的并发。

冰封的爱 2007-07-20 14:55 发表评论

JBoss 4.0.2集群指南(一)

冰封的爱 — Fri, 20 Jul 2007 06:54:00 GMT

    本文主要讲解JBoss cluster的基本知识以及简单的配置方法，其间涉及了一些jboss的补充知识。

一、材料准备：

1、   JBoss 4.0.2

JBoss各个版本之间差异比较大，即使同为jboss 4.x的版本，内部组件的版本也不一致，所以请尽量使用同一版本的server。目前已经证明可以配置cluster的版本多为jboss 3.2.6和jboss 4.0.2。

2、   Apache 2.0.54

3、   Apache mod_jk-1-2-13-apache-2-0-54

二、安装：

1、   jboss4.0.2与apache 2.0.54的安装请自行搞定。假设jboss的安装目录为%jboss%，apache安装目录为%apache%。

2、   mod_jk的安装。

从apache.org获得文件mod_jk-1-2-13-apache-2-0-54.so，将该文件拷贝到%apache%\ modules。

三、jboss cluster入门

   Jboss 支持如下类型的cluster：EJB、web、JNDI、JMS，我们主要了解web cluster。
Web cluster实际上可以划分为两个话题：负载均衡 (load balance) 和状态同步。它们是互相独立的，单独配置。

负载均衡的概念比较简单，重要的是负载均衡的粒度。可以选择针对每个request的均衡，或者是针对每个用户的均衡。选择不同的粒度，需要不同的状态同步方式。

1、基于request的负载均衡

   该种方式下，负载均衡器 (load balancer)会根据各个node的状况，把每个http request进行分发。使用这样的均衡策略，就必须在多个node之间复制用户的session，实时保持整个cluster的用户状态同步，这种操作被称为session复制(session replication)。Jboss的实现原理是使用拦截器(interceptor)，根据用户的同步策略拦截request，做同步处理后再交给server产生响应。

   该方法的优点是客户不会被绑定都具体的node，只要还有一个node存活，用户状态都不会丢失，cluster都能够继续工作。缺点是node之间通信频繁，响应速度有影响，多并发、高频操作的情况下性能下降比较厉害。

2、   基于用户的负载均衡

该种方式下，当用户发出第一个request后，负载均衡器动态的把该用户分配到某个节点，并记录该节点的jvm路由，以后该用户的所有request都会被绑定这个jvm路由，用户只会与该server发生交互，这种策略被称为粘性session(session sticky)。

该方法的优点是响应速度快，多个节点之间无须通信。缺点也很明显，某个node死掉以后，它负责的所有用户都会丢失session。

四、实战

1、负载均衡

   Jboss的负载均衡目前有两种方案，一是使用apache的mod_jk，二是使用jboss自带的负载均衡模块。下面分别讲解这两种配置。

mod_jk的配置

1、   请确认%apache%\modules下已经有mod_jk-1-2-13-apache-2-0-54.so文件。
2、   修改%apache%\conf\httpd.conf   在文件末尾添加:   Include conf/mod_jk2.conf
3、   在%apache%\conf下新建文件   mod_jk2.conf       文件内容如下：

# Load mod_jk module. Specify the filename
# of the mod_jk lib you’ve downloaded and
# installed in the previous section
LoadModule jk_module modules/mod_jk-1-2-13-apache-2-0-54.so
# Where to find workers.properties
JkWorkersFile conf/workers2.properties
# Where to put jk logs
JkLogFile logs/mod_jk.log
# Set the jk log level [debug/error/info]
JkLogLevel info
# Select the log format
JkLogStampFormat "[%a %b %d %H:%M:%S %Y] "
# JkOptions indicate to send SSL KEY SIZE,
JkOptions +ForwardKeySize +ForwardURICompat -ForwardDirectories
# JkRequestLogFormat set the request format
JkRequestLogFormat "%w %V %T"
JkMount /* loadbalancer

其中JkMount /* loadbalancer的意思是，把所有的请求都发给loadbalancer处理。可以通过修改url来控制发送某些request。
4、在%apache%\conf下新建文件   workers2.properties       其内容为：

worker.list=loadbalancer,server1,server2

# Define the first node...
worker.server1.port=8009
worker.server1.host=172.16.0.116
worker.server1.type=ajp13
worker.server1.lbfactor=1
worker.server1.local_worker=1
worker.server1.cachesize=10

# Define the first node...
worker.server2.port=8009
worker.server2.host=172.16.32.88
worker.server2.type=ajp13
worker.server2.lbfactor=1
worker.server2.local_worker=1
worker.server2.cachesize=10

# Now we define the load-balancing behaviour
worker.loadbalancer.type=lb
worker.loadbalancer.balanced_workers=server1,server2
worker.loadbalancer.sticky_session=1

其中对于node的命名规则是worker.节点名.xxxx。所以上述文件定义了两个节点：server1和server2。8009端口是jboss默认的ajp端口，另外需要注意的是worker.server2.lbfactor参数，它是节点的负载加权，它的值越大，获得负载的机会就越大。可以根据node的硬件性能进行调整。worker.loadbalancer.sticky_session参数是指定是否使用粘性session。

所有需要负载均衡的节点，都必须在worker.loadbalancer.balanced_workers参数中列举出来。

请记住所有node的名称和它对应着哪台机器，后面的配置中会使用。

尝试启动apache：%apache\bin\apache.exe，正常情况下没有任何提示。如果你使用的jk是2.0的，那么配置文件的写法完全不同，由于mod_jk2已经停止开发，所以apache并没有提供任何讲解，对于配置文件的编写也没有任何指导。

Jboss自带均衡器的配置

   将文件夹%jboss%\docs\examples\varia\loadbalancer\loadbalancer.sar拷贝到%jboss%\server\all\deploy下，并且修改loadbalancer.sar\loadbalancer.sar\META-INF\jboss-service.xml，在标签中类出所有节点，在标签中指定是否使用粘性session。配置完成。

   该均衡器的缺点是负载能力相对不高，配置参数太少，比如无法指定不同节点的负载加权，所以后面都以mod_jk为例，不再讲解jboss自带的负载均衡器的内容。

   负载均衡的配置基本完成，启动jboss，其中过程中会列出DefaultPatition中所有的节点：
run.bat -c all

任何节点的关闭与启动都会在cluster中广播，比如加如一个新节点后，其他节点会得到以下提示：

2、session sticky配置

   apache应该会以粘性session的方式分发请求。部署一个应用测试一下，你会发现粘性session没有起作用。因为我们还没有给jboss配置jvm路由( jvmRoute)，apache就无法知道究竟哪些session是属于哪个节点的。我们继续往下：

   修改server1机器上的jboss的配置文件：%jboss%\server\all\deploy\jbossweb-tomcat55.sar\ META-INF\ jboss-service.xml

   在110行有：false，将它改为true。值得注意的是在这行标签上面有一段注释，要求你在server.xml中必须有：
Engine name="jboss.web" jmvRoute="Node1" defaultHost="localhost"

   请注意这里有一个气死人不偿命的小bug，jboss的官方文档把 jvmRoute写成了jmvRoute，就是v和m两个字母的颠倒让我郁闷了三天，翻遍了jboss.com和theserverside.com。都是直接拷贝的错，吐血吐到脱水啊。

   下面需要修改server1上的%jboss%\server\all\deploy\jbossweb-tomcat55.sar\ server.xml，在32行左右有：

给它增加一个jvmRoute属性：

请注意，jvmRoute的值必须和mod_jk中的节点名字正确对应，否则无法正确路由。Cluster中的所有节点都应该做相应的配置。

Jboss的配置完成了，下面需要在你的web应用中修改配置文件，让它支持集群。

在WEB-INF\web.xml中加入属性：

Ok，基于用户的cluster完成了，每个用户会绑定都某个节点上进行交互。这种绑定是如何完成的呢？原来apache把客户分发到节点后，该节点会在用户的session id后面加上此节点的路由名称，变成这个样子：

Efdfxxd98daja87daj76da2dka**,server1

   有了这个标志，就能分辨该session属于哪个节点。

3、session replication配置

   下面要做的是基于request的cluster，也就让各个节点之间互相复制session状态。有两种复制模式，同步与异步。使用同步的方式，jboss会把session复制的操作和对request的响应放到一个应用事务(application transaction)，session复制完成后才去处理request。异步复制则发送session复制的消息后马上处理request，session复制则会稍有延迟。但是在多框架的web页面中，这样的集群方式会有问题。由于frame在同一时间发出多个request，会造成一些混乱，这也是采用基于用户的集群方式的原因之一。

   JBoss 4.0.2中采用了Jboss cache来实现session复制，实际上就是一个分布式缓存，由于session id中包含了jvm route，所以能够分辨session属于哪个节点。Session的更新类似于hibernate中的乐观锁，有了更新之后就让session的版本号增加，其他节点通过对比版本号来决定是否同步session状态。

   配置session replication首先需要编辑
%jboss% server\all\deploy\jbossweb-tomcat55.sar\META-INF\ jboss-service.xml，88行左右有：
instant
这就是刚才提到的复制模式，instant为立即复制，如果设为interval 那么系统会在延迟一段时间再进行复制，时间长度在2000中指定，单位是毫秒。

单独配置这一个地方还不够，在%jboss% server\all\deploy\ tc5-cluster-service.xml中有：

REPL_ASYNC

这里才真正决定复制是同步的还是异步的，可以指定为REPL_ASYNC(异步)或者REPL_SYNC(同步)。

在这个文件下面一点，还有一个config标签，里面指定了各个节点在进行session复制的时候如何通信，有udp和tcp两种可选，如果使用udp方式，那么应该将udp的lookback属性指定为true，因为windows上有一个叫做media sense的东西会影响udp multicast。注意如果你不了解multi address的ip规则，请不要随便修改mcast_addr的值。如果采用tcp方式的话，应该指定bind_addr的值为本机ip，并且在TCPPING标签的initial_hosts属性中列出所有节点，格式是”机器名[端口号]”，比如在我们的例子中，就应该这样配置tcp(以其中一个节点为例)：

num_initial_members="3" up_thread="true" down_thread="true"/>

             retransmit_timeout="3000"/>

    print_local_addr="true" down_thread="true" up_thread="true"/>

   JBoss的clustering版主建议尽量使用udp。不过在Sobey内部，建议使用tcp方式，经测试可能有不明物体在影响udp通信，导致Timeout异常。

   在%jboss%\ server\all\deploy\ cluster-service.xml中也有关于udp和tcp的配置信息，在4.0以前版本的jboss中，会以这个文件为主配置，4.0以后都以tc5-cluster-service.xml为主配置。

   Jboss的配置完成了，最后需要在web应用中增加配置信息，控制session复制的粒度。在WEB-INF\   jboss-web.xml中增加以下内容：

SET_AND_NON_PRIMITIVE_GET

SESSION

其中replication-trigger是指定哪些操作引发session的版本更新，它的取值有：

SET_AND_GET
SET_AND_NON_PRIMITIVE_GET
SET

replication-granularity是复制粒度，可以取session或attribute。如果取为attribute有可能导致复制失败，这是目前版本的jboss cache的一个bug，等待修正。

部署项目，测试，如果配置没有问题，可以在%jboss%\0server\all\log\server.log中发现类似于这样的信息：

DEBUG [org.jboss.web.tomcat.tc5.session.JBossCacheManager] check to see if needs to store and replicate session with id Im9-qpuaXppMS+xXwE3M+Q**.server1

DEBUG [org.jboss.web.tomcat.tc5.session.ClusteredSession] processSessionRepl(): session is dirty. Will increment version from: 20 and replicate.

   Session replication配置的成功率比较低，情况也很复杂，请仔细操作。

五、分布式热部署(distributable hot deploy)

   在一个节点很多的cluster中，如果部署应用的时候必须把程序文件拷贝到每个机器上的话，那实在太愚蠢了，幸好通过all启动的jboss自动支持分布式热部署。把支持cluster的应用（通常需要打包成war文件），放到%jboss%\server\all\farm下，那么处于同一cluster中的其他节点会自动下载并且部署，jboss把这个称为Farm deploy。如下图：

End 2005-7-11 Released by bromon

冰封的爱 2007-07-20 14:54 发表评论

EJB client调用EJB3 (转)

冰封的爱 — Fri, 20 Jul 2007 06:51:00 GMT

当你的EJB3是deploy to jboss的情况下，ejb client调用EJB3分两种情况：

1) 发布在jboss的web app作为client来调用EJB

EJB和调用EJB的WEB 应用都发布在Jboss 集成环境下。在Jboss下发布WEB 应用，需要把WEB 应用打包成war 文件。另外在此环境下调用EJB 不需要把EJB 的接口类放入/WEB-INF/classes/目录中，否则在调用Stateful Bean 就会发生类型冲突，引发下面的例外

java.lang.ClassCastException: $Proxy84

org.apache.jsp.StatefulBeanTest_jsp._jspService(org.apache.jsp.StatefulBeanTest_jsp:55)

如果EJB和调用EJB的WEB 应用都发布在Jboss 集成环境下，那么EJB的Local或Remote接口都可以被调用

发布在Jboss 下的客户端不需要明确设置JNDI 访问的上下文环境，可以直接通过

InitialContext ctx = new InitialContext()

获得上下文环境，容器会自动赋给InitialContext 正确的环境，例如：

InitialContext ctx = new InitialContext();//客户端和jboss运行在同一个jvm,不需要传入props

HelloWorld helloworld = (HelloWorld) ctx.lookup("HelloWorldBean/remote");

如果硬给InitialContext 设置了访问属性，反而会带来不可移植的问题，因为你的应用有可能部署在weblogic 等应用服务器。（本教程考虑到部分同学可能需要在独立的J2se 中调用EJB，为了教学的方便，把访问属性都设上了，这样不管在jboss、j2se 或独立tomcat，都能获得正确的InitialContext）

2) 在单独的Tomcat或J2SE（如junit test）中调用EJB

在正式的生产环境下，大部分调用EJB 的客户端可能是单独的Tomcat 或Resin。下面介绍如何在单独的Tomcat服务器中调用EJB。在单独的Tomcat 服务器中调用EJB 需要有以下步骤：

A) 把调用EJB 所依赖的Jar 包拷贝到tomcat 下的/shared/lib 目录或WEB 应用的WEB-INF/lib下,所依赖的Jar在jboss 安装目录的client目录下。你可以在eclipse里设置一个自定义的library “ejb3 library”，把这些jars都添加到该library里，然后在你的EJB project里把“ejb3 library” add to classpath

B) 把EJB 接口拷贝到应用的/WEB-INF/classes/目录下

C) 客户端访问EJB 时必须明确设置InitialContext 环境属性，代码如下:

Properties props = new Properties();

props.setProperty("java.naming.factory.initial", "org.jnp.interfaces.NamingContextFactory");

props.setProperty("java.naming.provider.url", "localhost:1099");

props.setProperty("java.naming.factory.url.pkgs", "org.jboss.naming");

InitialContext ctx = new InitialContext(props);//客户端和jboss运行在同一个jvm,不需要传入props

HelloWorld helloworld = (HelloWorld) ctx.lookup("HelloWorldBean/remote");

Tip: 除了上面通过硬编码设置环境属性的方式外，还可以在应用的classpath 下放置一个jndi.properties 文件

注意：在单独的tomcat和J2SE里不能调用EJB 的Local 接口，因为他与JBOSS 不在同一个VM 中。J2se中调用EJB3 同样需要把上述jar 及EJB 接口放置在应用的类路径下。

冰封的爱 2007-07-20 14:51 发表评论

关于JNDI and EJB

冰封的爱 — Fri, 20 Jul 2007 06:50:00 GMT

JNDI (The Java Naming and Directory Interface，Java 命名和目录接口) 是一组在Java 应用中访问命名和目录服务的API。为开发人员提供了查找和访问各种命名和目录服务的通用、统一的方式。借助于JNDI 提供的接口，能够通过名字定位用户、机器、网络、对象服务等。

命名服务：就像DNS一样，通过命名服务器提供服务，大部分的J2EE 服务器都含有命名服务器。

目录服务：一种简化的RDBMS 系统，通过目录具有的属性保存一些简单的信息。目录服务通过目录服务器实现，比如微软ACTIVE DIRECTORY 等。

JNDI 的好处:

（1）包含大量命名和目录服务，可以使用相同API 调用访问任何命名或目录服务。

（2）可以同时连接多个命名和目录服务。

（3）允许把名称同JAVA 对象或资源关联起来，不必知道对象或资源的物理ID。

（4）使用通用接口访问不同种类的目录服务

（5）使得开发人员能够集中使用和实现一种类型的命名或目录服务客户API 上。

上下文：由0 或多个绑定构成。比如java/MySql，java 为上下文（context），MySql 为命名

子上下文（subConext）：上下文下的上下文。比如MyJNDITree/ejb/helloBean，ejb 为子上下文。

因为JNDI 是一组接口，所以我们只需根据接口规范编程就可以。要通过JNDI 进行资源访问，我们必须设置初始化上下文的参数，主要是设置JNDI 驱动的类名(java.naming.factory.initial) 和提供命名服务的URL (java.naming.provider.url)。

因为Jndi 的实现产品有很多。所以java.naming.factory.initial 的值因提供JNDI 服务器的不同而不同，java.naming.provider.url 的值包括提供命名服务的主机地址和端口号。

访问Jboss 服务器的例子代码：

Properties props = new Properties();
props.setProperty("java.naming.factory.initial", "org.jnp.interfaces.NamingContextFactory");
props.setProperty("java.naming.provider.url", "localhost:1099");
InitialContext = new InitialContext(props);
HelloWorld helloworld = (HelloWorld) ctx.lookup("HelloWorldBean/remote");

访问Sun 应用服务器的例子代码：

Properties props = new Properties();
props.setProperty("java.naming.factory.initial",
"com.sun.enterprise.naming.SerialInitContextFactory");
props.setProperty("java.naming.provider.url", "localhost:3700");
InitialContext = new InitialContext(props);
HelloWorld helloworld = (HelloWorld) ctx.lookup("com.foshanshop.ejb3.HelloWorld");

访问Weblogic10 应用服务器的例子代码：

Properties props = new Properties();
props.setProperty("java.naming.factory.initial", "weblogic.jndi.WLInitialContextFactory");
props.setProperty("java.naming.provider.url", "t3://localhost:7001");
InitialContext = new InitialContext(props);
HelloWorld helloworld = (HelloWorld) ctx.lookup("HelloWorldBean#com.foshanshop.ejb3.HelloWorld");

JBOSS 环境下JNDI 树的命名约定：

（1）java:copm 这个上下文环境和其子上下文环境仅能被与之相关的特定应用组件访问和使用

（2）java：子上下文环境和绑定的对象只能被Jboss 服务器虚拟机内的应用访问

（3）其他上下文环境只要实现序列化就可以被远程用户调用。

当你把EJB发布到JBOSS后，你就可以在jboss 的管理平台查看她们的JNDI 名，输入下面URL http://localhost:8080/jmx-console/，点击“service=JNDIView” link，在出现的page里找到“List of MBean operations:”栏的“list()”方法，click “Invoke”button，就会看到下面的界面

在上图中可以看见HelloWorld 会话Bean 的JNDI路径，JNDI 路径名的组成规则是“上层名称/下层名称，每层之间以”/”分隔。HelloWorld 会话Bean 的JNDI路径名是：HelloWorldBean/remote

下面要重点说明一下Jboss EJB JNDI 名称默认的命名规则，命名规则如下：

1> 如果EJB 打包进后缀为*.ear 的J2EE 发布文件，默认的JNDI 路径名称是

访问本地接口：EAR-FILE-BASE-NAME/EJB-CLASS-NAME/local

访问远程接口：EAR-FILE-BASE-NAME/EJB-CLASS-NAME/remote

例：EJB HelloWorld 打包进名为 HelloWorld.ear 的J2EE 应用，访问她远程接口的JNDI 名是：HelloWorld/HelloWorldBean/remote

2> 如果EJB 应用打包成后缀为*.jar 的发布文件, 默认的JNDI 路径名称是

访问本地接口：EJB-CLASS-NAME/local

访问远程接口：EJB-CLASS-NAME/remote

例： HelloWorld 应用打包成HelloWorld.jar 文件，访问她远程接口的JNDI 名称是：HelloWorldBean/remote

注意：EJB-CLASS-NAME 是不带包名的，如com.foshanshop.ejb3.impl.HelloWorldBean 只需取HelloWorldBean。

目前网上很多教材获取JNDI 路径名的方式不适用在jboss 下，如：

HelloWorld helloworld = (HelloWorld) ctx.lookup(HelloWorld.class.getName());

这种方式适用于Sun Application Server 及glassfish

自定义JNDI 命名

默认的JNDI 命名规则上面已经介绍过，但有些情况下需要自定义名称。在Jboss 中要自定义JNDI 名称，可以使用@LocalBinding 和@RemoteBinding 注释

关键代码(只需要在bean interface前加binding注释)：

import org.jboss.annotation.ejb.RemoteBinding;
...
@Remote
@RemoteBinding (jndiBinding="testbinding/myAccount")
publicinterface MyAccount extends Serializable {
publicint Add(int a, int b);
publicint getResult() ;
}

那么在client端调用上面的EJB的代码为：
InitialContext ctx = new InitialContext(props);
MyAccount bean1 = (MyAccount) ctx.lookup("testbinding/myAccount");

冰封的爱 2007-07-20 14:50 发表评论

开发、调试和测试EJB3 APP(转)

冰封的爱 — Fri, 20 Jul 2007 06:48:00 GMT

如何开发、调试和测试EJB3 APP？

1．Install Eclipse + JBOSS IDE 2.0

2．官方的使用JBOSS IDE来开发EJB3 APP的教程还没出来（查看http://www.jboss.com/docs/trailblazer），所以只能用下列步骤

3．创建一个普通的java project，把我自己定义的“ejb library”加入到classpath里，同时把junit 4也添加到classpath

4．打开JBoss Server View：window à Show View à Other.. à JBoss Server View

5．在JBoss Server View里create a jboss server，注意：选的server选项如下图：

创建完之后，JBoss Server View见下图：

6．如果是要调试的话，则选定server，然后click上图的debug button，如果是运行，则click run button

7．在project root folder下创建好build.xml，它非常重要，用于打包和copy打包的文件到jboss server deploy目录下（build.xml参看自己的ejb3 hello world project）。

8．然后如果要调试的话，就在build.xml的outline view里right click task，然后选择 Debug As à Ant Build (见下图)，如果不是调试，则选择Run As à Ant Build

9．进行Junit Test也很容易，但最关键的前提是还是需要先启动jboss server，然后把你的ejb jar发布到jboss里才可以进行junit test，因为ejb的调用离不开ejb container！！那么调用ejb的代码如下：

public static Object getEJB(String jndipath) {

            Properties props = new Properties();

            props.setProperty("java.naming.factory.initial", "org.jnp.interfaces.NamingContextFactory");

            props.setProperty("java.naming.provider.url", "localhost:1099");

            props.setProperty("java.naming.factory.url.pkgs", "org.jboss.naming:org.jnp.interfaces");

            InitialContext ctx = new InitialContext(props);

            ctx.lookup("HelloWorldBean/remote");

冰封的爱 2007-07-20 14:48 发表评论

JBoss下数据源密码加密

冰封的爱 — Fri, 20 Jul 2007 06:46:00 GMT

[摘]JBoss下数据源密码加密

1.先来看一个普通的数据源配置文件

xml version="1.0" encoding="UTF-8"?>
<datasources>
  <local-tx-datasource>
    <jndi-name>MySqlDSjndi-name>   //jndi名字
    <use-java-context>falseuse-java-context>
    <connection-url>jdbc:mysql://10.16.175.137:3306/testconnection-url>  //URL地址
    <driver-class>com.mysql.jdbc.Driverdriver-class>  //驱动
    <user-name>rootuser-name>    //用户名
    <password>123456password>  //密码
    <exception-sorter-class-name>
        org.jboss.resource.adapter.jdbc.vendor.MySQLExceptionSorter
       exception-sorter-class-name>
      <metadata>
       <type-mapping>mySQLtype-mapping>
    metadata>
  local-tx-datasource>
datasources>

看一下这个文件,里面用户名与密码都是以明文方式存储的,这样子对系统的安全而言带来了极大的威协。所以我们要为我们这个明文的密码加一下密,这就是本文的目的.

2.说到密码加密，这里我们用到了JBoss下的一个类org.jboss.resource.security.SedureIdentityLoginModule,看看我们该如何用它来帮我们的密码加密。

先看个配置数据源的例子(mysql-ds.xml)：

xml version="1.0" encoding="UTF-8"?>
<datasources>
  <local-tx-datasource>
    <jndi-name>MySqlDSjndi-name>
    <use-java-context>falseuse-java-context>
    <connection-url>jdbc:mysql://192.168.1.91:3306/atteamconnection-url>
    <driver-class>com.mysql.jdbc.Driverdriver-class>
    <security-domain>EncryptDBPasswordsecurity-domain>//这里不用写上你的用户名与密码了，我们可以在login-config.xml里做点手脚，就OK了
    <exception-sorter-class-name>org.jboss.resource.adapter.jdbc.vendor.MySQLExceptionSorterexception-sorter-class-name>
    <metadata>
       <type-mapping>mySQLtype-mapping>
    metadata>
  local-tx-datasource>
datasources>

接着我们修改server\default\conf\login-config.xml文件,加上下面这一段配置文件

<application-policy name="EncryptDBPassword"> //这里的name应该是你在配置数据源时写的security-domain里的字符串
     <authentication>
       <login-module code="org.jboss.resource.security.SecureIdentityLoginModule"
         flag="required">
         <module-option name="username">testmodule-option> //数据库的用户名
         <module-option name="password">64c5fd2979a86168module-option> //数据库的密码，不过是加密过的了
         <module-option name="managedConnectionFactoryName">jboss.jca:service=LocalTxCM,name=MySqlDSmodule-option>
        //注意name等于你的数据源的jndi-name,这里是MySqlDS
       login-module>
     authentication>
application-policy>

3.补充一下，这个加密的密码是哪来的（呵呵，忘了说了）

java -cp "D:\TDdownload\jboss-4.2.0.CR1\jboss-4.2.0.CR1\lib\jboss-jmx.jar;D:\TDdownload\jboss-4.2.0.CR1\jboss-4.2.0.CR1\lib\jboss-common.jar;D:\TDdownload\jboss-4.2.0.CR1\jboss-4.2.0.CR1\server\default\lib\jboss-jca.jar;D:\TDdownload\jboss-4.2.0.CR1\jboss-4.2.0.CR1\server\default\lib\jbosssx.jar" org.jboss.resource.security.SecureIdentityLoginModule 123456

Encoded password: 64c5fd2979a86168

写上你自己的路径和你要加密的密码就行了,我这里要加密的密码是123456,加密过之后就是64c5fd2979a86168

冰封的爱 2007-07-20 14:46 发表评论

Appfuse 增量式开发步骤

冰封的爱 — Wed, 18 Jul 2007 08:43:00 GMT

前置条件：

假设用户已经按照《appfuse执行步骤》文档进行配置并操作，最后产生了一个叫uapp的web应用。如果用户需要新增加功能，只要按照下面的步骤去操作就可以轻松地完成任务。

开发步骤：

1. 先在数据库里创建表。例如，student表。注意，表的名称的第二个字母最好不要大写。以免出现奇怪的问题（好像是hibernate的bug）。

2. 把目录切换到appgen的工作目录，修改文件tables。把里面的内容先去掉，然后添加新的表名。例如，student。

3. 在appgen的工作目录下，运行Ant generate。

运行结果：从数据库里读取表结构，并生成相关的strus表单、jsp文件、hibernate的POJO对象、DAO和manager对象、struts配置文件、spring配置文件、velocity的模板文件。

4. 转到uapp目录下，执行ant package-web生成WAR文件

这个过程里，

a) 会根据java文件生成hibernate的映射文件；

b) compile-dao。编译dao目录下的java对象。

c) package-dao。把dao目录下的classes打包成demo-dao.jar；

d) compile-service。编译service目录下的java对象。

e) package-service。把service目录下的classes打包成demo-service.jar

f) copy-resources。期间，会调用native2ascii Converting 1 file from D:projectappfusemyappfusedemowebWEB-INFclasses to D:projectappfusemyappfusedemobuildwebclasses

g) generate.database.properties。

h) copy-web-files。

i) gen-forms。根据struts配置文件产生Form表单对象。

j) compile-web。会编译action对象。 javac Compiling 40 source files to D:projectappfusemyappfusedemobuildwebclasses

k) webdoclet。产生

i. web.xml

ii. uapp.tld

iii. struts-config.xml

iv. validation.xml

l) package-web.。生成war包。

注意：我们经常要处理实体间的关系，如一对多，多对多。而appgen产生的POJO对象往往都太简单，没有处理这些复杂的关系。所以，我们需要手工地修改POJO对象，建立对象的关联。例如，在Parent对象里建立对Child的关联。

在Parent.java对象里，增加

private Set children =new HashSet();

/**

* @return Returns the booths.

* @hibernate.collection-one-to-many

* class="org.aos.exhibition.model.Child"

* @hibernate.collection-key column="pid"

* @hibernate.set

* name="children"

* table="child"

* inverse="true"

* sort="unsorted

* lazy="true"

* cascade="all"

public Set getChildren()

{

return this.children;

}

还有相关的addChildren(Child child)方法和getChildren()方法。

在Child对象里，增加

private Parent parent;

/**

* @return Returns the parent.

* @hibernate.many-to-one name="parent"

* column="pid"

* not-null="false"

* cascade="all"

public Parent getParent() {

return parent;

}

public void setParent(Parent parent) {

this.parent = parent;

}

最后，运行ant package-web产生相关的hibernate映射文件，并编译。

在编译的过程中，可能会有一些错误，例如， ActionForm包名的错误导致编译问题。

org.appfuse.model.Parent应该为org.aos.exhibition.model.Parent。需要自己修改相关的ActionForm，把包名更正。

1. 另外，我们经常会发现appgen给我们产生的jsp代码框架太简单，不能符合我们的要求，例如样式、布局等等。那么我们需要修改uappwebpages目录下的jsp文件。

2. 部署。执行ant deploy. 发布web应用到tomcat的webapps目录下。

3. 拷贝D:Tomcat50webappsdemoWEB-INFclassesorgappfusewebappactionLookupMethods.properties到classesorgaosexhibitionwebappaction 目录下。

4. 如果是中文版本，还需要把ApplicationResources_en.properties里面新增的内容拷贝到ApplicationResources_zh_CN.properties文件里面。

5. 使用链接：http://localhost:端口号/uapp/ 来启动web应用。如果在调试过程中发生net.sf.hibernate.HibernateException: Batch update row count wrong这样的异常，那需要重新运行Ant generate，从第三步开始作一遍

冰封的爱 2007-07-18 16:43 发表评论

Appfuse开发指南

冰封的爱 — Wed, 18 Jul 2007 08:35:00 GMT

Appfuse开发指南

如果你已经下载了AppFuse并且希望在你的机器上完成安装配置，最合适的参考资料是快速起步指南。一旦你完成了所有的安装设置，下面的手册是学习如何使用AppFuse开发的重要资料。

注意: Appfuse的发布包里面已经包括了这个指南。如果你希望更新你的工程目录下的手册(在 docs 目录下)，运行 "ant wiki"。

从 1.6.1 版本开始，你可以产生这个指南所包含的源代码。如果你使用 Struts+Hibernate，你可以产生所有的源代码，如果使用Spring 或者 WebWork，因为写专门的安装程序比较麻烦所以你需要手工配置 Controllers 和 Actions。造成这个局面的主要原因是我没有为这些 web framework 使用 XDoclet 从而使得基于ant的安装程序功能受到了限制。 AppGen 工具可以产生第一部分所需要的全部源代码。

还有另外一个AppFuse Generator 项目建立的工具有类似AppGen的功能。

第一部分： 在AppFuse建立DAO和POJO - 讲述如何创建POJO(对应相应的数据表)和 DAO（管理POJO持久化操作的对象）。

第二部分： 创建新的Manager - 讲述如何创建一个 Business Facades ，它可以跟数据层 (DAOs)和web 层 (Actions 或 Controllers)交互。

第三部分： (Struts) 创建 Struts Actions和JSPs - 讲述如何创建在你自己的appfuse工程里面创建Actions和JSPs。包括生成JSP并且进行修改定制让它们好看一点。此外，你需要编写WebTest来测试这个JSP的功能。其他可选的web framework如下所示：

Spring: 创建 Spring Controllers 和 JSPs

WebWork: 创建 WebWork Actions 和 JSPs

JSF: 创建 JSF Beans 和 JSPs

Tapestry: 创建 Tapestry 页面和模版

第四部分: (Struts) 增加校验功能和列表页面 - 增加一个验证personForm的firstName和lastName为必填项的校验逻辑，并且增加一个列表面显示数据库中所有的person记录。

Spring: 增加校验功能和列表页面

WebWork: 增加校验功能和列表页面

JSF: 增加校验功能和列表页面

Tapestry: 增加校验功能和列表页面

注意： 你可以用AppGen生成这个指南里创建的所有源文件。在经验不足的情况下 - 你可以把自己编写的程序和AppGen产生的程序作比较以检查问题。如果你想这样做的话，进入extras/appgen目录并运行"ant test-detailed"，这将创建一个"appfuse-appgen"工程，产生这个指南的所有代码并且进行测试

Thomas Gaudin的非常好的AppFuse开发指南

Thomas Gaudin在他的网站上放了两个详细的很容易学习的开发指南

处理日期（使用AppFuse 和 Struts）

创建一个可持久化的动态 web tree

相关的 AppFuse 指南

我如何建立自己的开发环境.

使用Eclipse开发你自己的AppFuse应用程序.

在 MyEclipse 中使用Appfuse: 第一部分 和 第二部分 .

AppFuse 也支持 IDEA 4.0 out-of-the-box, or at least the project files are included.

使用Anthill 或者 CruiseControl 完成 AppFuse 自动测试。

如何使用Hibernate创建对象间的关系.

如何在Resin上运行AppFuse.

如何在Orion上运行AppFuse.

如何在Oracle上运行AppFuse.

如何在DB2上运行AppFuse.

如何在PostgreSQL上运行AppFuse.

如何使用Velocity Template代替JSP.

在Eclipse使用Hibernate的XDoclet Template.

如何向Appfuse中增加一个独立类库.

如何向Appfuse中增加一个servlet.

如何自动从DAO层产生PDF文档.

如何自动产生测试用随机数据.

服务器配置

Apache 2.x和SSL

Apache 2.x和Tomcat 4.x

Apache/Tomcat/SSL in Real-Time

Apache 1.3.x和Tomcat 4.x

启动Apache和Tomcat

Jabber Server Setup (1.4.2)

Securing Directories in IIS

Tips for configuring Tomcat

其他

AppFuse开发者技巧

还有些用处的旧文档：

Struts Example for iPlanet

Wiki Evaluation (Java-based)

冰封的爱 2007-07-18 16:35 发表评论

AppFuse快速起步指南

冰封的爱 — Wed, 18 Jul 2007 08:26:00 GMT

AppFuse项目的主要目的是帮助你加速web应用程序的开发。下面说明如何利用它创建一个新工程的基本步骤。

1. 安装 J2SE 1.4.2+ 并设置环境变量JAVA_HOME指向J2SE所在的目录。

2. 下载源程序报或者从CVS(cvs -d :pserver:guest@cvs.dev.java.net:/cvs co appfuse)中检出appfuse模块。

注意: 你可以使用the all-in-one installer 一次性下载安装AppFuse 1.8, Ant 1.6.2, Tomcat 5.0.28 和 MySQL 4.1.11 (for Windows)。查看相关的 README.txt 文件可以了解更多信息。

3. 安装 Install Ant 1.6.2+ 并设置 ANT_HOME 环境变量。安装 Tomcat 4.1.x+ (推荐使用Tomcat 5.0.28) 并设置 CATALINA_HOME 环境变量指向对应的Tomcat安装目录。参阅我的文章 设置开发环境 可以了解在哪里下载到这些程序并且可以了解我通常如何安装配置这些程序。

4. 安装 MySQL 3.23.x+ (推荐使用 4.1.7).

注意: 如果你使用 MySQL 4.1.7, 确定正确设置了 UTF-8 字符集和 InnoDB 表类型。 这里说明如何设置 。

5. 设置本机的 SMTP server 或者修改 mail.properties 文件(在 web/WEB-INF/classes 目录下) 和 build.properties 文件(在根目录下 -- 给 log4j 消息使用) 以使用一个已有的smtp server - 默认值是 localhost。

6. 把文件 lib/junit3.8.1/junit.jar 拷贝到 $ANT_HOME/lib目录下。

注意: 你可能会发现在 $ANT_HOME/lib目录已经有一个 ant-junit.jar 文件了. 这个 jar 包不是 JUnit 类库, 而是 Ant 的 junit task 实现，在执行Ant junit task时会使用你新增的这个junit.jar 文件。

7. 如果你计划使用 iBATIS (代替 Hibernate) 或者 struts 以外的 web framework, 现在安装它们 (安装指令下面可以查到)。安装完成以后, 在appfuse目录下运行 ant new 。会提示你输入application name, database name 和 package name。完成这些操作以后会在appfuse同级目录家里一个包含新程序所需要的全部文件的以你输入的application name命名的目录。

警告: 请不要在输入的application name, database name 和 package name使用 "test", 包含 "appfuse" 的名称或者以数字作为起始字符的名称，否则将会导致任务无法正常执行，此外使用两个破折号 (-) 会造成结果混乱。

8. 切换到这个新的工程目录并且运行 ant setup (或者运行 ant setup-db setup-tomcat deploy) 创建数据库，配置tomcat并发布你的新应用程序。创建数据库的任务只有在你的root用户密码为空的情况下才能工作。需要的话你可以修改 build.properties 文件if necessary. 需要 安装设置帮助setup?

9. 若你细想要进行测试以确定所有程序工作良好，运行 ant test-all - 在运行这个任务的时候确定 Tomcat 没有启动。接下来, 运行 ant test-reports - 运行结束后会显示消息告诉你如何查看产生的报告。

在你确认你正确的完成了上述步骤以后 - 浏览一下指南了解如何使用appfuse开发程序。

安装的可选项

如果你希望使用 iBATIS 作为持久化framework, 查看extras/ibatis目录下的 README.txt 文件或者运行 ant install-ibatis。

如果你希望使用 Spring 作为web framework, 查看 extras/spring 目录下的 README.txt 文件或者运行 ant install-springmvc。

如果你希望使用 WebWork 作为web framework, 查看extras/webwork 目录下的 README.txt 文件或者运行 ant install-webwork。

如果你希望使用 JSF 作为web framework, 查看 extras/jsf 目录下的 README.txt 文件或者运行 ant install-jsf。

如果你希望使用 Tapestry 作为web framework, 查看 extras/tapestry 目录下的 README.txt 文件或者运行 ant install-tapestry。

如果你想写脚本自动基于Appfuse创建并测试自己的工程。在CVS上面有两个我已经写好的用来测试的脚本供参考： spring+ibatis 和 webwork 。注意在实际开发过程中最好不要使用 "appfuse" 作为工程名因为可能会造成不必要的查找/替换。

如果你不希望安装 iBATIS, Spring MVC, WebWork, JSF 和 Tapestry - 你应该在把它们检入前删除extras下的相关目录。

注意: 安装程序会修改 Eclipse classpath, 但是不会是理想的方法。你需要人工修改它。

冰封的爱 2007-07-18 16:26 发表评论

MSSQL2000还原数据库,更改用户登陆权限

冰封的爱 — Mon, 16 Jul 2007 01:04:00 GMT

有的时候还原完数据库后,使用账号登陆不进去,报告没有这个用户的时候,可以使用以下sql解决:

sp_change_users_login 'update_one','tongrenuser','tongrenuser'

冰封的爱 2007-07-16 09:04 发表评论

Hibernate与ibatis

冰封的爱 — Fri, 13 Jul 2007 06:34:00 GMT

Hibernate

Hibernate是一个开放源代码的对象关系映射框架，它对JDBC进行了非常轻量级的对象封装，使得Java程序员可以随心所欲的使用对象编程思维来操纵数据库。Hibernate可以应用在任何使用JDBC的场合，既可以在Java的客户端程序使用，也可以在Servlet/JSP的Web应用中使用，最具革命意义的是，Hibernate可以在应用EJB的J2EE架构中取代CMP，完成数据持久化的重任。

一、基本功能

Hibernate作为数据持久化的中间件，足以让数据库在业务逻辑层开发中去冬眠。它通过可扩展标记语言（XML）实现了类和数据表之间的映射，使程序员在业务逻辑的开发中面向数据库而改为面向对象开发。使整个项目开发分工更加明确，提高了程序开发的效率。

configuration对象：

Configuration 类负责管理Hibernate 的配置信息。Hibernate 运行时需要
获取一些底层实现的基本信息，其中几个关键属性包括：
1．数据库URL
2．数据库用户
3．数据库用户密码
4．数据库JDBC驱动类
5．数据库dialect，用于对特定数据库提供支持，其中包含了针对特定数据库特性的实现，如Hibernate数据类型到特定数据库数据类型的映射等。

以上信息一般情况下由hibernate.cfg.xml或者hibernate.properties文件来配置，实现与不同数据库的连接。

Session对象：

Session是持久层操作的基础，相当于JDBC中的Connection:
实例通过SessionFactory实例构建:

Configuration config = new Configuration().configure();
SessionFactory sessionFactory = config.buildSessionFactory();
Session session = sessionFactory.openSession();

之后我们就可以调用Session所提供的save、find、flush等方法完成持久层操作。因此Session对象也封装了所有对数据库的操作来实现Hibernate对数据库的操纵功能，如：

Save()方法实现增加和保存；

Delete()方法实现数据的删除；

Update()方法实现数据更新和修改；

Find()方法实现数据的检索；

……

Hibernate会根据不同的操作自动生成相应的SQL语句，从而实现了程序员对PO对象的操作转化为对数据库关系表的操作。

二、使用步骤

1．编写Hibernate配置文件

Hibernate配置文件有两种，分别是hibernate.cfg.xml文件和hibernate.properties,推荐使用hibernate.cfg.xml。

2．PO和映射文件

使用middlegen和hibernate-extensions从数据库导出PO的映射文件，并在hibernate.cfg.xml当中声明。

3．编写DAO

对每一张关系表编写一个DAO，提供一组增、删、改、查方法供业务逻辑对数据库操作使用。

Ibatis

相对Hibernate和Apache OJB 等"一站式"ORM解决方案而言，ibatis 是一种"半自动化"的ORM实现。所谓"半自动"，可能理解上有点生涩。纵观目前主流的ORM，无论Hibernate 还是Apache OJB，都对数据库结构提供了较为完整的封装，提供了从POJO 到数据库表的全套映射机制。程序员往往只需定义好了POJO 到数据库表的映射关系，即可通过Hibernate或者OJB 提供的方法完成持久层操作。程序员甚至不需要对SQL 的熟练掌握，Hibernate/OJB 会根据制定的存储逻辑，自动生成对应的SQL 并调用JDBC 接口加以执行。

Ibatis最直接的好处就是不但为程序员提供了对象与关系数据库之间的映射，同时提供操作方法与SQL间的直接影射，设计者可以直接为一个方法指定一条SQL语句，从而取得更加准确的数据，同时为优化查询、连接查询提供了方便。

一、基本功能

作为又一个轻量级的ORM中间件，ibatis除了提供了对数据库基本的增、删、改、查外还提供了连接管理，缓存支持，线程支持，（分布式）事物管理等一套教为完整的数据库管理功能。

SqlMapClient对象是ibatis持久层操作的基础，相当于hibernate中的session，提供对SQL映射的方法。

insert()方法实现对插入SQL语句的映射；

delete()方法实现对删除SQL语句的映射；

update()方法实现对更新SQL语句的影射；

queryForList()、queryForMap()、queryForObject()、queryForPaginatedList()等方法提供了一组查询SQL语句的影射；

……

二、使用步骤

1．ibatis SQL Map 配置文件

文件中对所用数据库的连接做了基本配置，包括数据库驱动类型、用户名、密码，以及连接池的相关管理数据。

2．PO和映射文件

和hibernate一样，PO作为数据库关系表的影射，也需要响应的映射配置文件，可以手写，也可以借助hibernate的相关工具生成PO，不会影响PO在ibatis中的使用。与hibernate不同的是，ibatis的映射文件中没有对PO中每个属性做响应的描述，而是指定了一系列与PO有关的SQL相关操作，也体现了ibatis良好的灵活性与可扩展性。

3．编写DAO

在DAO中，可以使用SqlMapClient提供的方法来对应的指定对PO操作的SQL语句，从而使业务逻辑层的开发仍然是面向对象的操作。

相对Hibernate“O/R”而言，iBATIS 是一种“Sql Mapping”的ORM实现。
Hibernate对数据库结构提供了较为完整的封装，Hibernate的O/R Mapping实现了POJO 和数据库表之间的映射，以及SQL 的自动生成和执行。程序员往往只需定义好了POJO 到数据库表的映射关系，即可通过Hibernate 提供的方法完成持久层操作。程序员甚至不需要对SQL 的熟练掌握， Hibernate/OJB 会根据制定的存储逻辑，自动生成对应的SQL 并调用JDBC 接口加以执行。
而iBATIS 的着力点，则在于POJO 与SQL之间的映射关系。也就是说，iBATIS并不会为程序员在运行期自动生成SQL 执行。具体的SQL 需要程序员编写，然后通过映射配置文件，将SQL所需的参数，以及返回的结果字段映射到指定POJO。使用iBATIS 提供的ORM机制，对业务逻辑实现人员而言，面对的是纯粹的Java对象，这一层与通过Hibernate 实现ORM 而言基本一致，而对于具体的数据操作，Hibernate会自动生成SQL 语句，而iBATIS 则要求开发者编写具体的SQL 语句。相对Hibernate而言，iBATIS 以SQL开发的工作量和数据库移植性上的让步，为系统设计提供了更大的自由空间。
二者的对比：1． iBATIS非常简单易学，Hibernate相对较复杂，门槛较高。2．二者都是比较优秀的开源产品3．当系统属于二次开发,无法对数据库结构做到控制和修改,那iBATIS的灵活性将比Hibernate更适合4．系统数据处理量巨大，性能要求极为苛刻，这往往意味着我们必须通过经过高度优化的SQL语句（或存储过程）才能达到系统性能设计指标。在这种情况下iBATIS会有更好的可控性和表现。5． iBATIS需要手写sql语句，也可以生成一部分，Hibernate则基本上可以自动生成，偶尔会写一些Hql。同样的需求,iBATIS的工作量比Hibernate要大很多。类似的，如果涉及到数据库字段的修改，Hibernate修改的地方很少，而iBATIS要把那些sql mapping的地方一一修改。6．以数据库字段一一对应映射得到的PO和Hibernte这种对象化映射得到的PO是截然不同的，本质区别在于这种PO是扁平化的，不像Hibernate映射的PO是可以表达立体的对象继承，聚合等等关系的，这将会直接影响到你的整个软件系统的设计思路。7． Hibernate现在已经是主流O/R Mapping框架，从文档的丰富性，产品的完善性，版本的开发速度都要强于iBATIS8．最关键的一句话是iBATIS的作者说的：If you are starting a new project and you're in full control of your object model and database design, Hibernate is a good choice of O/R tool.If you are accessing any 3rd party databases (e.g. vendor supplied), or you're working with a legacy database, or even just a really poorly designed database, then an O/R mapper might not be capable of handling the situation. That's were an SQL Mapper comes in handy 结论:结论:

Hibernate 和iBATIS可以说是互相补充,共同发展的关系.具体你想用什么要看实际情况.如果看了上面的文字还是拿不定注意,那就Just to try it.实践是检验真理的唯一标准.鞋合不合适,只有试了才知道.

选择Hibernate还是iBATIS都有它的道理：

Hibernate功能强大，数据库无关性好，O/R映射能力强，如果你对Hibernate相当精通，而且对Hibernate进行了适当的封装，那么你的项目整个持久层代码会相当简单，需要写的代码很少，开发速度很快，非常爽。

Hibernate的缺点就是学习门槛不低，要精通门槛更高，而且怎么设计O/R映射，在性能和对象模型之间如何权衡取得平衡，以及怎样用好Hibernate方面需要你的经验和能力都很强才行。

iBATIS入门简单，即学即用，提供了数据库查询的自动对象绑定功能，而且延续了很好的SQL使用经验，对于没有那么高的对象模型要求的项目来说，相当完美。

iBATIS的缺点就是框架还是比较简陋，功能尚有缺失，虽然简化了数据绑定代码，但是整个底层数据库查询实际还是要自己写的，工作量也比较大，而且不太容易适应快速数据库修改。

我的建议就是：

如果你的团队没有Hibernate高手，那么请用iBATIS，要把Hibernate用好，并不容易；否则你应该选择Hibernate，那样你的开发速度和代码简洁性都相当棒！

BTW：

我觉得rails的ActiveRecord是平衡性做的最好的，避免了Hibernate的复杂性和学习HQL的成本，同时具备iBATIS即学即用的简单性。

冰封的爱 2007-07-13 14:34 发表评论

DWR学习

冰封的爱 — Thu, 12 Jul 2007 08:59:00 GMT

摘要: http://getahead.ltd.uk/dwr/ 这段时间较闲,研究了一番dwr.发现dwr实现的AJAX有些地方确实很是先进.比如动态生成javascript代码;隐藏的http协议;javascript于java代码交互的是javascript对象(或字符串)等. 以下是我临时译的一些东西.本来想全译,发现dwr实在是简单,就随便写了.英文居差,现一把. 1、D... 阅读全文

冰封的爱 2007-07-12 16:59 发表评论

在JSP裏混用JSF元件與HTML/JavaScript，輸出到Client時會被分離之迷解答

冰封的爱 — Thu, 12 Jul 2007 08:53:00 GMT

在JSP裏混用JSF元件與HTML/JavaScript，輸出到Client時會被分離之迷解答

開發JSF頁面及元件這半年來，常遇到一個問題，

在JSF的頁面裏，混著寫html/javascript文字及元件tag時,

輸出結果在最後output到client端時有時會被分離成兩組輸出,

而不是以我們在JSP看到的順序輸出。

例如一：

期望在client端應該是,





但事實上會變成

這個列子在初步一看一定覺得不合理,

而且在實際的開發上，一定會產生困優。

但這件事經過最終看完source後,又覺得無可厚非

會發生這件事情的主要元因是JSF的架構性的問題...

當你使用的元件是一個Container時(例如Panel這類的元件)

他可能會期望自己來排列兒子的順序(例如grid layout)

而不是依tag寫的"單純"順序去輸出結果。

這時候，這顆元件會(應該)去改寫getRenderChildren()，並retrun true，表示他要自己來render兒子.

(以gridPanel來看，就必需在各個兒子間用tr/td來作排版)

即表示，這時候利用的JSP裏tag的順序來out是不合用的，

因為tag跟tag中間可能要有其parent的客制化輸出

從JSF規格的source(UIComponentTag)來看

當一個元件不用自己render兒子元件時，

他的encodeStart會在doStartTag被呼叫

他的encodeEnd會在doEndTag被呼叫

他其兒子就理所當然的依JSP裏tag執行的順序被呼叫到,(而不呼叫該元件的encodeChildren)

而穿插在tag中的純文字輸出就理所當然依順序被輸出

例如JSP的JAVA Code：

    panel_tag.doStartTag()

    out.write("
")

    out.wirte("");

    button_tag.doStartTag();

    button_tag.doEndTag();

    out.write("
");

    panel_tag.doEndTag();

可是當一顆元件需要自己render兒子元件時

元件會設定了一個suppressed falg,(還有其他狀況的設suppressed,列如這個元件是在facet裏)

則它的encodeStart,encodeChildren及encodeEnd就會只在doEndTag時被呼叫(UIComponentTag的實作)

從這個元件之後.

它的所有下層元件將被壓制，不再在doStartTag,及doEndTag裏來輸出，

而這顆元件有將其下層元件呼叫輸出的義務(直到遇到下層中另外一顆也需自己輸出兒子的元件)。

從JSP的JAVA CODE來看.

panel_tag.doStartTag() ==> no output

out.write("

out.wirte("");

button_tag.doStartTag(); ==> no output

button_tag.doEndTag(); ==> no output

out.write("

");

panel_tag.doEndTag(); ==> out panel & button

很明顯的，將導致輸出被分離的結果。

結論是，當一個頁面用了類似Panel這種要自己layout children的Componet後，

在裏面寫的HTML或javascript，必需不包含位置及序頁的特性

也就是說JavaScript寫成在.js裏，HTML....應該是沒救了...不要寫HTML~~~

Or,請愛用Tiles Panel元件~~~~~將script及html寫在tiles對應的layout.jsp裏

冰封的爱 2007-07-12 16:53 发表评论

看别人怎么学JSF的

冰封的爱 — Thu, 12 Jul 2007 08:36:00 GMT

记得华为总裁任正非说过，华为是因为无知才走上通信产业之路的。我在2004年年中开始接触JSF时，也是因为无知。几乎没有Java经验，Web更是一片空白，写了一个半吊子的JSP程序后，我居然判了JSP的死刑，铁下心来钻研我的JSF去了。无知者无畏，说得一点也不错。

从JSP起步，第二级台阶，也许Struts是最合适的。没有复杂的概念，没有深奥的理论，容易理解，上手快，从JSP向Struts的过渡显得特别自然。这是Struts流行的原因之一。如果当时请教过任何一个Java高手，我十有八九会以Struts作为我的JSP替代技术，并且很有可能成为 Struts的发烧友。可是，机缘巧合，我选择了JSF。

正应了那句俗语：“傻人有傻福。”采用JSF技术后，Web编程如有神助，一个月时间，我和一个刚毕业的程序员写出了一个规模不小的Web程序： 126张数据库表，346个JSP页面，458K Java源程序，还包括84页的《需求规格说明书》和189页的《数据库设计说明书》。即便是桌面应用，这样规模的程序在一个月内完成，老板也该偷着笑了。其实，效率的提高，完全是JSF的功劳。正如Sun在JSF的规范中所宣称的那样，JSF极大地简化了Java的 Web编程。

首先，在JSF中，页面干净了许多。无需声明Javabean，也不用嵌入Scriptlet，没有多余的符号，只是一些扩展标签而已，看上去规范而不失优雅，让人赏心悦目。程序员多半是完美主义者，眼睛里容不得丑陋的代码，我认识的一些程序员，平时不修边幅，可以整个冬天都穿同一件夹克，袖口磨得油光发亮，但他们的程序却整洁得让人嫉妒。

其次，JSP中趾高气扬的Request和Response对象淡出了JSF。在典型的JSF应用中，程序员基本上没有直接操作Request和 Response对象的必要，因为框架隐藏了对这两个对象的处理细节。不论是从Request中解码参数，还是将数据编码到Reponse中，都不需要程序员写任何代码，JSF知道该怎么做。当然，如果非要访问Request，JSF的隐含对象为程序员提供了可能。

JSF的UI组件

UI组件是JSF最具特色的组成部分。与桌面程序的UI组件不同的是，JSF的UI组件是服务器端的，但是，在JSF框架的支撑下，这些服务器端的 UI组件，在程序员看来和桌面程序的UI组件没什么不同。我用的Jbuilder版本不支持JSF页面设计的所见即所得，当我拖动一个UI组件到页面上时，Jbuilder为我生成的，是一段标签文本，跟随着我的鼠标，放在指定的位置。一个服务端UI组件就是这样诞生的，其在页面上的表现形式也随之确定。

没有所见即所得当然有点遗憾，但对我来说，这已经足够了，因为把组件的Value和后台Javabean的属性进行简单的绑定，我就得到了所有需要的程序行为。页面显示和后台数据的同步、用户输入的转换、数据的有效性验证、错误信息的提示以及UI组件状态的保存和恢复，所有这一切不需要我写任何代码， JSF已经代劳了。

JSF的另一个特色是它的数据组件。我曾经很长时间使用PowerBuilder开发程序，熟悉PowerBuilder的程序员都知道， PowerBuilder最引人注目的是它的所谓数据窗口。并不好看的界面，笨拙的IDE，PowerBuilder单单凭借一个数据窗口，就吸引了大批程序员。PowerBuilder与数据库是天生的一对，长期使用PowerBuilder的结果，我养成了以数据库为中心的设计习惯。

这个习惯一直保持到今天，几乎成了我的嗜好，前面提到的126张表，就是最好的例子，换成别的程序员，也许30张表就够了。

所以，JSF的数据组件让我一见钟情。数据组件实际上包括两个组件，一个是UIData，一个是UIColumn。JSF将数据表看成是由若干个列组成的一个表格，而行的数目取决于数据源中数据的条数。这与PowerBuilder的数据窗口殊途同归。当然，数据组件不是直接从数据库中取得数据（实际上，设计模式也不允许程序员这样做），而是通过一个Javabean以resultSet的形式传递给数据组件。在JSP中，这样的程序逻辑够我折腾一阵的了，而在JSF中，这和生成一个文本输入框一样容易。
JSF数据组件的用途并不限于显示数据库表的内容，实际上，所有实现了List接口的对象都可以成为数据组件的数据源，这给Java的Web编程带来了极大的便利。而且，如果你想直接编辑数据表中的数据，JSF也可以做到，只需以可读可写的方式，将UIColumn的value属性和数据源中你想修改的属性绑定在一起，用户在网页上所做的修改，就会自动保存到数据源中。这样的功能，在JSP中，程序员都要深吸一口气才敢动手的。我的第一个JSF程序，之所以能在一个月的时间内完成346个页面，数据组件功不可没。

JSF的事件和生命周期

OO中的事件，是对象通信的一种机制，对象通过响应彼此的事件相互协调一致。JSP没有事件，所以JSP的代码需要程序员自己去协调，什么时候执行什么代码，往往让程序员大费周章。如果说JSP代码是一群孩子的话，那么程序员就是这群孩子可怜的父母，吃喝拉撒全要操心，哪里能够集中精力做点事情！所以，小孩要上学，学知识可能只是一个借口，父母想找个老师代管，才是背后真正的原因。

JSF就是程序员们所要寻找的老师，把代码片断交给JSF去管理，程序员就可以集中精力编写业务逻辑了。在JSF里，有四类事件。值改变事件，当用户在输入框中输入数据后发生；动作事件，当用户提交Form时发生；数据模型事件，当数据表的某行被选中时发生；生命周期事件，当生命周期从一个阶段进入另一个阶段时发生。除了生命周期事件，其他事件都是桌面程序中大家所熟知的，而生命周期事件可以想象成窗口事件，例如窗口的生成、关闭、激活等等。

谈到JSF，就不能不谈谈JSF请求处理的生命周期。为什么很多人觉得JSF难学？都是生命周期惹的祸。JSP的生命周期只有一个阶段，而JSF却有 6个阶段！为什么要这样呢？其实，这是JSF框架所必需的。JSF只有细分生命周期阶段，才能对Request和Response施加粒度足够细的控制，因为JSP那样粗粒度的控制，不足以支撑UI组件模型和事件模式。

在我初学JSF时，生命周期成了我最大的障碍。不管我如何咬文嚼字地推敲JSF规范中关于生命周期的描述，我都无法弄明白到底专家们在说什么。甚至直到我完成了我的首个JSF程序的开发，我还是不懂。这让我十分的惴惴不安，时时担心自己误入歧途。奇怪的是，不论是Sun的Tutorial，还是JSF 的官方规范都把生命周期放在“头版头条”的位置，一开篇就大肆推销生命周期概念，生命周期真的那么重要吗？

这绝对是一个错误！生命周期是JSF的核心，但不是程序员的必修课，初涉JSF的程序员，根本没有必要浪费精力在生命周期晦涩的概念里纠缠，不懂生命周期，照样可以用JSF来编程。花很少的时间看看各个UI组件的功能和属性，然后弄明白各类事件的含义以及应该如何响应这些事件，了解一下JSF可配置的页面导航机制，再搞清楚Managed Bean是什么东西，马上就可以动手编写你的第一个JSF程序了！

生命周期当然重要，不理解生命周期是难以在JSF中深入下去的。但是，如果有机会让我来写JSF的入门教程的话，我会把生命周期放在最后一章，等大家都有了JSF的实践经验，对JSF是如何简化Java的Web编程有了感性的认识，再来深入剖析JSF的生命周期，才能水到渠成，一点就通。

冰封的爱 2007-07-12 16:36 发表评论

为Struts 2.0做好准备

冰封的爱 — Thu, 12 Jul 2007 07:25:00 GMT

摘要: Struts作为MVC 2的Web框架，自推出以来不断受到开发者的追捧，得到用广泛的应用。作为最成功的Web框架，Struts自然拥有众多的优点： MVC 2模型的使用功能齐全的标志库（Tag Library）开放源代码但是，所谓“金无赤金，人无完人”，Struts自身也有不少的缺点：需要编写的代码过多，容易引... 阅读全文

冰封的爱 2007-07-12 15:25 发表评论

使用 AppFuse 的七个理由

冰封的爱 — Thu, 12 Jul 2007 02:44:00 GMT

原文地址：http://www.ibm.com/developerworks/cn/java/j-appfuse/

AppFuse 是一个开放源码的项目和应用程序，它使用了在 Java 平台上构建的开放源码工具来帮助我们快速而高效地开发 Web 应用程序。从核心上来说，AppFuse 是一个项目骨架，类似于通过向导创建新 Web 项目时 IDE 所创建的东西。当我们使用 AppFuse 创建一个项目时，它会提示我们将使用开放源码框架，然后才创建项目。它使用 Ant 来驱动测试、代码生成、编译和部署。它提供了目录和包结构，以及开发基于 Java 语言的 Web 应用程序所需要的库。

AppFuse 提供了很多应用程序需要的一些特性，包括：

认证和授权
用户管理
Remember Me（这会保存您的登录信息，这样就不用每次都再进行登录了）
密码提醒
登记和注册
SSL 转换
E-mail
URL 重写
皮肤
页面修饰
模板化布局
文件上载

典型的 AppFuse 应用程序

理由 1：测试
AppFuse 的文档展示了如何测试应用程序的所有层次。它从数据库层开始入手，使用了 DbUnit（请参看参考资料）在运行测试之前提前使用数据来填充自己的数据库。在数据访问（DAO）层，它使用了 Spring 的 AbstractTransactionalDataSourceSpringContextTests 类（是的，这的确是一个类的名字！）来允许简单地加载 Spring 上下文文件。另外，这个类对每个 testXXX() 方法封装了一个事务，并当测试方法存在时进行回滚。这种特性使得测试 DAO 逻辑变得非常简单，并且不会对数据库中的数据造成影响。

在服务层，jMock （请参看参考资料）用来编写那些可以消除 DAO 依赖的真正单元测试。这允许进行验证业务逻辑正确的快速测试；我们不用担心底层的持久性逻辑。

在 Web 层，测试会验证操作（Struts/WebWork）、控件（Spring MVC）、页面（Tapestry）和管理 bean（JSF）如我们所期望的一样进行工作。Spring 的 spring-mock.jar 可以非常有用地用来测试所有这些框架，因为它包含了一个 Servlet API 的仿真实现。如果没有这个有用的库，那么测试 AppFuse 的 Web 框架就会变得非常困难。

UI 通常是开发 Web 应用程序过程中最为困难的一部分。它也是顾客最经常抱怨的地方 —— 这既是由于它并不是非常完美，也是由于它的工作方式与我们期望的并不一样。另外，没有什么会比在客户面前作演示的过程中看到看到异常堆栈更糟糕的了！您的应用程序可能会非常可怕，但是客户可能会要求您做到十分完美。永远不要让这种事情发生。Canoo WebTest 可以对 UI 进行测试。它使用了 HtmlUnit 来遍历测试 UI，验证所有的元素都存在，并可以填充表单的域，甚至可以验证一个假想的启用 Ajax 的 UI 与我们预期的工作方式一样。（有关 WebTest 和 HTMLUnit 的链接请参看参考资料。）

为了进一步简化 Web 的测试，Cargo（请参看参考资料）对 Tomcat 的启动和停止（分别在运行 WebTest 测试之前和之后）进行了自动化。

理由 2：集成

编译、报告和代码生成：Ant、Ant Contrib Tasks、Checkstyle、EMMA、Java2Html、PMD 和 Rename Packages
测试框架：DbUnit、Dumbster、jMock、JUnit 和 Canoo WebTest
数据库驱动程序：MySQL 和 PostgreSQL
持久性框架：Hibernate 和 iBATIS
IoC 框架：Spring
Web 框架：JSF、Spring MVC、Struts、Tapestry 和 WebWork
Web 服务：XFire
Web 工具：Clickstream、Display Tag、DWR、JSTL、SiteMesh、Struts Menu 和 URL Rewrite Filter
Security：Acegi Security
JavaScript 和 CSS：Scriptaculous、Prototype 和 Mike Stenhouse 的 CSS Framework

理由 3：自动化

 理由 4：安全特性和可扩展性
Acegi Security 是 J2EE 安全模型中曾经出现过的最好模型。它让我们可以实现很多有用的特性，这些特性在 Servlet API 的安全模型中都不存在：认证、授权、角色保护方法、Remember Me、密码加密、SSL 切换、用户切换和注销。它让我们还可以将用户证书存储到 XML 文件、数据库、LDAP 或单点登录系统（例如 Yale 的 Central Authentication Service (CAS) 或者 SiteMinder）中。

理由 5：使用 AppGen 生成代码

AppFuse 中提供了一个基于 Ant 和 XDoclet 的代码生成工具，名叫 AppGen。默认情况下，常见的 DAO 和管理器都可以允许我们对任何普通老式 Java 对象（POJO）进行 CRUD 操作，但是在 Web 层上这样做有些困难。AppGen 有几个特性可以用来执行以下任务：

（使用 Middlegen 和 Hibernate 工具）从数据库表中生成 POJO
从 POJO 生成 UI
为 DAO、管理器、操作/控制器和 UI 生成测试

理由 6：文档

 理由 7：社区

参考资料

学习

您可以参阅本文在 developerWorks 全球站点上的英文原文。
AppFuse：该项目的主页。
AppFuse Demos：查看演示和视频。
Struts 2 和 JSF：了解为什么要将这些技术放到一起工作。
Sun 的 J2EE 项目目录结构指南：AppFuse 非常接近于这些指南。
Maven 的 Standard Directory Layout：AppFuse 2.0 将转换到这个目录结构上。
AppFuse 快速入门指南：快速入门并使用 AppFuse。
AppFuse 教程：深入学习更多有关使用 AppFuse 的知识。
Apache Axis 集成：如何将 Apache Axis 集成到自己的 AppFuse 项目中。
Java.net 项目状态：请查看 2005 年 1 月、2 月和 3 月的动态。还可以查看 java.net 上的最佳项目。

获得产品和技术

AppFuse on java.net：下载不同风味的 AppFuse。
WebWork：了解这个易于使用的 Web 框架。
DbUnit：查看更多有关 JUnit 扩展的内容。
jMock：创建动态仿真对象来简化真正的单元测试。
Canoo WebTest：自动化 Web 应用程序的 UI 测试。
HtmlUnit：WebTest 的优秀 JavaScript 支持背后的基础。
Cargo：自动启动和停止容器。
Greenbox：一种代码生成框架。

讨论

AppFuse 论坛：与同行开发人员交流技巧。

冰封的爱 2007-07-12 10:44 发表评论

appfuse 源码分析(web)

冰封的爱 — Thu, 12 Jul 2007 02:43:00 GMT

摘要: appfuse 的web包下有这么几个包org.appfuse.webapp.action：org.appfuse.webapp.filter:org.appfuse.webapp.listerner:org.appfuse.webapp.taglib:org.appfuse.webapp.util jsf 它有自己的配制文件位于/ WEB-INF/faces-config.xml... 阅读全文

冰封的爱 2007-07-12 10:43 发表评论

BlogJava-.№爱の冰封-文章分类-J2EE

大型B/S系统的并发问题

定义一个内部类的比较器，比较两个对象并且进行排序

Spring+hibernate+DWR整合

获得汉字拼音首字母(java版)

根据拼音首字母查询人名(C#版)

java开源项目

在 Java 应用程序中计划重复执行的任务(转)

如何使用ejb3持久化中callback

EJB3 QL查询

EJB3 QL查询

Query接口

简单查询

使用参数查询

排序(order by)

查询部分属性

查询中使用构造器(Constructor)

聚合查询(Aggregation)

关联(join)

比较Entity

批量更新(Batch Update)

批量删除(Batch Remove)

使用操作符NOT

使用操作符BETWEEN

使用操作符IN

使用操作符LIKE

使用操作符IS NULL

使用操作符IS EMPTY

使用操作符EXISTS

使用操作符ALL/SOME/ANY

字符串函数

计算函数

子查询

mssql2000数据库使用备份还原造成的孤立用户和对象名‘XX’无效的解决办法

JDK1.5新特性之Java Generics

在 JBoss 4.0.5GA 上使用应用程序自己的 log4j 配置

Oracle PL/Sql循序渐进全面学习教程

JBoss 4.0.2集群指南(二)----建立JMS集群服务

JBoss 4.0.2集群指南(一)

EJB client调用EJB3 (转)

关于JNDI and EJB

开发、调试和测试EJB3 APP(转)

JBoss下数据源密码加密

Appfuse 增量式开发步骤

Appfuse开发指南

AppFuse快速起步指南

MSSQL2000还原数据库,更改用户登陆权限

Hibernate与ibatis

Hibernate

一、 基本功能

二、使用步骤

Ibatis

一、基本功能

二、使用步骤

DWR学习

在JSP裏混用JSF元件與HTML/JavaScript，輸出到Client時會被分離之迷解答

看别人怎么学JSF的

为Struts 2.0做好准备

使用 AppFuse 的七个理由

appfuse 源码分析(web)

一、基本功能