coreoak@J2EE.com 每一个人都是这个世界的匆匆过客，生命的价值就在于他为社会做了多少贡献！ http://coreoak.javaeye.com UTF-8 Copyright 2003-2008, JavaEye.com http://blogs.law.harvard.edu/tech/rss JavaEye - 做最棒的软件开发交流社区 javascript innerText示例 coreoak 作者: coreoak  链接：http://coreoak.javaeye.com/blog/230795  发表时间: 2008年08月20日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

javascript innderText实例，当用户点击文字时改变显示的文字 
  <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<HTML>
 <HEAD>
  <TITLE> New Document </TITLE>
  <META NAME="Generator" CONTENT="EditPlus">
  <META NAME="Author" CONTENT="">
  <META NAME="Keywords" CONTENT="">
  <META NAME="Description" CONTENT="">
  <style>
  body {color: "blue";font-family:"宋体";font-size:"12pt" }
  </style>
  <script  type = "text/javascript">
	function changeText() {
		var text = document.getElementById("CT").innerText;		
		if (text.indexOf("你") > -1){
			CT.innerText = "我很好呀！"
		} else {
			CT.innerText = "你好吗?";
		}
	}
  </script>
 </HEAD>

 <BODY>
  <div>
	<ul>
	<li id = "CT" onclick = "changeText();">你好吗？</li>
	</ul>
  </div>
 </BODY>
</HTML>


已有 0 人发表留言，猛击->>这里<<-参与讨论


JavaEye推荐



]]> Wed, 20 Aug 2008 18:01:22 +0800 http://coreoak.javaeye.com/blog/230795 http://coreoak.javaeye.com/blog/230795 Spring MVC4 coreoak 作者: coreoak  链接：http://coreoak.javaeye.com/blog/187606  发表时间: 2008年04月28日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

9) Sample Application
9.1) Introduction

The final Section of this article details a Simple Contact Application that has provisions for Creating, Deleting and Listing Contact Objects. The aim of this Application is to show the various use of Controller Components like Abstract Controller, Abstract Command Controller and Form Controller along with Configuration Information.
9.2) The Web Descriptor File

As mentioned previously, since the Dispatcher Servlet acts as an Interceptor for the Client Request, an entry for the same has to be mentioned in the web.xml file. Follow is the code snippet for the same,

web.xml


<?xml version="1.0" encoding="UTF-8"?>
<web-app version="2.4" xmlns="http://java.sun.com/xml/ns/j2ee"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee
http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd">

<servlet>
<servlet-name>dispatcher</servlet-name>
<servlet-class>
org.springframework.web.servlet.DispatcherServlet
</servlet-class>
<load-on-startup>2</load-on-startup>
</servlet>

<servlet-mapping>
<servlet-name>dispatcher</servlet-name>
<url-pattern>*.htm</url-pattern>
</servlet-mapping>

</web-app>


9.3) Configuration File

The following represents the Configuration File for holding various piece of Configuration Information. The first thing to note is the type of Handler Mapping configured. In our case, it is the Bean Name Url Handler Mapping which means that the Url of the Client is tightly coupled with the class name of the Bean (Controller). Since all the Jsp files are maintained in the '/WEB/contacts' directory the 'prefix' property is pointing to '/WEB/contacts'.

For the Create, Delete and List operation on Contacts, three different Controller Components have been defined. They are CreateContactController, DeleteContactController and ListContactsController respectively.

dispatcher-servlet.xml


<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN"
"http://www.springframework.org/dtd/spring-beans.dtd">
<beans>

<bean id="beanNameUrlMapping" class="org.springframework.web.servlet.handler.
BeanNameUrlHandlerMapping"/>

<bean name = "/CreateContact.htm" class="net.javabeat.articles.spring.mvc.
contacts.CreateContactController">

<property name="formView">
<value>CreateContact</value>
</property>
<property name="successView">
<value>ContactCreated</value>
</property>

</bean>

<bean name = "/DeleteContact.htm" class= "net.javabeat.articles.spring.mvc.
contacts.DeleteContactController">
</bean>

<bean name = "/ListContacts.htm" class= "net.javabeat.articles.spring.mvc.
contacts.ListContactsController">
</bean>

<bean id="viewResolver" class="org.springframework.web.servlet.view.
InternalResourceViewResolver">
<property name="prefix" value="/WEB-INF/contacts/"/>
<property name="suffix" value=".jsp" />
</bean>

</beans>


9.4) CreateContact and ContactCreated Jsp Files

The following is the code for CreateContact.jsp file.

CreateContact.jsp


<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">

<title>Create a Contact</title>
</head>
<body>

<h1>Create a Contact</h1>

<form name = "CreateContact" method = "get"">
<input type = "text" name = "firstname" />
<input type = "text" name = "lastname" />
<br>
<input type="submit" name = "Create Contact" value = "Create Contact"/>
</form>

</body>
</html>


Note that since this is the page that will be shown to the user initially, in the Configuration file, the property 'formView' is pointed to 'CreateContact'. Following is the code for ContactCreated.jsp. Since this is the View that will be shown after the Form Submission the property 'successView' is made to point to 'ContactCreated'.

ContactCreated.jsp


<html>
<head>
<meta http-equiv = "Content-Type" content = "text/html; charset = UTF-8">
<title>Contact is Created</title>
</head>

<body>

<h1>Contact is successfully Created</h1>

</body>
</html>


9.5) DeleteContact.jsp

Following is the complete listing for DeleteContact.jsp file. Note that this Jsp File is mapped to DeleteContactController in the Configuration File.

DeleteContact.jsp


<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">

<title>Delete Contact</title>
</head>
<body>

<h1>Delete Contact</h1>

<form name = "DeleteContact" method = "get">
<input type = "text" name = "firstname" />
<br>
<input type="submit" name = "DeleteContact" value = "Delete Contact"/>
</form>

</body>
</html>


9.6) ListContacts.jsp

This page is to list all the existing Contacts that were created before. It should be noted that the Model Object that holds all the Contact Information in the form of List is available in the ListContactsController. The Model Information from the Controller after getting bound to the Request Scope is being taken off from the View in the form of Expression Language.

Following is the listing for ListContacts.jsp

ListContacts.jsp


<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">

<title>Showing All Contacts</title>
</head>
<body>

<h1>Showing All Contacts</h1>

<p> The following are the created Contacts </p>

<c:forEach items = "${allContacts}" var="contact">
<c:out value="${contact.firstname}"/><br>
<c:out value="${contact.lastname}"/><br>
</c:forEach>

</body>
</html>


9.7) Contacts.java

The following is the Class structure for Contacts.java for encapsulating the properties firstname and lastname.

Contact.java


package net.javabeat.articles.spring.mvc.contacts;

public class Contact {

private String firstName;
private String lastName;

public Contact() {
}

public Contact(String firstName, String lastName){
this.firstName = firstName;
this.lastName = lastName;
}

public String getFirstName() {
return firstName;
}

public void setFirstName(String firstName) {
this.firstName = firstName;
}

public String getLastName() {
return lastName;
}

public void setLastName(String lastName) {
this.lastName = lastName;
}

public int hashCode(){
return firstName.hashCode() + lastName.hashCode();
}

public boolean equals(Object object){
if (object instanceof Contact){
Contact second = (Contact)object;
return (firstName.equals(second.getFirstName()) &&
lastName.equals(second.getLastName()));
}
return false;
}

public String toString(){
return "[First Name = " + firstName + ", Last Name = " + lastName + "]";
}
}


9.8) ContactService.java

This simple service class provides functionalities for creating, deleting and listing the Contact information. All the Controller Components makes use of this class to achieve their respective functionalities.

ContactService.java


package net.javabeat.articles.spring.mvc.contacts;

import java.util.*;

