久久久国产午夜精品,麻豆精品蜜桃,丝袜视频国产在线播放

JPA 单独使用

大鱼 — Sun, 15 Mar 2009 16:09:00 GMT

之前一直在用EJB3�Q�但现在惛_��J2SE里面使用JPA�Q�因��Z��大喜�ƢHibernate的XML文�g配置�?/p>

而��用DB4O的时候，出现了一些莫名其妙的问题�Q�一直没解决�Q�就暂时搁下了�?/p>

使用myeclipse 6开发jpa如下�Q?/p>

1.创徏web project

2.��d��jpa capabilities�Q�选择toplink�Q�把自动创徏数据库的和更新persistence.xml的勾�?/p>

3.切换成database explorer视图�Q�选择表，jpa逆向工程�?/p>

4.��试

生成的persistence.xml如下�Q?/p>

xml version="1.0" encoding="UTF-8"?>
<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_1_0.xsd" version="1.0">
<persistence-unit name="JPAWebPU"
transaction-type="RESOURCE_LOCAL">
<provider>
oracle.toplink.essentials.PersistenceProvider
provider>
<class>com.persia.entity.Consumerclass>
<properties>
<property name="toplink.jdbc.driver"
value="com.mysql.jdbc.Driver" />
<property name="toplink.jdbc.url"
value="jdbc:mysql://localhost:3306/ejb3" />
<property name="toplink.jdbc.user" value="root" />
<property name="toplink.jdbc.password" value="root" />
<property name="toplink.ddl-generation"
value="create-tables" />
properties>
persistence-unit>
persistence>

生成的几个类如下�Q?/p>

实体�c�：

package com.persia.entity;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.Table;
/**
* Consumer entity.
*
* @author MyEclipse Persistence Tools
*/
@Entity
@Table(name = "consumer", catalog = "ejb3", uniqueConstraints = {})
public class Consumer implements java.io.Serializable {
// Fields
private Integer id;
private String name;
private String password;
// Constructors
/** default constructor */
public Consumer() {
}
/** full constructor */
public Consumer(Integer id, String name, String password) {
this.id = id;
this.name = name;
this.password = password;
}
// Property accessors
@Id
@Column(name = "id", unique = true, nullable = false, insertable = true, updatable = true)
public Integer getId() {
return this.id;
}
public void setId(Integer id) {
this.id = id;
}
@Column(name = "name", unique = false, nullable = false, insertable = true, updatable = true, length = 45)
public String getName() {
return this.name;
}
public void setName(String name) {
this.name = name;
}
@Column(name = "password", unique = false, nullable = false, insertable = true, updatable = true, length = 45)
public String getPassword() {
return this.password;
}
public void setPassword(String password) {
this.password = password;
}
}

DAO接口

package com.persia.entity;
import java.util.List;
/**
* Interface for ConsumerDAO.
*
* @author MyEclipse Persistence Tools
*/
public interface IConsumerDAO {
/**
* Perform an initial save of a previously unsaved Consumer entity. All
* subsequent persist actions of this entity should use the #update()
* method. This operation must be performed within the a database
* transaction context for the entity's data to be permanently saved to the
* persistence store, i.e., database. This method uses the
* {@link javax.persistence.EntityManager#persist(Object) EntityManager#persist}
* operation.
*
* * EntityManagerHelper.beginTransaction();
* IConsumerDAO.save(entity);
* EntityManagerHelper.commit();
* 
*
* @param entity
*            Consumer entity to persist
* @throws RuntimeException
*             when the operation fails
*/
public void save(Consumer entity);
/**
* Delete a persistent Consumer entity. This operation must be performed
* within the a database transaction context for the entity's data to be
* permanently deleted from the persistence store, i.e., database. This
* method uses the
* {@link javax.persistence.EntityManager#remove(Object) EntityManager#delete}
* operation.
*
* * EntityManagerHelper.beginTransaction();
* IConsumerDAO.delete(entity);
* EntityManagerHelper.commit();
* entity = null;
* 
*
* @param entity
*            Consumer entity to delete
* @throws RuntimeException
*             when the operation fails
*/
public void delete(Consumer entity);
/**
* Persist a previously saved Consumer entity and return it or a copy of it
* to the sender. A copy of the Consumer entity parameter is returned when
* the JPA persistence mechanism has not previously been tracking the
* updated entity. This operation must be performed within the a database
* transaction context for the entity's data to be permanently saved to the
* persistence store, i.e., database. This method uses the
* {@link javax.persistence.EntityManager#merge(Object) EntityManager#merge}
* operation.
*
* * EntityManagerHelper.beginTransaction();
* entity = IConsumerDAO.update(entity);
* EntityManagerHelper.commit();
* 
*
* @param entity
*            Consumer entity to update
* @returns Consumer the persisted Consumer entity instance, may not be the
*          same
* @throws RuntimeException
*             if the operation fails
*/
public Consumer update(Consumer entity);
public Consumer findById(Integer id);
/**
* Find all Consumer entities with a specific property value.
*
* @param propertyName
*            the name of the Consumer property to query
* @param value
*            the property value to match
* @return List found by query
*/
public List findByProperty(String propertyName, Object value);
public List findByName(Object name);
public List findByPassword(Object password);
/**
* Find all Consumer entities.
*
* @return List all Consumer entities
*/
public List findAll();
}

