亚洲第一精品在线视频,亚洲精品高清国产一线久久,亚洲AV无码不卡在线播放

Servlet Mappings - rules, pattern....

honzeland — Fri, 22 Oct 2010 14:41:00 GMT

http://www.rawbw.com/~davidm/tini/TiniHttpServer/docs/ServletMappings.html

honzeland 2010-10-22 22:41 发表评论

Java remote invocation frameworks (RPC)

honzeland — Wed, 09 Jun 2010 06:25:00 GMT

1. Remote Method Invocation (RMI)

2. Hessian

3. Burlap

4. HTTP invoker

5. EJB

6. JAX-RPC

7. JMX

honzeland 2010-06-09 14:25 发表评论

Tomcat Architecture Diagram

honzeland — Mon, 10 May 2010 02:39:00 GMT

zz from http://marakana.com/forums/tomcat/general/106.html

Valve and Filter:
"Valve" is Tomcat specific notion, and they get applied at a higher level than anything in a specific webapp. Also, they work only in Tomcat.

"Filter" is a Servlet Specification notion and should work in any compliant servlet container. They get applied at a lower level than all of Tomcat's
Valves.

However, consider also the division between your application and the application server. Think whether the feature you're planning is part of your application, or is it rather a generic feature of the application server, which could have uses in other applications as well. This would be the correct criteria to decide between Valve and Filter.

Order for filter: The order in which they are defined matters. The container will execute the filters in the order in which they are defined.

honzeland 2010-05-10 10:39 发表评论

Quartz scheduled executions

honzeland — Thu, 21 Jan 2010 09:38:00 GMT

�q�周被Quartz折腾了一番�?br /> 我们知道�Q�Quartz采用JobDataMap实现向Job实例传送配�|�属性，正如Quartz官方文档说的那样�Q?br />
How can I provide properties/configuration for a Job instance? The key is the JobDataMap, which is part of the JobDetail object.
The JobDataMap can be used to hold any number of (serializable) objects which you wish to have made available to the job instance when it executes.
JobDataMap map �Q?context.getJobDetail().getJobDataMap();

