title: Java/Spring - Object references an unsaved transient instance
body: <p>Well, my issue is related to when I try to save an entity (Parade) which has a collection of other entity (AcmeFloat) using the corresponding default CRUD method in convenient repository (the code is attached below). When it reaches the save() method, it throws an exception.</p>
  
  <p>I tried to save the pertinent entities of AcmeFloat class which need to be updated by hand, but, whatever I do (whether save first the Parade updated and later update and save each AcmeFloat or inside out) raises an exception.</p>
  
  <p>So I went into Stack Overflow and the solution I found is putting a 'cascade=CascadeType.ALL' inside the @ManyToMany anotation, without success. I tried also to do both things, which also fails.</p>
  
  <p>Here is the code:</p>
  
  <p>Parade (Domain Class):</p>
  
  <pre><code>package domain;
  
  import java.util.ArrayList;
  import java.util.Collection;
  import java.util.Date;
  
  import javax.persistence.Access;
  import javax.persistence.AccessType;
  import javax.persistence.Basic;
  import javax.persistence.CascadeType;
  import javax.persistence.Column;
  import javax.persistence.Entity;
  import javax.persistence.ManyToMany;
  import javax.persistence.ManyToOne;
  import javax.persistence.Temporal;
  import javax.persistence.TemporalType;
  import javax.validation.Valid;
  import javax.validation.constraints.Pattern;
  
  import org.hibernate.validator.constraints.NotBlank;
  import org.springframework.format.annotation.DateTimeFormat;
  
  @Entity
  @Access(AccessType.PROPERTY)
  public class Parade extends DomainEntity {
  
      // Fields -----------------------------------------------------------------
  
      private String                  title;
      private String                  description;
      private Date                    moment;
      private String                  ticker;
      private boolean                 isDraft;
  
      // Relationships ----------------------------------------------------------
  
      private Brotherhood             brotherhood;
      private Collection&lt;AcmeFloat&gt;   acmeFloats;
  
  
      // Field access methods ---------------------------------------------------
  
      @NotBlank
      public String getTitle() {
          return this.title;
      }
  
      public void setTitle(final String title) {
          this.title = title;
      }
  
      @NotBlank
      public String getDescription() {
          return this.description;
      }
  
      public void setDescription(final String description) {
          this.description = description;
      }
  
      @Temporal(TemporalType.TIMESTAMP)
      @DateTimeFormat(pattern = "dd/MM/yyyy HH:mm")
      public Date getMoment() {
          return this.moment;
      }
  
      public void setMoment(final Date moment) {
          this.moment = moment;
      }
  
      @NotBlank
      @Pattern(regexp = "^([\\d]){6}-([A-Z]){5}$")
      @Column(unique = true)
      public String getTicker() {
          return this.ticker;
      }
  
      public void setTicker(final String ticker) {
          this.ticker = ticker;
      }
  
      @Basic
      public boolean getIsDraft() {
          return this.isDraft;
      }
  
      public void setIsDraft(final boolean isDraft) {
          this.isDraft = isDraft;
      }
  
      // Relationship access methods --------------------------------------------
  
      @Valid
      @ManyToOne(optional = true)
      public Brotherhood getBrotherhood() {
          return this.brotherhood;
      }
  
      public void setBrotherhood(final Brotherhood brotherhood) {
          this.brotherhood = brotherhood;
      }
  
      @Valid
      @ManyToMany(mappedBy = "parades", cascade = CascadeType.ALL)
      public Collection&lt;AcmeFloat&gt; getAcmeFloats() {
          return new ArrayList&lt;AcmeFloat&gt;(this.acmeFloats);
      }
  
      public void setAcmeFloats(final Collection&lt;AcmeFloat&gt; acmeFloats) {
          this.acmeFloats = acmeFloats;
      }
  
  }
  </code></pre>
  
  <p>AcmeFloat (Domain Class):</p>
  
  <pre><code>package domain;
  
  import java.util.ArrayList;
  import java.util.Collection;
  import java.util.List;
  
  import javax.persistence.Access;
  import javax.persistence.AccessType;
  import javax.persistence.CascadeType;
  import javax.persistence.ElementCollection;
  import javax.persistence.Entity;
  import javax.persistence.ManyToMany;
  import javax.persistence.ManyToOne;
  import javax.validation.Valid;
  import javax.validation.constraints.NotNull;
  
  import org.hibernate.validator.constraints.NotBlank;
  
  @Entity
  @Access(AccessType.PROPERTY)
  public class AcmeFloat extends DomainEntity {
  
      // Fields -----------------------------------------------------------------
  
      private String              title;
      private String              description;
      private List&lt;String&gt;        pictures;
  
      // Relationships ----------------------------------------------------------
  
      private Collection&lt;Parade&gt;  parades;
      private Brotherhood         brotherhood;
  
  
      // Field access methods ---------------------------------------------------
  
      @NotNull
      @NotBlank
      public String getTitle() {
          return this.title;
      }
  
      public void setTitle(final String title) {
          this.title = title;
      }
  
      @NotNull
      @NotBlank
      public String getDescription() {
          return this.description;
      }
  
      public void setDescription(final String description) {
          this.description = description;
      }
  
      //Optional
      //@URL
      @NotNull
      @ElementCollection
      public List&lt;String&gt; getPictures() {
          return this.pictures;
      }
  
      public void setPictures(final List&lt;String&gt; pictures) {
          this.pictures = pictures;
      }
  
      // Relationship access methods --------------------------------------------
  
      @ManyToMany(cascade = CascadeType.ALL)
      @Valid
      public Collection&lt;Parade&gt; getParades() {
          return this.parades;
      }
  
      public void setParades(final Collection&lt;Parade&gt; parades) {
          this.parades = new ArrayList&lt;Parade&gt;(parades);
      }
      @ManyToOne
      @Valid
      public Brotherhood getBrotherhood() {
          return this.brotherhood;
      }
  
      public void setBrotherhood(final Brotherhood brotherhood) {
          this.brotherhood = brotherhood;
      }
  
  }
  </code></pre>
  
  <p>ParadeForm (Form Object):</p>
  
  <pre><code>package forms;
  
  import java.util.Collection;
  import java.util.Date;
  
  import javax.persistence.Temporal;
  import javax.persistence.TemporalType;
  import javax.validation.constraints.NotNull;
  
  import org.hibernate.validator.constraints.NotBlank;
  import org.hibernate.validator.constraints.Range;
  import org.springframework.format.annotation.DateTimeFormat;
  
  import domain.AcmeFloat;
  
  public class ParadeForm {
  
      // Fields -----------------------------------------------------------------
  
      private int                     id;
  
      private String                  title;
      private String                  description;
      private Date                    moment;
  
      // Relationships ----------------------------------------------------------
  
      private Collection&lt;AcmeFloat&gt;   acmeFloats;
  
  
      // Field access methods ---------------------------------------------------
  
      @Range(min = 0)
      public int getId() {
          return this.id;
      }
  
      public void setId(final int id) {
          this.id = id;
      }
  
      @NotBlank
      public String getTitle() {
          return this.title;
      }
  
      public void setTitle(final String title) {
          this.title = title;
      }
  
      @NotBlank
      public String getDescription() {
          return this.description;
      }
  
      public void setDescription(final String description) {
          this.description = description;
      }
  
      @Temporal(TemporalType.TIMESTAMP)
      @DateTimeFormat(pattern = "dd/MM/yyyy HH:mm")
      public Date getMoment() {
          return this.moment;
      }
  
      public void setMoment(final Date moment) {
          this.moment = moment;
      }
  
      // Relationship access methods --------------------------------------------
  
      @NotNull
      public Collection&lt;AcmeFloat&gt; getAcmeFloats() {
          return this.acmeFloats;
      }
  
      public void setAcmeFloats(final Collection&lt;AcmeFloat&gt; acmeFloats) {
          this.acmeFloats = acmeFloats;
      }
  
  }
  </code></pre>
  
  <p>ParadeRepository:</p>
  
  <pre><code>package repositories;
  
  import java.util.Date;
  import java.util.List;
  
  import org.springframework.data.jpa.repository.JpaRepository;
  import org.springframework.data.jpa.repository.Query;
  import org.springframework.stereotype.Repository;
  
  import domain.Parade;
  
  @Repository
  public interface ParadeRepository extends JpaRepository&lt;Parade, Integer&gt; {
  
      @Query("select p from Parade p where p.ticker like ?1")
      List&lt;Parade&gt; findByTicker(String ticker);
  
      @Query("select p from Parade p where p.moment &lt; ?1 and p.isDraft = false")
      List&lt;Parade&gt; findBeforeDate(Date date);
  
      @Query("select p from Parade p where p.isDraft = false")
      List&lt;Parade&gt; findAllFinal();
  
      @Query("select p from Parade p where p.isDraft = false and brotherhood.userAccount.id = ?1")
      List&lt;Parade&gt; findAllFinalByBrotherhoodAccountId(int id);
  
      @Query("select p from Parade p where brotherhood.userAccount.id = ?1")
      List&lt;Parade&gt; findAllByBrotherhoodAccountId(int id);
  
      @Query("select p from Parade p join p.brotherhood.enrolments e where e.member.id= ?1")
      List&lt;Parade&gt; findPossibleMemberParades(int id);
  
  }
  </code></pre>
  
  <p>AcmeFloatRepository:</p>
  
  <pre><code>package repositories;
  
  import java.util.Collection;
  
  import org.springframework.data.jpa.repository.JpaRepository;
  import org.springframework.data.jpa.repository.Query;
  import org.springframework.stereotype.Repository;
  
  import domain.AcmeFloat;
  
  @Repository
  public interface AcmeFloatRepository extends JpaRepository&lt;AcmeFloat, Integer&gt; {
  
      @Query("select f from AcmeFloat f where f.brotherhood.userAccount.id = ?1")
      Collection&lt;AcmeFloat&gt; findAcmeFloats(int principalId);
  
  }
  </code></pre>
  
  <p>ParadeService:</p>
  
  <pre><code>package services;
  
  import java.util.ArrayList;
  import java.util.Calendar;
  import java.util.Date;
  import java.util.GregorianCalendar;
  import java.util.List;
  import java.util.Random;
  
  import javax.validation.ValidationException;
  
  import org.springframework.beans.factory.annotation.Autowired;
  import org.springframework.stereotype.Service;
  import org.springframework.transaction.annotation.Transactional;
  import org.springframework.util.Assert;
  import org.springframework.validation.BindingResult;
  import org.springframework.validation.Validator;
  
  import repositories.ParadeRepository;
  import security.LoginService;
  import domain.AcmeFloat;
  import domain.Parade;
  import forms.ParadeForm;
  
  @Service
  @Transactional
  public class ParadeService {
  
      ////////////////////////////////////////////////////////////////////////////////
      // Managed repository
  
      @Autowired
      private ParadeRepository    paradeRepository;
  
      ////////////////////////////////////////////////////////////////////////////////
      // Supporting services
  
      @Autowired
      private BrotherhoodService      brotherhoodService;
  
      ////////////////////////////////////////////////////////////////////////////////
      // Supporting services
  
      @Autowired
      private Validator               validator;
  
      ////////////////////////////////////////////////////////////////////////////////
      // Ticker generation fields
  
      private static final String     TICKER_ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
      private static final int        TICKER_LENGTH   = 5;
      private final Random            random          = new Random();
  
  
      ////////////////////////////////////////////////////////////////////////////////
      // Constructors
  
      public ParadeService() {
          super();
      }
  
      ////////////////////////////////////////////////////////////////////////////////
      // CRUD methods
  
      public Parade create() {
          final Parade parade = new Parade();
          parade.setBrotherhood(this.brotherhoodService.findByUserAccountId(LoginService.getPrincipal().getId()));
          parade.setAcmeFloats(new ArrayList&lt;AcmeFloat&gt;());
          parade.setIsDraft(true);
          parade.setDescription("");
          parade.setTitle("");
          if (parade.getTicker() == null || parade.getTicker().isEmpty()) {
              final Calendar calendar = new GregorianCalendar();
              String dateString = "";
              dateString += String.format("%02d", calendar.get(Calendar.YEAR) % 100);
              dateString += String.format("%02d", calendar.get(Calendar.MONTH) + 1);
              dateString += String.format("%02d", calendar.get(Calendar.DAY_OF_MONTH));
              dateString += "-";
              String ticker;
              do {
                  ticker = dateString;
                  for (int i = 0; i &lt; ParadeService.TICKER_LENGTH; ++i)
                      ticker += ParadeService.TICKER_ALPHABET.charAt(this.random.nextInt(ParadeService.TICKER_ALPHABET.length()));
              } while (this.paradeRepository.findByTicker(ticker).size() &gt; 0);
              parade.setTicker(ticker);
          }
  
          return parade;
      }
  
      public Parade save(final Parade parade) {
          Assert.notNull(parade);
          //final Parade originalParade = this.paradeRepository.findOne(parade.getId());
          //if (originalParade != null)
          Assert.isTrue(parade.getIsDraft());
          Assert.isTrue(parade.getMoment().after(new Date()));
  
          //TODO: if ticker existe en BBDD, generar nuevo, else, se guarda
          return this.paradeRepository.save(parade);
      }
      public void delete(final Parade parade) {
          Assert.notNull(parade);
          Assert.isTrue(parade.getIsDraft());
  
          this.paradeRepository.delete(parade);
      }
      public Parade findOne(final int id) {
          return this.paradeRepository.findOne(id);
      }
  
      public List&lt;Parade&gt; findAll() {
          return this.paradeRepository.findAll();
      }
  
      ////////////////////////////////////////////////////////////////////////////////
      // Ancillary methods
  
      public List&lt;Parade&gt; findWithin30Days() {
          final Calendar calendar = Calendar.getInstance();
          calendar.setTime(new Date());
          calendar.add(Calendar.DATE, 30);
          final Date plus30Days = calendar.getTime();
          return this.paradeRepository.findBeforeDate(plus30Days);
      }
  
      public List&lt;Parade&gt; findAllByBrotherhoodAccountId(final int id) {
          return this.paradeRepository.findAllByBrotherhoodAccountId(id);
      }
  
      public List&lt;Parade&gt; findAllFinalByBrotherhoodAccountId(final int id) {
          return this.paradeRepository.findAllFinalByBrotherhoodAccountId(id);
      }
  
      public List&lt;Parade&gt; findAllFinal() {
          return this.paradeRepository.findAllFinal();
      }
  
      public List&lt;Parade&gt; findPossibleMemberParades(final int memberId) {
          return this.paradeRepository.findPossibleMemberParades(memberId);
      }
  
      public Parade reconstruct(final ParadeForm paradeForm, final BindingResult binding) {
          Parade result;
  
          if (paradeForm.getId() == 0)
              result = this.create();
          else
              result = this.paradeRepository.findOne(paradeForm.getId());
  
          result.setTitle(paradeForm.getTitle());
          result.setDescription(paradeForm.getDescription());
          result.setMoment(paradeForm.getMoment());
          result.setAcmeFloats(paradeForm.getAcmeFloats());
  
          this.validator.validate(result, binding);
          this.paradeRepository.flush();
          if (binding.hasErrors())
              throw new ValidationException();
  
          return result;
      }
  
  }
  </code></pre>
  
  <p>AcmeFloatService:</p>
  
  <pre><code>package services;
  
  import java.util.ArrayList;
  import java.util.Collection;
  import java.util.List;
  
  import org.springframework.beans.factory.annotation.Autowired;
  import org.springframework.stereotype.Service;
  import org.springframework.transaction.annotation.Transactional;
  import org.springframework.util.Assert;
  
  import repositories.AcmeFloatRepository;
  import domain.AcmeFloat;
  import domain.Parade;
  
  @Service
  @Transactional
  public class AcmeFloatService {
  
      ////////////////////////////////////////////////////////////////////////////////
      // Managed repository
  
      @Autowired
      private AcmeFloatRepository acmeFloatRepository;
  
  
      ////////////////////////////////////////////////////////////////////////////////
      // Supporting services
  
      ////////////////////////////////////////////////////////////////////////////////
      // Constructors
  
      public AcmeFloatService() {
          super();
      }
  
      ////////////////////////////////////////////////////////////////////////////////
      // CRUD methods
  
      public AcmeFloat create() {
          final AcmeFloat result = new AcmeFloat();
  
          // set fields
          result.setTitle("");
          result.setDescription("");
          result.setPictures(new ArrayList&lt;String&gt;());
          // set relationships
          result.setParades(new ArrayList&lt;Parade&gt;());
          result.setBrotherhood(null);
  
          return result;
      }
  
      public AcmeFloat save(final AcmeFloat acmeFloat) {
          Assert.isTrue(acmeFloat != null);
          return this.acmeFloatRepository.save(acmeFloat);
      }
  
      public Iterable&lt;AcmeFloat&gt; save(final Iterable&lt;AcmeFloat&gt; acmeFloats) {
          Assert.isTrue(acmeFloats != null);
          return this.acmeFloatRepository.save(acmeFloats);
      }
  
      public void delete(final AcmeFloat acmeFloat) {
          Assert.isTrue(acmeFloat != null);
          this.acmeFloatRepository.delete(acmeFloat);
      }
  
      public void delete(final Iterable&lt;AcmeFloat&gt; acmeFloats) {
          Assert.isTrue(acmeFloats != null);
          this.acmeFloatRepository.delete(acmeFloats);
      }
  
      public AcmeFloat findOne(final int id) {
          return this.acmeFloatRepository.findOne(id);
      }
  
      public List&lt;AcmeFloat&gt; findAll() {
          return this.acmeFloatRepository.findAll();
      }
  
      ////////////////////////////////////////////////////////////////////////////////
      // Ancillary methods
  
      public Collection&lt;AcmeFloat&gt; findAcmeFloats(final int id) {
          return this.acmeFloatRepository.findAcmeFloats(id);
      }
  
  }
  </code></pre>
  
  <p>ParadeController:</p>
  
  <pre><code>package controllers;
  
  import java.util.Collection;
  import javax.validation.Valid;
  import javax.validation.ValidationException;
  
  import org.springframework.beans.factory.annotation.Autowired;
  import org.springframework.stereotype.Controller;
  import org.springframework.util.Assert;
  import org.springframework.validation.BindingResult;
  import org.springframework.web.bind.annotation.ModelAttribute;
  import org.springframework.web.bind.annotation.RequestMapping;
  import org.springframework.web.bind.annotation.RequestMethod;
  import org.springframework.web.bind.annotation.RequestParam;
  import org.springframework.web.servlet.ModelAndView;
  
  import security.LoginService;
  import security.UserAccount;
  import services.AcmeFloatService;
  import services.BrotherhoodService;
  import services.ParadeService;
  import domain.AcmeFloat;
  import domain.Brotherhood;
  import domain.Parade;
  import forms.ParadeForm;
  
  @Controller
  @RequestMapping("/parade")
  public class ParadeController extends AbstractController {
  
      // Services ---------------------------------------------------------------
  
      @Autowired
      private ParadeService       paradeService;
  
      @Autowired
      private BrotherhoodService  brotherhoodService;
  
      @Autowired
      private AcmeFloatService    acmeFloatService;
  
  
      // Constructors -----------------------------------------------------------
  
      public ParadeController() {
  
      }
  
      // List -------------------------------------------------------------------
  
      @RequestMapping(value = "/brotherhood/list", method = RequestMethod.GET)
      public ModelAndView list() {
          final ModelAndView result;
          Collection&lt;Parade&gt; parades;
  
          parades = this.paradeService.findAllByBrotherhoodAccountId(LoginService.getPrincipal().getId());
  
          result = new ModelAndView("parade/brotherhood/list");
          result.addObject("parades", parades);
          result.addObject("requestURI", "parade/brotherhood/list.do");
  
          return result;
      }
  
      // Create -----------------------------------------------------------------
  
      @RequestMapping(value = "/brotherhood/create", method = RequestMethod.GET)
      public ModelAndView create() {
          final ModelAndView result;
          Parade parade;
  
          parade = this.paradeService.create();
          parade.setIsDraft(true);
          result = this.createEditModelAndView(parade, "create");
  
          return result;
      }
  
      // Edit -------------------------------------------------------------------
  
      @RequestMapping(value = "/brotherhood/edit", method = RequestMethod.GET)
      public ModelAndView edit(@RequestParam final int paradeId) {
          ModelAndView result;
          Parade parade;
  
          parade = this.paradeService.findOne(paradeId);
          Assert.notNull(parade);
          result = this.createEditModelAndView(parade, "edit");
  
          return result;
      }
  
      // Save -------------------------------------------------------------------
  
      @RequestMapping(value = "/brotherhood/edit", method = RequestMethod.POST, params = "save")
      public ModelAndView save(@ModelAttribute("parade") final ParadeForm paradeForm, final BindingResult binding) {
          ModelAndView result;
          Parade parade;
          Parade oldParade;
  
          parade = this.paradeService.reconstruct(paradeForm, binding);
          oldParade = this.paradeService.findOne(paradeForm.getId());
  
          try {
               for(AcmeFloat f : parade.getAcmeFloats()){
                  Collection&lt;Parade&gt; parades = f.getParades();
                  parades.add(parade);
                  f.setParades(parades);
                  this.acmeFloatService.save(f);
              }
              if(parade.getId() != 0){
                  Collection&lt;AcmeFloat&gt; paradesRemoved = oldParade.getAcmeFloats();
                  paradesRemoved.removeAll(parade.getAcmeFloats());
                  for(AcmeFloat f : paradesRemoved){
                      final Collection&lt;Parade&gt; parades = f.getParades();
                      parades.remove(parade);
                      f.setParades(parades);
                      this.acmeFloatService.save(f);
                  }
              }
              this.paradeService.save(parade);
              result = new ModelAndView("redirect:list.do");
          } catch (final ValidationException oops) {
              result = this.createEditModelAndView(parade, "edit");
          } catch (final Throwable oops) {
              result = this.createEditModelAndView(parade, "parade.commit.error", "edit");
          }
  
          return result;
      }
  
  
  /*
              final Parade paradeUpdated = this.paradeService.reconstruct(paradeForm, binding);
              Collection&lt;AcmeFloat&gt; paradesRemoved = new ArrayList&lt;&gt;();
              if (paradeForm.getId() != 0)
                  paradesRemoved = parade.getAcmeFloats();
              if (paradeUpdated.getId() != 0)
                  paradesRemoved.removeAll(paradeUpdated.getAcmeFloats());
              final Parade paradeSaved = this.paradeService.save(paradeUpdated);
              for (final AcmeFloat f : paradeUpdated.getAcmeFloats()) {
                  final Collection&lt;Parade&gt; parades = f.getParades();
                  parades.add(paradeSaved);
                  f.setParades(parades);
                  this.acmeFloatService.save(f);
              }
              if (paradeUpdated.getId() != 0)
                  for (final AcmeFloat f : paradesRemoved) {
                      final Collection&lt;Parade&gt; parades = f.getParades();
                      parades.remove(parade);
                      f.setParades(parades);
                      this.acmeFloatService.save(f);
  */
  
  
  
      // Delete -----------------------------------------------------------------
  
      @RequestMapping(value = "/brotherhood/edit", method = RequestMethod.POST, params = "delete")
      public ModelAndView delete(final Parade parade, final BindingResult binding) {
          ModelAndView result;
  
          try {
              this.paradeService.delete(parade);
              result = new ModelAndView("redirect:list.do");
          } catch (final Throwable oops) {
              result = this.createEditModelAndView(parade, "parade.commit.error", "edit");
          }
  
          return result;
      }
  
      // Save in Final Mode -----------------------------------------------------
  
      @RequestMapping(value = "/brotherhood/edit", method = RequestMethod.POST, params = "finalMode")
      public ModelAndView finalMode(@Valid final Parade parade, final BindingResult binding) {
          ModelAndView result;
  
          if (binding.hasErrors())
              result = this.createEditModelAndView(parade, "edit");
          else
              try {
                  parade.setIsDraft(false);
                  this.paradeService.save(parade);
                  result = new ModelAndView("redirect:list.do");
              } catch (final Throwable oops) {
                  result = this.createEditModelAndView(parade, "parade.commit.error", "edit");
              }
  
          return result;
      }
  
      // Show -------------------------------------------------------------------
  
      @RequestMapping(value = "/public/show", method = RequestMethod.GET)
      public ModelAndView show(@RequestParam final int paradeId) {
          ModelAndView result;
          Parade parade;
  
          parade = this.paradeService.findOne(paradeId);
          Assert.notNull(parade);
          Assert.isTrue(parade.getIsDraft());
  
          result = new ModelAndView("parade/public/" + "show");
  
          result.addObject("parade", parade);
  
          // result.addObject("messageCode", null);
  
          return result;
      }
  
      // Ancillary Methods ------------------------------------------------------
  
      protected ModelAndView createEditModelAndView(final Parade parade, final String method) {
          ModelAndView result;
  
          result = this.createEditModelAndView(parade, null, method);
  
          return result;
      }
  
      protected ModelAndView createEditModelAndView(final Parade parade, final String messageCode, final String method) {
          final ModelAndView result;
          final Brotherhood brotherhood;
          final Collection&lt;AcmeFloat&gt; acmeFloats;
          final UserAccount userAccount = LoginService.getPrincipal();
  
          brotherhood = this.brotherhoodService.findPrincipal();
          acmeFloats = this.acmeFloatService.findAcmeFloats(userAccount.getId());
  
          result = new ModelAndView("parade/brotherhood/" + method);
          result.addObject("brotherhood", brotherhood);
          result.addObject("acmeFloats", acmeFloats);
  
          result.addObject("parade", parade);
  
          result.addObject("messageCode", messageCode);
  
          return result;
      }
  
  }
  </code></pre>
  
  <p>In the Create case, the flow is the next one: When in the create view after filling form and sending, save() method is called in ParadeController. Its input is a ParadeForm object with id=0. "parade" (the new Parade in this case and the updated Parade in case of edition) and "oldParade" (null in this case but the Parade before the update in update case) objects are created and declared anyway. Then, we go into the try/catch. First, it get the parade's acmeFloats in order to update them adding in their parades collection the just created Parade. But, at first attempt of saving, it throws the following thing:</p>
  
  <pre><code>org.springframework.dao.InvalidDataAccessApiUsageException: org.hibernate.TransientObjectException: object references an unsaved transient instance
  </code></pre>
  
  <p>Saving first the new Parade gives the same results. I was intended to, in case it is an edition (so the Parade existed before and can have had AcmeFloats), find the AcmeFloats that have been removed from the Parade and update them and then save the Parade. So I needed the oldParade in edit case to check which AcmeFloats I have to remove the Parade from.</p>
  
  <p>Also, I don't know whether I have to do all this thing with the cascade in @ManyToMany, but just saving the Parade once reconstructed, but it doesn't work anyway, so I decided to post that part of the code so that you figure out how would it work without the cascade.</p>
  
  <p>I've been having troubles with this issue for the last month and before. Thanks in advance.</p>
  
  <p>EDIT 1:</p>
  
  <p>When I put a flush() after saving in the repository, it throws the following exception at saving:</p>
  
  <pre><code>org.springframework.orm.jpa.JpaSystemException: Exception occurred inside getter of domain.Parade.acmeFloats; nested exception is org.hibernate.PropertyAccessException: Exception occurred inside getter of domain.Parade.acmeFloats
  </code></pre>