日本精品二区,国产丝袜在线观看视频,中文字幕人成一区

Message-Driven POJOs

Jhonney — Tue, 19 Jun 2007 18:25:00 GMT

http://jroller.com/page/habuma/20050715#message_driven_pojos

Message-Driven POJOs

In my preparation for a presentation I'll be giving next month, I have been tinkering with Message-driven POJOs as proposed by James Strachan and as implemented in ActiveMQ.

Message-driven POJOs offer MDB-like functionality to simple JavaBeans. I have found message-driven POJOs to be a compelling alternative to MDBs, especially if you're already a big fan of Spring and are using it to develop your applications. Message-driven POJOs can take advantage of all of the features provided by Spring (such as dependency injection and AOP).

Although message-driven POJOs aren't exactly new news, I had a hard time finding much information about them online. ActiveMQ's own documentation isn't too bad, but left me with several unanswered questions. As a service to everyone out there who may be searching for more info on message-driven POJOs, I'm writing this article to document what I've learned. I hope you find it useful and maybe it will fill in some of the gaps for you.

What you'll need

To get started, here's a summary of the JARs that I used when developing and running the examples:

activemq-core-3.1-SNAPSHOT.jar
activemq-container-3.1-SNAPSHOT.jar
activemq-ra-3.1-SNAPSHOT.jar
commons-logging-1.0.3.jar
concurrent-1.3.4.jar
geronimo-spec-j2ee-connector-1.5-rc4.jar (or equivalent J2EE JAR)
geronimo-spec-j2ee-management-1.0-rc4.jar (or equivalent J2EE JAR)
geronimo-spec-jms-1.1-rc4.jar (or equivalent J2EE JAR)
geronimo-spec-jta-1.0.1B-rc4.jar (or equivalent J2EE JAR)
log4j-1.2.9.jar
spring.jar (version 1.2.2)

The biggest challenge you'll face when developing message-driven POJOs is pulling together all of these JARs. To make things easier on you, I've made everything you'll need (including the example code) available here.

Your mileage may vary if you choose to use different versions of JARs than what I've listed above. One important note, however, is that in my examples, I'm using the shorthand XML available in Spring 1.2, so if you use an older version of Spring, you'll need to tweak the XML appropriately.

Writing the message-driven POJO

Writing a message-driven POJO isn't dramatically different than writing a message-driven EJB. The major difference is that you don't have to implement javax.ejb.MessageDrivenBean, which means that you also don't have to implement the EJB lifecycle methods mandated by that interface. (If you need to hook into a POJO's lifecycle, you can use Spring's init-method and destroy-method attributes when declaring the bean.)

In the interest of keeping the focus on how to develop message-driven POJOs, my example will be as simple as possible. In the grand tradition of all simple examples, here's a "Hello World" message-driven POJO:

  package com.habuma.mdpojo;

  import javax.jms.JMSException;
  import javax.jms.Message;
  import javax.jms.MessageListener;

  public class HelloBean implements MessageListener {
    public void onMessage(Message msg) {
      try {
        String name = msg.getStringProperty("name");
        if(name == null) {
          name = "World";
        }

        System.out.println("Hello " + name + "!");
      } catch (JMSException e) {
        // handle exception?
      }
    }
  }

Notice that (as with MDBs) message-driven POJOs still must implement javax.jms.MessageListener. Even though James Strachan refers to these as POJOs, I don't consider this a pure POJO because in order to work it must implement a platform/framework-specific interface. But the MessageListener interface isn't too much of a burden to bear and it's still lighterweight than MDBs, so I guess I can't complain too much.

The onMessage() method should be self-explanatory. When a message is dispatched to this bean, this method is called. Inside of the method, we extract the "name" property from the message and use it to display the traditional greeting.

Listening for messages

The next thing to do is to declare HelloBean as a bean in a Spring context and associate it with a message queue. Declaring the bean itself is simple enough (in hello-mdpojo.xml):

There's really nothing special about this bean. In a real application, however, your message-driven POJO would probably be more interesting and be injected with references to DAOs, service-layer beans, or some other beans that it collaborates with to do its job. It may also be proxied by some Spring aspects for declarative transactions, security, etc.