我们通过map向Job实例传送多个objects�Q�其中有一个是个bean�Q�一个是基本�c�d��。对于scheduled triggers�Q�我们要求bean对于所有的序列都不变，包括其属性，而基本类型可以在Job�q�行�q�程中改变，�q�媄响下一个序列。实际情冉|��Q�对于下个序列，bean的属性被上次的修改了�Q�而基本类型却�l�持�W�一�ơput到Map里面的倹{��正好和我们要求的相反�?br />
受bean的媄响，以�ؓmap里面包含的都是更新的对象�Q�即每个序列里面的JobDetail是同一个对象，但是基本�c�d��的结果否认了�q�一炏V��回头重新翻阅了下Quartz的文档：

Now, some additional notes about a job's state data (aka JobDataMap): A Job instance can be defined as "stateful" or "non-stateful". Non-stateful jobs only have their JobDataMap stored at the time they are added to the scheduler. This means that any changes made to the contents of the job data map during execution of the job will be lost, and will not seen by the job the next time it executes.

Job有两个子接口�Q�StatefulJob and InterruptableJob�Q�我们��承的是InterruptableJob�Q�或许Quartz应该有个InterruptableStatefulJob。另外StatefulJob不支持�ƈ发执行，和我们的需求不匚w��Q�我们有自己的同步控�Ӟ��Job必须可以�q�发�q�行�?br />
然后查看了Quartz的相��x��码：

// RAMJobStore.storeJob
public void storeJob(SchedulingContext ctxt, JobDetail newJob,
            boolean replaceExisting) throws ObjectAlreadyExistsException {
        JobWrapper jw = new JobWrapper((JobDetail)newJob.clone()); // clone a new one
        .
        jobsByFQN.put(jw.key, jw);

}

也就是说�Q�store里面攄��是初始JobDetail的克隆，在序列运行完�Ӟ��只有StatefulJob才会更新store里面的JobDetail�Q?br />

// RAMJobStore.triggeredJobComplete
public void triggeredJobComplete(SchedulingContext ctxt, Trigger trigger,
            JobDetail jobDetail, int triggerInstCode) {
    JobWrapper jw = (JobWrapper) jobsByFQN.get(jobKey);

    if (jw != null) {
        JobDetail jd = jw.jobDetail;
        if (jd.isStateful()) {
            JobDataMap newData = jobDetail.getJobDataMap();
            if (newData != null) {
                newData = (JobDataMap)newData.clone();
                newData.clearDirtyFlag();
            }
            jd.setJobDataMap(newData); // set to new one


    }

}

然后�Q�每�ơ序列运行时所用的JobDetail�Q�是存放在Store里面的克隆�?br />

// RAMJobStore.retrieveJob
public JobDetail retrieveJob(SchedulingContext ctxt, String jobName,
        String groupName) {
    JobWrapper jw = (JobWrapper) jobsByFQN.get(JobWrapper.getJobNameKey(
        jobName, groupName));
    return (jw != null) ? (JobDetail)jw.jobDetail.clone() : null; // clone a new
}

问题很清楚了�Q�存攑֜�Store里面的JobDetail是初始对象的克隆�Q�然后每个序列所用的JobDetail�Q?是Store里面的克隆，只有Stateful job�Q�Store里面的JobDetail才更新�?br /> 最有Quartz里面使用的clone():

// Shallow copy the jobDataMap. Note that this means that if a user
// modifies a value object in this map from the cloned Trigger
// they will also be modifying this Trigger.
if (jobDataMap != null) {
copy.jobDataMap = (JobDataMap)jobDataMap.clone();
}

所以对于前面所讲的�Q�修改bean的属性，会媄响所有clone的对象，因此�Q�我们可以将基本�c�d��装��C��个bean里面�Q�map里面存放的是bean�Q�然后通过修改bean的属性，来达到媄响下一个序列的目的�?br />

honzeland 2010-01-21 17:38 发表评论

Useful Links: ing...

honzeland — Tue, 03 Jun 2008 07:09:00 GMT

About Java:
http://www.theserverside.com
http://www.javablogs.com
http://www.java2s.com
Java(TM) Platform Performance: Strategies and Tactics
A Simple Data Access Layer using Hibernate
Discover the secrets of the Java Serialization API
Setting up two-way (mutual) SSL with Tomcat on Java5
Basic Tomcat Tour and Tomcat Security
When Runtime.exec() won't
Asynchronous processing support in Servlet 3.0
About security:
The Types Of Digital Certificates
Cryptography Lecture PPT
MD5 considered harmful today
Cryptography Tutorials - Herong's Tutorial Notes
Defective Sign & Encrypt in S/MIME, PKCS#7, MOSS, PEM, PGP, and XML
Cryptography resources by Bouncycastle
Others:
Colors for the webColors for the web
Test Frameworks
Lightstreamer: a scalable and reliable Server for pushing live data to Rich Internet Applications
honzeland 2008-06-03 15:09 发表评论

Managing HttpSession Objects

honzeland — Wed, 21 May 2008 07:49:00 GMT

zz: java.sys-con.com

Java servlet technology provides developers with functionality, scalability, and portability that can't be found in other server-side languages. One feature of the Java servlet specification that's commonly used, and sometimes misused, is the HttpSession interface. This simple interface allows you to maintain a session or state for Web site visitors.

In my previous article ("Introduction to Session Management," [JDJ, Vol. 7, issue 9]), I introduced you to session management and the HttpSession interface. In that article, we walked through using the HttpSession API to create, use, and destroy session objects for Web site visitors. The next step is to better understand how to manage the sessions and those objects in a session. This article will help you achieve this by helping you understand the following concepts:

Code-based session management through listeners
Proper design of the session and the objects it contains
Controlling what is in the session and why it's there
Session persistence
Memory management

The Java APIs discussed in this article are from Sun's Java Servlet 2.3 specification.

Listeners
A listener is an object that's called when a specified event occurs. There are four listener interfaces that allow you to monitor changes to sessions and the objects that are in those sessions:

HttpSessionListener
HttpSessionBindingListener
HttpSessionAttributeListener
HttpSessionActivationListener

Figure 1 provides a method summary for each of the listener interfaces. The implementing class that you write will override these methods to provide the functionality you need.

HttpSessionListener
The HttpSessionListener interface is used to monitor when sessions are created and destroyed on the application server. Its best practical use would be to track session use statistics for a server.

The use of HttpSessionListener requires a configuration entry in the deployment descriptor, or web.xml file, of the application server. This entry points the server to a class that will be called when a session is created or destroyed. The entry required is simple. All you need is a listener and listener-class element in the following format. The listener-class element must be a fully qualified class name.

package.Class

As you can see in Figure 1, the class that implements this listener can override two methods: sessionCreated() and sessionDestroyed(). These methods will be notified when the server creates or destroys a session.

These methods take an HttpSessionEvent object as a parameter. HttpSessionEvent is simply a class that represents notifications of changes to the Web application's sessions. HttpSessionEvent has one method, getSession(), that returns the HttpSession object that's been modified.

HttpSessionBindingListener
The HttpSessionBindingListener interface is implemented when an object needs to be notified if it's being bound to a session or unbound from a session.

This interface has two methods, valueBound() and valueUnbound(), that are notified when the status of the object has changed (see Figure 1).

These methods have an HttpSessionBindingEvent parameter that can be used to retrieve the session that the object was bound to and the name it was given in the session. In Figure 2, you can see the methods of this object that are used to get the name that's assigned to the object, the session it's bound to, and the actual object.

HttpSessionAttributeListener
The HttpSessionAttributeListener interface is used to monitor changes to attributes in any session on the server. This can be useful when you know the name assigned to a specific object that gets put into the session and you want to track how often it's being used.

As with HttpSessionListener, HttpSessionAttributeListener also requires an entry in the deployment descriptor for the server. This entry tells the server which class to call when an attribute in a session has changed.

The HttpSessionAttributeListener interface has three methods - attributeAdded(), attributeRemoved(), and attributeReplaced(). These methods, shown in Figure 1, are called by the server when attributes of a session are changed.

HttpSessionActivationListener
The final listener, HttpSessionActivationListener, is implemented when an object needs to know if the session that it's bound to is being activated or passivated (moved). You would come across this scenario if your session is being shared across JVMs or your server is persisting the session in a database or file system.

This interface, displayed in Figure 1, has two methods that are overridden by the implementing class: sessionDidActivate() and sessionWillPassivate(). These methods are called when the status of the session in a JVM is changed.

Session Persistence
Today's J2EE-compliant servers allow for fault-tolerance and failover to provide support in the event that a server suddenly becomes unavailable because of hardware, software, or network failure. This support is usually provided by allowing two or more application servers, often called a cluster, to run together and provide backup support for each other. If one server fails, the others pick up the requests and continue on as if nothing happened. This allows your Web site visitors to keep going without interruption.

A proxy server is usually used in front of the application servers. This server is responsible for directing each HTTP request to the appropriate server. The proxy server can be set up to ensure that the server receiving the first request from a user will continue to receive all subsequent requests from that user. This means that a session created for the user on the application server will continue to be available for that user. If the server suddenly fails, there has to be a system in place to allow the session to continue on without it.

Session persistence allows the session contents to be saved outside the application server so that other servers can access it. Figure 3 shows the relationship between the persisted session data and the application servers that access it. In this figure, you see a client accessing a Web site's HTTP server. The HTTP server is forwarding requests for application resources to one of the application servers through the use of a proxy server. The application servers are persisting the session data in an external form.

There are four types of session persistence:

Memory persistence (one server or a cluster of two or more)
File system persistence
Database persistence
Cookie persistence

Every application server will handle session persistence differently and all servers may not support all types of persistence. Objects that are placed in the session must be serializable for persistence to work.

Memory Persistence
In most cases, a single standalone server will store sessions in memory. This allows for fast retrieval and update of the information. It also means that the session information will be lost when the server is shut down. This is usually the default configuration on most application servers. Memory persistence can be used when two or more servers need to share the session information. The application servers can be configured to share any changes made to the session so that the information is available on multiple servers. This redundancy of the session information helps the cluster preserve the session during a failure.

File System Persistence
File system persistence can be used to serialize any objects that are in the session. The object contents are placed in a file on the server. The location of the files created is configurable; however, the files must be accessible by all the servers in the cluster. The speed at which the file system is accessed can be a factor in the performance of your Web site. A slow disk drive, for example, would result in a delay as data is read from or written to the file.

Database Persistence
Database persistence can be used to provide a central data store for the session contents. Each application server in the cluster must be able to access the database. When sessions are modified, the changes are immediately persisted in the database. A data source is usually set up for JDBC persistence and the connections are pooled. This provides a quicker response. There's also the issue of database failover, which would be addressed at the database level of the system.

Cookie Persistence
The fourth type of session persistence, cookie persistence, is so ineffective and insecure that it doesn't deserve consideration when designing a fail-safe system. Cookie persistence, as the name implies, persists session data by storing the session information in browser cookie(s). There's a limitation on data handling because cookies store only text, not objects, and the amount of data that can be transmitted in a cookie is limited. There's also the fact that cookies transmit data back and forth between the client and the server. This prevents you (at least it should) from saving sensitive information, like a social security number. This type of persistence should be used in only the smallest of Web sites, and only if there's a good reason not to store the session in memory.

The most common type of persistence is database persistence. It provides an efficient way of saving session data and it's usually fairly easy to set up on the application server. Memory persistence in a cluster is also easy to use, if your application server supports it. The only drawback is that sessions can sometimes hold large amounts of data. Storing the session in memory reduces the amount of memory available to the other processes on the server. File system persistence can be slow at times and the file system may not always be accessible to multiple servers.

Watching the Session Size
As you and your fellow employees work on a Web application, you may notice that more and more objects are being thrown into the session, often "for convenience" or "just temporarily." The session becomes a quick catch-all for any information you need to get from your servlets to your JSPs. The HttpSession interface makes sessions easy to use, which can lead to the session being overused. This is a concern because the session takes up space. In most cases that would be memory space. In other cases, it could be database or file system space. In all cases, it means more work for the server and more work for the programmers to manage what is there.

Although the session is convenient because it's accessible from every servlet or JSP, it's not always the best place to put information. Most of the data that's retrieved for display in a Web application will only be used on one page. Instead of putting the information into the session scope, use the request scope and then forward the request from the servlet to the JSP. This causes the objects to be destroyed after the request has ended, which is after the data is displayed by the JSP. If you put the objects into the session, you would either have to remove them in your code or leave them there. Leaving objects in the session is not a good idea because you're using up valuable resources for no reason. This becomes even more of an issue when your Web site has hundreds or thousands of visitors, all of whom have a session that's loaded with objects.

Some objects should be stored in the session. Objects that may be needed over and over again as a user moves through a Web site are those that should be put into the session. Anything that needs to exist longer than one request can be stored in the session, as long as these objects are removed as soon as they're no longer needed.

Considerations for Managing Sessions
When working with sessions, there are a few things to consider before designing or redesigning a Web application:

Are sessions needed in the application?
How long should the session be inactive before timing out?
Are all the objects in the session serializable?
Are the objects being bound to the session too large?
Do the objects that are in the session really need to be there?

A Need for Sessions
If you have unique users on a Web site and need to know who they are or need to get specific information to them, such as search results, then you should be using sessions. If you follow the guidelines set here, there's no reason not to use the HttpSession interface that Java provides. It's easy to use, flexible, secure, and it helps you to build a better Web site.

There's another architecture that deals with maintaining state for a client. Instead of relying on the HttpSession interface, state for clients can be maintained within Enterprise JavaBeans (EJBs). The EJB architecture takes the business logic for an application and places it in components or beans. A session bean is a type of EJB that exists for a given client/server session and provides database access or other business logic, such as calculations. Session beans can be stateless or they can maintain the state for a client, very much like an HttpSession object.

There is still some debate over where the state for a Web site visitor should be maintained. The best design for the application at this time is to continue using the HttpSession object for maintaining the state of the presentation layer of the Web application and to use stateful EJBs to maintain the state of the business logic and data layer. There are many other factors that should be considered with EJBs, one being the better performance of stateless beans over those that maintain state. These issues, which are outside the scope of this article, should be considered carefully when architecting an application.

Session Timeout
By default, on most servers the session is set to expire after 30 minutes of inactivity. The amount of time can be configured in the deployment descriptor of the Web application. The HttpSession API also provides a setMaxInactiveInterval() method that you can use to specify the timeout period for a session. The getMaxInactiveInterval() method will return this timeout value. The value given is in seconds.

The length of time will vary depending on what your visitors are doing on your site. If they're logging in to check their account balance, a shorter session timeout period can be used because it doesn't take long for a person to read a couple of numbers. If, on the other hand, the user is logging in to read large amounts of data, you need to be sure that you provide enough time for the user to do what he or she wants without being logged out. If the user is constantly navigating through your site, the session will last indefinitely.

Implement Serializable
It's important to make sure that all objects placed in the session can be serialized. This may not be an issue if you know that your Web application will not run in a cluster, but it should still be done anyway. What happens if your Web site grows too big for one server and you suddenly have to move to two? If you implement Serializable in your code now, you won't have to go back and do it later.

Keep It Simple
You should design objects that are going to be placed into a session so that they're not too big and don't contain unnecessary information. A JavaBean that contains a customer's name, address, phone number, e-mail address, credit card numbers, and order history should not be placed into the session if you're only going to use the object to get the customer's name.

Session Contents
When you're working on a Web site, it's important to know which objects are in the session and why they're needed. The size of the session should be kept as small as possible. If you're building a new Web site, work out ahead of time what goes in the session, why it's there, and where it gets removed. If you're redesigning an existing site, this may be a little tougher, especially when you have hundreds of servlets and JSPs to deal with. In this case, try implementing an HttpSessionAttributeListener to get an idea of what is going into the session. With this information, you may be able to better manage your sessions.

Conclusion
Hopefully this article helped you to better understand the design issues involved in using the HttpSession interface. Java provides a more robust session implementation than other languages. It's because of this power and flexibility that you must take the time to properly lay out the use of the session. A well-designed session will help make a Web application better for the programmers and the users.

References

Hall, M. (2002). More Servlets and JavaServer Pages. Prentice Hall PTR.

Java Servlet Technology: http://java.sun.com/products/servlet

Enterprise JavaBeans Technology: http://java.sun.com/products/ejb

Java BluePrints (J2EE): http://java.sun.com/blueprints/guidelines/ designing_enterprise_applications

另外�Q�还有一些收集的材料
关于HttpSession的误解实在是太多了，本来是一个很��单的问题�Q�怎会搞的如此的复杂呢�Q�下面说说我的理解吧�Q?br /> 1、HTTP协议本��n�?#8220;�q�接-��h��-应答-关闭�q�接”模式的，是一�U�无状态协议（HTTP只是一个传输协议）�Q?br /> 2、Cookie规范是�ؓ了给HTTP增加状态跟�t�用的（如果要精��把握，��仔细阅读一下相关的RFC�Q�，但不是唯一的手�D�；
3、所谓Session�Q�指的是客户端和服务端之间的一�D�交互过�E�的状态信息（数据�Q�；�q�个状态如何界定，生命期有多长�Q�这是应用本�w�的事情�Q?br /> 4、由于B/S计算模型中计��是在服务器端完成的�Q�客��L��只有��单的昄��逻辑�Q�所以，Session数据对客��L��应该是透明的不可理解的�q�且应该受控于服务端�Q�Session数据要么保存到服务端�Q�HttpSession�Q�，要么在客��L��和服务端之间传递（Cookie或url rewritting或Hidden input�Q�；
5、由于HTTP本��n的无状态性，服务端无法知道客��L��相��发来的请求是来自一个客��L��Q�所以，当��用服务端HttpSession存储会话数据的时候客��L��的每个请求都应该包含一个session的标�?sid, jsessionid �{�等)来告诉服务端�Q?br /> 6、会话数据保存在服务端（如HttpSession�Q�的好处是减��了HTTP��h��的长度，提高了网�l�传输效率；客户端session信息存储则相反；
7、客��L��Session存储只有一个办法：cookie(url rewritting和hidden input因�ؓ无法做到持久化，不算�Q�只能作��Z��换session id的方式，即a method of session tracking)�Q�而服务端做法大致也是一个道理：容器有个session��理器（如tomcat�?org.apache.catalina.session包里面的�c�）�Q�提供session的生命周期和持久化管理�ƈ提供讉K��session数据�?api�Q?br /> 8、��用服务端�q�是客户端session存储要看应用的实际情�늚�。一般来说不要求用户注册��d��的公共服务系�l�（如google�Q�采�?cookie做客��L��session存储�Q�如google的用户偏好设�|�）�Q�而有用户��理的系�l�则使用服务端存储。原因很昄��Q�无需用户��d��的系�l�唯一能够标识用户的就是用��L��电脑�Q�换一台机器就不知道谁是谁了，服务端session存储�Ҏ��不管用；而有用户��理的系�l�则可以通过用户id来管理用户个人数据，从而提供�Q意复杂的个性化服务�Q?br /> 9、客��L��和服务端的session存储在性能、安全性、跨站能力、编�E�方便性等斚w��都有一定的区别�Q�而且优劣�q��l�对�Q�譬如TheServerSide��L��不��用HttpSession�Q�所以性能好，�q�很昄��Q�一个具有上亿的讉K��用户的系�l�，要在服务端数据库中检索出用户的偏好信息显然是低效的，Session��理器不��用什么数据结构和��法都要耗费大量内存和CPU旉��Q�而用cookie�Q�则�Ҏ��不用��索和�l�护session数据�Q�服务器可以做成无状态的�Q�当焉��效）�Q?br /> reply1:
不过我们也不能在session里面攑օ��q�多的东�?br /> 一般来说不能超�q?K
太多�?br /> 对系�l�资源是一个很严重的浪�?br /> reply2:
4K已是很大的一个数字了�?br /> 我一般喜�Ƣ写一个类。封装用��L��陆后的一些信息�?br /> 然后把这个类攑֜�session中，取得直接用类的方法取相关信息�Q?br />

honzeland 2008-05-21 15:49 发表评论

Svn revision retrieve and logging to database

honzeland — Mon, 28 Apr 2008 07:43:00 GMT

最�q�接��C��个很��的tickets�Q�两个都是�ؓ了项目开发时的方便：一是将logs写入到数据库中，以方便日志的查询�Q�一是在build�Ӟ��在war包加入svn revision info�?br /> 1�Q?logging to database
�l�过调查�Q�决定采用log4j的org.apache.log4j.jdbc.JDBCAppender�Q�于是采用：
# logging to db
log4j.logger.com.example=DEBUG, DATABASE
log4j.additivity.com.example=false
log4j.appender.DATABASE=org.apache.log4j.jdbc.JDBCAppender
log4j.appender.DATABASE.url=jdbc:postgresql://localhost:5432/test
log4j.appender.DATABASE.driver=org.postgresql.Driver
log4j.appender.DATABASE.user=pguser
log4j.appender.DATABASE.password=post
log4j.appender.DATABASE.sql=INSERT INTO debug_log(created, logger, priority, message) VALUES (to_timestamp('%d{ISO8601}','YYYY-MM-DD HH:MI:SS.MS'),'%c.%M:%L','%p','%m')
log4j.appender.DB.layout=org.apache.log4j.PatternLayout
log4j.appender.DATABASE.layout.ConversionPattern=%d{ISO8601} %p %c.%M:%L %m
很直观，用�v来还很方便，但是不久��出��C��问题�Q�tomcat抛出了exception。只好把之前fixed ticket reopen�Q�提交新的comments�Q�Unfortunately, org.apache.log4j.jdbc.JDBCAppender that ships with the Log4j distribution is not able to process logging messages that have characters like ' (single quote) and , (comma) in it. When logging messages contains characters like single quote or comma, the program will throw an exception.
重新google了，扑ֈ�了一个plusjdbc�Q�Looking further, I found an alternative JDBCAppender package (org.apache.log4j.jdbcplus.JDBCAppender) from http://www.dankomannhaupt.de/projects/index.html. It can solve this problem. 长叹了一下�?br />
最后采用：
log4j.appender.DATABASE=org.apache.log4j.jdbcplus.JDBCAppender
log4j.appender.DATABASE.url=jdbc:postgresql://localhost:5432/test
log4j.appender.DATABASE.dbclass=org.postgresql.Driver
log4j.appender.DATABASE.username=pguser
log4j.appender.DATABASE.password=post
log4j.appender.DATABASE.sql=INSERT INTO debug_log(created, logger, priority, message) VALUES (to_timestamp('@LAYOUT:1@', 'YYYY-MM-DD HH:MI:SS.MS'),'@LAYOUT:3@','@LAYOUT:2@','@LAYOUT:4@')
log4j.appender.DATABASE.layout=org.apache.log4j.PatternLayout
log4j.appender.DATABASE.layout.ConversionPattern=%d{ISO8601}#%p#%c.%M:%L#%m
log4j.appender.DATABASE.layoutPartsDelimiter=#
log4j.appender.DATABASE.buffer=1
log4j.appender.DATABASE.commit=true
log4j.appender.DATABASE.quoteReplace=true
问题解决�Q�但是中间有点小波折�Q�在我的��目中，log4j.jar�Q?gt;1.2.9�Q�重复了�Q�在$CATALINA_HOME/lib下有一份，在web工程下的WEB-INF/lib下也有一份，而plus-jdbc.jar攄��?CATALINA_HOME/lib下，�l�果启动Tomcat�Q�出�?br /> log4j:ERROR A "org.apache.log4j.jdbcplus.JDBCAppender" object is not assignable to a "org.apache.log4j.Appender" variable.
log4j:ERROR The class "org.apache.log4j.Appender" was loaded by
log4j:ERROR [WebappClassLoader^M
delegate: false^M
repositories:^M
----------> Parent Classloader:^M
org.apache.catalina.loader.StandardClassLoader@1ccb029^M
] whereas object of type
log4j:ERROR "org.apache.log4j.jdbcplus.JDBCAppender" was loaded by [org.apache.catalina.loader.StandardClassLoader@1ccb029].
log4j:ERROR Could not instantiate appender named "DATABASE".
原来是两个JDBCAppender实例不在同一个classlaoder里面�Q�将WEB-INF/lib下的log4j.jar删除掉，重启��没问题了，按理�Q�将$CATALINA_HOME/lib下的plus-jdbc.jar�U�d��WEB-INF/lib下，应该也没问题�Q�没有测试�?br />
2�Q�Add build revision info in war file and read it on tomcat startup
�q�个�l�历比较惨痛�Q�两个问题，如何获取revision�Q?And how to read it when tomcat startup? �W�二个问题倒是没什么，采用javax.servlet.ServletContextListener��可以实玎ͼ�很简单，走弯路的是第一个问题，google后发现有两种常见的实玎ͼ�
As I have learned, there are totally two solutions to get svn revision info.

First, retrieve the svn revision from local file($BASE_HOME/.svn/entries). Just parsing the xml file, get the revision property and write it to a properties file.�Q�就是该�ȝ��xml�Q�远在乌克兰的同事，该文件却不是xml的，也只怪自��p��研不充分�Q�还得折腾了半天�Q�后来发玎ͼ�最新版的svn��Z��performance的考虑�Q�采用meta data来实现entries�Q?br />
Second, retrieve the svn revision from the remote repository. The solution always use a svn client to perform a demand with remote server to retrieve the revision info. Installing a snv client and using SvnAnt? are most commonly used at present. SvnAnt? is an ant task that provides an interface to Subversion revision control system and encapsulates the svn client. It uses javahl - a native (JNI) java interface for the subversion api if it can find the corresponding library. javahl is platform-dependent.

Because of needing interaction with the server(服务器在国外�Q�更新很�?, now I employ the first solution. But I found a flaw of this method when i was going off duty. Generally, we may update our project with svn before committing. This may make a mismatch with svn revision between remote server and local file. Svn revision in local file is usually updated when we update our project. But when we take a commit after update, the svn revision in the remote server will change to a new one.

So, the case is that if we update, commit, and then build, we may get a mismatch with the newest svn revision, and build the error revision into our ROOT.war. If we update , then build ,without commit, we can get right revision info.

下面是第一版实玎ͼ�








        svn revision: ${wc-entries.entry.revision}











�l�果write-svn-revision-to-file�q�个在我�q�倒是可以获取本地的svn revision�Q�但是远方的同事可急了�Q�build老失败，只好把这部分build注释了，�q�好�Q�到周末了，可以在家好好研究一下，很快找了一个新的工��P��
It's my fault. In my version of svn, the entries file is xml formatted. So i parse it using ant task - 'xmlproperty'. Now i have fix this problem by using 'svnkit' tools, a pure java svn toolkit. Now there are two ways to retrieve svn revision. One is from remote repository server. For this one, before building, you should set your own username and password for the remote repository server('remote.repository.username' and 'remote.repository.password' properties in build.xml,respectively). Another one is retrieving revision from local working copy. If using this one, you should set 'local.repository' property in build.xml to your own directory.
利用svnkit�Q�从服务器上获取revision大概是：
            repository = SVNRepositoryFactory.create(SVNURL.parseURIDecoded(urlStr));
            ISVNAuthenticationManager authManager = SVNWCUtil.createDefaultAuthenticationManager(username, password);
            repository.setAuthenticationManager(authManager);
            headRevision = repository.getLatestRevision();
从本地working copy获取revision�Q?br />             SVNClientManager clientManager = SVNClientManager.newInstance();
            SVNWCClient wcClient = clientManager.getWCClient();
            SVNInfo info = wcClient.doInfo(new File(fileUrl), SVNRevision.WORKING);
            headRevision = info.getRevision().getNumber();

利用ant task��获取的revision写入��C��个配�|�文件中�Q�如revision.properties�Q?在tomcat启动的时候加载进来，��可以了�?nbsp;

honzeland 2008-04-28 15:43 发表评论

Tomcat ClassLoader and load resources

honzeland — Thu, 24 Apr 2008 07:46:00 GMT

zz: http://rosonsandy.blogdriver.com/rosonsandy/871539.html

1 - Tomcat的类载入器的�l�构
Tomcat Server在启动的时候将构造一个ClassLoader树，以保证模块的�c�d��是私有的
Tomcat Server的ClassLoader�l�构如下�Q?br />         +-----------------------------+

        |         Bootstrap           |

        |             |               |

        |          System             |

        |             |               |

        |          Common             |

        |         /      \            |

        |     Catalina Shared        |

        |               /    \        |

        |          WebApp1 WebApp2   |

        +-----------------------------+

其中�Q?br /> - Bootstrap - 载入JVM自带的类�?JAVA_HOME/jre/lib/ext/*.jar
- System - 载入$CLASSPATH/*.class
- Common - 载入$CATALINA_HOME/common/...�Q�它们对TOMCAT和所有的WEB APP都可�?br /> - Catalina - 载入$CATALINA_HOME/server/...�Q�它们仅对TOMCAT可见�Q�对所有的WEB APP都不可见
- Shared - 载入$CATALINA_HOME/shared/...�Q�它们仅�Ҏ��有WEB APP可见�Q�对TOMCAT不可见（也不必见�Q?br /> - WebApp - 载入ContextBase?/WEB-INF/...�Q�它们仅对该WEB APP可见

2 - ClassLoader的工作原�?br />
每个�q�行中的�U�程都有一个成员contextClassLoader�Q�用来在�q�行时动态地载入其它�c?br /> �pȝ��默认的contextClassLoader是systemClassLoader�Q�所以一般而言java�E�序在执行时可以使用JVM自带的类�?JAVA_HOME/jre/lib/ext/中的�c�d��$CLASSPATH/中的�c?br /> 可以使用Thread.currentThread().setContextClassLoader(...);更改当前�U�程的contextClassLoader�Q�来改变其蝲入类的行�?br />
ClassLoader被组�l�成树�Ş�Q�一般的工作原理是：
1) �U�程需要用到某个类�Q�于是contextClassLoader被请求来载入该类
2) contextClassLoader��h��它的父ClassLoader来完成该载入��h��
3) 如果父ClassLoader无法载入�c�，则contextClassLoader试图自己来蝲�?br />
注意�Q�WebApp?ClassLoader的工作原理和上述有少�怸�同：
它先试图自己载入�c�（在ContextBase?/WEB-INF/...中蝲入类�Q�，如果无法载入�Q�再��h��父ClassLoader完成

由此可得�Q?br /> - 对于WEB APP�U�程�Q�它的contextClassLoader是WebApp?ClassLoader
- 对于Tomcat Server�U�程�Q�它的contextClassLoader是CatalinaClassLoader

3 �cȝ��查找

ClassLoader�c�M��loadClass�Ҏ��为缺省实玎ͼ�用下面的��序查找�c�：
1、调用findLoadedClass�Ҏ��来检查是否已�l�被加蝲。如果没有则�l�箋下面的步骤�?br /> 2、如果当前类装蝲器有一个指定的委托父装载器�Q�则用委托父装蝲器的loadClass�Ҏ��加蝲�c�，也就是委托给父装载器加蝲相应的类�?br /> 3、如果这个类装蝲器的委托层��体系没有一个类装蝲器加载该�c�，则��用类装蝲器定位类的特定实现机�Ӟ��调用findClass�Ҏ��来查扄��?br />
4 - 部分原代码分�?br /> 4.1 - org/apache/catalina/startup/Bootstrap.java
Bootstrap中定义了三个classloader:commonLoader,catalinaLoader,sharedLoader.三者关�p�d��下：
//注意三个自己定置的ClassLoader的层�ơ关�p�：
            // systemClassLoader (root)
            //   +--- commonLoader
            //          +--- catalinaLoader
            //          +--- sharedLoader

Tomcat Server�U�程的�v�?br /> 构造ClassLoader树，通过Thread.currentThread().setContextClassLoader(catalinaLoader)讄��当前的classloader为catalinaLoader�?br /> 载入若干�c�，然后转入org.apache.catalina.startup.Catalina�c�M��

4.2 org.apache.catalina.loader.StandardClassLoader.java

通过看loadClass�q�个�Ҏ��来看tomcat是如何加载类的，��序如下�Q?br />
(0) Check our previously loaded class cache查找已经装蝲的class
        clazz = findLoadedClass(name);

(1) If a system class, use system class loader通过�pȝ��classloader来装载class
        ClassLoader loader = system;
            clazz = loader.loadClass(name);

(2) Delegate to our parent if requested如果有代理则使用父类classloader
            ClassLoader loader = parent;
            if (loader == null)
                loader = system;
            clazz = loader.loadClass(name);

(3) Search local repositories 查找本地�c�L��Q�比�?CATALINA_HOME/server
           clazz = findClass(name);

(4) Delegate to parent unconditionally 默认使用代理装蝲�?br />
[查看代码]

4.3 - org/apache/catalina/startup/ClassLoaderFactory.java

�Ҏ��讄��创徏�q�返回StandardClassLoader的实�?br />
[查看代码]

4.4 - org/apache/catalina/loader/StandardClassLoader.java

�c�蝲入器

4.5 - org/apache/catalina/startup/SecurityClassLoad.java

该类仅包含一个静态方法，用来为catalinaLoader载入一些类

[查看代码]

Appendix - 参�?br />
[1] http://jakarta.apache.org/tomcat/中的Tomcat 4.1.x文档Class Loader HOW-TO

在一个JVM中可能存在多个ClassLoader�Q�每个ClassLoader拥有自己的NameSpace。一个ClassLoader只能拥有一个class对象�c�d��的实例，但是不同的ClassLoader可能拥有相同的class对象实例�Q�这时可能��生致命的问题。如ClassLoaderA�Q�装载了�c�A的类型实例A1�Q�而ClassLoaderB�Q�也装蝲了类A的对象实例A2。逻辑上讲A1=A2�Q�但是由于A1和A2来自于不同的ClassLoader�Q�它们实际上是完全不同的�Q�如果A中定义了一个静态变量c�Q�则c在不同的ClassLoader中的值是不同的�?br />
[2] 深入Java2�q�_��安全

zz: http://mail-archives.apache.org/mod_mbox/tomcat-users/200212.mbox/raw/%3c20021204192034.P86616-100000@icarus.apache.org%3e
try {
   Properties props = new Properties();
   InputStream in = getClass().getResourceAsStream("/conf/db.properties");
   props.load(in);
   ......
   propertie1 = props.getProperty("propertie1");

The examples already given will find properties files for you just fine whether the file is in a directory structure or inside an archive. How do you think Java loads classes? It works out of archives, no? here are some various was to access a properties file ( or any resource, for that matter) in whether the app is deployed as a directory or as a .war file (even inside a .jar file in WEB-INF/lib)....

1. This will load a file in WEB-INF/classes/conf or any jar file in the classpath with a package of "conf"...
   getClass().getResourceAsStream("/conf/db.properties");
2. This will load a file relative to the current class. For instance, if the class is "org.mypackage.MyClass", then the file would be loaded at "org.mypackage.conf.dbproperties". Note that this is because we didn't prepend "/" to the path. When that is done, the file is loaded from the root of the current classloader where this loads it relative to the current class...
   getClass().getResourceAsStream("conf/db.properties");
3. This will find db.properties anywhere in the current classloader as long as it exists in a "conf" package...
   getClass().getClassLoader().getResourceAsStream("conf/db.properties");
4. This will find the file in a "conf" directory inside the webapp (starting from the root). This starts looking in the same directory as contains WEB-INF. When I say "directory", I don't mean "filesystem". This could be in a .war file as well as in an actual directory on the filesystem...
   getServletContext().getResourceAsStream("/conf/db.properties");
5. Of course you would probably not want just anyone seeing your db.properties file, so you'd probably want to put in inside WEB-INF of your webapp, so....
   getServletContext().getResourceAsStream("/WEB-INF/conf/db.properties");
6. If your db.properties exists in another classloader which your app has access to, you can reach it by using:
   Thread.currentThread().getContextClassLoader().getResourceAsStream("conf/db.properties");
that will act similar to getClass().getClassLoader(), but it can see across all available classloaders where the latter can only see within the classloader that loaded the current class.

honzeland 2008-04-24 15:46 发表评论

Double Checked Locking 模式

honzeland — Tue, 19 Feb 2008 06:21:00 GMT

�l�典文章�Q?br /> Double-checked locking: Clever, but broken
Warning! Threading in a multiprocessor world

When is a singleton not a singleton?

honzeland 2008-02-19 14:21 发表评论

honzeland — Fri, 15 Feb 2008 08:19:00 GMT

一、UDP Server
��目的需要，需要利用java实现一个udp server�Q�主要的功能是侦听来自客��L��的udp��h��Q�客戯��求可能是大�ƈ发量的，对于每个��h��Server端的处理很简单，处理每个��h��的时间大�U�在1ms左右�Q�但是Server端需要维护一个对立于��h��的全局变量Cache�Q�项目本�w�已�l�采用Mina架构�Q�http://mina.apache.org/�Q�，我要开发的Server作�ؓ整个��目的一个模块，�׃��之前没有开发UDP Server�Q�受TCP Server的媄响，很自然的惛_��用多�U�程来实玎ͼ�对于每个客户��h��Q�新��Z��个线�E�来处理相应的逻辑�Q�在实现的过�E�中�Q�利用Mina的Thread Model�Q�实��C��一个多�U�程的UDP Server�Q�但是由于要�l�护一个全局Cache�Q�需要在各线�E�之间同步，加之处理��h��的时间很短，很快��发现在此利用多�U�程�Q��ƈ不能提高性能�Q�于是决定采用单�U�程来实玎ͼ�在动手之前，�q�是发现有两�U�方案来实现单线�E�UDP Server�Q?br /> 1�Q?采用JDK的DatagramSocket和DatagramPacket来实�?br /> public class UDPServerUseJDK extends Thread{
   /**
   * Constructor
   * @param port port used to listen incoming connection
   * @throws SocketException error to consturct a DatagramSocket with this port
   */
   public MediatorServerUseJDK(int port) throws SocketException{
       this("MediatorServerThread", port);
   }

   /**
   * Constructor
   * @param name the thread name
   * @param port port used to listen incoming connection
   * @throws SocketException error to consturct a DatagramSocket with this port
   */
   public MediatorServerUseJDK(String name, int port) throws SocketException{
       super(name);
       socket = new DatagramSocket(port);
       System.out.println("Mediator server started on JDK model...");
       System.out.println("Socket buffer size: " + socket.getReceiveBufferSize());
   }

   public void run(){
       long startTime = 0;
       while(true){
            try {
               buf = new byte[1024];
               // receive request
               packet = new DatagramPacket(buf, buf.length);
                socket.receive(packet);
               .........
            }catch (IOException e) {
           .........
            }
       }
   }
�?br /> 2�Q?采用Mina的DatagramAcceptor来实玎ͼ�在创建Exector的时候，只传递单个线�E?br /> public class MediatorServerUseMina {
   private DatagramAcceptor acceptor;

   public MediatorServerUseMina() {

   }

   public void startListener(InetSocketAddress address, IoHandler handler) {
       // create an acceptor with a single thread
       this.acceptor = new DatagramAcceptor(Executors.newSingleThreadExecutor());
       // configure the thread models
       DatagramAcceptorConfig acceptorConfig = acceptor.getDefaultConfig();
       acceptorConfig.setThreadModel(ThreadModel.MANUAL);
       // set the acceptor to reuse the address
       acceptorConfig.getSessionConfig().setReuseAddress(true);
       // add io filters
       DefaultIoFilterChainBuilder filterChainBuilder = acceptor.getFilterChain();
       // add CPU-bound job first,
       filterChainBuilder.addLast("codec", new ProtocolCodecFilter(new StringCodecFactory()));
       try {
           // bind
           acceptor.bind(address, handler);
           System.out.println("Mediator Server started on mina model...");
           System.out.println("Socket buffer size: " + acceptorConfig.getSessionConfig().getReceiveBufferSize());
       } catch (IOException e) {
           System.err.println("Error starting component listener on port(UDP) " + address.getPort() + ": "
                   + e.getMessage());
       }
   }
}
二、Performance Test
��Z��试两个Server的性能�Q�写了个��单的��试客户�?br /> import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.net.SocketException;
import java.net.UnknownHostException;

/**
* @author Herry Hong
*
*/

public class PerformanceTest {
   /** Number of threads to be created */
   static final int THREADS = 100;
   /** Packets to be sent per thread */
   static final int PACKETS = 500;
   /** The interval of two packets been sent for each thread */
   private static final int INTERVAL = 80;
   private static final String DATA = "5a76d93cb435fc54eba0b97156fe38f432a4e1da3a87cce8a222644466ed1317";

   private class Sender implements Runnable {
       private InetAddress address = null;
       private DatagramSocket socket = null;
       private String msg = null;
       private String name = null;
       private int packet_sent = 0;

       public Sender(String addr, String msg, String name) throws SocketException,
               UnknownHostException {
           this.address = InetAddress.getByName(addr);
           this.socket = new DatagramSocket();
           this.msg = msg;
           this.name = name;
       }

       @Override
       public void run() {
           // send request
           byte[] buf = msg.getBytes();
           DatagramPacket packet = new DatagramPacket(buf, buf.length,
                   address, 8000);
           try {
               for (int i = 0; i < PerformanceTest.PACKETS; i++) {
                   socket.send(packet);
                   packet_sent++;
                   Thread.sleep(INTERVAL);
               }
           } catch (IOException e) {
               e.printStackTrace();
           } catch (InterruptedException e) {
               e.printStackTrace();
           }
           //System.out.println("Thread " + name + " sends " + packet_sent + " packets.");
           //System.out.println("Thread " + name + " end!");
       }
   }

   /**
   * @param args
   */
   public static void main(String[] args) {
       if (args.length != 1) {
           System.out.println("Usage: java PerformanceTest ");
           return;
       }
       String msg;
       for (int i = 0; i < THREADS; i++) {
           if(i % 2 == 0){
               msg = i + "_" + (i+1) + ""r"n" + (i+1) + "_" + i + ""r"n" + DATA;
           }else{
               msg = i + "_" + (i-1) + ""r"n" + (i-1) + "_" + i + ""r"n" + DATA;
           }
           try {
               new Thread(new PerformanceTest().new Sender(args[0], msg, "" + i)).start();
           } catch (SocketException e) {
               e.printStackTrace();
           } catch (UnknownHostException e) {
               e.printStackTrace();
           }
       }
   }
}
三、测试结�?br /> ��试环境�Q?br /> Server�Q�AMD Athlon(tm) 64 X2 Dual Core Processor 4000+�Q?G memory
Client�Q�AMD Athlon(tm) 64 X2 Dual Core Processor 4000+�Q?G memory
在测试的�q�程中，当INTERVAL讄��的太��时�Q�服务器端会出现丢包现象�Q�INTERVAL��小�Q�丢包越严重�Q��ؓ了提高Server的性能�Q�特��Socket的ReceiveBufferSize讄��成默认大��的两倍，
对于JDK实现�Q?br />    public MediatorServerUseJDK(String name, int port) throws SocketException{
       super(name);
       socket = new DatagramSocket(port);
       // set the receive buffer size to double default size
        socket.setReceiveBufferSize(socket.getReceiveBufferSize() * 2);
        System.out.println("Mediator server started on JDK model...");
       System.out.println("Socket buffer size: " + socket.getReceiveBufferSize());
   }
对于Mina实现�Q?br />        DatagramAcceptorConfig acceptorConfig = acceptor.getDefaultConfig();
       acceptorConfig.setThreadModel(ThreadModel.MANUAL);
       // set the acceptor to reuse the address
       acceptorConfig.getSessionConfig().setReuseAddress(true);
       // set the receive buffer size to double default size
       int recBufferSize = acceptorConfig.getSessionConfig().getReceiveBufferSize();
       acceptorConfig.getSessionConfig().setReceiveBufferSize(recBufferSize * 2);
此时�Q�相同的INTERVAL�Q�丢包现象明昑և��?br /> 接下来，再测试不同实现的性能差异�Q?br /> UDP server started on JDK model...
Socket buffer size: 110592
INTERVAL �Q?100ms�Q�没有出��C��包，
Process time: 49988
Process time: 49982
Process time: 49984
Process time: 49986
Process time: 49984
INTERVAL �Q?80ms�Q�仍然没有丢包，不管Server是不是初�ơ启�?br /> Process time: 40006
Process time: 40004
Process time: 40003
Process time: 40005
Process time: 40013
UDP Server started on mina model...
Socket buffer size: 110592
INTERVAL �Q?80ms�Q�Server初次启动�Ӟ��l�常会出��C��包，当第一�ơ（指服务器初次启动�Ӟ��没有丢包�Ӟ��随后基本不丢包，
Process time: 39973
Process time: 40006
Process time: 40007
Process time: 40008
Process time: 40008
INTERVAL �Q?100ms�Q�没有出��C��?br /> Process time: 49958
Process time: 49985
Process time: 49983
Process time: 49988
四、结�?br /> 在该要求下，采用JDK和Mina实现性能相当�Q�但是在Server初次启动时JDK实现基本不会出现丢包�Q�而Mina实现则在Server初次启动时经常出��C��包现象，在经历第一�ơ测试后�Q�两�U�实现处理时间相�q�，��h��q�发量大概�ؓ每ms一个请求时�Q�服务器不会出现丢包�?br />

honzeland 2008-02-15 16:19 发表评论

honzeland — Fri, 25 Jan 2008 09:36:00 GMT

1�?从Openfire SVN Server中dump出源码；
2�?Build: ant & ant plugins
3�?��build后的target/openfire作�ؓopenfire_home
4�?在target/openfire下徏立两个目录：src和classes�Q�将dump下来的源码copy到src路径下，��classes讄��为eclipse�~�译后的输出路径
5�?��?openfire_home/lib下的openfire.jar中src中存在的部分删除�Q�剩下的部分作�ؓ新的openfire.jar�Q�注意，在ubuntu下之间打开openfire.jar�Ӟ��直接��?org/jivesoftware/admin, /org/jivesoftware/openfire, /org/jivesoftware/util三个目录删除�Q�而对�?org/jivesoftware/database目录�Q�只��源码中有的那部分删除，/org/jivesoftware下面�q�有一个隐藏目�?org/jivesoftware/stringprep�Q�不能删除，接下来，��?openfire_home/lib下的jar包作为工�E�的Referenced Libraries.
6�?��取出来的工�E�下src/web/WEB-INF/classes/openfire_init.xml导入到eclipse的查询�\径里�Q�如��src/web/WEB-INF/classes目录作�ؓeclipse的源目录�Q�这样openfire_init.xml自动copy�?openfire_home/classses下面�Q�将openfire_init.xml中的openfireHome讄��?openfire_home
7�?修改org.jivesoftware.openfire.starter.ServerStarter中的如下两个field�Q?br />            private static final String DEFAULT_LIB_DIR = "../lib";
           private static final String DEFAULT_ADMIN_LIB_DIR = "../plugins/admin/webapp/WEB-INF/lib";
�Ҏ��Q?br />            private static final String DIR_PREFIX = "$openfire_home";     // to be your own openfire_home
           private static final String DEFAULT_LIB_DIR = DIR_PREFIX + "lib";
           private static final String DEFAULT_ADMIN_LIB_DIR = DIR_PREFIX + "plugins/admin/webapp/WEB-INF/lib";

honzeland 2008-01-25 17:36 发表评论

honzeland — Tue, 15 Jan 2008 06:45:00 GMT

zz: http://daoger.javaeye.com/blog/47801

2.调用有简单返回值的java�Ҏ��
2.1�?span class="hilite1">dwr.xml的配�|?
配置�?.1
<dwr>

dwr.TestClass" />

dwr>
2.2、javascript中调�?
首先�Q�引入javascript脚本
其次�Q�编写调用java�Ҏ��的javascript函数和接收返回值的回调函数
Function callTestMethod2(){
testClass.testMethod2(callBackFortestMethod2);
}
Function callBackFortestMethod2(data){
//其中date接收�Ҏ��的返回�?
//可以在这里对�q�回��D��行处理和昄��{�等
alert("the return value is " + data);
}
其中callBackFortestMethod2是接收返回值的回调函数

3、调用有��单参数的java�Ҏ��
3.1�?span class="hilite1">dwr.xml的配�|?
配置�?.1
<dwr>

dwr.TestClass" />

dwr>
3.2、javascript中调�?
首先�Q�引入javascript脚本
其次�Q�编写调用java�Ҏ��的javascript函数
Function callTestMethod3(){
//定义要传到java�Ҏ��中的参数
var data;
//构造参�?
data = “test String”;
testClass.testMethod3(data);
}

4、调用返回JavaBean的java�Ҏ��
4.1�?span class="hilite1">dwr.xml的配�|?
<dwr>

dwr.TestClass" />

dwr.TestBean">

dwr>
标签负责公开用于Web�q�程的类和类的方法，标签则负责这些方法的参数和返回类型。convert元素的作用是告诉DWR在服务器端Java 对象表示和序列化的JavaScript之间如何转换数据�c�d��?span class="hilite1">DWR自动地在Java和JavaScript表示之间调整��单数据类型。这些类型包括Java原生�c�d��和它们各自的��装�c�表�C�，�q�有String、Date、数�l�和集合�c�d��?span class="hilite1">DWR也能把JavaBean转换成JavaScript 表示�Q�但是出于安全性的原因�Q�要求显式的配置�Q?lt;convertor>标签��是完成此功能的。converter="bean"属性指定�{换的方式采用JavaBean命名规范�Q�match=""com.dwr.TestBean"属性指定要转换的javabean名称�Q?lt;param>标签指定要�{换的JavaBean属性�?
4.2、javascript中调�?
首先�Q�引入javascript脚本
其次�Q�编写调用java�Ҏ��的javascript函数和接收返回值的回调函数
Function callTestMethod4(){
testClass.testMethod4(callBackFortestMethod4);
}
Function callBackFortestMethod4(data){
//其中date接收�Ҏ��的返回�?
//对于JavaBean�q�回��|��有两�U�方式处�?
//不知道属性名�U�时�Q��用如下方�?
for(var property in data){
alert("property:"+property);
alert(property+":"+data[property]);
}
//知道属性名�U�时�Q��用如下方�?
alert(data.username);
alert(data.password);
}
其中callBackFortestMethod4是接收返回值的回调函数

5、调用有JavaBean参数的java�Ҏ��
5.1�?span class="hilite1">dwr.xml的配�|?
配置�?.1
<dwr>

dwr.TestClass" />

dwr.TestBean">

dwr>
5.2、javascript中调�?
首先�Q�引入javascript脚本
其次�Q�编写调用java�Ҏ��的javascript函数
Function callTestMethod5(){
//定义要传到java�Ҏ��中的参数
var data;
//构造参敎ͼ�date实际上是一个object
data = { username:"user", password:"password" }
testClass.testMethod5(data);
}

6、调用返回List、Set或者Map的java�Ҏ��
6.1�?span class="hilite1">dwr.xml的配�|?
配置�?.1
<dwr>

dwr.TestClass" />

dwr.TestBean">

dwr>
注意�Q�如果List、Set或者Map中的元素均�ؓ��单类型（包括其封装类�Q�或String、Date、数�l�和集合�c�d��Q�则不需�?lt;convert>标签�?
6.2、javascript中调�?以返回List��Z��Q�List的元素�ؓTestBean)
首先�Q�引入javascript脚本
其次�Q�编写调用java�Ҏ��的javascript函数和接收返回值的回调函数
Function callTestMethod6(){
testClass.testMethod6(callBackFortestMethod6);
}
Function callBackFortestMethod6(data){
//其中date接收�Ҏ��的返回�?
//对于JavaBean�q�回��|��有两�U�方式处�?
//不知道属性名�U�时�Q��用如下方�?
for(var i=0;i for(var property in data){
alert("property:"+property);
alert(property+":"+data[property]);
}
}
//知道属性名�U�时�Q��用如下方�?
for(var i=0;i alert(data[i].username);
alert(data[i].password);
}
}

7、调用有List、Set或者Map参数的java�Ҏ��
7.1�?span class="hilite1">dwr.xml的配�|?
<dwr>

dwr.TestClass" />

dwr.TestBean">

<signatures>
import java.util.List;
import com.dwr.TestClass;
import com.dwr.TestBean;
TestClass.testMethod7(List);
]]>
signatures>
dwr>
<signatures>标签是用来声明java�Ҏ��中List、Set或者Map参数所包含的确切类�Q�以便java代码作出判断�?
7.2、javascript中调�?以返回List��Z��Q�List的元素�ؓTestBean)
首先�Q�引入javascript脚本
其次�Q�编写调用java�Ҏ��的javascript函数
Function callTestMethod7(){
//定义要传到java�Ҏ��中的参数
var data;
//构造参敎ͼ�date实际上是一个object数组�Q�即数组的每个元素均为object
data = [
{
username:"user1",
password:"password2"
},
{
username:"user2",
password:" password2"
}
];
testClass.testMethod7(data);
}

