#1 Transaction Propagation Behavior
Required:Excute within a current tx, create a new one if none exists.
Supports: Excute within a current tx, execute without a tx if none exsits.
Mandatory: Excute within a current tx, throw an exception if none exists.
Requires New: Create a new tx and excute within the tx, suspend the current tx if one exists.
Not Supported: Excute without a tx, suspend the current tx if none exsits.
Never: Excute without a tx, throw an exception if a tx exsits.

#2 Transaction Isolation Level[1]
#2.1 Concurrent Problem
Dirty Reads: 脏读（脏数据指已更新，还没提交的数据）。事务T1读取到事务T2中的脏数据。

Unrepeatable Reads: 不可重复读。事务T1检索到某行后，事务T2更新并提交了该行，若事务T2再次检索该行，则会看到不一样的结果。

Phantom Reads: 虚读。事务T1检索到符合某条件的行集后，事务T2插入并提交了满足该条件的新行，若事务T2再次按该条件检索，则会看到以前不存在的行“Phantom”。

#2.2 Isolation Level
+---------------+-------+------------------+-----------+
|Isolation Level|Phantom|Unrepeatable Reads|Dirty Reads|
+---------------+-------+------------------+-----------+
|Read Uncommited|   Y   |         Y        |     Y     |
+---------------+-------+------------------+-----------+
|Read Commited  |   Y   |         Y        |     N     |
+---------------+-------+------------------+-----------+
|Repeatable Read|   Y   |         N        |     N     |
+---------------+-------+------------------+-----------+
|Serializable   |   N   |         N        |     N     |
+---------------+-------+------------------+-----------+

#3 Timeout

#4 ReadOnly Transaction
只读事务保证了多条查询SQL的在事务级别的读一致性。JDBC和数据库会对只读事务做一些优化。

[1] C.J.Date, An Introduction to Database Systems 7th.

#0
MXML优点：使用方便，XML代码简洁易懂
缺点：事件、函数、界面描混在一起。程序规模大了难于开发维护。

#1
Cairngorm框架是iterationtwo推出的号称基于JEE Best Practice的Flex程序开发的light-weight framework。(恩,light-weight这个词还真是流行呢)。目前最新版本为0.99。

Cairngorm的结构如下：
org
└─nevis
    └─cairngorm
        ├─application
        │      CairngormApplication.as
        │
        ├─business
        │      Responder.as
        │      ServiceLocator.as
        │
        ├─commands
        │      Command.as
        │      SequenceCommand.as
        │
        ├─control
        │      Event.as
        │      EventBroadcaster.as
        │      FrontController.as
        │
        ├─model
        │      ModelLocator.as
        │
        ├─view
        │      ViewHelper.as
        │      ViewLocator.as
        │
        └─vo
                ValueObject.as

#2
下面给大家简单介绍Cairngorm的实现思路。

#2.1
Command/FrontController将Event与Viwe分离。
FrontController实现Singleton模式(以下简写为SP)。所有自定义的Command在要在FrontController构造函数中实例化并以关联数组的方式注册FrontController#addCommand(eventType:String, commandInstance:Command)。EventBroadcaster实现SP。Event类的结构为{type:eventType, data:eventData}。我们通过EventBroadcaster#broadcastEvent(eventType:String, eventData:Object)发布Event。Event发布后,与eventType对应的command instance执行Command#execute(event:Event)。

BTW：在Cairngorm的源码中，eventType、commandName、eventName混用，我统一用eventType。

#2.2
ServiceLocator将Remote Service声明与View分离。
ServiceLocator实现SP。在Cairngorm的demo中，又通过Delegate对象解除Command/Responder和ServiceLocator之间的依赖。这个Delegate做的事情其实意义不大，就是调用ServiceLocator中的Method，设置莫个Responder为相应远程方法的handler。个人觉得无谓地增加了代码量，而且Delegate对象也没实现SP，也就是说我们每次调用一次Remote Service中的Method，都要new一个Delegate对象，实在浪费。

#2.3
ViewLocator/ViewHelper将View（MXML）中夹杂的function与View分离。
ViewHelper有点意思，当一个ViewHelper在某个MXML页面中声明时，如<view:LoginViewHelper id="loginViewHelper" />。ViewHelper能自动取得所在MXML对象的引用，并通过ViewLocator#register(id, this:ViewHelper)将自身注册到ViewLocator中。ViewLocator实现SP。借助ViewLocator/ViewHelper,我们就可以方便的调用不同MXML页面中的方法。

#2.4
ModelLocator是一个marker interface，程序中Model可以放在某个ModelLocator方便调用。

#2.5
ValueObject也是一个marker interface, 基本不需要。

