简述普通 Java 与 Spring 工程中 hibernate 的使用与工作原理

已于 2022-10-27 10:28:51 修改
阅读量600 收藏 1
点赞数 1
文章标签： hibernate java 后端
于 2022-09-22 20:34:32 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41490274/article/details/126992811
版权

Hibernate 简单使用

1.在 Maven 项目中使用 Hibernate，这里省略数据库驱动与数据源的依赖坐标。

<dependency>
    <groupId>org.hibernate</groupId>
    <artifactId>hibernate-entitymanager</artifactId>
    <version>5.4.2.Final</version>
</dependency>

2.创建配置文件 src/main/resources/META-INF/persistence.xml。

<persistence xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
             xmlns="http://java.sun.com/xml/ns/persistence"
             xsi:schemaLocation="http://java.sun.com/xml/ns/persistence http://java.sun.com/xml/ns/persistence/persistence_2_0.xsd"
             version="2.0">

    <persistence-unit name="myJpa" transaction-type="RESOURCE_LOCAL">
        <description>jpa入门案例演示</description>

        <class>cn.smbms.entity.Product</class>

        <properties>
<!--            <property name="javax.persistence.jdbc.driver" value="com.mysql.jdbc.Driver"/>-->
<!--            <property name="javax.persistence.jdbc.url" value="jdbc:mysql://127.0.0.1:3306/smbms"/>-->
            <property name="javax.persistence.jdbc.driver" value="org.postgresql.Driver"/>
            <property name="javax.persistence.jdbc.url" value="jdbc:postgresql://127.0.0.1:5432/smbms"/>
            <property name="javax.persistence.jdbc.user" value="postgres"/>
            <property name="javax.persistence.jdbc.password" value="123456"/>
            <property name="hibernate.show_sql" value="true"/>
            <property name="hibernate.format_sql" value="true"/>
            <property name="hibernate.hbm2ddl.auto" value="none"/>
        </properties>
    </persistence-unit>
</persistence>

3.配置与表映射的 Java Entity。

import javax.persistence.*;
import java.io.Serializable;

@Entity
@Table
public class Product implements Serializable {
    
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column
    private Integer productId;
    
    @Column
    private String productName;
    
    
    public Integer getProductId() {
        return productId;
    }
    
    public void setProductId(Integer productId) {
        this.productId = productId;
    }
    
    public String getProductName() {
        return productName;
    }
    
    public void setProductName(String productName) {
        this.productName = productName;
    }
}

4.修改 persistence.xml hibernate.hbm2ddl.auto=create 设置 Hibernate 根据 Entity 配置自动建表，注意表结构创建好之后一般后续都修改 hibernate.hbm2ddl.auto 为 none。

<property name="hibernate.hbm2ddl.auto" value="create"/>

5.使用 Hibernate 进行 CRUD 测试。
插入：

    @Test
    public void test_01() {
    	// 根据 persistence.xml 中 persistence-unit=myJpa 配置创建 EntityManager 实例，
    	// 我们通过该 entityManager 操作数据库
        EntityManager entityManager = Persistence.createEntityManagerFactory("myJpa").createEntityManager();
        EntityTransaction tx = null;
        try {
            tx = entityManager.getTransaction();
            tx.begin();
            Product p = new Product();
            p.setProductName("电冰箱");
            entityManager.persist(p);
//            int i = 1 / 0;
            tx.commit();
        } catch (Exception e) {
            e.printStackTrace();
            tx.rollback();
        } finally {
            entityManager.close();
        }
    }

观察控制台我们发现 Hibernate 不仅创建了表结构，还插入了数据：
在这里插入图片描述
执行结果：
在这里插入图片描述

后续演示部分代码省略 EntityManager 实例的创建。

查，findById：

entityManagerFactory = Persistence.createEntityManagerFactory("myJpa");
EntityManager entityManager = entityManagerFactory.createEntityManager();
entityManager.getTransaction().begin();
Product product = entityManager.find(Product.class, 1);
logger.info("Product=>id:{},name:{}", product.getProductId(), product.getProductName());
entityManager.getTransaction().commit();
entityManager.close();

查，findAll：

