1、ssh框架開發的應用層級結構

j2ee應用可以分為3層：

1、表示層


2、業務邏輯層


3、資料服務層

ssh將應用分層更加細化（ssh將業務邏輯層劃分了4層）：

1、action層（控制層mvc中的c層）


2、service層  （業務層mvc中的m層）


3、dao層（資料訪問層）

4、entity層（資料實體層）

2、ssh中各個框架的作用

strust：

整個應用架構的骨架，負責應用中mvc模型的實現，向下層傳遞前端請求，向上層傳遞服務響應，主要作用於action層；

spring：

主要作用是依賴注入和控制反轉以達到解耦的目的，用於對整個應用中的bean例項進行管理，作用於ssh各個層；

hibernate：

主要用於資料庫操作，提供了便捷的資料庫操作框架，主要作用於dao層；

3、ssh全註解框架搭建

1、建立web專案並勾選web.xml

2、匯入ssh所需jar

        

可以去官網下載ssh所需jar包或者在我的資源中下載（解壓後的lib資料夾中）：http://download.csdn.net/download/duoluo9/9990702

3、配置web.xml

<?xmlversion="1.0"encoding="UTF-8"?>

<web-appxmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xmlns="http://java.sun.com/xml/ns/javaee"

xsi:schemaLocation="http://java.sun.com/xml/ns/javaeehttp://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"id="WebApp_ID"version="2.5">

 <display-name>demo1</display-name>

 <welcome-file-list>

   <welcome-file>index.html</welcome-file>

   <welcome-file>index.htm</welcome-file

