2009年2月18日随笔档案 - jiafang83

2009年2月18日

oracle 10g默认需要微软的网络适配器配置。新建一个就行了。
方法，打开控制面板，选者添加硬件—选择是，我已经连接了此硬件，下一步选者最后一项添加新的硬件设备，下一步选择安装我手动从列表选者的硬件（高级），下一步选者网络适配器，下一步选者Microsoft Loopback
Adapter,按向导提示下一步就行了。完成以后打开你的网上邻居看看是不是多了一个网上连接（2），然后设置它的IP地址如。192.168.1.1.随便就行了，这样在安装oracle的时候就可以用这一个假的网络来连接，蒙骗一下 oracle了。一定可以验证过去

posted @ 2012-08-18 13:38 jiafang83 阅读(908) | 评论 (0) | 编辑收藏

Hibernate 3注释简介

　摘自：http://article.pchome.net/content-330924.html

在过去几年里，Hibernate不断发展，几乎成为Java数据库持久性的事实标准。它非常强大、灵活，而且具备了优异的性能。在本文中，我们将了解如何使用Java 5 注释来简化Hibernate代码，并使持久层的编码过程变得更为轻松。

　　传统上，Hibernate的配置依赖于外部 XML 文件：数据库映射被定义为一组 XML 映射文件，并且在启动时进行加载。创建这些映射有很多方法，可以从已有数据库模式或Java类模型中自动创建，也可以手工创建。无论如何，您最终将获得大量的 Hibernate 映射文件。此外，还可以使用工具，通过javadoc样式的注释生成映射文件，尽管这样会给您的构建过程增加一个步骤。

　　在最近发布的几个Hibernate版本中，出现了一种基于 Java 5 注释的更为巧妙的新方法。借助新的 Hibernate Annotation 库，即可一次性地分配所有旧映射文件——一切都会按照您的想法来定义——注释直接嵌入到您的 Java 类中，并提供一种强大及灵活的方法来声明持久性映射。籍由自动代码完成和语法突出显示功能，最近发布的Java IDE也为其提供了有力的支持。

　　Hibernate Annotation还支持新的 EJB 3 持久性规范。这些规范旨在提供一种标准化的 Java 持久性机制。由于 Hibernate 3 还提供了一些扩展，因此您可以十分轻松地遵从这些标准，并使用 EJB 3 编程模型来对 Hibernate 持久层进行编码。

　　现在，让我们来动手使用Hibernate Annotation。

安装 Hibernate Annotation

　　要使用 Hibernate Annotation，您至少需要具备 Hibernate 3.2和Java 5。可以从 Hibernate 站点下载 Hibernate 3.2 和 Hibernate Annotation库。除了标准的 Hibernate JAR 和依赖项之外，您还需要 Hibernate Annotations .jar 文件（hibernate-annotations.jar）、Java 持久性 API （lib/ejb3-persistence.jar）。如果您正在使用 Maven，只需要向 POM 文件添加相应的依赖项即可，如下所示：

 ...

org.hibernate
hibernate
3.2.1.ga


org.hibernate
hibernate-annotations
3.2.0.ga


javax.persistence
persistence-api
1.0

...

　　下一步就是获取 Hibernate 会话工厂。尽管无需惊天的修改，但这一工作与使用 Hibernate Annotations有所不同。您需要使用 AnnotationConfiguration 类来建立会话工厂：

sessionFactory = new

AnnotationConfiguration().buildSessionFactory();

　　尽管通常使用元素来声明持久性类，您还是需要在 Hibernate 配置文件（通常是 hibernate.cfg.xml）中声明持久性类：

　　近期的许多 Java 项目都使用了轻量级的应用框架，例如 Spring。如果您正在使用 Spring 框架，可以使用 AnnotationSessionFactoryBean 类轻松建立一个基于注释的 Hibernate 会话工厂，如下所示：








org.hibernate.dialect.DerbyDialect
create
...




com.onjava.modelplanes.domain.PlaneType
com.onjava.modelplanes.domain.ModelPlane
...

第一个持久性类

　　既然已经知道了如何获得注释所支持的 Hibernate 会话，下面让我们来了解一下带注释的持久性类的情况：

　　像在其他任何 Hibernate应用程序中一样，带注释的持久性类也是普通 POJO。差不多可以说是。您需要向 Java 持久性 API （javax.persistence.*）添加依赖项，如果您正在使用任何特定于 Hibernate的扩展，那很可能就是 Hibernate Annotation 程序包（org.hibernate.annotations.*），但除此之外，它们只是具备了持久性注释的普通 POJO 。下面是一个简单的例子：

@Entity
public class ModelPlane {
private Long id;
private String name;
@Id
public Long getId() {
return id;
}
public void setId(Long id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}

　　正像我们所提到的，这非常简单。@Entity 注释声明该类为持久类。@Id 注释可以表明哪种属性是该类中的独特标识符。事实上，您既可以保持字段（注释成员变量），也可以保持属性（注释getter方法）的持久性。后文中将使用基于属性的注释。基于注释的持久性的优点之一在于大量使用了默认值（最大的优点就是 “惯例优先原则（convention over configuration）”）。例如，您无需说明每个属性的持久性——任何属性都被假定为持久的，除非您使用 @Transient 注释来说明其他情况。这简化了代码，相对使用老的 XML 映射文件而言也大幅地减少了输入工作量。

生成主键

　　Hibernate 能够出色地自动生成主键。Hibernate/EBJ 3 注释也可以为主键的自动生成提供丰富的支持，允许实现各种策略。下面的示例说明了一种常用的方法，其中 Hibernate 将会根据底层数据库来确定一种恰当的键生成策略：

@Id
@GeneratedValue(strategy=GenerationType.AUTO)
public Long getId() {
return id;
}

定制表和字段映射

　　默认情况下，Hibernate 会将持久类以匹配的名称映射到表和字段中。例如，前一个类可以与映射到以如下代码创建的表中：

CREATE TABLE MODELPLANE
(
ID long,
NAME varchar
)

　　如果您是自己生成并维护数据库，那么这种方法很有效，通过省略代码可以大大简化代码维护。然而，这并不能满足所有人的需求。有些应用程序需要访问外部数据库，而另一些可能需要遵从公司的数据库命名惯例。如果有必要，您可以使用 @Table 和 @Column 注释来定制您自己的持久性映射，如下所示：

@Entity
@Table(name="T_MODEL_PLANE")
public class ModelPlane {
private Long id;
private String name;
@Id
@Column(name="PLANE_ID")
public Long getId() {
return id;
}
public void setId(Long id) {
this.id = id;
}
@Column(name="PLANE_NAME")
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}

　　该内容将映射到下表中：

CREATE TABLE T_MODEL_PLANE
(
PLANE_ID long,
PLANE_NAME varchar
)

　　也可以使用其他图和列的属性来定制映射。这使您可以指定诸如列长度、非空约束等详细内容。Hibernate支持大量针对这些注释的属性。下例中就包含了几种属性：

 ...
@Column(name="PLANE_ID", length=80, nullable=true)
public String getName() {
return name;
}
...

映射关系

　　Java 持久性映射过程中最重要和最复杂的一环就是确定如何映射表间的关系。像其他产品一样， Hibernate 在该领域中提供了高度的灵活性，但却是以复杂度的增加为代价。我们将通过研究几个常见案例来了解如何使用注释来处理这一问题。

　　其中一种最常用的关系就是多对一的关系。假定在以上示例中每个 ModelPlane 通过多对一的关系（也就是说，每个飞机模型只与一种飞机类型建立联系，尽管指定的飞机类型可以与七种飞机模型建立联系）来与 PlaneType 建立联系。可如下进行映射：

 @ManyToOne( cascade = {CascadeType.PERSIST, CascadeType.MERGE} )
public PlaneType getPlaneType() {
return planeType;
}

　　CascadeType 值表明 Hibernate 应如何处理级联操作。

　　另一种常用的关系与上述关系相反：一对多再对一关系，也称为集合。在老式的 Hibernate 版本中进行映射或使用注释时，集合令人头疼，这里我们将简要加以探讨，以使您了解如何处理集合，例如，在以上示例中每个 PlaneType 对象都可能会包含一个 ModelPlanes 集合。可映射如下：

