Java tutorial
/* This file is part of Cyclos (www.cyclos.org). A project of the Social Trade Organisation (www.socialtrade.org). Cyclos is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. Cyclos is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with Cyclos; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ package nl.strohalm.cyclos.services.customization; import java.io.InputStream; import java.io.InputStreamReader; import java.io.Reader; import java.util.ArrayList; import java.util.Iterator; import java.util.List; import java.util.Locale; import java.util.Map; import java.util.Properties; import nl.strohalm.cyclos.dao.customizations.TranslationMessageDAO; import nl.strohalm.cyclos.entities.customization.translationMessages.TranslationMessage; import nl.strohalm.cyclos.entities.customization.translationMessages.TranslationMessageQuery; import nl.strohalm.cyclos.entities.exceptions.EntityNotFoundException; import nl.strohalm.cyclos.entities.settings.LocalSettings; import nl.strohalm.cyclos.services.InitializingService; import nl.strohalm.cyclos.services.fetch.FetchServiceLocal; import nl.strohalm.cyclos.services.settings.SettingsServiceLocal; import nl.strohalm.cyclos.utils.CacheCleaner; import nl.strohalm.cyclos.utils.DataIteratorHelper; import nl.strohalm.cyclos.utils.TransactionHelper; import nl.strohalm.cyclos.utils.cache.Cache; import nl.strohalm.cyclos.utils.cache.CacheAdapter; import nl.strohalm.cyclos.utils.cache.CacheCallback; import nl.strohalm.cyclos.utils.cache.CacheManager; import nl.strohalm.cyclos.utils.conversion.LocaleConverter; import nl.strohalm.cyclos.utils.transaction.CurrentTransactionData; import nl.strohalm.cyclos.utils.transaction.TransactionCommitListener; import nl.strohalm.cyclos.utils.validation.Validator; import org.apache.commons.io.IOUtils; import org.apache.commons.lang.StringUtils; import org.springframework.beans.factory.InitializingBean; import org.springframework.transaction.TransactionStatus; import org.springframework.transaction.support.TransactionCallbackWithoutResult; /** * Implementation for message service * @author luis */ public class TranslationMessageServiceImpl implements TranslationMessageServiceLocal, InitializingBean, InitializingService { private static final String PROPERTIES_KEY = "_PROPERTIES"; private TranslationMessageDAO translationMessageDao; private FetchServiceLocal fetchService; private CacheManager cacheManager; private SettingsServiceLocal settingsService; private TransactionHelper transactionHelper; private final List<TranslationChangeListener> listeners = new ArrayList<TranslationChangeListener>(); @Override public void addTranslationChangeListener(final TranslationChangeListener listener) { listeners.add(listener); } @Override public void afterPropertiesSet() throws Exception { getCache().addListener(new CacheAdapter() { @Override public void onCacheCleared(final Cache cache) { transactionHelper.runInCurrentThread(new TransactionCallbackWithoutResult() { @Override protected void doInTransactionWithoutResult(final TransactionStatus status) { notifyListeners(exportAsProperties()); } }); } }); } @Override public synchronized Properties exportAsProperties() { return getCache().get(PROPERTIES_KEY, new CacheCallback() { @Override public Object retrieve() { return translationMessageDao.listAsProperties(); } }); } @Override public void importFromProperties(final Properties properties, MessageImportType importType) { // Delete all messages if we will replace with the new file if (importType == MessageImportType.REPLACE) { translationMessageDao.deleteAll(); importType = MessageImportType.ONLY_NEW; } if (importType == MessageImportType.ONLY_NEW) { importOnlyNewProperties(properties); } else { final boolean emptyOnly = importType == MessageImportType.NEW_AND_EMPTY; importNewAndModifiedProperties(properties, emptyOnly); } clearCacheOnCommit(); } @Override public void initializeService() { final LocalSettings localSettings = settingsService.getLocalSettings(); Properties properties = readFile(localSettings.getLocale()); importFromProperties(properties, MessageImportType.NEW_AND_EMPTY); } @Override public TranslationMessage load(final Long id) { return translationMessageDao.load(id); } @Override public Properties readFile(final Locale locale) { final String language = LocaleConverter.instance().toString(locale); final String propertiesName = "ApplicationResources_" + language + ".properties"; InputStream in = Thread.currentThread().getContextClassLoader().getResourceAsStream("/" + propertiesName); final Properties properties = new Properties(); try { final Reader reader = new InputStreamReader(in, "UTF-8"); properties.load(reader); } catch (final Exception e) { // Ignore } finally { IOUtils.closeQuietly(in); } return properties; } @Override public int remove(final Long... ids) { final int count = translationMessageDao.delete(ids); clearCacheOnCommit(); return count; } @Override public TranslationMessage save(TranslationMessage translationMessage) { validate(translationMessage); if (translationMessage.isTransient()) { translationMessage = translationMessageDao.insert(translationMessage); } else { translationMessage = translationMessageDao.update(translationMessage); } clearCacheOnCommit(); return translationMessage; } @Override public List<TranslationMessage> search(final TranslationMessageQuery query) { return translationMessageDao.search(query); } public void setCacheManager(final CacheManager cacheManager) { this.cacheManager = cacheManager; } public void setFetchServiceLocal(final FetchServiceLocal fetchService) { this.fetchService = fetchService; } public void setSettingsServiceLocal(final SettingsServiceLocal settingsService) { this.settingsService = settingsService; } public void setTransactionHelper(final TransactionHelper transactionHelper) { this.transactionHelper = transactionHelper; } public void setTranslationMessageDao(final TranslationMessageDAO translationMessageDao) { this.translationMessageDao = translationMessageDao; } @Override public void validate(final TranslationMessage translationMessage) { getValidator().validate(translationMessage); } private void clearCacheOnCommit() { CurrentTransactionData.addTransactionCommitListener(new TransactionCommitListener() { @Override public void onTransactionCommit() { getCache().clear(); } }); } private Cache getCache() { return cacheManager.getCache("cyclos.TranslationMessages"); } private Validator getValidator() { final Validator validator = new Validator(); validator.property("key").required().maxLength(100); validator.property("value").maxLength(4000); return validator; } private void importNewAndModifiedProperties(final Properties properties, final boolean emptyOnly) { // Process existing messages. This is done with Object[], otherwise hibernate will load each message with a separate select final Iterator<Object[]> existing = translationMessageDao.listData(); try { while (existing.hasNext()) { final Object[] data = existing.next(); final String key = (String) data[1]; final String currentValue = (String) data[2]; final String newValue = properties.getProperty(key); if (newValue != null) { final boolean shallUpdate = !newValue.equals(currentValue) && (!emptyOnly || StringUtils.isEmpty(currentValue)); if (shallUpdate) { final TranslationMessage message = new TranslationMessage(); message.setId((Long) data[0]); message.setKey(key); message.setValue(newValue); translationMessageDao.update(message, false); } properties.remove(key); } } } finally { DataIteratorHelper.close(existing); } fetchService.clearCache(); // Only those who have to be inserted are left in properties insertAll(properties); } private void importOnlyNewProperties(final Properties properties) { final Iterator<String> allKeys = translationMessageDao.listAllKeys(); try { while (allKeys.hasNext()) { final String key = allKeys.next(); properties.remove(key); } } finally { DataIteratorHelper.close(allKeys); } // Only new keys are left on the properties object insertAll(properties); } private void insertAll(final Properties properties) { final CacheCleaner cacheCleaner = new CacheCleaner(fetchService); for (final Map.Entry<Object, Object> entry : properties.entrySet()) { final String key = (String) entry.getKey(); final String value = (String) entry.getValue(); final TranslationMessage translationMessage = new TranslationMessage(); translationMessage.setKey(key); translationMessage.setValue(value); try { // Try to load first final TranslationMessage existing = translationMessageDao.load(key); // Existing - update existing.setValue(value); translationMessageDao.update(existing, false); } catch (final EntityNotFoundException e) { // Not found - insert translationMessageDao.insert(translationMessage); } // Clear the entity cache to avoid an explosion of messages in cache cacheCleaner.clearCache(); } } private void notifyListeners(final Properties properties) { for (TranslationChangeListener listener : listeners) { listener.onTranslationsChanged(properties); } } }