#3
Cairngorm.99给我们开发Flex程序提供了很不错的架构模式,M/V/C/Remote之间可以做到完全解构。但在实际开发时没有必要死扣,代码结构清晰有活力就好。

#0
书和文档上写的都不是特清楚的。自己记下来。

#1 Using a PK association

#1.1 POJO with XDolclet annotation
public class Customer {
 /**
  * @return Returns the shoppingCart.
  * @hibernate.many-to-one cascade="delete" column="shopping_cart_id"
  *  unique="true" foreign-key="FK_SHOPPING_CART__CUSTOMER"
  */
 public ShoppingCart getShoppingCart() {
  return shoppingCart;
 }
}

public class ShoppingCart {
 /**
  * @return Returns the customer.
  * @hibernate.one-to-one property-ref="shoppingCart"
  */
 public Customer getCustomer() {
  return customer;
 }
}

property-ref="shoppingCart" 告诉Hibernate ShoppingCart#customer和Customer#shoppingCart是反向的关系。所以Hibernate知道如何从ShoppingCart#getCustomer中检索到相应的customer对象。取出某个Customer对象时，Hibernate会生成DEBUG SQL:324 - 3中的SQL语句。

#1.2 HBM
Customer.hbm.xml
<many-to-one
    name="shoppingCart"
    class="ShoppingCart"
    cascade="delete"
    outer-join="auto"
    foreign-key="FK_SHOPPING_CART__CUSTOMER"
    column="shopping_cart_id"
/>

ShoppingCart.hbm.xml
<one-to-one
    name="customer"
    class="Customer"
    cascade="none"
    outer-join="auto"
    constrained="false"
    property-ref="shoppingCart"
/>

#1.3 SCHEMA SQL
create table CUSTOMER (
    ID bigint generated by default as identity (start with 1),
    SHOPPING_CART_ID bigint,
    primary key (ID)
)

create table SHOPPING_CART (
    ID bigint generated by default as identity (start with 1)
    primary key (ID)
)

alter table CUSTOMER
    add constraint FK_SHOPPING_CART__CUSTOMER
    foreign key (SHOPPING_CART_ID)
    references SHOPPING_CART

#1.4 Query SQL
DEBUG SQL:324 - 1
select customer0_.ID as ID, customer0_.SHOPPING_CART_ID as SHOPPING2_3_, customer0_.USERNAME as USERNAME3_, customer0_.PWD as PWD3_
from CUSTOMER customer0_
where customer0_.USERNAME=? and customer0_.PWD=?

DEBUG SQL:324 - 2
select shoppingca0_.ID as ID0_, shoppingca0_.TOTAL as TOTAL8_0_
from SHOPPING_CART shoppingca0_
where shoppingca0_.ID=?

DEBUG SQL:324 - 3
select customer0_.ID as ID1_, customer0_.SHOPPING_CART_ID as SHOPPING2_3_1_, customer0_.USERNAME as USERNAME3_1_, customer0_.PWD as PWD3_1_, shoppingca1_.ID as ID0_, shoppingca1_.TOTAL as TOTAL8_0_
from
 CUSTOMER customer0_
 left outer join
 SHOPPING_CART shoppingca1_
 on customer0_.SHOPPING_CART_ID=shoppingca1_.ID
where customer0_.SHOPPING_CART_ID=?

#2 Using a FK association

#2.1 POJO with XDolclet annotation
public class Customer {
 /**
  * @return Returns the shoppingCart.
  * @hibernate.one-to-one cascade="delete"
  */
 public ShoppingCart getShoppingCart() {
  return shoppingCart;
 }
}

public class ShoppingCart {
 /**
  * @return Returns the id.
  * @hibernate.id generator-class="foreign"
  * @hibernate.generator-param name="property" value="customer"
  */
 public Long getId() {
  return id();
 }

 /**
  * @return Returns the customer.
  * @hibernate.one-to-one constrained="true" foreign-key="FK_CUSTOMER__SHOPPING_CART"
  */
 public Customer getCustomer() {
  return customer;
 }
}

constrained="true" 告诉Hibernate ShoppingCart的PK还应该是一个FK，这个FK引用Customer的PK。还需要多做一点工作，声明ShoppingCart的PK生成策略是foreign，对应ShoppingCart#customer。这和上面一句话不是一个意思嘛，FT~~

#2.2 HBM
Customer.hbm.xml
<one-to-one
    name="shoppingCart"
    class="ShoppingCart"
    cascade="delete"
    outer-join="auto"
    constrained="false"
/>

ShoppingCart.hbm.xml
<id
    name="id"
    column="id"
    type="java.lang.Long"
>
    <generator class="foreign">
 <param name="property">customer</param>
    </generator>
</id>

