Study & Dev | Blog Archive | Tiles2 и Sping: Перезагрузка

Tiles2 и Sping: Перезагрузка

May 1, 2008

Введение в суть проблемы

Я продолжаю выкладывать некоторые из своих наработок. Сегодня на очереди (так же как и в прошлый раз) несколько способов улучшить и облегчить жизнь java программистов использующих spring. Я расскажу об перезагрузке контекста spring и определений tiles2.

Одним из моментов, которые мне никогда не нравились в java (точнее в серверном программировании под нее), были большие затраты на перезапуск приложения после изменений. В то время как для других скрипт-основанных языков я просто изменял текст кода и жал в браузере кнопку "F5", то в java все было хуже. Хотя изменение кода сосредоточенного в jsp слое является наиболее безболезненным (просто замени текст файла и нажми "F5"), с изменением бизнес-логики все хуже. В случае небольших правок без изменения сигнатур методов, добавления новых классов и интенсивного рефакторинга, больших проблем нет - работает hotswap и изменения в коде проявляются мгновенно. В обратном случае вам приходится перезапускать контекст веб-приложения, либо набрав в адресной строке браузера сакраментальное.

http://center:8080/manager/reload?path=/НАЗВАНИЕ_МОЕГО_ВЕБ_ПРИЛОЖЕНИЯ

Либо использовать ant-задачи, например (спасибо товарищу Thomas Risberg за вырезанный из его книжки пример кода):

Собственно данный кусочек кода не будет слишком полезным продвинутым в java товарищам, но для начинающих почему бы и не скопировать еще раз классические строки.

<!-- ============================================================== -->

<!-- Tomcat tasks - remove these if you don't have Tomcat installed -->

<!-- ============================================================== -->

<!-- определять таким образом переменные не красиво, но путь будет так  -->

    <property name="appserver.home" location="E:\Program_Files_2\apache-tomcat-6.0.14" />

    <property name="tomcat.manager.url" value="http://localhost:8080/manager" />

    <property name="tomcat.manager.username" value="tomcat" />

    <property name="tomcat.manager.password" value="tomcat" />

    <property name="deploy.path" location="${appserver.home}/webapps" />

    <property name="name-web-app" value="Название-Моего-Мега-Приложения" />

    <property name="path-to-war-file" location="То-Самое-Место-Где-Находится-Архив-Нашего-Приложения" />

```
 
```
```
 
```
```
 
```

    <taskdef name="install" classname="org.apache.catalina.ant.InstallTask">

```
        <classpath>
```

            <path location="${appserver.home}/lib/catalina-ant.jar"/>

```
        </classpath>
```
```
    </taskdef>
```

    <taskdef name="reload" classname="org.apache.catalina.ant.ReloadTask">

```
        <classpath>
```

            <path location="${appserver.home}/lib/catalina-ant.jar"/>

```
        </classpath>
```
```
    </taskdef>
```

    <taskdef name="list" classname="org.apache.catalina.ant.ListTask">

```
        <classpath>
```

            <path location="${appserver.home}/lib/catalina-ant.jar"/>

```
        </classpath>
```
```
    </taskdef>
```

    <taskdef name="start" classname="org.apache.catalina.ant.StartTask">

```
        <classpath>
```

            <path location="${appserver.home}/lib/catalina-ant.jar"/>

```
        </classpath>
```
```
    </taskdef>
```

    <taskdef name="stop" classname="org.apache.catalina.ant.StopTask">

```
        <classpath>
```

            <path location="${appserver.home}/lib/catalina-ant.jar"/>

```
        </classpath>
```
```
    </taskdef>
```
```
 
```

    <target name="install" description="Install application in Tomcat">

        <install url="${tomcat.manager.url}"

                 username="${tomcat.manager.username}"

                 password="${tomcat.manager.password}"

                 path="/${name-web-app}"

                 war="${path-to-war-file}"/>

```
    </target>
```
```
 
```

    <target name="reload" description="Reload application in Tomcat">

        <echo message="${path-to-war-file}" />