entityManagerFactory = Persistence.createEntityManagerFactory("myJpa");
EntityManager entityManager = entityManagerFactory.createEntityManager();
entityManager.getTransaction().begin();
List<Product> list = entityManager.createQuery("from Product", Product.class).getResultList();
list.forEach(x -> logger.info("P=>id:{},name:{}", x.getProductId(), x.getProductName()));
entityManager.getTransaction().commit();
entityManager.close();

改：

EntityManager entityManager = null;
EntityTransaction tx = null;
try {
	// 封装了对 Persistence.createEntityManagerFactory("myJpa") 的调用
    entityManager = JPAUtil.getEntityManager();
    tx = entityManager.getTransaction();
    tx.begin();
    Product p = new Product();
    p.setProductId(3);
    p.setProductName("电冰箱");
    //修改方法
    entityManager.merge(p);
    //  int i = 1/0;
    tx.commit();
} catch (Exception e) {
    e.printStackTrace();
    JPAUtil.rollback(tx);  // 判空后调用 tx 的 rollback 方法
} finally {
    JPAUtil.close(entityManager); // 判空后调用 entityManager 的 close 方法
}

改（Java 对象与数据库数据行关联，对象的修改直接同步到数据库）：

EntityManager entityManager = null;
EntityTransaction tx = null;
try {
    entityManager = JPAUtil.getEntityManager();
    tx = entityManager.getTransaction();
    tx.begin();
    Product p = entityManager.find(Product.class, 3);//p从这之后就会变成持久化对象
    p.setProductName("空调");
    tx.commit();
} catch (Exception e) {
    e.printStackTrace();
    JPAUtil.rollback(tx);
} finally {
    JPAUtil.close(entityManager);
}

删：

EntityManager entityManager = null;
EntityTransaction tx = null;
try {
    entityManager = JPAUtil.getEntityManager();
    tx = entityManager.getTransaction();
    tx.begin();
    Product p = entityManager.find(Product.class, 3);//p从这之后就会变成持久化对象
    entityManager.remove(p);
    tx.commit();
} catch (Exception e) {
    e.printStackTrace();
    JPAUtil.rollback(tx);
} finally {
    JPAUtil.close(entityManager);
}

查，立即加载：

EntityManager entityManager = null;
EntityTransaction tx = null;
try {
    entityManager = JPAUtil.getEntityManager();
    tx = entityManager.getTransaction();
    tx.begin();
    //find()为立即加载 SQL语句 get()
    Product p = entityManager.find(Product.class, 2);//p从这之后就会变成持久化对象
    //没有使用p对象
    tx.commit();
} catch (Exception e) {
    e.printStackTrace();
    JPAUtil.rollback(tx);
} finally {
    JPAUtil.close(entityManager);
}

查，延迟加载：

EntityManager entityManager = null;
EntityTransaction tx = null;
try {
    entityManager = JPAUtil.getEntityManager();
    tx = entityManager.getTransaction();
    tx.begin();
    //getReference为延迟加载 SQL语句 load()
    //返回来的是一个 代理模式生成的代理对象 该代理对象中只有主键 其他的并没有
    Product p = entityManager.getReference(Product.class, 1);//p从这之后就会变成持久化对象
    //使用主键
    System.out.println(p.getProductId());
    Thread.sleep(1000);     // sleep 之前 SQL 并未执行
    System.out.println(p.getProductName());
    //没有使用p对象
    tx.commit();
} catch (Exception e) {
    e.printStackTrace();
    JPAUtil.rollback(tx);
} finally {
    JPAUtil.close(entityManager);
}

查，缓存：

EntityManager entityManager = null;
EntityTransaction tx = null;
try {
    entityManager = JPAUtil.getEntityManager();
    tx = entityManager.getTransaction();
    tx.begin();
    //find()为立即加载 SQL语句 get()
    Product p = entityManager.find(Product.class, 1);//p从这之后就会变成持久化对象
    Product p2 = entityManager.find(Product.class, 1);//p从这之后就会变成持久化对象
    System.out.println(p == p2);// true
    //没有使用p对象
    tx.commit();
} catch (Exception e) {
    e.printStackTrace();
    JPAUtil.rollback(tx);
} finally {
    JPAUtil.close(entityManager);
}

查，JPQL：

