1. Update make a detached object persistent.
2. Config mapping relating in mapping files make query as object oriented.
3. For many-to-many relation relationship, middle table store link to two tables.
4. Key element is identify the column of middle table.
5. Db operation happend at the end of a unit work ---- session flush.
6. For value type, "element" will replace "many-to-many" in set element(acturally, for all java object, hibernate take it as a value type), value type can not shared by more than one instance.
7. All bi-directional associations need one side as inverse. bi-direction means both sides of mapping mentain relations of middle table, inverse side is a mirror of the other side, during save or update, the other side will handle.
1. batch insert/update session.flush session.clear
2. statlesssession
There are three main kinds of mapping for inheritance:
1. table per class hirachy, for each subclass, use discriminator to distinguish different data, subclass specific property can not be null, only one table.
2. table per subclass, there is a common table for super class, subclass table reference to super table through primary key, add relationship between tables.
3. table per concrete class, generate too much redandance data, pk was generated by super class.
some mix mapping is available.
1. Entity name: can be used query.
2. Way of define mapping: xml, xdoclet, annotation.
3. Gerated properties: timestamp, version, and property can be generated. Types as follows :
never: default value.
always: generated when insert and update.
insert: only geneated when create data, won't change when updated it later.
4. Create db schema can be written in xml file.
1. lite archetecture: application handle connection and transaction, use niminum hibernate api.
2. full scream architecture: application will ingore underlying jdbc, jta apis, hibernate hold it.
3. Persistent object stats: persistence, transient and detached.
4. Session factory: a cache of compiled configuration files for single db, thread-safed, factory of session and client of connectionProvider, an optional cache of data for process, cluster layer.
5. Session: represent a conversation between application and db, factory of transaction. wrapped conncetion.
6. Transatcion: specify automic unit of work.
7. Context session: hibernateUtil class, for certain application, the scope of current is different, have different context concept. (need more research!)
8. Configration: store xml to java, can got it through specify xml, java class and proeprties.
9. Hibernate mapping: mapping java type to SQL type.
10. Custome mapping type: implement UserType or CompsiteUserType, can define short name, chould get certain value of property by key value.(useless)
11. Entity and Value: entity can be shared by more than one persistent class as reference.
Singleton模式可能是应用最广泛的模式之一了， 但有些错误的应用。
Singleton的实现： 有两种方式， 如下：
1. class Test {
public static final Test instance = new Test();
private Test() {}
}
2. class Test {
private static final Test instance = new Test();
private Test() {}
public static Test getInstance() {
return instance;
}
}
这两种方法都要求构造器是私有的， 这样就可以防止该类外的对象创建新的TEST对象。
但相对而言， 推荐使用第二种方法， 因为其更具有灵活性，当我们改变创建对象的方式的时候， 不需要改动客户代码。 第一种方法较第二种有一点完全可以忽略不计的效率的提高。
但应避免如下代码实现Singleton：
class Test {
private static Test singleton = null;
private Test() {}
public Test getSingleton() {
if(singleton == null) {
singleton = new Test();
}
return singleton;
}
}
因为严格上讲， 这并不能完全实现Singleton模式，而且会导致程序出错， 这同著名的线程问题－－DCL实效的原理是完全一样的：
JVM创建对象的过程可以分为几个步骤：创建空间， 把所有的变量赋值位默认值， 初始化。。。 当有两个线程A和B同事进入该方法， A先执行， A创建Test实例的空间， 这时，因为CPU的指令流机制，时间片段正好轮到B线程， 这时B判断singleton是否为NULL， 因为A已经为Test的实例分配了空间， 所以JVM认为实例已经创建了， B继续执行， 更糟糕的是B调用了singleton, 这时因为他并没有初始化完全， 所以抛出NullPointerException, 太糟糕了！
Bridge：主要实现的原理就是把接口 和实现分离开来, 保证他们再两个不同的类层次结构。
用Bridge而不是直接继承实现主要有两个好处：
1。 二进制兼容。 假设我们的应用程序需要用到format功能， 我们可能有要引用两个第三方JAR包， formatInterface.JAR And formatImp.jar， 我们程序可能只引用了formatInterface.jar中的接口， 而formatImpl.jar里是什么我们根本不需要关心， 因为他是formatInterface的实现， 所以当他改变的时候， 我们的应用程序完全不用重新修改代码， 编译。可能我在LINUX下用LINUXFormatImpl.jar, 再WINDOW下use WindowFormatImpl.jar, but Application will never care about it.
2. 接口与实现的分离， 实现不一定实现接口的内容， 就是说实现同接口之间不是一一对应的， 实现可能完成最原子的操作， 而接口通过持有一个实现的应用， 组装这些操作来实现接口。 比如说接口是createRectangle(), 实现可能只完成了createLine的操作， 然后有接口来组装。
Composite模式则要从全局的角度考虑对象之间的关系是否满足“树枝” 与 “树叶”的关系， 如果满足， 则需要定义一个树枝与树叶的集合接口Tree， 既包含树枝接口add(tree)和树叶接口getColor()。
每个JAVA对象都有一把所， 当有多个线程同时访问共享资源的时候， 需要Synchronize 来控制安全性， synchronize 分 synchronize 方法 和synchronize快，使用synchronize块时， 一定要显示的获得该对象的锁（如synchronize（object))而方法则不需要。
JAVA 的内存模型是对每一个进程有一个主内存， 每个线程有自己的内存， 他们从主内存中取数据， 然后计算， 再存入主内存中。
并发问题如下：如果多个线程同事操作同一数据， A线程从主内存中取的I的值为1， 然后进行加1操作， 这时B线程也取I的值， 进行加2操作， 然后A存入2到主内存中， B也存入， 这样就覆盖了A的值（同数据库中的并发问题一样）。
解决办法是用synchronize， 如用synchronized（I）。被synchronize 修饰的方法（块）把以下三步操作当成一个原子操作：取数据， 操作数据， 存数据。 我们知道原子操作是不可以被打断的， 所以其保证了数据一致性， 这样同一时间只有一个线程再执行， 对性能有一定的影响。这也是synchronize的第二个作用：保证统一时间只有一个线程再运行。 当实现SOCKET连接的时候经常用到.
JAVA中规定对非FLOAT, LONG的原始类型的取和存操作为原子操作。 其实就是对一个字（32位）的取，存位原始操作， 因为FLOAT, LONG为两个字节的长度， 所以其取， 存为非原子操作。 如果想把他们也变为原子操作， 可以用VOLATILE关键字来修饰。
1. serializable default serialize all field and object net.
2. Externalizable default deserialize all fields and use writeExternal and readExternal to serialize object. should provide public construct.
3. serializable interface use private writeObject and private readOjbect to implemnets the same fucntion as Extenalizable interface. (writeDefautObject and readDefaultObject).
4. Externalizable extends serializable
学习java也有几年的时间了， 大学开始就一直没有断过， 工作后有专门学习了java。
由于对原理型的知识比较看重， 所以JAVA基础学的比较多， 至今精通不敢说， 但至少也应该算是熟悉了吧！
我认为语言的学习最简单的就是文法学习， 估计一般学习一周 到两周就可以使用这种语言编写程序， 对于初级程序员这样也就足够了， 但要对语言有很深的了解：就是对这个语言的特性的了解， 把JAVA做例子， 他的所有类继承自OBJECT（他的所有方法用途， 作用等等）， CLONABLE接口， SERIALIZABEL接口改变了方法的行为，synchronized等等， 这些都是JAVA语言定义的自己的特征， 包括JAVA的性能， 要能高效率的运用JAVA， 必须对对这些特性有比较深的了解， 还要对其主要的库有一定的了解，比如说容器库， 输入输出流。。如果了解这些的话最少也要花费1－－2年的学习， 还不一定掌握精髓。 估计掌握这些知识的人怎么也应该是高级程序员了。 JAVA学习的最高境界应该是对其类库的无比熟悉， 能清楚其内在的实现， 如容器类散列桶的实现方法等等， 以及他们实现的优劣。 能达到这个程度的人应该寥寥无几， 这样的人一般是有10年JAVA工作经验的资深JAVA程序员了。
个人认为学习语言也不过这三个阶段：熟悉语法, 熟悉语言的特性， 精通类库。一个语言成熟与否的标志就是他是否有一个设计良好的全面的类库。