使用过滤器(Filter)Hibernate Session 延时加载 (一对多关系)

最新推荐文章于 2021-02-13 04:05:45 发布
转载 最新推荐文章于 2021-02-13 04:05:45 发布 · 1.2k 阅读 · 0
标签
#session #hibernate #filter #character #collation
#null
本文介绍Hibernate3.x中session的延时加载策略及其优点，并通过具体示例展示如何实现部门和员工之间的关联映射。

转自:http://www.blogjava.net/DoubleJ/archive/2008/03/04/183781.html 

 

Hibernate 3.x 提供的session的检索策略默认为延时加载.他有以下优点:
    减少数据库并发性
    减少数据的IO次数
下面的例子是关于session的延时加载的例子.

建立数据库example1

 

 1# SQL Manager 2005 Lite for MySQL 3.6.5.8
 2# ---------------------------------------
 3# Host     : localhost
 4# Port     : 3306
 5# Database : example1
 6
 7
 8/*!40101 SET @OLD_CHARACTER_SET_CLIENT=@@CHARACTER_SET_CLIENT */;
 9/*!40101 SET @OLD_CHARACTER_SET_RESULTS=@@CHARACTER_SET_RESULTS */;
10/*!40101 SET @OLD_COLLATION_CONNECTION=@@COLLATION_CONNECTION */;
11/*!40101 SET NAMES gb2312 */;
12
13SET FOREIGN_KEY_CHECKS=0;
14
15DROP DATABASE IF EXISTS `example1`;
16
17CREATE DATABASE `example1`
18    CHARACTER SET 'gbk'
19    COLLATE 'gbk_chinese_ci';
20
21USE `example1`;
22
23#
24# Structure for the `department` table : 
25#
26
27DROP TABLE IF EXISTS `department`;
28
29CREATE TABLE `department` (
30  `d_id` int(11) NOT NULL auto_increment,
31  `d_name` varchar(20) NOT NULL,
32  PRIMARY KEY  (`d_id`),
33  UNIQUE KEY `d_name` (`d_name`)
34) ENGINE=InnoDB DEFAULT CHARSET=gb2312;
35
36#
37# Data for the `department` table  (LIMIT 0,500)
38#
39
40INSERT INTO `department` (`d_id`, `d_name`) VALUES 
41  (1,'Office');
42
43COMMIT;
44
45#
46# Structure for the `emplyee` table : 
47#
48
49DROP TABLE IF EXISTS `emplyee`;
50
51CREATE TABLE `emplyee` (
52  `e_id` int(11) NOT NULL auto_increment,
53  `e_name` varchar(20) NOT NULL,
54  `e_login_name` varchar(20) NOT NULL,
55  `e_password` varchar(20) NOT NULL,
56  `e_reg_date` date default NULL,
57  `d_id` int(11) default NULL,
58  PRIMARY KEY  (`e_id`),
59  UNIQUE KEY `e_login_name` (`e_login_name`),
60  KEY `d_id` (`d_id`),
61  CONSTRAINT `emplyee_fk` FOREIGN KEY (`d_id`) REFERENCES `department` (`d_id`)
62) ENGINE=InnoDB DEFAULT CHARSET=gb2312;
63
64#
65# Data for the `emplyee` table  (LIMIT 0,500)
66#
67
68INSERT INTO `emplyee` (`e_id`, `e_name`, `e_login_name`, `e_password`, `e_reg_date`, `d_id`) VALUES 
69  (1,'YiJun','DoubleJ','windows','2008-03-01',1),
70  (2,'ZhangSan','Zs','windows','2008-03-04',1);
71
72COMMIT;
73
74
75
76/*!40101 SET CHARACTER_SET_CLIENT=@OLD_CHARACTER_SET_CLIENT */;
77/*!40101 SET CHARACTER_SET_RESULTS=@OLD_CHARACTER_SET_RESULTS */;
78/*!40101 SET COLLATION_CONNECTION=@OLD_COLLATION_CONNECTION */;

 

新建一javaWeb工程,取名为 DJ_HIBERNATE
在MyEclipse里的database Explorer建立数据源,连接上example1数据库,并将hibernate 3.0导入到工程中!
创建以下类:
org.dj.pojo.DepartmentPojo.java

package org.dj.pojo;

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

public class DepartmentPojo {
    private Integer did;

    private String dname;