EntityManager entityManager = null;
EntityTransaction tx = null;
try {
    entityManager = JPAUtil.getEntityManager();
    tx = entityManager.getTransaction();
    tx.begin();
    String jpql = "from Product";
    List<Product> resultList = entityManager.createQuery(jpql, Product.class).getResultList();
    resultList.forEach(x -> logger.info("P=>id:{},name:{}", x.getProductId(), x.getProductName()));
    //没有使用p对象
    tx.commit();
} catch (Exception e) {
    e.printStackTrace();
    JPAUtil.rollback(tx);
} finally {
    JPAUtil.close(entityManager);
}

查，JPSQL 模糊查询（参数位置）：

EntityManager entityManager = null;
EntityTransaction tx = null;
try {
    entityManager = JPAUtil.getEntityManager();
    tx = entityManager.getTransaction();
    tx.begin();
    // 根据产品名 模糊查询产品信息 使用参数位置绑定的方式 传递参数
    // 参数命名方式
    String jpql = "from Product where productName like concat('%',?0,'%')";
    List<Product> resultList = entityManager.createQuery(jpql, Product.class)
                    .setParameter(0, "手").getResultList();
    resultList.forEach(x -> logger.info("P=>id:{},name:{}", x.getProductId(), x.getProductName()));
    tx.commit();            // 没有使用 p 对象
} catch (Exception e) {
    e.printStackTrace();
    JPAUtil.rollback(tx);
} finally {
    JPAUtil.close(entityManager);
}

查，JPSQL 模糊查询（参数别名）：

EntityManager entityManager = null;
EntityTransaction tx = null;
try {
    entityManager = JPAUtil.getEntityManager();
    tx = entityManager.getTransaction();
    tx.begin();
    // 根据产品名 模糊查询产品信息 使用参数命名方式 绑定参数
    String jpql = "from Product where productName like concat('%',:name,'%')";
    List<Product> resultList = entityManager.createQuery(jpql, Product.class)
            .setParameter("name", "手").getResultList();
    resultList.forEach(x -> logger.info("P=>id:{},name:{}", x.getProductId(), x.getProductName()));
    tx.commit();            // 没有使用p对象
} catch (Exception e) {
    e.printStackTrace();
    JPAUtil.rollback(tx);
} finally {
    JPAUtil.close(entityManager);
}

查，JPQL 统计：

EntityManager entityManager = null;
EntityTransaction tx = null;
try {
    entityManager = JPAUtil.getEntityManager();
    tx = entityManager.getTransaction();
    tx.begin();
    //根据产品名 模糊查询产品信息 使用参数命名方式 绑定参数
    String jpql = "select count(*) from Product";
    //uniqueResult():统计查询用的
    Long resultList = ((Long) entityManager.createQuery(jpql).getSingleResult());
      System.out.println(resultList.getClass());//int long
    System.out.println(resultList.intValue());//int long
    //没有使用p对象
    tx.commit();
} catch (Exception e) {
    e.printStackTrace();
    JPAUtil.rollback(tx);
} finally {
    JPAUtil.close(entityManager);
}

查，JPQL 分页查询：

EntityManager entityManager = null;
EntityTransaction tx = null;
try {
    entityManager = JPAUtil.getEntityManager();
    tx = entityManager.getTransaction();
    tx.begin();
    //根据产品名 模糊查询产品信息 使用参数命名方式 绑定参数
    String jpql = "select count(*) from Product";
    //uniqueResult():统计查询用的
    Long resultList = ((Long) entityManager.createQuery(jpql).getSingleResult());
    int totalCount = resultList.intValue();
    System.out.println("总记录数:" + totalCount);
    int pageNo = 1;
    int pageSize = 2;
    //计算总页数
    int totalPage = totalCount % pageSize == 0 ? totalCount / pageSize : totalCount / pageSize + 1;
    System.out.println("总页数是:" + totalPage);
    //分页
    String jpqlPage = "from Product order by productId desc";
    List<Product> productList = entityManager.createQuery(jpqlPage, Product.class)
            .setFirstResult((pageNo - 1) * pageSize).setMaxResults(pageSize).getResultList();
    for (Product product : productList) {
        System.out.println(product);
    }
    tx.commit();            // 没有使用p对象
} catch (Exception e) {
    e.printStackTrace();
    JPAUtil.rollback(tx);
} finally {
    JPAUtil.close(entityManager);
}

