/ - Diff - EDIT - EDIT Project Management

« Previous | Next »

Revision 390328ab

Added by Cherian Mathew over 8 years ago

ID 390328ab2e8df46ee70cf7c4601c293e8ee4b057
Parent 6ac1f1fd
Child c237492d

Replace spring application context loading with programmatic loading

     package eu.etaxonomy.cdm.api.application;
     import java.util.ArrayList;
     import java.util.Arrays;
     import java.util.HashMap;
     import java.util.List;
     import java.util.Map;
     import org.apache.log4j.Logger;
     import org.springframework.beans.BeansException;
     import org.springframework.context.ApplicationContext;
     import org.springframework.context.ApplicationContextAware;
     import org.springframework.remoting.httpinvoker.HttpInvokerProxyFactoryBean;
     import org.springframework.remoting.httpinvoker.HttpInvokerRequestExecutor;
     import org.springframework.security.access.AccessDecisionVoter;
     import org.springframework.security.authentication.AuthenticationProvider;
     import org.springframework.security.authentication.ProviderManager;
     import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
     import org.springframework.security.authentication.dao.DaoAuthenticationProvider;
     import org.springframework.security.authentication.dao.ReflectionSaltSource;
     import org.springframework.security.authentication.encoding.Md5PasswordEncoder;
     import org.springframework.security.core.Authentication;
     import org.springframework.security.core.context.SecurityContext;
     import org.springframework.security.core.context.SecurityContextHolder;
-...
     import eu.etaxonomy.cdm.api.service.ITaxonNodeService;
     import eu.etaxonomy.cdm.api.service.ITaxonService;
     import eu.etaxonomy.cdm.api.service.ITermService;
     import eu.etaxonomy.cdm.api.service.ITestService;
     import eu.etaxonomy.cdm.api.service.IUserService;
     import eu.etaxonomy.cdm.api.service.IVocabularyService;
     import eu.etaxonomy.cdm.api.service.IWorkingSetService;
-...
     import eu.etaxonomy.cdm.api.service.molecular.IPrimerService;
     import eu.etaxonomy.cdm.api.service.molecular.ISequenceService;
     import eu.etaxonomy.cdm.ext.geo.IEditGeoService;
     import eu.etaxonomy.cdm.io.service.IIOService;
     import eu.etaxonomy.cdm.model.common.CdmBase;
     import eu.etaxonomy.cdm.persistence.hibernate.permission.CdmPermissionEvaluator;
     import eu.etaxonomy.cdm.persistence.hibernate.permission.ICdmPermissionEvaluator;
     import eu.etaxonomy.cdm.persistence.hibernate.permission.UnanimousBasedUnrevokable;
     import eu.etaxonomy.cdm.persistence.hibernate.permission.voter.DescriptionBaseVoter;
     import eu.etaxonomy.cdm.persistence.hibernate.permission.voter.DescriptionElementVoter;
     import eu.etaxonomy.cdm.persistence.hibernate.permission.voter.GrantAlwaysVoter;
     import eu.etaxonomy.cdm.persistence.hibernate.permission.voter.TaxonBaseVoter;
     import eu.etaxonomy.cdm.persistence.hibernate.permission.voter.TaxonNodeVoter;
     import eu.etaxonomy.taxeditor.remoting.source.ICdmRemoteSource;
     import eu.etaxonomy.taxeditor.service.CachedCommonServiceImpl;
     import eu.etaxonomy.taxeditor.service.CdmServiceRequestExecutor;
     import eu.etaxonomy.taxeditor.service.ICachedCommonService;
     import eu.etaxonomy.taxeditor.service.TermServiceRequestExecutor;
     import eu.etaxonomy.taxeditor.session.CdmEntitySessionManager;
     import eu.etaxonomy.taxeditor.session.ICdmEntitySessionManager;