 @OneToMany(mappedBy="planeType",
cascade=CascadeType.ALL,
fetch=FetchType.EAGER)
@OrderBy("name")
public List getModelPlanes() {
return modelPlanes;
}

命名查询

　　Hibernate 最优秀的功能之一就在于它能够在您的映射文件中声明命名查询。随后即可通过代码中的名称调用此类查询，这使您可以专注于查询，而避免了 SQL 或者 HQL 代码分散于整个应用程序中的情况。

　　也可以使用注释来实现命名查询，可以使用 @NamedQueries 和 @NamedQuery 注释，如下所示：

@NamedQueries(
{
@NamedQuery(
name="planeType.findById",
query="select p from PlaneType p left join fetch p.modelPlanes where id=:id"
),
@NamedQuery(
name="planeType.findAll",
query="select p from PlaneType p"
),
@NamedQuery(
name="planeType.delete",
query="delete from PlaneType where id=:id"
)
}
)

　　一旦完成了定义，您就可以像调用其他任何其他命名查询一样来调用它们。

结束语

　　Hibernate 3 注释提供了强大而精致的 API，简化了 Java 数据库中的持久性代码，本文中只进行了简单的讨论。您可以选择遵从标准并使用 Java 持久性 API，也可以利用特定于 Hibernate的扩展，这些功能以损失可移植性为代价提供了更为强大的功能和更高的灵活性。无论如何，通过消除对 XML 映射文件的需求，Hibernate 注释将简化应用程序的维护，同时也可以使您对EJB 3 有初步认识。来试试吧！

posted @ 2009-07-26 14:00 jiafang83 阅读(328) | 评论 (0) | 编辑收藏

Hibernate一对多双向annotation配置

摘自：http://www.javaeye.com/topic/95822

school和userMember是一对多关系：

SchoolInfo.java

import javax.persistence.CascadeType;
2

import javax.persistence.Column;
3

import javax.persistence.Entity;
4

import javax.persistence.FetchType;
5

import javax.persistence.GeneratedValue;
6

import javax.persistence.Id;
7

import javax.persistence.OneToMany;
8

import javax.persistence.Table;
9

import javax.persistence.Temporal;
10

import javax.persistence.TemporalType;
11

import org.hibernate.annotations.Formula;
13

import org.hibernate.annotations.GenericGenerator;
14

@Entity
16

@Table(name = "school_info")
17

public class SchoolInfo implements java.io.Serializable {
18

@Id
20

@GeneratedValue(generator = "system-uuid")
21

@GenericGenerator(name = "system-uuid", strategy = "uuid")
22

private String id;//hibernate的uuid机制,生成32为字符串
23

@Column(name = "actcodeId", updatable = false, nullable = true, length = 36)
25

private String actcodeId;
26

@Formula("select COUNT(*) from school_info")
28

private int count;
29

@Temporal(TemporalType.TIMESTAMP)//不用set,hibernate会自动把当前时间写入
31

@Column(updatable = false, length = 20)
32

private Date createTime;
33

@Temporal(TemporalType.TIMESTAMP)
35

private Date updateTime;// 刚开始我默认insertable=false,但会读取出错提示如下:
36

// Value '0000-00-00' can not be represented as java.sql.Timestamp
37

// mappedBy="school"就相当于inverse=true,(mappedBy指定的是不需要维护关系的一端)
39

// 应该注意的是mappedBy值对应@ManyToOne标注的属性,我刚开始写成"schoolId",让我郁闷了好一会
40

@OneToMany(mappedBy = "school", cascade = CascadeType.ALL, fetch = FetchType.EAGER, targetEntity = UserMember.class)
41

// 用范性的话,就不用targetEntity了
42

private List<usermember> users = </usermember>new ArrayList<usermember>(); </usermember>
43

}
45

@GeneratedValue(strategy=GenerationType.AUTO)我们常用的自增长机制,我这里采用的是hibernate的uuid生成机制.
需要注意的是import javax.xx.Entity ，而不是org.hibernate.xx.Entity。
郁闷的是我上面用到@Formula,生成的sql竟然是'select COUNT(*) from school_info as formula0_ from school_info schoolinfo0_,当然不能执行了,寻求正解中~!!!!!!!!!

UserMember.java(前面引入的包已经贴过了,下面就不贴了)

1 @Entity
2 @Table(name = "teacher_info")//实体类和数据库表名不一致时,才用这个
3 public class UserMember implements java.io.Serializable {
4
5     @Id
6     @GeneratedValue(generator = "system-uuid")
7     @GenericGenerator(name = "system-uuid", strategy = "uuid")
8     private String id;
9
10     @Column(updatable = false, nullable = false, length = 20)
11     private String logonName;
12
13     @Temporal(TemporalType.TIMESTAMP)
14     @Column(updatable = false, length = 20)
15     private Date createTime;
16
17     @Temporal(TemporalType.TIMESTAMP)
18     private Date updateTime;
19
20     @ManyToOne(cascade = { CascadeType.MERGE })
21     @JoinColumn(name = "schoolId")
22     private SchoolInfo school;
23     //注意该类就不用声明schoolId属性了,如果不用@JoinColumn指明关联的字段,hibernate默认会是school_id.
24
25 }

posted @ 2009-07-26 13:40 jiafang83 阅读(3176) | 评论 (1) | 编辑收藏

使用JAVA程序连接各种数据库

posted @ 2009-07-20 22:31 jiafang83 阅读(255) | 评论 (0) | 编辑收藏

深入浅出JSON

转载：http://www.cnblogs.com/Truly/archive/2006/12/31/608896.html

JSON定义

JSON(JavaScript Object Notation) 是一种轻量级的数据交换格式，易于阅读和编写，同时也易于机器解析和生成。它基于ECMA262语言规范（1999-12第三版）中JavaScript编程语言的一个子集。 JSON采用与编程语言无关的文本格式，但是也使用了类C语言（包括C， C++， C#， Java， JavaScript， Perl， Python等）的习惯，这些特性使JSON成为理想的数据交换格式。

JSON的结构基于下面两点

1. "名称/值"对的集合 不同语言中，它被理解为对象(object)，记录(record)，结构(struct)，字典(dictionary)，哈希表(hash table)，键列表(keyed list)等
2. 值的有序列表 多数语言中被理解为数组(array)

JSON使用：

JSON以一种特定的字符串形式来表示 JavaScript 对象。如果将具有这样一种形式的字符串赋给任意一个 JavaScript 变量，那么该变量会变成一个对象引用，而这个对象就是字符串所构建出来的，好像有点拗口，我们还是用实例来说明。

这里假设我们需要创建一个User对象，并具有以下属性

用户ID

用户名

用户Email

您可以使用以下JSON形式来表示User对象：

{"UserID":11, "Name":"Truly", "Email":"zhuleipro◎hotmail.com"};

然后如果把这一字符串赋予一个JavaScript变量，那么就可以直接使用对象的任一属性了。

完整代码:

<script>

var User = {"UserID":11, "Name":"Truly", "Email":"zhuleipro◎hotmail.com"};
alert(User.Name);
</script>

实际使用时可能更复杂一点，比如我们为Name定义更详细的结构，使它具有FirstName和LastName：

{"UserID":11, "Name":{"FirstName":"Truly","LastName":"Zhu"}, "Email":"zhuleipro◎hotmail.com"}

完整代码:

<script>

var User = {"UserID":11, "Name":{"FirstName":"Truly","LastName":"Zhu"}, "Email":"zhuleipro◎hotmail.com"};
alert(User.Name.FirstName);
</script>

现在我们增加一个新的需求，我们某个页面需要一个用户列表，而不仅仅是一个单一的用户信息，那么这里就需要创建一个用户列表数组。
下面代码演示了使用JSON形式定义这个用户列表：

[
{"UserID":11, "Name":{"FirstName":"Truly","LastName":"Zhu"}, "Email":"zhuleipro◎hotmail.com"},
{"UserID":12, "Name":{"FirstName":"Jeffrey","LastName":"Richter"}, "Email":"xxx◎xxx.com"},
{"UserID":13, "Name":{"FirstName":"Scott","LastName":"Gu"}, "Email":"xxx2◎xxx2.com"}
]

完整代码:

<script>
var UserList = [
{"UserID":11, "Name":{"FirstName":"Truly","LastName":"Zhu"}, "Email":"zhuleipro◎hotmail.com"},
{"UserID":12, "Name":{"FirstName":"Jeffrey","LastName":"Richter"}, "Email":"xxx◎xxx.com"},
{"UserID":13, "Name":{"FirstName":"Scott","LastName":"Gu"}, "Email":"xxx2◎xxx2.com"}
];
alert(UserList[0].Name.FirstName);
</script>

事实上除了使用"."引用属性外，我们还可以使用下面语句：

alert(UserList[0]["Name"]["FirstName"]); 或者 alert(UserList[0].Name["FirstName"]);

现在读者应该对JSON的使用有点认识了，归纳为以下几点：

对象是属性、值对的集合。一个对象的开始于“{”，结束于“}”。每一个属性名和值间用“:”提示，属性间用“,”分隔。

数组是有顺序的值的集合。一个数组开始于"["，结束于"]"，值之间用","分隔。

值可以是引号里的字符串、数字、true、false、null，也可以是对象或数组。这些结构都能嵌套。

字符串和数字的定义和C或Java基本一致。

小节：

本文通过一个实例演示，初步了解了JSON 的强大用途。可以归结如下：

JSON 提供了一种优秀的面向对象的方法，以便将元数据缓存到客户机上。

JSON 帮助分离了验证数据和逻辑。

JSON 帮助为 Web 应用程序提供了 Ajax 的本质。

posted @ 2009-06-16 01:03 jiafang83 阅读(321) | 评论 (0) | 编辑收藏

Tomcat中部署JSTL

转载：http://blog.csdn.net/sdlcn/

前提 OS: WIN2000
tomcat已经配置好(tomcat可以到http://jakarta.apache.org/tomcat 下载)
开始实战啦
1.准备jstl
到http://apache.towardex.com/jakarta/taglibs/standard/下载jakarta-taglibs-standard-current.zip
解压后成为jakarta-taglibs-standard-1.1.1

2.准备web开发目录
比如我的web目录为h:\webapp\myweb$当然可以把你的web应用放在%tomcat_home%\webapps$，称为工作目录Working folder,在工作目录h:\webapp\myweb\下建立WEB-INF\lib,WEB-INF\classes

3.拷贝.jar文件
将jakarta-taglibs-standard-1.1.1\lib\下的两个jar文件：standard.jar和jstl.jar文件拷贝到\WEB-INF\lib\下

4.拷贝.tld文件
将jakarta-taglibs-standard-1.1.1\tld\下的8个tld类型文件拷到"Working folder\WEB-INF\"下

5.在\WEB-INF\下建立web.xml文件：
<?xml version="1.0" encoding="ISO-8859-1"?>

<web-app 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"
    version="2.4">

<taglib>
    <taglib-uri>http://java.sun.com/jstl/fmt</taglib-uri>
    <taglib-location>/WEB-INF/fmt.tld</taglib-location>
</taglib>

<taglib>
<taglib-uri>http://java.sun.com/jstl/x-rt</taglib-uri>
<taglib-location>/WEB-INF/x-rt.tld</taglib-location>
</taglib>
</web-app>
6.建立一个名为test.jsp文件
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<%@ page contentType="text/html;charset=GB2312" %>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core"%>
<html>
<head>
<title>测试你的第一个使用到JSTL 的网页</title>
</head>
<body>
<c:out value="欢迎测试你的第一个使用到JSTL 的网页"/>
</br>你使用的浏览器是：</br>
<c:out value="${header['User-Agent']}"/>
<c:set var="a" value="David O'Davies" />
<c:out value="David O'Davies" escapeXml="true"/>
</body>
</html>

7.开启tomcat,进行调试，我的输出结果是

欢迎测试你的第一个使用到JSTL 的网页
你使用的浏览器是：
Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.0) David O'Davies

posted @ 2009-06-14 18:02 jiafang83 阅读(850) | 评论 (0) | 编辑收藏

javascript:return false

转载：http://blog.csdn.net/mtzai/archive/2009/05/24/4212490.aspx

在大多数情况下,为事件处理函数返回false,可以防止默认的事件行为.例如,默认情况下点击一个<a>元素,页面会跳转到该元素href属性指定的页.
Return False 就相当于终止符，Return True 就相当于执行符。

在js中return false的作用一般是用来取消默认动作的。比如你单击一个链接除了触发你的
onclick时间（如果你指定的话）以外还要触发一个默认事件就是执行页面的跳转。所以如果
你想取消对象的默认动作就可以return false。return false应用比较多的场合有：
<form name="form1" onsubmIT="return youfunction();">...... </form>
<a href="www.***.com" onclick="...;return false;">dddd </a> .

</head>

<a href="xxxx.do?....." target=dolink>连接abcd </a>
<iframe id=dolink src=about:blank style=display:none> </iframe>

点了上面的那个连接后，dolink帧执行页面处理的事情（xxxx.do？...然传递参数到服务器），页面不会跳转。 .

最近做的项目，通过绑定在 button 的 onclick 事件的函数提交表单。发现 return false 也是很重要的。比如：

submitAction 方法里面有提交表单的动作。如果不加 return false，在执行完 submitAction 之后，submit 按钮还会继续执行它的默认事件，就会再次提交表单。这可能就是很多错误的根源。

的确，return false的含义不是阻止事件继续向顶层元素传播，而是阻止浏览器对事件的默认处理。你可以这样试验：首先将所有的js脚本注释掉，在IE浏览器中尝试拖动一下图片，你会发现鼠标会成为禁止操作的样式，图片是被禁止拖动的，它是浏览器针对mousemove事件所提供的默认行为。return false就是为了去掉这种行为，否则就会出现你描述的中断事件连续执行。

另外，和return false等效的语句为：window.event.returnValue = false，你可以把return false替换为此语句并进行验证。

最后说明一下，此种方式只适用于IE浏览器。

<html>
<head>
<script language="javascript">
function verifyForm(){
var ass=document.getElementsByName("assetName");
if(ass[0].value.length==0){
alert("名称输入为空！");
return false;
}

if(ass[0].value.length>15){
alert("名称输入长度不能超过15个字符！");
return false;
}
}
</script>
</head>
<body>
<form name="xx">
<input name="assetName" type="text"/>
<--根据return 返回值的TRUE或FALSE 判定是否提交表单--->
<input type="submit" onclick="return verifyForm()"/>
</form>
</body>
</html>

潜水看了众大虾的精彩帖子，今也贡献一点心得。其闻共欣赏，疑义相与析。有不对之处请不吝拍砖。

众所周知，在表单中加上onsubmit="return false;"可以阻止表单提交。
下面是简单的一小段代码：

view plaincopy to clipboardprint?
<form action="index.jsp" method="post" onsubmit="submitTest();;">
    <INPUT value="www">
    <input type="submit" value="submit">
</form>

<SCRIPT LANGUAGE="JavaScript">

</SCRIPT>

<SCRIPT LANGUAGE="JavaScript">

</SCRIPT>
大家判断像上面的写法，点击submit按钮该表单是否提交？

若答案为是，就不用往下看了。

若答案为否，错了。实际情况是表单正常提交，若想它不提交，应该将

view plaincopy to clipboardprint?
<form action="index.jsp" method="post" onsubmit="submitTest();;">

<form action="index.jsp" method="post" onsubmit="submitTest();;">改为

view plaincopy to clipboardprint?
<form action="index.jsp" method="post" onsubmit="return submitTest();;">

为何？

原来onsubmit属性就像是<form>这个html对象的一个方法名，其值（一字符串）就是其方法体，默认返回true；

和Java一样，在该方法体中你可以写任意多个语句，包括内置函数和自定义函数，如

view plaincopy to clipboardprint?
onsubmit="
    alert('haha');; // 内置函数
    submitTest();; // 自定义函数
    alert(this.tagName);; // 用到了this关键词
    ......(任意多条语句);
    return false;
"

onsubmit="
    alert('haha');; // 内置函数
    submitTest();; // 自定义函数
    alert(this.tagName);; // 用到了this关键词
    ......(任意多条语句);
    return false;
"
就相当于

view plaincopy to clipboardprint?
Form.prototype.onsubmit = function(); {
    alert('haha');; // 内置函数
    submitTest();; // 自定义函数
    alert(this.tagName);; // 用到了this关键词
    ......(任意多条语句);
    return false;
};

Form.prototype.onsubmit = function(); {
    alert('haha');; // 内置函数
    submitTest();; // 自定义函数
    alert(this.tagName);; // 用到了this关键词
    ......(任意多条语句);
    return false;
};
这样的话你就覆写了(override)其默认方法（默认返回true）
大家注意到方法体中可以用this这个关键词，这里即代表了<form>的对象实例。

经过这样的分析后，以上情况就不难理解了：

view plaincopy to clipboardprint?
<form action="index.jsp" method="post" onsubmit="submitTest();;">

<form action="index.jsp" method="post" onsubmit="submitTest();;">这样写，override方法的效果为：

view plaincopy to clipboardprint?
Form.prototype.onsubmit = function(); {
submitTest();;
};

Form.prototype.onsubmit = function(); {
submitTest();;
};
在这里submitTest()虽然返回false，但我们只执行了此函数，没有对其结果进行任何处理。而

view plaincopy to clipboardprint?
<form action="index.jsp" method="post" onsubmit="return submitTest();;">

<form action="index.jsp" method="post" onsubmit="return submitTest();;">
override方法的效果为：

view plaincopy to clipboardprint?
Form.prototype.onsubmit = function(); {
return submitTest();;
};

Form.prototype.onsubmit = function(); {
return submitTest();;
};
这样，我们利用到了它的返回值，达到了预期效果。
这样理解的话我想印象会深刻得多，就不易出错了

结论：
我们可以用Java里的思维方式来思考模拟JavaScript中的类似情况（JavaScript中基于prototype的面向对象技术也确实是这样做的），但他们毕竟还是有本质上的区别，如Java是强类型的，有严格的语法限制，而JavaScript是松散型的。象上述方法：

view plaincopy to clipboardprint?
Form.prototype.onsubmit = function(); {
};

Form.prototype.onsubmit = function(); {
};
既可以有返回值，又可以没有返回值，在Java里是通不过的，毕竟Java里面不能靠方法的返回值不同来重载(overload)方法，而JavaScript中的重载要松散得多。

posted @ 2009-06-13 23:52 jiafang83 阅读(1336) | 评论 (0) | 编辑收藏

request.getParameter与request.getParameterValues的区别

一、简单的对比

request.getParameter用的比较多，相对熟悉

request.getParameterValues(String name)是获得如checkbox类（名字相同，但值有多个）的数据。接收数组变量，如checkobx类型
request.getParameter（String name）是获得相应名的数据，如果有重复的名，则返回第一个的值 . 接收一般变量，如text类型

例：

1. 三个名字相同的text标签

request.getParameterValues("test") ----------------- [1, 2, 3]

request.getParameter("test") ------------------ 1

${paramValues.test}

${param.test}

2. checkbox

<input type="checkbox" name="habit" value="read">看书

<input type="checkbox" name="habit" value="movie">电影

<input type="checkbox" name="habit" value="game">游戏

request.getParameterValues("habit")

二、与此相关的话题------隐含对象

1. JSP隐含对象(Implicit Object)

所谓隐含对象，是指当编写jsp网页时，不必做任何声明就可以直接使用的对象。 JSP2.0定义了九个隐含对象

request response pageContext session application out conifg page exception

这里只提一下request 和 response 两个对象

request 对象表示客户端请求的内容，比如我们从request中取得了用户输入的内容，实现了javax.servlet.http.HttpServletRequest接口

response对象表示响应客户端的结果。

上面我们使用了request的两个方法getParameter 和 getParameterValues，其实request还有其他几个比较重要的方法，这里只涉及几个获取请求参数的方法

String getParameter(String name) 取得name的参数值

String[] getParameterValues(String name) 取得所有name的参数值

Enumeration getParameterNames() 取得所有的参数名称

Map<String, String[]> getParameterMap() 取得request的所有参数的一个映射

Returns a java.util.Map of the parameters of this request. Request parameters are extra information sent with the request. For HTTP servlets, parameters are contained in the query string or posted form data.
Returns:
an immutable java.util.Map containing parameter names as keys and parameter values as map values. The keys in the parameter map are of type String. The values in the parameter map are of type String array.
//

response等其他几个隐含对象也有非常重要的身份，有机会专门整理一下，宣扬一下它们的显赫地位。

2. EL隐含对象

EL即Experssion Language，自JSP2.0后正式成为JSP的标准规范之一，支持Servlet2.4/JSP2.0的Container也就相应的支持EL语法。

一个常见的形式如，<c:out value="${ 3 + 7 * 4}" />

EL的隐藏对象有11个 PageContext PageScope RequestScope sessionScope applicationScope

param paramValues header headerValues cookie initParam

其中param 和 paramValues即对相应ServletRequest.getParameter(String name)和ServletRequest.getParameterValues(String name)

转载：http://blog.csdn.net/moreorless/archive/2009/05/18/4199677.aspx

posted @ 2009-06-12 14:53 jiafang83 阅读(737) | 评论 (0) | 编辑收藏

Javascript强制类型转换

转载：http://www.sucai.com/Tech/List2/17830.htm

javascript是弱类型的语言，所以强制类型转换还是比较重要的，下面看一下它的几个强制转换的函数：

1. Boolean(value):把值转换成Boolean类型；

2. Nnumber(value):把值转换成数字（整型或浮点数）；

3. String(value):把值转换成字符串。

我们先来看Boolean()：在要转换的值为“至少有一字符的字符串”、“非0的数字”或“对象”，那么Boolean()将返回true，如果要转换的值为“空字符串”、“数字0”、“undefined”，“null”这些话，那么Boolean()会返回false。你可以用以下代码来测试

var　t1　=　Boolean("");//返回false,空字符串
var　t2　=　Boolean("s");//返回true，非空字符串
var　t3　=　Boolean(0);//返回false，数字0
var　t3　=　Boolean(1),t4　=　Boolean(-1);//返回true，非0数字
var　t5　=　Boolean(null),t6　=　Boolean(undefined);//返回false
var　t7　=　Boolean(new　Object());//返回true，对象

再来看看Number()：Number()与parseInt()和parseFloat()类似，它们区别在于Number()转换是整个值，而parseInt()和parseFloat()则可以只转换开头的数字部分，例如：Number("1.2.3"),Number("123abc")会返回NaN，而parseInt("1.2.3")返回1、parseInt("123abc")返回123、parseFloat("1.2.3")返回1.2、parseFloat("123abc")返回123。Number()会先判断要转换的值能否被完整的转换，然后再判断是调用parseInt()或parseFloat()。下面列了一些值调用Number()之后的结果：

Number(false)　 0
Number(true)　 1
Number(undefined)　 NaN
Number(null)　 0
Number("1.2")　 1.2

Number("12")　 12
Number("1.2.3")　 NaN
Number(new Object())　 NaN
Number(123)　 123

最后是String()：这个以比较简单了，它可以把所有类型的数据转换成字符串，如：String(false)---"false"、String(1)---"1"。它和toString()方法有些不同，区别在于：

var　t1　=　null;
var　t2　=　String(t1);//t2的值　"null"
var　t3　=　t1.toString();//这里会报错
var　t4;
var　t5　=　String(t4);//t5的值　"undefined"
var　t6　=　t4.toString();//这里会报错

posted @ 2009-06-09 16:03 jiafang83 阅读(9620) | 评论 (2) | 编辑收藏

JAVA版汉字转拼音缩写程序

摘要: 阅读全文

posted @ 2009-06-08 14:28 jiafang83 阅读(2180) | 评论 (3) | 编辑收藏

tomcat虚拟路径的几种配置方法

摘要: 阅读全文

posted @ 2009-06-05 15:52 jiafang83 阅读(21681) | 评论 (0) | 编辑收藏

修改类文件，tomcat自动重启的问题

摘要: 阅读全文

posted @ 2009-06-02 16:58 jiafang83 阅读(1737) | 评论 (0) | 编辑收藏

Tomcat中部署java web应用程序

摘要: 阅读全文

posted @ 2009-06-02 16:50 jiafang83 阅读(1558) | 评论 (0) | 编辑收藏

JdbcTemplate学习笔记

转载：http://www.javaeye.com/topic/53526

推荐圈子: Groovy on Grails
更多相关推荐

1、使用JdbcTemplate的execute()方法执行SQL语句

Java代码

jdbcTemplate.execute("CREATE TABLE USER (user_id integer, name varchar(100))");

jdbcTemplate.execute("CREATE TABLE USER (user_id integer, name varchar(100))");

2、如果是UPDATE或INSERT,可以用update()方法。

Java代码

jdbcTemplate.update("INSERT INTO USER VALUES('"
+ user.getId() + "', '"
+ user.getName() + "', '"
+ user.getSex() + "', '"
+ user.getAge() + "')");

jdbcTemplate.update("INSERT INTO USER VALUES('"
+ user.getId() + "', '"
+ user.getName() + "', '"
+ user.getSex() + "', '"
+ user.getAge() + "')");

3、带参数的更新

Java代码

jdbcTemplate.update("UPDATE USER SET name = ? WHERE user_id = ?", new Object[] {name, id});

jdbcTemplate.update("UPDATE USER SET name = ? WHERE user_id = ?", new Object[] {name, id});

Java代码

jdbcTemplate.update("INSERT INTO USER VALUES(?, ?, ?, ?)", new Object[] {user.getId(), user.getName(), user.getSex(), user.getAge()});

jdbcTemplate.update("INSERT INTO USER VALUES(?, ?, ?, ?)", new Object[] {user.getId(), user.getName(), user.getSex(), user.getAge()});

4、使用JdbcTemplate进行查询时，使用queryForXXX()等方法

Java代码

int count = jdbcTemplate.queryForInt("SELECT COUNT(*) FROM USER");

int count = jdbcTemplate.queryForInt("SELECT COUNT(*) FROM USER");

Java代码

String name = (String) jdbcTemplate.queryForObject("SELECT name FROM USER WHERE user_id = ?", new Object[] {id}, java.lang.String.class);

String name = (String) jdbcTemplate.queryForObject("SELECT name FROM USER WHERE user_id = ?", new Object[] {id}, java.lang.String.class);

Java代码

List rows = jdbcTemplate.queryForList("SELECT * FROM USER");

List rows = jdbcTemplate.queryForList("SELECT * FROM USER");

Java代码

List rows = jdbcTemplate.queryForList("SELECT * FROM USER");
Iterator it = rows.iterator();
while(it.hasNext()) {
Map userMap = (Map) it.next();
System.out.print(userMap.get("user_id") + "\t");
System.out.print(userMap.get("name") + "\t");
System.out.print(userMap.get("sex") + "\t");
System.out.println(userMap.get("age") + "\t");
}

List rows = jdbcTemplate.queryForList("SELECT * FROM USER");
Iterator it = rows.iterator();
while(it.hasNext()) {
Map userMap = (Map) it.next();
System.out.print(userMap.get("user_id") + "\t");
System.out.print(userMap.get("name") + "\t");
System.out.print(userMap.get("sex") + "\t");
System.out.println(userMap.get("age") + "\t");
}

JdbcTemplate将我们使用的JDBC的流程封装起来，包括了异常的捕捉、SQL的执行、查询结果的转换等等。spring大量使用Template Method模式来封装固定流程的动作，XXXTemplate等类别都是基于这种方式的实现。
除了大量使用Template Method来封装一些底层的操作细节，spring也大量使用callback方式类回调相关类别的方法以提供JDBC相关类别的功能，使传统的JDBC的使用者也能清楚了解spring所提供的相关封装类别方法的使用。

JDBC的PreparedStatement

Java代码

final String id = user.getId();
final String name = user.getName();
final String sex = user.getSex() + "";
final int age = user.getAge();
jdbcTemplate.update("INSERT INTO USER VALUES(?, ?, ?, ?)",
new PreparedStatementSetter() {
public void setValues(PreparedStatement ps) throws SQLException {
ps.setString(1, id);
ps.setString(2, name);
ps.setString(3, sex);
ps.setInt(4, age);
}
});

final String id = user.getId();
final String name = user.getName();
final String sex = user.getSex() + "";
final int age = user.getAge();
jdbcTemplate.update("INSERT INTO USER VALUES(?, ?, ?, ?)",
new PreparedStatementSetter() {
public void setValues(PreparedStatement ps) throws SQLException {
ps.setString(1, id);
ps.setString(2, name);
ps.setString(3, sex);
ps.setInt(4, age);
}
});

Java代码

final User user = new User();
jdbcTemplate.query("SELECT * FROM USER WHERE user_id = ?",
new Object[] {id},
new RowCallbackHandler() {
public void processRow(ResultSet rs) throws SQLException {
user.setId(rs.getString("user_id"));
user.setName(rs.getString("name"));
user.setSex(rs.getString("sex").charAt(0));
user.setAge(rs.getInt("age"));
}
});

final User user = new User();
jdbcTemplate.query("SELECT * FROM USER WHERE user_id = ?",
new Object[] {id},
new RowCallbackHandler() {
public void processRow(ResultSet rs) throws SQLException {
user.setId(rs.getString("user_id"));
user.setName(rs.getString("name"));
user.setSex(rs.getString("sex").charAt(0));
user.setAge(rs.getInt("age"));
}
});

Java代码

class UserRowMapper implements RowMapper {
public Object mapRow(ResultSet rs, int index) throws SQLException {
User user = new User();
user.setId(rs.getString("user_id"));
user.setName(rs.getString("name"));
user.setSex(rs.getString("sex").charAt(0));
user.setAge(rs.getInt("age"));
return user;
}
}
public List findAllByRowMapperResultReader() {
String sql = "SELECT * FROM USER";
return jdbcTemplate.query(sql, new RowMapperResultReader(new UserRowMapper()));
}

class UserRowMapper implements RowMapper {
public Object mapRow(ResultSet rs, int index) throws SQLException {
User user = new User();
user.setId(rs.getString("user_id"));
user.setName(rs.getString("name"));
user.setSex(rs.getString("sex").charAt(0));
user.setAge(rs.getInt("age"));
return user;
}
}
public List findAllByRowMapperResultReader() {
String sql = "SELECT * FROM USER";
return jdbcTemplate.query(sql, new RowMapperResultReader(new UserRowMapper()));
}

在getUser(id)里面使用UserRowMapper

Java代码

public User getUser(final String id) throws DataAccessException {
String sql = "SELECT * FROM USER WHERE user_id=?";
final Object[] params = new Object[] { id };
List list = jdbcTemplate.query(sql, params, new RowMapperResultReader(new UserRowMapper()));
return (User) list.get(0);
}

public User getUser(final String id) throws DataAccessException {
String sql = "SELECT * FROM USER WHERE user_id=?";
final Object[] params = new Object[] { id };
List list = jdbcTemplate.query(sql, params, new RowMapperResultReader(new UserRowMapper()));
return (User) list.get(0);
}

网上收集
org.springframework.jdbc.core.PreparedStatementCreator 返回预编译SQL 不能于Object[]一起用

Java代码

public PreparedStatement createPreparedStatement(Connection con) throws SQLException {
return con.prepareStatement(sql);
}