To associate "helloBean" with a message queue, we'll need to use ActiveMQ's JCAContainer. The JCAContainer associates itself with a specific ActiveMQ server and acts as a factory to produce connectors to that server. It is declared in Spring as a :

  
    
       
    

    
                class="org.activemq.ra.ActiveMQResourceAdapter">

For the most part, this chunk of XML is boiler-plate code to set up a JCAContainer to interact with the message queue. The good news is that you'll only need one JCAContainer, regardless of how many of your POJOs will be message-driven.

The only thing of interest is the value assigned to the "serverUrl" property of the "activeMQResourceAdapter" inner-bean. This property tells the container how to connect to your ActiveMQ server--in this case, via TCP on port 61616 of the localhost (where ActiveMQ will be listening by default.)

At this point we have a JCAContainer that is associated with the ActiveMQ server and we have a POJO that is ready and willing to accept messages. All that's left is to connect the POJO to the JCAContainer. The following does the trick:

        factory-method="addConnector" 
      factory-bean="activeMQContainer">

This bean is where the proverbial "rubber meets the road". Using Spring's factory-method feature, this bean declaration leans on the JCAContainer's addConnector() method to create a connector to associate the "helloBean" with the ActiveMQ server. Specifically, the "activationSpec" property tells the JCAContainer to set up a connector that listens to the queue named "Hello.Queue" and the "ref" property tells it to send messages from that queue to the bean named "helloBean".

Bringing this message-driven POJO to life requires two things. First, you'll need to fire up an ActiveMQ server. In the bin directory of the ActiveMQ distribution, you'll find either an activemq.bat (for Windows) or an activemq script (for UNIX). Running this script will start up an ActiveMQ server instance listening on port 61616.

The next thing you'll need is a simple application that loads the Spring application context. The following main() method should suffice (I'll leave the class you place this in up to you):

  public static void main(String[] args) {
    new FileSystemXmlApplicationContext("hello-mdpojo.xml");
  }

If all goes well, running this program will result in a HelloBean POJO that is patiently awaiting a message to process. So, let's send it a message.

Sending a message

There are a variety of ways to send a JMS message, but for the purposes of this example, I'm going to use Spring's JmsTemplate (as described in chapter 7 of Spring in Action). The following declaration of a JmsTemplate is what I used to test the HelloBean (in mq-client.xml):

        class="org.springframework.jms.core.JmsTemplate">

The "defaultDestinationName" property tells the template the name of the message queue to attach to. The "connectionFactory" property tells the template how to connect. I could've used Spring's JndiObjectFactoryBean to pull a connection factory from JNDI (as I described in SiA) or any implementation of javax.jms.ConnectionFactory. But so that I don't have to mess with JNDI for this simple example, let's use ActiveMQ's ActiveMQConnectionFactory:

        class="org.activemq.ActiveMQConnectionFactory">

