很長時間對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);
}
}
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
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
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);
}
}
實現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>
先把字符串日期轉換成對應的格式，然后再轉換成日期
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
開發中碰到了一個需求，需要把鍵值對字符串分隔，但鍵值之間空格很多，只用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
創建一個接口
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:
解析完畢
一對一關聯包括兩種類型：
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
*/
}
三種狀態：
生命周期：
代碼表示：
//三種狀態
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();
}
}