二、框架学习（一）Hibernate框架学习（4）Hibernate注解开发

注解的方式与xml很很多类似：

首先是需要加入4个jar包：hibernate-commons-annotations.jar 、 hibernate-annotations.jar、ejb3-persistence.jar 、 hibernate-jpa-2.0-api-1.0.1.Final.jar

下面是不同的地方：

（1）：hibernate.hbm.xml 文件中把引用：xxx.hbm.xml改为引用实体类：

即把：<mapping resource="com/wsw/hibernate/model/Person.hbm.xml"/>

　　改为：<mapping class="com.wsw.hibernate.model.Teacher" />

（2）：获取SessionFactory方式发生了变化：

　　即：由SessionFactory sf = new Configuration().configure().buildSessionFactory()

　　改为：SessionFactory sf = new AnnotationConfiguration().configure().buildSessionFactory()

　　注意：在hibernate4之后就移除了AnnotationConfiguration()方法了，Configuration已经包含了注解的方法，所以你可以直接用：

Configuration con = new Configuration();
SessionFactory sf = con.configure().buildSessionFactory();
Session s = sf.openSession();

　　　　如果是hibernate4之前的版本还是要用AnnotationConfiguration()方法

（3）：注解方式不需要在xxx.hbm.xml把实体类与表进行映射。而采用在实体类中进行注解。

　　注意：（1）：如果实体类属性名与表字段名不一致的时候，要么都注解在属性前，要么都注解在get方法前。不能部分注解在属性前，部分注解在方法前。

　　　　（2）：如果实体类属性名与表字段名一致的时候，可以部分注解在属性前，部分注解在方法前。

　　　　（3）：如果在实体类中某些属性不注解：（属性和get都不写注解），默认为表字段名与实体类属性名一致。

（4）：如果实体类的某个成员属性不需要存入数据库中，使用@Transient 进行注解就可以了。即类似于：(xxx.hbm.Xml配置中的某些字段不写(就是不需要对这个成员属性进行映射))

（5）：表名称可以在实体类前进行注解。

（6）：所有这些注解在：javax.persistence包下。而不是在hibernate包中。

代码：

hibernate.cfg.xml配置：

 1 <?xml version="1.0" encoding="UTF-8"?>
 2 <!DOCTYPE hibernate-configuration PUBLIC
 3     "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
 4     "http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">
 5 <hibernate-configuration>
 6     <session-factory>
 7     <!-- 第一部分：配置数据库信息 -->
 8     <property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
 9     <property name="hibernate.connection.url">jdbc:mysql:///hibernate_day04</property>
10     <property name="hibernate.connection.username">root</property>
11     <property name="hibernate.connection.password">343492</property>
12     <!-- 第二部分：配置hibernate信息  可选的-->
13     <!--配置session绑定本地线程 -->
14     <property name="hibernate.current_session_context_class">thread</property>
15     
16     
17     <!--输出底层sql语句 -->
18     <property name="hibernate.show_sql">true</property>
19     <property name="hibernate.format_sql">true</property>
20     <!--hibernate帮创建表，需要配置后 
21         update：如果已经有表，更新，如果没有，创建
22     -->
23     <property name="hibernate.hbm2ddl.auto">update</property>
24     <!-- 配置数据库的方言 -->
25     <property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>
26     
27     
28     
29     <!-- 第三部分：把注解实体类放到核心配置文件中 -->
30     <mapping class="cn.itcast.entity.Customer"/>
31     <mapping class="cn.itcast.entity.LinkMan"/>
32     </session-factory>
33 </hibernate-configuration>

实体类Customer：

 1 package cn.itcast.entity;
 2 
 3 import java.util.HashSet;
 4 import java.util.Set;
 5 
 6 import javax.persistence.Column;
 7 import javax.persistence.Entity;
 8 import javax.persistence.GeneratedValue;
 9 import javax.persistence.GenerationType;
