Hibernate

最新推荐文章于 2023-07-19 19:59:34 发布
最新推荐文章于 2023-07-19 19:59:34 发布
阅读量354 收藏
点赞数
分类专栏： JAVA
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yongdami/article/details/41040431
版权

Hibernate



hibernate简单示例：

hibernate.cfg.xml

<?xml version='1.0' encoding='utf-8'?>
<!DOCTYPE hibernate-configuration PUBLIC
        "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
        "http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">

<hibernate-configuration>

    <session-factory>

        <!-- Database connection settings -->
        <property name="connection.driver_class">com.mysql.jdbc.Driver</property>
        <property name="connection.url">jdbc:mysql://localhost:3306/test</property>
        <property name="connection.username">root</property>
        <property name="connection.password">root</property>

        <!-- SQL dialect -->
        <property name="dialect">org.hibernate.dialect.MySQLDialect</property>

        <!-- Disable the second-level cache  -->
        <property name="cache.provider_class">org.hibernate.cache.NoCacheProvider</property>

        <!-- Echo all executed SQL to stdout -->
        <property name="show_sql">true</property>

        <!-- Drop and re-create the database schema on startup -->
        <!-- <property name="hbm2ddl.auto">update</property> -->

        <mapping resource="com/java/Student.hbm.xml"/>

    </session-factory>

</hibernate-configuration>


Student.java

package com.java;

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;
	}
	
}
Student.hbm.xml 

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC
        "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
        "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">

<hibernate-mapping package="com.java">

 	<class name="Student" table="student">
        <id name="id" column="id">
            <generator class="native"/>
        </id>
        <property name="name"/>
        <property name="age"/>
    </class>
    
</hibernate-mapping>
Client.java 

package com.java;

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

public class Client {
	public static void main(String[] args) {
		//new对象
		Student s1 = new Student();
		s1.setId(1);
		s1.setName("大大大");
		s1.setAge(60);
		
		//得到hibernate连接
		Configuration cfg = new Configuration().configure();
		SessionFactory sessionFactory = cfg.buildSessionFactory();
		Session session = sessionFactory.openSession();
		
		//使用事务存储  关闭资源
		session.beginTransaction();
		session.save(s1);
		session.getTransaction().commit();
		session.close();
		sessionFactory.close();
	}
}

Annotation注解配置

User.java

package com.java;

import java.util.Date;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.Table;
import javax.persistence.Temporal;
import javax.persistence.TemporalType;
import javax.persistence.Transient;

@Entity
@Table(name="User")
public class User {
	private int id;
	private String username;
	private String password;
	private String title;
	private Date birthday;
	@Id
	@GeneratedValue(strategy=GenerationType.IDENTITY)
	public int getId() {
		return id;
	}
	public void setId(int id) {
		this.id = id;
	}
	@Column(name="username")
	public String getUsername() {
		return username;
	}
	public void setUsername(String username) {
		this.username = username;
	}
	@Column(name="password")
	public String getPassword() {
		return password;
	}
	public void setPassword(String password) {
		this.password = password;
	}
	//数据库不要该字段
	@Transient
	public String getTitle() {
		return title;
	}
	public void setTitle(String title) {
		this.title = title;
	}
	//时间格式   只记录日期  了解
	@Temporal(TemporalType.DATE)
	public Date getBirthday() {
		return birthday;
	}
	public void setBirthday(Date birthday) {
		this.birthday = birthday;
	}
	
}

hibernate.cfg.xml

<mapping class="com.java.User"/>
Demo.java 
package com.java;

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

public class Demo {
	public static void main(String[] args) {
		//new对象
		User u1 = new User();
		u1.setId(3);
		u1.setUsername("root");
		u1.setPassword("root");
		
		//得到hibernate连接
		//Configuration cfg = new Configuration().configure();
		Configuration cfg = new AnnotationConfiguration().configure();
		SessionFactory sessionFactory = cfg.buildSessionFactory();
		Session session = sessionFactory.openSession();
		
		//使用事务存储  关闭资源
		session.beginTransaction();
		session.save(u1);
		session.getTransaction().commit();
		session.close();
		sessionFactory.close();
	}
}