    private Set<EmplyeePojo> emps = new HashSet<EmplyeePojo>(0);

    public DepartmentPojo() {
        // TODO Auto-generated constructor stub
    }

    public DepartmentPojo(String dname) {
        super();
        this.dname = dname;
    }

    public DepartmentPojo(Integer did, String dname) {
        super();
        this.did = did;
        this.dname = dname;
    }

    public Integer getDid() {
        return did;
    }

    public void setDid(Integer did) {
        this.did = did;
    }

    public String getDname() {
        return dname;
    }

    public void setDname(String dname) {
        this.dname = dname;
    }

    public Set<EmplyeePojo> getEmps() {
        return emps;
    }

    public void setEmps(Set<EmplyeePojo> emps) {
        this.emps = emps;
    }

}

并在org.dj.pojo包下创建DepartmentPojo.hbm.xml关系配置文件
 1<?xml version="1.0"?>
 2<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
 3"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
 4<hibernate-mapping>
 5    <class name="org.dj.pojo.DepartmentPojo" table="department">
 6        <id name="did" column="d_id" type="java.lang.Integer">
 7            <generator class="native"></generator>
 8        </id>
 9        <property name="dname" column="d_name"
10            type="java.lang.String">
11        </property>
12        <set name="emps">
13            <key column="d_id"></key>
14            <one-to-many class="org.dj.pojo.EmplyeePojo" />
15        </set>
16    </class>
17</hibernate-mapping>

再创建org.dj.pojo.EmplyeePojo类,
 1package org.dj.pojo;
 2
 3import java.sql.Date;
 4
 5public class EmplyeePojo {
 6    private Integer eid;
 7
 8    private String ename;
 9
10    private String eloginName;
11
12    private String epassword;
13
14    private java.sql.Date eregDate;
15
16    private DepartmentPojo department;
17
18    public DepartmentPojo getDepartment() {
19        return department;
20    }
21
22    public void setDepartment(DepartmentPojo department) {
23        this.department = department;
24    }
25
26    public EmplyeePojo() {
27        // TODO Auto-generated constructor stub
28    }
29
30    public EmplyeePojo(String ename, String eloginName, String epassword,
31            Date eregDate) {
32        super();
33        this.ename = ename;
34        this.eloginName = eloginName;
35        this.epassword = epassword;
36        this.eregDate = eregDate;
37    }
38
39    public EmplyeePojo(Integer eid, String ename, String eloginName,
40            String epassword, Date eregDate) {
41        super();
42        this.eid = eid;
43        this.ename = ename;
44        this.eloginName = eloginName;
45        this.epassword = epassword;
46        this.eregDate = eregDate;
47    }
48
49    public Integer getEid() {
50        return eid;
51    }
52
53    public void setEid(Integer eid) {
54        this.eid = eid;
55    }
56
57    public String getEloginName() {
58        return eloginName;
59    }
60
61    public void setEloginName(String eloginName) {
62        this.eloginName = eloginName;
63    }
64
65    public String getEname() {
66        return ename;
67    }
68
69    public void setEname(String ename) {
70        this.ename = ename;
71    }
72
73    public String getEpassword() {
74        return epassword;
75    }
76
77    public void setEpassword(String epassword) {
78        this.epassword = epassword;
79    }
80
81    public java.sql.Date getEregDate() {
82        return eregDate;
83    }
84
85    public void setEregDate(java.sql.Date eregDate) {
86        this.eregDate = eregDate;
87    }
88
89}
90


再在org.dj.pojo包下创建与其对应的配置文件EmplyeePojo.hbm.xml

 1<?xml version="1.0"?>
 2<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
 3"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
 4<hibernate-mapping>
 5    <class name="org.dj.pojo.EmplyeePojo" table="emplyee">
 6        <id name="eid" column="e_id" type="java.lang.Integer">
 7            <generator class="native"></generator>
 8        </id>
 9        <property name="ename" column="e_name"
10            type="java.lang.String">
11        </property>
12        <property name="eloginName" column="e_login_name"
13            type="java.lang.String">
14        </property>
15        <property name="epassword" column="e_password"
16            type="java.lang.String">
17        </property>
18        <property name="eregDate" column="e_reg_date"
19            type="java.sql.Date">
20        </property>
21        <many-to-one name="department"
22            class="org.dj.pojo.DepartmentPojo" column="d_id">
23        </many-to-one>
24    </class>
25</hibernate-mapping>