public class ContactService {

private static Map contacts = new HashMap();

public ContactService() {
}

public static Contact createContact(Contact contact){
contacts.put(new Integer(contact.hashCode()), contact);
return contact;
}

public static Contact createContact(String firstName, String lastName){
return createContact(new Contact(firstName, lastName));
}

public static boolean deleteContact(String firstName){
Iterator iterator = contacts.entrySet().iterator();
while (iterator.hasNext()){
Map.Entry entry = (Map.Entry)iterator.next();
Contact contact = (Contact)entry.getValue();
if (contact.getFirstName().equals(firstName)){
contacts.remove(new Integer(contact.hashCode()));
return true;
}
}
return false;
}

public static List listContacts(){
return toList(contacts);
}

private static List toList(Map contacts){
List contactList = new ArrayList();
Iterator iterator = contacts.entrySet().iterator();
while (iterator.hasNext()){
Map.Entry entry = (Map.Entry)iterator.next();
Contact contact = (Contact)entry.getValue();
contactList.add(contact);
}
return contactList;
}
}


9.9) Controller Classes

Following is the listing for CreateContact Controller. Note that since the Model Information for creating a contact (for which the Client supplies the firstname and the lastname parameters) is the Contact class, call has been made in the Constructor to setCommandClass() by passing the class name of the Contact class.

CreateContactController.java


package net.javabeat.articles.spring.mvc.contacts;

import org.springframework.web.servlet.mvc.SimpleFormController;

public class CreateContactController extends SimpleFormController{

public CreateContactController() {
setCommandClass(Contact.class);
}

public void doSubmitAction(Object command){
Contact contact = (Contact)command;
ContactService.createContact(contact);
}
}


Note that the method doSubmitAction() doesn't return anything because the next Logical View to be displayed will be taken from the Configuration file which is represented by the property called 'successView'.

Following two classes are the Controller Components for Deleting and Listing Contacts. Note that in the case of Delete Operation, a Jsp Page (DeletedContact.jsp) containing information telling that the Contact has been Deleted will displayed. But since for the Contact Listing operation, the model information containing a Collection of Contact Objects has to be passed from the Controller to the View and the same is achieved in the 3 argument constructor to ModelAndView.

DeleteContactController.java


package net.javabeat.articles.spring.mvc.contacts;

import javax.servlet.http.*;
import org.springframework.validation.BindException;
import org.springframework.web.servlet.ModelAndView;
import org.springframework.web.servlet.mvc.AbstractCommandController;

public class DeleteContactController extends AbstractCommandController{

public DeleteContactController(){
setCommandClass(Contact.class);
}

public ModelAndView handle(HttpServletRequest request,
HttpServletResponse response, Object command, BindException errors)
throws Exception {

Contact contact = (Contact)command;
ContactService.deleteContact(contact.getFirstName());
return new ModelAndView("DeletedContact");

}
}


Here is the listing for ListContactsController.java.

ListContactsController.java


package net.javabeat.articles.spring.mvc.contacts;

import java.util.List;
import javax.servlet.http.*;
import org.springframework.web.servlet.ModelAndView;
import org.springframework.web.servlet.mvc.AbstractController;

public class ListContactsController extends AbstractController{

public ListContactsController() {
}

public ModelAndView handleRequestInternal(HttpServletRequest request,
HttpServletResponse response) throws Exception{

List allContacts = ContactService.listContacts();
return new ModelAndView("ListContacts", "allContacts", allContacts);

}
}


10) Conclusion

The Article provided a basic Introduction over the core concepts in Spring MVC for the Web Tier. Since the Spring Web Tier is built on top of the Spring Core Layer all the functionalities like Bean Lifecycle Management, Dependency Injection etc. will be automatically available to the Bean Components. Starting off with the Interactions that will take place when a Client Request for a Resource, it pointed out the various micro-level activities that take place in that Work flow. Then the Core Components of Spring like Dispatcher Servlet, Controllers, Model/View, Handler Mappings, Handler Adapters and View Resolvers are also discussed briefly. Finally the article ended up with the Simple Contact Application that demonstrated the usage of the various types of Controllers.

已有 0 人发表留言，猛击->>这里<<-参与讨论


JavaEye推荐



]]> Mon, 28 Apr 2008 16:40:10 +0800 http://coreoak.javaeye.com/blog/187606 http://coreoak.javaeye.com/blog/187606 Spring MVC3 coreoak 作者: coreoak  链接：http://coreoak.javaeye.com/blog/187600  发表时间: 2008年04月28日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

6) Controller

Controllers are components that are being called by the Dispatcher Servlet for doing any kind of Business Logic. Spring Distribution already comes with a variety of Controller Components each doing a specific purpose. All Controller Components in Spring implement the org.springframework.web.servlet.mvc.Controller interface. This section aimed to provide the commonly used Controllers in the Spring Framework. The following are the Controller Components available in the Spring Distribution.

* SimpleFormController
* AbstractController
* AbstractCommandController
* CancellableFormController
* AbstractCommandController
* MultiActionController
* ParameterizableViewController
* ServletForwardingController
* ServletWrappingController
* UrlFilenameViewController

The following section covers only on AbstractController, AbstractCommandController, SimpleFormController and CancellableFormController in detail.
6.1) Abstract Controller

If one wants to implement Custom Controller Component right from the scratch, then instead of implementing the Controller interface, extending AbstractController can be preferred as it provides the basic support for the GET and the POST methods. It is advised that only for simple purpose, this type of extensions should be used. The purpose may be as simple as returning a resource to the Client upon request without having the need to examine the Request Parameters or other Stuffs. For example, consider the following piece of code,

MySimpleController.java


public class MySimpleController extends AbstractController{

public void handleRequestInternal(HttpServletRequest request,
HttpServletResponse response){

return new ModelAndView("myView");

}
}


Note that the Dispatcher Servlet will call the handleRequest() method by passing the Request and the Response parameters. The implementation just returns a ModelAndView (discussed later) object with myView being the logical view name. There are Components called View Resolvers whose job is to provide a mapping between the Logical View Name and the actual Physical Location of the View Resource. For the time being, assume that somehow, myView is mapped to myView.jsp. So, whenever the Dispatcher Servlet invokes this MySimpleController object, finally myView.jsp will be rendered back to the Client.
6.2) Abstract Command Controller

The concept of Command Controller comes into picture when the Business Logic depends upon the values that are submitted by the User. Instead of depending on the Servlet Api to get the Request Parameter Values and other session Objects, we can depend on this Abstract Command Controller to take those pieces of Information. For example consider the following code snippet which has a simple business logic telling that, depending on the existence of username, display the form success.jsp or failure.jsp

MySimpleController.java


public class MySimpleController extends AbstractCommandController{

public MySimpleController(){
setCommandClass(UserInfo.class);
}

public void handle(HttpServletRequest request, HttpServletResponse response,
Object command){

UserInfo userInfo = (UserInfo)command;
if ( exists(userInfo.getUserName){
return new ModelAndView("success");
}else{
return new ModelAndView("failure");
}
}

private boolean exits(String username){
// Some logic here.
}
}


Note that the Client Parameters (username , in this case) is encapsulated in a simple Class called UserInfo which is given below. The value given by the Client for the username field will be directly mapped to the property called username in the UserInfo. In the Constructor of the MySimpleController class, we have mentioned the name of the Command Class which is going to hold the Client Request Parameters by calling the setCommandClass() method. Also note that in the case of Command Controller, the method that will be called by the Dispatcher Servlet will be handle() which is passed with the Command object apart from the Request and the Response objects.

UserInfo.java


public class UserInfo{

private String username;
// Getters and Setters here.

}


6.3) Simple Form Controller

Asking the User to fill in a Form containing various information and submitting the form normally happens in almost every Web Application. The Simple Form Controller is exactly used for that purpose. Let us give a simple example to illustrate this. Assume that upon Client Request a page called empInfo.jsp is rendered to the client containing empName, empAge and empSalary fields. Upon successful completion a Jsp Page called empSuccess.jsp is displayed back to the Client. Now let us see how we can make use of the Simple Form Controller to achieve this kind functionality.

The very first thing is that, to collect the Client Input Values, a Command object which contains getter and setters must be defined. Following the skeleton of the class called EmpInfo.

EmpInfo.java


public class EmpInfo{

private String empName;
private int empAge;
private double empSalary;

// Getters and setters for the above properties.

}


The next thing is to write a class that extends SimpleFormController. But this time, the doSubmitAction() method should be overridden. This is the method that will be called when the Client submits the form. Following is the definition of the Controller class.

EmpFormController.java


