Hibernate

最新推荐文章于 2024-06-04 09:07:32 发布
最新推荐文章于 2024-06-04 09:07:32 发布
阅读量834 收藏 1
点赞数
文章标签： hibernate orm
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Ro_bot/article/details/51332579
版权

Hibernate官方中文文档

优化Hibernate所鼓励的7大措施

  1. 尽量使用many-to-one，避免使用单项one-to-many
  2. 灵活使用单向one-to-many
  3. 不用一对一，使用多对一代替一对一
  4. 配置对象缓存，不使用集合缓存
  5. 一对多使用Bag 多对一使用Set
  6. 继承使用显示多态 HQL:from object polymorphism=”exlicit” 避免查处所有对象
  7. 消除大表，使用二级缓存

Hibernate 介绍

什么是Hibernate?

  • 首先，hibernate 是数据持久层的一个轻量级框架。
  • 并且 hibernate 是一个开源的 orm (object relations model) 框架，提供了查询获取数据的方法，用面向对象的思想来操作数据库，节省了我们开发处理数据的时间。

优点

  1. 使用简洁的 hql (hibernate query language)。可以不使用传统的 insert，update等 sql 语句。比如 insert 一个对象，原来的做法是：insert into table_name value (value1, value2, value3...)，而现在的做法是：save(obj)。
  2. 使用 or 映射。对象到关系数据库之间的映射，是从对象的角度操作数据库，在此体现了面向对象的思想。原来的实体抽取方法：首先有了表，然后表映射实体对象。而现在 hibernate 的做法是：直接由对象映射到表。
  3. 没有侵入性，移植性比较好。什么是没有侵入性？就是hibernate 采用了 pojo 对象。所有pojo 对象就是没有继承 hibernate 类或实现 hibernate 接口。这样的话，此类就是一个普通的 Java 类，所以移植性比较好。
  4. 支持透明持久化。透明是针对上层而言的。三层架构的理念是上层对下层的依赖，只是依赖接口不依赖具体实现。而 hibernate 中的透明是指对业务逻辑层提供了一个接口 session ，而其他的都是封装隐藏。持久化是指把内存中的数据存放到磁盘的文件中去。

缺点

  1. 若是大量数据批量操作，不适合使用hibernate。
  2. 一个持久化对象不能映射到多张表中。

核心接口

  1. Configuration：负责配置及启动 hibernate，用来创建 SessionFactory。
  2. SessionFactory：一个SessionFactory对应一个数据源存储，也就是一个数据库对应一个SessionFactory。SessionFactory用来创建Session对象。并且SessionFactory是线程安全的，可以由多个线程访问SessionFactory共享。
  3. Session：这个接口是 hibernate 中常用的接口，主要用于对数据的操作（增删查改）。而这个Session对象不是线程安全的。不能共享。
  4. Query：用于数据库的查询对象。
  5. Transaction：hibernate 事务接口。它封装了底层的事务操作，比如JTA (java transaction architecture) 所有的数据操作，不如增删查改都写在事务中。

Hibernate 使用步骤

  1. 配置hibernate.cfg.xml 配置文件
  2. 建立实体类
  3. 建立实体类配置文件*.hbm.xml
  4. 添加*.hbm.xml映射文件路径到hibernate.cfg.xml

悲观锁和乐观锁

悲观锁：在查询时加

Student s = session.get(Student.class, id, LockMode.UPGRADE);

五种模式

  1. LockMode.NONE：查询时先在 cache （缓存）里找，如果没有，再到 db 里加载无锁机制。
  2. LockMode.READ：不管 cache 有没有，都查询数据库，hibernate 在读取记录的时候会自动获取。
  3. LockMode.UPGRADE：不管cache 有没有，都查询数据库，并且对查询的数据加锁，如果锁被其它事务拿走，当前事务会一直等到加上锁为止。利用数据库的for update子句加锁。
  4. LockMode.UPGRADE_NOWAIT：不管 cache 有没有，都查询数据库，并且对查询的数据加锁，如果锁被其它事务拿走，当前事务会立即返回。hibernate Oracle 的特定实现，利用 Oracle 的for update nowait子句实现加锁。
  5. LockMode.WRITE：在做 insert, update, delete会自动使用模式，内部使用。

什么时候用悲观锁（查询数据时，就给数据加锁）

  1. 数据源被多个事务并发访问的机会很大
  2. 修改数据所需时间非常短