 public PreparedStatement createPreparedStatement(Connection con) throws SQLException {
return con.prepareStatement(sql);
}

1.增删改
org.springframework.jdbc.core.JdbcTemplate 类(必须指定数据源dataSource)

Java代码

template.update("insert into web_person values(?,?,?)",Object[]);

 template.update("insert into web_person values(?,?,?)",Object[]);

或

Java代码

template.update("insert into web_person values(?,?,?)",new PreparedStatementSetter(){ 匿名内部类只能访问外部最终局部变量
public void setValues(PreparedStatement ps) throws SQLException {
ps.setInt(index++,3);
});

 template.update("insert into web_person values(?,?,?)",new PreparedStatementSetter(){ 匿名内部类 只能访问外部最终局部变量
public void setValues(PreparedStatement ps) throws SQLException {
ps.setInt(index++,3);
});

org.springframework.jdbc.core.PreparedStatementSetter 接口处理预编译SQL

Java代码

public void setValues(PreparedStatement ps) throws SQLException {
ps.setInt(index++,3);
}

 public void setValues(PreparedStatement ps) throws SQLException {
ps.setInt(index++,3);
}

2.查询JdbcTemplate.query(String,[Object[]/PreparedStatementSetter],RowMapper/RowCallbackHandler)
org.springframework.jdbc.core.RowMapper 记录映射接口处理结果集

Java代码

public Object mapRow(ResultSet rs, int arg1) throws SQLException { int表当前行数
person.setId(rs.getInt("id"));
}
List template.query("select * from web_person where id=?",Object[],RowMapper);

 public Object mapRow(ResultSet rs, int arg1) throws SQLException {   int表当前行数
person.setId(rs.getInt("id"));
}
List template.query("select * from web_person where id=?",Object[],RowMapper);

org.springframework.jdbc.core.RowCallbackHandler 记录回调管理器接口处理结果集

Java代码

template.query("select * from web_person where id=?",Object[],new RowCallbackHandler(){
public void processRow(ResultSet rs) throws SQLException {
person.setId(rs.getInt("id"));
});

posted @ 2009-05-26 15:06 jiafang83| 编辑收藏

DecimalFormat 格式化十进制数字

DecimalFormat 是 NumberFormat 的一个具体子类，用于格式化十进制数字。该类设计有各种功能，使其能够分析和格式化任意语言环境中的数，包括对西方语言、阿拉伯语和印度语数字的支持。它还支持不同类型的数，包括整数 (123)、定点数 (123.4)、科学记数法表示的数 (1.23E4)、百分数 (12%) 和金额 ($123)。所有这些内容都可以本地化。

截取double类型的小数位：
2

public class Test {
3

public static void main(String[] args){
4

double a = 1.999999999999;
5

//保留a的两位小数，注意不是四舍五入
6

DecimalFormat df = new DecimalForma("#.00");
7

a = Double.parseDouble(df.format(a));//format方法返回的是字符串类型
8

System.out.println(a);
9

}
10

}

posted @ 2009-04-16 09:04 jiafang83 阅读(241) | 评论 (0) | 编辑收藏

web打印杂谈

转载：
1.web打印控件的三种实现方法：http://www.blogjava.net/midstr/archive/2009/03/13/256597.html ----“岁月如歌”的博客
2.IEWebBrowser组件的execWB方法：http://dev.csdn.net/article/16/16938.shtm ------haley_hj 的 Blog
3.WEB打印大全：http://www.fangxun.net/tech/techfile/prog/asp/200610/2612.htm
4.14个经典的JavaScript代码：http://www.vikecn.com/Skins/Skin3/blogview.asp?153078-27932.html

posted @ 2009-04-15 14:42 jiafang83| 编辑收藏

iframe父窗口和子窗口的调用方法

转载：http://hi.baidu.com/xeelytech/blog/item/b8e42cfdac841d1508244d42.html

iframe 父窗口和子窗口的调用方法
父窗口调用子窗口
iframe_name.iframe_document_object.object_attribute = attribute_value
例子:onClick="iframe_text.myH1.innerText='http://www.pint.com';"
子窗口调用父窗口parent.parent_document_object.object_attribute = attribute_value
例子:onclick="parent.myH1.innerText='http://www.pint.com';"
上面在IE下没有问题，但在firefox下不正常。在firefox下，应该是
父窗口调用子窗口
window.frames["iframe_name"].document.getElementById("iframe_document_object"-).object_attribute = attribute_value
例子
window.frames["iframe_text"].document.getElementById("myH1").innerHTML= "http://www.pint.com";
子窗口调用父窗口
parent.document.getElementById("parent_document_object").object_attribute = attribute_value
例子
parent.document.getElementById("myH1").innerHTML = "http://www.adsf.com";

完整例子：

start.html

<html>

function b(){

alert("父窗口编辑子窗口的内容。。。");

window.frames["floater"].document.getElementById("bb").innerHTML="父窗口改变子窗口内容";

//下句只适合IE浏览器

//floater.bb.innerText="父窗口修改子窗口内容。。。";

}

</script>

<body>

</IFRAME><BR>

</form>

</body>

</html>

one.html

<html>

one.html

</html>

three.html

<html>

function a(){

alert("子窗口编辑父窗口内容parent表示父窗口");

//下句只适合IE浏览器

//parent.aa.innerText="ppppppppppppp";

parent.document.getElementById("aa").innerHTML="修改父窗口内容";

//parent.frames["iframe的名称"].document.getElementById("aa").innerText="修改父窗口内容。。。。";

//子窗口修改父窗口的另一个子窗口的内容

}

</script>

<h1 id="bb">改变父窗口的元素值。</h1>

</body>

</html>

posted @ 2009-03-29 15:53 jiafang83| 编辑收藏

SVN的分支与合并

转载：http://hi.baidu.com/wukongafei/blog/item/9e92e800923eca14728b6596.html

把subversion加入windows服务
sc create svnserver binPath= "E:\Program Files\Subversion\bin\svnserve.exe --service -r E:\cjf\repository" DisplayName= "subversion" depend= Tcpip start= auto

posted @ 2009-03-23 09:01 jiafang83| 编辑收藏

Eclipse中SVN插件的安装

转载：
http://blog.sina.com.cn/s/blog_49ee6e040100awbe.html

posted @ 2009-03-23 09:00 jiafang83| 编辑收藏

删除数组中元素重复次数超过N的元素，然后返回该数组

import java.util.ArrayList;
2

public class Test01 {
4

Test01() { }
6

/**
8

* 除去字符串数组中重复次数超过整数n的数组元素.使用时请使用try{}catch(){}包含.或是使用throws声明抛出异常
9

*/
10

public String[] execute(String[] args, int n) throws Exception {
11

//Arrays.sort(args); // 此行代码可以不使用,使用得话会使数组工整,排序数据.
12

ArrayList<String> list = new ArrayList<String>(args.length);
13

//count变量，记录数组元素的重复次数
14

int count = 0;
15

for (int i = 0; i < args.length; i++) {
16

count = 0;
17

for (int j = 0; j < args.length; j++) {
18

if (args[i].equals(args[j])) {
19

count++;
20

}
21

}
22

//把重复次数小于等于n的数组元素放进集合List中
23

if (count <= n) {
24

list.add(args[i]);
25

}
26

}
28

//新建一个数组，数组的长度为集合list的长度
29

String[] retStrs = new String[list.size()];
30

//然后把集合list的元素按照顺序赋给新建的数组
31

for (int i = 0; i < list.size(); i++) {
32

retStrs[i] = (String) list.get(i);
33

}
34

//返回该数组
35

return retStrs;
36

}
37

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

String[] t = new Test01().execute(new String[] { "aaaaa", "ccccc",
41

"aaaaa", "aaaaa", "ccccc", "ddddd", "ddddd", "eeeee", "aaaaa",
42

"fffff", "ddddd", "fffff", "ddddd" }, 3);
43

for (String x : t) {
44

System.out.println(x);
45

}
46

}
47

}

posted @ 2009-03-11 21:17 jiafang83 阅读(672) | 评论 (0) | 编辑收藏

Eclipse插件的安装

转载：http://zhidao.baidu.com/question/35054792.html

Eclipse插件的安装有两种方法

1、在eclipse的主目录（ECLIPSE_HOME，比如在我的机器上安装的目录是：D:\JavaDev\3.1）有一个plugins的目录，这种方法的插件安装非常简单，只要将插件copy到这个目录下就可以了。比如我有一个weblogic的插件（bea站点上可以下载），解压缩之后得到得到一个目录：【com.bea.eclipse.weblogic_1.1.1】，我就将这个目录直接放到%ECLIPSE_HOME%\plugins目录下，重新启动eclipse之后就看到Run->“Start Weblogic”的菜单。安装之后，weblogic插件的全路径为：D:\JavaDev\3.1\plugins\com.bea.eclipse.weblogic_1.1.1]

2、在eclipse目录（ECLIPSE_HOME）下创建一个links目录，然后将你自己的插件放在你想放的任何地方，这个时候你放插件的目录我称她为插件目录（PLUGIN_HOME），然后在你的%ECLIPSE_HOME%\links\目录下创建一个link文件，比如我要安装一个vss插件，我就在我的links目录下创建了：VSS_1.6.1.link文件。而这个VSS_1.6.1.link文件则是指向的我的插件目录（PLUGIN_HOME，比如在我的机器上插件目录为D:\JavaDev\plugins）。VSS_1.6.1.link文件的内容是：

path=D:\\JavaDev\\plugins\\vssplugin_1.6.1

第二种安装插件的时候需要注意，如果你是一个单独的jar文件，则最好在link文件指定的目录下创建这样级别的目录：eclipse\plugins\xxx.xxx（插件名称和版本号），然后将jar文件放在这个目录下即可。比如vss插件在我的机器上的目录是D:\JavaDev\plugins\vssplugin_1.6.1\eclipse\plugins\org.vssplugin_1.6.1，下有一个文件：vssplugin.jar

两种方法的插件安装之后需要重新启动eclipse才能看到插件。如果某一个插件已经安装了想要重新安装，只要将文件替换或者修改link文件的路径即可。如果发现认不到插件，可能是你的插件不支持你的当前eclipse版本，请检查。也有可能是系统配置引起的，我出现过一次，我的解决方法是将ECLIPSE_HOME下的configuration目录下的所有文件删除，剩下config.ini文件。

13.Eclipse插件使用links目录的用法：
假设把插件安装在d:\myplugin目录中，则myplugin的目录结构一定要是这样的：
d:\\myplugin\\eclipse\\plugins\\插件及 d:\\myplugin\\eclipse\\features\\插件
例如安装EclipseME插件到d:\myplugin目录中，则目录结构

d:\\myplugin\\eclipse\\plugins\\eclipseme_0.4.5。
再假设eclipse安装在d:\eclipse目录中，则在eclipse目录中创建名称为links的目录，在links目

录中建立一个link文件，比如myplugin.link，该文件内容为path=d:\\myplugin。
启动eclipse，插件即安装上了，如果想暂时不启动插件，只需把myplugin.link文件删除即可。
补充说明：
1. 插件可以分别安装在多个自定义的目录中。
2. 一个自定义目录可以安装多个插件。
3. link文件的文件名及扩展名可以取任意名称，比如myplugin.txt，goodplugin都可以。
4. link文件可以有多行path=插件目录，对应多个自定义插件目录，每一行的path参数都将生效。
5. 在links目录也可以有多个link文件，每个link文件中的path参数都将生效。
6. 插件目录可以使用相对路径，如果我们把myplugin目录创建在eclipse安装目录中，如上例中的

d:\eclipse目录中，则只需设置path=myplugin即可。

posted @ 2009-02-18 21:36 jiafang83 阅读(134) | 评论 (0) | 编辑收藏

四种操作XML的方式比较

http://hi.baidu.com/menglinxi%5Fa/blog/item/cf492e4532f85821cffca383.html

1. 介绍

1）DOM(JAXP Crimson解析器)
DOM是用与平台和语言无关的方式表示XML文档的官方W3C标准。DOM是以层次结构组织的节点或信息片断的集合。这个层次结构允许开发人员在树中寻找特定信息。分析该结构通常需要加载整个文档和构造层次结构，然后才能做任何工作。由于它是基于信息层次的，因而DOM被认为是基于树或基于对象的。DOM以及广义的基于树的处理具有几个优点。首先，由于树在内存中是持久的，因此可以修改它以便应用程序能对数据和结构作出更改。它还可以在任何时候在树中上下导航，而不是像SAX那样是一次性的处理。DOM使用起来也要简单得多。

2）SAX

SAX处理的优点非常类似于流媒体的优点。分析能够立即开始，而不是等待所有的数据被处理。而且，由于应用程序只是在读取数据时检查数据，因此不需要将数据存储在内存中。这对于大型文档来说是个巨大的优点。事实上，应用程序甚至不必解析整个文档；它可以在某个条件得到满足时停止解析。一般来说，SAX还比它的替代者DOM快许多。
　　选择DOM还是选择SAX？对于需要自己编写代码来处理XML文档的开发人员来说，选择DOM还是SAX解析模型是一个非常重要的设计决策。 DOM采用建立树形结构的方式访问XML文档，而SAX采用的事件模型。

　　DOM解析器把XML文档转化为一个包含其内容的树，并可以对树进行遍历。用DOM解析模型的优点是编程容易，开发人员只需要调用建树的指令，然后利用navigation APIs访问所需的树节点来完成任务。可以很容易的添加和修改树中的元素。然而由于使用DOM解析器的时候需要处理整个XML文档，所以对性能和内存的要求比较高，尤其是遇到很大的XML文件的时候。由于它的遍历能力，DOM解析器常用于XML文档需要频繁的改变的服务中。

　　SAX解析器采用了基于事件的模型，它在解析XML文档的时候可以触发一系列的事件，当发现给定的tag的时候，它可以激活一个回调方法，告诉该方法制定的标签已经找到。SAX对内存的要求通常会比较低，因为它让开发人员自己来决定所要处理的tag。特别是当开发人员只需要处理文档中所包含的部分数据时，SAX这种扩展能力得到了更好的体现。但用SAX解析器的时候编码工作会比较困难，而且很难同时访问同一个文档中的多处不同数据。

3）JDOM http://www.jdom.org/

JDOM的目的是成为Java特定文档模型，它简化与XML的交互并且比使用DOM实现更快。由于是第一个Java特定模型，JDOM一直得到大力推广和促进。正在考虑通过“Java规范请求JSR-102”将它最终用作“Java标准扩展”。从2000年初就已经开始了JDOM开发。

　　JDOM与DOM主要有两方面不同。首先，JDOM仅使用具体类而不使用接口。这在某些方面简化了API，但是也限制了灵活性。第二，API大量使用了Collections类，简化了那些已经熟悉这些类的Java开发者的使用。

　　JDOM文档声明其目的是“使用20%(或更少)的精力解决80%(或更多)Java/XML问题”(根据学习曲线假定为20%)。JDOM对于大多数Java/XML应用程序来说当然是有用的，并且大多数开发者发现API比DOM容易理解得多。JDOM还包括对程序行为的相当广泛检查以防止用户做任何在XML中无意义的事。然而，它仍需要您充分理解XML以便做一些超出基本的工作(或者甚至理解某些情况下的错误)。这也许是比学习DOM或JDOM接口都更有意义的工作。

　　JDOM自身不包含解析器。它通常使用SAX2解析器来解析和验证输入XML文档(尽管它还可以将以前构造的DOM表示作为输入)。它包含一些转换器以将JDOM表示输出成SAX2事件流、DOM模型或XML文本文档。JDOM是在Apache许可证变体下发布的开放源码。

4）DOM4J http://dom4j.sourceforge.net/

虽然DOM4J代表了完全独立的开发结果，但最初，它是JDOM的一种智能分支。它合并了许多超出基本XML文档表示的功能，包括集成的XPath支持、XML Schema支持以及用于大文档或流化文档的基于事件的处理。它还提供了构建文档表示的选项，它通过DOM4J API和标准DOM接口具有并行访问功能。从2000下半年开始，它就一直处于开发之中。

　　为支持所有这些功能，DOM4J使用接口和抽象基本类方法。DOM4J大量使用了API中的Collections类，但是在许多情况下，它还提供一些替代方法以允许更好的性能或更直接的编码方法。直接好处是，虽然DOM4J付出了更复杂的API的代价，但是它提供了比JDOM大得多的灵活性。

　　在添加灵活性、XPath集成和对大文档处理的目标时，DOM4J的目标与JDOM是一样的：针对Java开发者的易用性和直观操作。它还致力于成为比JDOM更完整的解决方案，实现在本质上处理所有Java/XML问题的目标。在完成该目标时，它比JDOM更少强调防止不正确的应用程序行为。

　　DOM4J是一个非常非常优秀的Java XML API，具有性能优异、功能强大和极端易用使用的特点，同时它也是一个开放源代码的软件。如今你可以看到越来越多的Java软件都在使用DOM4J来读写XML，特别值得一提的是连Sun的JAXM也在用DOM4J。

2.. 比较

1）DOM4J性能最好，连Sun的JAXM也在用DOM4J。目前许多开源项目中大量采用DOM4J，例如大名鼎鼎的Hibernate也用DOM4J来读取XML配置文件。如果不考虑可移植性，那就采用DOM4J.

2）JDOM和DOM在性能测试时表现不佳，在测试10M文档时内存溢出。在小文档情况下还值得考虑使用DOM和JDOM。虽然JDOM的开发者已经说明他们期望在正式发行版前专注性能问题，但是从性能观点来看，它确实没有值得推荐之处。另外，DOM仍是一个非常好的选择。DOM实现广泛应用于多种编程语言。它还是许多其它与XML相关的标准的基础，因为它正式获得W3C推荐(与基于非标准的Java模型相对)，所以在某些类型的项目中可能也需要它(如在JavaScript中使用DOM)。

3）SAX表现较好，这要依赖于它特定的解析方式－事件驱动。一个SAX检测即将到来的XML流，但并没有载入到内存(当然当XML流被读入时，会有部分文档暂时隐藏在内存中)。

3. 四种xml操作方式的基本使用方法

xml文件：

<?xml version="1.0" encoding="utf-8" ?>
<Result>
   <VALUE>
       <NO DATE="2005">A1</NO>
       <ADDR>GZ</ADDR>
   </VALUE>
   <VALUE>
       <NO DATE="2004">A2</NO>
       <ADDR>XG</ADDR>
</VALUE>
</Result>

1）DOM

import java.io.*;
import java.util.*;
import org.w3c.dom.*;
import javax.xml.parsers.*;

public class MyXMLReader{
　public static void main(String arge[]){

　　long lasting =System.currentTimeMillis();
　　try{
　　　File f=new File("data_10k.xml");
　　　DocumentBuilderFactory factory=DocumentBuilderFactory.newInstance();
　　　DocumentBuilder builder=factory.newDocumentBuilder();
　　　Document doc = builder.parse(f);
　　　NodeList nl = doc.getElementsByTagName("VALUE");
　　　for (int i=0;i＜nl.getLength();i++){
　　　　System.out.print("车牌号码:" + doc.getElementsByTagName("NO").item(i).getFirstChild().getNodeValue());
　　　　System.out.println("车主地址:" + doc.getElementsByTagName("ADDR").item(i).getFirstChild().getNodeValue());
　　}
　　}catch(Exception e){
　　　e.printStackTrace();
}

2）SAX

import org.xml.sax.*;
import org.xml.sax.helpers.*;
import javax.xml.parsers.*;

public class MyXMLReader extends DefaultHandler {

　java.util.Stack tags = new java.util.Stack();
　public MyXMLReader() {
　　super();
}

　public static void main(String args[]) {
　　long lasting = System.currentTimeMillis();
　　try {
　　　SAXParserFactory sf = SAXParserFactory.newInstance();
　　　SAXParser sp = sf.newSAXParser();
　　　MyXMLReader reader = new MyXMLReader();
　　　sp.parse(new InputSource("data_10k.xml"), reader);
　　} catch (Exception e) {
　　　e.printStackTrace();
　　}

　　System.out.println("运行时间：" + (System.currentTimeMillis() - lasting) + "毫秒");}
　　public void characters(char ch[], int start, int length) throws SAXException {
　　String tag = (String) tags.peek();
　　if (tag.equals("NO")) {
　　　System.out.print("车牌号码：" + new String(ch, start, length));
    }
    if (tag.equals("ADDR")) {
　　System.out.println("地址:" + new String(ch, start, length));
    }
   }

　　public void startElement(String uri,String localName,String qName,Attributes attrs) {
　　tags.push(qName);}
}

3） JDOM

import java.io.*;
import java.util.*;
import org.jdom.*;
import org.jdom.input.*;

public class MyXMLReader {

　public static void main(String arge[]) {
　　long lasting = System.currentTimeMillis();
　　try {
　　　SAXBuilder builder = new SAXBuilder();
　　　Document doc = builder.build(new File("data_10k.xml"));
　　　Element foo = doc.getRootElement();
　　　List allChildren = foo.getChildren();
　　　for(int i=0;i＜allChildren.size();i++) {
　　　　System.out.print("车牌号码:" + ((Element)allChildren.get(i)).getChild("NO").getText());
　　　　System.out.println("车主地址:" + ((Element)allChildren.get(i)).getChild("ADDR").getText());
　　　}
　　} catch (Exception e) {
　　　e.printStackTrace();
}

}

4）DOM4J

import java.io.*;
import java.util.*;
import org.dom4j.*;
import org.dom4j.io.*;

public class MyXMLReader {

　public static void main(String arge[]) {
　　long lasting = System.currentTimeMillis();
　　try {
　　　File f = new File("data_10k.xml");
　　　SAXReader reader = new SAXReader();
　　　Document doc = reader.read(f);
　　　Element root = doc.getRootElement();
　　　Element foo;
　　　for (Iterator i = root.elementIterator("VALUE"); i.hasNext();) {
　　　　foo = (Element) i.next();
　　　　System.out.print("车牌号码:" + foo.elementText("NO"));
　　　　System.out.println("车主地址:" + foo.elementText("ADDR"));
　　　}
　　} catch (Exception e) {
　　　e.printStackTrace();
}
}

posted @ 2009-02-18 21:27 jiafang83 阅读(333) | 评论 (1) | 编辑收藏

Dom4j的下载及使用

http://hi.baidu.com/lc2tp/blog/item/477c3601aac1ca011c9583dc.html

要使用dom4j读写XML文档,需要先下载dom4j包,dom4j官方网站在 http://www.dom4j.org/
目前最新dom4j包下载地址:http://nchc.dl.sourceforge.net/sourceforge/dom4j/dom4j-1.6.1.zip

解开后有两个包,仅操作XML文档的话把dom4j-1.6.1.jar加入工程就可以了,如果需要使用XPath的话还需要加入包jaxen-1.1-beta-7.jar.

以下是相关操作:

一.Document对象相关

1.读取XML文件,获得document对象.
SAXReader reader = new SAXReader();
Document document = reader.read(new File("input.xml"));

2.解析XML形式的文本,得到document对象.
            String text = "<members></members>";
            Document document = DocumentHelper.parseText(text);
3.主动创建document对象.
            Document document = DocumentHelper.createDocument();
            Element root = document.addElement("members");// 创建根节点
二.节点相关

1.获取文档的根节点.
Element rootElm = document.getRootElement();
2.取得某节点的单个子节点.
Element memberElm=root.element("member");// "member"是节点名
3.取得节点的文字
String text=memberElm.getText();
也可以用:
String text=root.elementText("name");这个是取得根节点下的name字节点的文字.

4.取得某节点下名为"member"的所有字节点并进行遍历.
List nodes = rootElm.elements("member");

for (Iterator it = nodes.iterator(); it.hasNext();) {
   Element elm = (Element) it.next();
   // do something
}
5.对某节点下的所有子节点进行遍历.
            for(Iterator it=root.elementIterator();it.hasNext();){
                Element element = (Element) it.next();
                // do something
            }
6.在某节点下添加子节点.
Element ageElm = newMemberElm.addElement("age");
7.设置节点文字.
ageElm.setText("29");
8.删除某节点.
parentElm.remove(childElm);// childElm是待删除的节点,parentElm是其父节点
三.属性相关.
1.取得某节点下的某属性
            Element root=document.getRootElement();
            Attribute attribute=root.attribute("size");// 属性名name
2.取得属性的文字
            String text=attribute.getText();
也可以用:
String text2=root.element("name").attributeValue("firstname");这个是取得根节点下name字节点的属性firstname的值.

3.遍历某节点的所有属性
            Element root=document.getRootElement();
            for(Iterator it=root.attributeIterator();it.hasNext();){
                Attribute attribute = (Attribute) it.next();
                String text=attribute.getText();
                System.out.println(text);
            }
4.设置某节点的属性和文字.
newMemberElm.addAttribute("name", "sitinspring");
5.设置属性的文字
            Attribute attribute=root.attribute("name");
            attribute.setText("sitinspring");
6.删除某属性
            Attribute attribute=root.attribute("size");// 属性名name
            root.remove(attribute);
四.将文档写入XML文件.
1.文档中全为英文,不设置编码,直接写入的形式.
XMLWriter writer = new XMLWriter(new FileWriter("output.xml"));
writer.write(document);
writer.close();
2.文档中含有中文,设置编码格式写入的形式.
            OutputFormat format = OutputFormat.createPrettyPrint();
            format.setEncoding("GBK");    // 指定XML编码
            XMLWriter writer = new XMLWriter(new FileWriter("output.xml"),format);

            writer.write(document);
            writer.close();
五.字符串与XML的转换
1.将字符串转化为XML
String text = "<members> <member>sitinspring</member> </members>";
Document document = DocumentHelper.parseText(text);
2.将文档或节点的XML转化为字符串.
            SAXReader reader = new SAXReader();
            Document document = reader.read(new File("input.xml"));
            Element root=document.getRootElement();
            String docXmlText=document.asXML();
            String rootXmlText=root.asXML();
            Element memberElm=root.element("member");
            String memberXmlText=memberElm.asXML();
六.使用XPath快速找到节点.
读取的XML文档示例
<?xml version="1.0" encoding="UTF-8"?>
<projectDescription>
<name>MemberManagement</name>
<comment></comment>
<projects>
    <project>PRJ1</project>
    <project>PRJ2</project>
    <project>PRJ3</project>
    <project>PRJ4</project>
</projects>
<buildSpec>
    <buildCommand>
      <name>org.eclipse.jdt.core.javabuilder</name>
      <arguments>
      </arguments>
    </buildCommand>
</buildSpec>
<natures>
    <nature>org.eclipse.jdt.core.javanature</nature>
</natures>
</projectDescription>

使用XPath快速找到节点project.
public static void main(String[] args){
    SAXReader reader = new SAXReader();

    try{
      Document doc = reader.read(new File("sample.xml"));

      List projects=doc.selectNodes("/projectDescription/projects/project");

      Iterator it=projects.iterator();

      while(it.hasNext()){
        Element elm=(Element)it.next();
        System.out.println(elm.getText());
      }

    }
    catch(Exception ex){
       ex.printStackTrace();
    }
}

posted @ 2009-02-18 21:25 jiafang83 阅读(1024) | 评论 (1) | 编辑收藏

常用链接

留言簿(5)

随笔档案

文章档案

常用链接

我的好友

搜索

最新评论

阅读排行榜

评论排行榜

安装 Hibernate Annotation

第一个持久性类

生成主键

定制表和字段映射

映射关系

命名查询

结束语