public class EmpFormController extends SimpleFormController{

public EmpFormController(){
setCommandClass(EmpInfo.class);
}

public void doSubmitAction(Object command){
EmpInfo info = (EmpInfo)command;
process(info);
}

private void process(EmpInfo info){
//Do some processing with this object.
}
}


As we mentioned previously, the form that collects information from the Client is empInfo.jsp and upon successful submission the view empSuccess.jsp should be displayed. This information is externalized from the Controller class and it is maintained in the Configuration File like the following,


<bean id = "empForm" class="EmpFormController">

<property name="formView">
<value>empInfo</value>
</property>

<property name="successView">
<value>empSuccess</value>
</property>

</bean>


Note the two property names 'formView' and 'successView' along with the values 'empInfo' and 'empSuccess'. These properties represent the initial View to be displayed and the final view (after successful Form submission) to be rendered to the Client.
6.4) Cancellable FormController

If you carefully notice with the implementation of Simple Form Controller, there are ways to provide the Initial and the Successful View to the Clients. But what happens when the Form is cancelled by the User? Who will process the Cancel operation of the Form?

The above issues can be given immediate solution with the usage of Cancellable FormController. The good thing is that Cancellable FormController extends SimpleForm Controller so that all the functionalities are visible to this Controller also. Suppose say that the User clicks the cancel button, the Framework will check in the Request parameter for a key with name 'cancelParamKey'. If it is so, then it will call the onCancel() method. Consider the following definition,

MyCompleteFormController.java


public class MyCompleteFormController extends CancellableFormController{

public ModelAndView onCancel(){
return new ModelAndView("cancelView");
}
}


7) Model And View

Model and View (represented by the class org.springframework.web.servlet.ModelAndView) is returned by the Controller object back to the Dispatcher Servlet. This class is just a Container class for holding the Model and the View information. The Mode object represents some piece of information that can be used by the View to display the information. Both these Objects are given high degree of abstraction in the Spring Framework.

Any kind of View Technology (org.springframework.web.servlet.View) can be plugged into the Framework with ease. For example, Excel, Jasper Reports, Pdf, Xslt, Free Marker, Html, Tiles, Velocity etc. are the supported Frameworks as of now. The Model object (represented by org.springframework.ui.ModelMap) is internally maintained as a Map for storing the Information.

Following are the ways to Construct the Model and the View object.


View pdfView = �;
Map modelData = new HashMap();

ModelAndView mv1 = new ModelAndView(pdfView, modelData);


The above constructs a ModelAndView object by passing the actual View object along with the Model object. Now consider the following code,


ModelAndView mv1 = new ModelAndView("myView", someData);


Note, in the above example, a string with "myView" is passed for the View. This way of specifying a View is called a Logical View. It means that myView either can point to something called myView.jsp or myView.pdf or myView.xml. The Physical View Location corresponding to the Logical View can be made configurable in the Configuration File.
8) View Resolver

In the previous section, we talked about Logical View and the Physical View Location for the Logical View. The mapping between the Logical name and the Physical View Location is taken care by the View Resolver object. Without any surprise, Spring comes with a set of Built-In Spring Resolvers. It is even possible to write Custom View Resolvers by implementing the org.springframework.web.servlet.ViewResolver interface. Following are the available View Resolvers in the Spring Distribution.

* BeanNameViewResolver
* FreeMarkerViewResolver
* InternalResourceViewResolver
* JasperReportsViewResolver
* ResourceBundleViewResolver
* UrlBasedViewResolver
* VelocityLayoutViewResolver
* VelocityViewResolver
* XmlViewResolver
* XsltViewResolver

The following section concentrates only on Internal Resource View Resolver and Bean Name View Resolver in detail.
8.1) Internal Resource View Resolver

The Internal Resource View Resolver will try to map the Logical name of the Resource as returned by the Controller object in the form of ModelAndView object to the Physical View location. For example, consider the following class definition which returns different ModelAndView objects.

MyController.java


public class MyController {

public void handle(){
if(condition1()){
return new ModelAndView("myView1");
}else if (condition2()){
return new ModelAndView("myView2");
}
return new ModelAndView("myView3");
}
}


Assume that if the Client Request satisfies condition1(), then the view myView.jsp which is present in the /WEB-INF folder should be displayed and for the client Requests satisfying condition2() and the other one, myView2.jsp and myView3.jsp should be displayed.

For this to happen, the following entry must be made in the Configuration File,


<bean id="viewResolver" class="org.springframework.web.servlet.view.
InternalResourceViewResolver">

<property name="prefix"><value>/WEB-INF/</value></property>
<property name="suffix"><value>.jsp</value></property>

</bean>


This is how the Internal Resource View Resolver will map the Logical View Name to the physical Location. When the logical View name is myView1, then it will construct a view name which is the summation of the prefix + the logical View Name + the suffix, which is going to be /WEB-INF/myView.jsp. The same is the case for myView2.jsp and myView3.jsp.
8.2) Bean Name View Resolver

One of the dis-advantage of using Internal Resource View Resolver is that the name of the View file (whether it is a Jsp File or the Pdf File) must be present in the Web Application Context. Dynamically generated View files may not be possible. In such a case, we may use the Bean Name View Resolver which will dynamically generate View in Pdf or Excel Formats.

For the example, if the ModelAndView object represents a View by name "pdf" as shown in the following snippet,


return ModelAndView("pdf")


And, if we want to generate the Pdf file, then we should have defined the Configuration information in the file as follows,


<bean id="beanNameResolver"
class="org.springframework.web.servlet.view.BeanNameViewResolver"/>


The above code configures the Framework to use BeanNameViewResolver. Since the logical name 'pdf' must resolve to a Bean Name, we should define a similar entry like the following in the Configuration File. Note that, in the following MyPdfGenerator may be the sub-class of org.springframework.web.servlet.view.document.AbstractPdfView for generating the Pdf File.


<bean id = " pdf " class = "MyPdfGenerator"/>

已有 0 人发表留言，猛击->>这里<<-参与讨论


JavaEye推荐



]]> Mon, 28 Apr 2008 16:18:24 +0800 http://coreoak.javaeye.com/blog/187600 http://coreoak.javaeye.com/blog/187600 Spring MVC2 coreoak 作者: coreoak  链接：http://coreoak.javaeye.com/blog/187599  发表时间: 2008年04月28日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

4) Handler Mappings

When the Client Request reaches the Dispatcher Servlet, the Dispatcher Servlet tries to find the appropriate Handler Mapping Object to map between the Request and the Handling Object. A Handler Mapping provides an abstract way that tell how the Client's Url has to be mapped to the Handlers. Four concrete variation of Handler Mapping are available. They are defined as follows

* BeanNameUrl HandlerMapping
* CommonsPathMap HandlerMapping
* ControllerClassName HandlerMapping
* SimpleUrl HandlerMapping

All the above Handler Mapping objects are represented as BeanNameUrlHandlerMapping, CommonsPathMapHandlerMapping, ControllerClassNameHandlerMapping and SimpleUrlHandlerMapping in the org.springframework.web.servlet package respectively. Let us see the functionalities and the differences in usage one by one.
4.1) BeanNameUrl HandlerMapping

This is the simplest of the Handler Mapping and it is used to map the Url that comes from the Clients directly to the Bean Object. In the later section, we will see that the Bean is nothing but a Controller object. For example, consider that the following are the valid Url in a Web Application that a Client Application can request for.


http://myserver.com/eMail/showAllMails
http://myserver.com/eMail/composeMail
http://myserver.com/eMail/deleteMail


Note that the Url (excluding the Application Context) in the above cases are 'showAllMails', 'composeMail' and 'deleteMail'. This means that the Framework will look for Bean Definitions with Identifiers 'showAllMails', 'composeMail' and 'deleteMail'. Consider the following Xml code snippet in the Configuration file,


<beans>

<bean name="/showAllMails.jsp"
class="com.javabeat.net.ShowAllMailsController">
</bean>

<bean name="/composeMail.jsp"
class="com.javabeat.net.ComposeMailController">
</bean>

<bean name="/ deleteMail.jsp"
class="com.javabeat.net.DeleteMailController">
</bean>

</beans>