EntityManager接口详解

参考：https://blog.csdn.net/J080624/article/details/78751411

EntityManger && PersistenceContext 接口详解

参考：https://www.jianshu.com/p/091360c47e6b

Hibernate 的工作原理

1.在我们给项目中引入 hibernate-entitymanager 包后，classpath 下将多出一个与 Hibernate 有关的 Java SPI 文件，其指向了 Java javax.persistence.spi.PersistenceProvider 接口的 java persistence 规范接口的实现 org.hibernate.jpa.HibernatePersistenceProvider。
在这里插入图片描述
2.我们回顾我们 EntityManager 实例的创建： EntityManager entityManager = Persistence.createEntityManagerFactory("myJpa").createEntityManager()，其原理是调用 javax.persistence.Persistence 的静态方法 createEntityManagerFactory。
在这里插入图片描述

createEntityManagerFactory 通过 ServiceLoader.load 加载 Classpath 下 hibernate-core-5.4.2.Final.jar 包中的 SPI 文件，最终拿到 Hibernate 实现的 java persistence org.hibernate.jpa.HibernatePersistenceProvider。

3.HibernatePersistenceProvider 可对项目中 src/main/resources 下 META-INF/persistence.xml 的 Hibernate 配置文件的解析。其解析 persistence-unit 下对 @Entity 与数据库连接配置，并完成 Java Entity 与数据库表之间的映射。最终构造出实例 EntityManager 供我们在 Java 程序中对数据库进行全自动的 orm 操作。

Hibernate 遇上 Spring

当我们想要在 Spring 项目中使用 Hibernate 时，可以考虑 Spring 的 Spring Data Jpa 扩展。

Spring Data Jpa 基于 Hibernate 访问数据库，是简化 JPA 开发的框架，我们只需要按照约定写 DAO 层即可通过方法名称约定生成 JPA 查询，最终以 Spring 的方式来使用 JPA。

Spring Data Jpa 也包括一些额外的功能：分页、排序、复杂查询等。

项目依赖
<!--  Spring IoC 支持 -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
</dependency>
<!--  Spring AOP 支持 -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-aspects</artifactId>
</dependency>
<!--  Spring 数据库连接池支持 -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-jdbc</artifactId>
</dependency>
<!--  Spring 对 Hibernate 的支持 -->
<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-orm</artifactId>
</dependency>
<!--  Spring 对 Jpa 的支持 -->
<dependency>
    <groupId>org.springframework.data</groupId>
    <artifactId>spring-data-jpa</artifactId>
</dependency>
<!-- 数据库连接池 -->
<dependency>
    <groupId>org.hibernate</groupId>
    <artifactId>hibernate-c3p0</artifactId>
    <version>${hibernate.version}</version>
</dependency>
<!-- hibernate orm -->
<dependency>
    <groupId>org.hibernate</groupId>
    <artifactId>hibernate-entitymanager</artifactId>
    <version>${hibernate.version}</version>
</dependency>
<!-- postgresql 数据库驱动 -->
<dependency>
    <groupId>org.postgresql</groupId>
    <artifactId>postgresql</artifactId>
    <version>42.5.0</version>
</dependency>
测试 Spring Data Jpa
public interface ProductDao extends JpaRepository<Product, Integer>, JpaSpecificationExecutor<Product> {
}

@Entity
@Table
@Data
public class Product implements Serializable {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column
    private Integer productId;
    @Column
    private String productName;
}

c3p0 数据库连接池配置：

c3p0.minPoolSize=5
c3p0.maxPoolSize=20
c3p0.idleConnectionTestPeriod=60
c3p0.maxIdleTime=120
c3p0.acquireIncrement=2
c3p0.initialPoolSize=10
c3p0.jdbcUrl=jdbc:postgresql://127.0.0.1:5432/smbms
c3p0.driverClass=org.postgresql.Driver
c3p0.user=postgres
c3p0.password=123456

