Package net.sf.hibernate

Examples of net.sf.hibernate.Session

244
245
246
247
248
249
250
251
252
   * @throws DataAccessResourceFailureException if the Session could not be created
   * @see org.springframework.orm.hibernate.SessionFactoryUtils#getSession(SessionFactory, boolean)
   * @see net.sf.hibernate.FlushMode#NEVER
   */
  protected Session openSession(SessionFactory sessionFactory) throws DataAccessResourceFailureException {
    Session session = SessionFactoryUtils.getSession(sessionFactory, true);
    session.setFlushMode(FlushMode.NEVER);
    return session;
  }
View Full Code Here
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
    Assert.notNull(sessionFactory, "No SessionFactory specified");

    SessionHolder sessionHolder = (SessionHolder) TransactionSynchronizationManager.getResource(sessionFactory);
    if (sessionHolder != null && !sessionHolder.isEmpty()) {
      // pre-bound Hibernate Session
      Session session = null;
      if (TransactionSynchronizationManager.isSynchronizationActive() &&
          sessionHolder.doesNotHoldNonDefaultSession()) {
        // Spring transaction management is active ->
        // register pre-bound Session with it for transactional flushing.
        session = sessionHolder.getValidatedSession();
        if (!sessionHolder.isSynchronizedWithTransaction()) {
          logger.debug("Registering Spring transaction synchronization for existing Hibernate Session");
          TransactionSynchronizationManager.registerSynchronization(
              new SpringSessionSynchronization(sessionHolder, sessionFactory, jdbcExceptionTranslator, false));
          sessionHolder.setSynchronizedWithTransaction(true);
          // Switch to FlushMode.AUTO if we're not within a read-only transaction.
          FlushMode flushMode = session.getFlushMode();
          if (FlushMode.NEVER.equals(flushMode) &&
              !TransactionSynchronizationManager.isCurrentTransactionReadOnly()) {
            session.setFlushMode(FlushMode.AUTO);
            sessionHolder.setPreviousFlushMode(flushMode);
          }
        }
      }
      else {
        // No Spring transaction management active -> try JTA transaction synchronization.
        session = getJtaSynchronizedSession(sessionHolder, sessionFactory, jdbcExceptionTranslator);
      }
      if (session != null) {
        return session;
      }
    }

    try {
      logger.debug("Opening Hibernate Session");
      Session session = (entityInterceptor != null ?
          sessionFactory.openSession(entityInterceptor) : sessionFactory.openSession());

      // Set Session to FlushMode.NEVER if we're within a read-only transaction.
      // Use same Session for further Hibernate actions within the transaction.
      // Thread object will get removed by synchronization at transaction completion.
      if (TransactionSynchronizationManager.isSynchronizationActive()) {
        // We're within a Spring-managed transaction, possibly from JtaTransactionManager.
        logger.debug("Registering Spring transaction synchronization for new Hibernate Session");
        SessionHolder holderToUse = sessionHolder;
        if (holderToUse == null) {
          holderToUse = new SessionHolder(session);
        }
        else {
          holderToUse.addSession(session);
        }
        if (TransactionSynchronizationManager.isCurrentTransactionReadOnly()) {
          session.setFlushMode(FlushMode.NEVER);
        }
        TransactionSynchronizationManager.registerSynchronization(
            new SpringSessionSynchronization(holderToUse, sessionFactory, jdbcExceptionTranslator, true));
        holderToUse.setSynchronizedWithTransaction(true);
        if (holderToUse != sessionHolder) {
View Full Code Here
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
        // Look for transaction-specific Session.
        Transaction jtaTx = jtaTm.getTransaction();
        if (jtaTx != null) {
          int jtaStatus = jtaTx.getStatus();
          if (jtaStatus == Status.STATUS_ACTIVE || jtaStatus == Status.STATUS_MARKED_ROLLBACK) {
            Session session = sessionHolder.getValidatedSession(jtaTx);
            if (session == null && !sessionHolder.isSynchronizedWithTransaction()) {
              // No transaction-specific Session found: If not already marked as
              // synchronized with transaction, register the default thread-bound
              // Session as JTA-transactional. If there is no default Session,
              // we're a new inner JTA transaction with an outer one being suspended:
              // In that case, we'll return null to trigger opening of a new Session.
              session = sessionHolder.getValidatedSession();
              if (session != null) {
                logger.debug("Registering JTA transaction synchronization for existing Hibernate Session");
                sessionHolder.addSession(jtaTx, session);
                jtaTx.registerSynchronization(
                    new SpringJtaSynchronizationAdapter(
                        new SpringSessionSynchronization(sessionHolder, sessionFactory, jdbcExceptionTranslator, false),
                        jtaTm));
                sessionHolder.setSynchronizedWithTransaction(true);
                // Switch to FlushMode.AUTO if we're not within a read-only transaction.
                FlushMode flushMode = session.getFlushMode();
                if (FlushMode.NEVER.equals(flushMode)) {
                  session.setFlushMode(FlushMode.AUTO);
                  sessionHolder.setPreviousFlushMode(flushMode);
                }
              }
            }
            return session;
View Full Code Here
143
144
145
146
147
148
149
150
151
152
153
    }
    else {
      if (isSingleSession()) {
        // single session mode
        logger.debug("Opening single Hibernate Session in OpenSessionInViewInterceptor");
        Session session = SessionFactoryUtils.getSession(
            getSessionFactory(), getEntityInterceptor(), getJdbcExceptionTranslator());
        applyFlushMode(session, false);
        TransactionSynchronizationManager.bindResource(getSessionFactory(), new SessionHolder(session));
      }
      else {
View Full Code Here
71
72
73
74
75
76
77
78
79
80
81
        // cast to the types I want to use
        HttpServletRequest request = (HttpServletRequest) req;
        HttpServletResponse response = (HttpServletResponse) resp;
        HttpSession session = request.getSession(true);

        Session ses = null;
        boolean sessionCreated = false;

        try
        {
            chain.doFilter(request, response);
View Full Code Here
59
60
61
62
63
64
65
66
67
68
69
    //~ Methods ================================================================

    public static Session currentSession() throws PersistenceException
    {
        Session s = (Session) session.get();

        if (s == null)
        {
            s = PersistenceManager.openSession();
            if (log.isDebugEnabled())
View Full Code Here
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
        return s;
    }

    public static void closeSession() throws HibernateException, JDBCException
    {
        Session s = (Session) session.get();
        session.set(null);

        if (s != null)
        {
            if (s.isOpen())
            {
                s.flush();
                s.close();

                if (log.isDebugEnabled())
                {
                    log.debug("Closed hibernate session.");
                }
View Full Code Here
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
import java.util.List;

// Repository for files and directories
public class FileSystemImpl implements FileSystem {
    public Directory getRootDirectory() throws HibernateException {
        Session session = ThreadSession.get();
        List dirs = session.createQuery(
                "from dir in " + Directory.class + " where dir.parent is null").
                setMaxResults(1).list();
        if (dirs.iterator().hasNext()) {
            return (Directory)dirs.iterator().next();
        } else {
            Directory root = new Directory();
            root.setName("");
            session.save(root);
            session.flush();
            session.refresh(root);
            return root;
        }
    }
View Full Code Here
33
34
35
36
37
38
39
40
41
42
43
44
45
    }

    public Directory getDirectory(String path) throws HibernateException {
        String[] pathElements = path.split("/");
        Directory dir = getRootDirectory();
        Session session = ThreadSession.get();
        for (int i = 1; i < pathElements.length; i++) {
            List subdirectory = session.createQuery(
                    "from dir in "+Directory.class+" where dir.parent = :parent and dir.name = :name").
                    setParameter("parent", dir, Hibernate.entity(Directory.class)).
                    setParameter("name", pathElements[i]).
                    setMaxResults(1).list();
            if (subdirectory.size() > 0) {
View Full Code Here
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
                "select person.name, person.id from person in "
                + "class org.nxplanner.domain.Person where person.hidden = 0";

        HashMap names = new HashMap();
        try {
            Session session = GlobalSessionFactory.get().openSession();
            try {
                names.clear();
                List nameResults = session.find(namesQuery);
                Iterator iter = nameResults.iterator();
                while (iter.hasNext()) {
                    Object[] result = (Object[])iter.next();
                    names.put(result[1], result[0]);
                }

                developerMetrics.clear();
                List acceptedTasks =
                        session.find(acceptedTaskQuery, new Integer(userStoryId), Hibernate.INTEGER);
                Iterator acceptedTaskIter = acceptedTasks.iterator();
                while (acceptedTaskIter.hasNext()) {
                    Object[] result = (Object[])acceptedTaskIter.next();
                    double acceptedHours = toDouble(result[2]);
                    if (acceptedHours > 0.0) {
                        getDeveloperMetrics(
                                (String)names.get(result[1]),
                                toInt(result[1]),
                                userStoryId).setAcceptedHours(
                                        acceptedHours);
                    }
                }

                totalHours = 0.0;
                maxDeveloperHours = 0.0;
                List hoursResults = session.find(hoursQuery, new Integer(userStoryId), Hibernate.INTEGER);
                Iterator hoursIterator = hoursResults.iterator();
                while (hoursIterator.hasNext()) {
                    Object[] result = (Object[])hoursIterator.next();
                    int person1Id = toInt(result[0]);
                    int person2Id = toInt(result[1]);
                    Date startTime = (Date)result[2];
                    Date endTime = (Date)result[3];
                    double duration = toDouble(result[5]);
                    if ((endTime != null && startTime != null) || duration != 0) {
                        double hours =
                                duration == 0 ? (endTime.getTime() - startTime.getTime()) / 3600000.0 : duration;
                        boolean isPaired = person1Id != 0 && person2Id != 0;
                        if (person1Id != 0) {
                            updateWorkedHours(
                                    userStoryId,
                                    (String)names.get(result[0]),
                                    person1Id,
                                    hours,
                                    isPaired
                            );
                            totalHours += hours;
                        }
                        if (person2Id != 0) {
                            updateWorkedHours(
                                    userStoryId,
                                    (String)names.get(result[1]),
                                    person2Id,
                                    hours,
                                    isPaired
                            );
                            totalHours += hours;
                        }
                    }
                }
            } catch (Exception ex) {
                if (session.isConnected()) {
                    session.connection().rollback();
                }
                log.error("error", ex);
            } finally {
                session.close();
            }
        } catch (Exception ex) {
            log.error("error", ex);
        }
    }
View Full Code Here
TOP

Related Classes of net.sf.hibernate.Session

  • au.edu.qut.yawl.servicePersistence.DBSessionMngr
  • au.edu.qut.yawl.worklist.model.WorklistDBConnector
  • cash.util.HibernateUtil
  • com.javaeye.jert.service.test.DrillDownColumnServiceTest
  • com.javaeye.jert.service.test.TestService
  • com.opensymphony.xwork.interceptor.OpenSessionInXWorkInterceptor
  • net.mlw.vlh.adapter.hibernate.Hibernate20Adapter
  • org.apache.turbine.util.hibernate.HibernateFilter
  • org.apache.turbine.util.hibernate.HibernateUtils
  • org.infoglue.cms.controllers.kernel.impl.simple.WorkflowController
    • Copyright © 2018 www.massapicom. All rights reserved.
    All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.