注意�Q?
1、对于第6�U�情况，如果java�Ҏ��的返回��gؓMap�Q�则在接收该�q�回值的javascript回调函数中如下处理：
function callBackFortestMethod(data){
//其中date接收�Ҏ��的返回�?
for(var property in data){
var bean = data[property];
alert(bean.username);
alert(bean.password);
}
}
2、对于第7�U�情况，如果java的方法的参数为Map�Q�假讑օ�key为String�Q�value为TestBean�Q�，则在调用该方法的javascript函数中用如下�Ҏ��构造要传递的参数�Q?
function callTestMethod (){
//定义要传到java�Ҏ��中的参数
var data;
//构造参敎ͼ�date实际上是一个object�Q�其属性名为Map的key�Q�属性��gؓMap的value
data = {
"key1":{
username:"user1",
password:"password2"
},
"key2":{
username:"user2",
password:" password2"
}
};
testClass.testMethod(data);
}
�q�且�?span class="hilite1">dwr.xml中增加如下的配置�D?
<signatures>
import java.util.List;
import com.dwr.TestClass;
import com.dwr.TestBean;
TestClass.testMethod7(Map);
]]>
signatures>
3、由以上可以发现�Q�对于java�Ҏ��的返回��gؓList(Set)的情况，DWR��其转化为Object数组�Q�传递个javascript�Q�对于java�Ҏ��的返回��gؓMap的情况，DWR��其转化��Z��个Object�Q�其中Object的属性�ؓ原Map的key��|��属性��gؓ原Map相应的value倹{�?
4、如果java�Ҏ��的参��CؓList(Set)和Map的情况，javascript中也要根�?�U�所��_��构造相应的javascript数据来传递到java中�?br />

honzeland 2008-01-15 14:45 发表评论

glassfish java.net.UnknownHostException: xxx: xxx

honzeland — Wed, 09 Jan 2008 07:19:00 GMT

启动glassfish�Ӟ��发生如下异常�Q?br /> xxx@xxx:/opt$ asadmin start-domain domain1
Jan 9, 2008 2:49:18 PM com.sun.enterprise.util.ASenvPropertyReader setSystemProperties
SEVERE: property_reader.unknownHost
java.net.UnknownHostException: xxx: xxx
        at java.net.InetAddress.getLocalHost(InetAddress.java:1353)
        at com.sun.enterprise.util.net.NetUtils.getCanonicalHostName(NetUtils.java:102)
        at com.sun.enterprise.util.ASenvPropertyReader.setSystemProperties(ASenvPropertyReader.java:201)
        at com.sun.enterprise.cli.commands.S1ASCommand.(S1ASCommand.java:164)
        at com.sun.enterprise.cli.commands.BaseLifeCycleCommand.(BaseLifeCycleCommand.java:101)
        at com.sun.enterprise.cli.commands.StartDomainCommand.(StartDomainCommand.java:78)
        at sun.reflect.NativeConstructorAccessorImpl.newInstance0(Native Method)
        at sun.reflect.NativeConstructorAccessorImpl.newInstance(NativeConstructorAccessorImpl.java:39)
        at sun.reflect.DelegatingConstructorAccessorImpl.newInstance(DelegatingConstructorAccessorImpl.java:27)
        at java.lang.reflect.Constructor.newInstance(Constructor.java:513)
        at java.lang.Class.newInstance0(Class.java:355)
        at java.lang.Class.newInstance(Class.java:308)
        at com.sun.enterprise.cli.framework.CommandFactory.createCommand(CommandFactory.java:91)
        at com.sun.enterprise.cli.framework.CLIMain.invokeCommand(CLIMain.java:160)
        at com.sun.enterprise.cli.framework.CLIMain.main(CLIMain.java:79)
Starting Domain domain1, please wait.
Log redirected to /opt/glassfish/domains/domain1/logs/server.log.
Redirecting output to /opt/glassfish/domains/domain1/logs/server.log
Domain domain1 is ready to receive client requests. Additional services are being started in background.
java.net.UnknownHostException: hongzeguo: hongzeguo
CLI156 Could not start the domain domain1.

Solution�Q?br /> xxx@xxx:/opt$ nslookup xxx
Server:         202.106.46.151
Address:        202.106.46.151#53

** server can't find xxx: NXDOMAIN

Check your /etc/hosts file. Does it have an entry with actual name and ip address of your box?
For example: append follows to /etc/hosts
127.0.0.1 xxx

honzeland 2008-01-09 15:19 发表评论

JMock Examples

honzeland — Thu, 13 Dec 2007 04:45:00 GMT

The following is a simple example of a servlet we will write unit tests for:

The servlet:
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.ServletException;
import java.io.IOException;
import java.util.Map;

public class MyServlet extends HttpServlet {
   private MyService myService;
   public void setMyService(MyService myService) {
       this.myService = myService;
   }

   public void process(HttpServletRequest request, HttpServletResponse response) {
       String action = request.getParameter("action");
       if ("update".equals(action)) {
           Map parameters = request.getParameterMap();
           try {
               myService.updateModel(parameters);
           } catch (MyException e) {
               request.setAttribute("error", e.getMessage());
           }
       }
       request.setAttribute("model", myService.getModel());
       getServletContext().getRequestDispatcher("myView.jsp").forward(request, response);
   }

   protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
       process(request, response);
   }
}

