精品国产亚洲AV麻豆,2048亚洲精品国产,亚洲A∨精品一区二区三区

struts2 基础

Sheldon Sun — Tue, 29 Mar 2011 04:07:00 GMT

action extends ActionSupport abstract class, because it already provide some default operation(input, createErrorMessage).
property is set by reflect to action, and pass to jsp(jsp is filled with these properties, jsp is a servlet, what it returned to user is HTML file)
static validate happened in action method(override ActionSupport method), dynamic validation happened in action layer.
change dynamic property file value in this way : thankyou=Thank you for registerling %{personBean.firstName}, Resource file can be deployed in action layer, package layer and global layer
exception can be configured in bellow way:



        /securityerror.jsp
/error.jsp
Wildcard Method Selection: flexible but not useful()
integrate spring & struts 2 way: use spring plugin, main point is who to maintain action creation(spring || action), better choice is spring, you can enjoy great function of spring.
Add Convention Plugin to so that you can use annotation
intercepter can be configured in action level and package level.

Sheldon Sun 2011-03-29 12:07 发表评论

�?用Spring快速开发jms应用�Q�JBOSS服务器）

Sheldon Sun — Wed, 23 Mar 2011 06:49:00 GMT

http://www.tkk7.com/keweibo/articles/175545.html

异步�q�程通信是面向服务架�?SOA)一个重要的�l�成部分�Q�因��Z��业里很多�pȝ��通信�Q�特别是与外部组�l�间的通信�Q�实质上都是异步的�?a style="color: rgb(52,104,164)" target="_blank">Java消息服务(JMS)是用于编写��用异步消息传递的JEE应用�E�序的API。传�l�的使用JMS API�q�行消息传递的实现包括多个步骤�Q�例如JNDI查询队列�q�接工厂和Queue资源�Q�在实际发送和接收消息前创��Z��个JMS会话�?

　　 Spring框架则简化了使用JEE�l��g(包括JMS)的�Q务。它提供的模板机刉��藏了典型的JMS实现的细节，�q�样开发�h员可以集中精力放在处理消息的实际工作中，而不用担心如何去创徏�Q�访问或清除JMS资源�?/p>

　　本文��对Spring JMS API作一个概�q�ͼ��q��过一个运行在JBoss MQ服务器上的web例程来介�l�如何��用Spring JMS API来异步处理（发送和接收�Q�消息。我��通过传统JMS实现和Spring JMS实现两者间的比较，来展�C�Z��用Spring JMS处理消息是如何的��单和灉|��?/p>

异步消息传递和面向服务架构