-...
         protected ApplicationContext applicationContext;
         private ICdmRemoteSource remoteSource;
         private Map serviceMap = new HashMap<Class<IService>, IService>();
         private ICdmEntitySessionManager cdmEntitySessionManager;
         private CdmPermissionEvaluator cdmPermissionEvaluator;
         private ProviderManager authenticationManager;
         private ICachedCommonService cachedCommonService;
         public CdmApplicationRemoteConfiguration() {}
         public CdmApplicationRemoteConfiguration(ICdmRemoteSource remoteSource) {
             this.remoteSource = remoteSource;
+        }
         public void setRemoteSource(ICdmRemoteSource remoteSource) {
             this.remoteSource = remoteSource;
+        }
         private Object getService(Class<?> clazz, String serviceSuffix, HttpInvokerRequestExecutor executor) {
             if(serviceMap.containsKey(clazz)) {
                 return serviceMap.get(clazz);
+            }
             String baseUrl;
             if(remoteSource.getContextPath() == null || remoteSource.getContextPath().equals("")) {
                 baseUrl = "http://" + remoteSource.getServer() + ":" + String.valueOf(remoteSource.getPort());
             } else {
                 baseUrl = "http://" + remoteSource.getServer()  + ":" + String.valueOf(remoteSource.getPort()) + "/" + remoteSource.getContextPath();
+            }
             HttpInvokerProxyFactoryBean proxy = new HttpInvokerProxyFactoryBean();
             proxy.setServiceInterface(clazz);
             proxy.setServiceUrl(baseUrl + serviceSuffix);
             if(executor != null) {
                 proxy.setHttpInvokerRequestExecutor(executor);
+            }
             proxy.afterPropertiesSet();
             Object service = proxy.getObject();
             serviceMap.put(clazz,  service);
             return service;
+        }
         // ****************************** APPLICATION CONTEXT *************************************************/
         @Override