The unit test:
    * if the action is update, does it call myService.updateModel (example is below)
    * if myService.updateModel throws an exception does the response contain the exceptions message (not implemented below)
import org.jmock.Mock;
import org.jmock.MockObjectTestCase;
public class MyServletTest extends MockObjectTestCase {
   private Mock mockMyService;
   private Mock mockRequest;
   private Mock mockResponse;
   private MyService myService;
   private HttpServletRequest request;
   private HttpServletResponse response;
   private MyServlet myServlet;

   protected void setUp() throws java.lang.Exception {
       mockMyService = mock(MyService.class);
       mockRequest = mock(HttpServletRequest.class);
       mockResponse = mock(HttpServletResponse.class);
       myService = (MyService) mockMyService.proxy();
       request = (HttpServletRequest) mockRequest.proxy();
       response = (HttpServletResponse) mockResponse.proxy();
       myServlet = new MyServlet();
   }

   public void testUpdate() {
       // SETUP ANY OBJECTS USED ONLY IN THIS TESTCASE
       Map parameters = new Hashtable();
       // SETUP THE EXPECTED CALLS TO THE MOCK OBJECTS
       // setup the mock request object to have the getParameter
       // method called once with argument being equal to the
       // string action and have it return the string update
       mockRequest.expects(once()).method("getParameter").
           with(eq("action")).will(returnValue("update"));
       // setup the mock request object to have the getParameterMap
       // method called once with no arguments and have it
       // return an empty map
       mockRequest.expects(once()).method("getParameterMap")
           .will(returnValue(parameters));
       // setup the mock myService object to have the updateModel
       // method called once with the parameters map as the
       // argument
       mockMyService.expects(once()).method("updateModel").with(same(parameters));
       // setup the mock myService object to have the getModel
       // method called once with no arguments and have it
       // return an empty map
       mockMyService.expects(once()).method("getModel")
           .will(returnValue(parameters));
       // setup the mock myService object to have the updateModel
       // method called once with the parameters map as the
       // argument
       mockRequest.expects(once()).method("setAttribute").with(eq("model"), same(parameters));
       // RUN THE TEST
       // add the myService mock object to the servlet so
       // that it can handle calls later
       myServlet.setMyService(myService);
       myServlet.process(request, response);
   }
}

