hibernate 操作

最新推荐文章于 2020-02-15 13:54:01 发布
最新推荐文章于 2020-02-15 13:54:01 发布
阅读量995 收藏
点赞数
分类专栏： JAVA开发工具 文章标签： hibernate list session query null user
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xdy3008/article/details/1448233
版权

 hibernate的各种操作：

hibernate各种操作：
package Test;

import java.util.Iterator;
import java.util.List;

import org.hibernate.Criteria;
import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;
import org.hibernate.criterion.Expression;
import org.hibernate.metadata.ClassMetadata;

import Hibernate.HibernateSessionFactory;
import Hibernate.User;
import Hibernate.UserDAO;

public class TestHibernate {

 /**
  * @param args
  */
 public static void main(String[] args) {
  // TODO Auto-generated method stub
  
  Session session=HibernateSessionFactory.getSession();
  Transaction trans=session.beginTransaction();
  UserDAO dao=new UserDAO();
  
//  //通过load方法查询出id指定的某个记录
//  User user=new User();
//  session.load(user, new Integer(1));
//  System.out.println(user.getUserName()+"---"+user.getPassword());
//  trans.commit();
//  session.close();
  
  //通过DAO查询出id指定的某个记录
//  User user=new User();
//  user=dao.findById(1);
//  System.out.println(user.getUserName()+"---"+user.getPassword());
  
  //通过DAO根据某个属性及值查询记录集合
//  User user=new User();
//  user=(User) dao.findByProperty("password", "root").get(0);
//  System.out.println(user.getUserName()+"---"+user.getPassword());
  
  //通过DAO根据某个实例来查询记录集合
//  User user=new User();
//  user.setId(1);
//  user=(User)dao.findByExample(user).get(0);
//  System.out.println(user.getUserName()+"---"+user.getPassword());
  
  //通过get方法来查询出id指定的某个记录
//  User user=new User();
//  user=(User)session.get(User.class, new Integer(1));
//  System.out.println(user.getUserName()+"---"+user.getPassword());
//  trans.commit();
//  session.close();
  
  //通过Query来查询所有记录:Query.list() 获得集合
//  User user=new User();
//  Query query=session.createQuery("from User as obj");
//  List list=query.list();
//  for(int i=0;i<list.size();i++){
//   user=(User)list.get(i);
//   System.out.println(user.getUserName()+"---"+user.getPassword());
//  }
//  trans.commit();
//  session.close();
  
  
  //通过Query来查询where条件记录:Query.iterator() 获得集合
//  User user=new User();
  Query query=session.createQuery("from User as obj where obj.password=?");
  query.setString(0, "root");
//  Query query=session.createQuery("from User as obj where obj.password=:pass");
//  query.setString("pass", "root");
//  for(Iterator it=query.iterate();it.hasNext();){
//   user=(User)it.next();
//   System.out.println(user.getUserName()+"---"+user.getPassword());
//  }
//  trans.commit();
//  session.close();
  
  //根据SQL语句查询(session.createSQLQuery("sql语句").addEntity("table别名","实体类")  )
  User user=new User();
  //query0,query1无限制条件查询所有但是效果相同 ，query2 附带条件查询，并且设置条件
  Query query0=session.createSQLQuery("select obj.* from User as obj").addEntity("obj", User.class); 
  Query query1=session.createSQLQuery("select * from User").addEntity(User.class); 
  Query query2 =session.createSQLQuery("select obj.* from User as obj where id=? and password=?").addEntity("obj", User.class);
  query2.setInteger(0, 1);
  query2.setString(1, "xdy");
  List list=query2.list();
  for(int i=0;i<list.size();i++){
   user=(User)list.get(i);
   System.out.println(user.getUserName()+"---"+user.getPassword());
  }
  trans.commit();
  session.close();
  
  //Criteria查询
//  User user=new User();
//  Criteria criteria=session.createCriteria(User.class);
//  criteria.add(Expression.eq("password","root"));
//  List list=criteria.list();
//  for(int i=0;i<list.size();i++){
//   user=(User)list.get(i);
//   System.out.println(user.getUserName()+"---"+user.getPassword());
//  }
//  trans.commit();
//  session.close();
  
  
  //持久化类的元数据
//  Configuration cfg=new Configuration();
//  cfg.configure();
//  SessionFactory sf=cfg.buildSessionFactory();
//  Session ss=sf.openSession();
//  ClassMetadata metadata=sf.getClassMetadata(User.class);
//  String[] names=metadata.getPropertyNames();
//  
//  User user=new User();
//  Query query=ss.createQuery("from User as obj");
//  List list=query.list();
//  for(int i=0;i<list.size();i++){
//   user=(User)list.get(i);
//   System.out.println(names[0]+":"+user.getUserName()+"---"+names[1]+":"+user.getPassword());
//  }
//  trans.commit();
//  session.close();
 }

}

