第二個sql才是增加
	6、通過設置show_sql=true顯示所有在sql，便于分析系統的問題。
	7、在hibernate.cfg.xml中設置如下參數
		fetch-size:hibernate在select時一次從數據庫取多少行
			對于oracle默認是15，可以設置為30-50，太大了
			并不是很好。
		bach-size:hibernate在執行insert、update、delete時
			一次向數據庫提交多少行。
		行越多其執行效率越高，因為減少與數據庫交互次數。
		<property name="hibernateProperties">
			<props>
				<prop key="hibernate.dialect">org.hibernate.dialect.Oracle9Dialect</prop>
				<prop key="hibernate.show_sql">false</prop>
				<!-- Create/update the database tables automatically when the JVM starts up
				<prop key="hibernate.hbm2ddl.auto">update</prop> -->
				<!-- Turn batching off for better error messages under PostgreSQL 
				<prop key="hibernate.jdbc.batch_size">100</prop> -->
				<prop key="hibernate.jdbc.fetch_size">50</prop>
			</props>
		</property>
		注意在批量增加時需要:
			session.flush();
			sessionFactory.flush();
數據庫的類型:
	1、事務型數據庫:oltp，主要的操作insert、delete、update
	2、分析型數據庫:olap，主要的操作select
sql
	1、聯接:將多個表的列合在一起,one被復制了n-1份
		--聯接條件在from中
		select c.*,b.* from customer c join buy b on c.customerName=b.customerName;
		--聯接條件在where中
		select c.*,b.* from customer c,buy b where c.customerName=b.customerName;
		--左聯接:左邊所有，右邊匹配
		select c.*,b.* from customer c left join buy b on c.customerName=b.customerName;
	2、聯合:將多個表的行合在一起
		select customerName from customer
		union
		select buyName from buy;
	3、子查詢:子查詢的結果是父查詢的條件
		select * from buy where customerName in
		(
			select customerName from customer;
		)

四、manytomany
	create table power
	(
		powerID int primary key,
		powerName varchar(20)
	);
	create table role
	(
		roleID int primary key,
		roleName varchar(20)
	);
	create table rolepower
	(	
		powerID int foreign key references power(powerID),
		roleID int foreign key references role(roleID)
	);
	--power
	<set name="rolepowerSet" inverse="true"  table="rolepower">
            <key column="powerID"/>  --powerID是rolepower的外鍵列
            <many-to-many class="hibernate.Role" column="roleID"/> --roleID是rolepower的外鍵列
        </set>
		--清楚當前power的主鍵值
		select * from Role where rowID in
		(
			select roleID 
			from rolepower where  powerID=當前power的主鍵值
		);
	--role
	<set name="rolepowerSet" inverse="false" table="rolepower">
            <key column="roleID"/>
            <many-to-many class="hibernate.Power" column="powerID" />

		select * from Power where powerID in
		(select 中間的外鍵powerID from rolepower where 中間的外鍵roleID=role表的主鍵(roleId))
        </set>
OneToMany:
	1、查找是雙向,一方可以直接取出另一方,若要找到另一方，必將另一方作為當前方所屬性。
		one應當有表Set屬性，many應當有一個One類型的屬性。
	2、主控方:主要維護外鍵列的值。
		inverse="false"代表是主控方，另一方則為被控方，反之亦然。
		若要維護主外鍵的值，必須將被控方作為主控方的屬性
		一般主控方在many這邊。
主鍵的生成方式:
	assigned:主鍵需要用戶給定
	native：在數據庫中對應的identity,增加時用戶不用管，
		hibernate也不用管理。
hibernate的OneToMany
	1、hibernate中的oneToMany是雙向,對于one有一個屬性是set，對應的是many的對象，
	   對于many有一個屬是One對象，通過one的get方法可以取出many,通過many的
	   get方法可以取出one。
	   public class Customer
	   {
	   	private String customerName;
	   	private String sex;
	   	private Set buies;
	   	public void setBuies(set buies)
	   	{
	   		this.buies=buies;
	   	}
	   	public Set getBuies()
	   	{
	   		return this.buies;
	   	}
	   }	   
	   public class Buy
	   {
	   	private int buyID;
	   	private Customer customer;
	   	public void setCustomer(Customer customer)
	   	{
	   		this.customer=customer;
	   	}
	   	public Customer getCustomer()
	   	{
	   		return this.customer;
	   	}
	   }
	 2、主控方,英文是(inverse),用于維護外鍵值。
	 	如果inverse=false代表主控方,則另一方就是被控方，返這亦然。
	 	若要維護外鍵值必須將被控方作為主控方的一個屬性，
	 		通過set方法將被控方注入到主控方中。
	 	一般主控方要many這邊，因為在增加時只產一個insert語句。
	 3、延遲加載,英文是(lazy)
	 	若lazy=true,代表是延遲加載，加載時只加載當前對象，
	 		不加載相關對象，只有用到相關對象才加載，默認是延遲加載。
	 	若lazy=false，代表是即時加載，不但加載當前對象的，
	 		還加載其相關對象值。
	 	一般用的是lazy=true,即延遲加載
	 4、級聯,主增從增、主刪從刪、主改從改
	 	cascade="all":代表主增從增、主刪從刪、主改從改
	 	cascade="save-update":代表主增從增、主改從改
	 	若實現這樣的效果，必須將從作為主的屬性值或屬性一個元素。
	 	級聯給開發帶來的快捷，但一般不用，用開發的不方便。
	 5、為什么主控方在many方，不在one方，因為如果主控方在many方，增加時只產生一個sql
	    如果主控方在one方，增加時產生兩個sql