-...
          * @return
          */
         public IEditGeoService getEditGeoService() {
             return (IEditGeoService)getBean("editGeoService");
             return (IEditGeoService) getService(IEditGeoService.class, "/remoting/editgeo.service", new CdmServiceRequestExecutor());
+        }
         /**
          * @return
          */
         public ICachedCommonService getCachedCommonService(){
             return (ICachedCommonService) getBean("cachedCommonService");
             if(cachedCommonService == null) {
                 cachedCommonService = new CachedCommonServiceImpl();
+            }
             return cachedCommonService;
+        }
         public ICdmEntitySessionManager getCdmEntitySessionManager() {
             return (ICdmEntitySessionManager) getBean("cdmEntitySessionManager");
             if(cdmEntitySessionManager == null) {
                 cdmEntitySessionManager = new CdmEntitySessionManager();
+            }
             return cdmEntitySessionManager;
+        }
-...
         @Override
         public final Object getBean(String name){
             return this.applicationContext.getBean(name);
             throw new UnsupportedOperationException("getBean is not implemented for CdmApplicationRemoteConfiguration");
+        }
         @Override
         public IAgentService getAgentService(){
             return (IAgentService) getBean("agentService");
             return (IAgentService) getService(IAgentService.class, "/remoting/agent.service", new CdmServiceRequestExecutor());
+        }
         @Override
         public IDatabaseService getDatabaseService(){
             return (IDatabaseService) getBean("databaseService");
             return (IDatabaseService) getService(IDatabaseService.class, "/remoting/database.service", new CdmServiceRequestExecutor());
+        }
         @Override
         public INameService getNameService(){
             return (INameService) getBean("nameService");
             return (INameService) getService(INameService.class, "/remoting/name.service", new CdmServiceRequestExecutor());
+        }
         @Override
         public IReferenceService getReferenceService(){
             return (IReferenceService) getBean("referenceService");
             return (IReferenceService) getService(IReferenceService.class, "/remoting/reference.service", new CdmServiceRequestExecutor());
+        }
         @Override
         public ITaxonService getTaxonService(){
             return (ITaxonService) getBean("taxonService");
             return (ITaxonService) getService(ITaxonService.class, "/remoting/taxon.service", new CdmServiceRequestExecutor());
+        }
         @Override
         public IClassificationService getClassificationService(){
             return (IClassificationService) getBean("classificationService");
             return (IClassificationService) getService(IClassificationService.class, "/remoting/classification.service", new CdmServiceRequestExecutor());
+        }
         @Override
         public ITaxonNodeService getTaxonNodeService(){
             return (ITaxonNodeService) getBean("taxonNodeService");
             return (ITaxonNodeService) getService(ITaxonNodeService.class, "/remoting/taxonnode.service", new CdmServiceRequestExecutor());
+        }
         @Override
         public IDescriptionService getDescriptionService(){
             return (IDescriptionService) getBean("descriptionService");
             return (IDescriptionService) getService(IDescriptionService.class, "/remoting/description.service", new CdmServiceRequestExecutor());
+        }
         @Override
         public IOccurrenceService getOccurrenceService(){
             return (IOccurrenceService) getBean("occurrenceService");
             return (IOccurrenceService) getService(IOccurrenceService.class, "/remoting/occurrence.service", new CdmServiceRequestExecutor());
+        }
         @Override
         public IPrimerService getPrimerService(){
             return (IPrimerService) getBean("primerService");
             return (IPrimerService) getService(IPrimerService.class, "/remoting/primer.service", new CdmServiceRequestExecutor());
+        }
         @Override
         public IAmplificationService getAmplificationService(){
             return (IAmplificationService) getBean("amplificationService");
             return (IAmplificationService) getService(IAmplificationService.class, "/remoting/amplification.service", new CdmServiceRequestExecutor());
+        }
         @Override
         public ISequenceService getSequenceService(){
             return (ISequenceService) getBean("sequenceService");
             return (ISequenceService) getService(ISequenceService.class, "/remoting/sequence.service", new CdmServiceRequestExecutor());
+        }
         @Override
         public IMediaService getMediaService(){
             return (IMediaService) getBean("mediaService");
             return (IMediaService) getService(IMediaService.class, "/remoting/media.service", new CdmServiceRequestExecutor());
+        }
         @Override
         public ITermService getTermService(){
             return (ITermService) getBean("termService");
             return (ITermService) getService(ITermService.class, "/remoting/term.service", new TermServiceRequestExecutor());
+        }
         @Override
         public ICommonService getCommonService(){
             return (ICommonService) getBean("commonService");
             return (ICommonService) getService(ICommonService.class, "/remoting/common.service", new CdmServiceRequestExecutor());
+        }
         @Override
         public ILocationService getLocationService(){
             return (ILocationService) getBean("locationService");
             return (ILocationService) getService(ILocationService.class, "/remoting/location.service", new CdmServiceRequestExecutor());
+        }
         @Override
         public IUserService getUserService(){
             return (IUserService) getBean("userService");
             return (IUserService) getService(IUserService.class, "/remoting-public/user.service", new CdmServiceRequestExecutor());
+        }
         @Override
         public IGrantedAuthorityService getGrantedAuthorityService(){
             return (IGrantedAuthorityService) getBean("grantedAuthorityService");
             return (IGrantedAuthorityService) getService(IGrantedAuthorityService.class, "/remoting/grantedauthority.service", new CdmServiceRequestExecutor());
+        }
         @Override
         public IService<CdmBase> getMainService(){
             return (IService<CdmBase>) getBean("mainService");
             return null;
+        }
         @Override
         public ProviderManager getAuthenticationManager(){
             return (ProviderManager) getBean("authenticationManager");
             if(authenticationManager != null) {
                 return authenticationManager;
+            }
             Md5PasswordEncoder passwordEncoder = new Md5PasswordEncoder();
             ReflectionSaltSource saltSource = new ReflectionSaltSource();
             saltSource.setUserPropertyToUse("getUsername");
             DaoAuthenticationProvider daoAuthenticationProvider = new DaoAuthenticationProvider();
             daoAuthenticationProvider.setUserDetailsService(getUserService());
             daoAuthenticationProvider.setSaltSource(saltSource);
             daoAuthenticationProvider.setPasswordEncoder(passwordEncoder);
             authenticationManager = new ProviderManager(Arrays.asList((AuthenticationProvider)daoAuthenticationProvider));
             return authenticationManager;
+        }
-...
         @Override
         public ICollectionService getCollectionService(){
             return (ICollectionService) getBean("collectionService");
             return (ICollectionService) getService(ICollectionService.class, "/remoting/collection.service", new CdmServiceRequestExecutor());
+        }
         @Override
         public IFeatureTreeService getFeatureTreeService(){
             return (IFeatureTreeService) getBean("featureTreeService");
             return (IFeatureTreeService) getService(IFeatureTreeService.class, "/remoting/featuretree.service", new CdmServiceRequestExecutor());
+        }
         @Override
         public IFeatureNodeService getFeatureNodeService(){
             return (IFeatureNodeService) getBean("featureNodeService");
             return (IFeatureNodeService) getService(IFeatureNodeService.class, "/remoting/featurenode.service", new CdmServiceRequestExecutor());
+        }
         @Override
         public IVocabularyService getVocabularyService(){
             return (IVocabularyService) getBean("vocabularyService");
             return (IVocabularyService) getService(IVocabularyService.class, "/remoting/vocabulary.service", new CdmServiceRequestExecutor());
+        }
         @Override
         public IIdentificationKeyService getIdentificationKeyService(){
             return (IIdentificationKeyService) getBean("identificationKeyService");
             return (IIdentificationKeyService) getService(IIdentificationKeyService.class, "/remoting/identificationkey.service", new CdmServiceRequestExecutor());
+        }
         @Override
         public IPolytomousKeyService getPolytomousKeyService(){
             return (IPolytomousKeyService) getBean("polytomousKeyService");
             return (IPolytomousKeyService) getService(IPolytomousKeyService.class, "/remoting/polytomouskey.service", new CdmServiceRequestExecutor());
+        }
         @Override
         public IPolytomousKeyNodeService getPolytomousKeyNodeService(){
             return (IPolytomousKeyNodeService) getBean("polytomousKeyNodeService");
             return (IPolytomousKeyNodeService) getService(IPolytomousKeyNodeService.class, "/remoting/polytomouskeynode.service", new CdmServiceRequestExecutor());
+        }
         @Override
         public IWorkingSetService getWorkingSetService(){
             return (IWorkingSetService) getBean("workingSetService");
             return (IWorkingSetService) getService(IWorkingSetService.class, "/remoting/workingset.service", new CdmServiceRequestExecutor());
+        }
         @Override
         public IGroupService getGroupService(){
             return (IGroupService) getBean("groupService");
             return (IGroupService) getService(IGroupService.class, "/remoting/group.service", new CdmServiceRequestExecutor());
+        }
         @Override
         public IEntityValidationService getEntityValidationService(){
             return (IEntityValidationService) getBean("entityValidationService");
             return (IEntityValidationService) getService(IEntityValidationService.class, "/remoting/entityvalidation.service", new CdmServiceRequestExecutor());
+        }
         @Override
         public IEntityConstraintViolationService getEntityConstraintViolationService(){
             return (IEntityConstraintViolationService) getBean("entityConstraintViolationService");
             return (IEntityConstraintViolationService) getService(IEntityConstraintViolationService.class, "/remoting/entityconstraintviolation.service", new CdmServiceRequestExecutor());
+        }
         @Override
         public ICdmPermissionEvaluator getPermissionEvaluator(){
             return (ICdmPermissionEvaluator) getBean("cdmPermissionEvaluator");
             if(cdmPermissionEvaluator != null) {
                 return cdmPermissionEvaluator;
+            }
             List<AccessDecisionVoter> decisionVoters = new ArrayList<AccessDecisionVoter>();
             decisionVoters.add(new GrantAlwaysVoter());
             decisionVoters.add(new TaxonNodeVoter());
             decisionVoters.add(new TaxonBaseVoter());
             decisionVoters.add(new DescriptionBaseVoter());
             decisionVoters.add(new DescriptionElementVoter());
             UnanimousBasedUnrevokable accessDecisionManager = new UnanimousBasedUnrevokable(decisionVoters);
             cdmPermissionEvaluator = new CdmPermissionEvaluator();
             cdmPermissionEvaluator.setAccessDecisionManager(accessDecisionManager);
             return cdmPermissionEvaluator;
+        }
-...
             SecurityContext context = SecurityContextHolder.getContext();
             context.setAuthentication(authentication);