So, in BeanNameUrl Handler Mapping, the Url of the Client is directly mapped to the Controller. To enable this kind of Handler Mapping in the Application, the Configuration file should have a similar kind of definition like the following,


<beans>

�
<bean id="beanNameUrl"
class="org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping"/>
�

</beans>


4.2) CommonsPathMap HandlerMapping

This is a rarely used Handler Mapping in which case, the name of the Url to which the Controller has to be mapped is specified directly in the Source file of the Controller. Considering the previous example, if we want to map 'showAllMails', 'composeMail' and 'deleteMail' to Controllers namely ShowAllMailsController, ComposeMailController and DeleteMailController, then the mapping information must be specified in the form of meta-data in the source files inside the Javadoc comments. Consider the following Controller Definitions,


/**
*@@ org.springframework.web.servlet.handler.commonsattributes.
*PathMap("/showAllMails.jsp")
*/
public class ShowAllMailsController{
}

/**
*@@ org.springframework.web.servlet.handler.commonsattributes.
*PathMap("/composeMail.jsp")
*/
public class ComposeMailController{
}

/**
*@@ org.springframework.web.servlet.handler.commonsattributes.
*PathMap("/deleteMail.jsp")
*/
public class DeleteMailController {
}


The attribute must point to org.springframework.web.servlet.handler.commonsattributes.PathMap. By defining Controllers in this way, one more additional compilation step is needed. That is to make the availability of this attribute in the Class files, this Java Source has to be compiled with the Commons Attribute Compiler which comes along with the Spring Distribution. As before, to enable this kind of mapping , the Configuration File should have an entry similar to this,


<beans>

<bean id="metaHandlerMapping" class="org.springframework.web.servlet.handler.
metadata.CommonsPathMapHandlerMapping"/>

</beans>


4.3) ControllerClassName HandlerMapping

In this kind of Handler Mapping, the name of the Controller is taking directly from the Url itself with slight modifications. For example, let us assume that the Client request ends with Url as shown below,


http://myserver.com/emailApp/showInbox.jsp
http://myserver.com/emailApp/showDeletedItems.jsp


And as such, we have a Controller definition by name ShowController as follows,

ShowController.java


public class ShowController{
}


Also the Configuration file is made to activate this kind of Handler Mapping by making the following definition,


<beans>

<bean id="controllerClassName" class="org.springframework.web.servlet.handler.
metadata.ControllerClassNameHandlerMapping"/>

</beans>


The first thing the Framework does it, it will traverse through the List of Controllers defined in the Configuration File and perform these actions. For the Controller ShowController, then Framework will remove the Controller String and then lowercase the first letter. In our case the string now becomes show. Now whatever Client Request matches the pattern /show*, then the ShowController will be invoked.
4.4) SimpleUrl HandlerMapping

This is the Simplest of all the Handler Mappings as it directly maps the Client Request to some Controller object. Consider the following Configuration File,


<bean id="simpleUrlMapping"
class="org.springframework.web.servlet.handler.SimpleUrlHandlerMapping">

<property name="mappings">
<props>
<prop key="/showAllMails.jsp">showController</prop>
<prop key="/composeMail.jsp">composeController</prop>
<prop key="/deleteMail.jsp">deleteController</prop>
</props>
</property>

</bean>


The set of mappings is encapsulated in the 'property' tag with each defined in a 'prop' element with the 'key' attribute being the Url, the value being the Identifier of the Controller Objects. Note that the Beans for the above Identifiers should be defined somewhere in the Configuration File.
5) Handler Adapters

It is important to understand that the Spring Framework is so flexible enough to define what Components should be delegated the Request once the Dispatcher Servlet finds the appropriate Handler Mapping. This is achieved in the form of Handler Adapters. If you remember in the Spring Work flow section, that it is mentioned once the Dispatcher Servlet chooses the appropriate Handler Mapping, the Request is then forwarded to the Controller object that is defined in the Configuration File. This is the default case. And this so happens because the Default Handler Adapter is Simple Controller Handler Adapter (represented by org.springframework.web.servlet.SimpleControllerHandlerAdapter), which will do the job of the Forwarding the Request from the Dispatcher to the Controller object.

Other types of Handler Adapters are Throwaway Controller HandlerAdapter (org.springframework.web.servlet.ThrowawayControllerHandlerAdapter) and SimpleServlet HandlerAdapter (org.springframework.web.servlet.SimpleServletHandlerAdapter). The Throwaway Controller HandlerAdapter, for example, carries the Request from the Dispatcher Servlet to the Throwaway Controller (discussed later in the section on Controllers) and Simple Servlet Handler Adapter will carry forward the Request from the Dispatcher Servlet to a Servlet thereby making the Servlet.service() method to be invoked.

If, for example, you don't want the default Simple Controller Handler Adapter, then you have to redefine the Configuration file with the similar kind of information as shown below,


<bean id="throwawayHandler" class = "org.springframework.web.servlet.mvc.throwaway.
ThrowawayControllerHandlerAdapter"/>


or


<bean id="throwawayHandler" class="org.springframework.web.servlet.mvc.throwaway.
SimpleServletHandlerAdapter"/>


Even, it is possible to write a Custom Handler Adapter by implementing the HandlerAdapter interface available in the org.springframework.web.servlet package.

已有 0 人发表留言，猛击->>这里<<-参与讨论


JavaEye推荐



]]> Mon, 28 Apr 2008 16:17:19 +0800 http://coreoak.javaeye.com/blog/187599 http://coreoak.javaeye.com/blog/187599 spring MVC coreoak 作者: coreoak  链接：http://coreoak.javaeye.com/blog/187598  发表时间: 2008年04月28日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！

Introduction to Spring MVC Web Framework - Web Tier
1) Introduction

The Spring MVC provides rich functionality for building robust Web Applications and it is available as a separate module in the Distribution. As a pre-requisite, readers are advised to go through the introductory article on Spring Framework http://spring.javabeat.net/articles/2007/06/introduction-spring-web-framework. The Spring MVC Framework is architected and designed in such a way that every piece of logic and functionality is highly configurable. Also Spring can integrate effortlessly with other popular Web Frameworks like Struts, WebWork, Java Server Faces and Tapestry. It means that you can even instruct Spring to use any one of the Web Frameworks. More than that Spring is not tightly coupled with Servlets or Jsp to render the View to the Clients. Integration with other View technologies like Velocity, Freemarker, Excel or Pdf is also possible now. This article provides an introduction over the various components that are available in the Spring MVC for the Web Tier. Specifically the major Core Components like Dispatcher Servlet, Handler Mappings, Controller, Model, View and View Resolver along with the appropriate Api are discussed briefly. Finally the article will conclude by presenting a Sample Application.

* Page 1 - Introduction to Spring MVC Web Framework - Web Tier
* Page 2 - Handler Mappings
* Page 3 - Model,View,Controller,View Resolver
* Page - 4 Sample Application

2) The Spring Workflow

Before taking a look over the various Components that are involved in the Spring MVC Framework, let us have a look on the style of Spring Web Flow.

1. The Client requests for a Resource in the Web Application.
2. The Spring Front Controller, which is implemented as a Servlet, will intercept the Request and then will try to find out the appropriate Handler Mappings.
3. The Handle Mappings is used to map a request from the Client to its Controller object by browsing over the various Controllers defined in the Configuration file.
4. With the help of Handler Adapters, the Dispatcher Servlet will dispatch the Request to the Controller.
5. The Controller processes the Client Request and returns the Model and the View in the form of ModelAndView object back to the Front Controller.
6. The Front Controller then tries to resolve the actual View (which may be Jsp, Velocity or Free marker) by consulting the View Resolver object.
7. Then the selected View is rendered back to the Client.

Let us look into the various Core Components that make up the Spring Web Tier. Following are the components covered in the next subsequent sections.
3) Dispatcher Servlet

The Dispatcher Servlet as represented by org.springframework.web.servlet.DispatcherServlet, follows the Front Controller Design Pattern for handling Client Requests. It means that whatever Url comes from the Client, this Servlet will intercept the Client Request before passing the Request Object to the Controller. The Web Configuration file should be given definition in such a way that this Dispatcher Servlet should be invoked for Client Requests.

Following is the definition given in the web.xml to invoke Spring's Dispatcher Servlet.