Hibernate开发核心接口

session

Session session = sessionFactory.openSession();
Session session = sessionFactory.getCurrentSession();

openSession 永远都是新的session，必须手动close

getCurrentSession 只要不commit，拿到的都是同一个session，事务提交自动close，

配置文件必须加<property name="current_session_context_class">thread</property>

对象三种状态

Transient 临时状态

Persistent 持久化状态

Detached 分离状态

get、load 查询数据

		User user = (User)session.load(User.class, 32);
		User user = (User)session.get(User.class, 32);

get： 直接执行sql语句。

load： 懒加载机制，若等到session关闭再来取对象则抛异常。

清除缓存

session.clear();

刷新立即同步缓存与数据库（执行sql）
session.flush();
Hibernate Annotation 生成数据库表

package com.java;

import org.hibernate.cfg.AnnotationConfiguration;
import org.hibernate.tool.hbm2ddl.SchemaExport;

public class Test {
	public static void main(String[] args) {
		new SchemaExport(new AnnotationConfiguration().configure()).create(true,true);
	}
}
Hibernate  XML生成数据库表

package com.java;

import org.hibernate.cfg.Configuration;
import org.hibernate.tool.hbm2ddl.SchemaExport;

public class ExportDB {
	public static void main(String[] args) {
		Configuration cfg = new Configuration().configure();
		SchemaExport export = new SchemaExport(cfg); 
		export.create(true, true); 
	}
}

关系映射

但凡双向关联必有一方设@OneToOne(mappedBy="wife")或property-ref="student"
一对一单项外键关联_ annotation

Husband.java

package com.domain;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.OneToOne;

@Entity
public class Husband {
	private int id;
	private String name;
	private Wife wife;
	
	@Id
	@GeneratedValue
	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;
	}
	@OneToOne
	@JoinColumn(name="wifeId")
	public Wife getWife() {
		return wife;
	}
	public void setWife(Wife wife) {
		this.wife = wife;
	}
}
Wife.java 

package com.domain;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;

@Entity
public class Wife {
	private int id;
	private String name;
	
	@Id
	@GeneratedValue
	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;
	}
}

一对一双向外键关联
但凡双向关联必有一方设@OneToOne(mappedBy="wife")或property-ref="student" 
package com.domain;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.OneToOne;

@Entity
public class Husband {
	private int id;
	private String name;
	private Wife wife;
	
	@Id
	@GeneratedValue
	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;
	}
	@OneToOne
	@JoinColumn(name="wifeId")
	public Wife getWife() {
		return wife;
	}
	public void setWife(Wife wife) {
		this.wife = wife;
	}
}

package com.domain;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.OneToOne;

@Entity
public class Wife {
	private int id;
	private String name;
	private Husband husband;
	
	@Id
	@GeneratedValue
	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;
	}
	
	@OneToOne(mappedBy="wife")
	public Husband getHusband() {
		return husband;
	}
	public void setHusband(Husband husband) {
		this.husband = husband;
	}
}
多对一单向关联（多的一方加外键）

package com.domain;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.ManyToOne;

@Entity
public class User1 {
	private int id;
	private String name;
	private Group1 group1;
	@Id
	@GeneratedValue
	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;
	}
	@ManyToOne
	public Group1 getGroup1() {
		return group1;
	}
	public void setGroup1(Group1 group1) {
		this.group1 = group1;
	}
}


package com.domain;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;

@Entity
public class Group1 {
	private int id;
	private String name;

	@Id
	@GeneratedValue
	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;
	}
}

一对多单向外键关联(外键两张表)

package com.domain;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;

@Entity
public class User1 {
	private int id;
	private String name;
	@Id
	@GeneratedValue
	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;
	}
}

