用hibernate作查询

最新推荐文章于 2022-11-21 21:00:03 发布
最新推荐文章于 2022-11-21 21:00:03 发布
阅读量182 收藏
点赞数 1
分类专栏： hibernate
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43988251/article/details/106325811
版权

hibernate5版本测试

1 Session接口

几个常用的方法

  1. save , persist 保存数据 persist在事务外不会产生insert语句(不会进行提交)
    而save就算不处理事务也能提交 (hibernate5是这样的,在session关闭后会提交)

  2. delete 删除对象

  3. update 更新对象

  4. get 查询对象(根据ID),会立即访问数据库

  5. load 查询对象(根据ID), 返回的是代理对象,不会立即访问数据库,懒加载

  6. saveOrUpdate 保存或更新(在目前的测试中对象没有id就是保存，有id就是修改), merge (调用merge以后,对象是脱管的)

  7. lock 把对象变成持久对象,但不会同步对象的状态

  //例子 get 和load的不同之处
public static void main(String[] args) {
	AdminInfo admin =getAdmin(1);
	System.out.println(admin);  // could not initialize proxy [com.beans.AdminInfo#1] - no Session
}

public static AdminInfo  getAdmin(int id) {
	try {
		Session s=HibUtil.getSession();
		AdminInfo admin=s.load(AdminInfo.class, id);
//		Hibernate.initialize(admin);  //让它去把代理对象对应的数据查出来Hibernate.initialize(admin);  //让它去把代理对象对应的数据查出来
		return admin;
		
	}finally {
		HibUtil.closeSession();
	}
}


load方法,返回的是代理对象(并不是直的立即去查询数据库),如果在session之外再用到这个查询出来的对象,由于
没有了session,这个代理对象不能再进行数据库连接查询,所以出错

2 对象状态

–瞬时 (transien): 数据库中没有数据与之对应,超过作用域就会失效,就会被垃圾回收器回收,
通常,刚new出来的对象,处于这样的状态, 与Session无关

–持久 (persistent): 数据库中有数据与之对应,与session相关联,而且session没有关闭,事务没有提交
持久态的对象,如果内容发生改变,在事务提交后,会反映到数据库端

–脱管 (detached): 数据库有数据与之对应,但没有session与之相关,脱管对象的改变,不会影响到数据库

static void save() {
	AdminInfo admin=new AdminInfo();
	admin.setAdminName("rootabc");
	admin.setPassword("123");   //这时对象处理 瞬时 态
				
	Session s =HibUtil.getSession();
	Transaction tx=s.beginTransaction();
	
	s.persist(admin);  //对象处理 持久 态
	
	admin.setAdminName("李婧");
	admin.setNote("这是备注");
	
	tx.commit();
	HibUtil.closeSession();
	
	admin.setAdminName("lastname");  //对象处理脱管 态
}

     最后的结果是:	 李婧   123  这是备注

3,HQL语句查询

在5版本以后 用query.Query这个包 这个query带泛型

public AdminInfo login(String adminName,String passsword) {
	try {
		Session s=HibUtil.getSession();
		String hql="from AdminInfo where adminName=?1 and password =?2 ";  
		Query <AdminInfo>q =s.createQuery(hql,AdminInfo.class);
		
		q.setParameter(1, adminName);
		q.setParameter(2, passsword);
		
		AdminInfo admin=q.uniqueResult();
		return admin;

		
	} finally  {
		HibUtil.closeSession();
	}	


}

hql:

  1. //select * 不用写
  2. //from后面跟的是类名不能是表名
  3. //后面的字段也是类中的属性名,不是表中字段名
  4. //adminName=?1 and password =?2 "; ? 后面要加上1, 2 这个标志 (JAP规范)
  5. //q.setParameter(1, adminName); //前面的1 或2 等要和上面的标志对上
  6. //q.setParameter(2, passsword);实测发现,如果上面写成 0, 1 下面也可以按 0, 1 去查询
  7. uniqueResult 这个方法,当查不到数据的时候,得到的null 如果查出来的数据,多于一条,则出异常 query did not return a unique result: 2
  8. AdminInfo admin =q.getSingleResult(); 也可以用这个方法查询,当结果多于一条的时候,和上面的错误相同 ,如果没有查询到结果的时候 ,将出错 No entity found for query
  9. 对于hql 也可以用别名的方式传参
 String hql="from AdminInfo where adminName=:aname and password =:pwd ";   //select * 不用写  from后面跟的是类名不能是表名
