`

jpa技术总结

阅读更多
jpa是ejb的基础。现在ejb还没入门呢,但一定要学下去。从tc中应用ejb的程度来看,这技术在大的应用程序中应用很广泛。
虽然这次做得很失败,orm.xml还是没完全弄明白怎么写。但还是将自己所了解的写上来。HelloWorld example来自<java persistence with hibernate>
首先是persistence.xml文件
xml 代码
 
  1. <persistence xmlns="http://java.sun.com/xml/ns/persistence"  
  2.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
  3.     xsi:schemaLocation="http://java.sun.com/xml/ns/persistence  
  4. http://java.sun.com/xml/ns/persistence/persistence_1_0.xsd"  
  5.     version="1.0">  
  6.     <persistence-unit name="events_event">  
  7.         <provider>org.hibernate.ejb.HibernatePersistence<!---->provider>  
  8.         <!---->
  9.             <class>Holiday<!---->class>  
  10.         -->  
  11.         <properties>  
  12.             <property name="hibernate.show_sql" value="true" />  
  13.             <property name="hibernate.format_sql" value="true" />  
  14.             <property name="hibernate.connection.driver_class"  
  15.                 value="oracle.jdbc.driver.OracleDriver" />  
  16.             <property name="hibernate.connection.url"  
  17.                 value="jdbc:oracle:thin:@localhost:1521:tctest" />  
  18.             <property name="hibernate.connection.username" value="root" />  
  19.             <property name="hibernate.connection.password" value="gg" />  
  20.             <property name="hibernate.dialect"  
  21.                 value="org.hibernate.dialect.OracleDialect" />  
  22.         <!---->properties>  
  23.     <!---->persistence-unit>  
  24.       
  25. <!---->persistence>  

接着是orm.xml文件,自己组件的没做好,但helloworld还是没问题

xml 代码
 
  1. xml version="1.0" encoding="UTF-8"?>  
  2. <entity-mappings xmlns="http://java.sun.com/xml/ns/persistence/orm"  
  3.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
  4.     xsi:schemaLocation="http://java.sun.com/xml/ns/persistence/orm orm_1_0.xsd" version="1.0">  
  5.   
  6.     <mapped-superclass class="hello.BaseMessage">  
  7.         <attributes>  
  8.             <id name="id">  
  9.                 <column name="id" column-definition="number(38)" precision="38" scale="0" nullable="false" />  
  10.                 <generated-value strategy="SEQUENCE" generator="SEQ"/>  
  11.             <!---->id>  
  12.         <!---->attributes>  
  13.     <!---->mapped-superclass>  
  14.           
  15.     <entity class="hello.Message" name="Message">  
  16.         <table name="MESSAGES"><!---->table>  
  17.           
  18.         <sequence-generator name="SEQ" sequence-name="SQ_messages" allocation-size="1" />  
  19.   
  20.         <attribute-override name="id">  
  21.             <column name="message_id" column-definition="number(18)" nullable="false" precision="18" scale="0"/>  
  22.         <!---->attribute-override>  
  23.   
  24.         <attributes>  
  25.             <basic name="text">  
  26.                 <column name="MESSAGE_TEXT" nullable="false" />  
  27.             <!---->basic>  
  28.         <!---->attributes>  
  29.     <!---->entity>  
  30. <!---->entity-mappings>  

实体定义,用了继承,不用继承的早就解决了。注意@MappedSuperclass ,@entity,@Id的用法。需要jpa实现的包。我用的hibernate,这些包主要来自hibernate core 3.2.0g, hibernate entitymanager 3.2.0 and hibernate annotation 3.2. 具体要用其中的哪些我还没怎么弄明白,一个个加吧。

java 代码
 
  1. package hello;  
  2. import java.io.Serializable;  
  3.   
  4. import javax.persistence.Id;  
  5. import javax.persistence.MappedSuperclass;  
  6. @MappedSuperclass  
  7. public class BaseMessage implements Serializable {  
  8.     private static final long serialVersionUID = 4585624359812256628L;  
  9.     private Long id;  
  10.     public BaseMessage() {  
  11.         super();  
  12.     }  
  13.     @Id  
  14.     public Long getId() {  
  15.         return id;  
  16.     }  
  17.     public void setId(Long id) {  
  18.         this.id = id;  
  19.     }  
  20. }  
  21.   
  22. package hello;  
  23. import javax.persistence.Entity;  
  24. @Entity  
  25. public class Message extends BaseMessage {  
  26.     private static final long serialVersionUID = -7660981805652763488L;  
  27.     private String text;  
  28.     Message() {  
  29.     }  
  30.     public Message(String text) {  
  31.         this.text = text;  
  32.     }  
  33.     public String getText() {  
  34.         return text;  
  35.     }  
  36.     public void setText(String text) {  
  37.         this.text = text;  
  38.     }  
  39. }  

persistence 过程:
java 代码
 
  1. package hello;  
  2.   
  3. import java.util.List;  
  4.   
  5. import javax.persistence.EntityManager;  
  6. import javax.persistence.EntityManagerFactory;  
  7. import javax.persistence.EntityTransaction;  
  8. import javax.persistence.Persistence;  
  9.   
  10. public class HelloWorldEM {  
  11.     public static void main(String[] args) {  
  12.         // Start EntityManagerFactory  
  13.         EntityManagerFactory emf = Persistence.createEntityManagerFactory("helloworld");  
  14.         // First unit of work  
  15.         EntityManager em = emf.createEntityManager();  
  16.         EntityTransaction tx = em.getTransaction();  
  17.         tx.begin();  
  18.         Message message = new Message("Hello World");  
  19.         em.persist(message);  
  20.         Long msgId = message.getId();  
  21.         tx.commit();  
  22.         em.close();  
  23.   
  24.         // Second unit of work  
  25.         EntityManager newEm = emf.createEntityManager();  
  26.         EntityTransaction newTx = newEm.getTransaction();  
  27.         newTx.begin();  
  28.         List messages = newEm.createQuery("select m from Message m order by m.text asc").getResultList();  
  29.         System.out.println(messages.size() + " message(s) found");  
  30.         for (Object m : messages) {  
  31.             Message loadedMsg = (Message) m;  
  32.             System.out.println(msgId.longValue());  
  33.             System.out.println(loadedMsg.getText());  
  34.         }  
  35.         newTx.commit();  
  36.         newEm.close();  
  37.         emf.close();  
  38.     }  
  39. }  
分享到:
评论

相关推荐

    JPA核心知识总结

    5. **JPA技术**:包括实体管理、查询语言(JPQL)、 Criteria API、事务管理、事件监听等。 ### 二、JPA入门 1. **创建JPA步骤**:设置项目结构、引入JPA库、配置persistence.xml、创建实体类、配置数据源和实体...

    JPA技术:年初写的办公室OA系统

    **JPA技术详解** JPA(Java Persistence API)是Java平台上的一个标准,它为Java开发者提供了一种对象/关系映射工具来管理Java应用中的关系数据。在“年初写的办公室OA系统”这个项目中,JPA被用作持久化框架,帮助...

    jpa

    总结而言,这篇博客可能涵盖了JPA的基本概念、源码分析、在Spring和Struts框架中的应用,以及如何利用JPA来提高开发效率和代码可维护性。对于想要深入了解JPA和Java持久化技术的开发者来说,这将是一篇非常有价值的...

    EJB3+JPA开发总结

    ### EJB3+JPA开发总结 #### 一、EJB3概述 EJB3 (Enterprise JavaBeans 3) 是Java EE平台上的一个重要组件,它主要用于构建企业级应用程序中的业务逻辑层。相比于早期版本,EJB3进行了大量改进,简化了许多开发流程...

    jpa学习总结,pdf类型的,详细介绍了jpa的应用

    ### JPA学习总结知识点 #### 1. 什么是JPA? JPA (Java Persistence API) 是Sun官方提出的一种Java持久化规范,旨在为Java开发者提供一种便捷的方式去管理和操作Java应用中的关系型数据。它的主要目标是简化现有的...

    01_传智播客JPA详解_全面阐释和精彩总结JPA

    Java Persistence API(JPA)是Java平台上的一个标准,用于管理关系数据库中的数据。...在“01_传智播客JPA详解_全面阐释和精彩总结JPA”这个资源中,你将找到关于JPA的深入讲解和实用技巧,帮助你全面掌握这一技术。

    jpa的学习---jpa demo工程

    JPA通过ORM(Object-Relational Mapping)技术,将Java对象与数据库表进行映射,使得开发者可以使用面向对象的方式来操作数据库。它定义了一组API,允许开发者定义实体类、关系映射、事务控制等,而无需直接编写SQL...

    尚硅谷 jpa

    #### 四、JPA 技术要点 - **ORM 映射元数据**:可以通过 XML 或 JDK 5.0 注解来定义对象和数据库表之间的映射关系。 - **JPA 的 API**:提供了操作实体对象的方法,包括 CRUD (Create, Retrieve, Update, Delete) ...

    jpa1.0中文手册

    首先,标题中提到了“jpa1.0中文手册”,指出了文档所针对的技术是Java Persistence API(JPA)的1.0版本。JPA是一个Java社区规范(Java Community Process JSR 220),用于在Java EE和Java SE环境中管理对象和关系...

    Pro JPA 2版

    作者不仅详细解释了JPA2的每个组件和接口,还会提供大量示例代码和案例分析,帮助读者在实际工作中有效地应用JPA2技术。此外,本书还为高级用户准备了深入讨论主题,包括如何处理复杂的对象关系映射,如何优化查询...

    Spring Data JPA的优点和难点.pdf

    总结来说,Spring Data JPA作为一个强大的ORM工具,能够显著提高开发效率,简化数据库操作。然而,要充分发挥其优势并克服潜在问题,开发者需要深入理解JPA的工作机制,合理调整查询策略,以及适当地与其他优化技术...

    Hibernate JPA

    它最早实现了**Java Persistence API (JPA)**规范,并随着技术的发展不断进化和完善。Hibernate由JBoss收购后,成为JBoss项目中的一个重要组成部分,并遵循LGPLv2.1开源许可协议发布。官方网站提供最新的文档和技术...

    jpa代码自动生成工具-springboot

    总结起来,"jpa代码自动生成工具-springboot"是利用JPA和Spring Boot特性,配合特定工具,帮助开发者快速构建包含领域模型、数据访问、业务逻辑和前端控制的完整应用。通过这种方式,开发者可以更专注于业务创新,而...

    springboot + jpa 批量存储示例

    总结,通过Spring Boot和JPA,我们可以方便地进行数据库操作,包括批量存储。通过合理配置连接池如Druid和调整事务策略,可以进一步优化批量操作的性能。同时,对于大数据量的批量处理,记得采用分批保存的方式,以...

    详细介绍 jpa 开发文档

    综上所述,JPA 是一种强大的持久化技术,它不仅简化了数据库操作,还提高了代码的可移植性和可维护性。通过 JPA,开发者可以更高效地处理持久层的逻辑,减少因技术栈变化带来的影响。无论是对于初学者还是经验丰富的...

    springdata-jpa-querydsl

    Querydsl是一个用于创建类型安全查询的Java库,它支持JPA、JDO、SQL等多种持久化技术。Querydsl通过代码生成,将查询表达式转化为可读性强的Java对象,避免了字符串拼接造成的潜在错误,提高了代码质量。 三、...

Global site tag (gtag.js) - Google Analytics