package com.domain;

import java.util.HashSet;
import java.util.Set;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.OneToMany;


@Entity
public class Group1 {
	private int id;
	private String name;
	private Set<User1> users = new HashSet<User1>();
	@Id
	@GeneratedValue
	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;
	}
	@OneToMany
	@JoinColumn(name="groupId")//添加外键、只用两张表关联（省略中间表）
	public Set<User1> getUsers() {
		return users;
	}
	public void setUsers(Set<User1> users) {
		this.users = users;
	}
}

一对多_多对一_双向关联 
package com.domain;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.ManyToOne;

@Entity
public class User1 {
	private int id;
	private String name;
	private Group1 group1;
	@Id
	@GeneratedValue
	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;
	}
	@ManyToOne
	public Group1 getGroup1() {
		return group1;
	}
	public void setGroup1(Group1 group1) {
		this.group1 = group1;
	}
	
}

package com.domain;
import java.util.HashSet;
import java.util.Set;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.OneToMany;

@Entity
public class Group1 {
	private int id;
	private String name;
	private Set<User1> users = new HashSet<User1>();
	@Id
	@GeneratedValue
	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;
	}
	@OneToMany(mappedBy="group1")
	public Set<User1> getUsers() {
		return users;
	}
	public void setUsers(Set<User1> users) {
		this.users = users;
	}
}
多对多单向关联（必须含第三表）
package com.domain;

import java.util.HashSet;
import java.util.Set;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.JoinTable;
import javax.persistence.ManyToMany;
@Entity
public class Teacher {
	private int id;
	private String name;
	private Set<Student> students = new HashSet<Student>();
	@Id
	@GeneratedValue
	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;
	}
	@ManyToMany
	@JoinTable(name="t_s",
			joinColumns={@JoinColumn(name="teacher_id")},
			inverseJoinColumns={@JoinColumn(name="student_id")}	
		)
	//配置第三张表名、本表对应id列名、对方表对应id列名
	public Set<Student> getStudents() {
		return students;
	}
	public void setStudents(Set<Student> students) {
		this.students = students;
	}
	
}

package com.domain;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;

@Entity
public class Student {
	private int id;
	private String name;
	@Id
	@GeneratedValue
	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;
	}
}
多对多双向关联（必须包含第三表）
package com.domain;

import java.util.HashSet;
import java.util.Set;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.JoinTable;
import javax.persistence.ManyToMany;
@Entity
public class Teacher {
	private int id;
	private String name;
	private Set<Student> students = new HashSet<Student>();
	@Id
	@GeneratedValue
	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;
	}
	@ManyToMany
	@JoinTable(name="t_s",
			joinColumns={@JoinColumn(name="teacher_id")},
			inverseJoinColumns={@JoinColumn(name="student_id")}	
		)
	//配置第三张表名、本表对应id列名、对方表对应id列名
	public Set<Student> getStudents() {
		return students;
	}
	public void setStudents(Set<Student> students) {
		this.students = students;
	}
	
}


package com.domain;

import java.util.HashSet;
import java.util.Set;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.ManyToMany;

@Entity
public class Student {
	private int id;
	private String name;
	private Set<Teacher> teachers = new HashSet<Teacher>();
	@Id
	@GeneratedValue
	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;
	}
	@ManyToMany(mappedBy="students")
	public Set<Teacher> getTeachers() {
		return teachers;
	}
	public void setTeachers(Set<Teacher> teachers) {
		this.teachers = teachers;
	}
}

树状映射

Org.java 

package com.domain;

import java.util.HashSet;
import java.util.Set;
import javax.persistence.CascadeType;
import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.ManyToOne;
import javax.persistence.OneToMany;