10 import javax.persistence.Id;
11 import javax.persistence.Table;
12 
13 import org.hibernate.annotations.GenericGenerator;
14 
15 
16 
17 @Entity
18 @Table(name="t_customer")
19 public class Customer{
20     private Integer cid;
21     private String custName;
22     private String custLevel;
23     private String custSource;
24     private String custPhone;
25     private String custMobile;
26     
27     @Id 
28     @GenericGenerator(name = "generator", strategy = "increment")   
29     @GeneratedValue(generator = "generator")
30     
31     @Column(name = "Cid")
32     public Integer getCid() {
33         return cid;
34     }
35 
36     public void setCid(Integer cid) {
37         this.cid = cid;
38     }
39 
40     @Column(name = "custName")
41     public String getCustName() {
42         return custName;
43     }
44 
45     public void setCustName(String custName) {
46         this.custName = custName;
47     }
48 
49     @Column(name = "custLevel")
50     public String getCustLevel() {
51         return custLevel;
52     }
53 
54     public void setCustLevel(String custLevel) {
55         this.custLevel = custLevel;
56     }
57 
58     @Column(name = "custSource")
59     public String getCustSource() {
60         return custSource;
61     }
62 
63     public void setCustSource(String custSource) {
64         this.custSource = custSource;
65     }
66 
67     @Column(name = "custPhone")
68     public String getCustPhone() {
69         return custPhone;
70     }
71 
72     public void setCustPhone(String custPhone) {
73         this.custPhone = custPhone;
74     }
75 
76     @Column(name = "custMobile")
77     public String getCustMobile() {
78         return custMobile;
79     }
80 
81     public void setCustMobile(String custMobile) {
82         this.custMobile = custMobile;
83     }
84 
85 }

实体类LinkMan：

 1 package cn.itcast.entity;
 2 
 3 import javax.persistence.Entity;
 4 import javax.persistence.GeneratedValue;
 5 import javax.persistence.GenerationType;
 6 import javax.persistence.Id;
 7 import javax.persistence.Table;
 8 
 9 import org.hibernate.annotations.GenericGenerator;
10 
11 
12 @Entity
13 @Table(name="t_linkman")
14 public class LinkMan {
15     private Integer lkm_id;
16     private String lkm_name;
17     private String lkm_gender;
18     private String lkm_phone;
19     
20     
21     
22     
23     
24     @Id 
25     @GenericGenerator(name = "generator", strategy = "increment")   
26     @GeneratedValue(generator = "generator")
27     public Integer getLkm_id() {
28         return lkm_id;
29     }
30     public void setLkm_id(Integer lkm_id) {
31         this.lkm_id = lkm_id;
32     }
33     public String getLkm_name() {
34         return lkm_name;
35     }
36     public void setLkm_name(String lkm_name) {
37         this.lkm_name = lkm_name;
38     }
39     public String getLkm_gender() {
40         return lkm_gender;
41     }
42     public void setLkm_gender(String lkm_gender) {
43         this.lkm_gender = lkm_gender;
44     }
45     public String getLkm_phone() {
46         return lkm_phone;
47     }
48     public void setLkm_phone(String lkm_phone) {
49         this.lkm_phone = lkm_phone;
50     }
51     
52     
53     
54     
55     
56 }

工具类HibernateUtils：

 1 package cn.itcast.utils;
 2 
 3 import org.hibernate.Session;
 4 import org.hibernate.SessionFactory;
 5 import org.hibernate.Transaction;
 6 import org.hibernate.cfg.Configuration;
 7 
 8 public class HibernateUtils {
 9     private final static Configuration cfg;
10     private final static SessionFactory sessionFactory;
11     //静态的代码块
12     static {
13 //        第一步 加载hibernate核心配置文件
14         //在hibernate里面封装了对象
15         cfg = new Configuration();
16         cfg.configure();
17         
18         
19 //        第二步创建 Sessionfactory对象
20         //读取hibernate核心配置文件内容，创建ssssionFactory
21         //在过程中，根据映射关系，在配置数据库里面把表创建了
22         sessionFactory = cfg.buildSessionFactory();
23     }
24     
25     //提供返回与本地线程绑定的session的方法
26     public static Session getSession(){
27         return sessionFactory.getCurrentSession();
28     }
29     
30     
31     
32     public static SessionFactory getSessionFactory(){
33         return sessionFactory;
34     }
35     
36     public static void main(String[] args){
37         
38     }
39 }

