亚洲国产视频一区二区,91精品啪aⅴ在线观看国产,久久精品电影网

解決Join方法的疑惑

很長時間對join方法感到疑惑，不明白到底是誰要阻塞，誰要繼續執行（線程這部分亟需加強）。今天和一網友交流后疑惑得到解決，在此表示感謝Stephen_Liu。

假如在main方法中有個線程A，執行了A.join()，那么線程A繼續執行，而main線程這阻塞在A.join()處，直到線程A執行完畢并正常退出，此時main方法中的A.join()才返回，然后繼續執行A.join()后面的代碼。

public class ThreadJoin extends Thread {
    public static int n = 0;

    static synchronized void inc() {
        n++;
    }

    public void run() {
        try {
            for (int i = 0; i < 10; i++) {
                inc();
                sleep(3);
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) throws Exception {
        Thread thread[] = new Thread[100];
        for (int i = 0; i < thread.length; i++) {
            thread[i] = new ThreadJoin();
        }
        for (int i = 0; i < thread.length; i++) {
            thread[i].start();
        }
        for (int i = 0; i < thread.length; i++) {
             thread[i].join();  //不使用這句話n是個隨機數，使用n=1000
        }
        System.out.println("n=" + ThreadJoin.n);
    }
}

posted @ 2011-08-23 20:57 日出星辰閱讀(63) | 評論 (0) | 編輯收藏

使用Dom4j讀取xml文件（需要引入Dom4j.jar）

public class ReadXmlByDom4J {

	public static void main(String args[]){
		File f=new File("F:\\car.xml");
		Dom4J(f);
	}
	
	public static void Dom4J(File f){
		try {
			SAXReader reader=new SAXReader();    //使用SAXReader方式讀取XML文件
			Document doc=reader.read(f);        //加載XML配置文件，得到Document對象
			Element root=doc.getRootElement();  //獲得根節點
			
			//取得某節點的單個子節點
			System.out.println("-------取得某節點的單個子節點開始----------");
			Element value=root.element("VALUE");  
//			System.out.println(value.getName()+","+value.getText());
			Element no=value.element("NO");  //只獲得第一個元素
			Element addr=value.element("ADDR");
			System.out.println(no.getName()+":"+no.getText());
			System.out.println(addr.getName()+":"+addr.getText());
			System.out.println("--------取得某節點的單個子節點結束----------");
			
			for(Iterator i=root.elementIterator("VALUE");i.hasNext();){
				Element temp=(Element) i.next();
				System.out.println(temp.selectSingleNode("NO").getName()+":"+temp.selectSingleNode("NO").getText());
				
			}
		} catch (DocumentException e) {
			e.printStackTrace();
		}
	}
}

car.xml

<?xml version="1.0" encoding="GB2312"?>  
<RESULT>  
<VALUE>　　   
  <NO>A1234</NO>　　   
  <ADDR>河南省鄭州市金水區</ADDR>  
</VALUE>  
<VALUE>　　   
  <NO>B1234</NO> 　   
  <ADDR>河南省鄭州市二七區</ADDR>  
</VALUE>  
</RESULT>

輸出結果：

-------取得某節點的單個子節點開始----------
NO:A1234
ADDR:河南省鄭州市金水區
--------取得某節點的單個子節點結束----------
NO:A1234
NO:B1234

posted @ 2011-08-23 16:35 日出星辰閱讀(951) | 評論 (0) | 編輯收藏

Java連接數據庫方式大全

Mysql：

      String Driver="com.mysql.jdbc.Driver";    //驅動程序    
      String URL="jdbc:mysql://localhost:3306/db_name";     //連接的URL,db_name為數據庫名        
      String Username="username";    //用戶名    
      String Password="password";    //密碼    
      Class.forName(Driver).new Instance();   //加載數據庫驅動    
      Connection con=DriverManager.getConnection(URL,Username,Password);

Oracle：

     String Driver="oracle.jdbc.driver.OracleDriver";   
       String URL="jdbc:oracle:thin:@loaclhost:1521:orcl";    //orcl為數據庫的SID

DB2：

   String Driver="com.ibm.db2.jdbc.app.DB2.Driver";    //連接具有DB2客戶端的Provider實例    
   //String Driver="com.ibm.db2.jdbc.net.DB2.Driver";     //連接不具有DB2客戶端的Provider實例    
   String URL="jdbc:db2://localhost:50000/db_name";     //db_name為數據可名

SQL Server：

 1)
    String Driver="com.microsoft.jdbc.sqlserver.SQLServerDriver";    //連接SQL數據庫的方法    
   String URL="jdbc:microsoft:sqlserver://localhost:1433;DatabaseName=db_name";   //db_name為數據庫名    
2)
    String Driver="com.microsoft.sqlserver.jdbc.SQLServerDriver";       
   String URL="jdbc:sqlserver://localhost:1433;DatabaseName=db_name";

