Hibernate注解

时间：2015-12-22 06:25:34 阅读：256 评论：0 收藏：0 [点我收藏+]

标签：

前言：

　　最近正在学习Hibernate通过注解（annotation）来管理映射关系，以前都是通过XML映射文件。下面拿个小例子说一下。

数据库物理模型：

技术分享

数据库的描述：

　　一篇博客随笔可以分到不同的类中，一个类中又可以包含许多不同的博客随笔。就如同博客园的设计。也就是上图中博客-组和博客-消息是多对多的映射。

Hibernate关联映射方式：

　　双向N-N关联，两端都要使用Set集合属性，两端都增加对集合属性的访问。双向N-N关联没有太多的选择，只能采用连接表来建立两个实体之间的关联关系。

生成sql语句：

drop table if exists blogGroup;

drop table if exists blogMessage;

drop table if exists groupMessage;

create table blogGroup
(
   groupId              int not null auto_increment,
   groupName            varchar(50),
   primary key (groupId)
);

create table blogMessage
(
   msgId                int not null auto_increment,
   msgContent           varchar(1000),
   primary key (msgId)
);

create table groupMessage
(
   groupId              int not null,
   msgId                int not null,
   primary key (groupId, msgId)
);

alter table groupMessage add constraint FK_Relationship_1 foreign key (groupId)
      references blogGroup (groupId) on delete restrict on update restrict;

alter table groupMessage add constraint FK_Relationship_2 foreign key (msgId)
      references blogMessage (msgId) on delete restrict on update restrict;

PO（persisent object）类：

　　PO = POJO(plain ordinary java object) + 注解

PO : BlogGroup

package com.blog.entriy;

@Entity
@Table(name="blogGroup")
public class BlogGroup implements Serializable{
    @Id
    @Column(name="groupId")
    @GeneratedValue(strategy=GenerationType.IDENTITY)
    private int groupId;
    @Column(name="groupName")
    private String groupName;
    
    //fetch=FetchType.EAGER 抓取实体时，立即抓取关联实体，我用的get（）方式加载一个对象
    //ascadeType.PERSIST, CascadeType.MERGE, 分别是更新和保存时级联
    @ManyToMany(targetEntity=BlogMessage.class, cascade={CascadeType.PERSIST, CascadeType.MERGE}, fetch=FetchType.EAGER)
    @JoinTable(name="groupMessage",
        joinColumns=@JoinColumn(name="groupId", referencedColumnName="groupId"),
        inverseJoinColumns=@JoinColumn(name="msgId", referencedColumnName="msgId")
    )
    private Set<BlogMessage> message = new HashSet<BlogMessage>();
    
    public int getGroupId() {
        return groupId;
    }
    public void setGroupId(int groupId) {
        this.groupId = groupId;
    }
    public String getGroupName() {
        return groupName;
    }
    public void setGroupName(String groupName) {
        this.groupName = groupName;
    }
    public Set<BlogMessage> getMessage() {
        return message;
    }
    public void setMessage(Set<BlogMessage> message) {
        this.message = message;
    }
}

PO : BlogMessage

package com.blog.entriy;

@Entity
@Table(name="blogMessage")
public class BlogMessage implements Serializable{
    @Id
    @Column(name="msgId")
    @GeneratedValue(strategy=GenerationType.IDENTITY)
    private int msgId;
    @Column(name="msgContent")
    private String msgContent;
    
    @ManyToMany(targetEntity=BlogGroup.class)
    @JoinTable(name="groupMessage",
        joinColumns=@JoinColumn(name="msgId", referencedColumnName="msgId"),
        inverseJoinColumns=@JoinColumn(name="groupId", referencedColumnName="groupId")
    )
    private Set<BlogGroup> group = new HashSet<BlogGroup>();
    
    public int getMsgId() {
        return msgId;
    }
    
    public void setMsgId(int msgId) {
        this.msgId = msgId;
    }
    public String getMsgContent() {
        return msgContent;
    }
    public void setMsgContent(String msgContent) {
        this.msgContent = msgContent;
    }
    public Set<BlogGroup> getGroup() {
        return group;
    }
    public void setGroup(Set<BlogGroup> group) {
        this.group = group;
    }
}

DAO层：

　　分别测试了不同方式的插入操作，以及更新和删除。具体看函数的实现。

package com.blog.dao;


public class BlogDao {
   private SessionFactory sessionFactory;  
    
    public Session getSession() {  
        return sessionFactory.getCurrentSession();  
    }  
  
    public SessionFactory getSessionFactory() {  
        return sessionFactory;  
    }  
  
    public void setSessionFactory(SessionFactory sessionFactory) {  
        this.sessionFactory = sessionFactory;  
    }  
    
