开发者

Java Hibernate使用方法及整合查询

开发 作者： 右眸Remnant
目录
  • Hibernate的使用
  • Spring整合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进行管理：

<properties>
       <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
      <project.hibernate.version>5.5.3.Final</project.hibernate.version>
</properties>
<dependencies>
   <!-- hibernate对jpa的支持包 -->
   <dependency>
       <groupId>org.hibernate</groupId>
       <artifactId>hibernate-entitymanager</artifactId>
       <version>${project.hibernate.version}</version>
   </dependency>
</dependencies>

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

<?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_2_0.xsd"
             version="2.0">
    <!-- 配置持久化单元
            name:名称
            事务类型
    -->
    <persistence-unit name="myJpa" transaction-type="RESOURCE_LOCAL">
        <!--        配置JPA规范的服务提供者,这里使用hibernate-->
        <provider>org.hibernate.jpa.HibernatePersistenceProvider</provider>
        <properties>
            <property name="javax.persistence.jdbc.driver" value="com.mysql.www.devze.comjdbc.Driver"/>
            <property name="javax.persistence.jdbc.url" value="jdbc:mysql://localhost:3306/db5"/>
            <property name="javax.persistence.jdbc.user" value="root"/>
            <property name="javax.persistence.jdbc.password" value="123456"/>
			<!--在控制台输出sql语句-->
            <property name="hibernate.show_sql" value="true"/>
            <property name="hibernate.format_sql" value="true"/>
            <!--首先采用创建的类型， 如果不存在表首先创建一个；会覆盖原来的数据-->
            <!--<property name="hibernate.hbm2ddl.auto" value="create"/>-->
            <!--更新数据-->
            <property name="hibernate.hbm2ddl.auto" value="update"/>
        </properties>
    </persistence-unit>
</persistence>

这里的配置中，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();
        // 开启事务
        trans开发者_开发教程action.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的配置文件如下：

    <!-- 1.dataSource 配置数据库连接池-->
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="driverClass" value="com.mysql.jdbc.Driver" />
        <property name="jdbcUrl" value="jdbc:mysql://localhost:3306/db5?autoReconnect=true&amp;useUnicode=true&amp;characterEncoding=utf8&amp;serverTimezone=Asia/Shanghai" />
        <property name="user" value="root" />
        <property name="password" value="123456" />
    </bean>
    <!-- 2.配置entityManagerFactory -->
    <bean id="entityManagerFactory" class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
        <property name="dataSource" ref="dataSource" />
        <property name="packagesToScan" value="com.righteye.entity" />
        <property name="persistenceProvider">
            <bean class="org.hibernate.jpa.HibernatePersistenceProvider" /编程>
        </property>
        <!--JPA的供应商适配器-->
        <property name="jpaVendorAdapter">
            <bean class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter">
                <property name="generateDdl" value="false" />
                <property name="database" value="MYSQL" />
                <property name="databasePlatform" value="org.hibernate.dialect.MySQLDialect" />
                <property name="showSql" value="true" />
            </bean>
        </property>
        <property name="jpaProperties">
            <props>
                <!--可以设置是否自动创建表-->
                <prop key="hibernate.hbm2ddl.auto">update</prop>
            </props>
        </property>
        <property name="jpaDialect">
            <bean class="org.springframework.orm.jpa.vendor.HibernateJpaDialect" />
        </property>
    </bean>
    <!-- 3.事务管理器-->
    <!-- JPA事务管理器  -->
    <bean id="transactionManager" class="org.springframework.orm.jpa.JpaTransactionManager">
        <property name="entityManagerFactory" ref="entityManagerFactory" />
    </bean>
    <!-- 整合spring data jpa-->
    <jpa:repositories base-package="com.righteye.dao"
                      transaction-manager-ref="transactionManager"
                      entity-manager-factory-ref="entityManagerFactory"></jpa:repositories>
    <context:component-scan base-package="com.rightjseye"></context:component-scan>
    <!--组装其它 配置文件-->
</beans>

自定义查询

ep：通过custName和custID查询Customer

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

public interface CustomerDao extends JpaRepository<Customer, Long>, JpASPecificationExecutor<Customer> {
   // ...
}

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

CustomerDao接口中声明方法：

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

@Queryhttp://www.devze.com注解中写入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<LinkMan> 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);
}

到此这篇关于Java Hibernate使用方法及整合查询的文章就介绍到这了,更多相关Java Hibernate内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们！

继续阅读：Java HibernateJava Hibernate使用

更多精彩内容

0

上一篇:

下一篇:

精彩评论

暂无评论...
登录 注册
Qedev.com
验证码 换一张
取 消

最新开发

开发排行榜

法律声明：本站内容均为网友上传，网站举办方负责审核和监督，

如存在版权或非法内容，欢迎举报，我们将尽快予以删除。

Copyright © 2018-2020 开发者. All rights reserved.

Powered by 开发者

ICP备案号： 京ICP备10032868号-9