>

   <welcome-file>index.jsp</welcome-file>

   <welcome-file>default.html</welcome-file>

   <welcome-file>default.htm</welcome-file>

   <welcome-file>default.jsp</welcome-file>

 </welcome-file-list>

 <filter>

   <filter-name>action2</filter-name>

   <filter-class>org.apache.struts2.dispatcher.filter.StrutsPrepareAndExecuteFilter</filter-class>

   <!-- 自動掃描action --> 

   <init-param> 

     <param-name>actionPackages</param-name> 

     <param-value>ssh.action</param-value> 

   </init-param>   

 </filter>

 <filter-mapping>

   <filter-name>action2</filter-name>

   <url-pattern>/*</url-pattern>

 </filter-mapping>

 <!-- spring監聽器配置開始 -->

 <context-param>

   <param-name>contextConfigLocation</param-name>

   <param-value>classpath:applicationContext.xml</param-value>

 </context-param>

 <listener>

   <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>

 </listener>

</web-app>

4、配置spring的applicationContext.xml

<?xmlversion="1.0"encoding="UTF-8"?>

<beansxmlns="http://www.springframework.org/schema/beans"

    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xmlns:context="http://www.springframework.org/schema/context"

    xmlns:tx="http://www.springframework.org/schema/tx"

    xsi:schemaLocation="http://www.springframework.org/schema/beanshttp://www.springframework.org/schema/beans/spring-beans-3.0.xsd     

                http://www.springframework.org/schema/contexthttp://www.springframework.org/schema/context/spring-context-3.0.xsd     

               http://www.springframework.org/schema/txhttp://www.springframework.org/schema/tx/spring-tx-3.0.xsd">

<!--    <bean id="northMan"class="ssh.entity.NorthMan"></bean>

    <beanid="southMan" class="ssh.entity.SouthMan"></bean>

 -->

    <!-- 自動掃描與裝配bean -->

    <context:component-scanbase-package="ssh.*"></context:component-scan>

    <context:annotation-config/>

    <!-- dbcp配置 -->

    <beanid="dataSource"class="org.apache.commons.dbcp2.BasicDataSource"

        destroy-method="close">

        <propertyname="driverClassName">

            <value>com.mysql.jdbc.Driver</value>

        </property>

        <propertyname="url">

            <value>jdbc:mysql://127.0.0.1:3306/test?useUnicode=true&amp;characterEncoding=utf-8&amp;useSSL=false</value>

        </property>

        <propertyname="username">

            <value>root</value>

        </property>

        <propertyname="password">

            <value>root</value>

        </property>

    </bean>

    <beanid="sessionFactory"

        class="org.springframework.orm.hibernate4.LocalSessionFactoryBean">

        <propertyname="dataSource">

            <reflocal="dataSource"/>

        </property>

        <propertyname="hibernateProperties">

            <props>

                <!--配置Hibernate的方言 -->

                <propkey="hibernate.dialect">

                    org.hibernate.dialect.MySQLDialect

                </prop>

                <propkey="hibernate.hbm2ddl.auto">update</prop>

                <!--格式化輸出sql語句 -->

                <propkey="hibernate.show_sql">true</prop>

                <propkey="hibernate.format_sql">true</prop>

                <propkey="hibernate.use_sql_comments">false</prop>

            </props>

        </property>

        <!--自動掃描實體 -->

        <propertyname="packagesToScan"value="ssh.entity"/>

    </bean>

    <!-- 用註解來實現事務管理 -->

    <beanid="txManager"

        class="org.springframework.orm.hibernate4.HibernateTransactionManager">

        <propertyname="sessionFactory"ref="sessionFactory"></property>

    </bean>

    <tx:annotation-driventransaction-manager="txManager"/>

</beans>  

4、ssh中用到的註解標籤（來源於網路）

strust:

名稱空間註釋（動作註釋）：


@ Namespace註釋允許在Action類中，而不是基於零配置的約定動作的名稱空間的定義。


@Namespace("/content")
public class Employee extends ActionSupport{
 ...
}
結果註釋 - （動作譯註）：


@ Result註解允許在Action類中，而不是一個XML檔案中定義的動作結果。


@Result(name="success", value="/success.jsp")
public class Employee extends ActionSupport{
 ...
}
結果註釋 - （動作譯註）：


@ Results註解定義了一套動作的結果。


@Results({
  @Result(name="success", value="/success.jsp"),
  @Result(name="error", value="/error.jsp")
})
public class Employee extends ActionSupport{
 ...
}
註釋後（攔截註釋）：


@After註解標誌著一個需要呼叫後的主要操作方法和執行結果的操作方法。返回值將被忽略。


public class Employee extends ActionSupport{
  @After
  public void isValid() throws ValidationException {
   // validate model object, throw exception if failed
  }
  public String execute() {
   // perform secure action
   return SUCCESS;
  }
}
註釋之前（攔截註釋）：


@ Before註釋標記需要一個操作方法的主要操作方法之前被呼叫執行結果。返回值將被忽略。


public class Employee extends ActionSupport{
  @Before
  public void isAuthorized() throws AuthenticationException {
   // authorize request, throw exception if failed
  }
  public String execute() {
   // perform secure action
   return SUCCESS;
  }
}
BeforeResult註釋 - （攔截註釋）：


@ BeforeResult註解標誌著一個結果之前需要執行的操作方法。返回值將被忽略。


public class Employee extends ActionSupport{
  @BeforeResult
  public void isValid() throws ValidationException {
  // validate model object, throw exception if failed
  }
 
  public String execute() {
   // perform action
   return SUCCESS;
  }
}
ConversionErrorFieldValidator註釋 - （驗證譯註）：


此驗證註解如果有任何轉換錯誤進行了實地檢查，並適用於他們，如果他們存在。


public class Employee extends ActionSupport{
  @ConversionErrorFieldValidator(message = "Default message", 
            key = "i18n.key", shortCircuit = true)
  public String getName() {
    return name;
  }
}
DateRangeFieldValidator註釋 - （驗證譯註）：


這驗證註解檢查日期欄位的值在指定範圍內。


public class Employee extends ActionSupport{
  @DateRangeFieldValidator(message = "Default message", 
  key = "i18n.key", shortCircuit = true, 
  min = "2005/01/01", max = "2005/12/31")
  public String getDOB() {
    return dob;
  }
}
DoubleRangeFieldValidator註釋 - （驗證譯註）：


此驗證註解檢查雙欄位有一個值，該值在指定範圍內。如果既不最小或最大，什麼都不會做的。


public class Employee extends ActionSupport{
 
  @DoubleRangeFieldValidator(message = "Default message", 
  key = "i18n.key", shortCircuit = true, 
  minInclusive = "0.123", maxInclusive = "99.987")
  public String getIncome() {
    return income;
  }
}
EmailValidator註釋 - （驗證譯註）：


這驗證註解檢查一個欄位是一個有效的E-mail地址，如果它包含一個非空的字串。


public class Employee extends ActionSupport{
 
  @EmailValidator(message = "Default message", 
  key = "i18n.key", shortCircuit = true)
  public String getEmail() {
    return email;
  }
}
ExpressionValidator註釋 - （驗證譯註）：


這種非欄位級驗證驗證所提供的正則表示式。


@ExpressionValidator(message = "Default message", key = "i18n.key", 


shortCircuit = true, expression = "an OGNL expression" )


IntRangeFieldValidator註釋 - （驗證譯註）：


這驗證註解檢查一個數字欄位的值在指定的範圍內。如果既不最小或最大，什麼都不會做的。


public class Employee extends ActionSupport{
 
  @IntRangeFieldValidator(message = "Default message", 
  key = "i18n.key", shortCircuit = true, 
  min = "0", max = "42")
  public String getAge() {
    return age;
  }
}
RegexFieldValidator 註釋 - （驗證譯註）：


這個註解驗證一個字串欄位，使用正則表示式。


@RegexFieldValidator( key = "regex.field", expression = "yourregexp")


RequiredFieldValidator 註釋 - （驗證譯註）：


這驗證註解檢查一個欄位不為空。標註必須被應用在方法層面。


public class Employee extends ActionSupport{
 
  @RequiredFieldValidator(message = "Default message", 
  key = "i18n.key", shortCircuit = true)
  public String getAge() {
    return age;
  }
}
RequiredStringValidator註釋 - （驗證譯註）：


這驗證註解檢查一個字串欄位不為空（即非空，長度> 0）。


public class Employee extends ActionSupport{
 
  @RequiredStringValidator(message = "Default message", 
  key = "i18n.key", shortCircuit = true, trim = true)
  public String getName() {
    return name;
  }
}
StringLengthFieldValidator註釋 - （驗證譯註）：


這個驗證檢查字串欄位是合適的長度。假定該欄位是一個字串。如果設定既不是minLength 也不是最大長度，什麼都不會做。


public class Employee extends ActionSupport{
 
  @StringLengthFieldValidator(message = "Default message", 
  key = "i18n.key", shortCircuit = true, 
  trim = true, minLength = "5", maxLength = "12")
  public String getName() {
    return name;
  }
}
UrlValidator註釋 - （驗證譯註）：


這個驗證檢查一個欄位是一個有效的URL。


public class Employee extends ActionSupport{
 
  @UrlValidator(message = "Default message", 
  key = "i18n.key", shortCircuit = true)
  public String getURL() {
    return url;
  }
}
驗證註釋 - （驗證譯註）：


如果想使用多個相同型別的註釋，這些註釋必須巢狀在@Validations() 註釋。


public class Employee extends ActionSupport{
 
 @Validations(
  requiredFields =
   {@RequiredFieldValidator(type = ValidatorType.SIMPLE, 
   fieldName = "customfield", 
   message = "You must enter a value for field.")},
  requiredStrings =
   {@RequiredStringValidator(type = ValidatorType.SIMPLE, 
   fieldName = "stringisrequired", 
   message = "You must enter a value for string.")}
  )
  public String getName() {
    return name;
  }
}
CustomValidator註釋 - （驗證譯註）：


這個註解可以用於自定義驗證。使用ValidationParameter的註釋，以提供額外的 params.


@CustomValidator(type ="customValidatorName", fieldName = "myField")
轉換註釋 - （型別轉換註釋）：


這是一個標記註釋型別轉換型別級別。轉換註釋必須應用在型別級別。


@Conversion()
  public class ConversionAction implements Action {
}
CreateIfNull註釋 - （型別轉換註釋）：


這個註解設定型別轉換CreateIfNull。必須應用在域或方法級CreateIfNull註解。


@CreateIfNull( value = true )
private List<User> users;
元素註釋 - （型別轉換註釋）：


這個註解設定元素進行型別轉換。必須應用在欄位域或方法級元素的註解。


@Element( value = com.acme.User )
private List<User> userList;
關鍵註釋 - （型別轉換註釋）：


這個註解設定進行型別轉換的關鍵。必須應用在域或方法級的關鍵註解。


@Key( value = java.lang.Long.class )
private Map<Long, User> userMap;
KeyProperty註釋 - （型別轉換註釋）：


這個註解設定型別轉換KeyProperty。必須應用在域或方法級KeyProperty註解。


@KeyProperty( value = "userName" )
protected List<User> users = null;
TypeConversion註釋 - （型別轉換註釋）：


這個註解的註解是用於類和應用程式的轉換規則。註解可以應用於TypeConversion在屬性和方法的級別。


@TypeConversion(rule = ConversionRule.COLLECTION, 
converter = "java.util.String")
public void setUsers( List users ) {
  this.users = users;
}

spring :

使用 @Repository、@Service、@Controller 和 @Component 將類標識為 Bean
使用 @PostConstruct 和 @PreDestroy 指定生命週期回撥方法
使用 @Required 進行 Bean 的依賴檢查
使用 @Resource、@Autowired 和 @Qualifier 指定 Bean 的自動裝配策略
使用 @Configuration 和 @Bean 進行 Bean 的宣告
混合使用 XML 與註解進行 Bean 的配置

hibernate:

@Entity --註釋宣告該類為持久類。將一個Javabean類宣告為一個實體的資料庫表對映類,最好實現序列化.此時,預設情況下,所有的類屬性都為對映到資料表的永續性欄位.若在類中,新增另外屬性,而非對映來資料庫的,要用下面的Transient來註解.


@Table(name="promotion_info") --永續性對映的表(表名="promotion_info)[email protected]是類一級的註解,定義在@Entity下,為實體bean對映表,目錄和schema的名字,預設為實體bean的類名,不帶包名.


@Id--註釋可以表明哪種屬性是該類中的獨特識別符號(即相當於資料表的主鍵)。 
@GeneratedValue --定義自動增長的主鍵的生成策略. 
@Transient --將忽略這些欄位和屬性,不用持久化到資料庫.適用於,在當前的持久類中,某些屬性不是用於對映到資料表,而是用於其它的業務邏輯需要,這時,須將這些屬性進行transient的註解.否則系統會因對映不到資料表相應欄位而出錯. 
@Temporal(TemporalType.TIMESTAMP)--宣告時間格式 
@Enumerated --宣告列舉 
@Version --宣告新增對樂觀鎖定的支援 
@OneToOne --可以建立實體bean之間的一對一的關聯 
@OneToMany --可以建立實體bean之間的一對多的關聯 
@ManyToOne --可以建立實體bean之間的多對一的關聯 
@ManyToMany --可以建立實體bean之間的多對多的關聯 
@Formula --一個SQL表示式，這種屬性是隻讀的,不在資料庫生成屬性(可以使用sum、average、max等) 
@OrderBy --Many端某個欄位排序(List)
1.2
Hibernate 能夠出色地自動生成主鍵。Hibernate/EBJ 3 註釋也可以為主鍵的自動生成提供豐富的支援，允許實現各種策略。
其生成規則由@GeneratedValue設定的.這裡的@id和@GeneratedValue都是JPA的標準用法, JPA提供四種標準用法,由@GeneratedValue的原始碼可以明顯看出. 
JPA提供的四種標準用法為TABLE,SEQUENCE,IDENTITY,AUTO. 
TABLE：使用一個特定的資料庫表格來儲存主鍵。 
SEQUENCE：根據底層資料庫的序列來生成主鍵，條件是資料庫支援序列。 
IDENTITY：主鍵由資料庫自動生成（主要是自動增長型） 
AUTO：主鍵由程式控制。 


在指定主鍵時，如果不指定主鍵生成策略，預設為AUTO。 
@Id
相當於
@Id
@GeneratedValue(strategy = GenerationType.AUTO)
identity:
使用SQL Server 和 MySQL 的自增欄位，這個方法不能放到 Oracle 中，Oracle 不支援自增欄位，要設定sequence（MySQL 和 SQL Server 中很常用）。
Oracle就要採用sequence了.
同時,也可採用uuid,native等其它策略.(相關用法,上網查詢)
[2]
第一個永續性類 
@Entity 
@Table(name="T_MODEL_PLANE") 
public class ModelPlane implements Serializable { 
@Id 
@Column(name="PLANE_ID") 
@GeneratedValue(strategy=GenerationType.AUTO) //註解於屬性中 
/* 
對於oracle想使用各自的Sequence,設定如下: 
@GeneratedValue(strategy = GenerationType.AUTO,generator="PROMOTION_SEQ") 
@SequenceGenerator(name="PROMOTION_SEQ",sequenceName="PROMOTION_SEQ")
另外:
對於自動增長後,在資料表中的相應欄位,要設定欄位為auto_increment.
*/ 
private Long id; 