web.xml


<?xml version="1.0" encoding="UTF-8"?>
<web-app version="2.4">

<servlet>
<servlet-name>dispatcher</servlet-name>
<servlet-class>
org.springframework.web.servlet.DispatcherServlet
</servlet-class>
<load-on-startup>2</load-on-startup>
</servlet>

<servlet-mapping>
<servlet-name>dispatcher</servlet-name>
<url-pattern>*.*</url-pattern>
</servlet-mapping>

</web-app>


Look into the definition of servlet-mapping tag. It tells that whatever be the Client Request (represented by *.* meaning any Url with any extension), invoke the Servlet by name 'dispatcher'. In our case, the 'dispatcher' servlet is nothing but an instance of type 'org.springframework.web.servlet.DispatcherServlet'.

Closing associated term with the Dispatcher Servlet is the Application Context. An Application Context usually represents a set of Configuration Files that are used to provide Configuration Information to the Application. The Application Context is a Xml file that contain various Bean Definitions. By default the Dispatcher Servlet will try to look for a file by name <servlet-name>-servlet.xml in the WEB-INF directory. So, in our case the Servlet will look for a file name called dispatcher-servlet.xml file in the WEB-INF directory.

It is wise sometimes to split all the Configuration information across multiple Configuration Files. In such a case we have to depend on a Listener Servlet called Context Loader represented by org.springframework.web.context.ContextLoaderListener.


<web-app>

<listener>
<listener-class>
org.springframework.web.context.ContextLoaderListener
</listener-class>
</listener>

</web-app>


By default, this Context Listener will try to look for the Configuration File by name 'applicationContext.xml' in the '/WEB-INF' directory. But with the help of the parameter 'contextConfigLocation' the default location can be overridden. Even multiple Configuration Files each containing separate piece of Information is also possible.

web.xml


<?xml version="1.0" encoding="UTF-8"?>
<web-app version="2.4">

<listener>
<listener-class>
org.springframework.web.context.ContextLoaderListener
</listener-class>
</listener>

<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>/WEB-INF/contacts.xml, /WEB-INF/resources.xml</param-value>
</context-param>

</web-app>


The above definition instructs the Framework to look and load for the Configuration Files by name 'contacts.xml' and 'resources.xml' in the WEB-INF directory.

已有 1 人发表留言，猛击->>这里<<-参与讨论


JavaEye推荐



]]> Mon, 28 Apr 2008 16:15:38 +0800 http://coreoak.javaeye.com/blog/187598 http://coreoak.javaeye.com/blog/187598 PHP程序设计翻译1--简单的变量和操作符 coreoak 作者: coreoak  链接：http://coreoak.javaeye.com/blog/176575  发表时间: 2008年03月27日

声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！ 

 一旦你安装和运行你自己的PHP编程，你会发现你编写的大多数的脚本是变数，操作员并且你经常用的就是10个函数。 

在这一章中我们探讨不同类型的变量在PHP中如何使用，以及他们之间的如何转换，我们也将讨论操作符，这些操作符有对变量的加、减、乘等的功能。 

这一章将告诉你PHP的变量是如何工作的，你不需要了解相当复杂的部分，比如references 以及可变变量，除非你想真正理解PHP。 

本章的主要内容包括： 



(1)PHP中你可以用到什么样的数据 

(2)References，类型转换，可变变量 

(3)脚本变量，预定义变量，脚本常量，预定义的常量 

(4)操作符，比如说加、减、乘、除 

2.1：数据类型 

2.2检查一个变量是否被设置 

2.3自动类型转换 

2.4强制类型转化 

2.5非十进制系统 

2.6变量作用域 

2.7可变变量 

2.8The superglobal arrays 

2.9 预定义变量 

2.10 References 

2.11 常量 

2.11.1 预定义常量 

2.12 操作符 

2.12.1. Shorthand unary operators 

2.12.2. 比较操作符 

2.12.3. 完整操作符 

2.12.4. 三元操作符 

2.12.5. Scope resolution operator 

2.12.6. Execution operator 

2.12.7. 运算符优先级 



2.1：数据类型 

PHP有7种类型的变量，他们是strings, integers, floats, booleans, arrays, objects, and resources.你将要在本书中一直用到他们，因此在这里我们有必要记住他们。 

String类型是字符串类型，如"a","abc","Jack and Jill went up the hill to fetch a pail of water",etc, String 可以很短也可以随便长，String类型没有长度的限制。 



Integer 整形变量，正数或者负数，比如1,-20,55028932,etc，最小值 

-2147483647 最大值是2147483647，如果数字大于2147483647 则将会将数字自动转化成foloat类型。 



浮点数（也叫浮点数，双精度数或实数）可以用以下任何语法定义： 

<?php 
$a = 1.234; 
$a = 1.2e3; 
$a = 7E-10; 
?> 





boolean类型 只有 TRUE 或 FALSE。 boolean类型将0看作是false其它的任何数据都是true
          


          
            已有 0 人发表留言，猛击->>这里<<-参与讨论
          
          



          JavaEye推荐
          

          
          



          ]]>
        
        Thu, 27 Mar 2008 00:11:58 +0800
        http://coreoak.javaeye.com/blog/176575
        http://coreoak.javaeye.com/blog/176575
      
      
        PHP在线书籍整理
        coreoak
        
          
          作者: coreoak 
          链接：http://coreoak.javaeye.com/blog/174733 
          发表时间: 2008年03月22日
          


          声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！
          


          http://hudzilla.org/phpwiki/index.php?title=Table_of_Contents
          


          
            已有 0 人发表留言，猛击->>这里<<-参与讨论
          
          



          JavaEye推荐
          

          
          



          ]]>
        
        Sat, 22 Mar 2008 03:01:29 +0800
        http://coreoak.javaeye.com/blog/174733
        http://coreoak.javaeye.com/blog/174733
      
      
        HyperSnap基本用法 
        coreoak
        
          
          作者: coreoak 
          链接：http://coreoak.javaeye.com/blog/174732 
          发表时间: 2008年03月22日
          


          声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！
          


          作为抓图软件领域的老牌明星，HyperSnap-DX提供了专业级的影像效果，可让你轻松抓取屏幕，它支持抓取使用DirectX技术的游戏及DVD画面，并采用了新的去背景功能，你可以轻松去除抓取后的图形背景，Hpersnap-Dx还拥有许多抓图特色，是很多朋友喜爱的一款抓图工具。 



HyperSnap-DX启动后，除了常用工具按钮外，左边的那些按钮主要是用来作图的，在"捕捉"菜单中提供了它的主要抓取对象和热键，默认的热键分别为：全屏幕——"Ctrl+Shift+F"；窗口或控件(比如工具条/滚动条)——"Ctrl+ Shift+W"；按钮(包括命令按钮和工具栏上的各个按钮)——"Ctrl+Shift+B"；活动窗口——"Ctrl+Shift+A"；不带边框的活动窗口(使抓取的对象不包含边框)——"Ctrl+Shift+C"；选区(由用户指定要抓取的任意方形区域)——"Ctrl+Shift+R"；多区域捕捉——"Ctrl+Shift+M"。 



下面介绍几个常用且重要的操作： 



1.抓取全屏幕：按下热键"Ctrl+Shift+F"，或者用鼠标点击"捕捉"下的"全屏幕"菜单项，之后你会听到类似照相的"咔嚓"声，操作成功。 



2.抓取活动窗口：首先使要抓取的窗口成为活动窗口，然后按下热键"Ctrl+ Shift+A"。 



3.抓取下拉菜单：当你需要抓取某个窗口中的下拉菜单时，有多种方法可以实现：先让HyperSnap-DX最小化到任务栏上，再点击要抓取的菜单使之展开，然后按下热键"Ctrl+Shist+R"，屏幕上将出现一个十字形光标，移动此光标到起始位置用鼠标左键点击，再移动到菜单右下方再次点击；或者当菜单出现后直接按下窗口抓取热键"Ctrl+Shift+W"，你会看到一个闪动的矩形框，点击左键即可抓取该菜单；如果希望抓取多级子菜单中的某一级，应依次打开该级联菜单，按下热键"Ctrl+Shift+W"，当矩形框闪动时移动到希望抓取的子菜单上点击左键；如希望抓取级联菜单的全部，则要用到其"多区域捕捉"功能，按下热键"Ctrl+Shift+M"，当屏幕上出现闪动矩形框时点击左键增加要抓取的区域，以便让各级菜单都被选中(选中的区域会用黑色覆盖)，然后按下回车键完成抓取。 