<one-to-one
    name="customer"
    class="Customer"
    cascade="none"
    outer-join="auto"
    constrained="true"
/>

#2.3 SCHEMA SQL
create table CUSTOMER (
    ID bigint generated by default as identity (start with 1),
    primary key (ID)
)

create table SHOPPING_CART (
    ID bigint not null,
    TOTAL integer,
    primary key (ID)
)

alter table SHOPPING_CART
    add constraint FK_CUSTOMER__SHOPPING_CART
    foreign key (ID)
    references CUSTOMER

#2.4 Query SQL
DEBUG SQL:324 -
select customer0_.ID as ID, customer0_.USERNAME as USERNAME3_, customer0_.PWD as PWD3_
from CUSTOMER customer0_
where customer0_.USERNAME=? and customer0_.PWD=?

DEBUG SQL:324 -
select shoppingca0_.ID as ID0_, shoppingca0_.TOTAL as TOTAL8_0_
from SHOPPING_CART shoppingca0_
where shoppingca0_.ID=?

这个“真正”的one-to-one的好处是少条关联SQL语句，看到了吗？

Welcome to the ACM "Hello World" project. Everyone has seen the Hello World program used as a first exposure to a new language or environment. We are attempting to collect examples for as many languages and related programming environments (shells etc.) as possible.

Aproximate number of examples:204     <----wow~~~
This page has been accessed 33274 times.
Last updated: January 20, 2005   


看看C的，经典HelloWorld
#include <stdio.h>
main()
{
  for(;;)
      {
          printf ("Hello World!\n");
      }
}

这也是HelloWolrd？！
a 1986 entry from Bruce Holloway:

#include "stdio.h"
#define e 3
#define g (e/e)
#define h ((g+e)/2)
#define f (e-g-h)
#define j (e*e-g)
#define k (j-h)
#define l(x) tab2[x]/h
#define m(n,a) ((n&(a))==(a))

long tab1[]={ 989L,5L,26L,0L,88319L,123L,0L,9367L };
int tab2[]={ 4,6,10,14,22,26,34,38,46,58,62,74,82,86 };