Informix：

     String Driver="com.informix.jdbc.IfxDriver";        
       String URL="jdbc:Informix-sqli://localhost:1533/db_name:INFORMIXSER=myserver";

JDBC-ODBC：

  String Driver="sun.jdbc.odbc.JdbcOdbcDriver";    
   String URL="jdbc:odbc:dbsource";    //dbsource為數據源名

Sysbase:

    String Driver="com.sybase.jdbc.SybDriver";    //驅動程序    
   String URL="jdbc:Sysbase://localhost:5007/db_name";     //db_name為數據可名

PostgreSQL:

    String Driver="org.postgresql.Driver";    //連接數據庫的方法    
   String URL="jdbc:postgresql://localhost/db_name";     //db_name為數據可名

各種數據庫連接大同小異，區別的是Driver和URL，其他的區別不大。參考：http://www.cnblogs.com/itat/archive/2011/08/22/2149924.html

posted @ 2011-08-23 15:49 日出星辰閱讀(65) | 評論 (0) | 編輯收藏

JUint測試

ClassA.java

public class ClassA implements Serializable {

	private static final long serialVersionUID = 6013572251564847381L;
	private String name = "My name is a";
	private ClassB b = null;

	ClassA() {
		b = new ClassB();
	}

	public String show() {

		System.out.println("a.toString <a.name=\"" + this.name
				+ "\" a.b.name=\"" + this.b.getName() + "\">");

		return "a.toString <a.name=" + this.name + " a.b.name="
				+ this.b.getName() + ">";
		// \" 雙引號
		// \' 單引號
		// \\ 反斜線
	}

	public int add(int a, int b) {
		return a + b;
	}

	public int divide(int a, int b) throws Exception {
		if (0 == b) {
			throw new Exception("除數不能為零");
		}
		return a / b;
	}

	public int exception(int a, int b) throws Exception {
		if (a == 2) {
			throw new Exception("進入我設置的異常啦！");
		}
		return a + b;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public ClassB getB() {
		return b;
	}

	public void setB(ClassB b) {
		this.b = b;
	}

}

ClassB.java

public class ClassB implements Serializable{

	private static final long serialVersionUID = -4324044767844361076L;

	private String name="My name is b";
	
	ClassB(){}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}
	
	
}

JUin測試

public class ClassATest extends TestCase {

	ClassA a = new ClassA();

	public void testShow() {
		// 覆蓋原來的name
		a.setName("hello TestA");
		a.getB().setName("hello TestB");
		a.show();
	}

	public void testAdd() {
		// boolean b=false;
		// Assert.assertEquals(true, b);
		int result = 0;
		result = a.add(2, 5);
		Assert.assertEquals(7, result);
	}

	public void testDivide() {
		int result = 0;
		try {
			result = a.divide(10, 5);
		} catch (Exception e) {
			e.printStackTrace(); // 如果進入到catch中說明執行divide失敗
			System.out.println("執行上面那句話了");
			Assert.fail();
		}
		Assert.assertEquals(2, result);
	}

	public void testException() {
		int result = 0;
		try {
			result = a.exception(3, 4);
		} catch (Exception e) {
			e.printStackTrace();
			System.out.println("執行上面那句話了");
			Assert.fail();
		}
		Assert.assertEquals(7, result);
	}
}

posted @ 2011-08-23 15:36 日出星辰閱讀(175) | 評論 (0) | 編輯收藏