@Entity
public class Org {
	private int id;
	private String name;
	private Set<Org> childs = new HashSet<Org>();
	private Org parent;
	@Id
	@GeneratedValue
	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;
	}
	//级联所有增删改        双向关联必须交给一方管理       拿到父亲所有孩子一起拿出
	@OneToMany(cascade=CascadeType.ALL,mappedBy="parent",fetch=FetchType.EAGER)
	public Set<Org> getChilds() {
		return childs;
	}
	public void setChilds(Set<Org> childs) {
		this.childs = childs;
	}
	@ManyToOne
	@JoinColumn(name="parent_id")
	public Org getParent() {
		return parent;
	}
	public void setParent(Org parent) {
		this.parent = parent;
	}
	
}
Test.java 

//属性结构保存到数据库
public class Save {
		//new对象
		Org o = new Org();
		o.setName("总公司");
		Org o2 = new Org();
		o2.setName("北京分公司");
		Org o3 = new Org();
		o3.setName("上海分公司");
		Org o4 = new Org();
		o4.setName("北京分公司人事部");
		Org o5 = new Org();
		o5.setName("北京分公司财务部");
		
		o.getChilds().add(o2);
		o.getChilds().add(o3);
		o2.getChilds().add(o4);
		o2.getChilds().add(o5);
		o5.setParent(o2);
		o4.setParent(o2);
		o3.setParent(o);
		o2.setParent(o);
		
		//得到hibernate连接
		//Configuration cfg = new Configuration().configure();
		Configuration cfg = new AnnotationConfiguration().configure();
		SessionFactory sessionFactory = cfg.buildSessionFactory();
		Session session = sessionFactory.openSession();
		
		//使用事务存储  关闭资源
		session.beginTransaction();
		
		session.save(o);
			
		session.getTransaction().commit();
		session.close();
		sessionFactory.close();
}

//数据库获取树形结构
public class Load {

		//得到hibernate连接
		//Configuration cfg = new Configuration().configure();
		Configuration cfg = new AnnotationConfiguration().configure();
		SessionFactory sessionFactory = cfg.buildSessionFactory();
		Session session = sessionFactory.openSession();
		
		//使用事务存储  关闭资源
		session.beginTransaction();

		Org o =(Org)session.load(Org.class, 1);
		print(o,0);
		
		session.getTransaction().commit();
		session.close();
		sessionFactory.close();
	}

	//递归打印
	private static void print(Org o,int level) {
		String preStr = "";
		for(int i=0;i<level;i++){
			preStr += "----";
		}
		System.out.println(preStr + o.getName());
		for(Org child : o.getChilds()){
			print(child,level+1);
		}
}

HQL

		//查询对象
		Query q = session.createQuery("from Cat");
		
		//年龄大于5
		Query q = session.createQuery("from Cat c where c.age > '5'");
		
		//名字排序
		Query q = session.createQuery("from Cat c order by c.name desc");
		
		//对象不重复
		Query q = session.createQuery("select distinct c from Cat c order by c.name desc");
		
		//设置属性
		Query q = session.createQuery("from Cat c where c.id > :min and c.id < :max");
		q.setParameter("min", 2);
		q.setParameter("max", 2);
		
		//查询属性   返回List集合里数组
		Query q = session.createQuery("select c.id,c.name from Cat c order by c.name desc");
		List<Object[]> categories = (List<Object[]>)q.list();
		for(Object[] o : categories){
			System.out.println(o[0] + "_" + o[1]);
		}
		
		//导航查询
		Query q = session.createQuery("from Cat c where c.mother.sister.id = 1");
		for(Object o : q.list()){
			Cat m = (Cat)o;
			System.out.println(m.getCont());
		}
		
		//连接查询
		Query q = session.createQuery("select t.title, c.name from Topic t join t.category c");
		for(Object o : q.list()){
			Object[] m = (Object[])o;
			System.out.println(m[0] + "-" + m[1]);
		}
		
		//uniqueResult  确定返回值是唯一结果时使用
		Long l = (Long)session.createQuery("select count(*) from Msg m").uniqueResult();
		
		//between
		Query q = session.createQuery("from Cat c where c.id between 3 and 5");
		
		//in
		Query q = session.createQuery("from Cat c where c.id in 3,4,5");
		
		//查询字段为空
		Query q = session.createQuery("from Cat c where c.name is empty");
		
		//模糊查询
		Query q = session.createQuery("from Cat c where c.name like '%猫'");
		
		//分组查询   (提示:group by里的条件必须出现在select里)
		Query q = session.createQuery("select c.name,count(*),c.type from Cat c group by c.type");
		
		//子查询
		Query q = session.createQuery("from Cat c where c.id < (select avg(t.id) from Topic t)");

		//修改
		Query q = session.createQuery("update Cat c set c.title = upper(c.title)");