```
 
```

        <reload url="${tomcat.manager.url}"

                username="${tomcat.manager.username}"

                password="${tomcat.manager.password}"

                path="/${name-web-app}"/>

```
    </target>
```
```
 
```

    <target name="start" description="Start Tomcat application">

        <start url="${tomcat.manager.url}"

               username="${tomcat.manager.username}"

               password="${tomcat.manager.password}"

               path="/${name-web-app}"/>

```
    </target>
```
```
 
```

    <target name="stop" description="Stop Tomcat application">

        <stop url="${tomcat.manager.url}"

              username="${tomcat.manager.username}"

              password="${tomcat.manager.password}"

```
              path="/${name-web-app}"/>
```
```
    </target>
```
```
 
```

    <target name="list" description="List Tomcat applications">

        <list url="${tomcat.manager.url}"

              username="${tomcat.manager.username}"

              password="${tomcat.manager.password}"/>

```
    </target>
```
```
 
```
```

```

В любом случае перезапуск веб-приложения может занять десяток-другой секунд (Боже, неужели прошли те времена когда я запускал сборку c++ приложения, откидывался на спинку стула и блаженно засыпал на минут 15). И если есть какой-то способ ускорить итерацию разработки, то ее нужно использовать. Собственно, когда я пишу с помощью spring, то есть особый вариант изменений, промежуточный между полным перезапуском веб-приложения и просто-поменяй-пару-файлов-jsp. Это ситуация обновления (перечитать все определения в контексте spring) и все определения из файла конфигурации tiles2. Надо сказать, что и в том, и в том инструментах предусмотрены стандартные механизмы для перезапуска конфигурации. Однако, я не нашел каких-то средств явно указать правила по которым будет выполняться перегрузка контекстов (если вы оказались зорче меня и знаете такой прием, то сообщите - буду благодарен).

Поэтому я решил написать два бина, которые добавляются в ваш spring-файл и выполняют периодическое определение того, нужно ли перечитать определения (на основании изменения даты последней модификации файлов) и запускают это самое обновление.

Сначала пример использования:

<bean id="tiles2ReloadBean" class="blz.server.utils.Tiles2ReloadBean">

        <property name="logOnlyIfErrorsOrReloadOccuried" value="true"/>

        <property name="interval" value="1000"/>

```
    </bean>
```
```
 
```

    <bean id="springReloadBean" class="blz.server.utils.SpringReloadBean">

        <property name="logOnlyIfErrorsOrReloadOccuried" value="true"/>

        <property name="intervalForScan" value="200"/>

        <property name="delayForRefresh" value="1000"/>

```
    </bean>
```

В первом случае, с перегрузкой tiles2 определений я должен указать только один конфигурационный параметр: интервал через которое будет выполняться сканирование ресурсов на предмет их обновления. Время как это и принято везде задается в миллисекундах. Второй параметр (logOnlyIfErrorsOrReloadOccuried - необязательный и играет нужен в основном для целей отладки, чтобы сообщать об каждом шаге в жизненном цикле "Бина-Нео").

Второй бин (SpringReloadBean) имеет два параметра: время для сканирования intervalForScan - его я устанавливаю как можно меньше - управляет тем как часто будут выполняться проверки были ли изменены файлы spring. Как только такое изменение было обнаружено, то срабатывает отложенное на некоторое время задание перезагрузить контекст spring. Величина такой задержки задается с помощью delayForRefresh. Дело в том, что я не решился запускать обновление одновременно, т.к. скорее всего изменение файлов контекста выполняется не атомарно, и лучше подождать секунду, до того как все файлы придут (будут скопированы) в актуальное состояние.

Могу сказать, что в код приложенного далее бина "перезагружающего spring", можно добавить поддержку перезагрузки не только тогда, когда изменился какой-то из xml-файлов, составляющих контекст, но и файлов настроек. Но я считаю такую функциональность не настолько важной и решил не усложнять.

Исходники бинов

Сначала код бина SpringReloadBean:

```
package blz.server.utils;
```
```
 
```

import org.springframework.beans.BeansException;