用序列化（Serializable)保存、讀取對象

　　實現Serializable借口的對象可以被轉換成一系列字節，并可以在以后使用時完全恢復原來的樣子。這一過程也可以在網絡中進行，這樣就可以先在windows機器上創建一個對象，對其序列化，然后通過網絡發送給Linux機器，就可以在Linux機器上準確無誤地恢復成原來的樣子。整個過程不必關心數據在不同機器上如何表示，也不必關心字節的順序或其他細節。

序列化的思想就是“凍結”對象，操作對象（寫到磁盤，通過網絡傳輸等），然后“解凍”對象，重新獲得可用的Java對象。功能的實現要靠ObjectInputStream/ObjectOutputStream類，完全保真原數據，并且開發愿意用Serializable。

實現了Serializable接口的類為保證serialVersionUID 值跨不同 java 編譯器實現的一致性，序列化類必須聲明一個明確的 serialVersionUID 值。

ClassA.java

public class ClassA implements Serializable {

	private static final long serialVersionUID = 6013572251564847381L;
	private String name = "My name is a";
	private ClassB b = null;

	ClassA() {
		b = new ClassB();
	}

	public String show() {

		System.out.println("a.toString <a.name=\"" + this.name
				+ "\" a.b.name=\"" + this.b.getName() + "\">");

		return "a.toString <a.name=" + this.name + " a.b.name="
				+ this.b.getName() + ">";
		// \" 雙引號
		// \' 單引號
		// \\ 反斜線
	}

                 .......................
}

ClassB.java

public class ClassB implements Serializable{

	private static final long serialVersionUID = -4324044767844361076L;

	private String name="My name is b";
	
	ClassB(){}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}
	
	
}

將對象內容保存到文本中

WriteSeri.java

public class WriteSeri {