DAO�c?/p>

package com.persia.entity;
import java.util.List;
import java.util.logging.Level;
import javax.persistence.EntityManager;
import javax.persistence.Query;
/**
* A data access object (DAO) providing persistence and search support for
* Consumer entities. Transaction control of the save(), update() and delete()
* operations must be handled externally by senders of these methods or must be
* manually added to each of these methods for data to be persisted to the JPA
* datastore.
*
* @see com.persia.entity.Consumer
* @author MyEclipse Persistence Tools
*/
public class ConsumerDAO implements IConsumerDAO {
// property constants
public static final String NAME = "name";
public static final String PASSWORD = "password";
private EntityManager getEntityManager() {
return EntityManagerHelper.getEntityManager();
}
/**
* Perform an initial save of a previously unsaved Consumer entity. All
* subsequent persist actions of this entity should use the #update()
* method. This operation must be performed within the a database
* transaction context for the entity's data to be permanently saved to the
* persistence store, i.e., database. This method uses the
* {@link javax.persistence.EntityManager#persist(Object) EntityManager#persist}
* operation.
*
* * EntityManagerHelper.beginTransaction();
* ConsumerDAO.save(entity);
* EntityManagerHelper.commit();
* 
*
* @param entity
*            Consumer entity to persist
* @throws RuntimeException
*             when the operation fails
*/
public void save(Consumer entity) {
EntityManagerHelper.log("saving Consumer instance", Level.INFO, null);
try {
getEntityManager().persist(entity);
EntityManagerHelper.log("save successful", Level.INFO, null);
} catch (RuntimeException re) {
EntityManagerHelper.log("save failed", Level.SEVERE, re);
throw re;
}
}
/**
* Delete a persistent Consumer entity. This operation must be performed
* within the a database transaction context for the entity's data to be
* permanently deleted from the persistence store, i.e., database. This
* method uses the
* {@link javax.persistence.EntityManager#remove(Object) EntityManager#delete}
* operation.
*
* * EntityManagerHelper.beginTransaction();
* ConsumerDAO.delete(entity);
* EntityManagerHelper.commit();
* entity = null;
* 
*
* @param entity
*            Consumer entity to delete
* @throws RuntimeException
*             when the operation fails
*/
public void delete(Consumer entity) {
EntityManagerHelper.log("deleting Consumer instance", Level.INFO, null);
try {
entity = getEntityManager().getReference(Consumer.class,
entity.getId());
getEntityManager().remove(entity);
EntityManagerHelper.log("delete successful", Level.INFO, null);
} catch (RuntimeException re) {
EntityManagerHelper.log("delete failed", Level.SEVERE, re);
throw re;
}
}
/**
* Persist a previously saved Consumer entity and return it or a copy of it
* to the sender. A copy of the Consumer entity parameter is returned when
* the JPA persistence mechanism has not previously been tracking the
* updated entity. This operation must be performed within the a database
* transaction context for the entity's data to be permanently saved to the
* persistence store, i.e., database. This method uses the
* {@link javax.persistence.EntityManager#merge(Object) EntityManager#merge}
* operation.
*
* * EntityManagerHelper.beginTransaction();
* entity = ConsumerDAO.update(entity);
* EntityManagerHelper.commit();
* 
*
* @param entity
*            Consumer entity to update
* @returns Consumer the persisted Consumer entity instance, may not be the
*          same
* @throws RuntimeException
*             if the operation fails
*/
public Consumer update(Consumer entity) {
EntityManagerHelper.log("updating Consumer instance", Level.INFO, null);
try {
Consumer result = getEntityManager().merge(entity);
EntityManagerHelper.log("update successful", Level.INFO, null);
return result;
} catch (RuntimeException re) {
EntityManagerHelper.log("update failed", Level.SEVERE, re);
throw re;
}
}
public Consumer findById(Integer id) {
EntityManagerHelper.log("finding Consumer instance with id: " + id,
Level.INFO, null);
try {
Consumer instance = getEntityManager().find(Consumer.class, id);
return instance;
} catch (RuntimeException re) {
EntityManagerHelper.log("find failed", Level.SEVERE, re);
throw re;
}
}
/**
* Find all Consumer entities with a specific property value.
*
* @param propertyName
*            the name of the Consumer property to query
* @param value
*            the property value to match
* @return List found by query
*/
@SuppressWarnings("unchecked")
public List findByProperty(String propertyName, final Object value) {
EntityManagerHelper.log("finding Consumer instance with property: "
+ propertyName + ", value: " + value, Level.INFO, null);
try {
final String queryString = "select model from Consumer model where model."
+ propertyName + "= :propertyValue";
Query query = getEntityManager().createQuery(queryString);
query.setParameter("propertyValue", value);
return query.getResultList();
} catch (RuntimeException re) {
EntityManagerHelper.log("find by property name failed",
Level.SEVERE, re);
throw re;
}
}
public List findByName(Object name) {
return findByProperty(NAME, name);
}
public List findByPassword(Object password) {
return findByProperty(PASSWORD, password);
}
/**
* Find all Consumer entities.
*
* @return List all Consumer entities
*/
@SuppressWarnings("unchecked")
public List findAll() {
EntityManagerHelper.log("finding all Consumer instances", Level.INFO,
null);
try {
final String queryString = "select model from Consumer model";
Query query = getEntityManager().createQuery(queryString);
return query.getResultList();
} catch (RuntimeException re) {
EntityManagerHelper.log("find all failed", Level.SEVERE, re);
throw re;
}
}
}

