title: could not initialize proxy - no Session Exception
body: <p>I am working on the project which is based on hibernate and spring. I have spent two days but can't figure out why the "lazy exception" error is coming when i call this piece of code: </p>
  
  <pre><code>public MemberUser SendEmail(MemberUser user) throws MailSendingException {
      // Check if password will be sent by mail
      // Hibernate.initialize(user);
      user = fetchService.fetch(user, FETCH);
      // user = userDao.load(user.getId(), FETCH);
      final MemberGroup group = user.getMember().getMemberGroup();
      final boolean sendPasswordByEmail = group.getMemberSettings().isSendPasswordByEmail();
  
      String newPassword = null;
      if (sendPasswordByEmail) {
        // If send by mail, generate a new password
        newPassword = generatePassword(group);
      }
  
      // Update the user
      user.setPassword(hashHandler.hash(user.getSalt(), newPassword));
      user.setPasswordDate(null);
      userDao.update(user);
  
      if (sendPasswordByEmail) {
        // Send the password by mail
        mailHandler.sendResetPassword(user.getMember(), newPassword);
      }
      return user;
    }
  </code></pre>
  
  <p>This code is basically sending the email to the user for reset password after getting the user information from the db.
  Exception comes at "user= fetchService.fetch(user, FETCH)", while FETCH is :</p>
  
  <pre><code>private static final Relationship FETCH = RelationshipHelper.nested(User.Relationships.ELEMENT,
        Element.Relationships.GROUP);
  </code></pre>
  
  <p>This is the code of the fetch function ,when the fetch is called this is executed:</p>
  
  <pre><code>@Override
  public &lt;E extends Entity&gt; List&lt;E&gt; fetch(final Collection&lt;E&gt; entities, final Relationship... fetch) {
      if (entities == null) {
          return null;
      }
      final List&lt;E&gt; result = new ArrayList&lt;E&gt;(entities.size());
      for (E entity : entities) {
          entity = fetch(entity, fetch);
          result.add(entity);
      }
      return result;
  }
  </code></pre>
  
  <p>These are hibernate classes but I don't have a grip on these .</p>
  
  <pre><code>public class HibernateHelper {
      */
      public static class QueryParameter {
          private final Object value;
          private final String operator;
  
          public QueryParameter(final Object value, final String operator) {
              this.value = value;
              this.operator = operator;
          }
  
          public String getOperator() {
              return operator;
          }
  
          public Object getValue() {
              return value;
          }
      }
  
  
      private static Map&lt;Class&lt;? extends Entity&gt;, Set&lt;String&gt;&gt; directPropertiesCache = new HashMap&lt;Class&lt;? extends Entity&gt;, Set&lt;String&gt;&gt;();
  
  
      public static void addInElementsParameter(final StringBuilder hql, final Map&lt;String, Object&gt; namedParameters, final String path, final Entity value) {
          if (value != null &amp;&amp; value.isPersistent()) {
              final String parameterName = getParameterName(namedParameters, path);
              hql.append(" and :").append(parameterName).append(" in elements(").append(path).append(") ");
              namedParameters.put(parameterName, value);
          }
      }   public static void addInParameterToQuery(final StringBuilder hql, final Map&lt;String, Object&gt; namedParameters, final String path, final Collection&lt;?&gt; values) {
          if (values != null &amp;&amp; !values.isEmpty()) {
              final String parameterName = getParameterName(namedParameters, path);
              hql.append(" and ").append(path).append(" in (:").append(parameterName).append(") ");
              namedParameters.put(parameterName, values);
          }
      }
  
      /**
       * Adds an "in" operator parameter to the HQL query, if the given value is not empty, appending the values to the named parameters map
       */
      public static void addInParameterToQuery(final StringBuilder hql, final Map&lt;String, Object&gt; namedParameters, final String path, final Object... values) {
          if (values != null &amp;&amp; values.length &gt; 0) {
              addInParameterToQuery(hql, namedParameters, path, Arrays.asList(values));
          }
      }
  
      /**
       * Adds a 'path like %value%' parameter to the HQL query if the given value is not empty, appending the value to the named parameters map
       */
      public static void addLikeParameterToQuery(final StringBuilder hql, final Map&lt;String, Object&gt; namedParameters, final String path, final String value) {
          doAddLike(hql, namedParameters, path, value, false);
      }
  
      /**
       * Adds a equals parameter to the HQL query, if the given value is not empty, appending the value to the named parameters map
       */
      public static void addParameterToQuery(final StringBuilder hql, final Map&lt;String, Object&gt; namedParameters, final String path, final Object value) {
          addParameterToQueryOperator(hql, namedParameters, path, "=", value);
      }
  
      /**
       * Adds a custom parameter to the HQL query, if the given parameter is not empty, appending the value to the named parameters map
       */
      public static void addParameterToQuery(final StringBuilder hql, final Map&lt;String, Object&gt; namedParameters, final String path, final QueryParameter parameter) {
          if (parameter != null) {
              addParameterToQueryOperator(hql, namedParameters, path, parameter.getOperator(), parameter.getValue());
          }
      }
  
      /**
       * Adds a custom operator parameter to the HQL query, if the given value is not empty, appending the value to the named parameters map
       */
      public static void addParameterToQueryOperator(final StringBuilder hql, final Map&lt;String, Object&gt; namedParameters, final String path, final String operator, final Object value) {
          if (value != null &amp;&amp; !"".equals(value)) {
              final String parameterName = getParameterName(namedParameters, path);
              hql.append(" and ").append(path).append(" ").append(operator).append(" :").append(parameterName).append(" ");
              namedParameters.put(parameterName, value);
          }
      }
  
      /**
       * Adds a period test to the HQL query, if the given period is not empty, appending the value to the named parameters map. See {@link Period}, as
       * it controls whether the begin and end dates are inclusive / exclusive.
       * 
       */
      public static void addPeriodParameterToQuery(final StringBuilder hql, final Map&lt;String, Object&gt; namedParameters, final String path, final Period period) {
          addParameterToQuery(hql, namedParameters, path, getBeginParameter(period));
          addParameterToQuery(hql, namedParameters, path, getEndParameter(period));
      }
  
      /**
       * Adds a 'path like value%' parameter to the HQL query if the given value is not empty, appending the value to the named parameters map
       */
      public static void addRightLikeParameterToQuery(final StringBuilder hql, final Map&lt;String, Object&gt; namedParameters, final String path, final String value) {
          doAddLike(hql, namedParameters, path, value, true);
      }
  
      /**
       * Appends the join portion on the query to fetch the specified relationships, when appliable
       */
      public static void appendJoinFetch(final StringBuilder hql, final Class&lt;? extends Entity&gt; entityType, final String entityAlias, final Collection&lt;Relationship&gt; fetch) {
          if (fetch != null) {
              final Set&lt;String&gt; directRelationships = getDirectRelationshipProperties(entityType, fetch);
  
              for (final String directRelationship : directRelationships) {
                  hql.append(" left join fetch ").append(entityAlias).append(".").append(directRelationship).append(" ");
              }
          }
      }
  
      /**
       * Appends the order by portion, with the given path lists (with an optional direction, ie: "e.date desc", "e.name", "x.name")
       */
      public static void appendOrder(final StringBuilder hql, final Collection&lt;String&gt; paths) {
          if (CollectionUtils.isNotEmpty(paths)) {
              hql.append(" order by " + StringUtils.join(paths.iterator(), ","));
          }
      }
  
      /**
       * Appends the order by portion, with the given path lists (with an optional direction, ie: "e.date desc", "e.name", "x.name")
       */
      public static void appendOrder(final StringBuilder hql, final String... paths) {
          if (paths != null &amp;&amp; paths.length &gt; 0) {
              appendOrder(hql, Arrays.asList(paths));
          }
      }
  
      /**
       * Returns the begin date of the given period, handling null
       */
      public static QueryParameter getBeginParameter(final Period period) {
          if (period == null) {
              return null;
          }
          Calendar begin = period.getBegin();
          if (begin == null) {
              return null;
          }
          // We must consider the time when explicitly set
          if (!period.isUseTime()) {
              // Truncate the begin date
              begin = DateHelper.truncate(begin);
          }
          String operator = period.isInclusiveBegin() ? "&gt;=" : "&gt;";
          return new QueryParameter(begin, operator);
      }
  
      /**
       * Returns the end date of the given period, handling null
       */
      public static QueryParameter getEndParameter(final Period period) {
          if (period == null) {
              return null;
          }
          Calendar end = period.getEnd();
          if (end == null) {
              return null;
          }
          // We must consider the time when explicitly set
          if (!period.isUseTime()) {
              // Truncate the end date and set the next day
              end = DateHelper.getDayEnd(end);
          }
          String operator = period.isInclusiveEnd() ? "&lt;=" : "&lt;";
          return new QueryParameter(end, operator);
      }
  
      /**
       * Returns a StringBuilder containing the begin of a single entity select HQL
       * @param entityType The entity type to search
       * @param entityAlias The entity alias on the query
       * @return The StringBuiler
       */
      public static StringBuilder getInitialQuery(final Class&lt;? extends Entity&gt; entityType, final String entityAlias) {
          return getInitialQuery(entityType, entityAlias, null);
      }
  
      /**
       * Returns a StringBuilder containing the begin of a single entity select HQL, with the especified fetch relationships, when appliable
       * @param entityType The entity type to search
       * @param entityAlias The entity alias on the query
       * @param fetch The relationships to fetch
       * @return The StringBuiler
       */
      public static StringBuilder getInitialQuery(final Class&lt;? extends Entity&gt; entityType, final String entityAlias, final Collection&lt;Relationship&gt; fetch) {
          final StringBuilder hql = new StringBuilder(" from ").append(entityType.getName()).append(" ").append(entityAlias).append(" ");
          appendJoinFetch(hql, entityType, entityAlias, fetch);
          hql.append(" where 1=1 ");
          return hql;
      }
  
      private static void doAddLike(final StringBuilder hql, final Map&lt;String, Object&gt; namedParameters, final String path, String value, final boolean rightOnly) {
          value = StringUtils.trimToNull(value);
          if (value == null) {
              return;
          }
          // Remove any manually entered '%'
          value = StringUtils.trimToNull(StringUtils.replace(value, "%", ""));
          if (value == null) {
              return;
          }
          // Assuming the default database collation is case insensitive, we don't need to perform case transformations
          if (rightOnly) {
              value += "%";
          } else {
              value = "%" + value + "%";
          }
          addParameterToQueryOperator(hql, namedParameters, path, "like", value);
      }
  
      /**
       * Returns a set of properties that will be fetched directly on the HQL
       */
      private static Set&lt;String&gt; getDirectRelationshipProperties(final Class&lt;? extends Entity&gt; entityType, final Collection&lt;Relationship&gt; fetch) {
          // Populate the direct properties cache for this entity if not yet exists
          Set&lt;String&gt; cachedDirectProperties = directPropertiesCache.get(entityType);
          if (cachedDirectProperties == null) {
              cachedDirectProperties = new HashSet&lt;String&gt;();
              final PropertyDescriptor[] propertyDescriptors = PropertyUtils.getPropertyDescriptors(entityType);
              // Scan for child -&gt; parent relationships
              for (final PropertyDescriptor descriptor : propertyDescriptors) {
                  if (descriptor.getReadMethod() != null &amp;&amp; descriptor.getWriteMethod() != null &amp;&amp; Entity.class.isAssignableFrom(descriptor.getPropertyType())) {
                      // This is a child -&gt; parent relationship. Add it to the cache
                      cachedDirectProperties.add(descriptor.getName());
                  }
              }
              directPropertiesCache.put(entityType, cachedDirectProperties);
          }
  
          // Build the properties to add to HQL fetch from a given relationship set
          final Set&lt;String&gt; propertiesToAddToFetch = new HashSet&lt;String&gt;();
          for (final Relationship relationship : fetch) {
              final String name = PropertyHelper.firstProperty(relationship.getName());
              if (cachedDirectProperties.contains(name)) {
                  propertiesToAddToFetch.add(name);
              }
          }
          return propertiesToAddToFetch;
      }
  
      /**
       * Generates a parameter name
       */
      private static String getParameterName(final Map&lt;String, Object&gt; namedParameters, final String propertyName) {
          int counter = 1;
  
          // Transform the property in a valid identifier
          final StringBuilder sb = new StringBuilder(propertyName.length());
          for (int i = 0, len = propertyName.length(); i &lt; len; i++) {
              final char c = propertyName.charAt(i);
              if (Character.isJavaIdentifierPart(c)) {
                  sb.append(c);
              } else {
                  sb.append('_');
              }
          }
  
          final String field = sb.toString();
          String parameterName = field.concat("_1");
          while (namedParameters.containsKey(parameterName)) {
              parameterName = field.concat("_").concat(String.valueOf(++counter));
          }
          return parameterName;
      }
  
  }
  </code></pre>
  
  <p>This is the error:</p>
  
  <pre><code>org.hibernate.LazyInitializationException: could not initialize proxy - no Session
      at org.hibernate.proxy.AbstractLazyInitializer.initialize(AbstractLazyInitializer.java:167)
      at nl.strohalm.cyclos.utils.hibernate.HibernateQueryHandler.initialize(HibernateQueryHandler.java:252)
      at nl.strohalm.cyclos.dao.FetchDAOImpl.doFetch(FetchDAOImpl.java:80)
      at nl.strohalm.cyclos.dao.FetchDAOImpl.fetch(FetchDAOImpl.java:37)
      at nl.strohalm.cyclos.services.fetch.FetchServiceImpl.fetch(FetchServiceImpl.java:45)
      at nl.strohalm.cyclos.services.access.AccessServiceImpl.SendEmail(AccessServiceImpl.java:1695)
      at nl.strohalm.cyclos.services.access.AccessServiceImpl.resetPasswordAndSendAfterExpire(AccessServiceImpl.java:1732)
      at com.omnia.payo.scheduling.task.UserLoginInfoSchedulingTask.doRun(UserLoginInfoSchedulingTask.java:43)
      at nl.strohalm.cyclos.scheduling.tasks.BaseScheduledTask.run(BaseScheduledTask.java:42)
      at nl.strohalm.cyclos.utils.tasks.TaskRunnerImpl$4.run(TaskRunnerImpl.java:193)
      at java.util.concurrent.Executors$RunnableAdapter.call(Executors.java:511)
      at nl.strohalm.cyclos.utils.access.LoggedUser.runAsSystem(LoggedUser.java:285)
      at nl.strohalm.cyclos.utils.tasks.TaskRunnerImpl.doRunScheduledTask(TaskRunnerImpl.java:190)
      at nl.strohalm.cyclos.utils.tasks.TaskRunnerImpl.doRunScheduledTask(TaskRunnerImpl.java:170)
      at nl.strohalm.cyclos.utils.tasks.TaskRunnerImpl$ScheduledTaskThreads.process(TaskRunnerImpl.java:64)
      at nl.strohalm.cyclos.utils.tasks.TaskRunnerImpl$ScheduledTaskThreads.process(TaskRunnerImpl.java:1)
      at nl.strohalm.cyclos.utils.ParallelTask$1.process(ParallelTask.java:43)
      at nl.strohalm.cyclos.utils.WorkerThreads$WorkerThread$1.call(WorkerThreads.java:53)
      at nl.strohalm.cyclos.utils.WorkerThreads$WorkerThread$1.call(WorkerThreads.java:1)
      at nl.strohalm.cyclos.utils.access.LoggedUser.runAsSystem(LoggedUser.java:285)
      at nl.strohalm.cyclos.utils.WorkerThreads$WorkerThread.run(WorkerThreads.java:49)
  </code></pre>
  
  <p>Code for doFetch in FetchDAOImpl is:</p>
  
  <pre><code>private &lt;E extends Entity&gt; E doFetch(final E inputEntity, final Relationship... fetch) {
          if (inputEntity == null || inputEntity.getId() == null) {
              throw new UnexpectedEntityException();
          }
          E entity;
  
          // Discover the entity real class and id
          final Class&lt;? extends Entity&gt; entityType = EntityHelper.getRealClass(inputEntity);
          final Long id = inputEntity.getId();
  
          // Load and initialize the entity
          try {
              entity = (E) getHibernateTemplate().load(entityType, id);
              entity = (E) hibernateQueryHandler.initialize(entity);
          } catch (final ObjectRetrievalFailureException e) {
              throw new EntityNotFoundException(entityType, id);
          } catch (final ObjectNotFoundException e) {
              throw new EntityNotFoundException(entityType, id);
          }
  
          // ... and fetch each relationship
          if (!ArrayUtils.isEmpty(fetch)) {
              for (final Relationship relationship : fetch) {
                  if (relationship == null) {
                      continue;
                  }
                  try {
                      final String name = relationship.getName();
                      Object bean = entity;
                      String first = PropertyHelper.firstProperty(name);
                      String nested = PropertyHelper.nestedPath(name);
                      while (bean != null &amp;&amp; first != null) {
                          final Object value = hibernateQueryHandler.initializeProperty(bean, first);
                          bean = value;
                          first = PropertyHelper.firstProperty(nested);
                          nested = PropertyHelper.nestedPath(nested);
                      }
                  } catch (final PropertyException e) {
                      // Ok - nonexisting property. Probably fetching a relationship that only exists in one of the subclasses, and trying to use it no
                      // another one
                  } catch (final Exception e) {
                      throw new PropertyException(entity, relationship.getName(), e);
                  }
              }
          }
          return entity;
      }
  </code></pre>
  
  <p>please someone help me ,i'll be really thankful. </p>