honzeland 2007-12-13 12:45 发表评论

Eclipse 启动讄��Q�避免Out of Memory

honzeland — Thu, 13 Dec 2007 04:40:00 GMT

-vmargs
-Xmx512M
-XX:PermSize=64M
-XX:MaxPermSize=128M

honzeland 2007-12-13 12:40 发表评论

honzeland — Fri, 18 May 2007 06:59:00 GMT

http://www.onjava.com

O'Reilly的Java�|�站. 每周都有新文�?/span>

http://java.sun.com

官方的Java开发者网�?- 每周都有新文章发�?/p>

http://www.developer.com/java

由Gamelan.com �l�护的Java技术文章网�?/span>

http://www.java.net

Sun公司�l�护的一个Java�C�֌��|�站

http://www.ibm.com/developerworks/java

IBM的Developerworks技术网�? �q�是其中的Java技术主��?/p>

http://www.javaworld.com

最早的一个Java站点. 每周更新Java技术文�?/span>

http://www.javadesktop.org

位于Java.net的一个Java桌面技术社区网�?

http://www.theserverside.com

�q�是一个讨论所有Java服务器端技术的�|�站.

http://www.jars.com

提供Java评论服务. 包括各种framework和应用程�?/p>

http://www.ibiblio.org/javafaq/javafaq.html