4.多区域抓图：上面介绍的抓取级联菜单仅仅是多区域抓图的一个简单应用，实际上这个功能相当强大，你可以将它和"Region Capture"(区域抓图)结合使用以完成更复杂的抓取任务。例如：要在资源管理器中同时抓取某个文件(夹)的右键快捷菜单和该文件(夹)的图标，可以这样操作：首先用鼠标右键点击该文件(夹)弹出其快捷菜单，然后按下抓取热键"Ctrl+Shift+M"，点取菜单区域使它被选中，再按下鼠标右键不放手，会马上出现一个子菜单，从中点击"重启区域方式"后放开，此时出现十字形光标，用该光标点击文件图标的左上角和右下角各一次，使文件图标被选中(原来选中的菜单仍处于选中状态)，最后按下回车键完成抓取。 



在上述抓取过程中，只要还没有完成抓取，随时可按下ESC键放弃当前操作。 



5.抓取对话框中的按钮：如果希望抓取某个对话框中的命令按钮，当对话框出现后，把光标移到要抓取的按钮上，然后按下热键"Ctrl+Shift+B"，便会看到这个按钮被自动"按"了一下，抓取完成。 



6.抓取游戏画面：如需要抓取游戏的一连串画面，并且不希望中断游戏并对所抓取的图像进行命名等操作，则要使用HyperSnap-DX的特殊捕捉功能，还要设置让HyperSnap-DX自动保存。 



1)首先设置其"特殊捕捉"：在"Capture"(捕捉)菜单下点击"Directx/Glide"(使用特殊捕捉)，在设置窗口中选中其提供的三种捕捉类型之一，如果不能确定到底使用的是哪一种，则最好三个一并选上，其他选项取默认值，最后点击确定。 



2)设置自动保存：在"Capture Settings"(捕捉设置)对话框中点击"Quick save"(快速保存)选项，选上"Automatically save each capture to a file"(自动保存捕捉后的文件)；如果不想使用其默认的保存文件名，点击"Change"按钮定位一个保存位置，然后在该按钮左边的文本框中输入文件名的前缀字母，并输入名称的起始/终止数字(如输入前缀为pic，范围值定为1到100，则抓取后会自动生成pic1、pic2......pic100等文件)。 



关闭捕捉设置对话框后进入游戏，当出现需要的画面时按下抓取热键"Scroll Lock"或"Print Screen"键(注意不要误认为是全屏幕游戏画面就用"Ctrl+Shift+F")，图像会自动被捕捉并依次保存下来。 



退出游戏后，在HyperSnap-DX窗口中会看到抓取到的最后一幅图像，你可以按PageDown和PageUp键来回翻动，逐个查看所有抓取到的画面。 



7.抓取VCD/DVD电影画面：能否顺利捕捉VCD/DVD电影画面取决于你所使用的播放器是否支持DirectX(最好使用PowerDVD，不过经笔者验证也可以用"豪杰超级解霸"和"Windows Media Player 8.0"，HyperSnap-DX都可以正常抓取)，其次同样需要设置并启动特殊捕捉功能，然后用VCD/DVD播放软件播放电影，当出现需要捕捉的画面时(注意让电影画面出现在前台)，按下"Scroll Lock"键或"Print Screen "抓取。 



如果在抓取时出现"Unsupported Pixel Format"(不支持的像素格式)的提示，这表明HyperSnap-DX无法从DirectX覆盖缓冲区中对图像解码，你可以找找看播放软件中是否有"Hardware Acceleration"(启用硬件加速)或"Optimized Video"(视频优化)等选项，如有则取消它，然后重新抓取图像。如果还不能抓取，建议你换用其他的播放软件。 



8.抓取超长网页窗口：如果要抓取超过屏幕的超长网页(即要拖动滚动条才能查看所有内容的网页)，可以使用Hypersnap-Dx的抓取"扩展活动窗口"功能来完成：启动Hypersnap-Dx，切换到网页画面，按下热键"Ctrl+Shift+X"，会提示你输入要扩展的高度和宽度(单位为像素)，其高度和宽度可以大于整个屏幕尺寸，然后按下确定，稍等片刻(等待时间长短取决于输入的高度和宽度)就会将超长网页抓取下来。 



注：也可使用Snagit来抓取：在Snagit中选择"Image Capture"，单击"Input→Advanced→Custom Scroll"以启动其卷动抓取功能，切换到网页窗口中，按下抓取热键"Ctrl+Shift+P"，出现类似区域抓图时的手形光标，移动此光标到左上角，然后拖动到垂直滚动条底端的下拉按钮处放开左键，此时光标变成手指向上且旁边出现向下三角形，单击左键即可滚动当前网页直至窗口底部(注意：一定要到滚动条的下拉按钮处单击)。这样就将超长网页抓取成一个图片。 



9.隐藏HyperSnap-DX窗口：你可以让HyperSnap-DX在抓图时彻底隐藏，甚至让它看起来好像是Windows的一部分而非单独的程序，也可以设置让它把每一次抓取的内容自动放入剪贴板而不只是放在它自己的窗口中，设置方法如下：单击"捕捉"下的"Capture settings" (捕捉设置)菜单项，在对话框中点击"Capture settings"选项卡，去掉"Restore HyperSnap-DX window to front after capture"(完成捕捉后恢复HyperSnap-DX窗口至最前面)前面的对钩，这样抓图完毕就不会看到HyperSnap-DX的窗口了；再点击"复制和打印"选项卡，勾选上"复制每次抓取的图像到剪贴板"(此项不选则不会自动放入剪贴板，这样便不能直接在其他程序中粘贴)，以上两项组合使用后，用HyperSnap-DX所抓取的图像便自动存入剪贴板；如果选中下面的"将每次捕捉的图像粘贴"并指定一个程序，则以后每次抓取的图像便被自动放入该窗口中——这对经常写软件介绍方面稿子的朋友很有用，比如，你可以指定自动粘贴到Word中，这样就不用来回切换抓图窗口和Word窗口了。 



记不住抓取热键又不想打开HyperSnap-DX窗口怎么办？别担心，用右键点击它在任务栏上的图标，弹出的菜单中会给你提示。
          


          
            已有 0 人发表留言，猛击->>这里<<-参与讨论
          
          



          JavaEye推荐
          

          
          



          ]]>
        
        Sat, 22 Mar 2008 02:59:19 +0800
        http://coreoak.javaeye.com/blog/174732
        http://coreoak.javaeye.com/blog/174732
      
      
        感悟城市的发展
        coreoak
        
          
          作者: coreoak 
          链接：http://coreoak.javaeye.com/blog/170954 
          发表时间: 2008年03月13日
          


          声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！
          


          在一个城市生活久了， 就或多或少的感受一点这个城市的一种文化，接触到这个城市的一些人民，同时也了解他们的一些思想，不知不觉中就有这样的感触，每一个经济高速发展的城市，都忽略了一个问题，那就是物质文明和精神文明建设没有一起抓，往往我们只是抓住了物质文明建设但是缺少了精神文明建设，没有做到两手抓两手都要硬。因此在经济高速发展的过程中就会有一段时间是人们心理出现病态的时期，这些病态的心理并没有被人们所认识，往往认识到的人就会被打入冷宫，显得好像跟这个城市格格不入！
          


          
            已有 0 人发表留言，猛击->>这里<<-参与讨论
          
          



          JavaEye推荐
          

          
          



          ]]>
        
        Thu, 13 Mar 2008 20:48:24 +0800
        http://coreoak.javaeye.com/blog/170954
        http://coreoak.javaeye.com/blog/170954
      
      
        做人的实话
        coreoak
        
          
          作者: coreoak 
          链接：http://coreoak.javaeye.com/blog/141434 
          发表时间: 2007年11月17日
          


          声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！
          


          

做人的几大实话

