育才学习网hibernate中间表怎么写
1.hibernate如何操作中间表
举例说明：三张表 t_userseoles是中间表、其他的t_user和t_roleUsersRoles.hbm.xml
2.hibernate框架怎么查中间表
假设，现在关联关系 一个是UserEntity（用户），一个是DepartmentEntity（部门） 它们直接是多对多关系！
因为采取的是hibernate的注解 @JoinTable 。所以中间实体（Entity）就没有去建立。
解决办法如下：
SELECT dep_tab FROM DepartmentEntity dep_tab
left join dep_tab.userEntity user_tab
where user_tab.userId = 1
上面信息是通过UserID查询出该用户 所任职的岗位。DepartmentEntity 实体“.”当然也可以通过用户实体“.”出。因为本身是对对关系，就看查询所用到的条件了。
在上述查询的时候，切记不能写为 select * ，否则会报如下异常：
unexpected token: * near line 1,
hibernate查询怎么写
1. hibernate查询怎么能写得简洁
把重复的提取出来，封装成方法就行了。
像这样的一个简单的工具类：
public final class HibernateUtil {
private static SessionFactory sessionFactory;
private HibernateUtil() {
}
static {
try {
sessionFactory = new Configuration().configure().buildSessionFactory();
} catch (HibernateException e) {
e.printStackTrace();
System.exit(-1);
}
}
public static SessionFactory getSessionFactory() {
return sessionFactory;
}
public static Session getSession() {
return sessionFactory.openSession();
}
public static void closeSession(Session session) {
if (session != null)
session.close();
}
public static void saveEntity(Object entity) {
Session session = null;
try {
session = getSession();
session.beginTransaction();
session.save(entity);
session.getTransaction().commit();
} catch (HibernateException e) {
if (session.getTransaction() != null)
session.getTransaction().rollback();
throw e;
} finally {
closeSession(session);
}
}
}
以后，DAO方法的编码，就比原来简洁些了：
import static my.dao.impl.HibernateUtil.*；//为了便于使用，对HibernateUtil中所有的静态方法按需导入
public List<Goods> findAll() {
List<Goods> result = null;
Session session = null;
try {
session = getSession();
result = session.createCriteria(TGoods.class).list();
} catch(RuntimeException e) {
throw e;
} finally {
closeSession(s);
}
return result;
}
但这样的程度不够，并且并非只考虑开发效率和代码的可读性。在实际工作中更好的方法之一是用Spring框架的DAO支持。
2. hibernate查询怎么能写得简洁
把重复的提取出来，封装成方法就行了。
像这样的一个简单的工具类： public final class HibernateUtil { private static SessionFactory sessionFactory; private HibernateUtil() {}static {try {sessionFactory = new Configuration().configure().buildSessionFactory(); } catch (HibernateException e) { e.printStackTrace(); System.exit(-1);}} public static SessionFactory getSessionFactory() { return sessionFactory;} public static Session getSession() { return sessionFactory.openSession();} public static void closeSession(Session session) { if (session != null) session.close();}public static void saveEntity(Object entity) { Session session = null;try {session = getSession(); session.beginTransaction(); session.save(entity); session.getTransaction().commit(); } catch (HibernateException e) { if (session.getTransaction() != null) session.getTransaction().rollback();throw e;} finally { closeSession(session)；}}}以后，DAO方法的编码，就比原来简洁些了： import static my.dao.impl.HibernateUtil.*；//为了便于使用，对HibernateUtil中所有的静态方法按需导入 public List
3. hibernate中的查询方式有哪些
hibernate的查询方式主要有以下几种，你可以看看，也可以去官方下载文档来看看，不过是英文版本。
希望对你有帮助，谢谢 hibernate查询方式 ♦ 小结Hibernate。 ♦ Hibernate对多。
♦ hibernate查询。 ♦ Hibernate之查。
♦ Hibernate 查。 更多相关推荐。
在HQL中关键字不区分大小写，但是属性和类名区分大小写，下面介绍各种类型的Hibernate的HQL查询。1、Hibernate HQL查询：简单属性查询* 单一属性查询，返回结果集属性列表，元素类型和实体类中相应的属性类型一致* 多个属性查询，返回的集合元素是对象数组，数组元素的类型和对应的属性在实体类中的类型一致 数组的长度取决与select中属性的个数* 如果认为返回数组不够对象化，可以采用HQL动态实例化Student对象2、Hibernate HQL查询：实体对象查询* N + 1问题，在默认情况下，使用query.iterate查询，有可以能出现N+1问题，所谓的N+1是在查询的时候发出了N+1条sql语句，1： 首先发出一条查询对象id列表的sql,N： 根据id列表到缓存中查询，如果缓存中不存在与之匹配的数据，那么会根据id发出相应的sql语句* list和iterate的区别？* list每次都会发出sql语句，list会向缓存中放入数据，而不利用缓存中的数据* iterate：在默认情况下iterate利用缓存数据，但如果缓存中不存在数据有可以能出现N+1问题3、Hibernate HQL查询：条件查询* 可以采用拼字符串的方式传递参数 Java代码：List students = session.createQuery("select s.id, s.name from Student s where s.name like '%1%'").list（)； * 可以采用 ？来传递参数（索引从0开始） Java代码：List students = session.createQuery("select s.id, s.name from Student s where s.name like ?").setParameter(0, "%1%").list（)； //可以使用？方式传递参数 //参数的索引从0开始 //传递的参数值，不用单引号引起来 //注意方法链编程 * 可以采用 ：参数名 来传递参数 Java代码：List students = session.createQuery ("select s.id, s.name from Student s where s.name like :myname").setParameter("myname", "%1%").list（)； * 如果传递多个参数，可以采用setParamterList方法 Java代码：List students = session.createQuery("select s.id, s.name from Student s where s.id in(:myids)").setParameterList("myids", new Object[]{1, 2, 3, 4, 5}).list（)； * 在HQL中可以使用数据库的函数，如：date_format Java代码：List students = session.createQuery("select s.id, s.name from Student s where date_format(s.createTime, '%Y-%m')=?").setParameter(0, "2008-02").list(); SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss")； //查询2008-01-10到2008-02-15创建的学生 List students = session.createQuery("select s.id, s.name from Student s where s.createTime between ? and ?") ..setParameter(0, sdf.parse("2008-01-10 00:00:00")) .setParameter(1, sdf.parse("2008-02-15 23:59:59")) .list(); 4、Hibernate HQL查询：直接使用sql进行查询 Java代码：List students = session.createSQLQuery("select * from t_student").list（)； 不会返回对象，而是所有属性！ 5、Hibernate HQL查询：分页查询* setFirstResult（)，从0开始* setMaxResults，每页显示多少条数据 Java代码：List students = session.createQuery("from Student") .setFirstResult(1) .setMaxResults(2) .list(); 6、Hibernate HQL查询：对象导航查询，在HQL中采用 . 进行导航7、Hibernate HQL查询：连接查询* 内连 Sql代码：SELECT s.name, c.name FROM Student s (inner) join s.classes c * 外连接（左连接/右连接） Sql代码：SELECT s.name, c.name FROM Student s left join s.classes c 8、Hibernate HQL查询：统计查询 Java代码： List students =session.createQuery("select c.name, count(s) from Student s join s.classes c " +"group by c.name order by c.name").list(); for (Iterator iter=students.iterator(); iter.hasNext();) { Object[] obj = (Object[])iter.next(); System.out.println(obj[0] + ", " + obj[1]); } 9、DML风格的操作（尽量少用，因为和缓存不同步） Java代码：session.createQuery ("update Student s set s.name=? where s.id< ?") .setParameter(0， "李四") .setParameter(1, 5) .executeUpdate（)； 应当尽量少用，因为和缓存不同步，也就是说，假如在执行上面的语句之前，已经把student封装成一个list曾经拿了出来，再执行上面的语句对 student中的表进行数据更新，然后再list Student表，则此时的list是从缓存中取的数据，而不是从表中找到的数据，也就是 说，list拿到的是update前的数据，所以造成了这种不同步，所以这种风格尽量少用。
从这个方面也可以看得出Hibernate并不适用于聚集性，统计，大量批量的更新，删除等操作。
4. hibernate一对一查询怎么写
bean对象的结构：User表：@Entity@Table(name="t_users")public class User {private String userId; private String userCaption; private String photo; private String phone; private String password; private String createTime; private Integer userStatus; private String lastLoginTime; private String parentId; private String tags; private String idCard; private String description; private Set
5. hibernate怎么用查询
1:hibernate数据查询方式：有HQL方式，QBC方式，原生SQL方式。HQL适合静态查询，QBC则适合较多的动态查询。
A:HQL方式，支持条件查询，连接查询，分页查询，分组查询，内置函数和自定义函数查询（SUN(),MIN(),MAX（)），子查询，动态绑定参数查。
HQL语句定义如下：
String hql="from book";
Query query=session.createQuery(hql);
B:QBC方式，也就是QBC检索方式。QBC通过Session类创建Criteria实例，通过不同方法进行检索，实际上Criteria是用来装载查询条件的容器。QBC有很多条件函数，如：Resstictions.eq(),Resstictions.gt(),Resstictions.ge(),
Resstictions.le(),Resstictions.and(),Resstictions.or（)等。
Criteria容器使用方法如下：
Criteria criteria=session.createCriteria(book.class);
criteria.add(Restrications.It("id",new Integer(4)));
List list=criteria.list();
C：原生SQL方式。不管是HQL还是QBC最终都要通过Hibernate来解析，把他们转换成SQL语句进行对数据库的操作。因为我们知道SQL可以在多平台之间使用。
使用原生SQL方式如下：
String sql="select {b.*} from book b"
SQLQuery squery=session.createSQLQuery(sql);
squery.addEntity("b",book.class);
List list=squery.list();
2:hibernate的关联查询
A：一对一关联：
B：一对多，多对一关联
C：多对多关联
最后，要学hibernate，平时要多动手，慢慢积累经验，成就感就会也大，这样才能学而不厌。祝你学习进步。
6. Hibernate的查询是怎么实现的
简单地说，Hibernate在查询出一行数据之后，内部实现还是将数据读出到ResultSet里，然后分析session.get(Class, Object)函数的Class参数，通过类反射可以知道该Class包含哪些对象并且newInstance一个该类的对象，然后从ResultSet读出属性填充到该对象。用户只需要对这个对象进行简单的类型转换就可以使用了。
代码也有，是之前写一个持久化类库的时候写的。
static final ActiveRecord setupObject (Object object, ResultSet resultSet) throws java.sql.SQLException, ObjectAnalysisException
{
Map<Field, Accesstor> fields = ActiveRecord.analizeObjectFields(object);
try
{
for(Field field : fields.keySet())
{
Object value = resultSet.getObject(field.getName());
if(value != null)
fields.get(field).getSetter().invoke(object, value);
}
}
catch(SQLException err)
{
throw err;
}
catch(Exception err)
{
if(err instanceof IllegalAccessException || err instanceof IllegalArgumentException)
throw new ObjectAnalysisException(err.toString(), err);
else if(err instanceof InvocationTargetException)
throw new ObjectAnalysisException(err.toString(), err);
}
object.setId(resultSet.getLong("id"));
return object;
}
这段代码你无法编译因为还依赖其他的一些类，但是看看这个流程就大致能知道Hibernate如何智能地产生一个对象了。
hibernate语句怎么写
1. hibernate添加语句怎么写
不是有映射文件吗？
比如你的数据库表为student
那么的你就应该有hibernate.cfg.xml配置文件和他的映射文件hibernate.hbm.xml，最后还应该有一个student表的映射类student.java
这3个文件.
然后你建一个实现类studentInsert
实现是
SessionFactory sf = new Configuration().configure().buildSessionFactory();
Session session = sf.openSession();
Transaction tx = session.beginTransaction();
student st=new student();
st.setId("0001");
st.setUserName("Wang");
st.setpassWord("123");
session.save(st);
tx.commit();
session.close();
就是这样.
2. hibernate基本语句怎么操作
你既然用了hibernate就用第一种写法，
用第二种写法和不用hibernate有啥区别，不用hibernate就是要先开Connection然后开事物，保存，提交事物，然后关闭连接
你既然用了hibernate就完全不用用第二种方法，因为这些操作在getHibernateTemplate().save（)；里都已经封装好了，如果你非要用下面的写法也没办法，不是不行，只是跟只用jdbc有什么区别
hibernate3没有用过，但是如果没有find的话hibernate也是很好用的，抛开criteria不说
hql:
集合：this.getSession().createQuery("hql语句").list();
单一结果：this.getSession().createQuery("hql语句")uniqueResult();
有参数this.getSession().createQuery("hql语句").setString(0,"xxx").setString(1,"xxx").list();
sql:
this.getSession().createSqlQuery("sql语句")
其他一样
3. hql语句怎么写
String hql="from 类名 where app=6 AND pro_read_flag=FALSE";
Query query=session.createQuery(hql);
或者
String hql="from 类名 where app=? AND pro_read_flag=?";
Query query=session.createQuery(hql);
query.setParameter(0,6);
query.setParameter(1,false);
hibernate怎么写
1. hibernate工具怎么写
//泛型DAO接口
public interface IBaseDao{
// 根据主键获取实体。如果没有相应的实体，返回 null。
public T get(PK id);
// 根据主键获取实体。如果没有相应的实体，抛出异常。
public T load(PK id);
// 获取全部实体。
public ListloadAll();
public MapmakeStore();
// loadAllWithLock() ?
// 更新实体
public void update(T entity);
// 存储实体到数据库
public void save(T entity);
// saveWithLock()
// 增加或更新实体
public void saveOrUpdate(T entity);
// 增加或更新集合中的全部实体
public void saveOrUpdateAll(Collectionentities);
// 删除指定的实体
public void delete(T entity);
// 根据主键删除指定实体
public void deleteByKey(PK id);
// 删除集合中的全部实体
public void deleteAll(Collectionentities);
// -------------------- HSQL ----------------------------------------------
// 使用HSQL语句直接增加、更新、删除实体
public int bulkUpdate(String queryString);
// 使用带参数的HSQL语句增加、更新、删除实体
public int bulkUpdate(String queryString, Object[] values);
// 使用HSQL语句检索数据
public List find(String queryString);
//分页数据获取
public MapfindFenYeData(int pagecout,int nowpages);
//根据拼接HQL证据获取分页数据
public MapfindFenYeDataForHql(String hql,int pagecout,int nowpages);
// 使用带参数的HSQL语句检索数据
public List find(String queryString, Object[] values);
// 使用HSQL语句检索数据，返回 Iterator
public Iterator iterate(String queryString);
// 使用带参数HSQL语句检索数据，返回 Iterator
public Iterator iterate(String queryString, Object[] values);
// 关闭检索返回的 Iterator
public void closeIterator(Iterator it);
}
2. hibernate添加语句怎么写
不是有映射文件吗？
比如你的数据库表为student
那么的你就应该有hibernate.cfg.xml配置文件和他的映射文件hibernate.hbm.xml，最后还应该有一个student表的映射类student.java
这3个文件.
然后你建一个实现类studentInsert
实现是
SessionFactory sf = new Configuration().configure().buildSessionFactory();
Session session = sf.openSession();
Transaction tx = session.beginTransaction();
student st=new student();
st.setId("0001");
st.setUserName("Wang");
st.setpassWord("123");
session.save(st);
tx.commit();
session.close();
就是这样.
3. java连接mysql 用hibernate怎么写查询语句
第一种方式：HQL(Hibernate Query Languge,Hibernate 查询语言)查询是一种面向对象的查询语言，其中没有表和字段的概念，只有类、对象和属性的概念，HQL 是应用较为广泛的方式语法：[select/update/delete……] from Entity [where……] [group by……] [having……] [order by……]（1）.没使用Spring框架的写法：使用HQL需要四步得到Session、编写HQL语句、创建Query对象（Query接口是HQL 查询接口。
它提供了各种的查询功能）、执行查询，得到结果 sessionFactory = new Configuration().configure().buildSessionFactory(); session = sessionFactory.openSession(); String hql = “from Street”; Query query = session.createQuery(hql); List list = query.list();(2).使用Spring框架的写法：String queryString = "select form entity 。.";List list=getHibernateTemplate().find(queryString)；第二种方式：Criteria 查询Criteria 查询采用面向对象方式封装查询条件，又称为对象查询；就是对SQL 语句进行封装，采用对象的方式来组合各种查询条件由Hibernate 自动产生SQL 查询语句（1）.没使用Spring框架的写法；Criteria由Hibernate Session进行创建SessionFactory sessionFactory = new Configuration().configure() .buildSessionFactory(); Session session = sessionFactory.openSession(); Criteria criteria = session.createCriteria(User.class); List result = criteria.list(); Iterator it = result.iterator(); (2)使用Spring框架的写法：import org.hibernate.criterion.DetachedCriteria;DetachedCriteria criteria=DetachedCriteria.forClass(ObjectEntity.class);criteria.add(Restrictions.eq("propertyName", propertyValue));List result=getHibernateTemplate().findByCriteria(criteria)；第三种方式：使用SQL语句查询（以下都是使用了Spring框架的写法）1）.这是把执行结果放到了一个类里：（这个类通常使用VO实体，VO实体一般就只用来接收查询结果）List list = getHibernateTemplate().executeFind(new HibernateCallback() { public Object doInHibernate(Session session) throws HibernateException, SQLException { StringBuffer hqlBuffer = new StringBuffer(""); hqlBuffer.append("select column_Name from 。
")；//里面是SQL语句 SQLQuery sqlQuery = session.createSQLQuery(hqlBuffer.toString()); sqlQuery.addScalar("propertyName",Hibernate.STRING)；//该propertyName是 ObjectVO实体的一个属性 sqlQuery.setResultTransformer(Transformers.aliasToBean(ObjectVO.class)); List list = sqlQuery.list(); return list；//此处list集合中存放的是ObjectVO对象 } }）；2）.返回结果放到list中的： final String queryString = "";//sql语句 List resultList=getHibernateTemplate().executeFind(new HibernateCallback() { public List doInHibernate(Session session) throws HibernateException, SQLException { SQLQuery sqlQuery = session.createSQLQuery(queryString); List list=sqlQuery.executeUpdate(); return list; } });3）.无返回结果： final String queryString = "";//SQL语句 getHibernateTemplate().executeFind(new HibernateCallback() { public Object doInHibernate(Session session) throws HibernateException, SQLException { SQLQuery sqlQuery = session.createSQLQuery(queryString); sqlQuery.executeUpdate(); return null; } });。
4. 用hibernate的HQL怎么写一个插入语句
不是有映射文件吗？
比如你的数据库表为student
那么的你就应该有hibernate.cfg.xml配置文件和他的映射文件hibernate.hbm.xml，最后还应该有一个student表的映射类student.java
这3个文件.
然后你建一个实现类studentInsert
实现是
SessionFactory sf = new Configuration().configure().buildSessionFactory();
Session session = sf.openSession();
Transaction tx = session.beginTransaction();
student st=new student();
st.setId("0001");
st.setUserName("Wang");
st.setpassWord("123");
session.save(st);
tx.commit();
session.close();
就是这样.
转载请注明出处育才学习网 » hibernate怎么写sql