乐观锁：大多基于数据版本记录机制实现

  1. 在javabean 中加上 version 的属性提供 set() 和 get()方法
  2. 在数据库表上加上 version 列
  3. 在映射文件的<id></id>后加上<version name="version" column="version" />

实现原理

  • 读取出数据时，将此版本号一同读出，之后更新时，对此版本号加一。此时，将提交数据的版本数据与数据库表对应记录的当前版本信息进行对比，如果提交的数据版本号大于数据库表当前版本号，则予以更新，否则认为是过期数据。

事务的并发控制

多个事务运行时的并发问题

  • 并发问题归纳为以下几类：

    1. 第一类丢失更新：撤销一个事务时，把其它事务已经提交的更新数据覆盖。
    2. 脏读：一个事务读到另一个事务未提交的更新数据。
    3. 虚读：一个事务读到另一个事务提交的新插入的数据。
    4. 不可重复读：一个事务读到另一个事务已经提交的更新数据。事务A对统一数据重复读两次却得到不同的结果，有可能在A读取数据的时候事务B对统一数据做了修改。
    5. 第二类丢失更新：这是不可重复读中的特例，一个事务付给另一个事务已提交的更新事务。

数据库系统提供了四中事务隔离级别供用户选择

  1. Serializable（串行化）：一个事务在执行过程中完全看不到其他事务对数据库所做的更新。
  2. Repeatable Read（可重复读）：一个事务在执行过程中可以看到其他事务已经提交的新插入的记录，但是不能看到其他事务对已有记录的更新。
  3. Read Commited（读已提交数据）：一个事务在执行过程中可以看到其他事务已经提交的新插入的记录，而且能看到其他事务已经提交的对已有记录的更新。

  4. Read Uncommitted（读未提交数据）：一个事务在执行过程中可以拷打其他事务没有提交的新插入的记录，而且能看到其他事务没有提交的对已有记录的更新。

    隔离级别越高，越能保证数据的完整性和一致性，但是对并发性能的影响也越大。对于多数应用程序，可以有优先考虑把数据库系统的隔离级别设为Read Commited，它能够避免脏读，而且具有较好的并发性能。尽管它会导致不可重复读、虚读和第二类丢失更新这些并发问题，在可能出现这类问题的个别场合，可以由应用程序采用悲观锁或乐观锁来控制
    在hibernate.cfg.xml中设置隔离级别：

<session-factory>
    <!-- 设置格力层次，并发，缺省时Read Commited:2 -->
    <property name="connection.isolation">2</property>
    <!-- 配置事务实现类 -->
    <property name="transaction.factory_class">
        org.hibernate.transaction.JDBCTransactionFactory
    </property>
</session-factory>

对象状态

对象状态

关系映射

  • 这里的关系是指对象之间的关系，不是数据库之间的关系。

  • 简化问题：

    a) 怎么写Annotation

    b) 增删查改CRUD怎么写

    三种关系（一对一，一对多，多对多），如果在程序里就有（单向，多向）七种。
    常用的主键关联的单向的外键关联。

一对一的单向外键关联：

如果在类里面 new 另一个对象，则是类的单向引用。多对多，一对一都是多对多的特殊例子。

  • Annotation
@OneToOne
@JoinColumn(name="wifeId")
public Wife getWife() {
    return wife;
}
  • xml文件
<many-to-one name="student" column="studentId" unique="true">
</many-to-one>
<!-- 不能按照字面理解。unique="true"就变成了一对一的单向关联，
    column关联字段，注意在建立关联的时候，每个表格的配置都正确，
    因为出错了不会报错。
-->

一对一的双向外键关联：

两个关联
  • Annotation
@OneToOne(mappedBy="wife")
/*
 * 相当于告诉 hibernate 它跟该对象是一个一对一的关联
 * 告诉它在 Wife 已经在 husband 类的一个属性 wife上做了映射。
 */
  • xml文件

i

<one-to-one name="stuldCard" property-ref="student">
</one-to-one>

ii

<many-to-one name="student" column="studentId" unique="true">
</many-to-one>

一对一的单向主键关联（少用）

  • Annotation
@OneToOne
@PrimaryKeyJoinColumn
  • xml文件
<one-to-one name="student" constrained="true" column="student">
</one-to-one>
<!-- 可以设置主键约束，加上：constrained="true"
    主键也要改