再创建一个dao对象用来得到一个员工记录,些类为:
org.dj.dao.EmplyeeDao
 1package org.dj.dao;
 2
 3import java.io.Serializable;
 4
 5import org.dj.pojo.EmplyeePojo;
 6import org.dj.util.HibernateSessionFactory;
 7import org.hibernate.HibernateException;
 8import org.hibernate.Session;
 9import org.hibernate.Transaction;
10
11public class EmplyeeDao {
12    /**
13     * 根据id得到用户
14     * 
15     * @param eid
16     * @return
17     */
18    public EmplyeePojo getEmplyee(Serializable eid) {
19        EmplyeePojo emp = null;
20        Session session = HibernateSessionFactory.getSession();
21        // Transaction trans = session.beginTransaction();
22        try {
23            emp = (EmplyeePojo) session.load(EmplyeePojo.class, eid);
24            // trans.commit();
25        } catch (HibernateException e) {
26            e.printStackTrace();
27            // trans.rollback();
28        } finally {
29            // HibernateSessionFactory.closeSession();
30        }
31        return emp;
32    }
33}
34

一开始.请去掉我的代码注释;

下面,我们去写个Emplyee的Service类,写一个业务处理的方法, 通得员工ID计算已注册的天数
org.dj.service.EmplyeeManegerService
 1package org.dj.service;
 2
 3import java.io.Serializable;
 4import java.util.Calendar;
 5
 6import org.dj.dao.EmplyeeDao;
 7import org.dj.pojo.EmplyeePojo;
 8import org.dj.vo.EmplyeeVo;
 9
10public class EmplyeeManegerService {
11    private EmplyeeDao empDao = new EmplyeeDao();
12    /**
13     * 得到用户注册的天数(本网站的网齡)
14     * @param eid 用户的id
15     * @return 网龉
16     */
17    public Long loadEmplyeeOnlineTime(Serializable eid){
18        EmplyeePojo emp = empDao.getEmplyee(eid);
19        java.sql.Date regDate = emp.getEregDate();
20        Long time = System.currentTimeMillis() - regDate.getTime();
21        long day = time/(24*60*60*1000);
22        return day;
23    }
24    
25    public static void main(String[] args) {
26        Long day = new EmplyeeManegerService().loadEmplyeeOnlineTime(1);
27        System.out.println(day);
28    }
29}
30

里面有个main写的测试. 你去run的时候. 发现他会发生一个异常:
session was close;