	public static void main(String args[]){
		ObjectOutputStream outObj=null;
		try {
			//將對象內容寫入到文本中
			FileOutputStream  outStr=new FileOutputStream("obj.txt");
			outObj=new ObjectOutputStream(outStr);
			ClassA a=new ClassA();
			outObj.writeObject(a);
			System.out.println("write obj:"+a.show());
			outObj.flush();
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}finally{
				try {
				if (outObj != null) {
					outObj.close();
				}
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}
}

輸出結果：

a.toString <a.name="My name is a" a.b.name="My name is b">
write obj:a.toString <a.name=My name is a a.b.name=My name is b>

將文本內容還原給對象

ReadSeri.java

public class ReadSeri {

	public static void main(String args[]) {
		ObjectInputStream inObj = null;
		try {
			FileInputStream inStr = new FileInputStream("obj.txt");
			inObj = new ObjectInputStream(inStr);
			ClassA a = (ClassA) inObj.readObject();
			System.out.println("read object:" + a.show());
		} catch (FileNotFoundException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		} finally {
			if (inObj != null) {
				try {
					inObj.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}
	}
}

輸出結果：

a.toString <a.name="My name is a" a.b.name="My name is b">
read object:a.toString <a.name=My name is a a.b.name=My name is b>

posted @ 2011-08-23 15:33 日出星辰閱讀(184) | 評論 (0) | 編輯收藏

不同格式的日期字符串轉換

　先把字符串日期轉換成對應的格式，然后再轉換成日期

public static void main(String args[]){
		 String str="2010/05/06";
		 SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
		 try {
			 str=str.replace("/", "-");
			 System.out.println("str="+str);
			System.out.println("time="+sdf.parse(str));
			System.out.println("formateTime="+sdf.format(sdf.parse(str)));
		} catch (ParseException e) {
			e.printStackTrace();
		}
	 }

結果：

str=2010-05-06
time=Thu May 06 00:00:00 CST 2010
formateTime=2010-05-06

posted @ 2011-08-23 14:44 日出星辰閱讀(112) | 評論 (0) | 編輯收藏

很長空格的String轉換成Array數組

開發中碰到了一個需求，需要把鍵值對字符串分隔，但鍵值之間空格很多，只用split("")肯定不行，最后通過正則表達式解決了問題。

public class StringToArray {

	public static void main(String args[]) {
		String s = "北京天竺出口加工區                                 C1101";
		String[] arry = s.split("\\s+");
		System.out.println(arry.length);
		System.out.println("arry[0]=" + arry[0]);
		System.out.println("arry[1]=" + arry[1]);
	}
}

結果：

2
arry[0]=北京天竺出口加工區
arry[1]=C1101

posted @ 2011-08-23 14:40 日出星辰閱讀(114) | 評論 (0) | 編輯收藏

Java讀取、創建xml（通過dom方式）

創建一個接口

XmlInterface.java

public interface XmlInterface {

		/** 
		* 建立XML文檔 
		* @param fileName 文件全路徑名稱 
		*/ 
		public void createXml(String fileName); 
		/** 
		* 解析XML文檔 
		* @param fileName 文件全路徑名稱 
		*/ 
		public void parserXml(String fileName); 
}

接口實現

XmlImpl.java

package com.test.xml;

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.PrintWriter;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import javax.xml.transform.OutputKeys;
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerConfigurationException;
import javax.xml.transform.TransformerException;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.stream.StreamResult;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import org.xml.sax.SAXException;

public class XmlImpl implements XmlInterface{
	private Document document;

	public void init() {
		try {
			DocumentBuilderFactory factory = DocumentBuilderFactory
					.newInstance();
			DocumentBuilder builder = factory.newDocumentBuilder();
			this.document = builder.newDocument();
		} catch (ParserConfigurationException e) {
			System.out.println(e.getMessage());
		}
	}

	public void createXml(String fileName) {
		Element root = this.document.createElement("scores"); 
		this.document.appendChild(root); 
		Element employee = this.document.createElement("employee"); 
		Element name = this.document.createElement("name"); 
		name.appendChild(this.document.createTextNode("wangchenyang")); 
		employee.appendChild(name); 
		Element sex = this.document.createElement("sex"); 
		sex.appendChild(this.document.createTextNode("m")); 
		employee.appendChild(sex); 
		Element age = this.document.createElement("age"); 
		age.appendChild(this.document.createTextNode("26")); 
		employee.appendChild(age); 
		root.appendChild(employee); 
		TransformerFactory tf = TransformerFactory.newInstance();
		try {
			Transformer transformer = tf.newTransformer();
			DOMSource source = new DOMSource(document);
			transformer.setOutputProperty(OutputKeys.ENCODING, "gb2312");
			transformer.setOutputProperty(OutputKeys.INDENT, "yes");
			PrintWriter pw = new PrintWriter(new FileOutputStream(fileName));
			StreamResult result = new StreamResult(pw);
			transformer.transform(source, result);
			System.out.println("生成XML文件成功!");
		} catch (TransformerConfigurationException e) {
			System.out.println(e.getMessage());
		} catch (IllegalArgumentException e) {
			System.out.println(e.getMessage());
		} catch (FileNotFoundException e) {
			System.out.println(e.getMessage());
		} catch (TransformerException e) {
			System.out.println(e.getMessage());
		}
	}

	public void parserXml(String fileName) {
		try {
			DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
			DocumentBuilder db = dbf.newDocumentBuilder();
			Document document = db.parse(fileName);
			
			NodeList employees = document.getChildNodes();
			for (int i = 0; i < employees.getLength(); i++) {
				Node employee = employees.item(i);
				NodeList employeeInfo = employee.getChildNodes();
				for (int j = 0; j < employeeInfo.getLength(); j++) {
					Node node = employeeInfo.item(j);
					NodeList employeeMeta = node.getChildNodes();
					for (int k = 0; k < employeeMeta.getLength(); k++) {
						System.out.println(employeeMeta.item(k).getNodeName()
								+ ":" + employeeMeta.item(k).getTextContent());
					}
				}
			}
			System.out.println("解析完畢");
		} catch (FileNotFoundException e) {
			System.out.println(e.getMessage());
		} catch (ParserConfigurationException e) {
			System.out.println(e.getMessage());
		} catch (SAXException e) {
			System.out.println(e.getMessage());
		} catch (IOException e) {
			System.out.println(e.getMessage());
		}
	}
}

測試

public class Main {

	public static void main(String args[]){
		XmlImpl dd=new XmlImpl();
		String str="D:/grade.xml";
		dd.init();
		dd.createXml(str);    //創建xml
		dd.parserXml(str);    //讀取xml
	}
}

結果

生成xml

<?xml version="1.0" encoding="GB2312"?>
<scores>
<employee>
<name>wangchenyang</name>
<sex>m</sex>
<age>26</age>
</employee>
</scores>

讀取xml

生成XML文件成功!
#text:

name:wangchenyang
#text:

sex:m
#text:

age:26
#text:

解析完畢

posted @ 2011-08-23 14:34 日出星辰閱讀(205) | 評論 (0) | 編輯收藏

Hibernate學習之一對一關聯

一對一關聯包括兩種類型：
1.主鍵關聯
2.惟一外鍵關聯

主鍵關聯：
兩張關聯表通過主鍵形成一對一映射關系
實例：一個公民對應一個身份證

1.主鍵關聯

實體類

TUser .java

/**
 * 主鍵關聯
 * 
 */
public class TUser implements Serializable {

	private static final long serialVersionUID = -133439792227297972L;
	private Integer id;
	private Integer age;
	private String name;
	private TPassport passport;

	..........................
}

TPassport.java

/**
 * 主鍵關聯
 * 
 */
public class TPassport implements Serializable{

	private static final long serialVersionUID = -2207892280100301351L;
	private Integer id;
	private String serial;
	private Integer expiry;
	private TUser user;
}

配置文件

Tuser.hbm.xml

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
    "-//Hibernate/Hibernate Mapping DTD 2.0//EN"
    "http://hibernate.sourceforge.net/hibernate-mapping-2.0.dtd" >
<!-- 主鍵關聯 -->    
<hibernate-mapping>
<class 
    name="com.model.TUser" 
    table="t_user"
    dynamic-update="true"
>

    <id
        name="id"
        type="java.lang.Integer"
        column="id"
        unsaved-value="0"
    >
        <generator class="native" />
    </id>
    
    <property name="name" column="name" type="string"/>
    <property name="age" column="age" type="java.lang.Integer"/>
    <one-to-one name="passport" class="com.model.TPassport" cascade="all" outer-join="false"/>
</class>
</hibernate-mapping>

Tpassport.hbm.xml

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
    "-//Hibernate/Hibernate Mapping DTD 2.0//EN"
    "http://hibernate.sourceforge.net/hibernate-mapping-2.0.dtd" >
   <!-- 主鍵關聯 -->  
<hibernate-mapping>
<class 
    name="com.model.TPassport" 
    table="t_passport"
    dynamic-update="true"
>

    <id
        name="id"
        type="java.lang.Integer"
        column="id"
        unsaved-value="0"
    >
    <!-- 由于采用了主鍵關聯方式，那么通過主鍵關聯的兩張表，其關聯記錄的主鍵值必須保持同步。
         這也就意味著，我們只需為一張表設定主鍵生成策略，而另一張表的主鍵與之共享相同的主鍵值
         通過“foreign”類型的主鍵生成策略與外鍵共享主鍵值    
     -->
        <generator class="foreign">
            <param name="property">user</param>
        </generator>
    </id>
    
    <property name="serial" column="serial" type="string"/>
    <property name="expiry" column="expiry" type="java.lang.Integer"/>
    <!-- constrained必須是“true”，以告知hibernate當前表主鍵上存在一個約束：t_passport表引用了t_user表的主鍵 -->
    <one-to-one name="user" class="com.model.TUser" constrained="true"/>
</class>
</hibernate-mapping>

測試代碼（部分）

	//主鍵關聯
	public void testSave() {
		TUser user = new TUser();
		user.setName("zhangsan");
		user.setAge(20);

		TPassport passport = new TPassport();
		passport.setExpiry(445555);
		passport.setSerial("PCN2324");

		// 設置相互關聯
		passport.setUser(user);
		user.setPassport(passport);

		try {
			Transaction tx = session.beginTransaction();
			// 由于TUser類的one-to-one節點被設置為cascade=all，其關聯的passport對象將被級聯保存
			session.save(user);
			tx.commit();
		} catch (HibernateException e) {
			e.printStackTrace();
		}
	}
	//主鍵關聯
	public void testLoad1() {
		try {
			TUser user = (TUser) session.load(TUser.class, 1);
			System.out.println("user name---->" + user.getName());
			System.out.println("passport serial---->"
					+ user.getPassport().getSerial());
		} catch (HibernateException e) {
			e.printStackTrace();
		}
		/**  out-join="true" 加載TUser實例時 hibernate通過left outer join將t_user表及其關聯的t_group表同時讀出
		 * Hibernate: select tuser0_.id as id1_, tuser0_.name as name1_,
		 * tuser0_.age as age1_, tpassport1_.id as id0_, tpassport1_.serial as
		 * serial0_, tpassport1_.expiry as expiry0_ from t_user tuser0_ 
		 * left outer join 
		 * t_passport tpassport1_ on tuser0_.id=tpassport1_.id where tuser0_.id=?
		 */
	}
	//主鍵關聯
	public void testLoad2() {
		try {
			TUser user = (TUser) session.load(TUser.class, 1);
			System.out.println("user name---->" + user.getName());
			System.out.println("passport serial---->"
					+ user.getPassport().getSerial());
		} catch (HibernateException e) {
			e.printStackTrace();
		}
		/** one-to-one節點設定為 out-join="false"時，分別讀取
		 * Hibernate: select tuser0_.id as id0_, tuser0_.name as name0_, tuser0_.age as age0_ from t_user tuser0_ where tuser0_.id=?
		 * Hibernate: select tpassport0_.id as id1_, tpassport0_.serial as serial1_, tpassport0_.expiry as expiry1_, tuser1_.id as id0_, tuser1_.name as name0_, tuser1_.age as age0_ from t_passport tpassport0_ left outer join t_user tuser1_ on tpassport0_.id=tuser1_.id where tpassport0_.id=?
		 */
	}

2.惟一外鍵關聯

實體類

TGroup.java

/**
 * 惟一外鍵關聯實體
 */
public class TGroup implements Serializable {

	private static final long serialVersionUID = 263676571059714064L;
	private Integer id;
	private String name;
	// 不加實現的是單向一對一關系 通過Tuser2對象可以獲得其相對應的Tgroup對象，但不能反過來
	// 增加是為了實現雙向一對一關系 可以互相獲得 并且還要在TGroup.cfg.xml中追加one-to-one配置
	private TUser2 user;

               .............................
}

TUser2.java

/**
 *惟一外鍵關聯實體 
 */
public class TUser2 implements Serializable{
	private static final long serialVersionUID = -1898408468538505300L;
	private Integer id;
	private Integer age;
	private String name;
	private TGroup group;

                ..................
}

配置文件

TGroup.hbm.xml

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
    "-//Hibernate/Hibernate Mapping DTD 2.0//EN"
    "http://hibernate.sourceforge.net/hibernate-mapping-2.0.dtd" >
    
<hibernate-mapping>
<class 
    name="com.model.TGroup" 
    table="t_group"
    dynamic-update="true"
>

    <id
        name="id"
        type="java.lang.Integer"
        column="id"
        unsaved-value="0"
    >
        <generator class="native" />
    </id>
    
    <property name="name" column="name" type="string"/>
    
    <one-to-one name="user" class="com.model.TUser2" property-ref="group"/>
</class>
</hibernate-mapping>

Tuser2.hbm.xml

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
    "-//Hibernate/Hibernate Mapping DTD 2.0//EN"
    "http://hibernate.sourceforge.net/hibernate-mapping-2.0.dtd" >
    
<hibernate-mapping>
<class 
    name="com.model.TUser2" 
    table="t_user2"
    dynamic-update="true"
>

    <id
        name="id"
        type="java.lang.Integer"
        column="id"
        unsaved-value="0"
    >
        <generator class="native" />
    </id>
    
    <property name="name" column="name" type="string"/>
    <property name="age" column="age" type="java.lang.Integer"/>
    <!-- 惟一外鍵關聯的一對一關系只是多對一關系的一個特例而已 -->
    <many-to-one name="group" class="com.model.TGroup" column="group_id" unique="true"/>
</class>
</hibernate-mapping>

測試代碼（部分）

public void testSave2(){
		TGroup group=new TGroup();
		group.setName("group-one");
		
		TUser2 user=new TUser2();
		user.setName("lisi");
		user.setAge(20);
		user.setGroup(group);
		try {
			Transaction tx=session.beginTransaction();
			session.save(user);
			session.save(group); //必須保存 但先后順序不要求
			tx.commit();
		} catch (HibernateException e) {
			e.printStackTrace();
		}
		
	}
	//單向 user---->group
	public void testLoad3(){
		try {
			TUser2 user=(TUser2) session.load(TUser2.class, 1);
			System.out.println("group name--->"+user.getGroup().getName());
		} catch (HibernateException e) {
			e.printStackTrace();
		}
	}

	//雙向 group-->user
	public void testLoad4(){
		/**
		 * 在TGroup.cfg.xml中不添加one-to-one配置時，查不到user信息
		 * Hibernate: select tgroup0_.id as id0_, tgroup0_.name as name0_ from t_group tgroup0_ where tgroup0_.id=?
		   Group name---->group-one
		 */
		try {
			TGroup group=(TGroup) session.load(TGroup.class, 1);
			System.out.println("Group name---->"+group.getName());
			System.out.println("group user---->"+group.getUser().getName());
		} catch (HibernateException e) {
			e.printStackTrace();
		}
		/** 添加配置后
		 * Hibernate: select tgroup0_.id as id1_, tgroup0_.name as name1_, tuser21_.id as id0_, tuser21_.name as name0_, tuser21_.age as age0_, tuser21_.group_id as group_id0_ from t_group tgroup0_ left outer join t_user2 tuser21_ on tgroup0_.id=tuser21_.group_id where tgroup0_.id=?
			Hibernate: select tuser20_.id as id1_, tuser20_.name as name1_, tuser20_.age as age1_, tuser20_.group_id as group_id1_, tgroup1_.id as id0_, tgroup1_.name as name0_ from t_user2 tuser20_ left outer join t_group tgroup1_ on tuser20_.group_id=tgroup1_.id where tuser20_.group_id=?
			Group name---->group-one
			group user---->lisi

		 */
	}

posted @ 2011-08-23 13:35 日出星辰閱讀(1184) | 評論 (0) | 編輯收藏

Hibernate學習之三種狀態及生命周期（圖）

三種狀態：

生命周期：

代碼表示：

//三種狀態
	public void testThreeState(){
		TUser user=new TUser();
		user.setName("spark");  //此時user處于Transient
		
		try {
			Transaction tx=session.beginTransaction();
			session.save(user); //user對象已經由hibernate納入管理器，處于persistent狀態
			tx.commit();
			session.close();   //user對象此時為Detached狀態，因為與其關聯的session已經關閉
			
			Transaction tx2=session2.beginTransaction();
			session2.update(user);//user對象借助session2，由hibernate納入管理容器，恢復persistent狀態   update并沒有發送sql語句
			user.setName("spark_1");//處于persistent狀態，其屬性變更將自動由hibernate固話到數據庫中   ！！！！
			tx2.commit();           //commit之前調用session.flush()在其中發送sql語句
		} catch (HibernateException e) {
			e.printStackTrace();
		}
	}

posted @ 2011-08-23 11:36 日出星辰閱讀(88) | 評論 (0) | 編輯收藏

僅列出標題

日出星辰

My Links

Blog Stats

常用鏈接

留言簿

隨筆檔案

搜索

最新評論

閱讀排行榜

評論排行榜

解決Join方法的疑惑

使用Dom4j讀取xml文件（需要引入Dom4j.jar）

Java連接數據庫方式大全

JUint測試

用序列化（Serializable)保存、讀取對象

不同格式的日期字符串轉換

很長空格的String轉換成Array數組

Java讀取、創建xml（通過dom方式）

Hibernate學習之一對一關聯

Hibernate學習之三種狀態及生命周期（圖）