    public BlogGroup get_test(int id){
        BlogGroup blogGroup = null;
        Session session = null;
        Transaction tran = null;
        try{
            session = this.getSession();
            tran = session.beginTransaction();
            blogGroup = (BlogGroup)session.get(BlogGroup.class, id);
            tran.commit();
        } catch(Exception e){
            System.out.println(e.toString());
            tran.rollback();
        }
        return blogGroup;
    }
    
　　//只插入一端博客-组（BlogGroup）
    public void insert_test1(){
        Session session = null;
        Transaction tran = null;
        try{
            session = this.getSession();
            tran = session.beginTransaction();
            BlogGroup blogGroup = new BlogGroup();
            blogGroup.setGroupName("html");
            session.save(blogGroup);
            tran.commit();
        } catch(Exception e){
            System.out.println(e.toString());
            tran.rollback();
        }
    }
    //同时插入两端（博客-组 和 博客-消息），没有用cascade级联操作，所以BlogGroup和BlogMessage两端都要先持久化
    public void insert_test2(){
        Session session = null;
        Transaction tran = null;
        try{
            session = this.getSession();
            tran = session.beginTransaction();
            BlogGroup blogGroup = new BlogGroup();
            blogGroup.setGroupName("c++");
            BlogMessage blogMessage = new BlogMessage();
            blogMessage.setMsgContent("c++ primer");
            session.save(blogMessage);
            Set<BlogMessage> message = new HashSet<BlogMessage>();
            message.add(blogMessage);
            blogGroup.setMessage(message);
            session.save(blogGroup);
            tran.commit();
        } catch(Exception e){
            System.out.println(e.toString());
            tran.rollback();
        }
    }
    //同时插入两端,对BlogGroup设置persist级联操作 @ManyToMany(cascade={CascadeType.PERSIST})
    public void insert_test3(){
        Session session = null;
        Transaction tran = null;
        try{
            session = this.getSession();
            tran = session.beginTransaction();
            BlogGroup blogGroup = new BlogGroup();
            blogGroup.setGroupName("javaee");
            BlogMessage blogMessage = new BlogMessage();
            blogMessage.setMsgContent("Spring+hibernate+struct");
            blogGroup.getMessage().add(blogMessage);
            session.persist(blogGroup);
            tran.commit();
        } catch(Exception e){
            System.out.println(e.toString());
            tran.rollback();
        }
    }
    //向博客-组（BlogGroup）添加新的 博客-消息（BlogMessage）,对BlogGroup再添加一个更新的级联操作，CascadeType.MERGE 
    public void update_test(){
        BlogGroup blogGroup = get_test(1);//得到blogGroup主键为1的group
        Session session = null;
        Transaction tran = null;
        try{
            session = this.getSession();
            tran = session.beginTransaction();
            BlogMessage blogMessage = new BlogMessage();
            blogMessage.setMsgContent("css 学习笔记");
            blogGroup.getMessage().add(blogMessage);
            session.merge(blogGroup);
            tran.commit();
        } catch(Exception e){
            System.out.println(e.toString());
            tran.rollback();
        }
    }
    //删除某一个博客-组（BlogGroup），因为不能删除我们写的博客消息，所以不能有删除的级联操作
　　//注意：我们有三个表，分别是“博客-组”， “博客-消息”，“组-消息”，当从“博客-组”中删除一条记录X时，表“博客-消息”中和X相关的数据不会删除，
　　//因为我们没有设置级联关系，但是表“组-消息”中和X相关的数据会删除干净，表“组-消息”是中间关联表，一方被移除之后，该表相关数据自然被移除。
    public void delete_test(){
        BlogGroup blogGroup = get_test(1);//得到blogGroup主键为1的group
        Session session = null;
        Transaction tran = null;
        try{
            session = this.getSession();
            tran = session.beginTransaction();
            session.delete(blogGroup);
            tran.commit();
        } catch(Exception e){
            System.out.println(e.toString());
            tran.rollback();
        }
    }
}

罗列所有持久化类的类名：

　　hibernate.cfg.xml中配置：

 <hibernate-configuration> 
     <session-factory> 
   　　  ...

　　　　　...
     </session-factory> 
 </hibernate-configuration>

　　如果整合了Spring：application.cfg.xml中的配置<bean id="sessionFactory" class="org.springframework.orm.hibernate4.LocalSessionFactoryBean">

　　　　<!--Spring中： 包扫描的方式加载注解类 -->
        <property name="annotatedClasses">
            <list>
                <value>com.blog.entriy.BlogGroup</value>
                <value>com.blog.entriy.BlogMessage</value>
            </list>
        </property>    
       
       <!--  通过配置文件的方式获取数据源，只是通过XML管理映射方式的。
        <property name="mappingResources">
            <list>
               以下用来列出所有的PO映射文件
                <value>publishparty.cfg.xml</value>
            </list>
        </property>        -->
　　　　　.....

</bean>

Hibernate注解

标签：

原文地址：http://www.cnblogs.com/hujunzheng/p/5065409.html

踩

(0)

评论一句话评论（0）

分享档案

更多>

2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)

周排行