`
小覃Smile
  • 浏览: 705 次
  • 性别: Icon_minigender_2
  • 来自: 成都
社区版块
存档分类
最新评论

jpa注解

 
阅读更多

1、加入jpa所需要的包

直接把hibernate中lib/required中的所有包放进去以及连接oracle数据库的架包。

 

2、写实体类(如问题类)

 

 

package com.chinasofti.jpa.entity;

import java.util.Date;
import java.util.HashSet;
import java.util.Set;

import javax.persistence.CascadeType;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.JoinTable;
import javax.persistence.ManyToMany;
import javax.persistence.ManyToOne;
import javax.persistence.Table;

import org.hibernate.annotations.GenericGenerator;

@Entity  //声明这是一个实体类
@Table(name = "t_question")  //声明表与对应的表名
public class Question
{
    @Id
    @GenericGenerator(name = "uuid", strategy = "uuid")//用hibernate包中提供的uuid生成策略
    @GeneratedValue(generator = "uuid")
    @Column(name = "id")
    private String id;
    
    @Column(name = "title")//表中的列,若与表的列名相同,name可以省略
    private String title;
    
    @Column(name = "content")
    private String content;
    
    @Column(name = "questionTime")
    private Date questionTime;
    
    @Column(name = "endTime")
    private Date endTime;
    
    @Column(name = "award")
    private int award;
    
    @Column(name = "flag")
    private int flag;
    
    @Column(name = "praiseNums")
    private int praiseNums;
    
    @Column(name = "opposeNums")
    private int opposeNums;
    
    @ManyToOne  //多对一的配置
    @JoinColumn(name = "userId")  //对应表中的列
    private User user = new User();
    
     @ManyToMany(cascade=CascadeType.ALL)   //多对多的配置,cascade为级联类型
     @JoinTable(name="t_question_tag",   //对应的中间表名
     joinColumns=@JoinColumn(name="questionId"),  //在中间表中对应的列名
     inverseJoinColumns=@JoinColumn(name="tagId"))  //另一多表对应的列名
     private Set<Tag> tags=new HashSet<Tag>();
    
    public String getId()
    {
        return id;
    }
    
    public void setId(String id)
    {
        this.id = id;
    }
    
    public String getTitle()
    {
        return title;
    }
    
    public void setTitle(String title)
    {
        this.title = title;
    }
    
    public String getContent()
    {
        return content;
    }
    
    public void setContent(String content)
    {
        this.content = content;
    }
    
    public Date getQuestionTime()
    {
        return questionTime;
    }
    
    public void setQuestionTime(Date questionTime)
    {
        this.questionTime = questionTime;
    }
    
    public Date getEndTime()
    {
        return endTime;
    }
    
    public void setEndTime(Date endTime)
    {
        this.endTime = endTime;
    }
    
    public int getAward()
    {
        return award;
    }
    
    public void setAward(int award)
    {
        this.award = award;
    }
    
    public int getPraiseNums()
    {
        return praiseNums;
    }
    
    public void setPraiseNums(int praiseNums)
    {
        this.praiseNums = praiseNums;
    }
    
    public int getOpposeNums()
    {
        return opposeNums;
    }
    
    public void setOpposeNums(int opposeNums)
    {
        this.opposeNums = opposeNums;
    }
    
    public User getUser()
    {
        return user;
    }
    
    public void setUser(User user)
    {
        this.user = user;
    }
    
    public int getFlag()
    {
        return flag;
    }
    
    public void setFlag(int flag)
    {
        this.flag = flag;
    }
     public Set<Tag> getTags()
     {
     return tags;
     }
     public void setTags(Set<Tag> tags)
     {
     this.tags = tags;
     }
}

 

3、写配置文件(persistence.xml)

在src目录下创建一个文件夹,名字为META-INF,别改动名字,因为默认读取名为META-INF的文件夹下的persistence.xml,不然找不到persistence.xml文件

 

 

<persistence xmlns="http://java.sun.com/xml/ns/persistence"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://java.sun.com/xml/ns/persistence http://java.sun.com/xml/ns/persistence/persistence_2_0.xsd"
	version="2.0">

       <!-- Name属性用于定义持久化单元的名字 (name必选,空值也合法);   
              transaction-type 指定事务类型(可选)     -->
	<persistence-unit name="jpa" transaction-type="RESOURCE_LOCAL">

		<properties>
                       <!-- 加载数据驱动 -->
			<property name="javax.persistence.jdbc.driver" value="oracle.jdbc.driver.OracleDriver" />
                        <!--加载url -->
			<property name="javax.persistence.jdbc.url" value="jdbc:oracle:thin:@localhost:1521:ORCL" />
                        <!-- 用户名 -->
			<property name="javax.persistence.jdbc.user" value="jung" />
                         <!-- 密码 -->
			<property name="javax.persistence.jdbc.password" value="jung" />
                        <!-- 方言 -->
			<property name="hibernate.dialect" value="org.hibernate.dialect.Oracle10gDialect" />
                        <!-- 是否显示sql语句 -->
			<property name="hibernate.show_sql" value="true" />
		</properties>

	</persistence-unit>
</persistence>

 

 

4、写个工具类

 

package com.chinasofti.jpa.util;

import java.util.ArrayList;
import java.util.List;

import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.EntityTransaction;
import javax.persistence.Persistence;

public class HibernateUtil
{
    private static EntityManagerFactory factory;
    
    static{
    	//使用静态代码块:代码必须在项目启动的时候就执行
    	//创建工厂,“jpa”为persistence.xml中的name
        factory=Persistence.createEntityManagerFactory("jpa");             
    }
    
    public static EntityManagerFactory getFactory()
    {
        return factory;
    }
    
    public static EntityManager getManager()
    {
        EntityManager em=factory.createEntityManager();
        return em;
    }
    
    //添加
    public static  <T> void add(T t)
    {
        EntityManager em=getManager();
        EntityTransaction et=em.getTransaction();//事务
        et.begin();//开启事务
        em.persist(t);
        et.commit();//提交事务
    }
    
    //修改
    public static <T> void update(T t) {
        EntityManager em=getManager();
        EntityTransaction et=em.getTransaction();
        et.begin();
        em.merge(t);
        et.commit();
    }
    
    //删除
    public static <T> void delete(Class<T> c, String id) 
    {
        EntityManager em=getManager();
        EntityTransaction et=em.getTransaction();
        et.begin();
        em.remove(em.find(c, id));
        et.commit();
    }
    
    //根据id查询
    public static <T> T query(Class<T> c, String id) 
    {
        EntityManager em=getManager();
        EntityTransaction et=em.getTransaction();
        et.begin();
        T t=em.find(c, id);
        et.commit();
        return t;
    }
    
    //查询全部
    @SuppressWarnings("all")
    public static <T> List<T> queryAll(Class<T> c) 
    {
        EntityManager em=getManager();
        EntityTransaction et=em.getTransaction();
        et.begin();       
        List<T> list=em.createQuery("from  "+c.getSimpleName()).getResultList();
        et.commit();
        return list;
    }
}

 

 

5、写个DAO层

 

package com.chinasofti.jpa.dao;

import java.util.List;

import com.chinasofti.jpa.entity.Question;
import com.chinasofti.jpa.util.HibernateUtil;


public class QuestionDao
{
    //添加
    public void addQuestion(Question question)
    {
        HibernateUtil.add(question);
    }
    
    //修改
    public void updateQuestion(Question question)
    {
        HibernateUtil.update(question);
    }
    
    //删除
    public void delQuestion(String id)
    {
        HibernateUtil.delete(Question.class, id);
    }
    
    //根据id查询
    public Question queryQuestion(String id)
    {
        return HibernateUtil.query(Question.class, id);
    }
    
    //查询全部
    public List<Question> queryAllQuestions()
    {
        return HibernateUtil.queryAll(Question.class);
    }
}

 

 

6、写个测试类(需要导入junit包)

 

 

package com.chinasofti.jpa.test;

import java.util.Calendar;
import java.util.Date;
import java.util.List;
import java.util.Set;

import org.junit.Before;
import org.junit.Test;

import com.chinasofti.jpa.dao.QuestionDao;
import com.chinasofti.jpa.entity.Question;
import com.chinasofti.jpa.entity.Tag;


public class TestQuestion
{
    private QuestionDao questionDao;
    
    @Before 
    public void before()
    {
    	//每测试一个方法时都会实例一次
        questionDao=new QuestionDao();
    }
    
    @Test     
    public void addQuestion() //添加
    {
        Question question=new Question();
        question.setTitle("问题2333");
        question.setContent("问题详细信息23333");
        question.setFlag(1);
        question.setQuestionTime(new Date());
        Calendar c = Calendar.getInstance();
        c.add(Calendar.DATE, 15); //表示当前时间的15天后
        question.setEndTime(c.getTime());

         //多对一添加
        question.getUser().setId("2c848f82555301360155530138a80000");
        
        //多对多添加标签表
        Tag tag1=new Tag();
        tag1.setName("java");
        Tag tag2=new Tag();
        tag2.setName("oracle");
        
        question.getTags().add(tag1);
        question.getTags().add(tag2);
        
        questionDao.addQuestion(question);
    }
    
    @Test   //删除
    public void delQuestion(){
        questionDao.delQuestion("2c848f9f5558a9ec015558a9f2670000");
        
    }
    
    @Test   // 根据id查询
    public void queryQuestion()
    {
        Question questions=questionDao.queryQuestion("2c848f9f5557df17015557df19ae0000");
        System.out.println(questions.getContent()+","+questions.getId());
        
    }
    
    @Test    //查询全部
    public void queryAllQuestion()
    {
        List<Question> list=questionDao.queryAllQuestions();
        for (Question question : list)
        {
            System.out.println(question.getId()+","+question.getContent());
        }
    }
    
    @Test   //多对多级联查询
    public void query()
    {
        Question question= questionDao.queryQuestion("2c848f9f5557de7e015557de811d0000");
        Set<Tag> set=question.getTags();
        for (Tag tag : set)
        {
            System.out.println(tag.getId());
        }
    }
}

 

 

 

 

 

分享到:
评论

相关推荐

    JPA注解总结大全!!!!

    ### JPA注解总结大全 Java Persistence API (JPA) 是一种用于管理关系数据库中的对象/关系映射的标准。本文将详细介绍与 JPA 相关的一些常用注解及其使用方法,帮助开发者更好地理解和掌握 JPA 的核心功能。 #### ...

    JPA注解实现联合主键

    ### JPA注解实现联合主键 在关系型数据库中,单个字段作为主键的情况较为常见,但在某些场景下,我们需要使用多个字段共同作为主键来唯一标识表中的每一条记录,这就是所谓的“联合主键”。而在Java持久化框架...

    java程序使用JPA注解详解.doc

    Java 程序使用 JPA 注解详解 Java 持久层 API(Java Persistence API)是一种 Java 应用程序接口,用于访问、管理和持久化数据之间的关系。JPA 使用注解来定义实体类与数据库表之间的映射关系,本文将详细介绍 JPA ...

    jpa注解详解

    JPA注解详解 JPA(Java Persistence API)是Java企业版5(Java EE 5)的一部分,提供了一个对象关系映射方法,使得开发者可以使用声明方式定义如何将Java对象映射到关系数据库表。在JPA中,批注是一种使用元数据...

    JPA注解参考文档.txt

    ### JPA注解参考知识点详解 #### 一、引言 Java Persistence API(简称JPA)作为Java企业版5(Java EE 5)标准的一部分,是Enterprise JavaBeans(EJB)3.0规范的重要组成部分。它极大地简化了EJB持久化,并提供了...

    JPA注解参考文档

    JPA全称Java Persistence API.JPA通过JDK 5.0注解或XML描述对象-关系表的映射关系,并将运行期的实体对象持久化到数据库中。 JPA支持XML和JDK5.0注解两种元数据的形式。 JPA的总体思想和现有Hibernate、TopLink、...

    JPA 注解参考文档

    JPA全称Java Persistence API.JPA通过JDK 5.0注解或XML描述对象-关系表的映射关系,并将运行期的实体对象持久化到数据库中。 JPA支持XML和JDK5.0注解两种元数据的形式。 JPA的总体思想和现有Hibernate、TopLink、...

    JPA注解 和hibernate 建表

    JPA注解和Hibernate建表 一、JPA概述 Java Persistence API(JPA)是Sun官方提出的Java持久化规范,它只是一个规范不是一个产品。JPA的主要目标是提供一种简洁、易用的方式来访问、操作和管理Java应用程序中的数据...

    java程序使用JPA注解详解

    Java 程序使用 JPA 注解详解 Java 程序使用 JPA 注解可以实现对象关系映射(ORM),使得 Java 应用程序能够与关系数据库进行交互。JPA(Java Persistence API)提供了多种注解来定义实体类与数据库表之间的映射关系...

    SpringMVC+JPA 注解开发 maven

    本项目提供了完整的配置代码,并有详细注释,非常适合初学者了解和学习SpringMVC+JPA的注解开发方式,以及如何结合Maven进行项目管理。通过实践这个项目,你可以深入理解Web应用开发的流程,掌握这些技术的使用。

    Toplink_JPA注解参考

    **Toplink JPA注解参考** Toplink JPA(Java Persistence API)是Oracle公司提供的一种对象关系映射(ORM)框架,它允许开发者使用Java对象来操作数据库,而无需直接编写SQL语句。JPA提供了丰富的注解,使得在Java...

    JPA注解@Access实例

    **JPA注解@Access详解** Java Persistence API (JPA) 是Java中用于对象关系映射(ORM)的标准框架,它允许开发人员将Java类与数据库表进行映射,从而简化数据操作。在JPA中,`@Access`注解是用于指定实体属性访问...

    Hibernate使用JPA注解代码

    这个异常通常意味着在使用JPA注解配置时,遇到了不兼容或错误的配置。 首先,让我们深入理解`@Table`和`@Index`这两个JPA注解。`@Table`用于指定一个实体类所对应的数据库表名,而`@Index`则是用来定义表中的索引。...

    Hibernate之JPA注解

    Hibernate之JPA注解

    JPA注解.doc J PA注解.

    以下是对JPA注解的详细解释: 1. **@Entity(name="EntityName")** 这个注解标记一个Java类为实体类,表示它将映射到数据库的一个表。`name`参数是可选的,用于指定表的名称。如果未指定,将使用类名作为表名。 2...

    hibernate+jpa注解实现最简单的增删改查

    **hibernate+jpa注解实现最简单的增删改查** 在Java开发中,Hibernate和JPA(Java Persistence API)是两种广泛使用的对象关系映射(ORM)框架,它们简化了与数据库交互的过程,使开发者可以使用面向对象的方式来...

    Hibernate+JPA注解教程.doc

    【Hibernate+JPA注解教程】 本教程将详细介绍如何在Java开发环境中利用Hibernate和Java Persistence API(JPA)的注解进行数据持久化操作。首先,我们需要了解开发所需的环境和工具,包括MyEclipse 8.5(内含...

    JPA注解.docx

    以下是对JPA注解的详细解释: 1. **@Entity(name="EntityName")**:此注解用于标记一个类作为JPA的实体类,它对应数据库中的一个表。`name`参数是可选的,用于指定实体在数据库中的表名,若不指定,默认取类名。 2...

    JPA注解参考_Oracle.chm

    JPA注解参考_Oracle.chm 通过它可以全面的掌握JPA编程

Global site tag (gtag.js) - Google Analytics