logger.debug("Process {} is already executed.", p);
                }
            }
        }

        /**
         * Checks if the destroyer has been executed.
         * @return True if executed, false otherwise.
         */
        public boolean isExecuted() {
            return executed.get();
        }
    }

    /**

# Lifespan Events { #lifespan-events }

You can define logic (code) that should be executed before the application **starts up**. This means that this code will be executed **once**, **before** the application **starts receiving requests**.

The same way, you can define logic (code) that should be executed when the application is **shutting down**. In this case, this code will be executed **once**, **after** having handled possibly **many requests**.

Only the code prior to and including the `yield` statement is executed before creating a response:

{* ../../docs_src/dependencies/tutorial007_py39.py hl[2:4] *}

The yielded value is what is injected into *path operations* and other dependencies:

{* ../../docs_src/dependencies/tutorial007_py39.py hl[4] *}

The code following the `yield` statement is executed after the response:

{* ../../docs_src/debugging/tutorial001_py39.py hl[1,15] *}

### About `__name__ == "__main__"` { #about-name-main }

The main purpose of the `__name__ == "__main__"` is to have some code that is executed when your file is called with:

<div class="termy">

```console
$ python myapp.py
```

</div>

but is not called when another file imports it, like in:

```Python
from myapp import app
```

    @Resource
    private ScheduledJobService scheduledJobService;

    @Resource
    private SystemHelper systemHelper;

    @Resource
    private JobHelper jobHelper;

    /** The job class to be executed by this scheduler */
    protected Class<? extends LaJob> jobClass = ScriptExecutorJob.class;

    /** The timestamp when the scheduler was last updated */
    protected long schedulerTime;

    @Override

        super("synonym.*\\.txt");
    }

    /**
     * Registers this creator with the dictionary manager upon initialization.
     * This method is annotated with {@link PostConstruct} to be executed after
     * dependency injection is complete.
     */
    @PostConstruct
    public void register() {
        if (logger.isInfoEnabled()) {
            logger.info("Loaded {}", this.getClass().getSimpleName());

* All of them will include the predefined `responses`.
* All these *path operations* will have the list of `dependencies` evaluated/executed before them.
    * If you also declare dependencies in a specific *path operation*, **they will be executed too**.

        super("stopwords.*\\.txt");
    }

    /**
     * Registers this creator with the dictionary manager upon initialization.
     * This method is annotated with {@link PostConstruct} to be executed after
     * dependency injection is complete.
     */
    @PostConstruct
    public void register() {
        if (logger.isInfoEnabled()) {
            logger.info("Loaded {}", this.getClass().getSimpleName());

        super("stemmer_override.*\\.txt");
    }

    /**
     * Registers this creator with the dictionary manager upon initialization.
     * This method is annotated with {@link PostConstruct} to be executed after
     * dependency injection is complete.
     */
    @PostConstruct
    public void register() {
        if (logger.isInfoEnabled()) {
            logger.info("Loaded {}", this.getClass().getSimpleName());

        return (context, query, boost) -> filter.execute(context, query, boost, chain);
    }

    /**
     * Creates the default filter chain that executes query commands.
     * This chain looks up the appropriate query command based on the query class name
     * and executes it. If no command is found, throws an InvalidQueryException.
     *