1.遇到乞讨者：遇到要钱的就给他(她)点饭，遇到要饭的就给他(她)点钱。

2.上车遇到老弱病残、孕妇：让座的时候别动声色，也别大张旗鼓。站起来用身体挡住其他人留出空位子给需要的人，然后装作下车走远点。人太多实在走不远，人家向你表示谢意的时候微笑一下。

3.雨雪的时候、天冷的傍晚或者是雪天的傍晚，遇到卖菜的、卖水果的、卖报纸的剩的不多了又不能回家，能全买就全买，不能全买就买一份，反正吃什么也是吃，看什么也是看，买下来让人早点回家。

4.遇到迷路的小孩和老头老太太，能送回家送回家，不能送回家的送上车、送到派出所也行，如果有电话的替老人或小孩打个电话就走，反正你也不缺那两个电话费。

5.遇到迷路的人打听某个地址，碰巧你又知道，就主动告诉一声。别不好意思，没有人笑话你。　6.捡到钱包就找找失主，如果你实在缺钱就把现金留下。打电话告诉失主就说你在厕所里捡到的。把信用卡、身份证、驾驶执照还给人家，一般人家也不会在乎钱了。把人家的地址记在你的笔记本上，以后发达了去找人家道个谦，把钱还给人家。

7.遇到学生出来打工的、勤工俭学的，特别是中学生、小姑娘。她卖什么你就买点，他发传单，你就收下，如果她不是家庭困难，出来打工也需要勇气的，鼓励鼓励她吧。

8.遇到夜里摆地摊的，能买就多买一些，别还价，东西都不贵。家境哪怕好一点，谁会大冷天夜里摆地摊。

9.如果钱还宽裕，别养二奶，偷偷养几个贫困山区的学生。别让人家知道你是谁，要不然见面了多尴尬，多不好意思。但是你心里一定会觉得舒坦，比包二奶提心吊胆的要好得多。如果真想包也可以包一个，好事坏事一起做。人吗，本来就复杂。
          


          
            已有 0 人发表留言，猛击->>这里<<-参与讨论
          
          



          JavaEye推荐
          

          
          



          ]]>
        
        Sat, 17 Nov 2007 23:11:34 +0800
        http://coreoak.javaeye.com/blog/141434
        http://coreoak.javaeye.com/blog/141434
      
      
        HTML学习教程
        coreoak
        
          
          作者: coreoak 
          链接：http://coreoak.javaeye.com/blog/141377 
          发表时间: 2007年11月17日
          


          声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！
          


          帮朋友整理的W3C上中文html学习教程，个人认为是比较好的html入门资料， 如果有需要的朋友一起分享一下
          


          
            已有 1 人发表留言，猛击->>这里<<-参与讨论
          
          



          JavaEye推荐
          

          
          



          ]]>
        
        Sat, 17 Nov 2007 15:19:32 +0800
        http://coreoak.javaeye.com/blog/141377
        http://coreoak.javaeye.com/blog/141377
      
      
        光贵节快乐！
        coreoak
        
          
          作者: coreoak 
          链接：http://coreoak.javaeye.com/blog/140002 
          发表时间: 2007年11月12日
          


          声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！
          


          一年一度的光贵节来临了， 祝愿全世界的光贵都在这一天快乐！
          


          
            已有 0 人发表留言，猛击->>这里<<-参与讨论
          
          



          JavaEye推荐
          

          
          



          ]]>
        
        Mon, 12 Nov 2007 19:20:20 +0800
        http://coreoak.javaeye.com/blog/140002
        http://coreoak.javaeye.com/blog/140002
      
      
        java垃圾回收机制学习资料
        coreoak
        
          
          作者: coreoak 
          链接：http://coreoak.javaeye.com/blog/91594 
          发表时间: 2007年06月18日
          


          声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！
          


          
1、谁在做Garbage Collection?

　　一种流行的说法:在C++里，是系统在做垃圾回收;而在Java里，是Java自身在做。


　 　在C++里，释放内存是手动处理的，要用delete运算符来释放分配的内存。这是流行的说法。确切地说，是应用认为不需要某实体时，就需用 delete告诉系统，可以回收这块空间了。这个要求，对编码者来说，是件很麻烦、很难做到的事。随便上哪个BBS，在C/C++版块里总是有一大堆关于 内存泄漏的话题。


　　Java采用一种不同的，很方便的方法:Garbage Collection.垃圾回收机制放在JVM里。JVM完全负责垃圾回收事宜，应用只在需要时申请空间，而在抛弃对象时不必关心空间回收问题。


　　二、对象在啥时被丢弃?


　　在C++里，当对象离开其作用域时，该对象即被应用抛弃。


　　是对象的生命期不再与其作用域有关，而仅仅与引用有关。


　　Java的垃圾回收机制一般包含近十种算法。对这些算法中的多数，我们不必予以关心。只有其中最简单的一个:引用计数法，与编码有关。


　　一个对象，可以有一个或多个引用变量指向它。当一个对象不再有任何一个引用变量指向它时，这个对象就被应用抛弃了。或者说，这个对象可以被垃圾回收机制回收了。


　　这就是说，当不存在对某对象的任何引用时，就意味着，应用告诉JVM:我不要这个对象，你可以回收了。


　　JVM的垃圾回收机制对堆空间做实时检测。当发现某对象的引用计数为0时，就将该对象列入待回收列表中。但是，并不是马上予以销毁。


　　三、丢弃就被回收?


　　该对象被认定为没有存在的必要了，那么它所占用的内存就可以被释放。被回收的内存可以用于后续的再分配。


　　但是，并不是对象被抛弃后当即被回收的。JVM进程做空间回收有较大的系统开销。如果每当某应用进程丢弃一个对象，就立即回收它的空间，势必会使整个系统的运转效率非常低下。


　　前面说过，JVM的垃圾回收机制有多个算法。除了引用计数法是用来判断对象是否已被抛弃外，其它算法是用来确定何时及如何做回收。JVM的垃圾回收机制要在时间和空间之间做个平衡。


　　因此，为了提高系统效率，垃圾回收器通常只在满足两个条件时才运行:即有对象要回收且系统需要回收。切记垃圾回收要占用时间，因此，Java运行时系统只在需要的时候才使用它。因此你无法知道垃圾回收发生的精确时间。


　　四、没有引用变量指向的对象有用吗?


　　前面说了，没挂上引用变量的对象是被应用丢弃的，这意味着，它在堆空间里是个垃圾，随时可能被JVM回收。


　　不过，这里有个不是例外的例外。对于一次性使用的对象(有些书称之为临时对象)，可以不用引用变量指向它。举个最简单也最常见的例子:


　　System.out.println(“I am Java!”);


　　就是创建了一个字符串对象后，直接传递给println()方法。


　　五、应用能干预垃圾回收吗?


　 　许多人对Java的垃圾回收不放心，希望在应用代码里控制JVM的垃圾回收运作。这是不可能的事。对垃圾回收机制来说，应用只有两个途径发消息给 JVM.第一个前面已经说了，就是将指向某对象的所有引用变量全部移走。这就相当于向JVM发了一个消息:这个对象不要了。第二个是调用库方法 System.gc()，多数书里说调用它让Java做垃圾回收。


　　第一个是一个告知，而调用System.gc()也仅仅是一个请求。JVM接受这个消息后，并不是立即做垃圾回收，而只是对几个垃圾回收算法做了加权，使垃圾回收操作容易发生，或提早发生，或回收较多而已。


　　希望JVM及时回收垃圾，是一种需求。其实，还有相反的一种需要:在某段时间内最好不要回收垃圾。要求运行速度最快的实时系统，特别是嵌入式系统，往往希望如此。


　　Java的垃圾回收机制是为所有Java应用进程服务的，而不是为某个特定的进程服务的。因此，任何一个进程都不能命令垃圾回收机制做什么、怎么做或做多少。


　　六、对象被回收时要做的事


　　一个对象在运行时，可能会有一些东西与其关连。因此，当对象即将被销毁时，有时需要做一些善后工作。可以把这些操作写在finalize()方法(常称之为终止器)里。


　　protected void finalize()


　　{


　　// finalization code here


　　}