　　在现实中�Q�大多数web��h��都是同步处理的。例如，当用戯��d��一个网站，首先输入用户名和密码�Q�然后服务器验证��d��合法性。如果验证成功，�E�序��允许该用户�q�入�|�站。这里，��d��h��在从客户端接收以后被��x��处理了。信用卡验证是另一个同步处理的例子�Q�只有服务器证实输入的信用卡��h��有效的，同时客户在帐户上有��够的存款�Q�客��h��被允许��l�操作。但是让我们思考一下在��序处理�pȝ��上的支付�l�算步骤。一旦系�l�证实该用户信用卡的信息是准��的�Q��ƈ且在帐户上有��_��的资金，��׃��必等到所有的支付�l�节落实、�{账完成。支付结��可以异步方式进行，�q�样客户可以�l�箋�q�行核查操作�?/p>

　　需要比典型同步��h��耗费更长旉��的请求，可以使用异步处理。另一个异步处理的例子是，在本地贷�Ƒ֤�理程序中�Q�提交至自动扉K��pȝ��Q�AUS�Q�的信用��h��处理�q�程。当借方提交��h��甌��后，抉|��公司会向AUS发送请求，以获取信用历史记录。由于这个请求要求得到全面而又详细的信用报告，包括借方��C��和过�ȝ��帐户�Q�最�q�的付款和其他胦务资料，服务器需要耗费较长的时��_��几小时或着有时甚至是几天）来对�q�些��h��作出响应。客��L��E�序�Q�应用）要与服务器连接�ƈ耗费如此长的旉��来等待结果，�q�是毫无意义的。因此通信应该是异步发生的�Q�也��是�Q�一旦请求被提交�Q�它��p��攄��在队列中�Q�同时客��L��与服务器断开�q�接。然后AUS服务从指定的队列中选出��h��q�行处理�Q��ƈ��处理得到的消息攄��在另一个消息队列里。最后，客户端程序从�q�个队列中选出处理�l�果�Q�紧接着处理�q�个信用历史数据�?/p>

JMS

　　如果您��用过JMS代码�Q�您会发现它与JDBC或JCA很像。它所包含的样本代码创建或JMS资源对象回溯�Q��得每一�ơ您需要写一个新�c�L��发送和接收消息�Ӟ��都具有更好的代码密集性和重复性。以下序列显�C�Z��传统JMS实现所包括的步骤：

创徏JNDI初始上下文（context�Q��?/li>
从JNDI上下文获取一个队列连接工厂�?/li>
从队列连接工厂中获取一个Quene�?/li>
创徏一个Session对象�?/li>
创徏一个发送者（sender�Q�或接收者（receiver�Q�对象�?/li>
使用步骤5创徏的发送者或接收者对象发送或接收消息�?/li>
处理完消息后�Q�关闭所有JMS资源�?/li>

您可以看刎ͼ�步骤6是处理消息的唯一地方。其他步骤都只是��理与实际业务要求无关的JMS资源�Q�但是开发�h员必��ȝ��写�ƈ�l�护�q�些额外步骤的代码�?/p>

Spring JMS

　　 Spring框架提供了一个模板机制来隐藏Java APIs的细节。JEE开发�h员可以��用JDBCTemplate和JNDITemplate�c�L��分别讉K��后台数据库和JEE资源�Q�数据源�Q�连接池�Q�。JMS也不例外。Spring提供JMSTemplate�c�，因此开发�h员不用�ؓ一个JMS实现�ȝ��写样本代码。接下来是在开发JMS应用�E�序时Spring所��h��一些的优势�?/p>

提供JMS抽象API�Q�简化了讉K��目标�Q�队列或主题�Q�和向指定目标发布消息时JMS的��用�?/li>
JEE开发�h员不需要关心JMS不同版本�Q�例如JMS 1.0.2与JMS 1.1�Q�之间的差异�?/li>
开发�h员不必专门处理JMS异常�Q�因为Spring为所有JMS异常提供了一个未�l�检查的异常�Q��ƈ在JMS代码中重新抛出�?/li>

�C�Z��E�序

说明�Q�因为只是�ؓ了演�C�如何��用spring�~�写jms的应用，所以本例没有什么实际用途�?/p>

�E�序功能�Q�MessageProducer.java�Ҏ��一用户信息产生一个消息发送到 JMS Provider�Q�由MessageConsumer.java接收�?/p>

1.在Jboss里配�|�XML文�g创徏一个新的JMS provider�?br /> 打开位于%JBOSS_HOME%server\default\deploy\jms文�g夹下的jbossmq-destinations-service.xml文�g�Q�加入以下代码片断：

   name="jboss.mq.destination:service=Queue,name=registerUserQueue">
   jboss.mq:service=DestinationManager

name="jboss.mq.destination:service=Topic,name=registerUserTopic">
   jboss.mq:service=DestinationManager

2.在spring的配�|�文件中配置JMS�l��g的具体细节�?br /> �Q?�Q�JNDI上下文是取得JMS资源的�v始位�|�，因此首先我们要配�|�JNDI模板�Q?br />




       org.jnp.interfaces.NamingContextFactory

      localhost

       org.jnp.interfaces:org.jboss.naming




   注意�Q�此JNDI模板用到了org.jnp.interfaces.NamingContextFactory所以要�?JBOSS_HOME%\client下的jbossall-client.jar加到你的��目的classpath中�?br /> �Q?�Q�配�|�连接工厂：






     XAConnectionFactory


   注意�Q�XAConnectionFactory�q�个JNDI名字是在%JBOSS_HOME%server\default\deploy\jms文�g夹下的jms-ds.xml中定义的(它是由JBoss指定�?�?br /> �Q?�Q�配�|�JmsTemplate�l��g。在例程中我们��用JmsTemplate102。同时��用defaultDestination属性来指定JMS目标�?br />




    true



         30000


  注意�Q�如果��用topic-subscribe(主题订阅)模式�Q�该模板的pubSubDomain属性��gؓtrue;若��用PToP(点对�?模式�Q�pubSubDomain属性��gؓfalse或不配置该属性�?br /> (4)定义一个JMS目标来发送和接收消息:





    topic/registerUserTopic


(5)配置发送者和接收者组�?








3.相应的类:
(1). User对象�?br /> /**
   * User.java
   * created on Jul 2, 2006
   * Copyrights 2006 BOCO,Inc. All rights reserved.
   */
  package com.boco.dto;

  import java.io.Serializable;

  /**
   * desc: 用户信息 Bean
   * @author qiujy
   */
  public class User {
   private int id;
   private String username;
   private String password;
   private String email;

   public User(){}

   //以下为Getter,setter�Ҏ��?br />    ......
  }

(2).消息生��者：
   /**
   * MessageProducer.java
   * created on Jul 22, 2006
   * Copyrights 2006 BOCO,Inc. All rights reserved.
   */
  package com.boco.jms;

  import javax.jms.JMSException;
  import javax.jms.MapMessage;
  import javax.jms.Message;
  import javax.jms.Session;

  import org.springframework.jms.core.JmsTemplate;
  import org.springframework.jms.core.MessageCreator;

  import com.boco.dto.User;

  /**
   * desc:消息生��?br />    * @author qiujy
   *
   */
  public class MessageProducer {
   /** JMS模板 */
   private JmsTemplate jmsTemplate;

   public void setJmsTemplate(JmsTemplate jmsTemplate){
    this.jmsTemplate = jmsTemplate;
   }

   public void sendMessage(final User user){
    //调用模板的send来发送消�?br />     jmsTemplate.send(new MessageCreator(){

     public Message createMessage(Session session) throws JMSException {
      //构造一个要发送的消息
      MapMessage message = session.createMapMessage();
       message.setInt("id", user.getId());
       message.setString("username", user.getUsername());
       message.setString("password", user.getPassword());
       message.setString("email", user.getEmail());
      System.out.println("send success!!");
      return message;
     }
    });
   }
  }

(3).消息消费者：
  /**
   * MessageConsumer.java
   * created on Jul 22, 2006
   * Copyrights 2006 BOCO,Inc. All rights reserved.
   */
  package com.boco.jms;

  import javax.jms.JMSException;
  import javax.jms.MapMessage;

  import org.springframework.jms.core.JmsTemplate;

  import com.boco.dto.User;

  /**
   * desc:消息消费�?br />    * @author qiujy
   *
   */
  public class MessageConsumer {
   /** JMS模板 */
   private JmsTemplate jmsTemplate;

   public void setJmsTemplate(JmsTemplate jmsTemplate){
    this.jmsTemplate = jmsTemplate;
   }

   public User receiveMessage(){
    //参数为Destination的JNDI名字��L��前面的模式类型标�?br />     //MapMessage msg = (MapMessage)jmsTemplate.receive("registerUserQueue");
    MapMessage msg = (MapMessage)jmsTemplate.receive("registerUserTopic");
    User user = new User();

    try {
     user.setId(msg.getInt("id"));
     user.setUsername(msg.getString("username"));
     user.setPassword(msg.getString("password"));
     user.setEmail(msg.getString("email"));
    } catch (JMSException e) {
     // TODO Auto-generated catch block
     e.printStackTrace();
    }

    return user;
   }
  }

(4).��试用例�Q?br />    //======== 生��者测试用�?===============
   /**
   * TestMsgProducer.java
   * created on Jul 22, 2006
   * Copyrights 2006 BOCO,Inc. All rights reserved.
   */
  package com.boco.jms;

  import junit.framework.TestCase;

  import org.springframework.context.ApplicationContext;
  import org.springframework.context.support.ClassPathXmlApplicationContext;

  import com.boco.dto.User;

  /**
   * desc:
   * @author qiujy
   *
   */
  public class TestMsgProducer extends TestCase {

   private ApplicationContext context;
   /**
    * @param arg0
    */
   public TestMsgProducer(String arg0) {
    super(arg0);
    context = new ClassPathXmlApplicationContext("applicationContext_jms.xml");
   }

   /* (non-Javadoc)
    * @see junit.framework.TestCase#setUp()
    */
   protected void setUp() throws Exception {
    super.setUp();
   }

   /* (non-Javadoc)
    * @see junit.framework.TestCase#tearDown()
    */
   protected void tearDown() throws Exception {
    super.tearDown();
   }

   /**
    * Test method for {@link com.boco.jms.MessageProducer#sendMessage(com.boco.dto.User)}.
    */
   public void testSendMessage() {
    User user = new User();
    user.setId(132);
    user.setUsername("JMSTest");
    user.setPassword("password");
    user.setEmail("support@boco.com.cn");

    MessageProducer producer = (MessageProducer)context.getBean("msgProducer");

    producer.sendMessage(user);

   }

  }

  //============ 消费者测试用�?===============
  /**
   * TestMsgConsumer.java
   * created on Jul 22, 2006
   * Copyrights 2006 BOCO,Inc. All rights reserved.
   */
  package com.boco.jms;

  import junit.framework.TestCase;

  import org.springframework.context.ApplicationContext;
  import org.springframework.context.support.ClassPathXmlApplicationContext;

  import com.boco.dto.User;

  /**
   * desc:
   * @author qiujy
   *
   */
  public class TestMsgConsumer extends TestCase {
   private ApplicationContext context;
   /**
    * @param arg0
    */
   public TestMsgConsumer(String arg0) {
    super(arg0);
    context = new ClassPathXmlApplicationContext("applicationContext_jms.xml");
   }

   /* (non-Javadoc)
    * @see junit.framework.TestCase#setUp()
    */
   protected void setUp() throws Exception {
    super.setUp();
   }

   /* (non-Javadoc)
    * @see junit.framework.TestCase#tearDown()
    */
   protected void tearDown() throws Exception {
    super.tearDown();
   }

   /**
    * Test method for {@link com.boco.jms.MessageConsumer#receiveMessage()}.
    */
   public void testReceiveMessage() {
    MessageConsumer consumer = (MessageConsumer)context.getBean("msgConsumer");
    User user = consumer.receiveMessage();
    assertNotNull(user);
    System.out.println( "id========" + user.getId()
        + "\nname======" + user.getUsername()
        + "\npassword==" + user.getPassword()
        + "\nemail=====" + user.getEmail());
   }

  }

Sheldon Sun 2011-03-23 14:49 发表评论

concurrent

Sheldon Sun — Wed, 23 Mar 2011 05:25:00 GMT

AVA后台�E�序设计及UTIL.CONCURRENT包的应用

摘要 : 在很多��Y仉��目中�Q�JAVA语言常常被用来开发后台服务程序。线�E�池技术是提高�q�类�E�序性能的一个重要手�D�c��在实践中，该技术已�l�被�q�泛的��用。本文首�?对设计后台服务程序通常需要考虑的问题进行了基本的论�q�ͼ�随后介绍了JAVA�U�程池的原理、��用和其他一些相关问题，最后对功能强大的JAVA开放源码线 �E�池包util.concurrent 在实际编�E�中的应用进行了详细介绍�?br /> 关键�? JAVA�Q�线�E�池�Q�后台服务程序；util.concurrent

1 引言
在��Y仉��目开发中�Q�许多后台服务程序的处理动作��程都具有一个相同点�Q�就是：接受客户端发来的��h��Q�对��h��q�行一些相关的处理�Q�最后将处理�l�果�q�回�l�客�?端。这些请求的来源和方式可能会各不相同�Q�但是它们常帔R��有一个共同点�Q�数量巨大，处理旉��短。这�c�L��务器在实际应用中��h��较大的普遍性，如web服务器，短信服务器，DNS服务器等�{�。因此，研究如何提高此类后台�E�序的性能�Q�如何保证服务器的稳定性以及安全性都��h��重要的实用�h倹{�?br />
2 后台服务�E�序设计
2.1 关于设计原型
构徏服务器应用程序的一个简单的模型是：启动一个无限��@环，循环里放一个监听线�E�监听某个地址端口。每当一个请求到辑ְ�创徏一个新�U�程�Q�然后新�U�程��求服务，监听�U�程�q�回�l�箋监听�?br /> ��单�D例如下：
import java.net.*;
public class MyServer extends Thread{
public void run(){
try{
ServerSocket server=null;
Socket clientconnection=null;
server = new ServerSocket(8008);//监听某地址端口�?br /> while(true){�q�入无限循环
clientconnection =server.accept();//收取��h��
new ServeRequest(clientconnection).start();//启动一个新服务�U�程�q�行服务
……
}
}catch(Exception e){
System.err.println("Unable to start serve listen:"+e.getMessage());
e.printStackTrace();
}
}
}
实际上，�q�只是个��单的原型�Q�如果试��N��|�以�q�种方式�q�行的服务器应用�E�序�Q�那么这�U�方法的严重不��很明显�?br /> 首先�Q��ؓ每个��h��创徏一个新�U�程的开销很大�Q��ؓ每个��h��创徏新线�E�的服务器在创徏和销毁线�E�上��p��的时间和消耗的�pȝ��资源, 往往有时候要比花在处理实际的用户��h��的时间和资源更多。在Java中更是如此，虚拟机将试图跟踪每一个对象，以便能够在对象销毁后�q�行垃圾回收。所以提高服务程序效率的一个手�D�就是尽可能减少创徏和销毁对象的�ơ数。这��L��合看来，�pȝ��的性能瓉��在于线�E�的创徏开销�?br /> 其次�Q�除了创建和销毁线�E�的开销之外�Q�活动的�U�程也消耗系�l�资源。在一�?JVM 里创建太多的�U�程可能会导致系�l�由于过度消耗内存而用完内存或“切换�q�度”。�ؓ了防止资源不��I��服务器应用程序需要一些办法来限制��M��l�定时刻�q�行的处�?�U�程数目�Q�以防止服务器被“压死”的情况发生。所以在设计后台�E�序的时候，一般需要提前根据服务器的内存、CPU�{�硬件情况设定一个线�E�数量的上限倹{�?br /> 如果创徏和销毁线�E�的旉��相对于服务时间占用的比例较大�Q�那末假讑֜�一个较短的旉��内有成千上万的请求到达，惌��一下，服务器的旉��和资源将会大量的花在创徏和销毁线�E�上�Q�而真正用于处理请求的旉��却相对较��，�q�种情况下，服务器性能瓉��在于创建和销毁线�E�的旉��。按照这个模型写一个简单的�E�序��试一�?卛_��看出�Q�由于篇�q�关�p�，此处略。如果把�Q�服务时�?创徏和销毁线�E�的旉��Q�作��量服务器性能的一个参敎ͼ�那末�q�个比��D��大，服务器的性能��p��高�?br /> 应此�Q�解��x��c�问题的实质��是��量减少创徏和销毁线�E�的旉��Q�把服务器的资源��可能多地用到处理请求上来，从而发挥多�U�程的优点（�q�发�Q�，避免多线�E�的�~�点�Q�创建和销毁的时空开销�Q��?br /> �U�程池�ؓ�U�程生命周期开销问题和资源不��问题提供了解决�Ҏ��。通过对多个�Q务重用线�E�，�U�程创徏的开销被分摊到了多个�Q务上。其好处是，因�ؓ在请求到达时 �U�程已经存在�Q�所以无意中也消除了�U�程创徏所带来的�g�q�。这��P��可以立即�ؓ��h��服务�Q��应用�E�序响应更快。而且�Q�通过适当地调整线�E�池中的�U�程数目�Q�也 ��是当请求的数目��过某个阈值时�Q�就强制其它��M��新到的请求一直等待，直到获得一个线�E�来处理为止�Q�从而可以防止资源不��?br />
3　　　　JAVA�U�程池原�?br /> 3.1 原理以及实现
在实践中�Q�关于线�E�池的实现常常有不同的方法，但是它们的基本思�\大都是相似的�Q�服务器预先存放一定数目的“�?#8221;的线�E�，�q�发�E�序需要��用线�E�的时候，�?服务器取用一条已�l�创建好的线�E�（如果�U�程池�ؓ�I�则�{�待�Q�，使用该线�E�对��h��服务�Q��用结束后�Q�该�U�程�q�不删除�Q�而是�q�回�U�程池中�Q�以备复用，�q�样可以�?免对每一个请求都生成和删除线�E�的昂贵操作�?br /> 一个比较简单的�U�程池至��应包含�U�程池管理器、工作线�E�、�Q务队列、�Q务接口等部分。其中线�E�池��理器（ThreadPool Manager�Q�的作用是创建、销毁�ƈ��理�U�程池，��工作线�E�放入线�E�池中；工作�U�程是一个可以��@环执行�Q务的�U�程�Q�在没有��d��时进行等待；��d��队列的作用是提供一�U�缓冲机�Ӟ��没有处理的��d��攑֜��d��队列中；��d��接口是每个�Q务必��d��现的接口�Q�主要用来规定�Q务的入口、�Q务执行完后的收尾工作、�Q务的�?行状态等�Q�工作线�E�通过该接口调度�Q务的执行。下面的代码实现了创��Z��个线�E�池�Q?br /> public class ThreadPool
{
private Stack threadpool = new Stack();
private int poolSize;
private int currSize=0;
public void setSize(int n)
{
poolSize = n;
}
public void run()
{
for(int i=0;i
(发帖旉��:2003-11-30 11:55:56)
---岑心 J

回复(1):

4.2　　　　框架与结�?br /> 下面让我们来看看util.concurrent的框架结构。关于这个工具包概述的e文原版链接地址是http: //gee.cs.oswego.edu/dl/cpjslides/util.pdf。该工具包主要包括三大部分：同步、通道和线�E�池执行器。第一部分主要是用来定刉��Q�资源管理，其他的同步用途；通道则主要是为缓冲和队列服务的；�U�程池执行器则提供了一�l�完善的复杂的线�E�池实现�?br /> --主要的结构如下图所�C?br />
4.2.1 Sync
acquire/release协议的主要接�?br /> - 用来定制锁，资源��理�Q�其他的同步用�?br /> - 高层抽象接口
- 没有区分不同的加锁用�?br />
实现
-Mutex, ReentrantLock, Latch, CountDown,Semaphore, WaiterPreferenceSemaphore, FIFOSemaphore, PrioritySemaphore
�q�有�Q�有几个��单的实现�Q�例如ObservableSync, LayeredSync

举例�Q�如果我们要在程序中获得一独占锁，可以用如下简单方式：
try {
lock.acquire();
try {
action();
}
finally {
lock.release();
}
}catch�Q�Exception e�Q�{
}

�E�序�?使用lock对象的acquire()�Ҏ��获得一独占锁，然后执行您的操作�Q�锁用完后，使用release()�Ҏ��释放之即可。呵呵，��单吧�Q�想想看�Q�如果您亲自撰写独占锁，大概会考虑到哪些问题？如果关键的锁得不到怎末办？用�v来是不是会复杂很多？而现在，以往的很多细节和�Ҏ��异常情况在这里都无需多考虑�Q�您��可以把�_�֊�花在解决您的应用问题上去�?br />
4.2.2 通道(Channel)
为缓�Ԍ��队列�{�服务的��L��?br />
具体实现
LinkedQueue, BoundedLinkedQueue,BoundedBuffer, BoundedPriorityQueue, SynchronousChannel, Slot

通道例子
class Service { // ...
final Channel msgQ = new LinkedQueue();
public void serve() throws InterruptedException {
String status = doService();
msgQ.put(status);
}
public Service() { // start background thread
Runnable logger = new Runnable() {
public void run() {
try {
for(;;)
System.out.println(msqQ.take());
}
catch(InterruptedException ie) {} }
};
new Thread(logger).start();
}
}
在后台服务器中，�~�冲和队列都是最常用到的。试惻I��如果�Ҏ��有远端的��h��不排个队列，让它们一拥而上的去争夺cpu、内存、资源，那服务器瞬间不当掉才怪。而在�q�里�Q�成熟的队列和缓冲实现已�l�提供，您只需要对其进行正��初始化�q��用即可，大大�~�短了开发时间�?br />
4.2.3执行�?Executor)
Executor是这里最重要、也是我们往往最�l�写�E�序要用到的�Q�下面重点对其进行介�l��?br /> �c�M��U�程的类的主接口
- �U�程�?br /> - 轻量�U�运行框�?br /> - 可以定制调度��法

只需要支持execute(Runnable r)
- 同Thread.start�c�M��

实现
- PooledExecutor, ThreadedExecutor, QueuedExecutor, FJTaskRunnerGroup

PooledExecutor�Q�线�E�池执行器）是个最常用到的�c�，以它��Z��Q?br /> 可修改得属性如下：
- ��d��队列的类�?br /> - 最大线�E�数
- 最��线�E�数
- 预热(预分�?和立�?分配)�U�程
- 保持�z�跃直到工作�U�程�l�束
-- 以后如果需要可能被一个新的代�?br /> - 饱和(Saturation)协议
-- ��d��Q�丢弃，生��者运行，�{�等

可不要小看上面这数条属性，对这些属性的讄��完全可以�{�同于您自己撰写的线�E�池的成百上千行代码。下面以�W�者撰写过得一个GIS服务器�ؓ例：
该GIS服务器是一个典型的“��h��Q�服�?#8221;�c�d��的服务器�Q�遵循后端程序设计的一般框架。首先对所有的��h��按照先来先服务排入一个请求队列，如果瞬间到达�?��h��过了请求队列的定w��Q�则��溢出的��h��转移至一个��旉��列。如果��旉��列也排满了，则对以后辑ֈ�的请求给予一�?#8220;服务器忙”的提�C�后��其��单抛弃。这个就够忙�z�M��늚�了�?br /> 然后�Q�结合链表结构实��C��个线�E�池�Q�给池一个初始容量。如果该池满�Q�以x2的策略将池的定w��动态增加一倍，依此�c�L��Q�直到�ȝ��E�数服务辑ֈ��pȝ��能力上限�Q?之后�U�程池容量不在增加，所有请求将�{�待一个空余的�q�回�U�程。每从池中得��C��个线�E�，该线�E�就开始最��h��q�行GIS信息的服务，如取坐标、取地图�Q�等�{��?服务完成后，该线�E�返回线�E�池�l�箋��求队列离地后�l�请求服务，周而复始。当时用矢量链表来暂存请求，用wait()�?notify() �?synchronized�{�原语结合矢量链表实现线�E�池�Q��d��U?00行程序，而且在运行时间较长的情况下服务器不稳定，�U�程池被取用的线�E�有异常消失�?情况发生。而��用util.concurrent相关�c�M��后，仅用了几十行�E�序��完成了相同的工作而且服务器运行稳定，�U�程池没有丢��q��E�的情况发生。由此可见util.concurrent包极大的提高了开发效率，为项目节省了大量的时间�?br /> 使用PooledExecutor例子
import java.net.*;
/**
*

Title:

Description: 负责初始化线�E�池以及启动服务�?/span>

Company:

* @author not attributable
* @version 1.0
*/
public class MainServer {
//初始化常�?br /> public static final int MAX_CLIENT=100; //�pȝ��最大同时服务客��h��
//初始化线�E�池
public static final PooledExecutor pool =
new PooledExecutor(new BoundedBuffer(10), MAX_CLIENT); //chanel定w��?0,
//在这里�ؓ�U�程池初始化了一�?br /> //长度�?0的�Q务缓冲队列�?br />
public MainServer() {
//讄��U�程池运行参�?br /> pool.setMinimumPoolSize(5); //讄��U�程池初始容量�ؓ5个线�E?br /> pool.discardOldestWhenBlocked();//对于��出队列的请求，使用了抛弃策略�?br /> pool.createThreads(2); //在线�E�池启动的时候，初始化了��h��一定生命周期的2�?#8220;�?#8221;�U�程
}

public static void main(String[] args) {
MainServer MainServer1 = new MainServer();
new HTTPListener().start();//启动服务器监听和处理�U�程
new manageServer().start();//启动��理�U�程
}
}

�c�HTTPListener
import java.net.*;
/**
*

Title:

Description: 负责监听端口以及��Q务交�l�线�E�池处理

Company:

* @author not attributable
* @version 1.0
*/

public class HTTPListener extends Thread{
public HTTPListener() {
}
public void run(){
try{
ServerSocket server=null;
Socket clientconnection=null;
server = new ServerSocket(8008);//服务套接字监听某地址端口�?br /> while(true){//无限循环
clientconnection =server.accept();
System.out.println("Client connected in!");
//使用�U�程池启动服�?br /> MainServer.pool.execute(new HTTPRequest(clientconnection));//如果收到一个请求，则从�U�程池中取一个线�E�进行服务，��d��完成后，该线�E�自动返�q�线�E�池
}
}catch(Exception e){
System.err.println("Unable to start serve listen:"+e.getMessage());
e.printStackTrace();
}
}
}

关于util.concurrent工具包就有选择的介�l�到�q�，更详�l�的信息可以阅读�q�些java源代码的API文档。Doug Lea是个很具�?#8220;open”�_��的作者，他将util.concurrent工具包的java源代码全部公布出来，有兴��的读者可以下载这些源代码�q�细 �l�品呟�?span class="Apple-converted-space">

5　　　　�l�束�?br /> 以上内容介绍了线�E�池基本原理以及设计后台服务�E�序应考虑到的问题�Q��ƈ�l�合实例详细介绍了重要的多线�E�开发工具包util.concurrent的构架和使用。结合��用已有完善的开发包�Q�后端服务程序的开发周期将大大�~�短�Q�同时程序性能也有了保障�?br />

Sheldon Sun 2011-03-23 13:25 发表评论

JAVA事务,JTA,JDBC,JDO,DAO,JNDI概念

Sheldon Sun — Tue, 22 Mar 2011 09:35:00 GMT

引用http://dyldragon.javaeye.com/blog/789374

一、什么是Java事务

通常的观念认为，事务仅与数据库相兟�?/span>
事务必须服从ISO/IEC所制定�?/span>ACID原则�?/span>

ACID是原子性（atomicity�Q�、一致性（consistency�Q�、隔��L��（isolation�Q�和持久性（durability�Q�的�~�写�?/span>

事务的原子性表�C�Z��务执行过�E�中的�Q何失败都��导致事务所做的��M��修改失效�?/span>

一致性表�C�当事务执行��p�|�Ӟ��所有被该事务媄响的数据都应该恢复到事务执行前的状态�?/span>

隔离性表�C�在事务执行�q�程中对数据的修改，在事务提交之前对其他事务不可见�?/span>

持久性表�C�已提交的数据在事务执行��p�|�Ӟ��数据的状态都应该正确�?/span>

通俗的理解，事务是一�l�原子操作单元，从数据库角度��_��是一�l?/span>SQL指��o�Q�要么全部执行成功，若因为某个原因其中一条指令执行有错误�Q�则撤销先前执行�q�的所有指令。更��{�的说就是：要么全部执行成功�Q�要么撤销不执行�?/span>

既然事务的概念从数据库而来�Q�那Java事务是什么？之间有什么联�p�？实际上，一�?/span>Java应用�pȝ��Q�如果要操作数据库，则通过JDBC来实现的。增加、修攏V��删除都是通过相应�Ҏ��间接来实现的�Q�事务的控制也相应�{�U�d��Java�E�序代码中。因此，数据库操作的事务习惯上就�U�CؓJava事务�?/span>

二、�ؓ什么需要事�?/span>

事务是�ؓ解决数据安全操作提出的，事务控制实际上就是控制数据的安全讉K��。具一个简单例子：比如银行转帐业务�Q��̎�?/span>A要将自己账户上的1000 元�{�?/span>B账户下面�Q?/span>A账户余额首先要减�?/span>1000元，然后B账户要增�?/span>1000元。假如在中间�|�络出现了问题，A账户减去1000元已�l�结束，B因�ؓ�|�络中断而操作失败，那么整个业务��p�|�Q�必��d��出控�Ӟ��要求A账户转帐业务撤销。这才能保证业务的正��性，完成�q�个操走��需要事务，��?/span>A账户资金减少�?/span>B账户资金增加方到一个事务里面，要么全部执行成功�Q�要么操作全部撤销�Q�这样就保持了数据的安全性�?/span>

三�?/span>Java事务的类�?/span>
Java 事务的类型有三种�Q?/span>JDBC事务�?/span>JTA(Java Transaction API)事务、容器事务�?/span>
1�?/span>JDBC事务
JDBC 事务是用 Connection 对象控制的�?/span>JDBC Connection 接口( java.sql.Connection )提供了两�U�事务模式：自动提交和手工提交�?/span> java.sql.Connection 提供了以下控制事务的�Ҏ��Q?/span>

public void setAutoCommit(boolean)
public boolean getAutoCommit()
public void commit()
public void rollback()
使用 JDBC 事务界定�Ӟ��您可以将多个 SQL 语句�l�合��C��个事务中�?/span>JDBC 事务的一个缺�Ҏ��事务的范围局限于一个数据库�q�接。一�?/span> JDBC 事务不能跨越多个数据库�?/span>
2�?/span>JTA(Java Transaction API)事务
JTA 是一�U�高层的�Q�与实现无关的，与协议无关的API�Q�应用程序和应用服务器可以��?/span>JTA来访问事务�?/span>
JTA允许应用�E�序执行分布式事务处�?/span>--在两个或多个�|�络计算��源上讉K��q�且更新数据�Q�这些数据可以分布在多个数据库上�?/span>JDBC驱动�E�序�?/span>JTA支持极大地增��Z��数据讉K��能力�?/span>
如果计划�?/span> JTA 界定事务�Q�那么就需要有一个实�?/span> javax.sql.XADataSource �?/span> javax.sql.XAConnection �?/span> javax.sql.XAResource接口�?/span> JDBC 驱动�E�序。一个实��C��q�些接口的驱动程序将可以参与 JTA 事务。一�?/span> XADataSource 对象��是一�?/span>XAConnection 对象的工厂�?/span> XAConnection s 是参�?/span> JTA 事务�?/span> JDBC �q�接�?/span>
您将需要用应用服务器的��理工具讄�� XADataSource 。从应用服务器和 JDBC 驱动�E�序的文档中可以了解到相关的指导�?/span>
J2EE 应用�E�序�?/span> JNDI 查询数据源。一旦应用程序找��C��数据源对象，它就调用 javax.sql.DataSource.getConnection() 以获得到数据库的�q�接�?/span>
XA �q�接与非 XA �q�接不同。一定要��C�� XA �q�接参与�?/span> JTA 事务。这意味着 XA �q�接不支�?/span> JDBC 的自动提交功能。同�Ӟ��应用�E�序一定不要对 XA �q�接调用 java.sql.Connection.commit() 或�?/span> java.sql.Connection.rollback() 。相反，应用�E�序应该使用 UserTransaction.begin()�?/span> UserTransaction.commit() �?/span> serTransaction.rollback() �?/span>

3、容器事�?/span>
容器事务主要�?/span>J2EE应用服务器提供的�Q�容器事务大多是��Z��JTA完成�Q�这是一个基�?/span>JNDI的，相当复杂�?/span>API实现。相对编码实�?/span>JTA 事务��理�Q�我们可以通过EJB容器提供的容器事务管理机�Ӟ��CMT�Q�完成同一个功能，�q�项功能�?/span>J2EE应用服务器提供。这使得我们可以��单的指定��哪个方法加入事务，一旦指定，容器��负责事务管理�Q务。这是我们土建的解决方式�Q�因为通过�q�种方式我们可以��事务代码排除在逻辑�~�码之外�Q�同时将所有困难交�l?/span> J2EE容器去解冟뀂��?/span>EJB CMT的另外一个好处就是程序员无需兛_��JTA API的编码，不过�Q�理��Z��我们必须使用EJB�?/span>
四、三�U�事务差�?/span>
1�?/span>JDBC事务控制的局限性在一个数据库�q�接内，但是其��用简单�?/span>
2�?/span>JTA事务的功能强大，事务可以跨越多个数据库或多个DAO�Q��用也比较复杂�?/span>
3、容器事务，主要指的�?/span>J2EE应用服务器提供的事务��理�Q�局限于EJB应用使用�?/span>

JTA

Java事务API�Q�JTA�Q�Java Transaction API�Q�和它的同胞Java事务服务(JTS�Q�Java Transaction Service)�Q��ؓJ2EE�q�_��提供了分布式事务服务。一个分布式事务�Q�distributed transaction�Q�包括一个事务管理器�Q�transaction manager�Q�和一个或多个资源��理�?resource manager)。一个资源管理器�Q�resource manager�Q�是��L��c�d��的持久化数据存储。事务管理器�Q�transaction manager�Q�承担着所有事务参与单元者的�怺�通讯的责仅R��下图显�C�Z��事务��理器和资源��理的间的关�p�R�?/span>

JTA事务比JDBC事务更强大。一个JTA事务可以有多个参与者，而一个JDBC事务则被限定在一个单一的数据库�q�接�?/span>下列��M��个Java�q�_��的组仉��可以参与��C��个JTA事务中：

JDBC�q�接

JDO PersistenceManager 对象
JMS 队列
JMS 主题
企业JavaBeans�Q�EJB�Q?/span>
一个用J2EE Connector Architecture 规范�~�译的资源分配器�?/span>

DAO

DAO是Data Access Object数据讉K��接口�Q�数据访问：��֐�思义��是与数据库打交道。夹在业务逻辑与数据库资源中间。对数据库进行CURD�Q�增删查�Ҏ��作）�?/span>

　　在核�?/span>J2EE模式中是�q�样介绍DAO模式的：��Z��建立一个健壮的J2EE应用�Q�应该将所有对数据源的讉K��操作抽象��装在一个公共API中。用�E�序设计的语�a�来说�Q�就是徏立一个接口，接口中定义了此应用程序中��会用到的所有事务方法。在�q�个应用�E�序中，当需要和数据源进行交互的时候则使用�q�个接口�Q��ƈ且编写一个单独的�c�L��实现�q�个接口在逻辑上对应这个特定的数据存储�?/span>

JDBC

JDBC�Q�Java Data Base Connectivity,java数据库连接）是一�U�用于执行SQL语句的Java API�Q�可以�ؓ多种关系数据库提供统一讉K��Q�它�׃��l�用Java语言�~�写的类和接口组成。JDBC为工�?数据库开发�h员提供了一个标准的API�Q�据此可以构建更高��的工具和接口�Q��数据库开发�h员能够用�U?Java API �~�写数据库应用程序，同时�Q�JDBC也是个商标名�?/span>

有了JDBC�Q�向各种关系数据发送SQL语句��是一件很�Ҏ��的事。换�a�之，有了JDBC API�Q�就不必��问Sybase数据库专门写一个程序，��问Oracle数据库又专门写一个程序，或�ؓ讉K��Informix数据库又�~�写另一个程序等�{�，�E�序员只需用JDBC API写一个程序就够了�Q�它可向相应数据库发送SQL调用。同�Ӟ��Java语言和JDBC�l�合��h��使程序员不必��Z��同的�q�_��~�写不同的应用程序，只须写一遍程序就可以让它在�Q何��^��C��q�行�Q�这也是Java语言“�~�写一�ơ，处处�q�行”的优�ѝ�?/span>

��单地��_��JDBC 可做三�g事：与数据库建立�q�接、发�?操作数据库的语句�q�处理结果�?/span>

JDO

JDO(Java Data Object )是一个JAVA用于存取某种数据仓库中的对象的标准化API。JDO提供了透明的对象存储，因此对开发�h员来��_��存储数据对象完全不需要额外的代码�Q�如JDBC API的��用）。这些繁琐的例行工作已经转移到JDO产品提供商��n上，使开发�h员解脱出来，从而集中时间和�_�֊�在业务逻辑上。另外，JDO很灵�z�，因�ؓ它可以在��M��数据底层上运行。JDBC只是面向关系数据库（RDBMS�Q�JDO更通用�Q�提供到��M��数据底层的存储功能，比如关系数据库、文件、XML以及对象数据库（ODBMS�Q�等�{�，使得应用可移植性更强�?/span>

JNDI

英文全称�?Java Naming and Directory Interface

术语解释�Q�一�l�帮助做多个命名和目录服务接口的API�?/span>

JNDI(Java Naming and Directory Interface)是SUN公司提供的一�U�标准的Java命名�pȝ��接口�Q�JNDI提供�l�一的客��L��API�Q�通过不同的访问提供者接口JNDI SPI的实玎ͼ��q��理者将JNDI API映射为特定的命名服务和目录系�l�，使得Java应用�E�序可以和这些命名服务和目录服务之间�q�行交互。集��JNDI实现了高可靠性JNDI[8]�Q�通过服务器的集群�Q�保证了JNDI的负载��^衡和错误恢复。在全局�׃�n的方式下�Q�集��中的一个应用服务器保证本地JNDI树的独立性，�q�拥有全局的JNDI树。每个应用服务器在把部��v的服务对象绑定到自己本地的JNDI树的同时�Q�还�l�定��C��个共享的全局JNDI树，实现全局JNDI和自�w�JNDI的联�p�R�?/span>

JNDI(Java Naming and Directory Interface)是一个应用程序设计的API�Q��ؓ开发�h员提供了查找和访问各�U?/span>

命名和目录服务的通用、统一的接口，�c�M��JDBC都是构徏在抽象层上�?/span>

JNDI可访问的现有的目录及服务有：DNS、XNam 、Novell目录服务、LDAP(Lightweight Directory Access Protocol ��d��目录讉K��协议)�?CORBA对象服务、文件系�l�、Windows XP/2000/NT/Me/9x的注册表、RMI�?/span>

DSML v1&v2、NIS�?/span>

JNDI与JDBC

JNDI提供了一�U�统一的方式，可以用在�|�络上查扑֒�讉K��服务。通过指定一个资源名�U�ͼ�该名�U�对应于数据库或命名服务中的一个记录，同时�q�回数据库连接徏立所必须的信息�?/span>

JNDI主要有两部分�l�成�Q�应用程序编辑接口和服务供应商接口。应用程序编�E�接口提供了Java应用�E�序讉K��各种命名和目录服务的功能�Q�服务供应商接口提供了�Q意一�U�服务的供应商��用的功能�?/span>

Java代码  
try{  
　　Context cntxt = new InitialContext();  
　　DataSource ds = (DataSource) cntxt.lookup("jdbc/dpt");  
}  
　　catch(NamingException ne){  
　　...  
}  

Sheldon Sun 2011-03-22 17:35 发表评论

Restart

Sheldon Sun — Wed, 11 Jun 2008 10:27:00 GMT

From now, i will restart my blog , try to record sth of my life, including some thoughts and research results of technology, the only little hope is that the blog can leave my memory of life, as time flying, when i open it , i can get something.

Technology - Hibernate collection:
Maybe i used to write sth related before.
Several points as follows:
1. Define interface as property, for Hibernate will use its own implementation during runtime.
2. element is used to identiry foreign key for specified table.
3. and is used for value type definition while and is used for entities type.
4. indexed-collections contain : map, list, index is used to record position for certain record in the container. for map while for list.
Next two items is for bidirection:
5. inverse can be set in either sides for many-to-many relation.
6. For one-to-many, many sides will mantain relationship between object. exception happened when many side is index container.in this situation, it is not a completely "bidirectoinal".

7. Sort is done in memory while order by is down in DB.
8. is used when property is defined as list, but is not welcome.
9. is a list which can generate an id for primary key.

Sheldon Sun 2008-06-11 18:27 发表评论

Interpret and command pattern

Sheldon Sun — Thu, 22 Nov 2007 08:56:00 GMT

解释器模式：
�~�译器用的比较多�?br /> 针对某一特定语法的分析，解释�Q?�q�进行处理！
E.g: Expression = expression1 | expression2 | repeatableExpresson|Literal
针对整个Expression�Q?分析出其每个�l�成的expresion1�Q?expression2�Q?�Ҏ��个分析出的结果，都有相应的处理类�Q?�q�初始化出处理类的实例进行处理！
Literal代表元数�?�Q?br /> 如果对一个汽车组件的各个生��厂商�q�行解释器模式分析的话：汽�R = 轮胎 �Q�　发动�?�Q�　框架那么首先建立一个分析程序，分析汽�R的组成， �q��Ҏ��个部件初始化一个不见对应的对象�Q?来匹配该部�g�Q?�q�调用部件的�Ҏ��Ҏ��Q?处理部�g�Q?�q�回生��厂家的名�U�ͼ�

�q�个例子好失败， Interpret 模式优点在表辑ּ�的租成有很多模块�Q?每个模块重复的包含其他模块的情况下，辑ֈ�代码重用的目的！所以除了正则表辑ּ��Q?�~�译器以外，暂时想不��Z��么好的例子来�Q?br />
命��o行模式：
Struts 应用是典型的命��o行模式�?br /> 1�?把请求参数话�?br /> 2�?�Ҏ��个请求配�|�相应的处理�c�R��处理类有统一的接口�?br /> 3�?配置��h��与处理类的对应关�p�R�?br /> 4�?调用处理�cȝ��一接口�?br />
没什么好说的�Q?br />

今天比较凡，感觉自己职业发展已经到达了一个瓶颈，不知道怎么发展才好�Q?
感觉自己交流能力比较差，大家在一��L��时候都是听别�h��_�� 自己很少发言�Q?做编码已�l�感觉没有太大意思了�Q?因�ؓ现在的公司只注重�l�果�Q?不看中代码的质量�Q�开发出来很�Ҏ��Q?但开发好的代码很难！周围的同事开发出来代码的水��^比我都差很多�Q?也一样通过�Q?搞得自己��x��高自己都没有动力�Q?br /> ��x��高一下交��能力，不知道�{行做QA会不会有�Ҏ��善，或者还家公司？
比较�q��Q?br />

Sheldon Sun 2007-11-22 16:56 发表评论

Chain of responsibility

Sheldon Sun — Wed, 21 Nov 2007 08:49:00 GMT

刚才看了看职责链模式�Q?没什么概念，脑袋�q�是比较混�ؕ�Q?把思�\写出来！

职责链主要是��Z��一个请求，可能有很多个处理者， �q�些处理者数目�ƈ不固定而设计的�Q?br />
�Ҏ��U�处理，都会有一个处理类来对应！没个具体的处理类都会有一个后�l�： succor�Q?�q�个后��比处理类更广泛！如果当前的处理类可以处理改请求，则处理，否则使用后��的处理方法！

感觉最关键的一点就是对后��者的定义�Q?那�ؓ什么不用��承机制呢�Q�？�Q?br />

Sheldon Sun 2007-11-21 16:49 发表评论

Validate xml

Sheldon Sun — Wed, 08 Aug 2007 01:53:00 GMT

package testSchema;

import java.io.IOException;
import java.io.InputStream;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;

import org.apache.commons.codec.binary.Base64;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.DocumentHelper;
import org.dom4j.Element;
import org.dom4j.Namespace;
import org.dom4j.io.SAXReader;
import org.dom4j.tree.DefaultNamespace;

import org.iso_relax.verifier.Schema;
import org.iso_relax.verifier.Verifier;
import org.iso_relax.verifier.VerifierConfigurationException;
import org.iso_relax.verifier.VerifierFactory;
import org.iso_relax.verifier.VerifierFilter;
import org.xml.sax.EntityResolver;
import org.xml.sax.ErrorHandler;
import org.xml.sax.InputSource;
import org.xml.sax.SAXException;
import org.xml.sax.SAXParseException;

import com.sun.msv.verifier.jarv.TheFactoryImpl;

public class ValidateXML {

    public Document validate(InputStream stream, String xsdName) throws IOException{

    Document result = null;
    InputStream xmlStream = stream;
    InputStream schemaStream = this.getClass().getResourceAsStream(xsdName);
    SAXReader reader;
    try {
        reader = createSAXReader(schemaStream);
        result = reader.read(xmlStream);
        xmlStream.close();
        schemaStream.close();
    } catch (DocumentException e) {
        System.out.println("Validate failed !");
        e.printStackTrace();
    } catch(IOException e) {
        System.out.println("Xsd file does not exist !");
        e.printStackTrace();
    }
    catch (Exception e) {
        System.out.println("Xsd file format error !");
        e.printStackTrace();
    }

    return result;
}

private SAXReader createSAXReader(InputStream xsdStream) throws VerifierConfigurationException, SAXException, IOException {
    VerifierFactory factory = new TheFactoryImpl();
Schema schema = factory.compileSchema(xsdStream);

Verifier verifier = schema.newVerifier();
verifier.setErrorHandler(new ErrorHandler() {
    public void error(SAXParseException e) {
    System.out.println("ERROR: " + e);
    }

    public void fatalError(SAXParseException e) {
    System.out.println("FATAL: " + e);
    }

    public void warning(SAXParseException e) {
    System.out.println("WARNING: " + e);
    }
});

// now install the verifying filter
VerifierFilter filter = verifier.getVerifierFilter();
SAXReader reader = new SAXReader();
reader.setXMLFilter(filter);
return reader;
}

public static void main(String[] args) throws IOException {
    ValidateXML validateXML = new ValidateXML();
//    InputStream schemaStream = validateXML.getClass().getResourceAsStream("Response.xml");
//    validateXML.validate(schemaStream, "BAK-Response.xsd");
    validateXML.validateByDtd("hibernate-configuration-3.0.dtd", "src\\testSchema\\hibernate.cfg.xml");
}

public Document validateByDtd(String dtdFile, String xmlFile) {
    List errors = new ArrayList();
    SAXReader saxReader = new SAXReader();
    saxReader.setEntityResolver(new DTDEntityResolver(dtdFile));
    saxReader.setErrorHandler(new ErrorLogger(xmlFile, errors));
    saxReader.setValidation(true);
    Document doc = null;
    try {
    doc = saxReader.read(xmlFile);
    } catch (DocumentException e) {
    // TODO Auto-generated catch block
    e.printStackTrace();
    }

    return doc;
}

public static class ErrorLogger implements ErrorHandler {
    private String file;
    private List errors;
    ErrorLogger(String file, List errors) {
        this.file=file;
        this.errors = errors;
    }
    public void error(SAXParseException error) {
        System.err.println( "Error parsing XML: " + file + '(' + error.getLineNumber() + ") " + error.getMessage() );
        errors.add(error);
    }
    public void fatalError(SAXParseException error) {
        System.err.println(error);
    }
    public void warning(SAXParseException warn) {
        System.err.println( "Warning parsing XML: " + file + '(' + warn.getLineNumber() + ") " + warn.getMessage() );
    }
}

public static class DTDEntityResolver implements EntityResolver, Serializable {

    private static final Log log = LogFactory.getLog( DTDEntityResolver.class );


    private String dtdFile;
    public DTDEntityResolver(String dtdFile) {
        this.dtdFile = dtdFile;
    }
    public InputSource resolveEntity(String publicId, String systemId) {
        if ( systemId != null ) {
            InputStream dtdStream = this.getClass().getResourceAsStream(dtdFile);
            InputSource source = new InputSource( dtdStream );
            source.setPublicId( publicId );
            source.setSystemId( systemId );

            return source;
        }
        // use default behavior
        return null;
    }

}

}

Sheldon Sun 2007-08-08 09:53 发表评论

Hibernate - Component

Sheldon Sun — Tue, 19 Jun 2007 01:31:00 GMT

1. Component is value type, can not shared between entities, dont own identifier!
2. Declaration for mapping under component element.
3. When storing in set(or other collection type), use composite-element.
4. When using as primary key, use composite-id.
5. Dynamic component.

Sheldon Sun 2007-06-19 09:31 发表评论

Hibernate - Persistent class

Sheldon Sun — Thu, 14 Jun 2007 03:12:00 GMT

1. Hibernate recommand persisten class as a standard javabean naming convention, but not required, Hibernate can access fileds directory too.
But a no-argument constuctor is requeried for hibernate to instiante an object of the class by refection.

2. Indentifier property if optional too, but needed if we want to use the full feature set of hibernate, for hibernate will distinguish object by identifiers while some special operation. e.g: merge(), saveOrUpdate.

3. Equals() and hasdCode() mehtod is recommanded to implenent when you want to store persisntent class in a Set or manipulate object span sessions.

4. There are other 2 ways to define enity object except java class, Map and xml, the defect maybe can not do compile check, metrit is more flexisble than java.

5. Tuplizier!!!!

Hibernate integrated with J2EE infrastructure:
Two main point:
1. Hidden Configuration.config().buildSessionFacotory operation.
2. Bound session factory to jndi namespace through many way. e.g: MBean

Sheldon Sun 2007-06-14 11:12 发表评论