Spring 配置文件：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	   xmlns:jdbc="http://www.springframework.org/schema/jdbc"
	   xmlns:tx="http://www.springframework.org/schema/tx"
	   xmlns:jpa="http://www.springframework.org/schema/data/jpa"
	   xmlns:context="http://www.springframework.org/schema/context"
	   xsi:schemaLocation="http://www.springframework.org/schema/jdbc https://www.springframework.org/schema/jdbc/spring-jdbc.xsd
		http://www.springframework.org/schema/beans https://www.springframework.org/schema/beans/spring-beans.xsd
		http://www.springframework.org/schema/data/jpa https://www.springframework.org/schema/data/jpa/spring-jpa.xsd
		http://www.springframework.org/schema/tx https://www.springframework.org/schema/tx/spring-tx.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">

	<!--c3p0的数据源-->
	<context:property-placeholder location="classpath:c3p0.properties"/>
	<!--Spring整合hibernate的第二种方式:定义c3p0连接池 -->
	<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource" destroy-method="close" >
		<property name="user" value="${c3p0.user}"/>
		<property name="password" value="${c3p0.password}"/>
		<property name="driverClass" value="${c3p0.driverClass}"/>
		<property name="jdbcUrl" value="${c3p0.jdbcUrl}"/>
		<!--minPoolSize :最小连接数(default 3)-->
		<property name="minPoolSize" value="${c3p0.minPoolSize}"/>
		<!--maxPoolSize :最大连接数(default 15)-->
		<property name="maxPoolSize" value="${c3p0.maxPoolSize}"/>
		<!--initialPoolSize : 初始连接数(default 3)-->
		<property name="initialPoolSize" value="${c3p0.initialPoolSize}"/>
		<!--maxIdleTime :最大闲置时间, 未使用的连接在被丢弃之前在连接池存活时间,单位为秒(default 0, 永久存活)-->
		<property name="maxIdleTime" value="${c3p0.maxIdleTime}"/>
		<!--acquireIncrement : 获取连接数量, 连接不足时,c3p0尝试一次获取新连接的个数(default 3)-->
		<property name="acquireIncrement" value="${c3p0.acquireIncrement}"/>
		<!-- 空闲检查时间间隔， 每隔60秒检查连接池里的空闲连接 ，单位是秒-->
		<property name="idleConnectionTestPeriod" value="${c3p0.idleConnectionTestPeriod}"/>
	</bean>

	<bean id="entityManagerFactory" class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
		<property name="dataSource" ref="dataSource" />
		<property name="packagesToScan" value="cn.smbms.entity" />
		<property name="jpaVendorAdapter">
			<bean class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter">
				<property name="database" value="POSTGRESQL" />
				<property name="generateDdl" value="false" />
				<property name="databasePlatform" value="org.hibernate.dialect.PostgreSQL10Dialect"/>
				<property name="showSql" value="true"/>
			</bean>
		</property>
	</bean>


	<jpa:repositories base-package="cn.smbms.dao" />

	<bean id="transactionManager" class="org.springframework.orm.jpa.JpaTransactionManager">
		<property name="entityManagerFactory" ref="entityManagerFactory" />
	</bean>

	<!--扫描注解-->
	<context:component-scan base-package="cn.smbms"/>
	
</beans>

启动 Spring 应用进行测试：

public class TestProductDao {
    @Test
    public void test_01(){
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("applicationContext.xml");
        ProductDao productDao = applicationContext.getBean(ProductDao.class);
        List<Product> all = productDao.findAll();
        all.forEach(System.out::println);
    }
}
Spring Data Jpa 关键配置说明

transactionManager、entityManagerFactory、jpaVendorAdapter、dataSource。

  • com.mchange.v2.c3p0.ComboPooledDataSource：基于C3P0的数据库连接池，对javax.sql.DataSource的实现，用于管理 Spring 应用中数据库连接。
  • org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter：适配数据库。
  • org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean：
    1. 是一个FactoryBean，用于构造 javax.persistence.EntityManagerFactory Bean， 参考 Java 直接使用 Hibernate 用法。
    2. 基于 Spring 的扫描，不需要 persistence.xml 扫描 entity。
    3. 依赖 jpaVendorAdapter 和 dataSource。
  • org.springframework.orm.jpa.JpaTransactionManager：jpa的事务管理器。
  • <jpa:repositories base-package=“cn.smbms.dao” />：扫描并动态代理继承了 JpaRepository 的 dao，并将代理后的 dao 动态注册到 IoC 容器。
关于对 JpaRepository 接口的代理