Query <AdminInfo>q =s.createQuery(hql,AdminInfo.class);

q.setParameter("aname", adminName);
q.setParameter("pwd", passsword);

可以使用 setFirstResult 和 setMaxResults 进行结果集过滤,实现分页功能
public List<AdminInfo> getAdminList(int beginRow,int pageSize){
	try {
		Session s=HibUtil.getSession();
		String hql="from AdminInfo";  
		Query <AdminInfo>q =s.createQuery(hql,AdminInfo.class);

		q.setFirstResult(beginRow);
		q.setMaxResults(pageSize);
 //		return q.list();
		return q.getResultList();

	} finally  {
		HibUtil.closeSession();
	}	
}
							
public static void main(String[] args) {
		AdminDao dao=new AdminDao();
		
		List<AdminInfo > adminList=dao.getAdminList(2,3);
		
		for(AdminInfo a: adminList) {
			System.out.println(a);
		}
	}
								
								
 //查询数据条数
public int getAdminCount() {
	try {
		Session s=HibUtil.getSession();
		Query <Long>q=s.createQuery("select count(*) from AdminInfo",Long.class);  //后对是对象名
		return new Integer(q.uniqueResult()+"");
		
	} finally  {
		HibUtil.closeSession();
	}	
}


//删除
public void deleteByName() {
	try {
		Session s=HibUtil.getSession();
		Query <?>q=s.createQuery("delete from AdminInfo where adminName=?0");
		q.setParameter(0, "hibernate用户一"); 
		
		Transaction tx=s.beginTransaction();
		q.executeUpdate();
		tx.commit();
		
	} finally  {
		HibUtil.closeSession();
	}	
}				 

 其他的一些query写法	
// 使where 
	Query q=s.createQuery("from AdminInfo where id not between 10 and 20");
	  //查询id不在10 到20之间的
	
// 使用in 
  Query q=s.createQuery("from AdminInfo where AdminName in('张三','李四','王五')"); 
  //只要在这个('张三','李四','王五')集合中含有的,就查出来
  
// 使用 like 
	  Query q=s.createQuery("from AdminInfo where AdminName like %赵%");  
	    // 查询名字中含有赵的所有用户
	  
	// 使用 null 
		Query q=s.createQuery("from AdminInfo where note is null"); 	
		//查询所有备注为null的用户		
		
  // 使用 and 
  	Query q=s.createQuery("from AdminInfo where note is null and id<5");	
  	   //查询备注信息是null而且id<5的用户
  	
  // 执行删除
    Query q=s.createQuery("from AdminInfo where password is null");

3 Criteria接口

