如何使用Java Hibernate实现数据库操作？

Jpa是满足JavaEE开发的标准之一，应用于持久化框架，如Hibernate等，这些框架符合Jpa标准，因此实现了相同的接口；能通过XML或者注解的方式实现ORM（对象关系映射），采用面向对象的而非面向数据库的开发方式。例如在使用Hibernate的时候，相比于Mybatis它是偏于自动化生成，可以通过注解javax.persistence.Entity的方式便可以实现数据库实体类的声明，完成表的创建；通过注解的方式将SQL语句置于代码当中，描述实体的映射关系。与MyBatis使用相比，代码中没有了Mapper映射文件。

JPA定义了独特的JPQL（Java Persistence Query Language），JPQL是EJB QL的一种扩展，它是针对实体的一种查询语言，操作对象是实体，而不是关系数据库的表，而且能够支持批量更新和修改、JOIN、GROUP BY、HAVING 等通常只有 SQL 才能够提供的高级查询特性，甚至还能够支持子查询。

Hibernate的使用

Hibernate是Jpa的一种落实，首先引入相关的jar包，使用maven进行管理：

       UTF-8
      5.5.3.Final


   
   
       org.hibernate
       hibernate-entitymanager
       ${project.hibernate.version}
   

默认扫描META-INF下的配置文件，因此在resources目录下创建META-INF/persistence.xml

    
    
        
        org.hibernate.jpa.HibernatePersistenceProvider
        
            
            
            
            
			
            
            
            
            
            
            
        
    

这里的配置中，hibernate.hbm2ddl.auto 能够确定sql的状态，如果为create，在其他操作之前首先判断是否存在实体类所属表，如果没有则先进行创建；但是不要使用create进行更新操作，因为后续的操作都是在原来的基础上进行覆盖

如果需要进行更新（add,update,delete）将value改为update

创建实体类 Customer，省略了get,set方法，可以使用lombok插件

@Entity//声明这是一个实体类
@Table(name = "cst_customer")  // 表名，如果为create状态且表不存在，自动创建
@ToString
public class Customer implements Serializable {
    // 表示cust_id为表的主键
    @Id
    // 主键生成策略，这里为自增主键
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    // 表名列，数据库列明与Java对象的对应关系
    @Column(name = "cust_id")
    private Long custId;
    @Column(name = "cust_name")
    private String custName;
    @Column(name = "cust_source")
    private String custSource;
    @Column(name = "cust_industry")
    private String custIndustry;
    @Column(name = "cust_level")
    private String custLevel;
    @Column(name = "cust_address")
    private String custAddress;
    @Column(name = "cust_phone")
    private String custPhone;
}

测试方法，使用Junit

@Test
    public void test01() {
        // 创建一个管理的工厂,这里构造器的名字与persistence.xml的配置持久化单元名字相同
        EntityManagerFactory emf = Persistence.createEntityManagerFactory("myJpa");
        // 创建实体管理
        EntityManager entityManager = emf.createEntityManager();
        // 获取事务对象
        EntityTransaction transaction = entityManager.getTransaction();
        // 开启事务
        transaction.begin();
        Customer user = new Customer();
        user.setCustName("righteye_db");
        // 持久化对象
        entityManager.persist(user);
        // 提交事务
        transaction.commit();
        // 释放资源
        entityManager.close();
        emf.close();
    }

Hibernate的基础使用结束

最后的持久化对象的创建流程相同，可以将创建实体工厂的流程抽象成工具类，简单的样例：

public final class JPAUtils {
    public static EntityManager entityManager = null;
    static {
        EntityManagerFactory emf = Persistence.createEntityManagerFactory("myJpa");
        entityManager = emf.createEntityManager();
    }
    public static EntityManager getEntityManager() {
        return entityManager;
    }
}

Spring整合Hibernate

application.xml spring的配置文件如下：

    
    
        
        
        
        
    
    
    
        
        
        
            
        
        
        
            
                
                
                
                
            
        
        
            
                
                update
            
        
        
            
        
    
    
    
    
        
    
    
    
    
    

自定义查询

ep：通过custName和custID查询Customer

CustomerDao接口的声明, 继承两个父类接口：

public interface CustomerDao extends JpaRepository, JpaSpecificationExecutor {
   // ...
}

在继承的两个接口中已经实现了若干简单的方法，支持简单的单表操作；如果需要自定义查询，如下：

CustomerDao接口中声明方法：

@Query("from Customer where custName = ?1 and custId = ?2")
Customer findCustomerByCondition(String custName, Long custId);

@Query注解中写入JPQL，这里的表名，字段可以直接用Java中的变量表示，使用占位符代替传入的变量，如?1,?2

程序中正常调用：

@Test
public void testMutliCondition() {
   Customer customer = customerDao.findCustomerByCondition("update", 1L);
   System.out.println(customer);
}

多表关系实现

这里使用Customer（顾客）和LinkMan（联系人）实现表之间的一对多关系；这里设定顾客和联系人是一对多

在使用Hibernate的时候，主要使用@OneToMany注解；在一对多的关系中，存在着外键的概念；一般的设计是多表加外键，因此代码如下：

// Customer类
@Entity//声明这是一个实体类
@Table(name = "cst_customer")
@ToString
public class Customer implements Serializable {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name = "cust_id")
    private Long custId;
    @Column(name = "cust_name")
    private String custName;
    @Column(name = "cust_source")
    private String custSource;
    @Column(name = "cust_industry")
    private String custIndustry;
    @Column(name = "cust_level")
    private String custLevel;
    @Column(name = "cust_address")
    private String custAddress;
    @Column(name = "cust_phone")
    private String custPhone;
	// 使用列表存储多的一方的数据，使用@OneToMany,参数表示目标关联表
	// JoinColumn 进行关联，reference(被参照的列) 主表列名：cust_id, 外键：lkm_cust_id
    @OneToMany(targetEntity = LinkMan.class)
    @JoinColumn(name = "lkm_cust_id",referencedColumnName = "cust_id")
    private List lList = new ArrayList<>();
}

外键所在的表，使用的注解实际基本相似

// LinkMan类
@Entity
@Table(name = "db_linkman")
public class LinkMan implements Serializable {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name = "lkm_id")
    private Long lkmId;
    @Column(name = "lkm_name")
    private String lkmName;
    @Column(name="lkm_gender")
    private String lkmGender;
    @Column(name="lkm_phone")
    private String lkmPhone;
    @Column(name="lkm_mobile")
    private String lkmMobile;
    @Column(name="lkm_email")
    private String lkmEmail;
    @Column(name="lkm_position")
    private String lkmPosition;
    @Column(name="lkm_memo")
    private String lkmMemo;
    // LinkMan和Customer是多对一的关系
    @ManyToOne(targetEntity = Customer.class)
    // 多的表加外键，并且指定外键关联的列名
    @JoinColumn(name = "lmk_cust_id", referencedColumnName = "cust_id")
    private Customer customer;
}

测试代码，如果设置了auto为create，代码执行完可以自动创建表

@Test
public void test03() {
    LinkMan lm = new LinkMan();
    lm.setLkmName("linkman");
    Customer customer = new Customer();
    customer.setCustName("customer");
    customerDao.save(customer);
    linkManDao.save(lm);
}