My-java-spark

<script>
        function window.onbeforeunload()  {
                if (event.clientX > document.body.clientHeight || event.clientY < 0 || event.altKey)  {
                      alert("That's good.");
                }
        }
</script>
 

<--------屏蔽F5、Alt＋F4的错-------->

<script>
        function window.onbeforeunload()  {

                if((event.keyCode != 0) && (event.clientX > document.body.clientHeight || event.clientY < 0) || event.altKey)  {

                      alert("That's good.");
                }
        }
</script>

需求分析的主要方法是用例(use-case).
系统级别的需求其实就是系统的参与者们所要达到的目标，每一个目标就是一个用例。用例就是参与者参与活动的场景描述。
每个用例参与者有三种，主要参与者，次要参与者和后台参与者。用例为其工作的参与者就是主要参与者，为用例提供服务的参与者就是次要参与者，用例结果产生影响的参与者是后台参与者。
用例一般有前置条件和后置条件，当前置条件为真时，用例才开始运作，当用例顺利完成，用例的后置条件为真。用例主要描述活动执行的“欢乐路径”，如果在某一步有异常情况则到用例扩展中去说明。
如果多个用例中有重复的部分，则可以提取成一个子用例。

JDBC隔离级别	特征
TRANSACTION_READ_UNCOMMITTED 未提交的读操作	允许读取有写锁定或无写锁定的行 未应用读锁定 无法确保并发事务将不会修改行或回退对行所做的更改
TRANSACTION_READ_COMMITTED 已提交的读操作	只允许读取没有写锁定的行 仅为读取当前行获取并保持读锁定，但当游标离开该行时释放读锁定 无法确保数据在事务执行过程中不发生更改
TRANSACTION_REPEATABLE_READ 可重复的读操作	只允许读取没有写锁定的行 读取结果集中的每一行时获取读锁定，并一直保持到事务结束为止
TRANSACTION_SERIALIZABLE 可序列化	只允许读取结果中没有写锁定的行 打开游标时获取读锁定，并一直保持到事务结束为止

   Spring为应用程序提供一个容器, 为应用程序的管理带来了方便. 它与hibernate的结合, 形成一个完整的后台体系, 也是当今应用开发流行的做法. 奋斗了一个晚上, 终于把hibernate3与spring整合了起来, hibernate2.x和hibernate3与spring的结合稍有不同, 关键是引入的spring的包的不同, 下面我会标识出来.

Spring 的配置文件applicationContext.xml

一个示例的hibernate的映射文件

DAO代码:

示意性的测试代码:

       Hibernate的动态模型为我们动态改动表结构带来了方便, 个人认为这一点非常有价值, 现在的企业级应用系统越来越强调用户可定制性, hibernate的这一点使用户自定义字段或自定义表成为可能 .
关于动态模型, 我还是把hibernate自带的测试用例贴到这里, 用以备忘.

java代码:

//$Id: DynamicClassTest.java,v 1.4 2005/03/06 16:31:24 oneovthafew Exp $
package org.hibernate.test.dynamic;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

import junit.framework.Test;
import junit.framework.TestSuite;

import org.hibernate.EntityMode;
import org.hibernate.Hibernate;
import org.hibernate.Session;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;
import org.hibernate.cfg.Environment;
import org.hibernate.test.TestCase;

/**
 * @author Gavin King
 */
public class DynamicClassTest extends TestCase {
 
 public DynamicClassTest(String str) {
  super(str);
 }

 protected void configure(Configuration cfg) {
  cfg.setProperty(Environment.DEFAULT_ENTITY_MODE, EntityMode.MAP.toString());
 }

 public void testLazyDynamicClass() {
  Session s = openSession();
  assertTrue( "Incorrectly handled default_entity_mode", s.getEntityMode() == EntityMode.MAP );
  Session other = s.getSession( EntityMode.MAP );
  assertEquals( "openSession() using same entity-mode returned new session", s, other );

  other = s.getSession( EntityMode.POJO );
  other.close();
  assertTrue( !other.isOpen() );
  assertTrue( other.isConnected() );  // because it is linked to the "root" session's connection

  s.close();

  s = openSession();
  Transaction t = s.beginTransaction();

  Map cars = new HashMap();
  cars.put("description", "Cars");
  Map monaro = new HashMap();
  monaro.put("productLine", cars);
  monaro.put("name", "monaro");
  monaro.put("description", "Holden Monaro");
  Map hsv = new HashMap();
  hsv.put("productLine", cars);
  hsv.put("name", "hsv");
  hsv.put("description", "Holden Commodore HSV");
  List models = new ArrayList();
  cars.put("models", models);
  models.add(hsv);
  models.add(monaro);
  s.save("ProductLine", cars);
  t.commit();
  s.close();

  s = openSession();
  t = s.beginTransaction();
  
  cars = (Map) s.createQuery("from ProductLine pl order by pl.description").uniqueResult();
  models = (List) cars.get("models");
  assertFalse( Hibernate.isInitialized(models) );
  assertEquals( models.size(), 2);
  assertTrue( Hibernate.isInitialized(models) );
  
  s.clear();
  
  List list = s.createQuery("from Model m").list();
  for ( Iterator i=list.iterator(); i.hasNext(); ) {
   assertFalse( Hibernate.isInitialized( ( (Map) i.next() ).get("productLine") ) );
  }
  Map model = (Map) list.get(0);
  assertTrue( ( (List) ( (Map) model.get("productLine") ).get("models") ).contains(model) );
  s.clear();
  
  t.commit();
  s.close();

  s = openSession();
  t = s.beginTransaction();
  cars = (Map) s.createQuery("from ProductLine pl order by pl.description").uniqueResult();
  s.delete(cars);
  t.commit();
  s.close();
 }

 protected String[] getMappings() {
  return new String[] { "dynamic/ProductLine.hbm.xml" };
 }

 public static Test suite() {
  return new TestSuite(DynamicClassTest.class);
 }

}

配置文件:

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
 "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
 "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">

<hibernate-mapping>

<!--

  This mapping demonstrates "dynamic" entities.
    
-->

 <class entity-name="ProductLine">

     <id name="id"
      column="productId"
      length="32"
      type="string">
      <generator class="uuid.hex"/>
     </id>

     <property name="description"
      not-null="true"
      length="200"
      type="string"/>

     <!-- don't use sets for associations, unless you want stack overflows! -->
     <!--这一点要特别小心, 我刚开始做试验的时候用的就是Set, 结果抛出 stack overflows异常, 害的我两个小时搞不定, 最后还是看了这个test, 才知道用这样的限制-->
     <bag name="models"
       cascade="all"
       inverse="true">
      <key column="productId"/>
      <one-to-many class="Model"/>
     </bag>

 </class>

    <class entity-name="Model">

     <id name="id"
      column="modelId"
      length="32"
      type="string">
      <generator class="uuid.hex"/>
     </id>
     
     <property name="name"
      not-null="true"
      length="25"
      type="string"/>
      
     <property name="description"
      not-null="true"
      length="200"
      type="string"/>
     
     <many-to-one name="productLine"
      column="productId"
      not-null="true"
      class="ProductLine"/>
     
 </class>

</hibernate-mapping>