return getSession().createQuery(
		"FROM Department d WHERE d.parent IS NULL")
		.list();
		
return getSession().createQuery(
		"FROM Department d WHERE d.parent IS NULL")
		.list();


Hibernate细节说明：

hibernate.cfg.xml 
<property name="hbm2ddl.auto">update</property>
表结构发生变化会改变表，id重复数据会自增id添加数据 
<property name="hbm2ddl.auto">create</property>
若表不存在会自动创建表,id重复数据会报错
id生成策略：
native 交给数据库管理 （跨数据库平台）
identity： 自增
uuid: 生成32位字节码  理论不重复 （跨数据库平台） 

@ManyToMany(cascade={CascadeType.ALL})
ALL: 全部级联
PERSIST: 存储时级联
REMOVE: 删除时级联

排序 
	@OrderBy("name ASC")
	public List<Teacher> getTeachers() {
		return teachers;
	}

树状映射 
	//级联所有增删改        双向关联必须交给一方管理       拿到父亲所有孩子一起拿出
	@OneToMany(cascade=CascadeType.ALL,mappedBy="parent",fetch=FetchType.EAGER)

yongdami
关注
专栏目录
Hibernate入门第一讲——Hibernate框架的快速入门
李阿昀的博客
08-04 12万+
Hibernate框架介绍什么是Hibernate我们可以从度娘上摘抄这样有关Hibernate的介绍： Hibernate是一个开放源代码的对象关系映射框架，它对JDBC进行了非常轻量级的对象封装，它将POJO与数据库表建立映射关系，是一个全自动的orm框架，hibernate可以自动生成SQL语句，自动执行，使得Java程序员可以随心所欲的使用对象编程思维来操纵数据库。Hibernate可以
Hibernate入门第三讲——Hibernate的常见配置
热门推荐
李阿昀的博客
08-05 1万+
在《Hibernate快速入门》一文中，我有讲到Hibernate的两个配置文件，今天就来详细地介绍这两个配置文件。Hibernate的配置详解在Hibernate中，我们使用时主要有两种配置文件： 核心配置文件——hibernate.cfg.xml(主要描述Hibernate的相关配置) 映射配置文件——xxx.hbm.xml 核心配置文件Hibernate的核心配置文件，即hibernate.c
Hibernate基本使用
qq_45429856的博客
04-13 5894
SpringBoot整合Hibernate
忆晨的博客
03-22 1万+
Hibernate是什么？ Hibernate与MyBatis都是流行的持久层开发框架，只不过Hibernate是全自动ORM框架，不需要关心sql编写。 Hibernate 是一个高性能的对象/关系映射（ORM）持久化存储和查询的服务，不仅负责从Java类到数据库表的映射 （还包括从Java数据类型到SQL数据类型的映射），还提供了面向对象的数据查询检索机制，从而极大地缩短了手动处理SQL和JDBC上的开发时间。 同时，Hibernate还实现了JPA规范，在SpringBoot中，JPA的默认实现就是使
hibernate
qq_43501462的博客
10-18 8872
hibernate入门和基本操作
hibernate简介
Lxn2zh的博客
03-11 5278
第一章 hibernate简介原文链接 https://zhhll.icu/2020/框架/hibernate/基础/1.hibernate简介/ORM(Object Relation Mapping)对象关系映射思想：将关系数据库中表中的记录映射为对象，以对象的形式展现，可以把对数据库的操作转化为对对象的操作。采用元数据来描述对象-关系映射细节，元数据通常采用XML格式，存放在专门的对象-关系映射文件中。hibernate是一个老牌的ORM框架，通过hbm.xml映射文件维护Java和数据库表之间的关
hibernate入门，springboot整合hibernate
沐雨橙风ιε的博客
07-19 5636
Mybatis和Hibernate是我们常用的两大ORM框架，这篇文章主要介绍hibernate的使用，如何通过springboot整合hibernate，实现简单的crud功能。
hibernate 的缓存机制
weixin_59705658的博客
03-30 2150
Hibernate 缓存分为两层：Hibernate 的一级缓存和 Hibernate 二级缓存。 1.Hibernate 一级缓存（Session 的缓存）： （1）Session 实现了第一级 Cache，属于事务级数据缓冲。一旦事务结束，缓存随之失效。一个 Session 的生命周期 对应一个数据库事务或一个程序事务。 （2）Session-Cache 总是被打开并且不能被关闭的。 （3）Session-Cache 保证一个 Session 中两次请求同一个对象时，取得的对象是同一个 Java
hibernate约束
qq_32600929的博客
01-05 2301
hibernate.cfg.xml <!DOCTYPE hibernate-configuration PUBLIC "-//Hibernate/Hibernate Configuration DTD 3.0//EN" "http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd"> com.mysql.jdbc.Dr
最新版本的Struts2+Spring4+Hibernate4框架整合
10-15
项目原型：Struts2.3.16 + Spring4.1.1 + Hibernate4.3.6 二、 项目目的： 整合使用最新版本的三大框架（即Struts2、Spring4和Hibernate4），搭建项目架构原型。 项目架构原型：Struts2.3.16 + Spring4.1.1 + ...
达梦数据库java驱动包、hibernate方言包
11-15
/*************************************** * 达梦8 JDBC驱动版本说明 /*************************************** ...8. DmDialect-for-hibernate5.3.jar 对应 Jdk1.7及以上, hibernate5.3 -- 5.4 环境
hibernate-jpa-2.1-api-1.0.2.Final-API文档-中文版.zip
06-25
赠送jar包：hibernate-jpa-2.1-api-1.0.2.Final.jar； 赠送原API文档：hibernate-jpa-2.1-api-1.0.2.Final-javadoc.jar； 赠送源代码：hibernate-jpa-2.1-api-1.0.2.Final-sources.jar； 赠送Maven依赖信息文件：...
CPPC++_低成本实现Wooting键盘的Rapid trigger功能不必为几个按键购买整个键盘人人都能做Wouo.zip
11-12
CPPC++_低成本实现Wooting键盘的Rapid trigger功能不必为几个按键购买整个键盘人人都能做Wouo
CPPC++_可能是世界上最快的协同程序库.zip
11-12
CPPC++_可能是世界上最快的协同程序库
ConsulHelper，.Net微服务基础框架，已支持.NetCore，具备服务发现、健康检查、服务分级、分布式配置.zip
最新发布
11-12
ConsulHelper，.Net微服务基础框架，已支持.NetCore，具备服务发现、健康检查、服务分级、分布式配置、版本控制
各种三维模型（gltf，glb格式）
11-12
有卫星、警车、消防车、Cesium飞机、Cesium无人机等等。具体图片如下文章：https://blog.csdn.net/weixin_44857463/article/details/143721670?sharetype=blogdetail&sharerId=143721670&sharerefer=PC&sharesource=weixin_44857463&spm=1011.2480.3001.8118
Hibernate 实战指南
"Hibernate in Action" 《Hibernate in Action》是一本由Christian Bauer和Gavin King合著的经典书籍，专注于介绍Hibernate框架。Hibernate是一个流行的开源对象关系映射（ORM）工具，它简化了Java开发者与数据库...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值