private String name;//註解寫於getter方法之上.請見下. 


//DATE - java.sql.Date 
//TIME - java.sql.Time 
//TIMESTAMP - java.sql.Timestamp 
@Temporal(TemporalType.TIMESTAMP) 
@Column(name="start_time") 
private Date startTime; 


//顯示0 隱藏1 
public static enum DisplayType {顯示,隱藏} 
@Enumerated(value = EnumType.ORDINAL)//ORDINAL序數 
private DisplayType displayType = DisplayType.顯示; 


//1.sql語句中的欄位和表名都應該和資料庫相應,而不是類中的欄位, 
//若帶有引數如la.id= id,這個=id才是類中屬性 
//2.操作欄位一定要用別名 
@Formula(select COUNT(la.id) from largess la) 
private int count; 


//註解於方法中 
@Column(name="PLANE_ID", length=80, nullable=true) //較詳細定義 
public String getName() { 
return name; 
} 
public void setName(String name) { 
this.name = name; 
} 
其它的setter,getter省略...... 
}


該內容將對映到下表中： 
CREATE TABLE T_MODEL_PLANE 
( 
PLANE_ID long, 
PLANE_NAME varchar 
其它欄位省略... 
)


預設情況下，Hibernate 會將持久類以匹配的名稱對映到表和欄位中。例如，下例中，若不用註解，則會對映到如下一表中：
CREATE TABLE MODELPLANE
(
ID long,
NAME varchar


其它欄位省略...
)