comp.lang.java的FAQ站点 - 攉��了来自comp.lang.java新闻�l�的问题和答案的分类目录.

http://java.sun.com/docs/books/tutorial/

来自SUN公司的官方Java指南 - 对于了解几乎所有的java技术特性非常有帮助.

http://www.javablogs.com

互联�|�上最�z�跃的一个Java Blog�|�站.

http://www.java2s.com

Java Codes

honzeland 2007-05-18 14:59 发表评论

关于ServerSocket.accept()

honzeland — Thu, 30 Nov 2006 08:46:00 GMT

对于TCP套接字，在服务器端通常采用下面的语句来实现�Q?/font>
ServerSocket welcomeSocket = new ServerSocket(6789); (1)
Socket connectionSocket = welcomeSocket.accept(); (2)
�W�（1�Q�句创徏了一个能监听某些客户�?span lang="EN-US">�?/span>敲门�?/span>声的门，welcomeSocket�?span lang="EN-US">6789端口上监听；当某些客��h��?span lang="EN-US">welcomeSocket�q�接�Ӟ��W�（2�Q�句创徏了一个新的套接字�Q�称�?span lang="EN-US">connectionSocket�Q�这个套接字也��?span lang="EN-US">6789端口�Q�这�Ӟ��两个套接字��用了相同的端口号�Q�因�?span lang="EN-US">TCP�q�接套接�?/span>�׃��个四元组�Q�源IP地址�Q�源端口��P��目的IP地址�Q�目的端口号�Q�来标识�Q?span lang="EN-US">UDP套接字（面向无连接的�Q�由一个包含目�?span lang="EN-US">IP地址和目的端口号�l�成的二元组来标识。之后，TCP在客��L��?span lang="EN-US">clientSocket和服务器端的connectionSocket之间建立了一条直接的虚礼��道�Q�该客户��Z��服务器可以通过该管道彼此发送字节，�q�且发送的所有字节将按顺序到辑֯�斏V��随着connectionSocket的徏立，该服务器能��l��?span lang="EN-US">welcomeSocket监听其它客户机的�q�接��h��?span lang="EN-US">