�q�有一个非常有用的helper

package com.persia.entity;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;
import javax.persistence.Query;
/**
* @author MyEclipse Persistence Tools
*/
public class EntityManagerHelper {
private static final EntityManagerFactory emf;
private static final ThreadLocal threadLocal;
private static final Logger logger;
static {
emf = Persistence.createEntityManagerFactory("JPAWebPU");
threadLocal = new ThreadLocal();
logger = Logger.getLogger("JPAWebPU");
logger.setLevel(Level.ALL);
}
public static EntityManager getEntityManager() {
EntityManager manager = threadLocal.get();
if (manager == null || !manager.isOpen()) {
manager = emf.createEntityManager();
threadLocal.set(manager);
}
return manager;
}
public static void closeEntityManager() {
EntityManager em = threadLocal.get();
threadLocal.set(null);
if (em != null) em.close();
}
public static void beginTransaction() {
getEntityManager().getTransaction().begin();
}
public static void commit() {
getEntityManager().getTransaction().commit();
}
public static void rollback() {
getEntityManager().getTransaction().rollback();
}
public static Query createQuery(String query) {
return getEntityManager().createQuery(query);
}
public static void log(String info, Level level, Throwable ex) {
logger.log(level, info, ex);
}
}

然后使用helper和dao�q�行��试

package com.jpa.test;
import java.util.List;
import com.persia.entity.Consumer;
import com.persia.entity.ConsumerDAO;
import com.persia.entity.EntityManagerHelper;
public class JPATest {
/**
* @param args
*/
public static void main(String[] args) {
// 1.创徏 DAO
ConsumerDAO dao = new ConsumerDAO();
// 2.创徏实体�c?/span>
Consumer c = new Consumer();
c.setName("jpa01");
c.setPassword("jianchi");
// 开始事�?
EntityManagerHelper.beginTransaction();
// 3. 保存
dao.save(c);
// 提交事务真正保存实体到数据库
EntityManagerHelper.commit();
// 4. 列出数据库中所有对�?/span>
List result = dao.findAll();
for(Consumer o : result) {
System.out.println(o.getId());
System.out.println(o.getName());
}
}
}

��试实例如下�Q?/p>

package test;
import java.util.List;
import dao.*;
public class JPATest {
public static void main(String[] args) {
// 1.创徏 DAO
StudentDAO dao = new StudentDAO();
// 2.创徏实体�c?/span>
Student user = new Student();
user.setUsername("hellojpa test");
user.setPassword("jpa password");
user.setAge(20);
// 开始事�?
EntityManagerHelper.beginTransaction();
// 3. 保存
dao.save(user);
// 提交事务真正保存实体到数据库
EntityManagerHelper.commit();
// 4. 列出数据库中所有对�?/span>
List result = dao.findAll();
for(Student o : result) {
System.out.println(o.getId());
System.out.println(o.getUsername());
}
// 5. 更改用户�?/span>
user.setUsername("���试JPA");
// 开始事�?
EntityManagerHelper.beginTransaction();
// 保存�Q�JPA会自动更新变动过的字�D�）
dao.update(user);
// 提交事务真正保存实体到数据库
EntityManagerHelper.commit();
// 6. 查找所有年龄�ؓ20的用��P��从第1个开始获取（�W?个是�W�一条记录）
result = dao.findByAge(20, 1);
for(Student o : result) {
System.out.println(o.getId());
System.out.println(o.getUsername());
}
// 7. �Ҏ�� ID 查找
user = dao.findById(2);
System.out.println(user.getUsername());
// 8. 删除
// 开始事�?
EntityManagerHelper.beginTransaction();
// 保存�Q�JPA会自动更新变动过的字�D�）
dao.delete(user);
// 提交事务真正保存实体到数据库
EntityManagerHelper.commit();
}
}

若部�|�到tomcat�Q�没有什么问题，也不要额外添加什么�?/p>

大鱼 2009-03-16 00:09 发表评论

大鱼 — Sun, 15 Mar 2009 15:42:00 GMT

JPA是什�?

定义 Java Persistence API
JPA通过JDK 5.0注解或XML描述对象�Q�关�p�表的映��关�p�，�q�将�q�行期的实体对象持久化到数据库中�?

��h��

Sun引入新的JPA ORM规范��Z��两个原因�Q�其一�Q�简化现有Java EE和Java SE应用的对象持久化的开发工作；其二�Q�Sun希望整合对ORM技术，实现天下归一�?br /> JPA由EJB 3.0软�g专家�l�开发，作�ؓJSR-220实现的一部分。但它不囿于EJB 3.0�Q�你可以在Web应用、甚��x��面应用中使用。JPA的宗旨是为POJO提供持久化标准规范，由此可见�Q�经�q�这几年的实跉|��索，能够��q��容器独立�q?行，方便开发和��试的理念已�l�深入�h心了。目前Hibernate 3.2、TopLink 10.1.3以及OpenJPA都提供了JPA的实现�?br /> JPA的��M��思想和现有Hibernate、TopLink�Q�JDO�{�ORM框架大体一致。�ȝ��来说�Q�JPA包括以下3斚w��的技术：
ORM映射元数�?/strong>
JPA支持XML和JDK 5.0注解两种元数据的形式�Q�元数据描述对象和表之间的映��关�p�，框架据此��实体对象持久化到数据库表中�Q?br /> JPA 的API
用来操作实体对象�Q�执行CRUD操作�Q�框架在后台替我们完成所有的事情�Q�开发者从�J�琐的JDBC和SQL代码中解脱出来�?br /> 查询语言
�q�是持久化操作中很重要的一个方面，通过面向对象而非面向数据库的查询语言查询数据�Q�避免程序的SQL语句紧密耦合�?
JPA的优�?/h2> 1 标准�?/strong>
JPA �?JCP �l�织发布�?Java EE 标准之一�Q�因此�Q何声�U�符�?JPA 标准的框枉��遵��@同样的架构，提供相同的访�?API�Q�这保证了基于JPA开发的企业应用能够�l�过��量的修改就能够在不同的JPA框架下运行�?br /> 2 对容器��Ҏ��的支持
JPA 框架中支持大数据集、事务、�ƈ发等容器�U�事务，�q��?JPA ��越了简单持久化框架的局限，在企业应用发挥更大的作用�?br /> 3 ��单易用，集成方便
JPA的主要目标之一��是提供更加��单的�~�程模型�Q�在JPA框架下创建实体和创徏Java �c�M��L��单，没有��M��的约束和限制�Q�只需要��?javax.persistence.Entity�q�行注释�Q�JPA的框架和接口也都非常��单，没有太多特别的规则和设计模式的要求，开发者可以很�Ҏ��?掌握。JPA��Z��非��R入式原则设计�Q�因此可以很�Ҏ��的和其它框架或者容器集成�?br /> 4 可媲��JDBC的查询能�?/strong>
JPA的查询语�a�是面向对象而非面向数据库的�Q�它以面向对象的自然语法构造查询语句，可以看成是Hibernate HQL的等��L��。JPA定义了独特的JPQL�Q�Java Persistence Query Language�Q�，JPQL是EJB QL的一�U�扩展，它是针对实体的一�U�查询语�a��Q�操作对象是实体�Q�而不是关�p�L��据库的表�Q�而且能够支持扚w��更新和修攏V��JOIN、GROUP BY、HAVING �{�通常只有 SQL 才能够提供的高��查询�Ҏ��，甚至�q�能够支持子查询�?br /> 5 支持面向对象的高�U�特�?/strong>
JPA 中能够支持面向对象的高��Ҏ��，如类之间的��ѝ��多态和�c�M��间的复杂关系�Q�这��L��支持能够让开发者最大限度的使用面向对象的模型设计企业应用，而不需要自行处理这些特性在关系数据库的持久化�?
JPA的供应商
JPA 的目标之一是制定一个可以由很多供应商实现的API�Q��ƈ且开发�h员可以编码来实现该API�Q�而不是��用私有供应商�Ҏ��的API。因此开发�h员只需使用供应商特有的API来获得JPA规范没有解决但应用程序中需要的功能。尽可能��C��用JPA API�Q�但是当需要供应商公开但是规范中没有提供的功能�Ӟ��则��用供应商�Ҏ��的API�?br /> 1 Hibernate
JPA是需要Provider来实现其功能的，Hibernate��是JPA Provider中很强的一个，目前来说应该无�h能出其右。从功能上来��_��JPA现在��是Hibernate功能的一个子集。Hibernate �?.2开始，��开始兼容JPA。Hibernate3.2获得了Sun TCK的JPA(Java Persistence API) 兼容认证�?br /> 只要熟悉Hibernate或者其他ORM框架�Q�在使用JPA时会发现其实非常�Ҏ��上手。例�?实体对象的状态，在Hibernate有自由、持久、游��M��U�，JPA里有new�Q�managed�Q�detached�Q�removed�Q�明��g�h一看就�?道，�q�些状态都是一一对应的。再如flush�Ҏ��Q�都是对应的�Q�而其他的再如说Query query = manager.createQuery(sql)�Q�它在Hibernate里写法上是session�Q�而在JPA中变成了manager�Q�所以从 Hibernate到JPA的代价应该是非常��的
同样�Q�JDO�Q�也开始兼容JPA。在ORM的领域中�Q�看来JPA已经是王道，规范��是规范。在各大厂商的支持下�Q�JPA的��用开始变得广泛�?br /> 2 Spring
Spring + Hibernate 常常被称�?Java Web 应用人气最旺的框架�l�合。而在 JCP 通过�?Web Beans JSR �Q�却�Ʋ将JSF + EJB + JPA 、来�?JBoss Seam�Q�Spring 除外�Q�的一些组件和EJB 3�Q�目前能够提供有基本拦截和依赖注入功能的��?Session Bean 框架�Q�的一�?Web �l�合�q�行标准化。如今的 Spring 2.0 �?JPA 提供了完整的 EJB 容器契约�Q�允�?JPA在�Q何环境内可以�?Spring ��理的服务层使用�Q�包�?Spring 的所�?AOP �?DI 增强�Q�。同�Ӟ��关于下一个Web应用�l�合会是 EJB、Spring + Hibernate �q�是 Spring + JPA 的论战，早已充斥于耟�?br /> 在Spring 2.0.1中，正式提供对JPA的支持，�q�也促成了JPA的发展，要知道JPA的好处在于可以分��M��容器�q�行�Q�变得更加的��z��?br /> 3 OpenJPA
OpenJPA �?Apache �l�织提供的开源项目，它实��C�� EJB 3.0 中的 JPA 标准�Q��ؓ开发者提供功能强大、��用简单的持久化数据管理框架。OpenJPA ��装了和关系型数据库交互的操作，让开发者把注意力集中在�~�写业务逻辑上。OpenJPA 可以作�ؓ独立的持久层框架发挥作用�Q�也可以��L��的与其它 Java EE 应用框架或者符�?EJB 3.0 标准的容器集成�?br /> 4 其它
目前支持的实现包括Toplink、Hibernate Entitymanager�{�。TopLink以前需要收费，如今开源了。OpenJPA虽然免费�Q�但功能、性能、普及性等斚w��更加需要加大力度�?br /> 对于EJB来说�Q�实体Bean一直是被批评的对象�Q�由于其太复杂和庞大。JPA的出玎ͼ�很大�E�度的分��M��复杂性。这让EJB的推�q�也变得�Ҏ��?br /> 总而言之，JPA规范主要��x��的仅是API的行为方面，而由各种实现完成大多数性能有关的调优。尽��如此，所有可靠的实现都应该拥有某�U�数据缓存，以作为选择。但愿不久的��来�Q�JPA能成为真正的标准�?br /> ��结
EJB 3.0和JPA 毫无疑问��是Java EE 5的主要卖炏V��在某些领域中，它们�l�Java�C�֌�带来了竞争优势，�q��Java 在其他领域与竞争�Ҏ��不分伯仲�Q�因为，不可否认�Q�目前某些领域尚不存在基于标准的�Ҏ��Q��?br /> �q�去数年来，Spring Framework一直是EJB在企业领域的主要竞争�Ҏ��。EJB3.0规范解决了很多促�q�Spring兴�v的问题。随着它的出现�Q�EJB3.0毫无疑问比Spring提供了更好的开发体验——最引�h注目的优势是它不需要配�|�文件�?br /> JPA提供一�U�标准的OR映射解决�Ҏ��Q�该解决�Ҏ��完全集成到EJB3�?兼容的容器中。JPA的前辈将会��l�稳定发展，但是业务应用�E�序中的 raw 使用��可能会减少。实�?JPA 兼容的实体管理器��g��很可能是此类技术的发展方向�?br /> Java EE�p�d��规范的较大问题与JPA没有��M��关系。Java EE �p�d��规范的问题涉及到 Web和EJB容器之间的集成。Spring在此领域仍然��h��主要竞争优势。JBoss的Seam��目��试使用自定义的�Ҏ��来解册��一问题。Caucho Resin应用服务器试图扩展容器边界�ƈ支持在Web容器中��用@EJB注释。我们希望Java EE 5.1��解军_��集成的问题，为我们提供一个全面而标准的依赖性注入方法�?br /> 在不久的��来�Q�Sun可能会将JPA作�ؓ一个单独的JSR对待�Q�同时JPA�q�可能作为Java SE的一部分。不�q�这些都不太重要�Q�重要的是，我们现在已经可以在脱��d��器的情况下、在Java SE应用中��用JPA了�?
JPA已经作�ؓ一��对象持久化的标准，不但可以获得Java EE应用服务器的支持�Q�还可以直接在Java SE中��用。开发者将无需在现有多�U�ORM框架中艰隑֜�选择�Q�按照Sun的预惻I��现有ORM框架头顶的光环将渐渐暗��E�Q�不再具有以往的吸引力�?

大鱼 2009-03-15 23:42 发表评论

大鱼 — Sun, 15 Mar 2009 14:41:00 GMT

Table

Table用来定义entity主表的name�Q�catalog�Q�schema�{�属性�?

元数据属性说明：

name: 表名
catalog: 对应关系数据库中的catalog
schema�Q�对应关�p�L��据库中的schema
UniqueConstraints:定义一个UniqueConstraint数组�Q�指定需要徏唯一�U�束的列

@Entity
@Table(name="CUST")
public class Customer { ... }
　　

SecondaryTable

一个entity class可以映射到多表，SecondaryTable用来定义单个从表的名字，主键名字�{�属性�?

元数据属性说明：

name: 表名
catalog: 对应关系数据库中的catalog
schema�Q�对应关�p�L��据库中的schema
pkJoin: 定义一个PrimaryKeyJoinColumn数组�Q�指定从表的主键�?
UniqueConstraints:定义一个UniqueConstraint数组�Q�指定需要徏唯一�U�束的列

下面的代码说明Customer�c�L��到两个表，主表名是CUSTOMER�Q�从表名是CUST_DETAIL�Q�从表的主键列和主表的主键列�c�d��相同�Q�列名�ؓCUST_ID�?

@Entity
@Table(name="CUSTOMER")
@SecondaryTable(name="CUST_DETAIL",pkJoin=@PrimaryKeyJoinColumn(name="CUST_ID"))
public class Customer { ... }

SecondaryTables

当一个entity class映射��C��个主表和多个从表�Ӟ��用SecondaryTables来定义各个从表的属性�?

元数据属性说明：

value�Q?定义一个SecondaryTable数组�Q�指定每个从表的属性�?

@Table(name = "CUSTOMER")
@SecondaryTables( value = {
@SecondaryTable(name = "CUST_NAME", pkJoin = { @PrimaryKeyJoinColumn(name = "STMO_ID", referencedColumnName = "id") }),
@SecondaryTable(name = "CUST_ADDRESS", pkJoin = { @PrimaryKeyJoinColumn(name = "STMO_ID", referencedColumnName = "id") }) })
public class Customer {}

UniqueConstraint

UniqueConstraint定义在Table或SecondaryTable元数据里�Q�用来指定徏表时需要徏唯一�U�束的列�?

元数据属性说明：

columnNames:定义一个字�W�串数组�Q�指定要建唯一�U�束的列名�?

@Entity
@Table(name="EMPLOYEE",
uniqueConstraints={@UniqueConstraint(columnNames={"EMP_ID", "EMP_NAME"})}
)
public class Employee { ... }

Column

Column元数据定义了映射到数据库的列的所有属性：列名�Q�是否唯一�Q�是否允��ؓ�I�，是否允许更新�{��?

元数据属性说明：

name:列名�?
unique: 是否唯一
nullable: 是否允许为空
insertable: 是否允许插入
updatable: 是否允许更新
columnDefinition: 定义��时创建此列的DDL
secondaryTable: 从表名。如果此列不建在主表上（默认建在主表�Q�，该属性定义该列所在从表的名字�?

public class Person {
@Column(name = "PERSONNAME", unique = true, nullable = false, updatable = true)
private String name;

@Column(name = "PHOTO", columnDefinition = "BLOB NOT NULL", secondaryTable="PER_PHOTO")
private byte[] picture;

JoinColumn

如果在entity class的field上定义了关系�Q�one2one或one2many�{�）�Q�我们通过JoinColumn来定义关�pȝ��属性。JoinColumn的大部分属性和Column�c�M��?

元数据属性说明：

name:列名�?
referencedColumnName:该列指向列的列名�Q�徏表时该列作�ؓ外键列指向关�p�d��一端的指定列）
unique: 是否唯一
nullable: 是否允许为空
insertable: 是否允许插入
updatable: 是否允许更新
columnDefinition: 定义��时创建此列的DDL
secondaryTable: 从表名。如果此列不建在主表上（默认建在主表�Q�，该属性定义该列所在从表的名字�?

下面的代码说明Custom和Order是一对一关系。在Order对应的映��表��Z��个名为CUST_ID的列�Q�该列作为外键指向Custom对应表中名�ؓID的列�?

public class Custom {

@OneToOne
@JoinColumn(
name="CUST_ID", referencedColumnName="ID", unique=true, nullable=true, updatable=true)
public order getOrder() {
return order;
}

JoinColumns

如果在entity class的field上定义了关系�Q�one2one或one2many�{�）�Q��ƈ且关�p�d��在多个JoinColumn�Q�用JoinColumns定义多个JoinColumn的属性�?

元数据属性说明：

value: 定义JoinColumn数组�Q�指定每个JoinColumn的属性�?

下面的代码说明Custom和Order是一对一关系。在Order对应的映��表��Z��列，一列名为CUST_ID�Q�该列作为外键指向Custom对应表中名�ؓID的列,另一列名为CUST_NAME�Q�该列作为外键指向Custom对应表中名�ؓNAME的列�?

public class Custom {
@OneToOne
@JoinColumns({
@JoinColumn(name="CUST_ID", referencedColumnName="ID"),
@JoinColumn(name="CUST_NAME", referencedColumnName="NAME")
})
public order getOrder() {
return order;
}

Id

声明当前field为映��表中的主键列。id值的获取方式有五�U�：TABLE, SEQUENCE, IDENTITY, AUTO, NONE。Oracle和DB2支持SEQUENCE�Q�SQL Server和Sybase支持IDENTITY,mysql支持AUTO。所有的数据库都可以指定为AUTO�Q�我们会�Ҏ��不同数据库做转换。NONE (默认)需要用戯��己指定Id的倹{��元数据属性说明：

generate():主键值的获取�c�d��
generator():TableGenerator的名字（当generate=GeneratorType.TABLE才需要指定该属性）

下面的代码声明Task的主键列id是自动增长的�?Oracle和DB2从默认的SEQUENCE取��|��SQL Server和Sybase该列建成IDENTITY�Q�mysql该列建成auto increment�?

@Entity
@Table(name = "OTASK")
public class Task {
@Id(generate = GeneratorType.AUTO)
public Integer getId() {
return id;
}
}

IdClass

当entity class使用复合主键�Ӟ��需要定义一个类作�ؓid class。id class必须�W�合以下要求:�c�d��d��明�ؓpublic�Q��ƈ提供一个声明�ؓpublic的空构造函数。必��d��现Serializable接，覆写 equals()和hashCode�Q�）�Ҏ��。entity class的所有id field在id class都要定义�Q�且�c�d��一栗��?

元数据属性说明：

value: id class的类�?

public class EmployeePK implements java.io.Serializable{
String empName;
Integer empAge;

public EmployeePK(){}

public boolean equals(Object obj){ ......}
public int hashCode(){......}
}

@IdClass(value=com.acme.EmployeePK.class)
@Entity(access=FIELD)
public class Employee {
@Id String empName;
@Id Integer empAge;
}

MapKey

在一对多�Q�多对多关系中，我们可以用Map来保存集合对象。默认用主键值做key�Q�如果��用复合主键，则用id class的实例做key�Q�如果指定了name属性，��q��指定的field的值做key�?

元数据属性说明：

name: 用来做key的field名字

下面的代码说明Person和Book之间是一对多关系。Person的books字段是Map�c�d��Q�用Book的isbn字段的��g��为Map的key�?

@Table(name = "PERSON")
public class Person {

@OneToMany(targetEntity = Book.class, cascade = CascadeType.ALL, mappedBy = "person")
@MapKey(name = "isbn")
private Map books = new HashMap();
}

OrderBy

在一对多�Q�多对多关系中，有时我们希望从数据库加蝲出来的集合对象是按一定方式排序的�Q�这可以通过OrderBy来实玎ͼ�默认是按对象的主键升序排列�?

元数据属性说明：

value: 字符串类型，指定排序方式。格式�ؓ"fieldName1 [ASC|DESC],fieldName2 [ASC|DESC],......",排序�c�d��可以不指定，默认是ASC�?

下面的代码说明Person和Book之间是一对多关系。集合books按照Book的isbn升序�Q�name降序排列�?

@Table(name = "MAPKEY_PERSON")
public class Person {

@OneToMany(targetEntity = Book.class, cascade = CascadeType.ALL, mappedBy = "person")
@OrderBy(name = "isbn ASC, name DESC")
private List books = new ArrayList();
}

PrimaryKeyJoinColumn

在三�U�情况下会用到PrimaryKeyJoinColumn�?

�l�承�?
entity class映射��C��个或多个从表。从表根据主表的主键列（列名为referencedColumnName值的列）�Q�徏立一个类型一��L��主键列，列名由name属性定义�?
one2one关系�Q�关�pȝ��护端的主键作为外键指向关�p�被�l�护端的主键�Q�不再新��Z��个外键列�?

元数据属性说明：

name:列名�?
referencedColumnName:该列引用列的列名
columnDefinition: 定义��时创建此列的DDL

下面的代码说明Customer映射��C��个表�Q�主表CUSTOMER,从表CUST_DETAIL�Q�从表需要徏立主键列CUST_ID�Q�该列和主表的主键列id除了列名不同�Q�其他定义一栗��?

@Entity
@Table(name="CUSTOMER")
@SecondaryTable(name="CUST_DETAIL",pkJoin=@PrimaryKeyJoinColumn(name="CUST_ID"�Q�referencedColumnName="id"))
public class Customer {
@Id(generate = GeneratorType.AUTO)
public Integer getId() {
return id;
}
}

下面的代码说明Employee和EmployeeInfo是一对一关系�Q�Employee的主键列id作�ؓ外键指向EmployeeInfo的主键列INFO_ID�?

@Table(name = "Employee")
public class Employee {
@OneToOne
@PrimaryKeyJoinColumn(name = "id", referencedColumnName="INFO_ID")
EmployeeInfo info;
}

PrimaryKeyJoinColumns

如果entity class使用了复合主键，指定单个PrimaryKeyJoinColumn不能满��要求�Ӟ��可以用PrimaryKeyJoinColumns来定义多个PrimaryKeyJoinColumn�?

元数据属性说明：

value: 一个PrimaryKeyJoinColumn数组�Q�包含所有PrimaryKeyJoinColumn�?

下面的代码说明了Employee和EmployeeInfo是一对一关系。他们都使用复合主键�Q�徏表时需要在Employee表徏立一个外键，从Employee的主键列id,name指向EmployeeInfo的主键列INFO_ID和INFO_NAME.

@Entity
@IdClass(EmpPK.class)
@Table(name = "EMPLOYEE")
public class Employee {

private int id;

private String name;

private String address;

@OneToOne(cascade = CascadeType.ALL)
@PrimaryKeyJoinColumns({
@PrimaryKeyJoinColumn(name="id", referencedColumnName="INFO_ID"),
@PrimaryKeyJoinColumn(name="name" , referencedColumnName="INFO_NAME")})
EmployeeInfo info;
}

@Entity
@IdClass(EmpPK.class)
@Table(name = "EMPLOYEE_INFO")
public class EmployeeInfo {

@Id
@Column(name = "INFO_ID")
private int id;

@Id
@Column(name = "INFO_NAME")
private String name;
}

Transient

Transient用来注释entity的属性，指定的这些属性不会被持久化，也不会�ؓ�q�些属性徏表�?

@Transient
private String name;

Version

Version指定实体�c�d��乐观事务中的version属性。在实体�c�重新由EntityManager��理�q�且加入��C��观事务中�Ӟ��保证完整性。每一个类只能有一个属性被指定为version�Q�version属性应该映��到实体�cȝ��主表上�?

下面的代码说明versionNum属性作��个类的version�Q�映��到数据库中主表的列名是OPTLOCK�?

@Version
@Column("OPTLOCK")
protected int getVersionNum() { return versionNum; }

Lob

Lob指定一个属性作为数据库支持的大对象�c�d��在数据库中存储。��用LobType�q�个枚�D来定义Lob是二�q�制�c�d��q�是字符�c�d��?

LobType枚�D�c�d��说明�Q?

BLOB 二进制大对象�Q�Byte[]或者Serializable的类型可以指定�ؓBLOB�?
CLOB 字符型大对象�Q�char[]、Character[]或String�c�d��可以指定为CLOB�?

元数据属性说明：

fetch�Q?定义�q�个字段是lazy loaded�q�是eagerly fetched。数据类型是FetchType枚�D�Q�默认�ؓLAZY,即lazy loaded.
type�Q?定义�q�个字段在数据库中的JDBC数据�c�d��。数据类型是LobType枚�D�Q�默认�ؓBLOB�?

下面的代码定义了一个BLOB�c�d��的属性和一个CLOB�c�d��的属性�?

@Lob
@Column(name="PHOTO" columnDefinition="BLOB NOT NULL")
protected JPEGImage picture;

@Lob(fetch=EAGER, type=CLOB)
@Column(name="REPORT")
protected String report;

JoinTable

JoinTable在many-to-many关系的所有者一边定义。如果没有定义JoinTable�Q��用JoinTable的默认倹{�?

元数据属性说明：

table:�q�个join table的Table定义�?
joinColumns:定义指向所有者主表的外键列，数据�c�d��是JoinColumn数组�?
inverseJoinColumns:定义指向非所有者主表的外键列，数据�c�d��是JoinColumn数组�?

下面的代码定义了一个连接表CUST和PHONE的join table。join table的表名是CUST_PHONE�Q�包含两个外键，一个外键是CUST_ID�Q�指向表CUST的主键ID�Q�另一个外键是PHONE_ID�Q�指向表PHONE的主键ID�?

@JoinTable(
table=@Table(name=CUST_PHONE),
joinColumns=@JoinColumn(name="CUST_ID", referencedColumnName="ID"),
inverseJoinColumns=@JoinColumn(name="PHONE_ID", referencedColumnName="ID")
)

TableGenerator

TableGenerator定义一个主键值生成器�Q�在Id�q�个元数据的generate�Q�TABLE�Ӟ��generator属性中可以使用生成器的名字。生成器可以在类、方法或者属性上定义�?

生成器是为多个实体类提供�q�箋的ID值的表，每一行�ؓ一个类提供ID��|��ID值通常是整数�?

元数据属性说明：

name:生成器的唯一名字�Q�可以被Id元数据��用�?
table:生成器用来存储id值的Table定义�?
pkColumnName:生成器表的主键名�U��?
valueColumnName:生成器表的ID值的列名�U��?
pkColumnValue:生成器表中的一行数据的主键倹{�?
initialValue:id值的初始倹{�?
allocationSize:id值的增量�?

下面的代码定义了两个生成器empGen和addressGen�Q�生成器的表是ID_GEN�?

@Entity public class Employee {
...
@TableGenerator(name="empGen",
table=@Table(name="ID_GEN"),
pkColumnName="GEN_KEY",
valueColumnName="GEN_VALUE",
pkColumnValue="EMP_ID",
allocationSize=1)
@Id(generate=TABLE, generator="empGen")
public int id;
...
}

@Entity public class Address {
...
@TableGenerator(name="addressGen",
table=@Table(name="ID_GEN"),
pkColumnValue="ADDR_ID")
@Id(generate=TABLE, generator="addressGen")
public int id;
...
}

SequenceGenerator

SequenceGenerator定义一个主键值生成器�Q�在Id�q�个元数据的generator属性中可以使用生成器的名字。生成器可以在类、方法或者属性上定义。生成器是数据库支持的sequence对象�?

元数据属性说明：

name:生成器的唯一名字�Q�可以被Id元数据��用�?
sequenceName:数据库中�Q�sequence对象的名�U�。如果不指定�Q�会使用提供商指定的默认名称�?
initialValue:id值的初始倹{�?
allocationSize:id值的增量�?

下面的代码定义了一个��用提供商默认名称的sequence生成器�?

@SequenceGenerator(name="EMP_SEQ", allocationSize=25)

DiscriminatorColumn

DiscriminatorColumn定义在��用SINGLE_TABLE或JOINED�l�承�{�略的表中区别不�l�承层次的列�?

元数据属性说明：

name:column的名字。默认��gؓTYPE�?
columnDefinition:生成DDL的sql片断�?
length:String�c�d��的column的长度，其他�c�d��使用默认�?0�?

下面的代码定义了一个列名�ؓDISC�Q�长度�ؓ20的String�c�d��的区别列�?

@Entity
@Table(name="CUST")
@Inheritance(strategy=SINGLE_TABLE,
discriminatorType=STRING,
discriminatorValue="CUSTOMER")
@DiscriminatorColumn(name="DISC", length=20)
public class Customer { ... }

大鱼 2009-03-15 22:41 发表评论