　 　这个终止器的用途类似于C++里的析构函数，而且都是自动调用的。但是，两者的调用时机不一样，使两者的表现行为有重大区别。C++的析构函数总是当对 象离开作用域时被调用。这就是说，C++析构函数的调用时机是确定的，且是可被应用判知的。但是，Java终止器却是在对象被销毁时。由上所知，被丢弃的 对象何时被销毁，应用是无法获知的。而且，对于大多数场合，被丢弃对象在应用终止后仍未销毁。


　　在编码时，考虑到这一点。譬如，某对象在 运作时打开了某个文件，在对象被丢弃时不关闭它，而是把文件关闭语句写在终止器里。这样做对文件操作会造成问题。如果文件是独占打开的，则其它对象将无法 访问这个文件。如果文件是共享打开的，则另一访问该文件的对象直至应用终结仍不能读到被丢弃对象写入该文件的新内容。


　　至少对于文件操作，编码者应认清Java终止器与C++析构函数之间的差异。


　　那么，当应用终止，会不会执行应用中的所有finalize()呢?据Bruce Eckel在Thinking in Java里的观点:“到程序结束的时候，并非所有收尾模块都会得到调用”。这还仅仅是指应用正常终止的场合，非正常终止呢?


　　因此，哪些收尾操作可以放在finalize()里，是需要酌酎的。

          


          
            已有 0 人发表留言，猛击->>这里<<-参与讨论
          
          



          JavaEye推荐
          

          
          



          ]]>
        
        Mon, 18 Jun 2007 14:21:32 +0800
        http://coreoak.javaeye.com/blog/91594
        http://coreoak.javaeye.com/blog/91594
      
      
        java加密技术收集
        coreoak
        
          
          作者: coreoak 
          链接：http://coreoak.javaeye.com/blog/91576 
          发表时间: 2007年06月18日
          


          声明：本文系JavaEye网站发布的原创博客文章，未经作者书面许可，严禁任何网站转载本文，否则必将追究法律责任！
          


          
在chinaitlab上面找到关于java加密技术的文章， 摘抄下来， 日后好好学习，链接地址：http://java.chinaitlab.com/base/719984_2.html


 最近在研究JAVA CLASS LOADING技术，已实现了一个自定义的加载器。对目前自定义加载器的应用，还在探讨中。下面是自定义的CLASSLOADER在JAVA加密解密方面的一些研究。



JAVA安全



    JAVA是解释执行的语言，对于不同的操作平台都有相应的JVM对字节码文件进行解释执行。而这个字节码文件，也就是我们平时所看到的每一个.class文件。



    这是我们大家都知道的常识，也就是由.java文件，经过编译器编译，变成JVM所能解释的.class文件。



    而这个过程，在现在公开的网络技术中，利用一个反编译器，任何人都可以很容易的获取它的源文件。这对于很多人来说是不希望看到的。



    对于加密解密技术，我懂的不多，有些可以利用某种技术“模糊”JAVA类文件。这样能够使反编译的难度增加。但估计反编译器的技术水平也在不断提升，导致这种方法层层受阻。另外还有很多其他的技术也可以实现对JAVA文件的加密解密。我现在所想要研究的，就是其中的一种。



    JAVA的灵活性使反编译变得容易，同时，也让我们的加密解密的方法变得灵活。



利用自定义的CLASSLOADER



参照：http://www.blogjava.net/realsmy/archive/2007/04/18/111582.html



JAVA中的每一个类都是通过类加载器加载到内存中的。对于类加载器的工作流程如下表示：

1.searchfile() 

找到我所要加载的类文件。（抛除JAR包的概念，现在只是要加载一个.class文件）

2.loadDataClass()

读取这个类文件的字节码。

3.difineClass()

加载类文件。（加载的过程其实很复杂，我们现在先不研究它。）



    从这个过程中我们能很清楚的发现，自定义的类加载能够很轻松的控制每个类文件的加载过程。这样在第二步（loadDataClass）和第三步（difineClass）之间，我们将会有自己的空间灵活的控制这个过程。



我们加密解密的技术就应用到这里。



加密解密



    JAVA加密解密的技术有很多。JAVA自己提供了良好的类库对各种算法进行支持。对于采用哪种算法，网络上说法不一，自己去GOOGLE一下吧。



下面用DES对称加密算法（设定一个密钥，然后对所有的数据进行加密）来简单举个例子。



首先，生成一个密钥KEY。

我把它保存到key.txt中。这个文件就象是一把钥匙。谁拥有它，谁就能解开我们的类文件。代码参考如下：




package com.neusoft.jiami;



import java.io.File;

import java.io.FileOutputStream;

import java.security.SecureRandom;

import javax.crypto.KeyGenerator;

import javax.crypto.SecretKey;



class Key {



    private String keyName;



    public Key(String keyName) {

        this.keyName = keyName;

    }



    public void createKey(String keyName) throws Exception {



        // 创建一个可信任的随机数源，DES算法需要

        SecureRandom sr = new SecureRandom();

        // 用DES算法创建一个KeyGenerator对象

        KeyGenerator kg = KeyGenerator.getInstance("DES");

        // 初始化此密钥生成器,使其具有确定的密钥长度

        kg.init(sr);

        // 生成密匙

        SecretKey key = kg.generateKey();

        // 获取密钥数据

        byte rawKeyData[] = key.getEncoded();

        // 将获取到密钥数据保存到文件中，待解密时使用

        FileOutputStream fo = new FileOutputStream(new File(keyName));

        fo.write(rawKeyData);

    }



    public static void main(String args[]) {

        try {

            new Key("key.txt");

        } catch (Exception e) {

            e.printStackTrace();

        }



    }

}


 


第二步，对我们所要进行加密的类文件进行加密。


    比如我有一个DigestPass类，已经被正常编译好生成DigestPass.class文件。此时，这个类文件是任何人都可以用的。因为系统的类加载器可以自动的加载它。那么下一步，我们要做的就是把这个类文件加密。使系统的类加载器无法读取到正确的字节码文件。参考代码如下：




package com.neusoft.jiami;



import java.io.File;

import java.io.FileInputStream;

import java.io.FileOutputStream;

import java.security.SecureRandom;



import javax.crypto.Cipher;

import javax.crypto.SecretKey;

import javax.crypto.SecretKeyFactory;

import javax.crypto.spec.DESKeySpec;



public class JiaMi {



    public static void main(String[] args) throws Exception {



        // DES算法要求有一个可信任的随机数源

        SecureRandom sr = new SecureRandom();

        // 获得密匙数据

        FileInputStream fi = new FileInputStream(new File("key.txt"));

        byte rawKeyData[] = new byte[fi.available()];

        fi.read(rawKeyData);

        fi.close();

        // 从原始密匙数据创建DESKeySpec对象

        DESKeySpec dks = new DESKeySpec(rawKeyData);

        // 创建一个密匙工厂，然后用它把DESKeySpec转换成一个SecretKey对象

        SecretKey key = SecretKeyFactory.getInstance("DES").generateSecret(dks);

        // Cipher对象实际完成加密操作

        Cipher cipher = Cipher.getInstance("DES");

        // 用密匙初始化Cipher对象

        cipher.init(Cipher.ENCRYPT_MODE, key, sr);

        // 现在，获取要加密的文件数据

        FileInputStream fi2 = new FileInputStream(new File("DigestPass.class"));

        byte data[] = new byte[fi2.available()];

        fi2.read(data);

        fi2.close();

        // 正式执行加密操作

        byte encryptedData[] = cipher.doFinal(data);

        // 用加密后的数据覆盖原文件

        FileOutputStream fo = new FileOutputStream(new File("DigestPass.class"));

        fo.write(encryptedData);

        fo.close();

    }

}






第三步，用自定义的CLASSLOADER进行加载。参考代码如下：




package com.neusoft.jiami;



import java.io.File;

import java.io.FileInputStream;

import java.io.FileOutputStream;

import java.security.SecureRandom;



import javax.crypto.Cipher;

import javax.crypto.SecretKey;

import javax.crypto.SecretKeyFactory;

import javax.crypto.spec.DESKeySpec;

import com.neusoft.classloader.MyClassLoader;



public class JieMi {



    public static void main(String[] args) throws Exception