Now we just need to use the "jmsTemplate" bean to send a message. In a real application, you might inject "jmsTemplate" into a property of another bean to use. But for simplicity's sake we'll just access the bean directly from a main() method (again, I'll leave the choice of a class up to you):

  public static void main(String[] args) {
    ApplicationContext ctx = new
        FileSystemXmlApplicationContext("mq-client.xml");

    JmsTemplate template = (JmsTemplate) ctx.getBean("jmsTemplate");
    template.send(
      new MessageCreator() {
        public Message createMessage(Session session)
            throws JMSException {
          MapMessage message = session.createMapMessage();
            message.setStringProperty("name", "Craig");
          return message;
        }
      }
    );
  }

Run this program in a separate window from where the application that runs the JCAContainer. If things are going your way, you should see "Hello Craig!" in the window running the JCAContainer app. Congratulations, you've just invoked a message-driven POJO.

So what?

What's the big deal? Why are message-driven POJOs better than MDBs? Well, I never actually claimed any superiority of message-driven POJOs over MDBs. But here are some things to consider:

MDBs must be run within an EJB container. Depending on the architecture of your app, this may be an excessive requirement, especially if you aren't use any other EJBs and do not require the features of a full-blown EJB container. Message-driven POJOs, on the other hand, can run anywhere, even (as shown here) in a simple main() method. The only requirement is an ActiveMQ message queue.
MDBs require that you implement the lifecycle methods of javax.ejb.MessageDrivenBean. Often these lifecycle methods aren't needed and are left as empty implementations. This isn't a real problem, except that it's simply unnecessary.
Although it may not be apparent from the simple HelloBean example, message-driven POJOs can take full advantage of the dependency injection and AOP support offered by Spring (including Spring's support for declarative transactions and Acegi's support for declarative security). In short, you can do anything with the POJO that you can do with any other bean in a Spring context.
The XML used to declare a message-driven POJO is slightly more verbose then for an MDB. You should, however, keep in mind that you'll only need to declare one JCAContainer bean, regardless of how many message-driven POJOs your application has.

One thing that I've not yet considered is how EJB 3 MDBs compare the message-driven POJOs. Honestly, I've not taken the time to perform this comparison. Perhaps this is something I'll do soon. If you have any insight in this subject, I'd be quite interested in hearing it.

Message-driven POJOs are just a small portion of a talk that I'll be presenting at the LoneStar Software Symposium in Austin, TX next month. If you're in the Austin area, I hope to see you there.

Jhonney 2007-06-20 02:25 发表评论

Limit指南

Jhonney — Tue, 12 Jun 2007 13:28:00 GMT

quto:http://www.aygfsteel.com/lucky/archive/2006/02/23/32059.html

1. 引言

在你需要处理大量数据时你应该考虑使用eXtremeTable的Limit�Ҏ��。Limit�q�个名字来自MySQL的limit 命��o�Q�Limit接口的目的就是如何对表的�l�果集进行limit处理。Limit实现知道当排序、过滤、分��c��导出时�Q�用户如何与表互�怽�用。有了这些信息你 ��能够��用可能是最有效的方式显�C�正��的�q��o、排序后的请求页面�?/p>

��Z��C��Limit�Ҏ��，我将要做的工作将分解为JSP、Controller、Service和DAO。这�C��了一�U��用分层的方式来处�?Limit。你可以�Ҏ��自己的需要来增加或减��层。本�C�Z��也��用了Spring框架来重新得��C��用Spring的JDBC取得的数据，因此你的代码看�v来可能有点不同。eXtremeTable的一个特点就是不依赖��M��框架和容器�?

1.1. JSP

��Z��使用Limit�Ҏ��，eXtremeTable需要��用limit特定的RetrieveRowsCallback�?FilterRowsCallback和SortRowsCallback接口。eXtremeComponents提供了每个接口的一个实玎ͼ�可以��单地通过讄��每个属性��gؓlimit来简单来使用�?

   items="presidents"
   retrieveRowsCallback="limit"
   filterRowsCallback="limit"
   sortRowsCallback="limit"
   view="limit"
   >
...

另外视图属性参照一个名为limit的定制视图。这是一个简单修攚w��认eXtremeTable视图�Q�不包含最后页工具条的实现。这仅仅关系��C��是否能取得确切需要的行�?一些数据库例如Oracle和MySQL都提供了一�U�得到确定行的特性，但是�Q�其他的数据库例如：Sybase没有提供�Ҏ��。在我的�C�Z��中我考虑最坏的情况你的数据库不支持�q�种�Ҏ��?/p>

即��你的数据库不提供取得特定行的�Ҏ��，当你考虑用户如何和表协同工作�Ӟ��Limit仍然非常有意义。用户通常会对一些数据进行排序、过滤和分页�?�q�个例子�?5条数据构成一��，�W�一��需�?5条数据，�W�二��需�?0条数据，�W�三��需�?5条数据，以此�c�L��。在�l�过一�D�|��间分��后�Q�他们常�怋�用过滤来提炼数据�?即��他们不这样做�Q�他们也必须在此之前对大量的数据�q�行分页�Q�这��媄响效率。当然如果允许用��L��L��后页�Q�那么所有的数据都将被取出，�q�将非常影响效率�?/p>

1.2. Controller

提示�Q�Spring框架的Controller和Struts框架的Action非常相像�?/em>

controller首先需要创��Z��个Limit。�ؓ了完成这个你需要得��C��些关于Context和LimitFactory的帮助�?/p>
Context context = new HttpServletRequestContext(request);
LimitFactory limitFactory = new TableLimitFactory(context);
Limit limit = new TableLimit(limitFactory);

Context是一个处理取得属性的接口�Q�LimitFactory使用Context来找出用户如何和eXtremeTable交互�?然后Limit使用LimitFactory来组装自己�?/p>
��Z��初始化Limit�Q�它��包含所有的有用的信息。这些信息包括数据将被如何排序和�q��o�Q�哪一��将被显�C�和是否允许被导出�?/p>
然而，Limit仍然需要得到行的信息，�q�样正确的信息页面才能被昄��l�用戗��行信息包括开始行、结束行、当前显�C��?controller必须从service得到�q�些信息�Q�而Service��从dao中得到这些信息。这里我只给出Controller端的代码�?/p>
int totalRows = presidentsService.getTotalPresidents(limit.getFilterSet(), limit.isExported());
limit.setRowAttributes(totalRows, defaultRowsDisplayed);

limit需要得到所有的行来得到行的信息。service需要知道那些被�q��o�Q�不��这些数据是否要导出。�ؓ了设�|�行信息�Q�默认的一��|��C�的行数需要被讄��?�q�可以通过对TableTag的rowsDisplayed属性设�|�一个确定的数值来实现�?/p>
现在我们只需要从services得到Collection数据�?/p>
Collection presidents = presidentsService.getPresidents(limit.getFilterSet(), limit.getSort(), limit.getRowEnd());

因�ؓlimit已经包含所有信息，�q�将十分�Ҏ��。所有需要做的就是传入过滤器�Q�排序和最后行的信息�?最后要做的是将Collections和totalRow�q�些信息传送回JSP以便eXtremeTable知道如何昄��q�些信息�?/p>
request.setAttribute("presidents", presidents);
request.setAttribute("totalRows", new Integer(totalRows));

1.3. Service

service需要和dao�q�行交互来得到总行数和Collection�?/p>

1.3.1. 取得总行�?/h4>

controller需要到�W�一条信息就是总行数�?/p>
public int getTotalPresidents(FilterSet filterSet, boolean isExported) {
String totalQuery = presidentsDao.getTotalPresidentsQuery();
String modTotalQuery = filterQuery(filterSet, totalQuery);
int totalRows = presidentsDao.getTotalPresidents(modTotalQuery);
if (isExported && totalRows > maxExportRows) {
totalRows = maxExportRows;
}
return totalRows;
}

service和dao一��h��q��o�l�果集，它的工作方式是在Where语句后面增加更多的AND语句来修�Ҏ��询字�W�串。�ؓ此，你需要和Limit FilterSet一起工作�?/p>
FilterSet是一个过滤器对象数组�Q�一个过滤器包括一个bean property和这个过滤器的倹{��或者，��单的说就是用��h��要过滤的行和他们输入的倹{��这使得它非常容易交互。service只需要�P代所有的 FilterSet�q�调用dao来拼接查询语句。（译者注�Q�过滤的实现方式是：在Where后面增加And语句来改变查询语句以辑ֈ��Ҏ��据进行过滤的效果�Q?/p>
private String filterQuery(FilterSet filterSet, String query) {
if (!filterSet.isFiltered() || filterSet.isCleared()) {
return query;
}

Filter filters[] = filterSet.getFilters();
for (int i = 0; i < filters.length; i++) {
Filter filter = filters[i];
String property = filter.getProperty();
String value = filter.getValue();
query = presidentsDao.filterQuery(query, property, value);
}

return query;
}

query修改包括了filter信息�Q�总行数。在一些情况下�q�就��_��Q�但是当用户导出数据时仍然存在一个潜在的问题。�ؓ了保持高�?service不允许导��Z��个最大行数的数据�?/p>

1.3.2. 取得Collection

controller需要到�W�二条信息就是Collection�?/p>
public Collection getPresidents(FilterSet filterSet, Sort sort, int rowEnd) {
String patientsQuery = presidentsDao.getPresidentsQuery();
String modPatientsQuery = filterQuery(filterSet, patientsQuery);
modPatientsQuery = sortQuery(sort, modPatientsQuery);
modPatientsQuery = presidentsDao.limitQuery(rowEnd, modPatientsQuery);
return presidentsDao.getPresidents(modPatientsQuery);
}

和前面一��P��service和dao一��h��q��o�l�果集�?/p>
另外query字符串需要扩展ORDER BY语句以便数据按照正确的方式进行排序。Sort包含一个bean property�?sortOrder��|��正序�q�是逆序�Q�。service仅仅需要��用Sort来调用dao�?/p>
private String sortQuery(Sort sort, String query) {
if (!sort.isSorted()) {
String defaultSortOrder = presidentsDao.getDefaultSortOrder();
if (StringUtils.isNotBlank(defaultSortOrder)) {
return query + defaultSortOrder;
}

return query;
}

String property = sort.getProperty();
String sortOrder = sort.getSortOrder();

return presidentsDao.sortQuery(query, property, sortOrder);
}

query字符串最后需要的修改��是增加数据库特别的指��o来limit��要被返回的�l�果集。这��是limitQuery() �Ҏ��的作用�?/p>

1.4. DAO

dao为service负责底层数据工作�?/p>

1.4.1. 定义Query字符�?/h4>

��Z��真正理解dao�Q�query字符串需要被展示�?/p>
�q�就是得到数据的presidents query字符�Ԍ��

private final static String presidentsQuery =
" SELECT " +
" president_id presidentId, " +
" first_name firstName, " +
" last_name lastName, " +
" nick_name nickName, " +
" concat(first_name, ' ',last_name) fullName, " +
" term, " +
" born, " +
" died, " +
" education, " +
" career, " +
" political_party politicalParty " +
" FROM presidents ";

�q�是得到总行数的query字符�Ԍ��

private final static String totalPresidentsQuery =
" SELECT count(*) FROM presidents ";

1.4.2. Filter �?Sort Query 字符�?/h4>

两个最有趣的方法就是过滤和排序�?/p>
filter看�v来像�q�样�Q?/p>
public String filterQuery(String query, String property, String value) {
StringBuffer result = new StringBuffer(query);

if (query.indexOf("WHERE") == -1) {
result.append(" WHERE 1 = 1 "); //stub WHERE clause so can just append AND clause
}

if (property.equals("fullName")) {
result.append(" AND concat(first_name, ' ',last_name) like '%" + value + "%'");
} else if (property.equals("nickName")) {
result.append(" AND nick_name like '%" + value + "%'");
} else {
result.append(" AND " + property + " like '%" + value + "%'");
}

return result.toString();
}

filterQuery()�Ҏ��需要增加正��的AND语句到query字符丌Ӏ?/p>
sort看�v来非常类��|��

public String sortQuery(String query, String property, String sortOrder) {
StringBuffer result = new StringBuffer(query + " ORDER BY ");

if (property.equals("fullName")) {
result.append("concat(first_name, ' ',last_name) " + sortOrder);
} else {
result.append(property + " " + sortOrder);
}

return result.toString();
}

sortQuery()�Ҏ��需要增加正��的ORDER BY语句到query字符丌Ӏ?/p>

1.4.3. Limit Query String

现在query字符串修改能够正��的�q�行filter和sort�Q�它�q�需要修改以便只取页面显�C�相关的数据。MySQL为s the limit命��o�?/p>
public String limitQuery(int rowEnd, String query) {
return query + " limit " + rowEnd;
}

1.4.4. 取回总行数和Collection.

service需要的唯一东西��是�Q�总行数和Collection�?/p>
public Collection getPresidents(final String query) {
return jdbcTemplate.query(query, new ResultReader() {
List results = new ArrayList();
public List getResults() {
return results;
}

public void processRow(ResultSet rs)
throws SQLException {
President president = new President();
president.setPresidentId(new Integer(rs.getInt("presidentId")));
president.setFirstName(rs.getString("firstName"));
president.setLastName(rs.getString("lastName"));
president.setNickName(rs.getString("nickName"));
president.setFullName(rs.getString("fullName"));
president.setTerm(rs.getString("term"));
president.setBorn(rs.getDate("born"));
president.setDied(rs.getDate("died"));
president.setEducation(rs.getString("education"));
president.setCareer(rs.getString("career"));
president.setPoliticalParty(rs.getString("politicalParty"));
results.add(president);
}
});
}

public int getTotalPresidents(final String query) {
return jdbcTemplate.queryForInt(query);
}

ResultReader是一个帮助处理JDBC查询的Spring�Ҏ��c�，作�ؓ一个callback来处理JDBC ResultSet。jdbcTemplate是对JDBC�q�接的抽象�?/p>

1.4.5. 默认的Sort��序

最后，�q�是service需要的默认sort��序�Q?/p>
public String getDefaultSortOrder() {
return " ORDER BY concat(first_name, ' ', last_name) ";
}

Jhonney 2007-06-12 21:28 发表评论

rowset下蝲地址

Jhonney — Fri, 08 Jun 2007 05:23:00 GMT

http://java.sun.com/products/jdbc/download.html#rowsetcobundle1_0
//////////////////////////////////

CachedRowSet使用的问题一�?rowset.jar在jdk1.4下的使用

在��用rowset包的时候遇��C��q�样的问题：
java.lang.NullPointerException
at java.io.Reader.(Reader.java:61)
at java.io.InputStreamReader.(InputStreamReader.java:80)
at java.util.Properties.load(Properties.java:266)
at java.util.PropertyResourceBundle.(PropertyResourceBundle.java:96)
at com.sun.rowset.JdbcRowSetResourceBundle.(JdbcRowSetResourceBundle.java:92)
at com.sun.rowset.JdbcRowSetResourceBundle.getJdbcRowSetResourceBundle(JdbcRowSetResourceBundle.java:114)
at com.sun.rowset.CachedRowSetImpl.(CachedRowSetImpl.java:360)Exception: null
at com.sun.rowset.WebRowSetImpl.(WebRowSetImpl.java:68)
at test.Test.generateXML(Test.java:98)
at test.Test.main(Test.java:168)

在网上看了一��《��用最新sun公司的rowset.jar包的��h��意》的文章�Q�用了感觉不太好使，又看了一下sun�C�֌�的那��，里面有种�Ҏ��Q�挺好用�Q�也不用修改rowset包，我写了一个CachedRowSet生成�c?把自��q��代码贴出来，和大家分享�?不知道代码好使不�?.

rowset.jar包可以在下面的连接页面下�?/p>
http://java.sun.com/products/jdbc/download.html#rowsetcobundle1_0

import javax.sql.rowset.CachedRowSet;
import com.sun.rowset.CachedRowSetImpl;
import java.util.Locale;
import java.sql.*;

public class cachedRowsetCreater {
protected CachedRowSet crs=createCachedRowset();
public void close(){
    try {
      crs.release();
    }
    catch (SQLException ex) {
    }
    crs=null;
}
public cachedRowsetCreater(String JNDI_NAME) throws Exception {
    crs.setDataSourceName(JNDI_NAME);
}

public CachedRowSet createCachedRowset() throws SQLException
{
Locale locale = Locale.getDefault ();
try
{//讄��资源��Z��国大�?br>Locale.setDefault (Locale.CHINESE);//在linux下好像要用CHINA
return new CachedRowSetImpl ();
}
finally
{
Locale.setDefault (locale);
}
}
public CachedRowSet executeQuery(String QueryString){
try{
CachedRowSet crs1=crs.createCopySchema();
crs1.setCommand(QueryString);
crs1.execute();
return crs1;
}catch(SQLException e){
return null;
}
}

}

Jhonney 2007-06-08 13:23 发表评论

cvc-complex-type.2.4.a错误解决�Ҏ��

Jhonney — Sat, 19 May 2007 06:56:00 GMT

/tags/struts-html
/WEB-INF/struts-html.tld

　　/tags/struts-bean
　　/WEB-INF/struts-bean.tld
　　
　　
　　
　　/tags/struts-logic
　　/WEB-INF/struts-logic.tld
　　

///////把所有跟jsp讄��有关的内定w��攑֜�里面////////

Jhonney 2007-05-19 14:56 发表评论

Jhonney — Thu, 12 Apr 2007 13:55:00 GMT
public class Singleton {

static class SingletonHolder {
    static Singleton instance = new Singleton();
}

public static Singleton getInstance() {
    return SingletonHolder.instance;
}

}

See in : http://crazybob.org/2007/01/lazy-loading-singletons.html
See also : http://www.oreillynet.com/onjava/blog/2007/01/singletons_and_lazy_loading.html

Jhonney 2007-04-12 21:55 发表评论