BlogJava-Jhonney的专栏-随笔分类-转载区

【转】你的核心竞争力是什么？

Jhonney — Sun, 22 Jul 2007 08:42:00 GMT

　早几天收到一位朋友发来的邮件，涉及到个人核心竞争力问题。朋友说，自己在学校的学习成绩比较好，具有竞争力。可是现在其他同学都具有了核心竞争力，而自己现在的工作“随时找个人，很容易就能替换”，因此，自己没有核心竞争力了。

　　这位朋友大学毕业两年，同学中有部分人从事软件开发，而我这位朋友选择了在互联网行业发展，目前的职位是一个中型网站的编辑部经理。朋友的同学中有个学Java的，写了2年程序，就自己开始招生搞培训班。于是，朋友就开始担心自己的竞争力问题了。

　　那么，什么是个人核心竞争力呢？所谓个人核心竞争力，就是指不断提高自己核心能力的能力。所谓核心能力，是相对其他人而言的，这种能力能很好的实现自己在某方面的价值，且别人不容易模仿。核心竞争力不仅表现在所掌握的技术上，更重要的体现在所具有的独到思想或见解、对某个领域业务的综合把握。

　　说到底，技术是不值钱的，只有业务和市场才能为企业赢利，技术只是实现业务的一个工具而已。因此，一个人要想具有核心竞争力，就必须对所在行业、所在企业的业务有深刻的理解，这远远不是学一两门程序设计语言就能搞定的事情。例如，朋友的同学搞Java培训班，其核心竞争力就是对IT培训业务的理解和洞察，而不是其Java程序设计的能力。（即使是Java程序设计能力，只毕业2年的学生，能核心到哪里去呢？如果有10年8年的经验，还说得过去！）如果其缺乏对培训业务的理解，缺乏培训公司运作的经验，其生存将是十分艰难的，倒闭就是眼前的事情。

　　个人核心竞争力其实是一个相对的概念，我们只能说某个人在某个方面具有核心竞争力，而不能笼统说甲具有核心竞争力，乙不具有核心竞争力。比如，拿大学教师为例，中文系的老师中会出名教授（具有核心竞争力），数学系的老师中也会出名教授（也具有核心竞争力）。但是，如果把中文系的名教授分配到数学系去上数学课，他就没有竞争力了。

　　我认为，对于软件开发人员而言，掌握一门程序设计语言并非是核心竞争力，而只是入门的一个工具而已，能够利用这个工具熟悉某个行业的业务流程和运作方式，能够娴熟地利用这个工具为某个行业提供解决方案，这才是核心竞争力；对于从事互联网行业的人员而言，能够把网络流量变成现金流量，能够把网络平台与单位业务结合起来，能够洞察互联网的发展方向，这才是核心竞争力；对于管理人员，能够在有限的资源下，提高整个团队的战斗力和凝聚力，使团队紧密团结在自己的周围，向团队目标努力奋进，这才是核心竞争力。

　　因此，就个人核心竞争力而言，行业不分好坏，职业不分好坏，工作不分好坏。只要你是有心人，在本职工作中潜心工作，努力摸索。这样，你收获的将不仅仅是每个月的工资，而且随着时间的增长，你的能力将不断提高，对业务的理解和把握能力将不断加强，最终形成自己的核心竞争力。

---------------------------------------------------------------------------------------
总结于一点，将自己的技能无论采用什么办法一定要达到和市场直接相结合

Jhonney 2007-07-22 16:42 发表评论

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.blogjava.net/lucky/archive/2006/02/23/32059.html

1. 引言

在你需要处理大量数据时你应该考虑使用eXtremeTable的Limit特性。Limit这个名字来自MySQL的limit 命令，Limit接口的目的就是如何对表的结果集进行limit处理。Limit实现知道当排序、过滤、分页、导出时，用户如何与表互相作用。有了这些信息你将能够使用可能是最有效的方式显示正确的过滤、排序后的请求页面。

为了示范Limit特性，我将要做的工作将分解为JSP、Controller、Service和DAO。这示范了一种使用分层的方式来处理 Limit。你可以根据自己的需要来增加或减少层。本示例也使用了Spring框架来重新得到使用Spring的JDBC取得的数据，因此你的代码看起来可能有点不同。eXtremeTable的一个特点就是不依赖任何框架和容器。

1.1. JSP

为了使用Limit特性，eXtremeTable需要使用limit特定的RetrieveRowsCallback、 FilterRowsCallback和SortRowsCallback接口。eXtremeComponents提供了每个接口的一个实现，可以简单地通过设置每个属性值为limit来简单来使用。

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

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

