hibernate 组件映射小结

<?xmlversion="1.0"encoding="UTF-8"?>
<!DOCTYPEhibernate-configurationPUBLIC
"-//Hibernate/HibernateConfigurationDTD3.0//EN"
"http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
<session-factory>
<propertyname="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
<propertyname="hibernate.connection.password">001052</property>
<propertyname="hibernate.connection.url">jdbc:mysql://localhost:3306/test</property>
<propertyname="hibernate.connection.username">root</property>
<propertyname="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>

<propertyname="hibernate.connection.isolation">2</property>

<!--mappingresource="basicCar/bean/BasicCar1.hbm.xml"/-->
<mappingresource="basicCar/bean/Account.hbm.xml"/>
<mappingresource="basicCar/bean/Customer.hbm.xml"/>
<mappingresource="basicCar/bean/Number.hbm.xml"/>
</session-factory>
</hibernate-configuration>

packagebasicCar.bean;

importjava.util.Map;
importjava.util.Set;
importjava.util.HashSet;

publicclassCustomerimplementsjava.io.Serializable{
privatelongid_no;

privateStringname;

privateStringaddress;

privateSetAccounts=newHashSet();//用于一对多存储多个账户时

privateNumbernumber;

publicCustomer(){
}

publicCustomer(longId,StringName,StringAddress){
this.id_no=Id;
this.name=Name;
this.address=Address;
}

publiclonggetId_no(){
returnthis.id_no;
}

publicvoidsetId_no(longId){
this.id_no=Id;
}

publicStringgetName(){
returnthis.name;
}

publicvoidsetName(StringN){
this.name=N;
}

publicStringgetAddress(){
returnthis.address;
}

publicvoidsetAddress(StringA){
this.address=A;
}

publicvoidsetAccounts(SetA){
this.Accounts=A;
}

publicSetgetAccounts(){
returnthis.Accounts;
}

publicvoidsetNumber(NumberN){
this.number=N;
}

publicNumbergetNumber(){
returnthis.number;
}

<?xmlversion="1.0"?>
<!DOCTYPEhibernate-mappingPUBLIC
"-//Hibernate/HibernateMappingDTD3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
<classname="basicCar.bean.Customer"table="customer"lazy="false">
<idcolumn="id_no"name="id_no"type="long">
<!--<generatorclass="increment"></generator>要手动插入值就不能设置自动增长-->
</id>
<propertyname="name"column="name"type="string"></property>
<propertyname="address"column="address"type="string"></property>
<!--	一对多，客户对账号-->
<setname="Accounts"inverse="true"cascade="delete">
<keycolumn="customerId"/>
<one-to-manyclass="basicCar.bean.Account"/>
</set>
<!--
一对一，客户对号码
-->
<one-to-one
name="number"
class="basicCar.bean.Number"
cascade="delete"
></one-to-one>

</class>
</hibernate-mapping>

packagebasicCar.bean;

importjava.sql.Timestamp;
importjava.util.Date;
importjava.util.HashSet;
importjava.util.Set;

publicclassAccountimplementsjava.io.Serializable{
privatelongid_a;

privatelongmoney;

privateTimestampopendate;

TimestamptimeStamp;

//	乐观锁的vision
privateintversion;

privateCustomercustomer;

publicAccount(){
}

publicAccount(longMoney,TimestampO,intV){
this.money=Money;
this.opendate=O;
this.version=V;
}

publiclonggetId_a(){
returnthis.id_a;
}

publicvoidsetId_a(longId){
this.id_a=Id;
}

publiclonggetMoney(){
returnthis.money;
}

publicvoidsetMoney(longM){
this.money=M;
}

publicDategetOpendate(){
returnthis.opendate;
}

publicvoidsetOpendate(TimestampO){
this.opendate=O;
}

publicCustomergetCustomer(){
returnthis.customer;
}

publicvoidsetCustomer(Customerc){
this.customer=c;
}

publicintgetVersion(){
returnthis.version;
}

publicvoidsetVersion(intV){
this.version=V;
}
}

<?xmlversion="1.0"?>
<!DOCTYPEhibernate-mappingPUBLIC
"-//Hibernate/HibernateMappingDTD3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
<classname="basicCar.bean.Account"table="account"lazy="false"dynamic-update="true"dynamic-insert="true"optimistic-lock="version">
<idname="id_a"column="id_a"type="long">
<generatorclass="increment"></generator>
</id>
<versioncolumn="version"name="version"type="int"/>
<propertyname="money"column="money"type="long"></property>
<propertyname="opendate"column="opendate"type="java.util.Date"></property>
<!--
多对一，账号对用户
-->
<many-to-onename="customer"
column="customerId"
class="basicCar.bean.Customer"
cascade="save-update"
not-null="false">
</many-to-one>
</class>
</hibernate-mapping>

packagebasicCar.bean;

publicclassNumberimplementsjava.io.Serializable{
privatelongnid;//号码ID号

privateStringhomeNumber;//家庭电话

privateStringworkNumber;//工作电话

privateStringmobileNumber;//手机号码

privateStringlinkmanNumber;//联系人电话

privateCustomercustomer;//一对一是用于获取对用户的操作

publicNumber(){

}

publicNumber(StringH,StringW,StringM,StringL){

this.homeNumber=H;
this.workNumber=W;
this.mobileNumber=M;
this.linkmanNumber=L;
}

publiclonggetNid(){
returnnid;
}
publicvoidsetNid(longN){
this.nid=N;
}
publicStringgethomeNumber(){
returnhomeNumber;
}
publicvoidsethomeNumber(StringH){
homeNumber=H;
}
publicStringgetworkNumber(){
returnworkNumber;
}
publicvoidsetworkNumber(StringW){
workNumber=W;
}
publicStringgetmobileNumber(){
returnmobileNumber;
}
publicvoidsetmobileNumber(StringW){
mobileNumber=W;
}
publicStringgetlinkmanNumber(){
returnlinkmanNumber;
}
publicvoidsetlinkmanNumber(StringL){
linkmanNumber=L;
}

publicCustomergetCustomer(){
returncustomer;
}

publicvoidsetCustomer(CustomerC){
customer=C;
}
}

<?xmlversion="1.0"?><!DOCTYPEhibernate-mappingPUBLIC"-//Hibernate/HibernateMappingDTD3.0//EN""http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd"><hibernate-mapping><classname="basicCar.bean.Number"table="number"lazy="false"><idname="nid"column="nid"type="long"><generatorclass="foreign"><paramname="property">customer</param></generator></id><propertyname="homeNumber"column="homeNumber"type="string"></property><propertyname="workNumber"column="workNumber"type="string"></property><propertyname="mobileNumber"column="mobileNumber"type="string"></property><propertyname="linkmanNumber"column="linkmanNumber"type="string"></property><!--已经在用户表设置了，这里再设置就是双向一对一--><one-to-onename="customer"class="basicCar.bean.Customer"constrained="true"cascade="save-update"></one-to-one></class></hibernate-mapping>

packagebasicCar;

importjava.awt.List;
importjava.sql.Date;
importjava.sql.Timestamp;
importjava.text.SimpleDateFormat;
importjava.util.HashMap;
importjava.util.Map;

importorg.hibernate.FlushMode;
importorg.hibernate.LockMode;
importorg.hibernate.Query;
importorg.hibernate.Session;
importorg.hibernate.SessionFactory;
importorg.hibernate.Transaction;
importorg.hibernate.cfg.Configuration;

importbasicCar.bean.Account;
importbasicCar.bean.Customer;
importbasicCar.bean.Number;

publicclassTest{

Configurationcfg;

SessionFactorysf;

//	Sessionsession;

publicstaticvoidmain(String[]args){

Testtest=newTest();
test.DoConfiguration();
test.saveEntity();
//test.deleteEntity();
//test.updateEntity();
//更新成功在这里输出提示

test.queryEntity();
System.out.println("end");
}

voidDoConfiguration(){
//newaconfigurationandreadtheconfigurationfromthegivenpath
cfg=newConfiguration();
cfg.configure("/basicCar/hibernate.cfg.xml");
//usetheproperitesintheconfigurefiletonewasessionFactory
sf=cfg.buildSessionFactory();
}

voidsaveEntity(){

Sessionsession;
session=sf.openSession();
//saveaBasicCarindatabase
Transactiontx1=session.beginTransaction();

Datetime=newjava.sql.Date(newjava.util.Date().getTime());//获得系统时间.
StringnowTime=newSimpleDateFormat("yyyy-MM-ddHH:mm:ss").format(time);//将时间格式转换成符合Timestamp要求的格式.
TimestampgoodsC_date=Timestamp.valueOf(nowTime);//把时间转换

Accountco1=newAccount(555,goodsC_date,1);
Accountco2=newAccount(555,goodsC_date,1);
//测试用户与电话两个类的关系调用
Customerss=newCustomer(222,"man32","广州");
Numbernumber1=newNumber("34234","","54545","345335");
//先保存ss,再保存、setnumber和co1的.
ss.getAccounts().add(co1);
ss.getAccounts().add(co2);
ss.setNumber(number1);
number1.setCustomer(ss);

co1.setCustomer(ss);
co2.setCustomer(ss);
//save先后顺序要先ss在co1
session.save(ss);
session.save(co1);
session.save(co2);
session.save(number1);
//System.out.println(bc1.getFactory());
tx1.commit();
//closesession
session.close();
}

voiddeleteEntity(){
Sessionsession;
//newasessionfromsessionfactory
session=sf.openSession();
//新建一个事务
Transactiontx3=session.beginTransaction();
//准备批次删除
Queryquery=session.createQuery("fromCustomer");
java.util.Listlist=query.list();
System.out.println("银行用户：");
for(inti=0;i<list.size()-1;i++)
{
Customercustomer=(Customer)list.get(i);
session.delete(customer);

//System.out.println(customer.getNumber().gethomeNumber());
}
//准备删除电话，观察对Customer的影响
/*Customerco2=(Customer)session.load(Customer.class,newLong(211));
Numberno1=co2.getNumber();
session.delete(no1);*/
//成功！对Customer没影响
//测试删除customer对Number的影响
/*Customerco2=(Customer)session.load(Customer.class,newLong(222));
session.delete(co2);*/
//成功！对Number有影响，会把Number也同时删除
try{
Accountao1=(Account)session.load(Account.class,newLong(3));
Customerco1=ao1.getCustomer();
Customerco2=(Customer)session.load(Customer.class,newLong(144));
//如果address.hbm.xml有cascade="delete"，那么可以连着把salesman也删除，否则只删除address
session.delete(co1);//删除账号后，用户和其它账号也被删除
Accountao2=(Account)session.load(Account.class,newLong(3));
//删除ao2对该用户另一个账号没影响
session.delete(ao2);

}catch(Exceptione){
System.out.println("id=1cararenotexisted,can'tbedeleted");
}
tx3.commit();
//closesession*/
session.close();
}

voidupdateEntity(){

//测试乐观锁
/*Sessionsession1=sf.openSession();
Sessionsession2=sf.openSession();

Transactiontx1=session1.beginTransaction();
Transactiontx2=session2.beginTransaction();

try{

Accountao1=(Account)session1.load(Account.class,newLong(28));
Accountao2=(Account)session2.load(Account.class,newLong(28));
//这时候，两个版本号是相同的
ao1.setMoney(ao1.getMoney()+10);
tx1.commit();
//这时候，两个版本号是不相同的
ao2.setMoney(ao2.getMoney()+10);
tx2.commit();
System.out.println("OK!");
}catch(Exceptione){
//System.out.println(e);
if(tx2!=null)//有同步数据库的作用
{
tx2.rollback();
updateEntity2();
}
elseif(tx1!=null)//有同步数据库的作用
{
tx1.rollback();
updateEntity2();
}

}finally{
session1.close();
session2.close();
}*/

Sessionsession;
//newasessionfromsessionfactory
//把cid=7的order的salesman从原来的sid=15号，更新为14号
session=sf.openSession();
//updatethenameofbesicCaraboveintodatabase
Transactiontx2=session.beginTransaction();
Customerco1=(Customer)session.load(Customer.class,newLong(133));

//测试用户与电话两个类的关系调用
//下面三行代码是用来说明账号跟用户之间的引用关系的使用
Accountao1=(Account)session.load(Account.class,newLong(12));
ao1.getCustomer().setName("Jack");
co1.setName("Amy");
session.update(co1);

//Salesmansas2=(Salesman)session.load(Salesman.class,newLong(9));
//sas2.getSaddress().setCity("nanjing2");
//session.update(sas2);
tx2.commit();

//closesession
session.close();
}

voidqueryEntity()
{

Sessionsession;
//newasessionfromsessionfactory
session=sf.openSession();
//queryacarfromdatabase
try{
Queryquery=session.createQuery("fromCustomer");
//某一行查询
/*Salesmanbc3=(Salesman)query.list().get(0);
System.out.println("nameforthefirstselectedcaris:"+bc3.getSid());*/
//多行查询
java.util.Listlist=query.list();
System.out.println("银行用户：");
for(inti=0;i<list.size();i++)
{
Customercustomer=(Customer)list.get(i);
System.out.print(customer.getId_no()+"");
System.out.print(customer.getName()+"");
System.out.print(customer.getAddress()+"");
Numbernumber1=customer.getNumber();
if(number1!=null)
System.out.println(number1.getmobileNumber());
else
System.out.println("暂时没有电话");
}
System.out.println("-----------------");
System.out.println("银行用户的账户：");
Queryquery2=session.createQuery("fromAccount");
java.util.Listlist2=query2.list();
for(inti=0;i<list2.size();i++)
{

Accountaccount=(Account)list2.get(i);
System.out.print(account.getId_a()+"");
System.out.print(account.getMoney()+"");
System.out.print(account.getCustomer().getId_no()+"");
System.out.println(account.getOpendate()+"");
}
System.out.println("-----------------");
System.out.println("用户的电话号码：");
Queryquery3=session.createQuery("fromNumber");
java.util.Listlist3=query3.list();
for(inti=0;i<list3.size();i++)
{
Numbernumber=(Number)list3.get(i);
System.out.print("用户id："+number.getCustomer().getId_no()+"");
System.out.print("家庭电话："+number.gethomeNumber()+"");
System.out.print("工作电话："+number.getworkNumber()+"");
System.out.print("手机号码："+number.getmobileNumber()+"");
System.out.println("联系人电话："+number.getlinkmanNumber()+"");
}
}catch(Exceptione){
System.out.println(e);
}

//closesession
session.close();
}

voidupdateEntity2(){
//测试乐观锁
Sessionsession1=sf.openSession();

Transactiontx1=session1.beginTransaction();

try{
Accountao1=(Account)session1.load(Account.class,newLong(28));

//重新执行该事务
ao1.setMoney(ao1.getMoney()+10);
tx1.commit();
System.out.println("OK2!");
}catch(Exceptione){
//System.out.println(e);
if(tx1!=null)//有同步数据库的作用
{
tx1.rollback();
updateEntity();
}

}finally{
session1.close();
}

}

}