--------------------------------------------------------------------

public class DbOperate {

 /**
  * 根据用户名得到Blog对象
  */
 public Blog getBlog(String userId) throws HibernateException {
  Session session = HibernateUtil.currentSession();
  Blog blog = null;
  Transaction tx = null;
  try {
   tx = session.beginTransaction();
//   创建查询对象
   Query query = session.createQuery("from Blog where username=:userId");
   query.setParameter("userId", userId);
   List list = query.list();
   if (!list.isEmpty())
    blog = (Blog) list.get(0);
   tx.commit();
  } catch (HibernateException e) {
   if (tx != null)
    tx.rollback();
   throw e;
  }
  session.close();
  return blog;
 }

 /**
  * 根据ID得到Blog对象
  */
 public Blog getBlog(int Id) throws HibernateException {
  Session session = HibernateUtil.currentSession();
  Blog blog = null;
  Transaction tx = null;
  try {
   tx = session.beginTransaction();
//   创建查询对象
   Query query = session.createQuery("from Blog where id=" + Id);
   List list = query.list();
   if (!list.isEmpty())
    blog = (Blog) list.get(0);
   tx.commit();
  } catch (HibernateException e) {
   if (tx != null)
    tx.rollback();
   throw e;
  }
  session.close();
  return blog;
 }


 /**
  * 得到热点Blog对象集
  */
 public List getBlogs(int showCount) throws HibernateException {
  Session session = HibernateUtil.currentSession();
  List list=null;
  Transaction tx = null;
  try {
   tx = session.beginTransaction();
//   创建查询对象
   Query query = session.createQuery("from Blog order by visitcount desc");
   if (showCount>0){
    query.setMaxResults(showCount);        //记录集最大个数
   }
   list = query.list(); //从数据库取出数据，并自动封装到List集合中
   tx.commit();
  } catch (HibernateException e) {
   if (tx != null)
    tx.rollback();
   throw e;
  }
  HibernateUtil.closeSession();
  return list;
 }

 /**
  * 得到匹配Blog对象集
  */
 public List getMatchBlogs(String key) throws HibernateException {
  Session session = HibernateUtil.currentSession();
  List list=null;
  Transaction tx = null;
  try {
   tx = session.beginTransaction();
//   创建查询对象
   Query query = session.createQuery("from Blog where subject like '%" + key + "%'");
   list = query.list(); //从数据库取出数据，并自动封装到List集合中
   tx.commit();
  } catch (HibernateException e) {
   if (tx != null)
    tx.rollback();
   throw e;
  }
  HibernateUtil.closeSession();
  return list;
 }

 /**
  * 根据ID得到Sort对象
  */
 public Sort getSort(int Id) throws HibernateException {
  Session session = HibernateUtil.currentSession();
  Sort sort = null;
  Transaction tx = null;
  try {
   tx = session.beginTransaction();
//   创建查询对象
   Query query = session.createQuery("from Sort where id=" + Id);
   List list = query.list();
   if (!list.isEmpty())
    sort = (Sort) list.get(0);
   tx.commit();
  } catch (HibernateException e) {
   if (tx != null)
    tx.rollback();
   throw e;
  }
  session.close();
  return sort;
 }

 /**
  * 根据ID得到Links对象
  */
 public Links getLink(int Id) throws HibernateException {
  Session session = HibernateUtil.currentSession();
  Links link = null;
  Transaction tx = null;
  try {
   tx = session.beginTransaction();
//   创建查询对象
   Query query = session.createQuery("from Links where id=" + Id);
   List list = query.list();
   if (!list.isEmpty())
    link = (Links) list.get(0);
   tx.commit();
  } catch (HibernateException e) {
   if (tx != null)
    tx.rollback();
   throw e;
  }
  session.close();
  return link;
 }

