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"
 "

<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>