posts - 55,comments - 89,trackbacks - 0
oracle 10g默认需要微软的网络适配器配置。新建一个就行了。
方法,打开控制面板,选者添加硬件—选择是,我已经连接了此硬件,下一步选者最后一项添加新的硬件设备,下一步选择 安装我手动从列表选者的硬件(高级),下一步选者网络适配器,下一步选者Microsoft Loopback
Adapter,按向导提示下一步就行了。完成以后打开你的网上邻居看看是不是多了一个网上连接(2),然后设置它的IP地址如。192.168.1.1.随便就行了,这样在安装oracle的时候就可以用这一个假的网络来连接,蒙骗一下 oracle了。一定可以验证过去
posted @ 2012-08-18 13:38 jiafang83 阅读(740) | 评论 (0)编辑 收藏
    摘自: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 阅读(234) | 评论 (0)编辑 收藏
摘自:http://www.javaeye.com/topic/95822

school和userMember是一对多关系:

SchoolInfo.java

 1import javax.persistence.CascadeType;   
 2import javax.persistence.Column;   
 3import javax.persistence.Entity;   
 4import javax.persistence.FetchType;   
 5import javax.persistence.GeneratedValue;   
 6import javax.persistence.Id;   
 7import javax.persistence.OneToMany;   
 8import javax.persistence.Table;   
 9import javax.persistence.Temporal;   
10import javax.persistence.TemporalType;   
11   
12import org.hibernate.annotations.Formula;   
13import org.hibernate.annotations.GenericGenerator;   
14   
15@Entity   
16@Table(name = "school_info")   
17public class SchoolInfo implements java.io.Serializable {   
18   
19    @Id   
20    @GeneratedValue(generator = "system-uuid")   
21    @GenericGenerator(name = "system-uuid", strategy = "uuid")   
22    private String id;//hibernate的uuid机制,生成32为字符串   
23   
24    @Column(name = "actcodeId", updatable = false, nullable = true, length = 36)   
25    private String actcodeId;   
26   
27    @Formula("select COUNT(*) from school_info")   
28    private int count;   
29   
30    @Temporal(TemporalType.TIMESTAMP)//不用set,hibernate会自动把当前时间写入   
31    @Column(updatable = false, length = 20)   
32    private Date createTime;   
33   
34    @Temporal(TemporalType.TIMESTAMP)   
35    private Date updateTime;// 刚开始我默认insertable=false,但会读取出错提示如下:   
36    // Value '0000-00-00' can not be represented as java.sql.Timestamp   
37   
38    // 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       
44}
   
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 阅读(2992) | 评论 (1)编辑 收藏
转载: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 阅读(210) | 评论 (0)编辑 收藏
     转载: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/fmt-rt</taglib-uri>
        <taglib-location>/WEB-INF/fmt-rt.tld</taglib-location>
    </taglib>

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

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

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

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

    <taglib>
        <taglib-uri>http://java.sun.com/jstl/x</taglib-uri>
        <taglib-location>/WEB-INF/x.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 阅读(718) | 评论 (0)编辑 收藏

    转载: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>    .

    <script>
    function test()
    {
      alert("test");
      return false();
    }
    </script>

    </head>

    <body>
    1, <a href='a.JSP' onclick='test();'>超级链接 </a>
    2, <input type="button" onclick='test()' value="提交">
    3, <form name="form1"  onsubmIT="return test();">
    内容
    <input type="submIT" value="提交">
    </form>
    </body>

    <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 也是很重要的。比如:

     <input type="submit" onclick="submitAction(); 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">  
    <!--  
        function submitTest(); {  
            // 一些逻辑判断  
         return false;  
        }  
    //-->  
    </SCRIPT> 

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

    <SCRIPT LANGUAGE="JavaScript">
    <!--
        function submitTest(); {
            // 一些逻辑判断
         return false;
        }
    //-->
    </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();;"> 

    <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 阅读(1226) | 评论 (0)编辑 收藏

    一、 简单的对比

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

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

    例:

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


    <input type="text" name="test" value="1" />
    <input type="text" name="test" value="2" />
    <input type="text" name="test" value="3" />

    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 阅读(600) | 评论 (0)编辑 收藏

    转载: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 阅读(9337) | 评论 (2)编辑 收藏
         摘要:   阅读全文
    posted @ 2009-06-08 14:28 jiafang83 阅读(1654) | 评论 (3)编辑 收藏
    仅列出标题  下一页