 /**
  * 得到指定文章对象
  */
 public Article getArticle(int articleid) throws HibernateException {
  Session session = HibernateUtil.currentSession();
  Article article = null;
  Transaction tx = null;
  try {
   tx = session.beginTransaction();
  // 创建查询对象
   Query query = session.createQuery("from Article where id=" + articleid);
   List list = query.list();
   if (!list.isEmpty())
    article = (Article) list.get(0);
   tx.commit();
  } catch (HibernateException e) {
   if (tx != null)
    tx.rollback();
   throw e;
  }
  session.close();
  return article;
 }

 /**
  * 得到匹配Article对象集
  */
 public List getMatchArticles(String key) throws HibernateException {
  Session session = HibernateUtil.currentSession();
  List list=null;
  Transaction tx = null;
  try {
   tx = session.beginTransaction();
//   创建查询对象
   Query query = session.createQuery("from Article where title like '%" + key + "%'");
   list = query.list(); //从数据库取出数据，并自动封装到List集合中
   tx.commit();
  } catch (HibernateException e) {
   if (tx != null)
    tx.rollback();
   throw e;
  }
  HibernateUtil.closeSession();
  return list;
 }

 /**
  * 得到最新文章对象集
  */
 public List getArticles(int showCount) throws HibernateException {
  Session session = HibernateUtil.currentSession();
  List list=null;
  Transaction tx = null;
  try {
   tx = session.beginTransaction();
//   创建查询对象
   Query query = session.createQuery("from Article order by pubtime desc");
   if (showCount>0){
    query.setMaxResults(showCount);        //记录集最大个数
   }
   list = query.list(); //从数据库取出数据，并自动封装到List集合中
   tx.commit();
  } catch (HibernateException e) {
   if (tx != null)
    tx.rollback();
   throw e;
  }
  HibernateUtil.closeSession();
  return list;
 }

 /**
  * 得到指定博客最新文章对象集
  */
 public List getBlogArticles(int blogid,int sortid) throws HibernateException {
  Session session = HibernateUtil.currentSession();
  List list=null;
  Transaction tx = null;
  try {
   tx = session.beginTransaction();
//   创建查询对象
   String strSql = "from Article  where blogid=" + blogid;//创建一个查询语句,查询指定类别产品;
   if (sortid>0){
    strSql = strSql + " and sortid=" + sortid ;        //记录集最大个数
   }
   strSql = strSql + " order by pubtime desc" ;        //记录集最大个数
   Query query = session.createQuery(strSql);
   list = query.list(); //从数据库取出数据，并自动封装到List集合中
   tx.commit();
  } catch (HibernateException e) {
   if (tx != null)
    tx.rollback();
   throw e;
  }
  HibernateUtil.closeSession();
  return list;
 }

 /**
  * 得到指定博客文章分类对象集
  */
 public List getBlogSorts(int blogid) throws HibernateException {
  Session session = HibernateUtil.currentSession();
  List list=null;
  Transaction tx = null;
  try {
   tx = session.beginTransaction();
//   创建查询对象
   String strSql = "from Sort where blogid=" + blogid;//创建一个查询语句,查询指定类别产品;
   Query query = session.createQuery(strSql);
   list = query.list(); //从数据库取出数据，并自动封装到List集合中
   tx.commit();
  } catch (HibernateException e) {
   if (tx != null)
    tx.rollback();
   throw e;
  }
  HibernateUtil.closeSession();
  return list;
 }

 /**
  * 得到指定博客超级链接对象集
  */
 public List getBlogLinks(int blogid) throws HibernateException {
  Session session = HibernateUtil.currentSession();
  List list=null;
  Transaction tx = null;
  try {
   tx = session.beginTransaction();
//   创建查询对象
   String strSql = "from Links where blogid=" + blogid;//创建一个查询语句,查询指定类别产品;
   Query query = session.createQuery(strSql);
   list = query.list(); //从数据库取出数据，并自动封装到List集合中
   tx.commit();
  } catch (HibernateException e) {
   if (tx != null)
    tx.rollback();
   throw e;
  }
  HibernateUtil.closeSession();
  return list;
 }

 /**
  * 得到指定文章回复对象集
  */
 public List getFeedBacks(int articleid) throws HibernateException {
  Session session = HibernateUtil.currentSession();
  List list=null;
  Transaction tx = null;
  try {
   tx = session.beginTransaction();
//   创建查询对象
   String strSql = "from FeedBack  where articleid=" + articleid
      + " order by pubtime desc" ;     //创建一个查询语句,查询指定类别产品;   
   Query query = session.createQuery(strSql);
   list = query.list(); //从数据库取出数据，并自动封装到List集合中
   tx.commit();
  } catch (HibernateException e) {
   if (tx != null)
    tx.rollback();
   throw e;
  }
  HibernateUtil.closeSession();
  return list;
 }