解决这个方法,你可以这样做.
先修改HibernateSessionFactory类.
  1package org.dj.util;
  2
  3import org.hibernate.HibernateException;
  4import org.hibernate.Session;
  5import org.hibernate.Transaction;
  6import org.hibernate.cfg.Configuration;
  7
  8
  9public class HibernateSessionFactory {
 10
 11    
 12    private static String CONFIG_FILE_LOCATION = "/hibernate.cfg.xml";
 13
 14    private static final ThreadLocal<Session> threadLocal = new ThreadLocal<Session>();
 15
 16    private static final ThreadLocal<Transaction> trThreadLocal = new ThreadLocal<Transaction>();
 17
 18    private static Configuration configuration = new Configuration();
 19
 20    private static org.hibernate.SessionFactory sessionFactory;
 21
 22    private static String configFile = CONFIG_FILE_LOCATION;
 23
 24    static {
 25        try {
 26            configuration.configure(configFile);
 27            sessionFactory = configuration.buildSessionFactory();
 28        } catch (Exception e) {
 29            System.err.println("%%%% Error Creating SessionFactory %%%%");
 30            e.printStackTrace();
 31        }
 32    }
 33
 34    private HibernateSessionFactory() {
 35    }
 36
 37    /**
 38     * Returns the ThreadLocal Session instance. Lazy initialize the
 39     * <code>SessionFactory</code> if needed.
 40     * 
 41     * @return Session
 42     * @throws HibernateException
 43     */
 44    public static Session getSession() throws HibernateException {
 45        Session session = (Session) threadLocal.get();
 46
 47        if (session == null || !session.isOpen()) {
 48            if (sessionFactory == null) {
 49                rebuildSessionFactory();
 50            }
 51            session = (sessionFactory != null) ? sessionFactory.openSession()
 52                    : null;
 53            threadLocal.set(session);
 54        }
 55
 56        return session;
 57    }
 58
 59    /**
 60     * Rebuild hibernate session factory
 61     * 
 62     */
 63    public static void rebuildSessionFactory() {
 64        try {
 65            configuration.configure(configFile);
 66            sessionFactory = configuration.buildSessionFactory();
 67        } catch (Exception e) {
 68            System.err.println("%%%% Error Creating SessionFactory %%%%");
 69            e.printStackTrace();
 70        }
 71    }
 72
 73    /**
 74     * Close the single hibernate session instance.
 75     * 
 76     * @throws HibernateException
 77     */
 78    public static void closeSession() throws HibernateException {
 79        Session session = (Session) threadLocal.get();
 80        threadLocal.set(null);
 81
 82        if (session != null) {
 83            session.close();
 84        }
 85    }
 86
 87    /**
 88     * return session factory
 89     * 
 90     */
 91    public static org.hibernate.SessionFactory getSessionFactory() {
 92        return sessionFactory;
 93    }
 94
 95    /**
 96     * return session factory
 97     * 
 98     * session factory will be rebuilded in the next call
 99     */
100    public static void setConfigFile(String configFile) {
101        HibernateSessionFactory.configFile = configFile;
102        sessionFactory = null;
103    }
104
105    /**
106     * return hibernate configuration
107     * 
108     */
109    public static Configuration getConfiguration() {
110        return configuration;
111    }
112
113    public static void openTransaction() {
114        Transaction tr = trThreadLocal.get();
115        if (tr == null) {
116            tr = getSession().beginTransaction();
117            System.out.println("BeginTransaction");
118            trThreadLocal.set(tr);
119        }
120    }
121
122    public static void commitTransaction() {
123        Transaction tr = trThreadLocal.get();
124        if (tr != null && !tr.wasCommitted() && !tr.wasRolledBack()) {
125            System.out.println("Commit !");
126            tr.commit();
127            trThreadLocal.set(null);
128        }
129    }
130
131    public static void RollbackTransaction() {
132        Transaction tr = trThreadLocal.get();
133        if (tr != null && !tr.wasCommitted() && !tr.wasRolledBack()) {
134            tr.rollback();
135            System.out.println("Rollback!");
136            trThreadLocal.set(null);
137        }
138    }
139
140}


注意最后面的三个方法和trThreadLocal的属性;

再写一个过滤器, 代码如下 :
org.dj.filter.HibernateSessionFilter
 1package org.dj.filter;
 2
 3import java.io.IOException;
 4
 5import javax.servlet.Filter;
 6import javax.servlet.FilterChain;
 7import javax.servlet.FilterConfig;
 8import javax.servlet.ServletException;
 9import javax.servlet.ServletRequest;
10import javax.servlet.ServletResponse;
11
12import org.dj.util.HibernateSessionFactory;
13
14public class HibernateSessionFilter implements Filter {
15
16    public void destroy() {
17        // TODO Auto-generated method stub
18
19    }
20
21    public void doFilter(ServletRequest request, ServletResponse response,
22            FilterChain chain) throws IOException, ServletException {
23
24        HibernateSessionFactory.getSession();
25        HibernateSessionFactory.openTransaction();
26        try {
27            chain.doFilter(request, response);
28            HibernateSessionFactory.commitTransaction();
29        } catch (Exception e) {
30            HibernateSessionFactory.RollbackTransaction();
31            e.printStackTrace();
32        } finally {
33            HibernateSessionFactory.closeSession();
34        }
35    }
36
37    public void init(FilterConfig filterConfig) throws ServletException {
38        // TODO Auto-generated method stub
39
40    }
41
42}
43