hibernate對象的生命周期
	1、自由狀態:用戶自己創建的類
		Customer customer=new Customer();
	2、持久狀態:經過get/load、update、insert、query.list操作后的對象，其由session管理。
		    在持久狀態對象的兩大特征:
		    	1、通過get方法可以取出對方
		    	2、在事務內可以通過set方法直接修改對象值。
	3、游離狀態:被session拋棄。
update方法與當象處于持狀態時的區別
	update方法中的對象應當沒有在session中，即處于游離或自由狀態，修改會成功。
	set方法只可以用的持久狀態。
復習:
	struts
		將IFcade作為BaseAction的一個屬性，通過FacadeFactory產Facade實例，返回一個IFacade接口。
	facade
		IFacade
		Facade
		FacadeFactory:
			產Facade實例，返回一個IFacade接口。
	dao
		UserDao接口
		UserDao實現類
		UserDaoFactory：產生具體的UserDao實現類，返回一個抽象的接口
		AbstractFactory:用了單例、返射、工廠，實例化了UserDaoFactory,
			   返回了一個AbstractFactory抽象類。
			   因為UserDaoFactory
			   是AbstractFacatory的子類，所以業務層調用的還是子類的
			   getUserDao方法產生具體的UserDao實現實例，返回UserDao接口。
	hibernate:持久化

四、hibernate的核心配置文件及作用?
	hibernate.cfg.xml:說明數據庫的連接及具體o/r Mapping文件所在的位置
	*.hbm.xml:具體的o/r mapping映射文件，說明類與表，屬性與字段的對應關系。
五、hibernate的核心類及作用?
	Configuration:加載hibernate.cfg.xml及*.hbm.xml文件
		Configuration config=new Configuration().configure();
	SessionFactory:產生sesson，進行二級緩存的管理,即應用級緩存的管理。
		SessionFactory sessionFactory=config.buildSessionFactory();
	Session:具體一個會話，進行增刪改查，進行一級緩存的管理，
			即事務級的緩存管理.
		save
		update
		delete
		get/load:根據主鍵值及類說明查找得到一個對象
		Query:根所sql查找得到一批數據也可批量刪除數據。其sql叫HQl,
			from后必須類名，條件里必須是屬性名而不是字段名
			Query query=session.createQuery("from Users where userName=:a and pwd=:b");
			query.setString("a","張三");
			query.setString("b","1234");
			query.list();
			//批量刪除
			Query query=session.createQuery("delete from Users");
			query.executeUpdate();
	Transaction:事務管理
		Transaction trans=session.beginTransaction();
		trans.commit();
		trans.rollback();
六、對于一個表,hibernate對應的主鍵生成機制有很多種?
	assigned:主鍵值需要手動給定，開發人員必須手動給值
	native:主鍵由數據庫自動生成，hibernate不管,開發人員也不用管。

hibernate的查詢 （比較get 與load) 
hibernate的查詢的比較
hibernate的查詢有很多,Query,find,Criteria,get,load

query使用hsql語句，可以設置參數是常用的一種方式

criteria的方式，盡量避免了寫hql語句，看起來更面向對象了。

find方式，這種方式已經被新的hibernate丟棄見這里
http://www.blogjava.net/dreamstone/archive/2007/07/28/133053.html

get和load方式是根據id取得一個記錄
下邊詳細說一下get和load的不同，因為有些時候為了對比也會把find加進來。

1，從返回結果上對比：
load方式檢索不到的話會拋出org.hibernate.ObjectNotFoundException異常
get方法檢索不到的話會返回null

2，從檢索執行機制上對比：
get方法和find方法都是直接從數據庫中檢索
而load方法的執行則比較復雜
1,首先查找session的persistent Context中是否有緩存，如果有則直接返回
2,如果沒有則判斷是否是lazy，如果不是直接訪問數據庫檢索，查到記錄返回，查不到拋出異常
3,如果是lazy則需要建立代理對象，對象的initialized屬性為false，target屬性為null
4, 在訪問獲得的代理對象的屬性時,檢索數據庫，如果找到記錄則把該記錄的對象復制到代理對象的target
上，并將initialized=true，如果找不到就拋出異常 。