1 Criteria接口
	public AdminInfo getLoginAdmin(String name,String password) {
		try {
			Session s=HibUtil.getSession();
			Criteria c=s.createCriteria(AdminInfo.class);
			
			c.add(Restrictions.eq("adminName", name));
			c.add(Restrictions.eq("password", password));
			return (AdminInfo) c.uniqueResult();
			
		} finally  {
			HibUtil.closeSession();
		}	
	}
	
	public static void main(String[] args) {
		AdminDao dao=new AdminDao();
		
		AdminInfo admin=dao.getLoginAdmin("admin"	, "123");
		System.out.println(admin);
	

 在hibernate5中  s.createCriteria 这样的方式不推荐使用了
 推荐我们用 JPA CriteriaQuery

//查询所有,相当于select * from adminInfo
	public static void test01() {
		try {
			Session s=HibUtil.getSession();
			
			CriteriaBuilder builder= s.getCriteriaBuilder();
			
			//获取 CriteriaQuery对象
			CriteriaQuery <AdminInfo>createQuery= builder.createQuery(AdminInfo.class);
			
			//指定根条件
			createQuery.from(AdminInfo.class);
			
			//执行查询
			List<AdminInfo> adminList=s.createQuery(createQuery).list();
			
			for(AdminInfo a:adminList ) {
				System.out.println(a);
			}		
			
		} finally  {
			HibUtil.closeSession();
		}	
	}
	
	//多条件查询  select * from adminInfo where adminName=xxxx and id >1
	public static void test02() {
		try {
			Session s=HibUtil.getSession();
			
			CriteriaBuilder builder= s.getCriteriaBuilder();
			
			//获取 CriteriaQuery对象
			CriteriaQuery <AdminInfo>createQuery= builder.createQuery(AdminInfo.class);
			
			//指定根条件
			Root<AdminInfo> root =createQuery.from(AdminInfo.class);
			
			//创建两个查询条件
			Predicate p1= builder.equal(root.get("adminName"),"admin"); 
			Predicate p2 =builder.gt(root.get("id"),1);
			
			//将查询条件放到where方法中
			createQuery.where(p1,p2 );
			
			//执行查询
			List<AdminInfo> adminList=s.createQuery(createQuery).list();
			
			for(AdminInfo a:adminList ) {
				System.out.println(a);
			}		
			
		} finally  {
			HibUtil.closeSession();
		}	
	}
		
// 这个是带or 条件的 select  * from t where (adminName=admin and id>1) or (note=垃圾)
	public static void test03() {
		try {
			Session s=HibUtil.getSession();
			
			CriteriaBuilder builder= s.getCriteriaBuilder();
			
			//获取 CriteriaQuery对象
			CriteriaQuery <AdminInfo>createQuery= builder.createQuery(AdminInfo.class);
			
			//指定根条件
			Root<AdminInfo> root =createQuery.from(AdminInfo.class);
			
			//创建两个查询条件
			Predicate p1 =builder.equal(root.get("adminName"),"admin"); 
			Predicate p2 =builder.gt(root.get("id"),1);
			Predicate p3 =builder.equal(root.get("adminName"), "垃圾");
			
			//将查询条件放到where方法中
			createQuery.where( builder.or ( builder.and(p1,p2) ,  p3) );
			
			//执行查询
			List<AdminInfo> adminList=s.createQuery(createQuery).list();
			
			for(AdminInfo a:adminList ) {
				System.out.println(a);
			}		
			
		} finally  {
			HibUtil.closeSession();
		}	
	}
	
	
 //查询所有雇员，按id降序排序,名字升序排序
	 public static void test04() {
		   	 Session s=HibUtil.getSession();
		      CriteriaBuilder builder = s.getCriteriaBuilder();
	   		//1. 获取CriteriaQuery对象
	        CriteriaQuery<AdminInfo> criteria = criteriaBuilder.createQuery(AdminInfo.class);
	        //2. 指定根条件
	        Root<AdminInfo> root = criteria.from(AdminInfo.class);
	        //3. 设置orderBy的字段，可同时对多个字段进行排序
	        criteria.orderBy(builder.desc(root.get("id")), builder.asc(root.get("adminName")));
		    	//4. 执行查询并返回结果
	        List<AdminInfo> list =  s.createQuery(criteria).list();
	      
	        for (AdminInfo a : list) {
	            System.out.println(a);
	        }     
	        ....
	    }

	 //查询所有带分页的
	 public static void test05() {
		    	Session s=HibUtil.getSession();
		      CriteriaBuilder builder = s.getCriteriaBuilder();
		    
	    	  //1. 获取CriteriaQuery对象
	        CriteriaQuery<AdminInfo> criteria = builder.createQuery(AdminInfo.class);
	        //2. 指定根条件
	        Root<AdminInfo> root = criteria.from(AdminInfo.class);
	        //3. 设置orderBy的字段
	        criteria.orderBy(builder.desc(root.get("id")));

	        List<AdminInfo> list = s.createQuery(criteria).setFirstResult(0).setMaxResults(5).list();
	        
	        for (AdminInfo a : list) {
	            System.out.println(a);
	        }
	        ...
	   }

4 使用sql进行查询

 //例一
static List<AdminInfo> getAdminList(){
try {
	Session s=HibUtil.getSession();
	String sql="select * from adminInfo"; //注意,它就是以前我们用的sql语句,后面的 adminInfo 是表名
	
	/* 这是过去的写法,废弃了
	SQLQuery<AdminInfo> q=s.createSQLQuery(sql).addEntity(AdminInfo.class);
	q.list();
	*/
	
	NativeQuery<AdminInfo> q=   s.createNativeQuery(sql,AdminInfo.class);
	return q.list();

} finally {
	HibUtil.closeSession();
}
}

//例二
static List<AdminInfo> getAdminList2(){
try {
	Session s=HibUtil.getSession();
	String sql="select * from adminInfo where adminName=? and password=?" ; 
	   //这里可以用命名参数
	NativeQuery<AdminInfo> q=   s.createNativeQuery(sql,AdminInfo.class);
	q.setParameter(1, "admin");
	q.setParameter(2, "123");
	q.setFirstResult(0);
	q.setMaxResults(5);
	return q.getResultList();

} finally {
	HibUtil.closeSession();
}
}

//例三 关联查询
public static void main(String[] args) {
	 List<Object[]>  obljectList= getNiguList3();
	 
	 for(Object [] row:obljectList) {
		 for(Object filedValue:row) {
			 System.out.print(filedValue +"  ");
		 }
		 
		 System.out.println();
	 }
}

static List<Object[]> getNiguList3() {
	try {
		Session s=HibUtil.getSession();
		String sql="select a.id,a.fahao , b.name from nigu a left join niguan b on a.niguan_id=b.id";
		NativeQuery q=s.createSQLQuery(sql);
		return q.list();

	} finally {
		HibUtil.closeSession();
	}	
}

//例四 使用Dto进行数据传输
public static void main(String[] args) {
	 List<NiguDto> niguList=	getNiguList4();
	 for(NiguDto n:niguList) {
		 System.out.println(n.getId() +  " "  + n.getFahao()+ "  "  + n.getName() );
	 }
}

//使用Dto进行数据传输
static List<NiguDto> getNiguList4(){
	try {
		Session s=HibUtil.getSession();
		String sql="select a.id,a.fahao , b.name from nigu a left join niguan b on a.niguan_id=b.id";
		Query q=s.createSQLQuery(sql);
		q.setResultTransformer(Transformers.aliasToBean(NiguDto.class));  
		 //进行数据传输对象的处理
		return q.list();

	} finally {
		HibUtil.closeSession();
	}	
}

public class NiguDto  extends Nigu{	
	private String name; //关联到的其他的表中的数据

	public String getName() {
		return name;
	}

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

上面的设计还是比较符合正常人类的思维的,而且NiguDto 不需要配置映射文件
但TMD败家的hibernate5 ,居然把上面的一些API给废弃了

//例五  使用 session 的 doWork 的方式
static void test() {
	Work work = new Work() {
		public void execute(Connection connection) throws SQLException {
			PreparedStatement stm = connection.prepareStatement("select * from AdminInfo");
			ResultSet rs = stm.executeQuery();
			while (rs.next()) {
				System.out.print(rs.getInt("id") + " ");
				System.out.print(rs.getString("adminName") + " ");
				System.out.println(rs.getString("password"));
			}
		}
	};

	try {
		Session s = HibUtil.getSession();
		s.doWork(work);
	} finally {
		HibUtil.closeSession();
	}
}

//例 使用 doWork 的方式,有返回值的处理		
public static void main(String[] args) {
	List<AdminInfo>  list =getAdminlist5();
	for(AdminInfo a :list) {
		System.out.println(a);
	}
}



static List<AdminInfo> getAdminlist5(){
	List<AdminInfo> adminList=new ArrayList<AdminInfo>();
	Work work = new Work() {
		public void execute(Connection connection) throws SQLException {
			PreparedStatement stm = connection.prepareStatement("select * from AdminInfo");
			ResultSet rs = stm.executeQuery();
			while (rs.next()) {
				AdminInfo admin=new AdminInfo();
				admin.setId(rs.getInt("id"));
				admin.setAdminName(rs.getString("adminName"));
				admin.setPassword(admin.getPassword());
				admin.setNote(rs.getString("note"));
				adminList.add(admin);
			}
		}
	};

	try {
		Session s = HibUtil.getSession();
		s.doWork(work);
	} finally {
		HibUtil.closeSession();
	}
	
	return adminList;
}

附:多条件查询				
public static void main(String[] args) {
	List<AdminInfo>  list =getAdminList6("admin",null);
	for(AdminInfo a :list) {
		System.out.println(a);
	}
}

static List<AdminInfo> getAdminList6(String adminName,String password) {
	try {
		Session s = HibUtil.getSession();
		String hql="from AdminInfo where 1=1 ";
		if(adminName!=null) {
			hql+=" and adminName='"+adminName+"'" ;
		}
		if(password!=null) {
			hql+=" and password='"+password+"'" ;
		}
		Query<AdminInfo> q =s.createQuery(hql,AdminInfo.class);
		return q.getResultList();

	} finally {
		HibUtil.closeSession();
	}
}

标题 5 DetacheCriteria

//控制层
public class AdminController {
	public static void main(String[] args) {
		Scanner scan=new Scanner(System.in);
		
		System.out.println("输入账号");
		String adminName=scan.next();
		
		System.out.println("输入备注");
		String note=scan.next();
		
		DetachedCriteria dc=DetachedCriteria.forClass(AdminInfo.class);
		
		if(adminName!=null && !"".equals(adminName)) {
			dc.add(Restrictions.eq("adminName",adminName));
		}
		if(note!=null && !"".equals(note) )  {
			dc.add(Restrictions.eq("note",note));
		}
		
		List<AdminInfo> adminList=new AdminDao().searchAdmin(dc);
		for(AdminInfo a: adminList) {
			System.out.println(a);
		}
	}
}



	/**
	 * @param dc 离线的Criteria(离线指的就是它不和session 相关)
	 * @return
	 */
	public List<AdminInfo> searchAdmin(DetachedCriteria dc) {
		try {
			Session s=HibUtil.getSession();
			Criteria c=dc.getExecutableCriteria(s);
			
			return c.list();
			
		}finally  {
			HibUtil.closeSession();
		}	
	}
559Jiang
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Hibernate高级查询一
逍遥飞鹤的专栏
08-26 900
1.hibernate查询的6种方法。 分别是HQL查询，对象化查询Criteria方法，动态查询DetachedCriteria，例子查询，sql查询，命名查询。            如果单纯的使用hibernate查询数据库只需要懂其中的一项就可以完成想要实现的一般功能，但是 从一个点，让我们掌握6中方法，则提供了更多选择。每一种方法都有其适用的情况与前提。 HQL查询
java Hibernate ireport jsperreport 制作报表
02-21
上述示例没有涉及到分页处理，如果数据量较大，为了避免一次性加载所有数据导致性能问题，可以使用 Hibernate 的分页查询功能，然后在报表填充过程中逐步加载每一页数据。 6. **报表参数和样式** 在报表设计中，...
hibernate5 save后立即find_关于 Laravel ORM 对 Model::find 方法进行缓存
weixin_39679468的博客
12-25 226
前段时间做项目时候，想要在不改变方法签名的情况下，给 Model::find 方法做个缓存。而且想要做到即插即用。1.先看一下当我们调用 find 方法时，框架干了什么？找到 IlluminateDatabaseEloquentModel 的代码，搜索 find，没有该方法。看来是走了 __callStatic 这个魔术方法。该方法里只有一行代码：return (new static)->$...
hibernate 六种查询方法
diqinxiao3873的博客
02-01 152
hibernate查询的6种方法。分别是1.HQL查询，2.对象化查询Criteria方法，3.动态查询DetachedCriteria，4.例子查询，5.sql查询，6.命名查询 一.HQL查询(适用情况：常用方法，比较传统，类似jdbc。缺点：新的查询语言，适用面有限，仅适用于Hibernate框架) staticvoidquery(Strin...
hibernate的Save与persist
weixin_41298572的博客
03-06 420
save和persist方法 区别 save方法：瞬时态 转换 持久态 ,会初始化OID 1.执行save方法，立即触发insert语句，从数据库获得主键的值（OID值） 2.执行save方法前，设置OID将忽略。 3.如果执行查询，session缓存移除了，在执行save方法，将执行insert persist方法：瞬时态 转换 持久态 persist保存的对象，在保存前，不能设...
hibernate中的查询 hibernate笔记
洛阳泰山的博客
08-30 2904
根据id的查询（get或load方法） Session.find(hql)---------------Hibernate3之前 2、Hql(Hibernate Query Language)： 关系型数据库的表名换成类名-----列名换成成员变量的名字 如： Query q=session.createQuery(“from Customer c where c.name=:nameand c.age=:age”); q.setString(“name”,”aaa”);...
springMVC+spring+hibernate+jquery分页完整项目，完整代码
01-04
同时，Hibernate还支持HQL（Hibernate Query Language），提供更接近Java对象的查询方式。 4. jQuery：jQuery是一个轻量级的JavaScript库，简化了DOM操作、事件处理、动画制作以及Ajax交互。在本项目的前端部分，...
Hibernate
10-28
Hibernate允许开发者用面向对象的方式处理数据，而无需直接编写SQL语句，极大地提高了开发效率和代码的可维护性。 描述中并未给出具体信息，但我们可以理解为讨论的是Hibernate在Java开发中的核心概念和应用。 **...
Struts+Hibernate制作门户网站源码
11-09
Struts和Hibernate是两种在Java Web开发中广泛使用的开源框架，它们在构建门户网站时发挥着重要作用。Struts作为MVC（Model-View-Controller）框架，主要负责处理应用程序的业务逻辑和控制流程，而Hibernate则是一个...
一个小小的hibernate学习之作
03-24
总结来说，这篇关于Hibernate的学习之作将涵盖如何配置Hibernate，创建实体类，执行CRUD操作，以及如何使用HQL进行查询。通过实践，你可以更深入地理解和掌握Hibernate在实际开发中的运用，提高开发效率，减少与...
电商平台后台管理系统--环境搭建与管理员登录（一）
最新发布
LJAVAI的博客
11-21 1413
电商平台后台搭建
我的Spring bean问题：getBean后赋值再new一个对象去取值发现Spring赋值并没有存到Admin的问题
weixin_44086507的博客
11-14 333
代码如下： ApplicationContext ac = new ClassPathXmlApplicationContext(BEAN1); Admin admin = new Admin(); admin.setUserName("hello"); admin.getUserName(); Admin admin1 = (Admin) ac.getBean("admin"); admin1.setUserName("312323"); admin1.getUserName();
java 不推荐使用方法_java-Hibernate 5中不推荐使用的createCriteria方法
weixin_42353805的博客
02-24 351
我有以下方法，出于安全原因更改了对象名称：public List listAllForIds(List ids) {Criteria criteria = getSessionFactory().getCurrentSession().createCriteria(MyObject.class).createAlias("joinObject", "joinObject").add(Restric...
Hibernate3的DetachedCriteria支持
我的世界我的梦
01-16 1155
Hibernate3支持DetachedCriteria，这是一个非常有意义的特性！我们知道，在常规的Web编程中，有大量的动态条件查询，即用户在网页上面自由选择某些条件，程序根据用户的选择条件，动态生成SQL语句，进行查询。 　　针对这种需求，对于分层应用程序来说，Web层需要传递一个查询的条件列表给业务层对象，业务层对象获得这个条件列表之后，然后依次取出条件，构造查询语句。这里的一个难点是条件
hibernate查询的6种方法
cocolee100的专栏
05-13 717
<br />hibernate查询的6种方法。分别是HQL查询<br />，对象化查询Criteria方法，动态查询DetachedCriteria，例子查询，sql查询，命名查询。<br />           如果单纯的使用hibernate查询数据库只需要懂其中的一项就可以完成想要实现的一般功能，但是<br />从一个点，让我们掌握6中方法，则提供了更多选择。每一种方法都有其适用的情况与前提。<br />HQL查询<br />HQL是hibernate自己的一套查询语言，于SQL语法不同，具有跨数据
在Java的Hibernate框架中对数据库数据进行查询操作
热门推荐
F2Zf的博客
07-14 1万+
Hibernate查询语言（HQL）是一种面向对象的查询语言，类似于SQL，但不是对表和列操作，HQL适用于持久对象和它们的属性。 HQL查询由Hibernate转换成传统的SQL查询，这在圈上的数据库执行操作。 虽然可以直接使用SQL语句和Hibernate使用原生SQL，但建议使用HQL尽可能避免数据库可移植性的麻烦，并采取Hibernate的SQL生成和缓存策略的优势。 都像SELECT
Hibernate的一级缓存、二级缓存和查询缓存。
weixin_30364147的博客
02-25 177
Hibernate的Session提供了一级缓存的功能，默认总是有效的，当应用程序保存持久化实体、修改持久化实体时，Session并不会立即把这种改变提交到数据库，而是缓存在当前的Session中，除非显示调用了Session的flush()方法或通过close()方法关闭Session。通过一级缓存，可以减少程序与数据库的交互，从而提高数据库访问性能。SessionFactory级别的二级缓存...
Hibernate里面如何使用DetachedCriteriaCriteria 实现多条件分页查询
Troub_cy的博客
03-30 271
WEB层： // 获取分页的请求参数 String start = request.getParameter(“start”); String page = request.getParameter(“page”); String limit = request.getParameter(“limit”); //获取请求表单的值，然后根据值是否为空，构件离线查询条件。 String tb_zzid...
Hibernate createCriteria查询详解
Less Is More
08-06 2170
本文转载自 : http://penghao122.javaeye.com/blog/80794 1、创建一个Criteria实例 net.sf.hibernate.Criteria这个接口代表对一个特定的持久化类的查询。Session是用来制造Criteria实例的工厂。 Criteria crit = sess.createCriteria(Cat.class); crit.setM
Hibernate原理与应用——高级实作培训专家分享详解
懒加载、HQL和Criteria查询、缓存以及事务处理等内容是Hibernate使用中常见的功能和技术，通过学习这些内容，学员可以更加高效地使用Hibernate来开发应用程序。 此外，课程还介绍了Hibernate不适合的场景、最佳实践...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值