[3]
一對多註解:
1.
在一對多註解中,會用到:
"一"方：
@OneToMany --> mappedBy:"多"方的關聯屬性(被控方)
"多"方：
@ManyToOne --> @JoinColumn，"多"方定義的外來鍵欄位.
如資料表定義外來鍵如下:
FOREIGN KEY (classid) REFERENCES classes(id)
則:
@JoinColumn(name="classid")
2.
在雙向關聯中，有且僅有一端作為主體（owner）端存在：主體端負責維護聯接列（即更新），對於不需要維護這種關係的從表則通過mappedNy屬性進行宣告。mappedBy的值指向另一主體的關聯屬性。例子中，mappedBy的值為classes。
附加說明:
mappedBy相當於過去的inverse="true".
inverse=false的side（side其實是指inverse＝false所位於的class元素）端有責任維護關係，而inverse＝true端無須維護這些關係。
3.
cascade與fetch使用說明:
Cascade
CascadeType.PERSIST （級聯新建） 
CascadeType.REMOVE （級聯刪除） 
CascadeType.REFRESH （級聯重新整理） 
CascadeType.MERGE （級聯更新）中選擇一個或多個。 
CascadeType.ALL
fetch屬性：
關聯關係獲取方式,即是否採用延時載入。
LAZY（預設值）採用延時載入，查詢資料時，不一起查詢關聯物件的資料。而是當訪問關聯物件時(如：getStudnets()時)才觸發相應的查詢操作，獲取關聯物件資料。
EAGER：是在查詢資料時，也直接一起獲取關聯物件的資料。
package oneToMany; 
import java.util.Set; 
import javax.persistence.*; 
/* 
注意匯入時，是匯入：import javax.persistence.*; 
非匯入org.hibernate的相關類：import org.hibernate.annotations.Entity; 
*/ 
@Entity 
@Table(name="classes") 
public class Classes implements Serializable { 
@Id 
@GeneratedValue(strategy=GenerationType.AUTO) 
private int id; 
private String name; 


@OneToMany(cascade=CascadeType.ALL,mappedBy="classes") 
private Set<Student> students; 
//getter,setter省略 
} 