并在web.xml里面配置这个过滤器,代码如下 :
1<filter>
2      <filter-name>sessionFilter</filter-name>
3      <filter-class>org.dj.filter.HibernateSessionFilter</filter-class>
4  </filter>
5  <filter-mapping>
6      <filter-name>sessionFilter</filter-name>
7      <url-pattern>/*</url-pattern>
8  </filter-mapping>

这样,我们就写好了. 再回过头把我在EmplyeeDao对象里面注释重新注释上.并写个两个jsp和一个Serlvet进行测试.代码如下:

index.jsp:
 1<%@ page language="java" import="java.util.*" pageEncoding="utf-8"%>
 2<%
 3    String path = request.getContextPath();
 4    String basePath = request.getScheme() + "://"
 5            + request.getServerName() + ":" + request.getServerPort()
 6            + path + "/";
 7%>
 8
 9<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
10<html>
11    <head>
12        <base href="<%=basePath%>">
13
14        <title>My JSP 'index.jsp' starting page</title>
15        <meta http-equiv="pragma" content="no-cache">
16        <meta http-equiv="cache-control" content="no-cache">
17        <meta http-equiv="expires" content="0">
18        <meta http-equiv="keywords" content="keyword1,keyword2,keyword3">
19        <meta http-equiv="description" content="This is my page">
20        <!--
21    <link rel="stylesheet" type="text/css" href="styles.css">
22    -->
23    </head>
24
25    <body>
26        <form action="/DJ_HIBERNATE/servlet/GetOnlineDays">
27            员工编号：
28            <input name="eid">
29            <input type="submit">
30        </form>
31
32
33    </body>
34</html>
35


disp.jsp:
 1<%@ page language="java" import="java.util.*" pageEncoding="GB18030"%>
 2<%
 3String path = request.getContextPath();
 4String basePath = request.getScheme()+"://"+request.getServerName()+":"+request.getServerPort()+path+"/";
 5%>
 6
 7<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
 8<html>
 9  <head>
10    <base href="<%=basePath%>">
11    
12    <title>My JSP 'disp.jsp' starting page</title>
13    
14    <meta http-equiv="pragma" content="no-cache">
15    <meta http-equiv="cache-control" content="no-cache">
16    <meta http-equiv="expires" content="0">    
17    <meta http-equiv="keywords" content="keyword1,keyword2,keyword3">
18    <meta http-equiv="description" content="This is my page">
19    <!--
20    <link rel="stylesheet" type="text/css" href="styles.css">
21    -->
22
23  </head>
24  
25  <body>
26    ${day }
27  </body>
28</html>
29

org.dj.servlet.GetOnlineDays的serlvet的代码如果:
package org.dj.servlet;

import java.io.IOException;
import java.io.PrintWriter;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.dj.service.EmplyeeManegerService;

public class GetOnlineDays extends HttpServlet {
    private EmplyeeManegerService service = new EmplyeeManegerService();

    public void doGet(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {
        Integer eid = Integer.parseInt(request.getParameter("eid"));
        Long day = service.loadEmplyeeOnlineTime(eid);
        request.setAttribute("day", day);
        request.getRequestDispatcher("/disp.jsp").forward(request, response);
    }

}

好了. 让我们发布后测试一下吧.
你会发现session was close的异常没有了.
基本的工作原理如下 图.
 
利用过滤器对hibernate的session管理,实现session在线程范围内的共享
文艺地工作着
07-19 1488
<br />hibernate中的Session关系到对数据库的增删查改等基本的数据存取操作.对Session进行有效的维护,就像是在jdbc编程中对JDBC collection的维护.<br />     在struts+hibernate的方案中,常常利用过滤器(Filter)对session进行管理,以实现session在线程范围内的共享.为什么仅仅实现线程内的共享,是因为,不能把session用于多线程,否则会出现意外.在线程范围内实现sesion的共享.避免了session的频繁的创建和销毁.我
Hinbernate中使用Filter过滤一对多中的选项
有梦就是幸福的
01-30 944
<br />实体类<br />package com.test.hibernate.entity;<br />/**<br /> * TblStreet entity.<br /> * <br /> * @author MyEclipse Persistence Tools<br /> */<br />public class TblStreet implements java.io.Serializable {<br /> // Fields<br /> private Integer i
hibernate session 过滤器控制
做一个踏实，持续努力的程序员
10-13 308
最近做一个公司项目的Demo，使用技术为jsp+dwr+hibernate,因为该Demo中所用的表多，有一对一，一对多和多对一的关系，所以利用hibernate的延迟加载（lazy="true"）对性能的提高相当重要，但随之带来的session管理更为重要，弄不好常出现延迟加载异常，在这里我利用了Filter 来处理session的close的，相关代码如下：   1.HibernateSess...
用Filter对Hibernate的session进行管理
lkf0217的专栏
08-05 820
关键字: hibernate, session ，Filterhibernate中的Session关系到对数据库的增删查改等基本的数据存取操作.对Session进行有效的维护,就像是在jdbc编程中对JDBC collection的维护.    在struts+hibernate的方案中,常常利用过滤器(Filter)对session进行管理,以实现session在线程范围内的共享
Hibernate过滤器使用窍门
For that dream
08-04 729
Hibernate过滤器（filter）是全局有效的、具有名字、可以带参数的过滤器，对于某个特定的Hibernate session您可以选择是否启用（或禁用）某个过滤器。 AD： 本文向大家介绍Hibernate过滤器，可能好多人还不了
Hibernate-OpenSessionInView-session开启-关闭过滤器filter
北京Java青年
06-13 821
public class OpenSessionInViewFilter implements Filter { @Override public void destroy() { // TODO Auto-generated method stub } @Override public void doFilter(ServletRequest ar
hibernate懒加载之No session扩大session作用范围
afdasfggasdf的博客
11-20 1569
当使用hibernate框架时因为懒加载策略问题，session已经在service时关闭 ，在后面查询关联的内容将出现no session问题 ，这时我们需要将session延迟到页面处理完成后完成。       注意：必须在struts框架之前配置，因为在struts之后就已经将内容处理完成了，不会再经过OpenSessionInViewFilter过滤器。     ope
Hibernate 超简单的一对多和多对一查询
热门推荐
kd_bright的博客
03-12 1万+
这里使用的Teacher类和Student类（假设一个Teacher对应多个学生，一个学生对应一个老师）所需jar包开始建表1（表名 teacher）2（表名 student）主键都为自增长创建实体类Teacher类package com.bright.po; import java.util.Set; public class Teacher { private Integer id; ...
hibernate一对多（OneToMany）注解开发
玲儿叮当想
04-19 1万+
hibernate基于注解开发的一对多关系小Demo。不多说，上代码Boss.java（老板类）package com.it.hibernate.domain; import java.util.Date; import java.util.HashSet; import java.util.Set; import javax.persistence.Column; import javax....
java hibernate事务处理_Hibernate中使用过滤器完成事务处理
weixin_33618737的博客
02-13 205
实现的功能:通过Hibernate的工具类得到一个全局唯一的SessionFactory对象通过SessionFactory对象得到Session对象,然后开始一个新的事务通过chain对象的doFilter()方法来完成业务处理提交或者回滚事务.HibernateFilter.javaimport java.io.IOException;import javax.servlet.Filte...
Hibernate过滤器
weixin_34297704的博客
09-18 114
HibernateFilter.java importjava.io.IOException; importjavax.servlet.Filter; importjavax.servlet.FilterChain; importjavax.servlet.FilterConfig; importjavax.servlet.ServletExceptio...
OpenSessionInViewFilter解决Hibernate延时加载问题
想作会飞的鱼的博客
06-06 1606
一、搭建项目环境1、创建一个动态web项目； 2、导入jar包（SSH、spring依赖、日志、数据库驱动）； 3、配置web.xml（struts2的过滤器、spring监听器、解决Hibernate延迟加载问题的过滤器、解决中文乱码的过滤器）第四步：创建项目目录结构第五步：在config目录中提供struts2的配置文件
hibernate的对象状态和opensessioninviewfilter的作用
SkydivingWang的博客
07-06 675
hibernate的对象状态分为三种: 瞬时状态(未持久化,新new的对象),持久状态(在数据库中有值的对象,具体是怎么操作的?是通过主键id来关联判断的吗?),游离状态(db中不存在,已经被删除,但是在程序中还保持该引用的对象); 对于持久化对象,在session清理缓存即flush方法的时候会做检查,检查对象中的属性是否发生变化,如果发生了变化(比如set了一些值),那么就会和数据库做同步
JPA（hibernate）一对多根据多的一方某属性进行过滤查询
tianyaleixiaowu的专栏
11-22 1万+
我们经常会碰上某个字段是集合元素（List，Set）的情况，并且我们要过滤出集合中包含某个或某些元素的数据。 譬如一个类User /** * 检索人 */ private Long userId; /** * 省、直辖市集合 */ @ElementCollection @CollectionTable pr
hibernate中OpenSessionInViewFilter的笔记 (转)
记录技术点点之路
03-17 203
&lt;!-- 过滤spring中对于hibernate的session关闭管理 --&gt; &lt;filter&gt; &lt;filter-name&gt;hibernateFilter&lt;/filter-name&gt; &lt;filter-class&gt; org.springframework.orm.hiber...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值