+        }
         public IIOService getIOService() {
             return (IIOService) getService(IIOService.class, "/remoting/io.service", new CdmServiceRequestExecutor());
+        }
         public ITestService getTestService() {
             return (ITestService) getService(ITestService.class, "/remoting/test.service", new CdmServiceRequestExecutor());
+        }
+    }

     package eu.etaxonomy.cdm.api.application;
     import java.util.List;
     import java.util.Properties;
     import org.apache.log4j.Logger;
     import org.hibernate.collection.internal.AbstractPersistentCollection;
     import org.hibernate.proxy.AbstractLazyInitializer;
     import org.springframework.beans.factory.xml.XmlBeanDefinitionReader;
     import org.springframework.context.ApplicationListener;
     import org.springframework.context.support.GenericApplicationContext;
     import org.springframework.context.support.PropertySourcesPlaceholderConfigurer;
     import org.springframework.core.io.ClassPathResource;
     import org.springframework.core.io.Resource;
-...
                 new ClassPathResource("/eu/etaxonomy/cdm/remotingApplicationContext.xml");
         private final Resource applicationContextResource;
         private final IProgressMonitor progressMonitor;
         private ICdmRemoteSource remoteSource;
         /**
-...
             this.applicationContextResource =
                     applicationContextResource != null ? applicationContextResource : DEFAULT_REMOTE_APPLICATION_CONTEXT_RESOURCE;
             this.progressMonitor = progressMonitor != null ? progressMonitor : new NullProgressMonitor();
             this.remoteSource = remoteSource;
             setNewRemoteSource(remoteSource, validateXml, listeners);
+        }
-...
             logger.info("Connecting to '" + remoteSource.getName() + "'");
             GenericApplicationContext applicationContext =  new GenericApplicationContext();
             int nTasks = 3;
             int nTasks = 2;
             progressMonitor.beginTask("Connecting to '" + remoteSource.getName() + "'", nTasks);
             progressMonitor.subTask("Initialising CDM Model Cache ...");
             CdmRemoteCacheManager.getInstance();
             progressMonitor.subTask("Loading context beans ...");
             PropertySourcesPlaceholderConfigurer pspc = new PropertySourcesPlaceholderConfigurer();
             Properties properties = new Properties();
             properties.setProperty("remoteServer", remoteSource.getServer());
             properties.setProperty("remotePort", String.valueOf(remoteSource.getPort()));
             properties.setProperty("remoteContext", remoteSource.getContextPath());
             pspc.setProperties(properties);
             applicationContext.addBeanFactoryPostProcessor(pspc);
             applicationContext.getEnvironment().setActiveProfiles("remoting");
             XmlBeanDefinitionReader xmlReader = new XmlBeanDefinitionReader(applicationContext);
             if(!validateXml) {
                 xmlReader.setValidating(false);
+            }
             xmlReader.loadBeanDefinitions(applicationContextResource);
             if (listeners != null){
                 for(ApplicationListener listener : listeners){
                     applicationContext.addApplicationListener(listener);
+                }
+            }
             progressMonitor.worked(1);
             progressMonitor.subTask("Starting application context ...");
             applicationContext.refresh();
             applicationContext.start();
             setApplicationContext(applicationContext);
             init();
             progressMonitor.worked(1);
             progressMonitor.done();
             return true;
-...
          */
         @Override
         protected void init(){
             // retrieving the application configuration
             configuration = (ICdmApplicationConfiguration)applicationContext.getBean("cdmApplicationRemoteConfiguration");
             configuration = new CdmApplicationRemoteConfiguration(remoteSource);
             ((CdmApplicationRemoteConfiguration)configuration).setApplicationContext(applicationContext);
             AbstractLazyInitializer.setConfiguration((CdmApplicationRemoteConfiguration)configuration);
             AbstractPersistentCollection.setConfiguration((CdmApplicationRemoteConfiguration)configuration);
+        }
         public ICdmEntitySessionManager getCdmEntitySessionManager() {
-...
+        }
         public IIOService getIOService(){
             return (IIOService) getBean("ioService");
             return ((CdmApplicationRemoteConfiguration)configuration).getIOService();
+        }
         public ITestService getTestService(){
             return (ITestService) getBean("testService");
             return ((CdmApplicationRemoteConfiguration)configuration).getTestService();
+        }
         public ICachedCommonService getCachedCommonService(){
             return (ICachedCommonService) getBean("cachedCommonService");
             return ((CdmApplicationRemoteConfiguration)configuration).getCachedCommonService();
+        }
+    }

     import eu.etaxonomy.cdm.api.service.IService;
     import eu.etaxonomy.cdm.config.ICdmSource;
     import eu.etaxonomy.cdm.database.DbSchemaValidation;
     import eu.etaxonomy.cdm.ext.geo.IEditGeoService;
     import eu.etaxonomy.cdm.model.common.CdmBase;
     import eu.etaxonomy.cdm.model.common.Language;
     import eu.etaxonomy.cdm.persistence.hibernate.permission.CRUD;