package oneToMany; 
import javax.persistence.*; 
@Entity 
@Table(name="student") 
public class Student implements Serializable { 
@Id 
@GeneratedValue(strategy=GenerationType.AUTO) 
private int sid; 


private String sname; 


//若有多個cascade，可以是：{CascadeType.PERSIST,CascadeType.MERGE} 
@ManyToOne(cascade={CascadeType.ALL}) 
@JoinColumn(name="classid") //student類中對應外來鍵的屬性：classid 
private Classes classes; 
//getter,setter省略 
} 




public class TestOneToMany { 
/* 
CREATE TABLE student ( --要定義外來鍵!!!!!!! 
`sid` double NOT NULL auto_increment, 
`classid` double NULL, 
`sname` varchar(255) NOT NULL, 
PRIMARY KEY (sid), 
INDEX par_ind (classid), 
FOREIGN KEY (classid) REFERENCES classes(id) ON DELETE CASCADE ON UPDATE CASCADE 
) ENGINE=InnoDB 
*/ 
public static void main(String[] args) throws SQLException 
{ 
try 
{ 
SessionFactory sf = new AnnotationConfiguration().configure().buildSessionFactory(); 
Session session=sf.openSession(); 
Transaction tx=session.beginTransaction();
/*
因為mappedBy是定義在classes中,即classes類不負責維護級聯關係.即維護者是student.所以,
1.要將clsses的資料,賦給student,即用student的setClasses()方法去捆定class資料;
2.在進行資料插入/更新session.save()/session.update()時,最後操作的是student.
*/
Classes classes=new Classes(); 
classes.setName("access"); 


Student st1=new Student(); 
st1.setSname("jason"); 
st1.setClasses(classes); 
session.save(st1); 


Student st2=new Student(); 
st2.setSname("hwj"); 
st2.setClasses(classes); 
session.save(st2); 
tx.commit();
/*
輸出如下:
Hibernate: insert into classes (name) values (?)
Hibernate: insert into student (classid, sname) values (?, ?)
Hibernate: insert into student (classid, sname) values (?, ?)
*/


/*
因為一端維護關係另一端不維護關係的原因，我們必須注意避免在應用中用不維護關係的類(class)建立關係，因為這樣建立的關係是不會在資料庫中儲存的。
如上的程式碼倒過來,則插入時,student的外來鍵值為空.如下:
*/
// Student st1=new Student(); 
// st1.setSname("jason"); 
// session.save(st1); 
// 
// Student st2=new Student(); 
// st2.setSname("hwj"); 
// session.save(st2); 
// 
// Set<Student> students=new HashSet<Student>(); 
// students.add(st1); 
// students.add(st2); 
// 
// Classes classes=new Classes(); 
// classes.setName("access"); 
// classes.setStudents(students); 
// session.save(classes);
/*
輸出如下:
Hibernate: insert into student (classid, sname) values (?, ?)
Hibernate: insert into student (classid, sname) values (?, ?)
Hibernate: insert into classes (name) values (?)
*/
} 
catch(HibernateException e) 
{ 
e.printStackTrace(); 
} 
} 
}




