复习3.txt

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

			如果得到是一个真实的对象
	21、hibernate常见优化策略
		用最新版本的hibernate
		制定合理的缓存策略
			用二级缓存，缓存的原则。		
		采用合理的session管理机制
			一个线程个session,线程结束session结束。
		尽量使用延迟加载
			many
			大文本、大文件
		设定合理的批处理参数(batch-size)
			fetch_size:每次从数据库中取出记录条数一般设置为30、50、100。
				OracleJDBC驱动默认的Fetch Size=15,设置Fetch Size为：
				30、50性能会明显提升。
			batch_size:
				在进行插入、更新、删除时执行多少个sql后将sql提交到数据库中
			hibernate中的配置如下:
				<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>
		如有可能，选用uuid作为主键生成器
		如有可能，选用基于version的乐观锁替代悲观锁
			非观锁:
				1、
					Query query1=session.createQuery("select * from Customer for update");
				2、
					Query query1=session.createQuery("select * from Customer");
					query1.setLockMode("Customer",LockMode.UPGRADE);
			
			乐观锁
				<class
					optimistic-lock="version/none"
				/>
		开发过程中，打开hibernate的SQl日志输出(hibernate.show_sql=true)，通过观察hibernate生成的sql语句进一步了解其实现原理，
			从而指事实上更好的实现策略。
	22、hql
		1、criteria：可以不用写hql就可查询数据库中的内容
			Criteria cri=session.createCriteria(Customer.class);
			--加入查询的条件
			cri.add(Expression.gt("age",30));
			--加入排序
			cri.addOrder(Order.desc("sex"));
			--分页
			cri.setFirstRow(0);
			cri.setMaxResultRows(2);
		2、取一个属性
			List<String> sexes=session.createQuyer("select sex from Customer");
			for(String sex:sexes)
			{
				
			}
		3、取多个属性
			List<Object[]> fields=session.createQuyer("select customerName,age,sex from Customer");
			for(Object[] field:fields)
			{
				field[0];
				field[1];
				field[2];
			}
		4、将多个属构造成一个对象
			List<Customer> customers=session.createQuyer("select new Customer(customerName,age,sex) from Customer");
			for(Customer customer:customers)
			{
				customer.getCustomerName();
			}
		5、查询的sql来自于配置文件
			--在*.hbm.xml文件中配置hql
				<class>
					
				</class>
				<query name="myHql">
					<[!CDATA[
						FROM Customer where customerName=:customerName
					]]>
				</query>
			Query query=session.getNamedQuery("myHql");
			query.setString("customerName","a1");
			query.list();
		6、order by及group by
			List<Object[]> fields=session.createQuery("
				select count(sex),customerName from Customer
				group by customerName order by customerName").list();
			for(Object[] field:fields)
			{
				Long count=(Long)fields[0];
				String customerName=(String)fields[1];
			}
		7、关联
			1、没有fetch	
				1、通用的sql
					a、在where条件中关联
						select c.*,b.* from customer c,buy b
						where c.customerName=b.customerName;
					b、在from子句中关联
						select c.*,b.* from customer c join buy b
						on c.customerName=b.customerName;
				2、hibernate的实现
					1、没有fetch的实现
						List<Object[]> results=session.createQuery("from Customer as customer inner join customer.buies");
						for(Object[] result:results)
						{
							Customer customer=(Customer)result[0];
							Buy buy=(Buy)result[1];
						}
					2、有fetch的实现
	23、数据加载方式
		即时加载:加载不但加载当前对象还加载其关联对象属性
		延迟加载:加载时只加载当前对象，不加载关联对象，只有真正用关联对象的属性时
			 才加载。
		预先加载:针对关联，一个sql加载多个对象。
		批量加载:设置bach-size及fetch-size参数
	24、继承的实现
		1、一个类一张表
		2、子类与父类是同一张表，在表中多加入一个字段说明是子类还是父类
			a、表
			create table user2
			(
				userName varchar(20) primary key,
				pwd varchar(20),
				guessRemark varchar(20),
				adminRemark varchar(20),
				DISCRIMINATOR_USERTYPE varchar(30)
			)
			2、三个类的实现,Guess及Admin继承于user2
			3、具体配置
				<class name="hibernate.User2" table="user2" discriminator-value="user">
				        <id name="userName" type="java.lang.String">
				            <column name="userName" length="20" />
				            <generator class="assigned"></generator>
				        </id>
				        <!--这个列值用于标识不同的类-->
				        <discriminator column="DISCRIMINATOR_USERTYPE" type="java.lang.String"></discriminator>
				        <property name="pwd" type="java.lang.String">
				            <column name="pwd" length="20" />
				        </property>
				        <!-- 说明第一个子类-->
				        <subclass name="hibernate.Guess2" discriminator-value="guess">
					        <property name="guessRemark" type="java.lang.String">
					            <column name="guessRemark" length="20" />
					        </property>
				        </subclass>
				        <subclass name="hibernate.Admin2" discriminator-value="admin">
					        <property name="adminRemark" type="java.lang.String">
					            <column name="adminRemark" length="20" />
					        </property>
				        </subclass>
				   </class>
			4、特点:查询父类时会查询所有的子类
		3、三个类三张表，子类对应的表共享父类的字段
			1、sql
				drop table guest3;
				drop table admin3;
				drop table user3;
				create table user3
				( 
				  USERID varchar(32) primary key,
				  username varchar (30),
				  pwd      varchar(20)   
				 );
				create table guest3
				(
					USERID varchar(32) primary key,
				 	guest_remark varchar(20),
					constraint guest3_fk foreign key(userID) references user3(userID)
				);
				create table admin3
				(
					USERID varchar(32)  primary key,
				 	admin_remark varchar(20),
					constraint admin3_fk foreign key(userID) references user3(userID)
				);
			2、配置
				<class name="hibernate.User3" table="user3" >
				        <id name="userid" type="java.lang.String">
				            <column name="USERID" length="32" />
				            <generator class="assigned"></generator>
				        </id>
				        <property name="username" type="java.lang.String">
				            <column name="username" length="30" />
				        </property>
				        <property name="pwd" type="java.lang.String">
				            <column name="pwd" length="20" />
				        </property>
				        <joined-subclass name="hibernate.Admin3" table="admin3"> 
				            <key column="USERID"/> 
				            <property name="adminRemark" type="java.lang.String">
								<column name="admin_remark" length="20" />
							</property>
				        </joined-subclass>        
				        <joined-subclass name="hibernate.Guest3" table="guest3"> 
				            <key column="USERID"/> 
				            <property name="guestRemark" type="java.lang.String">
								<column name="guest_remark" length="20" />
							</property>
				        </joined-subclass>
				    </class> 
	25、many-to-many
		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 power(powerID)
		);
		--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>