即使你的数据库不提供取得特定行的特性，当你考虑用户如何和表协同工作时，Limit仍然非常有意义。用户通常会对一些数据进行排序、过滤和分页。这个例子中15条数据构成一页，第一页需要15条数据，第二页需要30条数据，第三页需要45条数据，以此类推。在经过一段时间分页后，他们常常使用过滤来提炼数据。即使他们不这样做，他们也必须在此之前对大量的数据进行分页，这将影响效率。当然如果允许用户点击最后页，那么所有的数据都将被取出，这将非常影响效率。

1.2. Controller

提示：Spring框架的Controller和Struts框架的Action非常相像。

controller首先需要创建一个Limit。为了完成这个你需要得到一些关于Context和LimitFactory的帮助。

Context context = new HttpServletRequestContext(request);
LimitFactory limitFactory = new TableLimitFactory(context);
Limit limit = new TableLimit(limitFactory);

Context是一个处理取得属性的接口，LimitFactory使用Context来找出用户如何和eXtremeTable交互。然后Limit使用LimitFactory来组装自己。

为了初始化Limit，它将包含所有的有用的信息。这些信息包括数据将被如何排序和过滤，哪一页将被显示和是否允许被导出。

然而，Limit仍然需要得到行的信息，这样正确的信息页面才能被显示给用户。行信息包括开始行、结束行、当前显示行。 controller必须从service得到这些信息，而Service将从dao中得到这些信息。这里我只给出Controller端的代码。

int totalRows = presidentsService.getTotalPresidents(limit.getFilterSet(), limit.isExported());
limit.setRowAttributes(totalRows, defaultRowsDisplayed);

limit需要得到所有的行来得到行的信息。service需要知道那些被过滤，不管这些数据是否要导出。为了设置行信息，默认的一页显示的行数需要被设置。这可以通过对TableTag的rowsDisplayed属性设置一个确定的数值来实现。

现在我们只需要从services得到Collection数据。

Collection presidents = presidentsService.getPresidents(limit.getFilterSet(), limit.getSort(), limit.getRowEnd());

因为limit已经包含所有信息，这将十分容易。所有需要做的就是传入过滤器，排序和最后行的信息。最后要做的是将Collections和totalRow这些信息传送回JSP以便eXtremeTable知道如何显示这些信息。

request.setAttribute("presidents", presidents);
request.setAttribute("totalRows", new Integer(totalRows));

1.3. Service

service需要和dao进行交互来得到总行数和Collection。

1.3.1. 取得总行数

controller需要到第一条信息就是总行数。

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一起来过滤结果集，它的工作方式是在Where语句后面增加更多的AND语句来修改查询字符串。为此，你需要和Limit FilterSet一起工作。

FilterSet是一个过滤器对象数组，一个过滤器包括一个bean property和这个过滤器的值。或者，简单的说就是用户想要过滤的行和他们输入的值。这使得它非常容易交互。service只需要迭代所有的 FilterSet并调用dao来拼接查询语句。（译者注：过滤的实现方式是：在Where后面增加And语句来改变查询语句以达到对数据进行过滤的效果）

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信息，总行数。在一些情况下这就足够，但是当用户导出数据时仍然存在一个潜在的问题。为了保持高效 service不允许导出超出一个最大行数的数据。

1.3.2. 取得Collection

controller需要到第二条信息就是Collection。

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

和前面一样，service和dao一起来过滤结果集。

另外query字符串需要扩展ORDER BY语句以便数据按照正确的方式进行排序。Sort包含一个bean property和 sortOrder值（正序还是逆序）。service仅仅需要使用Sort来调用dao。

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字符串最后需要的修改就是增加数据库特别的指令来limit将要被返回的结果集。这就是limitQuery() 方法的作用。

1.4. DAO

dao为service负责底层数据工作。

1.4.1. 定义Query字符串

为了真正理解dao，query字符串需要被展示。

这就是得到数据的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 ";

这是得到总行数的query字符串：

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

1.4.2. Filter 和 Sort Query 字符串

两个最有趣的方法就是过滤和排序。

filter看起来像这样：

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字符串。

sort看起来非常类似：

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字符串。

1.4.3. Limit Query String

现在query字符串修改能够正确的进行filter和sort，它还需要修改以便只取页面显示相关的数据。MySQL为s the limit命令。

public String limitQuery(int rowEnd, String query) {
    return query + " limit " + rowEnd;
}

1.4.4. 取回总行数和Collection.

service需要的唯一东西就是：总行数和Collection。

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特殊类，作为一个callback来处理JDBC ResultSet。jdbcTemplate是对JDBC连接的抽象。

1.4.5. 默认的Sort顺序

最后，这是service需要的默认sort顺序：

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包的时候遇到了这样的问题：
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包的请注意》的文章，用了感觉不太好使，又看了一下sun社区的那篇，里面有种方法，挺好用，也不用修改rowset包，我写了一个CachedRowSet生成类.把自己的代码贴出来，和大家分享。(不知道代码好使不好).

rowset.jar包可以在下面的连接页面下载

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
{//设置资源为中国大陆
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设置有关的内容都放在里面////////

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 发表评论