hibernate.txt

Java大部分的基础知识,EJB3,EJB2,WEBSERVICE,SOAP,JMS,MQ,还有些面试题

		第二个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，如果找不到就抛出异常 。