一步步实现:JPA的基本增删改查CRUD(jpa基于hibernate)

1.创建一个JPA工程

首先,创建一个JPA工程(若不知道JPA创建或出现at least one user library must be selected等错误,请参考http://blog.csdn.net/baidu_37107022/article/details/76554393


jar包说明


2.创建实体类

有关实体类中相关注解的说明

[plain] view plain copy
  1. * @Table  标注类对应的表  
  2. * 若表名和类型相同时,省略@Table,比如类Users 和表 users;  
  3. * 若不相同时,必须有@Table,并设置name,为该类对应的表名。@Table(name="users")  
  4. *   
  5. * @Entity 标注实体  
  6. *   
  7. * @Id 标注id  
  8. *   
  9. * @Transient 标注该属性不做与表的映射(原因:可能表中没有该属性对应的字段)  
  10. * 有该注解,在执行sql语句时,就不会出现该属性,否则会有,若表中没有该字段则会报错  
  11. *   
  12. * @Basic 默认所有属性都有该注解(主键需要单独使用@Id),所以可以省略  
  13. *           该注解可以放在属性上,也可以放在对应的getter方法上。  
  14. *            注意:要么统一将@Basic放在属性上,要么统一放在对应的getter方法上。(一般都放在属性上,可读性比较好)  
  15. *   
  16. * @Column 类中属性名和表中对应字段名不相同时,会使用该注解,指明在类中对应的字段  
  17. *           @Column(name="对应的表中字段名")  


构建实体类Users

[java] view plain copy
  1. import javax.persistence.Basic;  
  2. import javax.persistence.Column;  
  3. import javax.persistence.Entity;  
  4. import javax.persistence.Id;  
  5. import javax.persistence.Table;  
  6. import javax.persistence.Transient;  
  7. /** 
  8.  * @Table  标注类对应的表 
  9.  * 若表名和类型相同时,省略@Table,比如类Users 和表 users; 
  10.  * 若不相同时,必须有@Table,并设置name,为该类对应的表名。@Table(name="users") 
  11.  *  
  12.  * @Entity 标注实体 
  13.  *  
  14.  * @Id 标注id 
  15.  *  
  16.  * @Transient 标注该属性不做与表的映射(原因:可能表中没有该属性对应的字段) 
  17.  * 有该注解,在执行sql语句时,就不会出现该属性,否则会有,若表中没有该字段则会报错 
  18.  *  
  19.  * @Basic 默认所有属性都有该注解(主键需要单独使用@Id),所以可以省略 
  20.  *          该注解可以放在属性上,也可以放在对应的getter方法上。 
  21.  *           注意:要么统一将@Basic放在属性上,要么统一放在对应的getter方法上。(一般都放在属性上,可读性比较好) 
  22.  *  
  23.  * @Column 类中属性名和表中对应字段名不相同时,会使用该注解,指明在类中对应的字段 
  24.  *          @Column(name="对应的表中字段名") 
  25.  * 
  26.  */  
  27. @Table(name="users")  
  28. @Entity  
  29. public class Users {  
  30.     //标注id  
  31.     @Id  
  32.     private String uid;  
  33.     @Basic  
  34.     @Column(name="uname")  
  35.     private String uname;  
  36.     @Basic  
  37.     private int age;  
  38.       
  39.     @Transient  
  40.     private String remark;//备注  
  41.       
  42.     public String getRemark() {  
  43.         return remark;  
  44.     }  
  45.     public void setRemark(String remark) {  
  46.         this.remark = remark;  
  47.     }  
  48.     public String getUid() {  
  49.         return uid;  
  50.     }  
  51.     public void setUid(String uid) {  
  52.         this.uid = uid;  
  53.     }  
  54.     public String getUname() {  
  55.         return uname;  
  56.     }  
  57.     public void setUname(String uname) {  
  58.         this.uname = uname;  
  59.     }  
  60.     public int getAge() {  
  61.         return age;  
  62.     }  
  63.     public void setAge(int age) {  
  64.         this.age = age;  
  65.     }  
  66.     @Override  
  67.     public String toString() {  
  68.         return "Users [uid=" + uid + ", uname=" + uname + ", age=" + age + "]";  
  69.     }  
  70.     public Users(String uid, String uname, int age) {  
  71.         super();  
  72.         this.uid = uid;  
  73.         this.uname = uname;  
  74.         this.age = age;  
  75.     }  
  76.     public Users() {  
  77.         super();  
  78.         // TODO Auto-generated constructor stub  
  79.     }  
  80.       
  81.       
  82. }  


3.JPA的配置文件persistence.xml的配置

[java] view plain copy
  1. <?xml version="1.0" encoding="UTF-8"?>  
  2. <persistence version="2.0"  
  3.     xmlns="http://java.sun.com/xml/ns/persistence" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
  4.     xsi:schemaLocation="http://java.sun.com/xml/ns/persistence http://java.sun.com/xml/ns/persistence/persistence_2_0.xsd">  
  5.     <persistence-unit name="JPA" transaction-type="RESOURCE_LOCAL">  
  6.         <!-- 配置jpa ORM产品 -->  
  7.         <provider>org.hibernate.jpa.HibernatePersistenceProvider</provider>  
  8.         <!-- 添加对应的持久化类 -->  
  9.         <class>com.java.bean.Users</class>  
  10.         <properties>  
  11.             <!-- jpa中连接数据库 -->  
  12.             <property name="javax.persistence.jdbc.driver" value="com.mysql.jdbc.Driver" />  
  13.             <property name="javax.persistence.jdbc.url" value="jdbc:mysql://localhost:3306/jpa" />  
  14.             <property name="javax.persistence.jdbc.user" value="root" />  
  15.             <property name="javax.persistence.jdbc.password" value="123"></property>  
  16.               
  17.             <!-- jpa中配置hibernate基本属性 -->  
  18.             <property name="hibernate.show_sql" value="true" />  
  19.             <property name="hibernate.format_sql" value="true" />  
  20.         </properties>  
  21.   
  22.     </persistence-unit>  
  23. </persistence>  

4.测试增删改查CRUD

[java] view plain copy
  1. import java.util.HashMap;  
  2. import java.util.Map;  
  3.   
  4. import javax.persistence.EntityManager;  
  5. import javax.persistence.EntityManagerFactory;  
  6. import javax.persistence.EntityTransaction;  
  7. import javax.persistence.Persistence;  
  8.   
  9. import com.java.utils.JPAUtils;  
  10.   
  11. import junit.framework.TestCase;  
  12.   
  13. public class TestUsers extends TestCase {  
  14.   
  15.     // 插入数据 persist 相当于hibernate save方法  
  16.     public void testInsert() {  
  17.         // 1.获得Factory  
  18.         EntityManagerFactory factory = Persistence.createEntityManagerFactory("JPA");  
  19.         // 2.获取Manager  
  20.         EntityManager manager = factory.createEntityManager();  
  21.         // 3.获得事务,并开启uiwu  
  22.         EntityTransaction transaction = manager.getTransaction();  
  23.         transaction.begin();  
  24.         // 4.执行sql  
  25.         Users users = new Users("1""小明"18);  
  26.         manager.persist(users);  
  27.         // 5.提交事务,关闭资源  
  28.         transaction.commit();  
  29.         manager.close();  
  30.         factory.close();  
  31.     }  
  32.   
  33.     /** 
  34.      * 创建EntityManagerFactory的第二种方式 可以将如下配置放在创建factory是进行配置,使用map 
  35.      * <property name="hibernate.show_sql" value="true" /> <property name= 
  36.      * "hibernate.format_sql" value="true" /> 
  37.      *  
  38.      * 当配置文件中和创建factory时有同一配置时,会按照创建的factory中的设置执行 
  39.      */  
  40.     public void testInsert2() {  
  41.         // 1.获得Factory  
  42.         Map properties = new HashMap<String, Object>();  
  43.         properties.put("hibernate.format_sql""false");  
  44.         EntityManagerFactory factory = Persistence.createEntityManagerFactory("JPA", properties);  
  45.         // 2.获取Manager  
  46.         EntityManager manager = factory.createEntityManager();  
  47.         // 3.获得事务,并开启uiwu  
  48.         EntityTransaction transaction = manager.getTransaction();  
  49.         transaction.begin();  
  50.         // 4.执行sql  
  51.         Users users = new Users("2""小明2"18);  
  52.         manager.persist(users);  
  53.         // 5.提交事务,关闭资源  
  54.         transaction.commit();  
  55.         manager.close();  
  56.         factory.close();  
  57.     }  
  58.   
  59.     // 根据id查询 find 相当于hibernate get方法  
  60.     public void testFind() {  
  61.         // 1.获得Factory  
  62.         EntityManagerFactory factory = Persistence.createEntityManagerFactory("JPA");  
  63.         // 2.获取Manager  
  64.         EntityManager manager = factory.createEntityManager();  
  65.         // 3.获得事务,并开启事务  
  66.         EntityTransaction transaction = manager.getTransaction();  
  67.         transaction.begin();  
  68.         // 4.执行sql  
  69.         Users users = manager.find(Users.class"1");  
  70.         System.out.println(users);  
  71.         // 5.提交事务,关闭资源  
  72.         transaction.commit();  
  73.         manager.close();  
  74.         factory.close();  
  75.     }  
  76.   
  77.     // 根据id查询 getReference 相当于hibernate load方法  
  78.     // find和getReference的区别----与hibernate中get和load的区别一样---懒加载--id没有对应值时报异常  
  79.     public void testGet() {  
  80.         // 1.获得Factory  
  81.         EntityManagerFactory factory = Persistence.createEntityManagerFactory("JPA");  
  82.         // 2.获取Manager  
  83.         EntityManager manager = factory.createEntityManager();  
  84.         // 3.获得事务,并开启事务  
  85.         EntityTransaction transaction = manager.getTransaction();  
  86.         transaction.begin();  
  87.         // 4.执行sql  
  88.         Users users=manager.getReference(Users.class"1");   
  89.         System.out.println(users);  
  90.         // 5.提交事务,关闭资源  
  91.         transaction.commit();  
  92.         manager.close();  
  93.         factory.close();  
  94.     }  
  95.   
  96.     // 修改数据  
  97.     public void testUpdate() {  
  98.         // 1.获得Factory  
  99.         EntityManagerFactory factory = Persistence.createEntityManagerFactory("JPA");  
  100.         // 2.获取Manager  
  101.         EntityManager manager = factory.createEntityManager();  
  102.         // 3.获得事务,并开启事务  
  103.         EntityTransaction transaction = manager.getTransaction();  
  104.         transaction.begin();  
  105.         // 4.执行sql  
  106.         Users users=manager.find(Users.class"1");   
  107.         users.setUname("哈哈哈1");  
  108.         // 5.提交事务,关闭资源  
  109.         transaction.commit();  
  110.         manager.close();  
  111.         factory.close();  
  112.   
  113.     }  
  114.   
  115.     // 删除数据 remove 相当于hibernate delete方法  
  116.     // remove方法只能移除执久化对象,不能删除游离对象  
  117.     public void testRemove() {  
  118.         // 1.获得Factory  
  119.         EntityManagerFactory factory = Persistence.createEntityManagerFactory("JPA");  
  120.         // 2.获取Manager  
  121.         EntityManager manager = factory.createEntityManager();  
  122.         // 3.获得事务,并开启事务  
  123.         EntityTransaction transaction = manager.getTransaction();  
  124.         transaction.begin();  
  125.         // 4.执行sql  
  126.         Users users=manager.find(Users.class"2"); manager.remove(users);  
  127.         // 5.提交事务,关闭资源  
  128.         transaction.commit();  
  129.         manager.close();  
  130.         factory.close();  
  131.     }  
  132.   
  133. }  



阅读更多
想对作者说点什么?

博主推荐

换一批

没有更多推荐了,返回首页