用户自定义 JpaRepository dao 层接口在容器中的bean 实际上统一映射为一个 JpaRepositoryFactoryBean 对象，使用者对这样一个 bean 进行依赖注入时，会调用其 FactoryBean#getObject 获取真正要注入的 SimpleJpaRepository 代理对象。
在这里插入图片描述

RepositoryFactoryBean 中依赖注入了 JPA entityManager 实例，也就能操作数据库。最终生成的用户自定义接口 JpaRepository 依赖于 JPA 的实现 Hibernate，Spring Data Jpa 的操作数据库的 SQL 的生成和执行也会依靠 Hibernate 来完成。

关于对 jpa:repositories 标签的解析

在这里插入图片描述
主要就是启用了 spring.handlers 对 <jpa:repositories base-package=“cn.smbms.dao” /> 标签进行解析。spring.handlers 文件配置告诉 Spring 该如何来解析你自定义的配置文件。

在这个配置类中，通过 registerBeanDefinitionParser 向 Spring 注册了 RepositoryBeanDefinitionParser 和 AuditingBeanDefinitionParser 与 JPA 有关的 BeanDefinition 解析器。

蔡徐坤是个程序媛
关注
javaWeb项目添加hibernate
qq_43516959的博客
06-17 192
右键项目-->MyEclipse-->Project Facets[Capabilities]-->Install Hibernate Facet 2.版本选择4.1，服务器选择MyEclipse自带的Tomcat7 3.选择存放HibernateSessionFactory的包 4.配置与数据库的连接，暂时不配。点击finish 5.在src目录下会有名字为hibernate.cfg.xml配置文件，在hibernate包下会有HibernateSess...
Hibernate的简介及工作原理
Mr_TXQ的博客
10-16 654
Hibernate Hibernate简介 Hibernate是一个ORM框架，突出特点就是强大、难学、开发迅速，适合开发中小型的、没有复杂关联关系的、业务 逻辑相对固定的项目。 Hibernate 四个核心部分：持久化操作、关联关系管理、Hibernate查询语言和二级缓存。 Hibernate持久化操作 Hibernate可以把对实体对象的操作转化为对数据库的操作。比如调用session.save(entity)时，Hibernate内部 会自动生成并执行insert语句来把数据保存到数据库。 .
在JAVA SE中使用Hibernate
键者天行
12-29 7808
目前人们很容易发现Hibernate正迅速的成为流行的J2EE的O/R映射工具和数据集成框架（如果不是最流行的）。Hibernate为企业应用开发者操作关系数据库的提供了清晰明了而又强大的工具。然而如果你需要在外部访问那些包装在J2EE web应用里的实体，情况又怎样呢？你的开发跟应用独立分开，却又相同的实体以访问你的数据吗？又或者你得编写附加的web组件来管理对数据的内部访问吗？在很多情况下，这
Spring 中使用 Hibernate
weixin_30783629的博客
08-04 545
Hibernate 在 ORM 领域具有广泛的影响，拥有广大的使用群体。它提供了 ORM 最完整、最丰富的实现，在 Spring 4.0 中目前全面支持 Hibernate 5.0，不再支持 Hibernate 3.6之前的版本。因为 iBatis 的升级版 MyBatis 自身已经提供了对 Spring 整合的支持，所以Spring 不再为 MyBatis 提供直接支持，大家直接使...
Spring中使用hibernate
XiuXiuBlaza
11-06 809
.
spring中使用hibernate
车前猛跑
09-30 70
[code="java"] public void delete (int[] deleteKey) { StringBuffer hql = new StringBuffer("delete Employee where employeeKey in ("); for (int i = 0; i < deleteKey.length; i++) { ...
理解hibernate hibernate工作原理
暖心~的博客
09-18 4199
Hibernate是一个开放源代码的对象关系映射框架。       Hibernate对JDBC进行了非常轻量级的对象封装，它将POJO（Plain Ordinary Java Object：简单的java对象，实际就是普通JavaBeans）与数据库表建立映射关系，是一个全自动的orm（Object Relational Mapping：对象关系映射）框架，hibernate可以自动生成SQL语
Java面试spring专题.zip
最新发布
03-15
4. **数据访问集成**：讨论Spring对各种数据存储方式的支持，如JDBC、ORM框架（Hibernate、MyBatis）、JPA等，以及Spring Data的使用。 5. **Spring MVC**：详述Spring MVC架构，包括DispatcherServlet、...
Spring的简介和工作原理
浮世的博客
04-24 1448
一、简介 Spring 是个java企业级应用的开源开发框架。Spring主要用来开发Java应用，但是有些扩展是针对构建J2EE平台的web应用。Spring 框架目标是简化Java企业级应用开发，并通过POJO为基础的编程模型促进良好的编程习惯。 二、工作原理 Spring最核心的两个点就是IOC和AOP 1、 IoC(Inversion of control): 控制反转 概念：控制权由对象本身转向容器；由容器根据配置文件去创建实例并创建各个实例之间的依赖关系 核心：bean工厂；...
java软件工程师工作业绩_JAVA软件工程师个人简历范文
weixin_30074763的博客
12-23 3673
应届毕业生求职网感谢 大家的支持，特地送上份JAVA方面的简历范文欣赏：[基本信息]姓名：李YJBYS 性别：男 出生日期：07-06居住地：上海市 工作年限：[教育经历]2002/09 - 2006/07 河北理工大学 计算机科学与技术专业 本科[证书]英语四级证书(523分)SUN公司认证SCJP证书[语言能力]英语：较好的文档读写能力；熟悉软...
hibernate依赖jar包
01-06
其中包含了作者在学习Hibernate时，所需要的jar包
hibernate 依赖包
10-13
hibernate 依赖包
spring和struts和hibernate最简单的整合
11-24
在Java Web开发领域，Spring、Struts和Hibernate是三大主流框架，它们分别负责不同层面的...虽然现代开发趋势更倾向于使用Spring Boot和Spring MVC，但理解这种传统的三层架构对于理解现代框架的工作原理仍然很有帮助。
基于SSH(Spring+SpringMVC+Hibernate)开发学生宿舍管理系统
11-16
简述： ...系统采用技术：Spring+SpringMVC+Hibernate+easyui+jQuery+Ajax+maven+面向接口编程 压缩包包含：项目源码+项目设计论文 详情描述：https://blog.csdn.net/CDWLX/article/details/102609862
hibernate框架如何在项目中运用
丶妖孽只在夜里哭
03-08 547
hibernate框架如何在项目中运用
5.Spring如何与Hibernate结合
shiyongyin的专栏
09-18 142
Spring 框架中的HibernateDaoSupport类中封装了运用hibernate框架来实现Dao的相关操作 具体步骤： 1. Dao的实现类通常继承HibernateDaoSupport类 2. 调用getHibernateTemplate().……;方法来实现对pojo进行相应的操作 代码： public class GenericDa...
Spring访问数据库之使用Hibernate
zy199701的博客
02-17 278
Hibernate就是将数据库中的数据映射为java对象，java程序通过操作映射的对象来更改数据库中的数据。 步骤1：设置依赖 !-- JDBC驱动，这里使用HSQLDB --> <dependency> <groupId>org.hsqldb</groupId> <artifactId>hsqldb</artifactId> <version>2.5.0</version> </dep
Hibernate框架--学习笔记（上）：hibernate项目的搭建和常用接口方法、对象的使用
张维鹏的博客
07-19 703
一、什么是Hibernate框架： 1.Hibernate是一个操作数据库的框架，实现了对JDBC的封装； 2.Hibernate是一个ORM（对象关系映射）框架，我们在写程序时 ，用的是面向对象的方法，但是在关系型数据库里，存的是一条条的数据，为了用纯面向对象的思想解决问题，所有需要将程序中的对象和数据库的记录建立起映射关系，ORM就是这样的技术，而Hibernate就是这样一个框架，以操作...
【工具】Java工程导入Hibernate
ThinkQuibbler的专栏
07-23 367
http://jingyan.baidu.com/article/cdddd41c612a3e53cb00e120.html
Spring Boot 3 官方中文文档，全面解析与入门指南
"Spring Boot 3 中文文档是针对Java开发者全新整理并翻译的高质量文档，旨在解决以往中文文档翻译不准确、过时的问题。该文档由 Deepl AI 翻译并经人工校验，内容涵盖Spring Boot的各个方面，包括入门、升级、开发、...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值