 /**
  * 插入实体对象所对应的记录
  */
 public void save(Object obj) throws HibernateException {
  Session session = HibernateUtil.currentSession();
  if (obj != null) {
   Transaction tx = null;
   try {
    tx = session.beginTransaction();
    session.save(obj);
    tx.commit();
   } catch (HibernateException e) {
    if (tx != null)
      tx.rollback();
    throw e;
   }
  }
  session.close();
 }

 /**
  * 修改实体对象所对应的记录
  */
 public void update(Object obj) throws HibernateException {
  Session session = HibernateUtil.currentSession();
  
  if (obj != null) {
   Transaction tx = null;
   try {
    tx = session.beginTransaction();
    session.update(obj);
    tx.commit();
   } catch (HibernateException e) {
    if (tx != null)
      tx.rollback();
    throw e;
   }
  }
  session.close();
 }
 
 /**
  * 删除对象所对应的记录
  */
 public void delete(Object obj) throws HibernateException {
  Session session = HibernateUtil.currentSession();
  if (obj != null) {
   Transaction tx = null;
   try {
    tx = session.beginTransaction();
    session.delete(obj);
    tx.commit();
   } catch (HibernateException e) {
    if (tx != null)
      tx.rollback();
    throw e;
   }
  }
  session.close();
 }
} 