-->
<id name="id" column="id">
    <generator class="foregin">
        <param name="property">
            student
        </param>
    </generator>
</id>

双向的主键关联（少用）

在设置主键关联的类的主键字段需要单独建立一个类，字段就是实体类需要主键关联的主键，WifePK.java。这个类不是实体类，不做任何操作。

  • Annotation

@IdClass(WifePK.class)：设置联合的类，包含联合的字段，WifePK需要实现Serializable和重写equals()和hashCode()方法。在每一个联合的属性上加@Id就可以了。如果要更改字段名字，在联合主键里用JoinColumns

@JoinColumn(
(
    @JoinColumn(name="wifeId", referencedColumnName="id")
    @JoinColumn(name="wifeName", referencedColumnName="name")
)

只要有双向关联mappedBy必设（不应该在两边都插数据）

多对一单向（重点）

  1. 项目名称
  2. 多个User可以是一个Group
  3. 在多那一方加外键。@OneToMany加在get()方法
  4. 多对一的映射关联用在映射类的get()方法上@ManyToOne，如果类名与表明不一样，用`@Table(name=”tableName”)
  5. xml<many-to-one name="student" column="studentId"></many-to-one>

一对多单向

  • Annotation
Set<User> user = new HashSet<User>();

@OneToMany
@JoinColumn(name="hb")
public Set<User> getUser() {
    return user;
}
  • xml文件
<set name="user">
    <key column="groupId" />
</set>
<one-to-many class="*.User">
</one-to-many>

Demo

hibernate.cfg.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-configuration PUBLIC
        "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
        "http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
    <session-factory>
        <!--用户名 -->
        <property name="hibernate.connection.username">root</property>
        <!--密码 -->
        <property name="hibernate.connection.password">root</property>
        <!--url信息 -->
        <property name="hibernate.connection.url">
            jdbc:mysql://localhost:3306/test
        </property>
        <!--数据库驱动信息 -->
        <property name="hibernate.connection.driver_class">
            com.mysql.jdbc.Driver
        </property>
        <!--数据库方言信息 -->
        <property name="dialect">
            org.hibernate.dialect.MySQLDialect
        </property>
        <!-- 数据库表生成策略
            create创建
            update更新
        -->
        <property name="hbm2ddl.auto">update</property>

        <!-- 是否打印SQL语句 -->
        <property name="show_sql">true</property>
        <!-- 是否格式化SQL语句 -->
        <property name="format_sql">true</property>

        <!-- sessionFactory.getCurrentSession()所需 -->
        <property name="hibernate.current_session_context_class">thread</property>

        <!-- 是否打开二级缓存，默认关闭
        <property name="cache.provider_class">
            net.sf.ehcache.hibernate.EhCacheProvider
        </property>
        指定二级缓存的实现类 -->

        <!--指定Hibernate映射文件需要关联的映射对象 -->
        <mapping resource="com/foo/hibernate/bean/student.hbm.xml" />
    </session-factory>
</hibernate-configuration>

student.hbm.xml

<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
    <!-- 对应表STUDENT -->
    <class name="com.foo.hibernate.bean.Student" table="STUDENT">

        <!-- 开启缓存
        <cache usage="read-only" />
        -->

        <!-- hibernate方言会将java类型转换成数据库数据类型  -->
        <id name="id" type="int">
            <!-- 字段 -->
            <column name="ID" />
            <!-- 生成策略
                native由数据库生成,如果创建时设置值也会忽视
            -->
            <generator class="native" />
        </id>
        <property name="name" type="java.lang.String">
            <column name="NAME" />
        </property>
        <property name="age" type="int">
            <column name="AGE" />
        </property>
    </class>
</hibernate-mapping>

Student.java

package com.lee.hibernate.bean;

public class Student {

    private int id;
    private String name;
    private int age;

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public Student() {
    }

    public Student(int id, String name, int age) {
        this.id = id;
        this.name = name;
        this.age = age;
    }

}

Hibernate API

SessionFactory

SessionFactory就是一个用于创建Hibernate的Session对象的工厂。SessionFactory通常是在应用启动时创建好的，应用程序中的代码用它来获得Session对象。作为一个单个的数据存储，它也是 线程安全的，所以多个线程可同时使用同一个SessionFactory。Java JEE应用一般只有一个SessionFactory，服务于客户请求的各线程都通过这个工厂来获得Hibernate的Session实例，这也是为什么SessionFactory接口的实现必须是线程安全的原因。还有，SessionFactory的内部状态包含着同对象关系影射有关的所有元数据，它是 不可变的，一旦创建好后就不能对其进行修改了。

Session

Session代表着Hibernate所做的一小部分工作，它负责维护者同数据库的链接而且 不是线程安全的，也就是说，Hibernage中的Session不能在多个线程间进行共享。虽然Session会以主动滞后的方式获得数据库连接，但是Session最好还是在用完之后立即将其关闭。

创建方式

//每次创建新的session对象
//需要手动关闭
//多次创建未关闭会导致连接池溢出
session = sessionFactory().openSession()

//使用现有的session对象,事务提交或回滚之后会自动关闭.
//需要在hibernate.cfg.xml配置
//本地事务( jdbc事务 )
//<property name="hibernate.current_session_context_class">thread</property>
//全局事务( jta事务 )
//<property name="hibernate.current_session_context_class">jta</property>
session = sessionFactory.getCurrentSession()

get()与load()获得持久化对象

//get()不支持延迟检索策略
//当缓存与数据库不存在与OID对应的记录返回null
object = session.get(id);

//支持延迟加载策略
//当缓存和数据库不存在与OID对应的记录时,抛出
//ObjectNotFoundException异常
object = session.load(id);

save、persist和saveOrUpdate这三个方法的不同之处

这三个方法，也就是save()、saveOrUpdate()和persist()都是用于将对象保存到数据库中的方法，但其中有些细微的差别。例如，save()只能INSERT记录，但是saveOrUpdate()可以进行 记录的INSERT和UPDATE。还有，save()的返回值是一个Serializable对象，而persist()方法返回值为void。你还可以访问 save、persist以及saveOrUpdate，找到它们所有的不同之处。

命名SQL查询

命名查询指的是用标签在影射文档中定义的SQL查询，可以通过使用Session.getNamedQuery()方法对它进行调用。命名查询使你可以使用你所指定的一个名字拿到某个特定的查询。 Hibernate中的命名查询可以使用注解来定义，也可以使用我前面提到的xml影射问句来定义。在Hibernate中，@NameQuery用来定义单个的命名查询，@NameQueries用来定义多个命名查询。

一级缓存（Session缓存）

一级缓存无法取消，用两个方法管理。
evict() 用于将某个对象从session中清除。
clear()用于将一级缓存中所有对象全部清除。

事例

HibernateUtils

package com.lee.hibernate.util;

import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;

public final class HibernateUtils {

    /**
     * configure()读取默认的hibernate.cfg.xml文件
     * 若不是则需configure("filename.cfg.xml")
     */
    private static Configuration config = new Configuration().configure();
    /**
     *针对某个数据库映射关系经过编译后的内存镜像, 是线程安全的.
     *SessionFactory对象一旦构造完毕, 即被赋予特定的配置信息.
     */
    private static SessionFactory sessionFactory = null;

    //私有化构造器, 不可被new
    private HibernateUtils() {
    }

    public static SessionFactory getSessionFactory() {
        if (sessionFactory == null) {
            sessionFactory = config.buildSessionFactory();
        }
        return sessionFactory;
    }

    public static Session getSession() {
        /*
         *两种方法创建session
         *sessionFactory.openSession()
         *sessionFactory.getCurrentSesssion()
         */
        return getSessionFactory().getCurrentSession();
    }
}

Test.java

package com.lee.hibernate.test;

import org.hibernate.Session;
import org.hibernate.Transaction;
import com.lee.hibernate.bean.Student;
import com.lee.hibernate.util.HibernateUtils;

public class Test {
    public static void main(String[] args) {
        Session session = null;
        Transaction transacton = null;
        try {
            session = HibernateUtils.getSession();
            transaction = session.beginTransaction();
            Student student = new Student(0, "jack", 20);
            session.save(student);
            transacton.commit();
        } catch (Exception e) {
            if (transaction != null) {
                transaction.rollback();
            }
            e.printStackTrace();
        } finally {
            if (transacton != null) {
                transacton = null;
            }
        }
    }
}

与 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:tx="http://www.springframework.org/schema/tx"
    xmlns:context="http://www.springframework.org/schema/context"
    xsi:schemaLocation="http://www.springframework.org/schema/beans 
    http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context 
        http://www.springframework.org/schema/context/spring-context-3.2.xsd
        http://www.springframework.org/schema/tx 
        http://www.springframework.org/schema/tx/spring-tx-3.2.xsd">

    <context:property-placeholder location="classpath:db.properties"/>

    <!-- 连接池 -->
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="driverClass" value="${driverClass}" />
        <property name="jdbcUrl" value="${jdbcUrl}" />
        <property name="user" value="${user}" />
        <property name="password" value="${password}" />

        <!--初始化时获取三个连接，取值应在minPoolSize与maxPoolSize之间。Default: 3 -->
        <property name="initialPoolSize" value="3"></property>
        <!--连接池中保留的最小连接数。Default: 3 -->
        <property name="minPoolSize" value="3"></property>
        <!--连接池中保留的最大连接数。Default: 15 -->
        <property name="maxPoolSize" value="5"></property>
        <!--当连接池中的连接耗尽的时候c3p0一次同时获取的连接数。Default: 3 -->
        <property name="acquireIncrement" value="3"></property>
        <!-- 控制数据源内加载的PreparedStatements数量。如果maxStatements与maxStatementsPerConnection均为0，则缓存被关闭。Default: 
            0 -->
        <property name="maxStatements" value="8"></property>
        <!--maxStatementsPerConnection定义了连接池内单个连接所拥有的最大缓存statements数。Default: 0 -->
        <property name="maxStatementsPerConnection" value="5"></property>
        <!--最大空闲时间,1800秒内未使用则连接被丢弃。若为0则永不丢弃。Default: 0 -->
        <property name="maxIdleTime" value="1800"></property>
    </bean>

    <bean id="sessionFactory" 
        class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
        <!-- 数据源 -->
        <property name="dataSource" ref="dataSource"/>
        <!-- Hibernate配置 -->
        <property name="hibernateProperties">
            <props>
                <prop key="hibernate.dialect">org.hibernate.dialect.MySQLDialect</prop>
                <prop key="hibernate.show_sql">true</prop>
                <prop key="hibernate.format_sql">true</prop>
                <!-- 与spring整合会发生错误 save is not valid without active transaction
                <prop key="hibernate.current_session_context_class">thread</prop>
                -->
            </props>
        </property>
        <!-- 扫描映射文件 -->
        <property name="mappingLocations">
            <value>classpath:com/lee/hibernate/entity/*.hbm.xml</value>
        </property>
    </bean>

    <!-- 事务 -->
    <bean id="transactionManager" 
        class="org.springframework.orm.hibernate3.HibernateTransactionManager">
        <property name="sessionFactory" ref="sessionFactory"/>
    </bean>
    <!-- 采用注解方式 -->
    <tx:annotation-driven/>
</beans>
「已注销」
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Hibernate入门第一讲——Hibernate框架的快速入门
李阿昀的博客
08-04 12万+
Hibernate框架介绍什么是Hibernate我们可以从度娘上摘抄这样有关Hibernate的介绍： Hibernate是一个开放源代码的对象关系映射框架，它对JDBC进行了非常轻量级的对象封装，它将POJO与数据库表建立映射关系，是一个全自动的orm框架，hibernate可以自动生成SQL语句，自动执行，使得Java程序员可以随心所欲的使用对象编程思维来操纵数据库。Hibernate可以
Hibernate源码
11-13
Hibernate是Java领域中一款广泛应用的关系型数据库对象映射框架，它简化了开发人员与数据库之间的交互，通过ORM（Object-Relational Mapping）技术将Java对象转换为SQL操作，从而实现数据持久化。Hibernate源码分析...
Hibernate foreign配置
freeglad的专栏
10-27 3379
级联保存    1、一对多级联保存：在和都加上cascade="save-update"    2、一对一级联保存则在配置上加上cascade="save-update"foreign配置   被设为外键方：   foreign">         users      users" class="com.zjhk.shop.vo.Users" constrained="true" cascade
hibernate多对多，多对一映射时用set，bag，list，array时有什么区别？
szyyyp的专栏
05-13 3060
简单的说，这些集合类除了bag，都有其对应的JDK中接口的语义。它们都可以表示一对多或多对多。 Set对应于java.util.Set接口，表示一个没有重复元素的集合。 怎样区别重复元素？这就涉及到对象的同一性。我们知道在数据库中，我们用主键来区分每一条记录，在Java的对象世界中，我们是用Object.equals()方法来区分是否是等价的对象。 set保证，在这个集合中，没有重复的对象。
hibernate
qq_43638685的博客
09-24 3875
hibernate.cfg.xml <?xml version='1.0' encoding='utf-8'?> <!DOCTYPE hibernate-configuration PUBLIC "-//Hibernate/Hibernate Configuration DTD 3.0//EN" "http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd"> <hibernate-configura
Hibernate基本使用
qq_45429856的博客
04-13 5700
SpringBoot整合Hibernate
热门推荐
忆晨的博客
03-22 1万+
Hibernate是什么？ Hibernate与MyBatis都是流行的持久层开发框架，只不过Hibernate是全自动ORM框架，不需要关心sql编写。 Hibernate 是一个高性能的对象/关系映射（ORM）持久化存储和查询的服务，不仅负责从Java类到数据库表的映射 （还包括从Java数据类型到SQL数据类型的映射），还提供了面向对象的数据查询检索机制，从而极大地缩短了手动处理SQL和JDBC上的开发时间。 同时，Hibernate还实现了JPA规范，在SpringBoot中，JPA的默认实现就是使
hibernate简介
Lxn2zh的博客
03-11 5027
第一章 hibernate简介原文链接 https://zhhll.icu/2020/框架/hibernate/基础/1.hibernate简介/ORM(Object Relation Mapping)对象关系映射思想：将关系数据库中表中的记录映射为对象，以对象的形式展现，可以把对数据库的操作转化为对对象的操作。采用元数据来描述对象-关系映射细节，元数据通常采用XML格式，存放在专门的对象-关系映射文件中。hibernate是一个老牌的ORM框架，通过hbm.xml映射文件维护Java和数据库表之间的关
hibernate入门，springboot整合hibernate
沐雨橙风ιε的博客
07-19 3999
Mybatis和Hibernate是我们常用的两大ORM框架，这篇文章主要介绍hibernate的使用，如何通过springboot整合hibernate，实现简单的crud功能。
hibernate包
01-24
Hibernate是一个开源的对象关系映射（ORM）框架，它在Java编程环境中广泛用于简化数据库操作。ORM框架使得开发者可以用面向对象的方式来处理数据库交互，而无需直接编写SQL语句，从而提高了开发效率和代码的可维护性...
hibernate 5.2.15
03-27
hibernate 5.2.15 hibernate 5.2.15 hibernate 5.2.15 hibernate 5.2.15 hibernate 5.2.15hibernate 5.2.15
hibernate jar包程序文件
08-05
hibernate-commons-annotations-4.0.1.Final.jar hibernate-core-4.1.12.Final.jar hibernate-ehcache-4.1.12.Final.jar hibernate-entitymanager-4.1.12.Final.jar hibernate-jpa-2.0-api-1.0.1.Final.jar ...
hibernate插件
08-21
**hibernate插件**是开发人员在使用Hibernate框架时不可或缺的工具，它极大地简化了数据持久化的操作，提高了开发效率。Hibernate是一个流行的Java对象关系映射（ORM）框架，它允许开发者用面向对象的方式处理数据库...
hibernate 的缓存机制
weixin_59705658的博客
03-30 2091
Hibernate 缓存分为两层：Hibernate 的一级缓存和 Hibernate 二级缓存。 1.Hibernate 一级缓存（Session 的缓存）： （1）Session 实现了第一级 Cache，属于事务级数据缓冲。一旦事务结束，缓存随之失效。一个 Session 的生命周期 对应一个数据库事务或一个程序事务。 （2）Session-Cache 总是被打开并且不能被关闭的。 （3）Session-Cache 保证一个 Session 中两次请求同一个对象时，取得的对象是同一个 Java
深入探索Stage #2：属性中的XSS注入技术
weixin_43822401的博客
06-04 676
在Web安全的学习旅程中，XSS（跨站脚本）注入是一个不可忽视的话题。"XSS Challenges"闯关游戏的Stage #2专为进阶学习者设计，专注于属性中的XSS注入技术。本文将详细介绍这一阶段的实操过程和关键概念。
chromedriver-mac-arm64_126.0.6474.0.zip
07-31
chromedriver-mac-arm64_126.0.6474.0.zip
chromedriver-mac-arm64_128.0.6548.0.zip
最新发布
07-31
chromedriver-mac-arm64_128.0.6548.0.zip
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值