[Tutti-commits] 03/05: passage de la persistence en lazy loading

This is an automated email from the git hooks/post-receive script. New commit to branch feature/6417 in repository tutti. See http://git.codelutin.com/tutti.git commit 7d4e97726c3c37fd318ab684b7260878f6b769e0 Author: Tony CHEMIT <chemit@codelutin.com> Date: Fri Jan 9 07:55:46 2015 +0100 passage de la persistence en lazy loading --- .../tutti/persistence/TuttiPersistenceImpl.java | 424 +++++++++++++-------- .../service/AbstractPersistenceService.java | 27 +- .../fr/ifremer/tutti/service/TuttiDataContext.java | 15 +- .../ifremer/tutti/service/ServiceDbResource.java | 4 +- .../catches/WeightComputingServiceTest.java | 3 +- .../fr/ifremer/tutti/ui/swing/TuttiUIContext.java | 9 +- 6 files changed, 305 insertions(+), 177 deletions(-) diff --git a/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/TuttiPersistenceImpl.java b/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/TuttiPersistenceImpl.java index d90c0cc..644d97b 100644 --- a/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/TuttiPersistenceImpl.java +++ b/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/TuttiPersistenceImpl.java @@ -53,6 +53,7 @@ import fr.ifremer.tutti.persistence.entities.referential.Speciess; import fr.ifremer.tutti.persistence.entities.referential.TuttiLocation; import fr.ifremer.tutti.persistence.entities.referential.TuttiReferentialEntity; import fr.ifremer.tutti.persistence.entities.referential.Vessel; +import fr.ifremer.tutti.persistence.service.AbstractPersistenceService; import fr.ifremer.tutti.persistence.service.AccidentalBatchPersistenceService; import fr.ifremer.tutti.persistence.service.AttachmentPersistenceService; import fr.ifremer.tutti.persistence.service.BenthosBatchPersistenceService; @@ -161,37 +162,37 @@ public class TuttiPersistenceImpl implements TuttiPersistence { @Override public void clearAllCaches() { - technicalPersistenceService.clearAllCaches(); + getTechnicalPersistenceService().clearAllCaches(); } @Override public <V> V invoke(Callable<V> call) { - return technicalPersistenceService.invoke(call); + return getTechnicalPersistenceService().invoke(call); } @Override public Version getDbVersion() { - return technicalPersistenceService.getDbVersion(); + return getTechnicalPersistenceService().getDbVersion(); } @Override public Version getApplicationVersion() { - return technicalPersistenceService.getApplicationVersion(); + return getTechnicalPersistenceService().getApplicationVersion(); } @Override public void updateSchema() { - technicalPersistenceService.updateSchema(); + getTechnicalPersistenceService().updateSchema(); } @Override public void sanityDb() { - technicalPersistenceService.sanityDb(); + getTechnicalPersistenceService().sanityDb(); } @Override public boolean isTemporary(TuttiReferentialEntity entity) { - return technicalPersistenceService.isTemporary(entity); + return getTechnicalPersistenceService().isTemporary(entity); } @Override @@ -200,25 +201,25 @@ public class TuttiPersistenceImpl implements TuttiPersistence { log.info("Open persistence driver " + getImplementationName()); } - caracteristicService.init(); - gearService.init(); - locationService.init(); - objectTypeService.init(); - personService.init(); - speciesService.init(); - vesselService.init(); - - programService.init(); - cruiseService.init(); - fishingOperationService.init(); - catchBatchService.init(); - speciesBatchService.init(); - benthosBatchService.init(); - marineLitterBatchService.init(); - accidentalBatchService.init(); - individualObservationBatchService.init(); - protocolService.init(); - attachmentService.init(); +// caracteristicService.init(); +// gearService.init(); +// locationService.init(); +// objectTypeService.init(); +// personService.init(); +// speciesService.init(); +// vesselService.init(); +// +// programService.init(); +// cruiseService.init(); +// fishingOperationService.init(); +// catchBatchService.init(); +// speciesBatchService.init(); +// benthosBatchService.init(); +// marineLitterBatchService.init(); +// accidentalBatchService.init(); +// individualObservationBatchService.init(); +// protocolService.init(); +// attachmentService.init(); } protected boolean close; @@ -264,107 +265,107 @@ public class TuttiPersistenceImpl implements TuttiPersistence { @Override public List<Caracteristic> getAllCaracteristic() { - return caracteristicService.getAllCaracteristic(); + return getCaracteristicService().getAllCaracteristic(); } @Override public List<Caracteristic> getAllCaracteristicWithProtected() { - return caracteristicService.getAllCaracteristicWithProtected(); + return getCaracteristicService().getAllCaracteristicWithProtected(); } @Override public List<Caracteristic> getAllCaracteristicForSampleCategory() { - return caracteristicService.getAllCaracteristicForSampleCategory(); + return getCaracteristicService().getAllCaracteristicForSampleCategory(); } @Override public List<Caracteristic> getAllNumericCaracteristic() { - return caracteristicService.getAllNumericCaracteristic(); + return getCaracteristicService().getAllNumericCaracteristic(); } @Override public Caracteristic getSizeCategoryCaracteristic() { - return caracteristicService.getSizeCategoryCaracteristic(); + return getCaracteristicService().getSizeCategoryCaracteristic(); } @Override public Caracteristic getSexCaracteristic() { - return caracteristicService.getSexCaracteristic(); + return getCaracteristicService().getSexCaracteristic(); } @Override public Caracteristic getSortedUnsortedCaracteristic() { - return caracteristicService.getSortedUnsortedCaracteristic(); + return getCaracteristicService().getSortedUnsortedCaracteristic(); } @Override public Caracteristic getMaturityCaracteristic() { - return caracteristicService.getMaturityCaracteristic(); + return getCaracteristicService().getMaturityCaracteristic(); } @Override public Caracteristic getAgeCaracteristic() { - return caracteristicService.getAgeCaracteristic(); + return getCaracteristicService().getAgeCaracteristic(); } @Override public Caracteristic getMarineLitterCategoryCaracteristic() { - return caracteristicService.getMarineLitterCategoryCaracteristic(); + return getCaracteristicService().getMarineLitterCategoryCaracteristic(); } @Override public Caracteristic getMarineLitterSizeCategoryCaracteristic() { - return caracteristicService.getMarineLitterSizeCategoryCaracteristic(); + return getCaracteristicService().getMarineLitterSizeCategoryCaracteristic(); } @Override public Caracteristic getVerticalOpeningCaracteristic() { - return caracteristicService.getVerticalOpeningCaracteristic(); + return getCaracteristicService().getVerticalOpeningCaracteristic(); } @Override public Caracteristic getHorizontalOpeningWingsCaracteristic() { - return caracteristicService.getHorizontalOpeningWingsCaracteristic(); + return getCaracteristicService().getHorizontalOpeningWingsCaracteristic(); } @Override public Caracteristic getHorizontalOpeningDoorCaracteristic() { - return caracteristicService.getHorizontalOpeningDoorCaracteristic(); + return getCaracteristicService().getHorizontalOpeningDoorCaracteristic(); } @Override public Caracteristic getDeadOrAliveCaracteristic() { - return caracteristicService.getDeadOrAliveCaracteristic(); + return getCaracteristicService().getDeadOrAliveCaracteristic(); } @Override public Caracteristic getPmfmIdCaracteristic() { - return caracteristicService.getPmfmIdCaracteristic(); + return getCaracteristicService().getPmfmIdCaracteristic(); } @Override public Caracteristic getWeightMeasuredCaracteristic() { - return caracteristicService.getWeightMeasuredCaracteristic(); + return getCaracteristicService().getWeightMeasuredCaracteristic(); } @Override public Caracteristic getCaracteristic(Integer pmfmId) { - return caracteristicService.getCaracteristic(pmfmId); + return getCaracteristicService().getCaracteristic(pmfmId); } @Override public boolean isVracBatch(SpeciesAbleBatch speciesBatch) { - return caracteristicService.isVracBatch(speciesBatch); + return getCaracteristicService().isVracBatch(speciesBatch); } @Override public Predicate<SpeciesAbleBatch> getVracBatchPredicate() { - return caracteristicService.getVracBatchPredicate(); + return getCaracteristicService().getVracBatchPredicate(); } @Override public boolean isHorsVracBatch(SpeciesAbleBatch speciesBatch) { - return caracteristicService.isHorsVracBatch(speciesBatch); + return getCaracteristicService().isHorsVracBatch(speciesBatch); } //------------------------------------------------------------------------// @@ -373,53 +374,53 @@ public class TuttiPersistenceImpl implements TuttiPersistence { @Override public List<TuttiLocation> getAllProgramZone() { - return locationService.getAllProgramZone(); + return getLocationService().getAllProgramZone(); } @Override public List<TuttiLocation> getAllCountry() { - return locationService.getAllCountry(); + return getLocationService().getAllCountry(); } @Override public List<TuttiLocation> getAllHarbour() { - return locationService.getAllHarbour(); + return getLocationService().getAllHarbour(); } @Override public List<TuttiLocation> getAllFishingOperationStrata(String zoneId) { - return locationService.getAllFishingOperationStrata(zoneId); + return getLocationService().getAllFishingOperationStrata(zoneId); } @Override public List<TuttiLocation> getAllFishingOperationSubStrata(String zoneId, String strataId) { - return locationService.getAllFishingOperationSubStrata(zoneId, - strataId); + return getLocationService().getAllFishingOperationSubStrata(zoneId, + strataId); } @Override public List<TuttiLocation> getAllFishingOperationLocation(String zoneId, String strataId, String subStrataId) { - return locationService.getAllFishingOperationLocation(zoneId, - strataId, - subStrataId); + return getLocationService().getAllFishingOperationLocation(zoneId, + strataId, + subStrataId); } @Override public String getLocationLabelByLatLong(Float latitude, Float longitude) { - return locationService.getLocationLabelByLatLong(latitude, longitude); + return getLocationService().getLocationLabelByLatLong(latitude, longitude); } @Override public Integer getLocationIdByLatLong(Float latitude, Float longitude) { - return locationService.getLocationIdByLatLong(latitude, longitude); + return getLocationService().getLocationIdByLatLong(latitude, longitude); } @Override public TuttiLocation getLocation(String id) { - return locationService.getLocation(id); + return getLocationService().getLocation(id); } //------------------------------------------------------------------------// @@ -428,12 +429,12 @@ public class TuttiPersistenceImpl implements TuttiPersistence { @Override public List<ObjectType> getAllObjectType() { - return objectTypeService.getAllObjectType(); + return getObjectTypeService().getAllObjectType(); } @Override public ObjectType getObjectType(String objectTypeCode) { - return objectTypeService.getObjectType(objectTypeCode); + return getObjectTypeService().getObjectType(objectTypeCode); } //------------------------------------------------------------------------// @@ -442,42 +443,42 @@ public class TuttiPersistenceImpl implements TuttiPersistence { @Override public List<Gear> getAllScientificGear() { - return gearService.getAllScientificGear(); + return getGearService().getAllScientificGear(); } @Override public List<Gear> getAllFishingGear() { - return gearService.getAllFishingGear(); + return getGearService().getAllFishingGear(); } @Override public Gear getGear(Integer gearId) { - return gearService.getGear(gearId); + return getGearService().getGear(gearId); } @Override public boolean isTemporaryGearUsed(Integer id) { - return gearService.isTemporaryGearUsed(id); + return getGearService().isTemporaryGearUsed(id); } @Override public Collection<Gear> importTemporaryGear(Collection<Gear> gears) { - return gearService.importTemporaryGear(gears); + return getGearService().importTemporaryGear(gears); } @Override public void replaceGear(Gear source, Gear target, boolean delete) { - gearService.replaceGear(source, target, delete); + getGearService().replaceGear(source, target, delete); } @Override public void deleteTemporaryGear(Integer id) { - gearService.deleteTemporaryGear(id); + getGearService().deleteTemporaryGear(id); } @Override public void deleteTemporaryGears(Collection<Integer> id) { - gearService.deleteTemporaryGears(id); + getGearService().deleteTemporaryGears(id); } //------------------------------------------------------------------------// @@ -486,26 +487,26 @@ public class TuttiPersistenceImpl implements TuttiPersistence { @Override public List<Species> getAllSpecies() { - List<Species> result = speciesService.getAllSpecies(); + List<Species> result = getSpeciesService().getAllSpecies(); setSpeciesSurveyCode(result, getProtocol()); return result; } @Override public List<Species> getAllReferentSpecies() { - List<Species> result = speciesService.getAllReferentSpecies(); + List<Species> result = getSpeciesService().getAllReferentSpecies(); setSpeciesSurveyCode(result, getProtocol()); return result; } @Override public Species getSpeciesByReferenceTaxonIdWithVernacularCode(Integer referenceTaxonId) { - return speciesService.getSpeciesByReferenceTaxonIdWithVernacularCode(referenceTaxonId); + return getSpeciesService().getSpeciesByReferenceTaxonIdWithVernacularCode(referenceTaxonId); } @Override public Species getSpeciesByReferenceTaxonId(Integer referenceTaxonId) { - return speciesService.getSpeciesByReferenceTaxonId(referenceTaxonId); + return getSpeciesService().getSpeciesByReferenceTaxonId(referenceTaxonId); } @Override @@ -525,18 +526,18 @@ public class TuttiPersistenceImpl implements TuttiPersistence { } } - return speciesService.isTemporarySpeciesUsed(referenceTaxonId); + return getSpeciesService().isTemporarySpeciesUsed(referenceTaxonId); } @Override public Collection<Species> importTemporarySpecies(Collection<Species> species) { - return speciesService.importTemporarySpecies(species); + return getSpeciesService().importTemporarySpecies(species); } @Override public void replaceSpecies(Species source, Species target, boolean delete) { - speciesService.replaceSpecies(source, target, delete); + getSpeciesService().replaceSpecies(source, target, delete); TuttiProtocol protocol = getProtocol(); @@ -560,12 +561,12 @@ public class TuttiPersistenceImpl implements TuttiPersistence { @Override public void deleteTemporarySpecies(Integer referenceTaxonId) { - speciesService.deleteTemporarySpecies(referenceTaxonId); + getSpeciesService().deleteTemporarySpecies(referenceTaxonId); } @Override public void deleteTemporarySpecies(Collection<Integer> referenceTaxonIds) { - speciesService.deleteTemporarySpecies(referenceTaxonIds); + getSpeciesService().deleteTemporarySpecies(referenceTaxonIds); } //------------------------------------------------------------------------// @@ -574,37 +575,37 @@ public class TuttiPersistenceImpl implements TuttiPersistence { @Override public List<Person> getAllPerson() { - return personService.getAllPerson(); + return getPersonService().getAllPerson(); } @Override public Person getPerson(Integer personId) { - return personService.getPerson(personId); + return getPersonService().getPerson(personId); } @Override public boolean isTemporaryPersonUsed(Integer id) { - return personService.isTemporaryPersonUsed(id); + return getPersonService().isTemporaryPersonUsed(id); } @Override public Collection<Person> importTemporaryPerson(Collection<Person> persons) { - return personService.importTemporaryPerson(persons); + return getPersonService().importTemporaryPerson(persons); } @Override public void replacePerson(Person source, Person target, boolean delete) { - personService.replacePerson(source, target, delete); + getPersonService().replacePerson(source, target, delete); } @Override public void deleteTemporaryPerson(Integer id) { - personService.deleteTemporaryPerson(id); + getPersonService().deleteTemporaryPerson(id); } @Override public void deleteTemporaryPersons(Collection<Integer> ids) { - personService.deleteTemporaryPersons(ids); + getPersonService().deleteTemporaryPersons(ids); } //------------------------------------------------------------------------// @@ -613,42 +614,42 @@ public class TuttiPersistenceImpl implements TuttiPersistence { @Override public List<Vessel> getAllScientificVessel() { - return vesselService.getAllScientificVessel(); + return getVesselService().getAllScientificVessel(); } @Override public List<Vessel> getAllFishingVessel() { - return vesselService.getAllFishingVessel(); + return getVesselService().getAllFishingVessel(); } @Override public Vessel getVessel(String vesselCode) { - return vesselService.getVessel(vesselCode); + return getVesselService().getVessel(vesselCode); } @Override public boolean isTemporaryVesselUsed(String code) { - return vesselService.isTemporaryVesselUsed(code); + return getVesselService().isTemporaryVesselUsed(code); } @Override public Collection<Vessel> importTemporaryVessel(Collection<Vessel> vessels) { - return vesselService.importTemporaryVessel(vessels); + return getVesselService().importTemporaryVessel(vessels); } @Override public void replaceVessel(Vessel source, Vessel target, boolean delete) { - vesselService.replaceVessel(source, target, delete); + getVesselService().replaceVessel(source, target, delete); } @Override public void deleteTemporaryVessel(String code) { - vesselService.deleteTemporaryVessel(code); + getVesselService().deleteTemporaryVessel(code); } @Override public void deleteTemporaryVessels(Collection<String> codes) { - vesselService.deleteTemporaryVessels(codes); + getVesselService().deleteTemporaryVessels(codes); } //------------------------------------------------------------------------// @@ -658,32 +659,32 @@ public class TuttiPersistenceImpl implements TuttiPersistence { @Override public List<Attachment> getAllAttachments(ObjectTypeCode objectType, Integer objectId) { - return attachmentService.getAllAttachments(objectType, objectId); + return getAttachmentService().getAllAttachments(objectType, objectId); } @Override public File getAttachmentFile(String attachmentId) { - return attachmentService.getAttachmentFile(attachmentId); + return getAttachmentService().getAttachmentFile(attachmentId); } @Override public Attachment createAttachment(Attachment attachment, File file) { - return attachmentService.createAttachment(attachment, file); + return getAttachmentService().createAttachment(attachment, file); } @Override public Attachment saveAttachment(Attachment attachment) { - return attachmentService.saveAttachment(attachment); + return getAttachmentService().saveAttachment(attachment); } @Override public void deleteAttachment(String attachmentId) { - attachmentService.deleteAttachment(attachmentId); + getAttachmentService().deleteAttachment(attachmentId); } @Override public void deleteAllAttachment(ObjectTypeCode objectType, Integer... objectIds) { - attachmentService.deleteAllAttachment(objectType, objectIds); + getAttachmentService().deleteAllAttachment(objectType, objectIds); } //------------------------------------------------------------------------// @@ -692,22 +693,22 @@ public class TuttiPersistenceImpl implements TuttiPersistence { @Override public List<Program> getAllProgram() { - return programService.getAllProgram(); + return getProgramService().getAllProgram(); } @Override public Program getProgram(String id) { - return programService.getProgram(id); + return getProgramService().getProgram(id); } @Override public Program createProgram(Program bean) { - return programService.createProgram(bean); + return getProgramService().createProgram(bean); } @Override public Program saveProgram(Program bean) { - return programService.saveProgram(bean); + return getProgramService().saveProgram(bean); } //------------------------------------------------------------------------// @@ -716,44 +717,44 @@ public class TuttiPersistenceImpl implements TuttiPersistence { @Override public List<Cruise> getAllCruise(String programId) { - return cruiseService.getAllCruise(programId); + return getCruiseService().getAllCruise(programId); } @Override public Cruise getCruise(String id) { - return cruiseService.getCruise(id); + return getCruiseService().getCruise(id); } @Override public Cruise createCruise(Cruise bean) { - return cruiseService.createCruise(bean); + return getCruiseService().createCruise(bean); } @Override public Cruise saveCruise(Cruise bean, boolean updateVessel, boolean updateGear) { - return cruiseService.saveCruise(bean, updateVessel, updateGear); + return getCruiseService().saveCruise(bean, updateVessel, updateGear); } @Override public void setCruiseReadyToSynch(Integer cruiseId) { - cruiseService.setCruiseReadyToSynch(cruiseId); + getCruiseService().setCruiseReadyToSynch(cruiseId); } @Override public CaracteristicMap getGearCaracteristics(String cruiseId, String gearId, short rankOrder) { - return cruiseService.getGearCaracteristics(cruiseId, gearId, rankOrder); + return getCruiseService().getGearCaracteristics(cruiseId, gearId, rankOrder); } @Override public boolean isOperationUseGears(Integer cruiseId, Collection<Gear> gears) { - return cruiseService.isOperationUseGears(cruiseId, gears); + return getCruiseService().isOperationUseGears(cruiseId, gears); } @Override public void saveGearCaracteristics(Gear gear, Cruise cruise) { - cruiseService.saveGearCaracteristics(gear, cruise); + getCruiseService().saveGearCaracteristics(gear, cruise); } //------------------------------------------------------------------------// @@ -762,42 +763,42 @@ public class TuttiPersistenceImpl implements TuttiPersistence { @Override public TuttiProtocol getProtocol() { - return protocolService.getProtocol(); + return getProtocolService().getProtocol(); } @Override public void setProtocol(TuttiProtocol protocol) { - protocolService.setProtocol(protocol); + getProtocolService().setProtocol(protocol); } @Override public boolean isProtocolExist(String id) { - return protocolService.isProtocolExist(id); + return getProtocolService().isProtocolExist(id); } @Override public List<String> getAllProtocolNames() { - return protocolService.getAllProtocolId(); + return getProtocolService().getAllProtocolId(); } @Override public List<TuttiProtocol> getAllProtocol() { - return protocolService.getAllProtocol(); + return getProtocolService().getAllProtocol(); } @Override public List<String> getAllProtocolId() { - return protocolService.getAllProtocolId(); + return getProtocolService().getAllProtocolId(); } @Override public TuttiProtocol saveProtocol(TuttiProtocol bean) { - return protocolService.saveProtocol(bean); + return getProtocolService().saveProtocol(bean); } @Override public void deleteProtocol(String id) { - protocolService.deleteProtocol(id); + getProtocolService().deleteProtocol(id); } @Override @@ -807,7 +808,7 @@ public class TuttiPersistenceImpl implements TuttiPersistence { @Override public TuttiProtocol getProtocol(String id) { - TuttiProtocol protocol = protocolService.getProtocol(id); + TuttiProtocol protocol = getProtocolService().getProtocol(id); // sanity it (remove all bad species and benthos) // see http://forge.codelutin.com/issues/4154 @@ -852,47 +853,47 @@ public class TuttiPersistenceImpl implements TuttiPersistence { @Override public int getFishingOperationCount(String cruiseId) { - return fishingOperationService.getFishingOperationCount(cruiseId); + return getFishingOperationService().getFishingOperationCount(cruiseId); } @Override public List<String> getAllFishingOperationIds(String cruiseId) { - return fishingOperationService.getAllFishingOperationIds(cruiseId); + return getFishingOperationService().getAllFishingOperationIds(cruiseId); } @Override public List<FishingOperation> getAllFishingOperation(String cruiseId) { - return fishingOperationService.getAllFishingOperation(cruiseId); + return getFishingOperationService().getAllFishingOperation(cruiseId); } @Override public FishingOperation getFishingOperation(String id) { - return fishingOperationService.getFishingOperation(id); + return getFishingOperationService().getFishingOperation(id); } @Override public List<Vessel> getFishingOperationSecondaryVessel(String fishingOperationId) { - return fishingOperationService.getFishingOperationSecondaryVessel(fishingOperationId); + return getFishingOperationService().getFishingOperationSecondaryVessel(fishingOperationId); } @Override public FishingOperation createFishingOperation(FishingOperation bean) { - return fishingOperationService.createFishingOperation(bean); + return getFishingOperationService().createFishingOperation(bean); } @Override public FishingOperation saveFishingOperation(FishingOperation bean) { - return fishingOperationService.saveFishingOperation(bean); + return getFishingOperationService().saveFishingOperation(bean); } @Override public Collection<FishingOperation> saveFishingOperations(Collection<FishingOperation> beans) { - return fishingOperationService.saveFishingOperations(beans); + return getFishingOperationService().saveFishingOperations(beans); } @Override public void deleteFishingOperation(String id) { - fishingOperationService.deleteFishingOperation(id); + getFishingOperationService().deleteFishingOperation(id); } //------------------------------------------------------------------------// @@ -901,32 +902,32 @@ public class TuttiPersistenceImpl implements TuttiPersistence { @Override public boolean isFishingOperationWithCatchBatch(String operationId) { - return catchBatchService.isFishingOperationWithCatchBatch(operationId); + return getCatchBatchService().isFishingOperationWithCatchBatch(operationId); } @Override public CatchBatch getCatchBatchFromFishingOperation(String id) throws InvalidBatchModelException { - return catchBatchService.getCatchBatchFromFishingOperation(id); + return getCatchBatchService().getCatchBatchFromFishingOperation(id); } @Override public CatchBatch createCatchBatch(CatchBatch bean) { - return catchBatchService.createCatchBatch(bean); + return getCatchBatchService().createCatchBatch(bean); } @Override public CatchBatch saveCatchBatch(CatchBatch bean) { - return catchBatchService.saveCatchBatch(bean); + return getCatchBatchService().saveCatchBatch(bean); } @Override public void deleteCatchBatch(String fishingOperationId) { - catchBatchService.deleteCatchBatch(fishingOperationId); + getCatchBatchService().deleteCatchBatch(fishingOperationId); } @Override public void recomputeCatchBatchSampleRatios(String fishingOperationId) { - catchBatchService.recomputeCatchBatchSampleRatios(fishingOperationId); + getCatchBatchService().recomputeCatchBatchSampleRatios(fishingOperationId); } //------------------------------------------------------------------------// @@ -935,47 +936,47 @@ public class TuttiPersistenceImpl implements TuttiPersistence { @Override public BatchContainer<SpeciesBatch> getRootSpeciesBatch(String fishingOperationId, boolean validateTree) throws InvalidBatchModelException { - return speciesBatchService.getRootSpeciesBatch(fishingOperationId, validateTree); + return getSpeciesBatchService().getRootSpeciesBatch(fishingOperationId, validateTree); } @Override public SpeciesBatch createSpeciesBatch(SpeciesBatch bean, String parentBatchId) { - return speciesBatchService.createSpeciesBatch(bean, parentBatchId); + return getSpeciesBatchService().createSpeciesBatch(bean, parentBatchId); } @Override public SpeciesBatch saveSpeciesBatch(SpeciesBatch bean) { - return speciesBatchService.saveSpeciesBatch(bean); + return getSpeciesBatchService().saveSpeciesBatch(bean); } @Override public void deleteSpeciesBatch(String id) { - speciesBatchService.deleteSpeciesBatch(id); + getSpeciesBatchService().deleteSpeciesBatch(id); } @Override public void deleteSpeciesSubBatch(String id) { - speciesBatchService.deleteSpeciesSubBatch(id); + getSpeciesBatchService().deleteSpeciesSubBatch(id); } @Override public void changeSpeciesBatchSpecies(String batchId, Species species) { - speciesBatchService.changeSpeciesBatchSpecies(batchId, species); + getSpeciesBatchService().changeSpeciesBatchSpecies(batchId, species); } @Override public List<SpeciesBatchFrequency> getAllSpeciesBatchFrequency(String speciesBatchId) { - return speciesBatchService.getAllSpeciesBatchFrequency(speciesBatchId); + return getSpeciesBatchService().getAllSpeciesBatchFrequency(speciesBatchId); } @Override public Multimap<Species, SpeciesBatchFrequency> getAllSpeciesBatchFrequencyForBatch(BatchContainer<SpeciesBatch> batchContainer) { - return speciesBatchService.getAllSpeciesBatchFrequencyForBatch(batchContainer); + return getSpeciesBatchService().getAllSpeciesBatchFrequencyForBatch(batchContainer); } @Override public List<SpeciesBatchFrequency> saveSpeciesBatchFrequency(String speciesBatchId, List<SpeciesBatchFrequency> frequencies) { - return speciesBatchService.saveSpeciesBatchFrequency(speciesBatchId, frequencies); + return getSpeciesBatchService().saveSpeciesBatchFrequency(speciesBatchId, frequencies); } //------------------------------------------------------------------------// @@ -984,48 +985,48 @@ public class TuttiPersistenceImpl implements TuttiPersistence { @Override public BatchContainer<BenthosBatch> getRootBenthosBatch(String fishingOperationId, boolean validateTree) throws InvalidBatchModelException { - return benthosBatchService.getRootBenthosBatch(fishingOperationId, validateTree); + return getBenthosBatchService().getRootBenthosBatch(fishingOperationId, validateTree); } @Override public BenthosBatch createBenthosBatch(BenthosBatch bean, String parentBatchId) { - return benthosBatchService.createBenthosBatch(bean, parentBatchId); + return getBenthosBatchService().createBenthosBatch(bean, parentBatchId); } @Override public BenthosBatch saveBenthosBatch(BenthosBatch bean) { - return benthosBatchService.saveBenthosBatch(bean); + return getBenthosBatchService().saveBenthosBatch(bean); } @Override public void deleteBenthosBatch(String id) { - benthosBatchService.deleteBenthosBatch(id); + getBenthosBatchService().deleteBenthosBatch(id); } @Override public void deleteBenthosSubBatch(String id) { - benthosBatchService.deleteBenthosSubBatch(id); + getBenthosBatchService().deleteBenthosSubBatch(id); } @Override public void changeBenthosBatchSpecies(String batchId, Species species) { - benthosBatchService.changeBenthosBatchSpecies(batchId, species); + getBenthosBatchService().changeBenthosBatchSpecies(batchId, species); } @Override public List<BenthosBatchFrequency> getAllBenthosBatchFrequency(String benthosBatchId) { - return benthosBatchService.getAllBenthosBatchFrequency(benthosBatchId); + return getBenthosBatchService().getAllBenthosBatchFrequency(benthosBatchId); } @Override public Multimap<Species, BenthosBatchFrequency> getAllBenthosBatchFrequencyForBatch(BatchContainer<BenthosBatch> batchContainer) { - return benthosBatchService.getAllBenthosBatchFrequencyForBatch(batchContainer); + return getBenthosBatchService().getAllBenthosBatchFrequencyForBatch(batchContainer); } @Override public List<BenthosBatchFrequency> saveBenthosBatchFrequency(String benthosBatchId, List<BenthosBatchFrequency> frequencies) { - return benthosBatchService.saveBenthosBatchFrequency(benthosBatchId, frequencies); + return getBenthosBatchService().saveBenthosBatchFrequency(benthosBatchId, frequencies); } //------------------------------------------------------------------------// @@ -1034,22 +1035,22 @@ public class TuttiPersistenceImpl implements TuttiPersistence { @Override public BatchContainer<MarineLitterBatch> getRootMarineLitterBatch(String fishingOperationId) { - return marineLitterBatchService.getRootMarineLitterBatch(fishingOperationId); + return getMarineLitterBatchService().getRootMarineLitterBatch(fishingOperationId); } @Override public MarineLitterBatch createMarineLitterBatch(MarineLitterBatch bean) { - return marineLitterBatchService.createMarineLitterBatch(bean); + return getMarineLitterBatchService().createMarineLitterBatch(bean); } @Override public MarineLitterBatch saveMarineLitterBatch(MarineLitterBatch bean) { - return marineLitterBatchService.saveMarineLitterBatch(bean); + return getMarineLitterBatchService().saveMarineLitterBatch(bean); } @Override public void deleteMarineLitterBatch(String id) { - marineLitterBatchService.deleteMarineLitterBatch(id); + getMarineLitterBatchService().deleteMarineLitterBatch(id); } //------------------------------------------------------------------------// @@ -1058,27 +1059,27 @@ public class TuttiPersistenceImpl implements TuttiPersistence { @Override public List<AccidentalBatch> getAllAccidentalBatch(String fishingOperationId) { - return accidentalBatchService.getAllAccidentalBatch(fishingOperationId); + return getAccidentalBatchService().getAllAccidentalBatch(fishingOperationId); } @Override public AccidentalBatch createAccidentalBatch(AccidentalBatch bean) { - return accidentalBatchService.createAccidentalBatch(bean); + return getAccidentalBatchService().createAccidentalBatch(bean); } @Override public AccidentalBatch saveAccidentalBatch(AccidentalBatch bean) { - return accidentalBatchService.saveAccidentalBatch(bean); + return getAccidentalBatchService().saveAccidentalBatch(bean); } @Override public void deleteAccidentalBatch(String id) { - accidentalBatchService.deleteAccidentalBatch(id); + getAccidentalBatchService().deleteAccidentalBatch(id); } @Override public void deleteAccidentalBatchForFishingOperation(String fishingOperationId) { - accidentalBatchService.deleteAccidentalBatchForFishingOperation(fishingOperationId); + getAccidentalBatchService().deleteAccidentalBatchForFishingOperation(fishingOperationId); } //------------------------------------------------------------------------// @@ -1087,27 +1088,27 @@ public class TuttiPersistenceImpl implements TuttiPersistence { @Override public List<IndividualObservationBatch> getAllIndividualObservationBatch(String fishingOperationId) { - return individualObservationBatchService.getAllIndividualObservationBatch(fishingOperationId); + return getIndividualObservationBatchService().getAllIndividualObservationBatch(fishingOperationId); } @Override public IndividualObservationBatch createIndividualObservationBatch(IndividualObservationBatch bean) { - return individualObservationBatchService.createIndividualObservationBatch(bean); + return getIndividualObservationBatchService().createIndividualObservationBatch(bean); } @Override public IndividualObservationBatch saveIndividualObservationBatch(IndividualObservationBatch bean) { - return individualObservationBatchService.saveIndividualObservationBatch(bean); + return getIndividualObservationBatchService().saveIndividualObservationBatch(bean); } @Override public void deleteIndividualObservationBatch(String id) { - individualObservationBatchService.deleteIndividualObservationBatch(id); + getIndividualObservationBatchService().deleteIndividualObservationBatch(id); } @Override public void deleteIndividualObservationBatchForFishingOperation(String fishingOperationId) { - individualObservationBatchService.deleteIndividualObservationBatchForFishingOperation(fishingOperationId); + getIndividualObservationBatchService().deleteIndividualObservationBatchForFishingOperation(fishingOperationId); } //------------------------------------------------------------------------// @@ -1151,4 +1152,93 @@ public class TuttiPersistenceImpl implements TuttiPersistence { } } } + + public AccidentalBatchPersistenceService getAccidentalBatchService() { + return getServiceInitialied(accidentalBatchService); + } + + public AttachmentPersistenceService getAttachmentService() { + return getServiceInitialied(attachmentService); + } + + public BenthosBatchPersistenceService getBenthosBatchService() { + return getServiceInitialied(benthosBatchService); + } + + public CaracteristicPersistenceService getCaracteristicService() { + return getServiceInitialied(caracteristicService); + } + + public CatchBatchPersistenceService getCatchBatchService() { + return getServiceInitialied(catchBatchService); + } + + public CruisePersistenceService getCruiseService() { + return getServiceInitialied(cruiseService); + } + + public FishingOperationPersistenceService getFishingOperationService() { + return getServiceInitialied(fishingOperationService); + } + + public GearPersistenceService getGearService() { + return getServiceInitialied(gearService); + } + + public IndividualObservationBatchPersistenceService getIndividualObservationBatchService() { + return getServiceInitialied(individualObservationBatchService); + } + + public LocationPersistenceService getLocationService() { + return getServiceInitialied(locationService); + } + + public MarineLitterBatchPersistenceService getMarineLitterBatchService() { + return getServiceInitialied(marineLitterBatchService); + } + + public ObjectTypePersistenceService getObjectTypeService() { + return getServiceInitialied(objectTypeService); + } + + public PersonPersistenceService getPersonService() { + return getServiceInitialied(personService); + } + + public ProtocolPersistenceService getProtocolService() { + return getServiceInitialied(protocolService); + } + + public ProgramPersistenceService getProgramService() { + return getServiceInitialied(programService); + } + + public SpeciesBatchPersistenceService getSpeciesBatchService() { + return getServiceInitialied(speciesBatchService); + } + + public SpeciesPersistenceService getSpeciesService() { + return getServiceInitialied(speciesService); + } + + public TechnicalPersistenceService getTechnicalPersistenceService() { + return getServiceInitialied(technicalPersistenceService); + } + + public VesselPersistenceService getVesselService() { + return getServiceInitialied(vesselService); + } + + protected <S> S getServiceInitialied(S service) { + + if (service instanceof AbstractPersistenceService) { + AbstractPersistenceService abstractPersistenceService = (AbstractPersistenceService) service; + + abstractPersistenceService.lazyInit(); + + } + + return service; + } + } diff --git a/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/AbstractPersistenceService.java b/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/AbstractPersistenceService.java index 2911049..c2d5f45 100644 --- a/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/AbstractPersistenceService.java +++ b/tutti-persistence/src/main/java/fr/ifremer/tutti/persistence/service/AbstractPersistenceService.java @@ -52,8 +52,7 @@ import java.util.List; public abstract class AbstractPersistenceService implements TuttiPersistenceServiceImplementor { /** Logger. */ - private static final Log log = - LogFactory.getLog(AbstractPersistenceService.class); + private static final Log log = LogFactory.getLog(AbstractPersistenceService.class); /** * Session factory. @@ -66,6 +65,29 @@ public abstract class AbstractPersistenceService implements TuttiPersistenceServ @Resource(name = "tuttiConfiguration") protected TuttiConfiguration config; + /** + * Etat pour savoir si le service a ete initialise. + */ + private boolean init; + + public void lazyInit() { + + if (!init) { + + try { + + init(); + + } finally { + + init = true; + + } + + } + + } + @Override public void init() { // do nothing by default @@ -74,6 +96,7 @@ public abstract class AbstractPersistenceService implements TuttiPersistenceServ @Override public void close() { // do nothing by default + init = false; } public void setConfig(TuttiConfiguration config) { diff --git a/tutti-service/src/main/java/fr/ifremer/tutti/service/TuttiDataContext.java b/tutti-service/src/main/java/fr/ifremer/tutti/service/TuttiDataContext.java index 5f96e87..8263c4a 100644 --- a/tutti-service/src/main/java/fr/ifremer/tutti/service/TuttiDataContext.java +++ b/tutti-service/src/main/java/fr/ifremer/tutti/service/TuttiDataContext.java @@ -182,8 +182,21 @@ public class TuttiDataContext extends AbstractBean implements Closeable { }); } - public void open(TuttiConfiguration config, PersistenceService persistenceService) { + public void setPersistenceService(PersistenceService service) { + this.service = service; + } + + public void open(TuttiConfiguration config) { + + PersistenceService persistenceService = this.service; + + // Check there is a persistence service injected + Preconditions.checkState(persistenceService != null); + + // Close data context close(); + + // Reset the persistence service this.service = persistenceService; // load protocol and propagate it to service diff --git a/tutti-service/src/test/java/fr/ifremer/tutti/service/ServiceDbResource.java b/tutti-service/src/test/java/fr/ifremer/tutti/service/ServiceDbResource.java index a1d8c00..8f5f3ce 100644 --- a/tutti-service/src/test/java/fr/ifremer/tutti/service/ServiceDbResource.java +++ b/tutti-service/src/test/java/fr/ifremer/tutti/service/ServiceDbResource.java @@ -307,8 +307,8 @@ public class ServiceDbResource extends DatabaseResource { TuttiServiceContext serviceContext = getServiceContext(); PersistenceService persistenceService = serviceContext.getService(PersistenceService.class); - - serviceContext.getDataContext().open(serviceContext.getConfig(), persistenceService); + serviceContext.getDataContext().setPersistenceService(persistenceService); + serviceContext.getDataContext().open(serviceContext.getConfig()); } public TuttiServiceContext setCountryInConfig(String countryCode) { diff --git a/tutti-service/src/test/java/fr/ifremer/tutti/service/catches/WeightComputingServiceTest.java b/tutti-service/src/test/java/fr/ifremer/tutti/service/catches/WeightComputingServiceTest.java index 7076f01..90a6409 100644 --- a/tutti-service/src/test/java/fr/ifremer/tutti/service/catches/WeightComputingServiceTest.java +++ b/tutti-service/src/test/java/fr/ifremer/tutti/service/catches/WeightComputingServiceTest.java @@ -89,7 +89,8 @@ public class WeightComputingServiceTest { persistenceService = serviceContext.getService(PersistenceService.class); - serviceContext.getDataContext().open(serviceContext.getConfig(), persistenceService); + serviceContext.getDataContext().setPersistenceService(persistenceService); + serviceContext.getDataContext().open(serviceContext.getConfig()); weightComputingService = serviceContext.getService(WeightComputingService.class); } diff --git a/tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/TuttiUIContext.java b/tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/TuttiUIContext.java index cce58d1..d23d363 100644 --- a/tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/TuttiUIContext.java +++ b/tutti-ui-swing/src/main/java/fr/ifremer/tutti/ui/swing/TuttiUIContext.java @@ -648,8 +648,8 @@ public class TuttiUIContext extends AbstractBean implements Closeable, UIMessage // use real service service = serviceContext.getService(PersistenceService.class); - - dataContext.open(config, service); + dataContext.setPersistenceService(service); +// dataContext.open(config, service); } } else { service = serviceContext.getService(ClosedPersistenceService.class); @@ -815,14 +815,15 @@ public class TuttiUIContext extends AbstractBean implements Closeable, UIMessage public void checkDbContext() { - // make sure persistence serivce is loaded - getPersistenceService(); + // open data context + dataContext.open(config); // ask data context to check his ids dataContext.checkDbContext(); // save config saveContextToConfig(); + } //------------------------------------------------------------------------// -- To stop receiving notification emails like this one, please contact codelutin.com SCM administrator <admin+scm@codelutin.com>.