xdy3008
关注
专栏目录
hibernate操作
11-05
hibernate操作全面配置讲解 让你知道如何使用myeclipse来配置一个hibernate的项目。
Java封装hibernate操作数据库.rar
03-25
本资料包"Java封装hibernate操作数据库.rar"主要涉及了如何使用Hibernate进行数据库操作，并通过DAO(Data Access Object)层的封装来实现更加高效、简洁的代码结构。 首先，让我们深入了解Hibernate。Hibernate是一...
hibernate入门和基本操作
指尖上的飞舞
04-17 622
什么是框架、什么是hibernate框架、什么是orm思想、搭建hibernate环境、Hibernate配置文件详解、hibernate核心api、解决配置文件没有提示问题
Hibernate入门和基本操作
dawn_1108的博客
02-15 570
文章目录1 Hibernate概述1.1 框架的含义1.2 Hibernate框架1.3 orm思想2 Hibernate入门2.1 环境搭建2.1.1 导jar包2.1.2 创建实体类2.1.3 使用配置文件实现映射关系2.1.4 创建hibernate的核心配置文件2.2 功能实现2.3 Hibernate核心api介绍2.3.1 Configuration2.3.2 SessionFacto...
Hibernate 操作
五月天的博客
06-26 92
List&lt;Object[]&gt; list = null; Session session = this.getHibernateTemplate().getSessionFactory().openSession(); try { list = session.createSQLQuery(sql).list(); fo...
Hibernate操作数据库
08-04
**标题：“Hibernate操作数据库”** Hibernate 是一个强大的Java对象关系映射（ORM）框架，它为开发者提供了在Java应用程序中操作数据库的强大工具。通过使用Hibernate，开发者可以避免编写大量的SQL语句，而是专注...
java使用hibernate操作数据库jar
07-25
Java使用Hibernate操作数据库是现代Java应用中常见的技术实践，Hibernate作为一个强大的对象关系映射（ORM）框架，极大地简化了数据库的交互。它允许开发者用Java对象来表示数据库中的记录，而无需关心底层SQL的实现...
Hibernate操作持久化对象
11-15
Hibernate 操作持久化对象是Java开发中用于简化数据库交互的重要工具。它是一个开源的Java持久化框架，由Gavin King创建，并逐渐发展成为Java世界中主流的持久化解决方案。Hibernate的核心在于提供对象-关系映射(ORM...
Hibernate操作视频
09-23
【Hibernate操作视频】系列教程是针对Java开发人员深入学习Hibernate框架的重要资源。Hibernate是一个开源的对象关系映射（ORM）框架，它简化了数据库与Java对象之间的交互，使得开发者可以更专注于业务逻辑，而不是...
菜鸟学习Hibernate——简单的增、删、改、查操作
weixin_30878361的博客
04-27 454
上篇博客利用Hibernate搭建起一个简单的例子，把数据库的映射显示了出来在上一篇的博客基础上这篇博客讲述如何利用Hinbernate框架实现简单的数据库操作。 1、加入junit.jar 2、新建一个工具类HibernateUtils.Java把一些对session的公共操作封装起来 import org.hibernate.Session; import or...
hibernate基本操作
lijunaccp的专栏
10-29 88
1．准备条件： 1.1 创建hibernate2工程 1.2 导入hibernate包 1.3 创建hibernate2数据库，以及customers表 2. Customers.java [code="java"] package com.hibernate2.bean; import java.sql.Date; import java.sql.Timestamp; ...
Hibernate操作（二）
凝望星空
06-17 122
一，java对象的三种状态 （1）瞬时状态 瞬时状态又称临时状态，当数据库中的数据不予对象关联时，这时对象就处在瞬时状态。临时状态的代码是不受Session管理的，也没有关联的。当java垃圾处理回收器运行时，如果瞬时状态的对象没有引用将被回收。 （2）持久状态 与数据库中数据有关联就是持久状态。持久状态下的代码时守Session管理和跟踪的。 （3）游离状态 脱离持久状态（脱离Ses...
Hibernate操作记录
weixin_42410730的博客
02-15 301
在线API文档 http://tool.oschina.net/apidocs/apidoc?api=hibernate-4.1.4 hibernate的hql查询语句总结 https://www.cnblogs.com/xiaoluo501395377/p/3376256.html
Hibernate基础操作
szuhuanggang的博客
10-17 163
/* * 插入数据 */ session.save(new Event("hello hg",new Date())); /* * 获取数据 * get:如果没有，返回null * load:如果没有，抛出异常 * find:？类似get */ Event e = session.get(Event.class, 1); System.out.println(e); ...
hibernate（二）基本操作
暖阳阳
06-15 343
一、hibernate CURD基本操作 package com.itheima.test; import java.util.List; import org.hibernate.Query; import org.hibernate.Session; import org.hibernate.Transaction; import org.junit.Test; import com....
Hibernate使用
zaifendou的专栏
10-09 4343
---------------Hibernate3.0 配置--------------1.Hibernate中配置参数/*** 注意：HQL中使用参数的方法：* 1.根据参数名称来设置参数：匹配名称；* 2.根据参数位置来设置参数：匹配位置；*///根据参数名称来设置参数Query query = session.createQuery("from UserManager u where u.u
【Hibernate】数据操作
LFSenior
05-19 3366
Hibernate数据操作： 1、更新： session.save(obj);   保存一个对象 session.update(emp);  更新一个对象 session.saveOrUpdate(emp);  保存或者更新的方法： à没有设置主键，执行保存； à有设置主键，执行更新操作; à如果设置主键不存在报错！   2、主键查询： session.get(Employ
hibernate 操作sqlite
最新发布
11-23
Hibernate是一个开源的对象关系映射框架，它简化了Java应用程序与数据库之间的交互。它提供了一种简单的方式来映射Java对象和关系数据库表，使得开发人员能够通过面向对象的方式来操作数据库。 要使用Hibernate操作SQLite数据库，首先需要引入相应的依赖和配置。在项目中增加SQLite的驱动，然后配置Hibernate的数据源和持久化单元。接着通过Hibernate的API来创建数据库表和操作数据，例如增加、删除、更新和查询。 在配置Hibernate时，需要指定SQLite的数据库连接URL、用户名、密码等信息。同时，需要定义实体类与数据库表的映射关系，包括字段名、类型、主键等信息。 在实际操作中，可以使用Hibernate提供的Session来进行数据库操作。通过Session可以进行数据库的增删改查操作，同时还可以使用Hibernate的HQL（Hibernate Query Language）来进行复杂的查询，并且能够实现事务管理。 在与SQLite数据库交互时，需要注意SQLite的一些特性，例如它是一个轻量级的数据库，不支持多用户并发访问，需要注意事务的使用和性能的优化。 总的来说，使用Hibernate操作SQLite数据库可以简化开发人员的工作，提高开发效率，同时还能够利用Hibernate强大的功能来实现对数据库的操作和管理。通过合理的配置和使用，可以使得Java应用程序与SQLite数据库的交互更加简洁和高效。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值