import org.springframework.context.ApplicationContext;

import org.springframework.context.ApplicationContextAware;

import org.springframework.context.ApplicationEvent;

import org.springframework.context.ApplicationListener;

import org.springframework.context.event.ContextClosedEvent;

import org.springframework.context.event.ContextRefreshedEvent;

import org.springframework.web.context.support.AbstractRefreshableWebApplicationContext;

```
 
```
```
import java.io.BufferedReader;
```
```
import java.io.File;
```
```
import java.io.FileReader;
```
```
import java.io.IOException;
```
```
import java.util.*;
```
```
import java.util.logging.Logger;
```
```
 
```
```
 
```
```
/**
```

 * Класс обеспечивающий перезагрузку контекста spring при изменении xml-файлов с его определениями

```
 */
```

public class SpringReloadBean implements ApplicationContextAware, ApplicationListener {

```
 
```

    AbstractRefreshableWebApplicationContext applicationContext;

```
 
```

    public synchronized void setApplicationContext(ApplicationContext applicationContext) throws BeansException {

        logger.info("SpringReloadBean.setApplicationContext got ApplicationContext");

        this.applicationContext = (AbstractRefreshableWebApplicationContext) applicationContext;

```
    }
```
```
 
```

    public synchronized void onApplicationEvent(ApplicationEvent event) {

        if (event instanceof ContextRefreshedEvent) {

            applicationContext = (AbstractRefreshableWebApplicationContext) event.getSource();

            logger.info("SpringReloadBean.onApplicationEvent on ContextRefreshedEvent");

            timer.schedule(taskScanFiles, new Date(new Date().getTime() +

              delayForRefresh + delayForRefresh), intervalForScan);

```
        }
```

        if (event instanceof ContextClosedEvent) {

```
            applicationContext = null;
```

            logger.info("SpringReloadBean.onApplicationEvent on ContextClosedEvent");

```
            taskScanFiles.cancel();
```
```
            timer.purge();
```
```
        }
```
```
 
```
```
    }
```
```
 
```
```
 
```

    Logger logger = Logger.getLogger(SpringReloadBean.class.getName());

```
    /**
```

     * Интервал, через который нужно выполнять сканирование файлов контекста на предмет их изменений (в ms.)

```
     */
```
```
    Integer intervalForScan = 500;
```
```
 
```

    public synchronized void setIntervalForScan(Integer intervalForScan) {

```
        if (intervalForScan < 100)
```

            throw new IllegalArgumentException("too low delay for SpringReloadBean.interval (min value 100 ms.)");

        this.intervalForScan = intervalForScan;

```
    }
```
```
 
```
```
    /**
```

     * Интервал, через который после обнаружения изменений в файлах контекста нужно выполнить его перезагрузку

```
     */
```
```
    Integer delayForRefresh = 1000;
```
```
 
```

    public synchronized void setDelayForRefresh(Integer delayForRefresh) {

```
        if (delayForRefresh < 0)
```

            throw new IllegalArgumentException("too low delay for SpringReloadBean.delayForRefresh (min value 0 ms.)");

        this.delayForRefresh = delayForRefresh;

```
    }
```
```
 
```
```
 
```
```
    /**
```

     * Свойство признак того, что сообщения в log будут выводиться только в тех случаях когда произошли ошибки или

     * контекст был действительно перезагружен

```
     */
```

    Boolean logOnlyIfErrorsOrReloadOccuried = true;

```
 
```

    public void setLogOnlyIfErrorsOrReloadOccuried(Boolean logOnlyIfErrorsOrReloadOccuried) {

        this.logOnlyIfErrorsOrReloadOccuried = logOnlyIfErrorsOrReloadOccuried;

```
    }
```
```
 
```
```
    /**
```

     * Переменная признак того, что задание на обновление контекста уже было задано

```
     */
```

    Boolean refreshTaskWasPlanned = false;

```
 
```
```
    /**
```

     * Создаем объект Timer и TimerTask, но запуск задачи будет выполнен только

     * после получения извещения о том, что контекст был запущен

```
     */
```
```
    public SpringReloadBean() {
```
```
        timer = new Timer(true);
```
```
 
```

        taskRefreshContext = new TimerTask() {

```
            public void run() {
```
```
                executeRefresh();
```
```
                timer.purge();
```

                // помечаем то что задача перезагрузки контекста была успешно выполнена

                // и теперь можно снова сканировать файлы контекста на предмет  их изменения

                refreshTaskWasPlanned = false;

```
            }
```
```
        };
```
```
 
```

        taskScanFiles = new TimerTask() {

```
            public void run() {
```

                if (!logOnlyIfErrorsOrReloadOccuried)

                    logger.info("SpringReloadBean -- prepare execute taskScanFiles");

                if (applicationContext == null) {

                    logger.severe("SpringReloadBean -- skip execute taskScanFiles,

                            because no applicationContext available");

```
                    return;
```
```
                }
```

                if (!logOnlyIfErrorsOrReloadOccuried)

                    logger.info("SpringReloadBean -- ready execute taskScanFiles");

```
 
```

                if ((!refreshTaskWasPlanned) && isContextFilesWereModified()) {

                    logger.info("SpringReloadBean -- context files were modified");

                    if (delayForRefresh == 0) {

                        // если значение параметра времени задержки перед обновлением контекста равно нулю,

                        // то нет никакого смысла том чтобы добавлять новое задание таймеру

                        logger.info("SpringReloadBean -- execute immediately refresh, no delay");

                        executeRefresh();

```
                    } else {
```

                        // а если время задержки перед обновлением контекста указано, то добавляем новое задание таймеру

                        logger.info("SpringReloadBean -- shedule refresh after " + delayForRefresh + " ms.");

                        // помечаем то что задание на обновление контекста было выдано

                        refreshTaskWasPlanned = true;

                        timer.schedule(taskRefreshContext, delayForRefresh);

```
                    }
```

                }// if files were modified

```
            }
```
```
        };
```
```
    }
```
```
 
```
```
    private void executeRefresh() {
```

        long now = System.currentTimeMillis();

        // а теперь перезапускаем контекст, к счастью данный метод выполняется в отдельном потоке

        // а иначе бы я даже не знал что может произойти

        final long contextStarted = applicationContext.getStartupDate();

        Date contextDat = new Date(contextStarted);

        logger.info("context was loaded last time at " + contextDat);

```
        applicationContext.refresh();
```

        // очищаем список найденных файлов образующих контекст, т.к. после перезагрузки контекста могли

        // появиться новые файлы и нужно выполнить пересканирование их содержимого

```
        scannedFiles.clear();
```

        long now2 = System.currentTimeMillis();

        logger.info("time used to refresh context = " + (now2 - now) + " ms.");

```
    }
```
```
 
```
```
 
```
```
    private TimerTask taskScanFiles;
```

    private TimerTask taskRefreshContext;

    private Timer timer = new Timer(true);

```
 
```
```
    /**
```

     * Сведения об файлах, которые образуют данные для контекста

```
     */
```

    private HashSet<String> scannedFiles = new HashSet<String>();

```
 
```

    public synchronized boolean isContextFilesWereModified() {

```
 
```
```
        if (scannedFiles.size() == 0) {
```

            ArrayList<File> tasks = new ArrayList<File>();

            final String[] locations = applicationContext.getConfigLocations();

            for (String location : locations) {

                File fullFile = new File(applicationContext.getServletContext().getRealPath(location));

```
                tasks.add(fullFile);
```
```
            }
```

            for (int i = 0; i < tasks.size(); i++) {

```
                File f = tasks.get(i);
```

                if (scannedFiles.contains(f.getAbsolutePath())) continue;

                scannedFiles.add(f.getAbsolutePath());

```
 
```
```
                try {
```

                    BufferedReader brin = new BufferedReader(new FileReader(f));

                    StringBuffer buf = new StringBuffer();

```
                    String line = null;
```
```
 
```

                    while ((line = brin.readLine()) != null)

                        buf.append(line).append("\n");

```
                    brin.close();
```
```
 
```

                    //<import resource="tmspring-mappings.xml" />

                    //"<(\\w+:)?import\\s+resource=[\"']([^\"']+)[\"']"

                    List<List<String>> arr_got = new ArrayList<List<String>>();

                    final String fileContent = buf.toString();

                    if (!RegexpUtils.preg_match_all("/<(\\w+:)?import\\s+resource=[\"']([^\"']+)[\"']/im",

                            fileContent, arr_got))

```
                        continue;
```
```
 
```

                    for (List<String> stringList : arr_got) {

                        tasks.add(new File(f.getParentFile(), stringList.get(2)));

```
                    }
```

                } catch (IOException e) {

                    e.printStackTrace();

```
                }
```
```
            }// scan all tasks
```

        }// if scanned files arrays is empty

```
 
```

        final long contextStarted = applicationContext.getStartupDate();

        for (String scannedFile : scannedFiles) {

            File f = new File(scannedFile);

            final long lastModified = f.lastModified();

            if (lastModified > contextStarted) {

                logger.info("SpringReloadBean -- found newer file '" + scannedFile +

                      "' modified at '" + new Date(lastModified) + "' vs. context startupDate '" +

                      new Date(contextStarted) + "'");

```
                return true;
```
```
            }
```
```
        }
```
```
 
```
```
        return false;
```
```
    }
```
```
}
```

Теперь код бина Tiles2ReloadBean:

```
package blz.server.utils;
```
```
 
```
```
import org.apache.tiles.TilesContainer;
```

import org.apache.tiles.access.TilesAccess;

import org.apache.tiles.definition.DefinitionsFactory;

import org.apache.tiles.definition.DefinitionsFactoryException;

import org.apache.tiles.definition.ReloadableDefinitionsFactory;

import org.apache.tiles.impl.BasicTilesContainer;

import org.springframework.beans.BeansException;

import org.springframework.context.ApplicationContext;

import org.springframework.context.ApplicationContextAware;

import org.springframework.context.ApplicationEvent;

import org.springframework.context.ApplicationListener;

import org.springframework.context.event.ContextClosedEvent;

import org.springframework.context.event.ContextRefreshedEvent;

import org.springframework.web.context.ServletContextAware;

import org.springframework.web.context.support.AbstractRefreshableWebApplicationContext;

```
 
```
```
import javax.servlet.ServletContext;
```
```
import java.util.Date;
```
```
import java.util.Timer;
```
```
import java.util.TimerTask;
```
```
import java.util.logging.Logger;
```
```
 
```
```
/**
```

 * Сервисный бин. Назначением которого является автоматическая перегрузка контекста tiles2

```
 */
```

public class Tiles2ReloadBean implements ApplicationContextAware,

                ApplicationListener, ServletContextAware {

```
 
```

    Logger logger = Logger.getLogger(Tiles2ReloadBean.class.getName());

```
    /**
```

     * Интервал, через который нужно выполнять перегрузку контекста (в ms.)

```
     */
```
```
    Integer interval = 2000;
```
```
 
```

    public void setInterval(Integer interval) {

```
        if (interval <= 100)
```

            throw new IllegalArgumentException("too low delay for Tiles2ReloadBean.interval (min value 100 ms.)");

```
        this.interval = interval;
```
```
    }
```
```
 
```
```
    /**
```

     * Свойство признак того, что сообщения в log будут выводиться только в тех случаях когда произошли ошибки или

     * контекст был действительно перезагружен

```
     */
```

    Boolean logOnlyIfErrorsOrReloadOccuried = true;

```
 
```

    public void setLogOnlyIfErrorsOrReloadOccuried(Boolean logOnlyIfErrorsOrReloadOccuried) {

        this.logOnlyIfErrorsOrReloadOccuried = logOnlyIfErrorsOrReloadOccuried;

```
    }
```
```
 
```
```
    ServletContext servletContext;
```
```
 
```

    public void setServletContext(ServletContext servletContext) {

        this.servletContext = servletContext;

```
    }
```
```
 
```
```
    public Tiles2ReloadBean() {
```
```
        timer = new Timer(true);
```
```
        task = new TimerTask() {
```
```
            public void run() {
```

                ServletContext contextFromWebContext = applicationContext.getServletContext();

                if (!logOnlyIfErrorsOrReloadOccuried)

                    logger.info("Tiles2ReloadBean -- prepare execute task");

                // такой странный код обусловлен не менее странным багом, внутри объекта ApplicationContext

                // вполне может не оказаться ссылки на контекст сервлетов ?

                if (contextFromWebContext == null && servletContext == null) {

                    logger.severe("Tiles2ReloadBean -- skip execute task, because no servlet context available");

```
                    return;
```
```
                }
```

                if (!logOnlyIfErrorsOrReloadOccuried)

                    logger.info("Tiles2ReloadBean -- ready execute task");

                TilesContainer container = TilesAccess.getContainer(contextFromWebContext);

                if (container instanceof BasicTilesContainer) {

                    if (!logOnlyIfErrorsOrReloadOccuried)

                        logger.info("Tiles2ReloadBean -- yes. container instanceof BasicTilesContainer");

                    BasicTilesContainer basic = (BasicTilesContainer) container;

                    DefinitionsFactory factory = basic.getDefinitionsFactory();

                    if (factory instanceof ReloadableDefinitionsFactory) {

                        if (!logOnlyIfErrorsOrReloadOccuried)

                            logger.info("Tiles2ReloadBean -- yes. factory instanceof ReloadableDefinitionsFactory");

                        ReloadableDefinitionsFactory rFactory = (ReloadableDefinitionsFactory) factory;

                        if (rFactory.refreshRequired()) {

                            logger.info("Tiles2ReloadBean -- yes. context refreshed");

```
                            try {
```

                                rFactory.refresh();

                            } catch (DefinitionsFactoryException e) {

                                e.printStackTrace();

```
                            }
```
```
                        } else {
```

                            if (!logOnlyIfErrorsOrReloadOccuried)

                                logger.info("Tiles2ReloadBean -- skip. no refresh is required");

```
                        }
```
```
                    }
```
```
                }
```
```
            }
```
```
        };
```
```
    }
```
```
 
```
```
    private TimerTask task;
```

    private Timer timer = new Timer(true);

```
 
```
```
 
```

    AbstractRefreshableWebApplicationContext applicationContext;

```
 
```

    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {

        logger.info("Tiles2ReloadBean.setApplicationContext got ApplicationContext");

        this.applicationContext = (AbstractRefreshableWebApplicationContext) applicationContext;

```
    }
```
```
 
```
```
    /**
```

     * А так нас извещают о том, что контекст spring был запущен или остановлен

```
     *
```
```
     * @param event
```
```
     */
```

    public void onApplicationEvent(ApplicationEvent event) {

        if (event instanceof ContextRefreshedEvent) {

            applicationContext = (AbstractRefreshableWebApplicationContext) event.getSource();

            logger.info("Tiles2ReloadBean.onApplicationEvent on ContextRefreshedEvent");

            timer.schedule(task, new Date(new Date().getTime() + interval), interval);

```
        }
```

        if (event instanceof ContextClosedEvent) {

```
            applicationContext = null;
```

            logger.info("Tiles2ReloadBean.onApplicationEvent on ContextClosedEvent");

```
            task.cancel();
```
```
            timer.purge();
```
```
        }
```
```
    }
```
```
 
```
```
 
```
```
}
```

Для того чтобы выполнять сканирование xml-файлов spring на предмет подключенных ресурсов с помощью regexp-ов я использую свою небольшую библиотечку-надстройку над java regexp-ами (я ее описал недавно в статье Regexp-ы для java точь в точь как для php). Так что, скопируйте код оттуда, или перепишите regexp-ы под java classic.

Categories: Разные мелкие утилитки

Study & DevО программировании и не только

Tiles2 и Sping: Перезагрузка

Введение в суть проблемы

Исходники бинов

Поиск

Недавнее

Архив

Разделы