main(m1,s) char *s; {
    int a,b,c,d,o[k],n=(int)s;
    if(m1==1){ char b[2*j+f-g]; main(l(h+e)+h+e,b); printf(b); }
    else switch(m1-=h){
        case f:
            a=(b=(c=(d=g)<<g)<'<g)<<g;
            return(m(n,a|c)|m(n,b)|m(n,a|d)|m(n,c|d));
        case h:
            for(a=f;a=e)for(b=g<<g;b<n;++b)o[b]=o[b-h]+o[b-g]+c;
            return(o[b-g]%n+k-h);
        default:
            if(m1-=e) main(m1-g+e+h,s+g); else *(s+g)=f;
            for(*s=a=f;a<e;) *s=(*s<<e)|main(h+a++,(char *)m1);
        }
}

曾经最短的HelloWorld（Jari.Arkko@lmf.eua.ericsson.se）
jar.1.c
char*_="Hello world.\n";

ln -s /dev/tty jar.1.o
cc -c jar.1.c


现在最短的HelloWorld （Jyrki Holopainen）
";main(){puts("Hello World!");}char*C=".c  
char*_=__FILE__;

 1<hibernate-mapping package="org.hibernate.auction.model">
 2 <class name="Parent" table="PARENT">
 3  <id name="id" column="PARENT_ID" type="long">
 4   <generator class="native"></generator>
 5  </id>
 6  <set name="children">
 7   <key column="MY_PARENT_ID" />
 8   <one-to-many class="org.hibernate.auction.model.Child" />
 9  </set>
10 </class>
11 <class name="Child" table="CHILD">
12  <id name="id" column="CHILD_ID" type="long">
13   <generator class="native"></generator>
14  </id>
15  <property name="name" column="NAME" type="string" />
16 </class>
17</hibernate-mapping>

If we were to execute the following code

 1Parent p = new Parent(new HashSet()); 
 2Child c1 = new Child(new String("c1"));
 3
 4try {
 5    session = sessionFactory.openSession();            
 6    tx = session.beginTransaction();           
 7    session.save(p);
 8    Long pid = p.getId();
 9    tx.commit();
10    session.close();
11    
12    session = sessionFactory.openSession();
13    tx = session.beginTransaction();
14    Parent pp = (Parent) session.load(Parent.class, pid); 
15    pp.getChildren().add(c1);        
16    session.save(c1);
17    session.flush();
18    tx.commit();
19
20} catch (HibernateException e) {
21}

Hibernate would issue two SQL statements:
- an INSERT to create the record for c
- an UPDATE to create the link from p to c

Hibernate: insert into PARENT values ( )
Hibernate: select parent0_.PARENT_ID as PARENT_ID0_ from PARENT parent0_ where parent0_.PARENT_ID=?
Hibernate: select children0_.MY_PARENT_ID as MY_PAREN3___, children0_.CHILD_ID as CHILD_ID__, children0_.CHILD_ID as CHILD_ID0_, children0_.NAME as NAME0_ from CHILD children0_ where children0_.MY_PARENT_ID=?

- Hibernate: insert into CHILD (NAME) values (?)
- Hibernate: update CHILD set MY_PARENT_ID=? where CHILD_ID=?

This is not only inefficient, but also violates any NOT NULL constraint on the
MY_PARENT_ID column.

**********1
The underlying cause is that the link (the foreign key parent_id) from p to c is not considered part of the state of the Child object and is therefore not created in the INSERT. So the solution is to make the link part of the Child mapping.
**********1

 <many-to-one name="my_parent"
  class="org.hibernate.auction.model.Parent" column="MY_PARENT_ID"
  not-null="true">
 </many-to-one>

**********2
Now that the Child entity is managing the state of the link, we tell the collection not to update the link. We use the inverse attribute.
**********2

 <set name="children" inverse="true">
  <key column="MY_PARENT_ID" />
  <one-to-many class="org.hibernate.auction.model.Child" />
 </set>

The following code would be used to add a new Child

1Parent pp = (Parent) session.load(Parent.class, pid); 
2pp.getChildren().add(c1);
3c1.setMy_parent(pp); //the link is part of the Child object's state. @see***1 
4session.save(c1);

And now, only one SQL INSERT would be issued!
To tighten things up a bit, we could create an addChild() method of Parent.

1public void addChild(Child c) {
2  c.setParent(this);
3  children.add(c);
4}

Now, the code to add a Child looks like

1Parent p = (Parent) session.load(Parent.class, pid);
2Child c = new Child();
3p.addChild(c);  // 1.let both side of the association knows each other.
4session.save(c); // 2.save the non-verse side

=========================================================================================
CONCLUSION:
1.The non-inverse(inverse="false") side is responsible to save the in-memory representation (object) to the database .
--- you should save the child: session.save(c);
2.Changes made only to the inverse end of the association are not persisted.
--- you needn't update the parent: //session.update(p);

 1session = sessionFactory.openSession();
 2tx = session.beginTransaction();
 3Parent pp = (Parent) session.load(Parent.class, new Long(1)); 
 4pp.getChildren().add(c1); //the parent(pp) now knowns about the relationship
 5c1.setMy_parent(pp); //the child(c1) now knows about the relationship
 6
 7// when cascade="save-update", update(p) will cause all p's
 8// referencing children become persistence(cascade 
 9// saveOrUpdate() operation to parent's all children).
10// So, it's same as you explicitly call session.save(c1).
11
12// when cascade="none"(default), update(p) will just cause
13// p become persistence.
14// And inverse="true", update(p) just persists p, but not 
15// persists the link between p and c1. @see ***2
16session.update(pp);  
17//session.save(c1);  
18session.flush();
19tx.commit();
20

Hibernate: select parent0_.PARENT_ID as PARENT_ID0_ from PARENT parent0_ where parent0_.PARENT_ID=?
Hibernate: select children0_.MY_PARENT_ID as MY_PAREN3___, children0_.CHILD_ID as CHILD_ID__, children0_.CHILD_ID as CHILD_ID0_, children0_.NAME as NAME0_, children0_.MY_PARENT_ID as MY_PAREN3_0_ from CHILD children0_ where children0_.MY_PARENT_ID=?

 1session = sessionFactory.openSession();
 2tx = session.beginTransaction();
 3Parent pp = (Parent) session.load(Parent.class, new Long(1)); 
 4pp.getChildren().add(c1);
 5c1.setMy_parent(pp);
 6//session.update(pp);
 7
 8// when save(c1), because c1 holds a reference to its Parent
 9// (my_parent), so p become persistence too.
10session.save(c1);  //The relationship will be saved. @see ***1
11session.flush();
12tx.commit();
13

Hibernate: select parent0_.PARENT_ID as PARENT_ID0_ from PARENT parent0_ where parent0_.PARENT_ID=?
Hibernate: select children0_.MY_PARENT_ID as MY_PAREN3___, children0_.CHILD_ID as CHILD_ID__, children0_.CHILD_ID as CHILD_ID0_, children0_.NAME as NAME0_, children0_.MY_PARENT_ID as MY_PAREN3_0_ from CHILD children0_ where children0_.MY_PARENT_ID=?
Hibernate: insert into CHILD (NAME, MY_PARENT_ID) values (?, ?)