测试类test：

 1 package cn.itcast.hibernatetest;
 2 
 3 import java.util.HashSet;
 4 import java.util.List;
 5 import java.util.Set;
 6 
 7 import org.hibernate.Criteria;
 8 import org.hibernate.Query;
 9 import org.hibernate.SQLQuery;
10 import org.hibernate.Session;
11 import org.hibernate.SessionFactory;
12 import org.hibernate.Transaction;
13 import org.hibernate.criterion.DetachedCriteria;
14 import org.hibernate.criterion.Order;
15 import org.hibernate.criterion.Projections;
16 import org.hibernate.criterion.Restrictions;
17 import org.junit.Test;
18 
19 import cn.itcast.entity.Customer;
20 import cn.itcast.entity.LinkMan;
21 import cn.itcast.utils.HibernateUtils;
22 
23 public class test {
24     //存储数据
25     @Test
26     public void test(){
27         SessionFactory sessionFactory=HibernateUtils.getSessionFactory();
28         Session session=sessionFactory.openSession();
29         Transaction tx=session.beginTransaction();
30         
31         Customer customer=new Customer();
32         customer.setCustLevel("1");
33         customer.setCustMobile("3435692");
34         customer.setCustName("阿里巴巴");
35         customer.setCustPhone("18863897308");
36         customer.setCustSource("北京海淀");
37         
38         session.save(customer);
39         tx.commit();
40         session.close();
41         sessionFactory.close();
42     }
43 
44 }

Hibernate中的常用注解：

1，@Entity : 表示当前的类为实体类，声明在类的前面。可以将当前类和数据库的表和字段进行关联映射。

2，@Table:表示映射的表，声明在类的前面

3，@Id:表示主键的映射，声明在主键的get方法前边，默认情况下主键利用assigned（用户提供）生成策略。如果想要设置API规范提供了四种主键生成策略：

@GeneratedValue(strategy=GenerationType.AUTO)      相当于Hibernate框架的native主键生成策略

@GeneratedValue(strategy=GenerationType.IDENTITY) 相当于Hibernate框架的identity主键生成策略，适用于MySQL,SQL Server

@GeneratedValue(strategy=GenerationType.SEQUENCE) 相当于Hibernate框架的sequence主键生成策略，适用于Oracle,DB2

@GeneratedValue(strategy=GenerationType.TABLE)     使用一张单表管理主键值。

         默认情况下API规范是不支持Hibernate框架中的uuid的主键生成策略，假如我们想要使用，需要我们进行增加主键生成器，如下：

@GenericGenerator(name="hibernate-uuid",strategy="uuid")

@GeneratedValue(generator="hibernate-uuid")

4，@Column : 表示映射属性，和表的字段进行关联

5，@ManyToOne : 表示映射关系中的多对一

6，@JoinColumn : 表示外键映射属性，和表的外键字段进行关联

7，@OneToMany : 表示映射关系中的一对多，这里需要注意，一对多时，外键的维护需要翻转交给多的一方进行维护，需要配置反转属性mappedBy,属性取值为多的一方的映射属性名称。相当于xml配置文件中的Inverse="true"。

8，@OrderBy : 表示排序字段

9，@Transient ：表示声明瞬时属性，不和数据库的字段发生关联，也就是没有表中列与之映射。

posted @ 2018-01-17 16:23 秋心无波阅读(174) 评论(0) 编辑收藏举报

会员力量，点亮园子希望

刷新页面返回顶部

秋心无波

二、框架学习 （一）Hibernate框架学习 （4）Hibernate注解开发

公告

二、框架学习（一）Hibernate框架学习（4）Hibernate注解开发