honzeland 2006-11-30 16:46 发表评论

Override and Overload

honzeland — Fri, 10 Nov 2006 02:37:00 GMT

Override: �Q�覆盖）
1 �?/span> Override 发生在��承中�Q��得一个子�c?/span> Override 其父�cȝ��一�?/span> method �?/span>
2 �?/span> Override Rules �Q?/span> Keeping the contract 。子�c?/span> override 父类�?/span> method �Ӟ��必须要保�?/span> overriding method 和父�c�M��?/span> overridden method ��h��相同的对外协�?/span> contract �Q�即相同的参数列表和兼容的返回类�?/span>�?/span>
3 �?/span> Arguments must be the same, and return types must be compatible.
4 �?/span> The method can't be less accessible. 考虑如下情况�Q�如果访问权限变��了�Q�如��q��c?/span> Parent 中的 public void test() 变成子类 Son 中的 private void test() �Q�如果编译器允许权限变小�Q�在某一�c�M��有如下语句： Parent p = new Son() �Q?/span> p.test() �Q�则�q�些语句能够通过�~�译�Q�当该类加蝲�q�行�Ӟ��会出现错误�Q�因为父�c?/span> reference p 指向的是一子类 Son 的对象，�?/span> Son 中的 test() �?/span> private �Q�不能在其他�c�M�� invoke �?/span>
另外�Q�上面的语句在编译器允许权限变小情况下之所以能够通过�~�译�Q�是因�ؓ�?/span> “Parent p = new Son() �Q?/span> �?/span> 中，声明了一个父�c?/span> Parent �?/span> reference p �Q�由�?/span> p 是父�cȝ�� reference �Q�由于父�c�M��?/span> test() �?/span> public �Q�故 “p.test() �Q?/span> �?/span> 能够通过�~�译�Q�而在�q�行�Ӟ�� p 指向的是一个子�cȝ��对象�Q?/span> p.test() 在运行时调用的是子类对象中的 test() �?/span>

Overload �Q�（重蝲�Q?/span>
1 、重载：两个或多�?/span> methods ��h��相同�?/span> name �Q?/span> �?/span> 不同�?/span> argument lists �?/span>
2 �?/span> The return types can be different.
3 �?/span> You can't change ONLY the return type �Q�不能仅仅改变返回类型， To overload a method, you MUST change the argument list, although you can change the return type to anything.
4 �?/span> You can vary the access levels in any direction.

honzeland 2006-11-10 10:37 发表评论

全面解析Java中的String数据�c�d��

honzeland — Sun, 05 Nov 2006 06:32:00 GMT