-...
             return getCurrentApplicationConfiguration().getPermissionEvaluator();
+        }
         /**
          * <p>
          * getGeoService
          * </p>
+         *
          * @return a {@link eu.etaxonomy.cdm.ext.geo.IEditGeoService} object.
          */
         public static IEditGeoService getGeoService() {
             return (IEditGeoService) getCurrentApplicationConfiguration().getBean(
                     "editGeoService");
+        }
         /*
          * SECURITY RELATED CONVENIENCE METHODS

                             if (!monitor.isCanceled()) {
                                 CdmStore.setInstance(applicationController, cdmSource);
                                 monitor.subTask("Authenticating user and starting editor context...");
                                 monitor.subTask("Authenticating user");
                                 display.syncExec(new Runnable() {
                                     /*
                                      * (non-Javadoc)
-...
                                             // create new security context
                                             CdmStore.getLoginManager().doAuthenticate(loginDialog.getUsername(), loginDialog.getPassword());
                                             loginDialog.onComplete();
                                             // start editor context
                                             CdmStore.getContextManager().notifyContextStartWithoutDialog(monitor);
                                             CdmStore.getContextManager().notifyContextStart();
                                         } catch(CdmAuthenticationException cae) {
                                             loginDialog.hide(false);
                                             loginDialog.setMessage(cae.getMessage());

     import org.eclipse.swt.SWT;
     import org.eclipse.swt.widgets.Label;
     import eu.etaxonomy.cdm.api.application.CdmApplicationRemoteConfiguration;
     import eu.etaxonomy.cdm.common.UriUtils;
     import eu.etaxonomy.cdm.ext.geo.IEditGeoService;
     import eu.etaxonomy.cdm.model.common.Language;
     import eu.etaxonomy.cdm.model.description.PresenceAbsenceTerm;
     import eu.etaxonomy.cdm.model.description.TaxonDescription;
-...
     		List<Language> languages = Arrays.asList(new Language[]{CdmStore.getDefaultLanguage()});
     		String parameter = CdmStore.getGeoService().getDistributionServiceRequestParameterString(
     		IEditGeoService editGeoService = ((CdmApplicationRemoteConfiguration)CdmStore.getCurrentApplicationConfiguration()).getEditGeoService();
     		String parameter = editGeoService.getDistributionServiceRequestParameterString(
     				getTaxonDescriptions(),
                     false,
                     false,

Also available in: Unified diff

Project

General

Profile

EDIT

Revision 390328ab

Added by Cherian Mathew over 8 years ago