[4]
多對多註解:
在多對多註解中,雙方都採用@ManyToMany.
其中被控方,像一對多註解中設定一樣,也要設定mappedBy.
其中主控方,不像一對多註解那樣,採用@joinColumn,而是採用@joinTable.如下:
@JoinTable(name="j_student_course" ,joinColumns={@JoinColumn(name="sid")},inverseJoinColumns={@JoinColumn(name="cid")})
其中,
如上所說,mappedBy,相當於inverse="true".所以,在@joinTable中的inverseJoinColumns中定義的欄位為mappedBy所在類的主鍵.
joinColumns定義的欄位,就是當前類的主鍵.
@Entity 
@Table(name="jcourse") 
public class Jcourse { 
@Id 
@GeneratedValue(strategy=GenerationType.AUTO) 
private int cid; 
private String cname; 


@ManyToMany(cascade={CascadeType.PERSIST,CascadeType.MERGE},fetch=FetchType.LAZY ,mappedBy="courses") 
private Set<Jstudent> students; 
//setter,getter省略.... 
} 




@Entity 
@Table(name="jstudent") 
public class Jstudent { 
@Id 
@GeneratedValue(strategy=GenerationType.AUTO) 
private int sid; 


private String sname; 


@ManyToMany(cascade={CascadeType.PERSIST,CascadeType.MERGE},fetch=FetchType.EAGER) 
//inverseJoinColumns中對應的id為以下屬性course的對應id. 
@JoinTable(name="j_student_course" ,joinColumns={@JoinColumn(name="sid")},inverseJoinColumns={@JoinColumn(name="cid")}) 
private Set<Jcourse> courses; 
//setter,getter省略.... 
} 




public class Test { 
public static void main(String[] args) { 
try 
{ 
SessionFactory sf = new AnnotationConfiguration().configure().buildSessionFactory(); 
Session session=sf.openSession(); 
Transaction tx=session.beginTransaction(); 


Jcourse course=new Jcourse(); 
course.setCname("jason-english"); 
session.save(course); //先各自儲存. 


Jcourse course2=new Jcourse(); 
course2.setCname("herry-english"); 
session.save(course2); 


Set<Jcourse> courses=new HashSet<Jcourse>(); 
courses.add(course); 
courses.add(course2); 


Jstudent student=new Jstudent(); 
student.setSname("jason"); 
student.setCourses(courses); 


session.save(student);// 要用非mapby定義的類(studet)來作為主者(會控制級聯關係),一對多,多對一也一樣道理. 
//可以嘗試反過來. 
tx.commit(); 
} 
catch(HibernateException e) 
{ 
e.printStackTrace(); 
} 
} 

}

原始碼地址：

https://github.com/duoluo9/ssh-conformity