1. 首先 String 不属�?/span> 8 �U�基本数据类型， String 是一个对象�?/span>
　　因�ؓ对象的默认值是 null �Q�所�?/span> String 的默认��g��?/span> null �Q�但它又是一�U�特�D�的对象�Q�有其它对象没有的一些特性�?/span>
2. new String() �?/span> new String(“�? 都是��x��一个新的空字符�Ԍ��是空串不�?/span> null �Q?/span>
3. String str=”kvill�?/span> �Q?/span> String str=new String (“kvill�?; 的区别：在这里，我们不谈堆，也不谈栈�Q�只先简单引入常量池�q�个��单的概念�?/span>
　　帔R��?/span> (constant pool) 指的是在�~�译期被��定�Q��ƈ被保存在已编译的 .class 文�g中的一些数据。它包括了关于类、方法、接口等中的帔R��Q�也包括字符串常量�?/span>
　　看例 1 �Q?/span>
String s0=”kvill�?
String s1=”kvill�?
String s2=”kv�?+ “ill�?
System.out.println( s0==s1 );
System.out.println( s0==s2 );

　　�l�果为：
true
true
　　首先�Q�我们要知结果�ؓ�?/span> Java 会确保一个字�W�串帔R��只有一个拷�?/span> �?/span>
　　因�ؓ例子中的 s0 �?/span> s1 中的 ”kvill�?/span> 都是字符串常量，它们在编译期��p��定�?/span>�Q�所�?/span> s0==s1 �?/span> true �Q��?/span> ”kv�?/span> �?/span> ”ill�?/span> 也都是字�W�串帔R��Q�当一个字�W�串由多个字�W�串帔R��q�接而成�Ӟ��它自��p��定也是字�W�串帔R��Q�所�?/span> s2 也同样在�~�译期就被解析�ؓ一个字�W�串帔R��Q�所�?/span> s2 也是帔R��池中 ”kvill�?/span> 的一个引用�?/span>
　　所以我们得�?/span> s0==s1==s2; �?/span> new String() 创徏的字�W�串不是帔R��Q�不能在�~�译期就��定�Q�所�?/span> new String() 创徏的字�W�串不放入常量池中，它们有自��q��地址�I�间�?/span>
　　看例 2 �Q?/span>
String s0=”kvill�?
String s1=new String(”kvill�?;
String s2=”kv�?+ new String(“ill�?;
System.out.println( s0==s1 );
System.out.println( s0==s2 );
System.out.println( s1==s2 );
　　�l�果为：
false
false
false

　　�?/span> 2 �?/span> s0 �q�是帔R��池中 ”kvill�?/span> 的应用， s1 因�ؓ无法在编译期��定�Q�所以是�q�行时创建的新对�?/span> ”kvill�?/span> 的引用， s2 因�ؓ有后半部�?/span> new String(“ill�? 所以也无法在编译期��定�Q�所以也是一个新创徏对象 ”kvill�?/span> 的应�?/span> ; 明白了这些也��q��道�ؓ何得出此�l�果了�?/span>
4. String.intern() �Q?/span>
　　再补充介�l�一点：存在�?/span> .class 文�g中的帔R��池，在运行期�?/span> JVM 装蝲�Q��ƈ且可以扩充�?/span> String �?/span> intern() �Ҏ��是扩充帔R��池的一个方法；当一�?/span> String 实例 str 调用 intern() �Ҏ��Ӟ�� Java 查找帔R��池中是否有相�?/span> Unicode 的字�W�串帔R��Q�如果有�Q�则�q�回其的引用�Q�如果没有，则在帔R��池中增加一�?/span> Unicode �{�于 str 的字�W�串�q�返回它的引用；看例 3 ��清楚了
　　�?/span> 3 �Q?/span>
String s0= “kvill�?
String s1=new String(”kvill�?;
String s2=new String(“kvill�?;
System.out.println( s0==s1 );
System.out.println( �?*********�?);
s1.intern();
s2=s2.intern(); // 把常量池�?/span> “kvill�?/span> 的引用赋�l?/span> s2
System.out.println( s0==s1);
System.out.println( s0==s1.intern() );
System.out.println( s0==s2 );
　　�l�果为：
false
**********
false // 虽然执行�?/span> s1.intern(), 但它的返回值没有赋�l?/span> s1
true // 说明 s1.intern() �q�回的是帔R��池中 ”kvill�?/span> 的引�?/span>
true
　　最后我再破除一个错误的理解�Q�有��Q?/span> �?/span> 使用 String.intern() �Ҏ��则可以将一�?/span> String �cȝ��保存��C��个全局 String 表中�Q�如果具有相同值的 Unicode 字符串已�l�在�q�个表中�Q�那么该�Ҏ��q�回表中已有字符串的地址�Q�如果在表中没有相同值的字符�Ԍ��则将自己的地址注册到表�?/span> �?/span> 如果我把他说的这个全局�?/span> String 表理解�ؓ帔R��池的话，他的最后一句话�Q?/span> �?/span> 如果在表中没有相同值的字符�Ԍ��则将自己的地址注册到表�?/span> �?/span> 是错的：
　　看例 4 �Q?/span>
String s1=new String("kvill");
String s2=s1.intern();
System.out.println( s1==s1.intern() );
System.out.println( s1+" "+s2 );
System.out.println( s2==s1.intern() );
　　�l�果�Q?/span>

false
kvill kvill
true
　　在这个类中我们没有声名一�?/span> ”kvill�?/span> 帔R��Q�所以常量池中一开始是没有 ”kvill�?/span> 的，当我们调�?/span> s1.intern() 后就在常量池中新��d��了一�?/span> ”kvill�?/span> 帔R��Q�原来的不在帔R��池中�?/span> ”kvill�?/span> 仍然存在�Q�也��׃��?/span> �?/span> ��自��q��地址注册到常量池�?/span> �?/span> 了�?/span>
　　 s1==s1.intern() �?/span> false 说明原来�?/span> “kvill�?/span> 仍然存在�Q?/span> s2 现在为常量池�?/span> “kvill�?/span> 的地址�Q�所以有 s2==s1.intern() �?/span> true �?/span>
5. 关于 equals() �?/span> ==
　　�q�个对于 String ��单来说就是比较两字符串的 Unicode 序列是否相当�Q�如果相�{�返�?/span> true; �?/span> == 是比较两字符串的地址是否相同�Q�也��是是否是同一个字�W�串的引用�?/span>
6. 关于 String 是不可变�?/span>
　　�q�一说又要说很多�Q�大家只要知�?/span> String 的实例一旦生成就不会再改变了�Q�比如说�Q?/span> String str=”kv�?”ill�?�?�?”ans�?
　　��是�?/span> 4 个字�W�串帔R��Q�首�?/span> ”kv�?/span> �?/span> ”ill�?/span> 生成�?/span> ”kvill�?/span> 存在内存中，然后 ”kvill�?/span> 又和 �?�? 生成 ”kvill �?/span> 存在内存中，最后又和生成了 ”kvill ans�? �q�把�q�个字符串的地址赋给�?/span> str, ��是因�ؓ String �?/span> �?/span> 不可�?/span> �?/span> 产生了很多��时变量，�q�也��是��Z��么徏议用 StringBuffer 的原因了�Q�因�?/span> StringBuffer 是可改变的�?/span>

honzeland 2006-11-05 14:32 发表评论

Abstract class and interface

honzeland — Thu, 26 Oct 2006 09:27:00 GMT

1 、抽象类和接口都不能被实例化�Q?/span>

2 、抽象类�Q�抽象类中可以不包含抽象�Ҏ��Q�即�c�M��的方法都是非抽象的，但是在类的声明中加上 abstract �Q�以使得该类是抽象的�Q�目的是防止客户端程序员创徏该类的对象；

3 、接口中的方法��L�� abstract and public �Q�不��是否被昄��的声明；

4 、接口中�?/span> field 只能�?/span> public static final �Q?/span>

5 、接口本�w�可以是 public or protected �Q?/span>

6 �?/span> extended class 必须实现抽象�c�M��的所有抽象方法， implemented class 必须实现接口中的所有方法，因�ؓ接口中的所有方法都�?/span> abstract �?/span>

honzeland 2006-10-26 17:27 发表评论

honzeland — Fri, 13 Oct 2006 07:53:00 GMT

Part One: The Web Tier

Section One: Configuring Web Applications

Mapping URLs to Web Components

When a request is received by the web container it must determine which web component should handle the request. It does so by mapping the URL path contained in the request to a web application and a web component. A URL path contains the context root and an alias:

http://host:port/context_root/alias

A context root identifies a web application in a Java EE server. You specify the context root when you deploy a web module. A context root must start with a forward slash (/) and end with a string.

The alias identifies the web component that should handle a request. The alias path must start with a forward slash (/) and end with a string or a wildcard expression with an extension (for example, *.jsp). Since web containers automatically map an alias that ends with *.jsp, you do not have to specify an alias for a JSP page unless you wish to refer to the page by a name other than its file name.

Declaring Welcome Files

For example, suppose you define a welcome file welcome.html. When a client requests a URL such as host:port/webapp/directory, where directory is not mapped to a servlet or JSP page, the file host:port/webapp/directory/welcome.html is returned to the client.

If no welcome file is specified, the Application Server will use a file named index.XXX, where XXX can be html or jsp, as the default welcome file. If there is no welcome file and no file named index.XXX, the Application Server returns a directory listing.

To specify a welcome file in the web application deployment descriptor, you need to nest a welcome-file element inside a welcome-file-list element. The welcome-file element defines the JSP page to be used as the welcome page. Make sure this JSP page is actually included in your WAR file.

Setting Initialization Parameters

The web components in a web module share an object that represents their application context. You can pass initialization parameters to the context or to a web component.

To add a context parameter you need the following in the example's web.xml file:

A param-name element that specifies the context object

A param-value element that specifies the parameter to pass to the context object.

A context-param element that encloses the previous two elements.

To add a web component initialization parameter you need the following in the example's web.xml file:

A param-name element that specifies the name of the initialization parameter

A param-value element that specifies the value of the initialization parameter

An init-param element that encloses the previous two elements

Mapping Errors to Error Screens

Declaring Resource References

honzeland 2006-10-13 15:53 发表评论