Ninja Framework - Basic Concepts

https://www.ninjaframework.org/documentation/basic_concepts/basic_concepts.html
Admin
Ninja Framework is a web framework that maps URLs to controllers and generates responses using...
Tokens:33,715
Snippets:274
Trust Score:8.6
Update:1 year ago
Show doc for...
Tokens:
Raw
### Startup Customization

Source: https://www.ninjaframework.org/documentation/basic_concepts/basic_concepts.html/getting_started/the_anatomy_of_a_ninja_application

StartupActions.java allows for custom logic to be executed when the application starts up. This can include initializing services, loading data, or performing setup tasks.

```java
// src/main/java/conf/StartupActions.java
// Customization of application startup (Optional)
```

--------------------------------

### Check Maven Version

Source: https://www.ninjaframework.org/documentation/basic_concepts/basic_concepts.html/getting_started/installing_ninja

Verifies the installed Apache Maven version. Maven is used for building and creating new projects in the Java ecosystem, including Ninja Framework. A minimum of Maven 3 is recommended.

```shell
mvn -version
```

--------------------------------

### Check Java Version

Source: https://www.ninjaframework.org/documentation/basic_concepts/basic_concepts.html/getting_started/installing_ninja

Verifies the installed Java Development Kit (JDK) version on your system. Ninja Framework requires at least Java 1.8.

```shell
java -version
```

--------------------------------

### Define Application Routes in Java

Source: https://www.ninjaframework.org/documentation/basic_concepts/basic_concepts.html/basic_concepts/basic_concepts

Example of a Ninja Framework `Routes.java` file, demonstrating how to map HTTP GET requests to controller methods. This file acts as the entry point for HTTP requests.

```Java
public class Routes implements ApplicationRoutes {

    @Override
    public void init(Router router) {

        router.GET().route("/").with(ApplicationController::index);

    }
}
```

--------------------------------

### Build and Run Ninja Application in SuperDevMode

Source: https://www.ninjaframework.org/documentation/basic_concepts/basic_concepts.html/getting_started/create_your_first_application

Navigate to your generated project directory. Use 'mvn clean install' to build the project and 'mvn ninja:run' to start Ninja's SuperDevMode for rapid development. Access the application at http://localhost:8080.

```shell
cd MY_INSTALLED_PROJECT
mvn clean install
mvn ninja:run
```

--------------------------------

### Custom Java Startup for Ninja Console

Source: https://www.ninjaframework.org/documentation/basic_concepts/basic_concepts.html/console

Provides a Java example for programmatically starting and customizing the Ninja console application. Shows how to set the mode, start the application, access the injector, and shut it down.

```java
import ninja.standalone.NinjaConsole;
import ninja.utils.NinjaMode;

public class MyMain {

    static public void main(String[] args) throws Exception {
        NinjaConsole ninja = new NinjaConsole()
            .ninjaMode(NinjaMode.prod)
            .start();

        // other code (e.g. access guice injector)
        // ninja.getInjector();

        ninja.shutdown();
    }

}
```

--------------------------------

### Configure Maven Build for Clever Cloud Deployment (Java)

Source: https://www.ninjaframework.org/documentation/basic_concepts/basic_concepts.html/deployment/cloud_hosting_options

This JSON file configures the build and deployment process for a Java application on Clever Cloud using Maven. It specifies the Maven goal for building the application and the name of the generated JAR file for deployment. This setup enables automatic builds and deployments from a GitHub repository.

```json
{
  "build": {
    "type": "maven",
    "goal":"package -DskipTests"
  },
  "deploy": {
    "type": "jar",
    "jarName": "target/yourApplicationArtifactId-1.0-SNAPSHOT.jar"
  }
}
```

--------------------------------

### Start Ninja Console via Command Line

Source: https://www.ninjaframework.org/documentation/basic_concepts/basic_concepts.html/console

Demonstrates how to start a Ninja application's console mode directly from the command line. Requires setting the classpath correctly.

```bash
java -cp <classpath-here> ninja.standalone.NinjaConsole
```

--------------------------------

### Test Resources

Source: https://www.ninjaframework.org/documentation/basic_concepts/basic_concepts.html/getting_started/the_anatomy_of_a_ninja_application

test_for_upload.txt is an example of a resource file used within the test directory, potentially for test data or mock inputs.

```text
// src/resources/test_for_upload.txt
```

--------------------------------

### Logback Logging Configuration

Source: https://www.ninjaframework.org/documentation/basic_concepts/basic_concepts.html/getting_started/the_anatomy_of_a_ninja_application

logback.xml configures the Logback framework for logging. It defines appenders, log levels, and logging patterns for different parts of the application.

```xml
<!-- src/main/java/logback.xml -->
<!-- Logging configuration via logback / slf4j -->
```

--------------------------------

### Logback XML Configuration Example

Source: https://www.ninjaframework.org/documentation/basic_concepts/basic_concepts.html/logging

An example of a logback.xml file used to configure logging behavior. It sets up file and console appenders with specific patterns and defines the root logger level.

```xml
<configuration>

  <appender name="FILE" class="ch.qos.logback.core.FileAppender">
    <file>myApp.log</file>

    <encoder>
      <pattern>%date %level [%thread] %logger{10} [%file:%line] %msg%n</pattern>
    </encoder>
  </appender>

  <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
    <encoder>
      <pattern>%msg%n</pattern>
    </encoder>
  </appender>

  <root level="debug">
    <appender-ref ref="FILE" />
    <appender-ref ref="STDOUT" />
  </root>
</configuration>
```

--------------------------------

### Ninja External Configuration for Deployment

Source: https://www.ninjaframework.org/documentation/basic_concepts/basic_concepts.html/security/getting_started

For production deployments, it is recommended to use an external configuration file that contains sensitive settings like the application secret. This can be achieved by specifying the path to the external configuration file using a system property when starting the application.

```bash
java -Dninja.external.configuration=/mydir/deployment.conf
```

--------------------------------

### Basic NinjaTestServer Integration Test

Source: https://www.ninjaframework.org/documentation/basic_concepts/basic_concepts.html/testing_your_application/getting_started

Demonstrates a basic integration test using NinjaTestServer to start a Ninja application, retrieve its base URL, access Guice-injected instances, and shut down the server.

```java
@Test
public void showcaseBasicTest() {

    // Creating a TestServer is done like this
    NinjaTestServer ninjaTestServer = NinjaTestServer.builder().build();

    // baseUrl is something like "http://localhost:5565"
    String baseUrl = ninjaTestServer.getBaseUrl();

    // ... using this url you can now call endpoints, verify and test your application

    // You can also get instances that are initialized by Guice out of your testserver.
    // This is often useful if you want to assert functionality programmatically.
    // Like testing repositories and so on.
    MyRepository myRepository = ninjaTestServer.getInjector().getInstance(MyRepository.class);

    Assertions.assertThat(myRepository.getNumberOfUsers()).isEqualTo(1);

    // Don't forget to shut down that instance.
    // You may also want to put this in a @After JUnit method.
    ninjaTestServer.shutdown();
}
```

--------------------------------

### Flyway Migration Script Example

Source: https://www.ninjaframework.org/documentation/basic_concepts/basic_concepts.html/working_with_relational_dbs/db_migrations

Demonstrates a basic SQL script for a Flyway database migration, including table creation and sequence generation. Flyway migration scripts are database vendor-specific.

```sql
-- Just a simple table
create table GuestbookEntry (
    id int8 not null,
    email varchar(255),
    text varchar(255),
    primary key (id)
);

--needed for hibernate running on postgresql
create sequence hibernate_sequence;

```

--------------------------------

### Controller Implementations

Source: https://www.ninjaframework.org/documentation/basic_concepts/basic_concepts.html/getting_started/the_anatomy_of_a_ninja_application

Controller files (e.g., ApiController.java, ApplicationController.java) handle incoming HTTP requests, process business logic, interact with DAOs, and render responses or views.

```java
// src/main/java/controllers/ApiController.java
// Controllers will handle the actual request and do something
```

```java
// src/main/java/controllers/ApplicationController.java
// Controllers will handle the actual request and do something
```

```java
// src/main/java/controllers/ArticleController.java
// Controllers will handle the actual request and do something
```

```java
// src/main/java/controllers/LoginLogoutController.java
// Controllers will handle the actual request and do something
```

--------------------------------

### Install MetricsModule in Module.java

Source: https://www.ninjaframework.org/documentation/basic_concepts/basic_concepts.html/basic_concepts/metrics

Install the MetricsModule in your application's Guice Module class to activate Ninja-Metrics.

```java
package conf;

import com.google.inject.AbstractModule;
import com.google.inject.Singleton;
import ninja.metrics.MetricsModule;

@Singleton
public class Module extends AbstractModule {

    @Override
    protected void configure() {

        install(new MetricsModule());

    }
}
```

--------------------------------

### Application Routes Definition

Source: https://www.ninjaframework.org/documentation/basic_concepts/basic_concepts.html/getting_started/the_anatomy_of_a_ninja_application

Routes.java centralizes all application routes, mapping HTTP requests (methods and paths) to controller actions. This file provides a clear overview of the application's entry points.

```java
// src/main/java/conf/Routes.java
// Contains all routes of your application in one location
```

--------------------------------

### Configure Ninja Module for Database Support

Source: https://www.ninjaframework.org/documentation/basic_concepts/basic_concepts.html/upgrade_guide

Demonstrates how to configure the application's Guice module to install `JpaModule` and `MigrationClassicModule`. This setup is necessary for enabling database support, including JPA and Flyway migrations, in Ninja Framework applications.

```java
@Singleton
public class Module extends AbstractModule {

    private final NinjaProperties ninjaProperties;

    public Module(NinjaProperties ninjaProperties) {
        this.ninjaProperties = ninjaProperties;
    }

    @Override
    protected void configure() {

        install(new JpaModule(ninjaProperties));
        install(new MigrationClassicModule());

        // ... likely more modules...
    }
}
```

--------------------------------

### Application Configuration

Source: https://www.ninjaframework.org/documentation/basic_concepts/basic_concepts.html/getting_started/the_anatomy_of_a_ninja_application

application.conf is the primary configuration file for the application, managing settings for different environments (development, test, production), including database connections, server ports, and feature flags.

```conf
# src/main/java/conf/application.conf
# Configuration for test dev and production mode
```

--------------------------------

### Generate Ninja Framework Project

Source: https://www.ninjaframework.org/documentation/basic_concepts/basic_concepts.html/working_with_relational_dbs/jpa

Use the Maven archetype plugin to generate a new Ninja Framework project, specifically the servlet-jpa-blog archetype for a quick start with JPA and a blog example.

```Maven
mvn archetype:generate -DarchetypeGroupId=org.ninjaframework -DarchetypeArtifactId=ninja-servlet-jpa-blog-archetype
```

--------------------------------

### JPA Persistence Configuration

Source: https://www.ninjaframework.org/documentation/basic_concepts/basic_concepts.html/getting_started/the_anatomy_of_a_ninja_application

persistence.xml contains the configuration details for Java Persistence API (JPA), specifying database connection properties, entity mappings, and transaction management settings.

```xml
<!-- src/main/java/META-INF/persistence.xml -->
<!-- Contains informations how to access databases via JPA -->
```

--------------------------------

### Ehcache Configuration

Source: https://www.ninjaframework.org/documentation/basic_concepts/basic_concepts.html/getting_started/the_anatomy_of_a_ninja_application

ehcache.xml provides configuration for Ehcache, a popular open-source cache for Java. It defines cache managers, caches, and their specific settings like memory limits and eviction policies.

```xml
<!-- src/main/java/ehcache.xml -->
<!-- Configuration for ehcache -->
```

--------------------------------

### Controller Unit and Integration Tests

Source: https://www.ninjaframework.org/documentation/basic_concepts/basic_concepts.html/getting_started/the_anatomy_of_a_ninja_application

Test files (e.g., ApiControllerTest.java, ApplicationControllerFluentLeniumTest.java) contain unit and integration tests for controllers, ensuring their functionality and behavior are correct.

```java
// src/test/java/controllers/ApiControllerDocTest.java
// Different tests for your application
```

```java
// src/test/java/controllers/ApiControllerDocTesterTest.java
// Different tests for your application
```

```java
// src/test/java/controllers/ApiControllerMockTest.java
// Different tests for your application
```

```java
// src/test/java/controllers/ApiControllerTest.java
// Different tests for your application
```

```java
// src/test/java/controllers/ApplicationControllerFluentLeniumTest.java
// Different tests for your application
```

```java
// src/test/java/controllers/ApplicationControllerTest.java
// Different tests for your application
```

```java
// src/test/java/controllers/LoginLogoutControllerTest.java
// Different tests for your application
```

```java
// src/test/java/controllers/RoutesTest.java
// Different tests for your application
```

--------------------------------

### Guice Module Definition

Source: https://www.ninjaframework.org/documentation/basic_concepts/basic_concepts.html/getting_started/the_anatomy_of_a_ninja_application

Module.java is used for defining dependency injection bindings using Google Guice. It configures how different components and services are instantiated and provided throughout the application.

```java
// src/main/java/conf/Module.java
// Dependency injection definitions via Guice (Optional)
```

--------------------------------

### Custom Template Engine Binding Example

Source: https://www.ninjaframework.org/documentation/basic_concepts/basic_concepts.html/upgrade_guide

Illustrates the change in Guice binding for template engines in Ninja Framework versions 5.4.0 and later. The example shows the older binding method and the updated method required for custom template engines.

```java
// Old binding method (prior to v5.4.0)
public class CustomTemplateEngineModule extends AbstractModule {
    @Override
    protected void configure() {
        bind(TemplateEngine.class).to(CustomTemplateEngine.class);
    }
}

// New binding method (as of v5.4.0)
public class CustomTemplateEngineModule extends AbstractModule {
    @Override
    protected void configure() {
        bind(CustomTemplateEngine.class);
    }
}
```

--------------------------------

### Manage Service Lifecycle with @Start and @Dispose

Source: https://www.ninjaframework.org/documentation/basic_concepts/basic_concepts.html/lifecycle

Demonstrates using @Start and @Dispose annotations in Java to manage the orderly startup and shutdown of services. The 'order' attribute controls the execution sequence.

```java
@Singleton
public class MyService {

    @Start(order = 90)
    public void startService() {
        //do something
    }

    @Dispose(order = 90)
    public void stopService() {
       //do something
    }

    public Result getCount(Context ctx) {
        return Results.json(count.get());
    }
}
```

```java
public class Module extends AbstractModule {

    protected void configure() {

        bind(MyService.class);

    }
}
```

--------------------------------

### Environment-Specific Memcached Configuration

Source: https://www.ninjaframework.org/documentation/basic_concepts/basic_concepts.html/using_the_cache

Example of configuring Memcached specifically for the production environment using a configuration prefix.

```conf
%prod.cache.implementation=ninja.cache.CacheMemcachedImpl
```

--------------------------------

### File Provider Configuration (Java)

Source: https://www.ninjaframework.org/documentation/basic_concepts/basic_concepts.html/uploading_files

Illustrates how to configure file providers for handling uploaded content, either in-memory or disk-based. Includes examples for module binding and controller annotations.

```java
bind(FileItemProvider.class).to(MemoryFileItemProvider.class)
```

```java
@FileProvider(DiskFileItemProvider.class)
@Singleton
public class MyController {
    @FileProvider(MemoryFileItemProvider.class)
    public Result myRouteMethod() {
        // This will use the MemoryFileItemProvider defined at method level
    }
    public Result myOtherRouteMethod() {
        // This will use the DiskFileItemProvider defined at class level
    }
}
```

--------------------------------

### Java Person Class Example

Source: https://www.ninjaframework.org/documentation/basic_concepts/basic_concepts.html/content_negotiation

Defines a simple Java class 'Person' with a 'name' attribute, used in Ninja Framework result examples for demonstrating content negotiation.

```java
class Person {
    String name;
}
```

--------------------------------

### Freemarker HTML Views

Source: https://www.ninjaframework.org/documentation/basic_concepts/basic_concepts.html/getting_started/the_anatomy_of_a_ninja_application

Freemarker template files (e.g., index.ftl.html, articleShow.ftl.html) define the presentation layer of the application. They are rendered by controllers to generate dynamic HTML content for the user interface.

```html
<!-- src/main/java/views/ApplicationController/index.ftl.html -->
<!-- Maps to controller "ApplicationController" and method "index" -->
```

```html
<!-- src/main/java/views/ApplicationController/setup.ftl.html -->
```

```html
<!-- src/main/java/views/ArticleController/articleNew.ftl.html -->
```

```html
<!-- src/main/java/views/ArticleController/articleShow.ftl.html -->
```

```html
<!-- src/main/java/views/LoginLogoutController/login.ftl.html -->
```

```html
<!-- src/main/java/views/LoginLogoutController/logout.ftl.html -->
```

```html
<!-- src/main/java/views/layout/defaultLayout.ftl.html -->
```

```html
<!-- src/main/java/views/layout/footer.ftl.html -->
```

```html
<!-- src/main/java/views/layout/header.ftl.html -->
```

```html
<!-- src/main/java/views/system/403forbidden.ftl.html -->
<!-- Error html views. Can be customized to output custom error pages -->
```

```html
<!-- src/main/java/views/system/404notFound.ftl.html -->
<!-- Error html views. Can be customized to output custom error pages -->
```

--------------------------------

### Maven Build Configuration

Source: https://www.ninjaframework.org/documentation/basic_concepts/basic_concepts.html/getting_started/the_anatomy_of_a_ninja_application

The pom.xml file defines project dependencies, build configurations, and plugins for the Maven build system. It's crucial for managing the project's lifecycle and external libraries.

```xml
<!-- pom.xml -->
<!-- Instructions about dependencies and the build (Maven) -->
```

--------------------------------

### Freemarker Main View with Layout

Source: https://www.ninjaframework.org/documentation/basic_concepts/basic_concepts.html/html_templating/getting_started

An example of a main Freemarker view that imports a layout template and uses its macro to render content, passing a custom title.

```freemarker
<#import "defaultLayout.ftl.html" as layout>
<@layout.myLayout "Home page">

    <h1>my text</h1>

</@layout.myLayout>
```

--------------------------------

### Basic Greeting Service Example

Source: https://www.ninjaframework.org/documentation/basic_concepts/basic_concepts.html/basic_concepts/dependency_injection

Demonstrates a simple dependency injection scenario using Guice. It includes an interface, its implementation, and a Guice module to bind them. The `@Inject` annotation is shown for consuming the service.

```java
public interface GreetingService {
    String hello();
}
```

```java
public class GreetingServiceImpl implements GreetingService {

    @Override
	public String hello() {
		return "hi!!!!";
	}

}
```

```java
public class Module extends com.google.inject.AbstractModule {

    @Override
    protected void configure() {

        bind(GreetingService.class).to(GreetingServiceImpl.class);

    }

}
```

```java
public class ApplicationController {

    @com.google.inject.Inject
    GreetingService greeter;

    public ninja.Result injection(ninja.Context context) {

        return ninja.Results.html().render("greeting", greeter.hello());

    }
}
```

--------------------------------

### Web Application Deployment Descriptor

Source: https://www.ninjaframework.org/documentation/basic_concepts/basic_concepts.html/getting_started/the_anatomy_of_a_ninja_application

web.xml is the deployment descriptor for Java web applications. It's used by servlet containers (like Tomcat) to configure servlets, filters, and other web application components.

```xml
<!-- src/main/webapp/WEB-INF/web.xml -->
<!-- Needed for servlet containers to start up Ninja -->
```

--------------------------------

### Argument Extractor

Source: https://www.ninjaframework.org/documentation/basic_concepts/basic_concepts.html/getting_started/the_anatomy_of_a_ninja_application

LoggedInUserExtractor.java is an example of an argument extractor, a feature that allows custom logic to extract parameters from requests and inject them into controller method arguments.

```java
// src/main/java/etc/LoggedInUser.java
// Argument extractors for controller methods
```

```java
// src/main/java/etc/LoggedInUserExtractor.java
// Argument extractors for controller methods
```

--------------------------------

### Controller Method with Path and Query Parameters

Source: https://www.ninjaframework.org/documentation/basic_concepts/basic_concepts.html/basic_concepts/routing

Example of a controller method signature demonstrating how Ninja framework binds path parameters (using @PathParam) and query parameters (using @Param) from incoming requests.

```java
package controllers;

@Singleton
public class ApplicationController {

    public Result index(
            @PathParam("id") String id,
            @PathParam("email") String email,
            @Param("debug") String debug) {

        //do something with the parameters...
    }

}
```

--------------------------------

### Run Ninja SuperDevMode

Source: https://www.ninjaframework.org/documentation/basic_concepts/basic_concepts.html/basic_concepts/super_dev_mode

Execute the ninja:run goal via Maven to start the SuperDevMode server. This command initiates the hot-reloading development environment.

```bash
mvn ninja:run
```

--------------------------------

### Implement a Controller in Java

Source: https://www.ninjaframework.org/documentation/basic_concepts/basic_concepts.html/basic_concepts/basic_concepts

Example of a Ninja Framework controller class (`ApplicationController`) that handles requests and returns an HTML `Result`. Controller methods should be placed under the `controllers` package.

```Java
package controllers;

@Singleton
public class ApplicationController {

    public Result index() {
        return Results.html();

    }
}
```

--------------------------------

### Internationalization Messages

Source: https://www.ninjaframework.org/documentation/basic_concepts/basic_concepts.html/getting_started/the_anatomy_of_a_ninja_application

messages.properties and messages_de.properties store localized text strings for internationalization (i18n). They map keys to translatable messages for different languages.

```properties
# src/main/java/conf/messages.properties
# 18n messages
```

```properties
# src/main/java/conf/messages_de.properties
```

--------------------------------

### Database Migration Scripts

Source: https://www.ninjaframework.org/documentation/basic_concepts/basic_concepts.html/getting_started/the_anatomy_of_a_ninja_application

SQL files (e.g., V1__.sql, V2__.sql) are used with Flyway for database schema versioning and migrations. They contain SQL statements to create or alter database tables and structures.

```sql
-- src/main/java/db/migration/V1__.sql
-- Database migrations when dealing with RDBMS (Flyway)
```

```sql
-- src/main/java/db/migration/V2__.sql
-- Database migrations when dealing with RDBMS (Flyway)
```

--------------------------------

### Simple HTML View Example

Source: https://www.ninjaframework.org/documentation/basic_concepts/basic_concepts.html/basic_concepts/basic_concepts

A basic HTML view file used by Ninja Framework controllers to render output. By convention, views for controllers are stored in `views/CONTROLLER_NAME/METHOD_NAME`.

```HTML
<html>
    <body>
        <h1>Hello world</h1>
    </body>
</html>
```

--------------------------------

### Ninja Controller with Content Negotiation

Source: https://www.ninjaframework.org/documentation/basic_concepts/basic_concepts.html/content_negotiation

Example of a Ninja Framework controller method demonstrating how to set supported content types (JSON, XML) and a fallback content type (JSON) for a result.

```java
public Result getPerson() {
    Person person = new Person();
    person.name = "Fritz Fritzensen";

    return Results
             .ok()
             .supportedContentTypes(
               Result.APPLICATION_JSON,
               Result.APPLICATION_XML)
             .fallbackContentType(Result.APPLICATION_JSON);
}
```

--------------------------------

### Model Classes

Source: https://www.ninjaframework.org/documentation/basic_concepts/basic_concepts.html/getting_started/the_anatomy_of_a_ninja_application

Model files (e.g., Article.java, User.java) represent the data structures of the application, often mapping to database tables for persistence. They define the entities managed by the application.

```java
// src/main/java/models/Article.java
// Some models that map to your relational database
```

```java
// src/main/java/models/ArticleDto.java
// Some models that map to your relational database
```

```java
// src/main/java/models/ArticlesDto.java
// Some models that map to your relational database
```

```java
// src/main/java/models/User.java
// Some models that map to your relational database
```

--------------------------------

### Ninja Framework Linux Service Script

Source: https://www.ninjaframework.org/documentation/basic_concepts/basic_concepts.html/deployment/ninja_standalone

A bash script to manage a Ninja Framework application as a standalone service on Linux systems, including start, stop, and status functionalities.

```bash
#!/bin/bash
# chkconfig: 345 20 80
# description: Ninja start/shutdown script
# processname: java
#
# Installation:
# copy file to /etc/init.d
# chmod +x /etc/init.d/ninja

# chkconfig --add /etc/init.d/ninja
# chkconfig ninja on
#     OR on a Debian system
# sudo update-rc.d ninja defaults

#
# Usage: (as root)
# service ninja start
# service ninja stop
# service ninja status
#
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #

# Path to the application
APPLICATION_NAME=my-ninja-service
APPLICATION_PATH=/srv/ninja_applications/${APPLICATION_NAME}
APPLICATION_JAR=my-ninja-service-1.0-SNAPSHOT-jar-with-dependencies.jar

PID_FILE=/var/run/${APPLICATION_NAME}.pid
PORT=9013

# Path to the JVM
JAVA_BIN=/opt/java-oracle/jdk1.7.0/bin/java
PARAMS="-Dninja.port=${PORT} -jar ${APPLICATION_PATH}/${APPLICATION_JAR}"

# User running the Ninja process
USER=ninja

RETVAL=0

start() {
    if [ -f ${PID_FILE} ]; then
        echo "Ninja application ${APPLICATION_NAME} already running"
    else
        DAEMON_START_LINE="start-stop-daemon --chdir=${APPLICATION_PATH} --make-pidfile --pidfile ${PID_FILE} --chuid ${USER} --exec ${JAVA_BIN} --background --start -- ${PARAMS}"
        ${DAEMON_START_LINE}
        RETVAL=$?
        echo -n "Starting Ninja Application: ${APPLICATION_NAME}... "

            if [ $RETVAL -eq 0 ]; then
                echo " - Success"
            else
                echo " - Failure"
            fi
        echo
    fi
    echo

}
stop() {
    kill -9 `cat ${PID_FILE}`
    RETVAL=$?
    rm -rf ${PID_FILE}
    echo -n "Stopping Ninja application: ${APPLICATION_NAME}"

    if [ $RETVAL -eq 0 ]; then
        echo " - Success"
    else
        echo " - Failure"
    fi
        echo
    }

status() {
    if [ -f ${PID_FILE} ]; then
        echo "Ninja application ${APPLICATION_NAME} running"
    else
        echo "Ninja application ${APPLICATION_NAME} not running"
    fi
    echo

}

clean() {
        rm -f ${PID_FILE}
}

case "$1" in
    start)
    start
    ;;
    stop)
    stop
    ;;
    restart|reload)
    stop
    sleep 10
    start
    ;;
    status)
    status
    ;;
    clean)
    clean
    ;;
*)
echo "Usage: $0 {start|stop|restart|status}"
;;
esac

```

--------------------------------

### Basic GET Request Routing in Ninja

Source: https://www.ninjaframework.org/documentation/basic_concepts/basic_concepts.html/basic_concepts/routing

Demonstrates how to map a GET request to a specific URI to a controller method using the Router interface. This is the fundamental way to define routes in Ninja Framework.

```Java
public class Routes implements ApplicationRoutes {

    @Override
    public void init(Router router) {

        // a GET request to "index" will be handled by a class called
        // "AppController" its method "index".
        router.GET().route("/index").with(AppController::index);

        ...

    }
}
```

--------------------------------

### Run Ninja Framework Application

Source: https://www.ninjaframework.org/documentation/basic_concepts/basic_concepts.html/working_with_relational_dbs/jpa

Execute the Maven package command followed by the ninja:run goal to build and start the Ninja Framework application. The application is typically accessible at http://localhost:8080.

```Maven
mvn package ninja:run
```

--------------------------------

### Request Logger Filter

Source: https://www.ninjaframework.org/documentation/basic_concepts/basic_concepts.html/getting_started/the_anatomy_of_a_ninja_application

LoggerFilter.java is a sample servlet filter that can intercept incoming requests to perform actions, such as logging request details before they reach the controller.

```java
// src/main/java/filters/LoggerFilter.java
// Filter to filter the request in the controller
```

--------------------------------

### Data Access Objects (DAOs)

Source: https://www.ninjaframework.org/documentation/basic_concepts/basic_concepts.html/getting_started/the_anatomy_of_a_ninja_application

DAO files (e.g., ArticleDao.java, UserDao.java) abstract database operations, providing methods for CRUD (Create, Read, Update, Delete) operations on data models, separating data access logic from controllers.

```java
// src/main/java/dao/ArticleDao.java
// Database access via DAO objects and not in the controller
```

```java
// src/main/java/dao/SetupDao.java
// Database access via DAO objects and not in the controller
```

```java
// src/main/java/dao/UserDao.java
// Database access via DAO objects and not in the controller
```

--------------------------------

### Enable Session Encryption

Source: https://www.ninjaframework.org/documentation/basic_concepts/basic_concepts.html/security/getting_started

Configure Ninja to encrypt user sessions by setting the `application.cookie.encryption` property to `true` in the `application.conf` file. This leverages AES encryption for enhanced security.

```HOCON
application.cookie.encryption=true
```

--------------------------------

### Ninja FluentLenium Test Example

Source: https://www.ninjaframework.org/documentation/basic_concepts/basic_concepts.html/testing_your_application/ninja_fluentlenium_test

Demonstrates a basic web test using FluentLenium integrated with Ninja Framework. It navigates to a URL, asserts the page title, clicks a login link, and verifies the URL change. Requires extending `NinjaFluentLeniumTest`.

```java
public class ApplicationControllerFluentLeniumTest extends NinjaFluentLeniumTest {

    @Test
    public void testThatHomepageWorks() {

        goTo(getBaseUrl() + "/");

        System.out.println("title: " + window().title());

        assertTrue(window().title().contains("Home page"));

        $("#login").click();

        assertTrue(url().contains("login"));

    }

}
```

--------------------------------

### Java Exception Wrapping Example

Source: https://www.ninjaframework.org/documentation/basic_concepts/basic_concepts.html/basic_concepts/error_handling

Demonstrates how to wrap an existing exception within a Ninja framework's internal server error exception.

```Java
throw new InternalServerErrorException(ioException);
```

--------------------------------

### Servlet Filter Integration

Source: https://www.ninjaframework.org/documentation/basic_concepts/basic_concepts.html/getting_started/the_anatomy_of_a_ninja_application

ServletException.java is used to integrate custom servlet filters and mappings, allowing for cross-cutting concerns like request logging, authentication, or transformation to be applied to incoming requests.

```java
// src/main/java/conf/ServletException.java
// Integration of arbitrary servlet filters and mappings (Optional)
```

--------------------------------

### Advanced Module Configuration

Source: https://www.ninjaframework.org/documentation/basic_concepts/basic_concepts.html/basic_concepts/dependency_injection

Illustrates how to customize Ninja's default Guice bindings by extending `FrameworkModule` and selectively installing or disabling features from `NinjaClassicModule`.

```java
package conf;

import ninja.conf.FrameworkModule;
import ninja.conf.NinjaClassicModule;
import ninja.utils.NinjaProperties;

public class Module extends FrameworkModule {

    private final NinjaProperties ninjaProperties;

    public Module(NinjaProperties ninjaProperties) {
        this.ninjaProperties = ninjaProperties;
    }

    @Override
    protected void configure() {
        // classic ninja stack but with no freemarker or xml
        install(new NinjaClassicModule(ninjaProperties)
            .freemarker(false)
            .xml(false)
        );
    }

}
```

--------------------------------

### Configure Logback via application.conf

Source: https://www.ninjaframework.org/documentation/basic_concepts/basic_concepts.html/logging

This example illustrates how to set the Logback configuration file path within Ninja's application.conf file. This method allows for configuration switching without modifying Java system properties.

```java
logback.configurationFile = /path/to/your/logback.xml
```

--------------------------------

### Ninja Controller Using Filtered Content Negotiation

Source: https://www.ninjaframework.org/documentation/basic_concepts/basic_concepts.html/content_negotiation

Example of a Ninja Framework controller method that utilizes a filter to automatically apply content negotiation settings (JSON, XML with JSON fallback).

```java
@FilterWith(XmlAndJsonResult.class)
public Result getPerson() {
    Person person = new Person();
    person.name = "Fritz Fritzensen";

    //The filter will set all content negotiation related stuff for us:
    return Results.ok();
}
```

--------------------------------

### Ninja Framework Configuration Properties

Source: https://www.ninjaframework.org/documentation/basic_concepts/basic_concepts.html/deployment/ninja_standalone

Defines command-line and system property configurations for customizing Ninja Framework application startup, including port, host, timeouts, and modes.

```APIDOC
- ninja.port
  Description: Allows you to select the port on which your application is starting.
  Default: 8080
  Type: Integer

- ninja.host
  Description: Allows you to select the host on which your application will bind.
  Default: any/0.0.0.0
  Type: String

- ninja.idle.timeout
  Description: Allows you to specify the timeout period after which idle HTTP connections will be closed.
  Default: 30000
  Unit: msec
  Type: Integer

- ninja.mode
  Description: Allows you to select the mode (test, dev, prod) of your application.
  Default: prod
  Type: String (Enum: test, dev, prod)

- ninja.external.configuration
  Description: Allows you to add an external application configuration file (e.g., conf/production.conf).
  Note: If conf/application.conf is also present, it's loaded first.
  Type: String (File Path)

- ninja.context
  Description: Allows you to add a context prefix to your application (e.g., /your_context_path).
  Type: String

- ninja.jetty.configuration
  Description: Supplies a comma-delimited list of jetty.xml configuration files to configure the server.
  Note: If supplied, ninja.port and ninja.host properties are skipped and must be configured in jetty.xml.
  Example: jetty.xml,jetty-ssl.xml
  Type: String (Comma-separated File Paths)
```

--------------------------------

### Test DAOs Directly with NinjaDaoTestBase

Source: https://www.ninjaframework.org/documentation/basic_concepts/basic_concepts.html/testing_your_application/advanced

Shows how to extend NinjaDaoTestBase to test DAO methods against a real database. Use `getInstance(DAO.class)` from the superclass to obtain DAO instances within your test methods. The Persistence Service starts using application.conf parameters, defaulting to NinjaMode.test.

```java
import ninja.NinjaDaoTestBase;
import org.junit.*;

public class AbstractDaoTest extends NinjaDaoTestBase {

    private TestDao testDao;

    @Before
    public void setup(){
        //Instanting DAO using super method
        testDao = getInstance(TestDao.class);
    }

    @Test
    public void testSave() {
        MyEntity myEntity = new MyEntity();
        myEntity.setEmail("[email\u00a0protected]");
        assertNull(myEntity.getId());

        //Use the DAO with a real database
        myEntity = testDao.save(myEntity);

        assertNotNull(entity.getId());
    }
}
```

--------------------------------

### Ninja Framework Controller Example

Source: https://www.ninjaframework.org/documentation/basic_concepts/basic_concepts.html/testing_your_application/mocked_tests

A sample Java controller in the Ninja Framework that injects an `ArticleDao`. The `postArticleJson` method uses the DAO to post an article and returns `Results.ok()` on success or `Results.notFound()` on failure.

```java
public class ApiController {

    @Inject
    ArticleDao articleDao;

    public Result postArticleJson(@LoggedInUser String username,
                              ArticleDto articleDto) {

        boolean succeeded = articleDao.postArticle(username, articleDto);

        if (!succeeded) {
            return Results.notFound();
        } else {
            return Results.ok();
        }

    }
}
```

--------------------------------

### Generate Ninja Project with Maven Archetype

Source: https://www.ninjaframework.org/documentation/basic_concepts/basic_concepts.html/getting_started/create_your_first_application

Use Maven to generate a new Ninja Framework project using the 'ninja-servlet-archetype-simple'. This command prompts for project group and artifact IDs, setting up the initial project structure.

```shell
mvn archetype:generate -DarchetypeGroupId=org.ninjaframework -DarchetypeArtifactId=ninja-servlet-archetype-simple
```

--------------------------------

### Annotate Methods with @Timed

Source: https://www.ninjaframework.org/documentation/basic_concepts/basic_concepts.html/basic_concepts/metrics

Annotate controller methods with @Timed to measure execution duration and rate. This requires the MetricsModule to be installed.

```java
package controllers;

import ninja.Results;
import ninja.Result;
import ninja.metrics.Timed;
import com.google.inject.Singleton;

@Singleton
public class AppController {

    @Timed
    public Result index() {

        return Results.html();
    }

}
```

--------------------------------

### Configure NinjaPostofficeModule

Source: https://www.ninjaframework.org/documentation/basic_concepts/basic_concepts.html/sending_mail

Install the NinjaPostofficeModule in your application's Module.java file to integrate email functionality. Ensure your SMTP server is configured in application.conf.

```java
@Singleton
public class Module extends AbstractModule {
    @Override
    protected void configure() {
        install(new NinjaPostofficeModule());
    }

}
```

--------------------------------

### Run All Tests with Maven

Source: https://www.ninjaframework.org/documentation/basic_concepts/basic_concepts.html/testing_your_application/getting_started

Executes all unit tests for a Ninja Framework application using the Maven build tool. This is the standard way to run tests from the command line.

```bash
mvn test
```

--------------------------------

### Ninja Console Application Entry Point

Source: https://www.ninjaframework.org/documentation/basic_concepts/basic_concepts.html/console

Ninja v6.3.0+ supports running webserver-less console applications by using `ninja.standalone.NinjaConsole` as the main entry point. This class initializes the application similar to a web server environment, including Guice configuration and lifecycle methods, but bypasses web server startup and router initialization.

```APIDOC
Class: ninja.standalone.NinjaConsole

Purpose:
  Provides a way to run Ninja framework applications as standalone console applications without a web server.

Behavior:
  - Starts the Ninja application lifecycle.
  - Initializes Guice configuration and dependency injection.
  - Does NOT start a web server (e.g., Jetty).
  - Does NOT initialize the application's `conf.Router`.
  - All other standard Ninja application startup procedures are followed.

Usage:
  Set `ninja.standalone.NinjaConsole` as the main class for your application's execution.

Example:
  // Assuming your application's main module is com.example.MyNinjaModule
  // and your application properties are configured correctly.
  // You would typically configure this in your build tool (e.g., Maven/Gradle) 
  // to run this class.
  public static void main(String[] args) {
    // NinjaConsole will handle the setup and lifecycle.
    // No explicit method calls are needed here to start the application.
    // The framework manages the startup process.
    // Example of how it might be invoked internally or via build tool:
    // NinjaConsole.main(new String[]{"--applicationModule=com.example.MyNinjaModule"});
    // Note: The exact invocation might vary based on Ninja's internal design or build tool integration.
  }

Dependencies:
  - Ninja Framework core libraries.
  - Application-specific Guice modules and configurations.

Limitations:
  - Cannot handle incoming HTTP requests as no web server is started.
  - Primarily useful for background tasks, scheduled jobs, or utility scripts that require Ninja's DI and configuration capabilities.
```

--------------------------------

### Configuring Ninja Application Modes

Source: https://www.ninjaframework.org/documentation/basic_concepts/basic_concepts.html/configuration_and_modes

Explains how to set the Ninja application mode (dev, test, prod) using Java system properties, which influences configuration loading and application behavior.

```bash
# On the command line:
java -Dninja.mode=dev

# Programmatically:
System.setProperty(NinjaConstant.MODE_KEY_NAME, NinjaConstant.MODE_DEV)
```

--------------------------------

### Run Fat Jar

Source: https://www.ninjaframework.org/documentation/basic_concepts/basic_concepts.html/deployment/ninja_standalone

Execute the generated fat JAR file using the Java command. You can specify the application port using the 'ninja.port' system property.

```bash
java -Dninja.port=9000 -jar MY-APPLICATION-jar-with-dependencies.jar
```

--------------------------------

### Override Configuration with System Properties

Source: https://www.ninjaframework.org/documentation/basic_concepts/basic_concepts.html/configuration_and_modes

Demonstrates overriding configuration values, including mode-specific properties (e.g., `%test.db.connection.password`), using Java system properties at runtime.

```bash
java -Dninja.external.configuration=conf/production.conf -Ddb.connection.password=otherpass
```

```bash
java -Dninja.external.configuration=conf/production.conf -D%test.db.connection.password=otherpass
```

--------------------------------

### Render HTML View by Convention (Java)

Source: https://www.ninjaframework.org/documentation/basic_concepts/basic_concepts.html/basic_concepts/controllers

Shows how to render an HTML view using Ninja's convention-over-configuration approach. The framework automatically maps controller methods to corresponding view files.

```java
package controllers;

public class ApplicationController {

    public Result index() {
        return Results.html(); // Renders views/ApplicationController/index.ftl.html by convention
    }
}
```

--------------------------------

### Reading Session Value

Source: https://www.ninjaframework.org/documentation/basic_concepts/basic_concepts.html/basic_concepts/sessions

Demonstrates how to retrieve a specific value from the user's session by its key. This can be done by injecting the `Session` object into a controller method and calling `get(key)`.

```Java
public Result getUserNameFromSession(Session session) {

    String username = session.get("username");

    return Results.html().render(username);

}
```

--------------------------------

### Content Negotiation for Rendering (Java)

Source: https://www.ninjaframework.org/documentation/basic_concepts/basic_concepts.html/basic_concepts/controllers

Illustrates how Ninja framework handles content negotiation for rendering objects based on the 'Accept' request header. It shows default behavior and how to explicitly enforce JSON or XML rendering.

```java
public Result getUser() {
    User user = userDao.getUser();
    return Results.ok().render(user);
}

// Explicitly render JSON
public Result getUserAsJson() {
    User user = userDao.getUser();
    return Results.json().render(user);
}

// Explicitly render XML
public Result getUserAsXml() {
    User user = userDao.getUser();
    return Results.xml().render(user);
}
```

--------------------------------

### Ninja Property Referencing and Interpolation

Source: https://www.ninjaframework.org/documentation/basic_concepts/basic_concepts.html/configuration_and_modes

Demonstrates how Ninja Framework allows referencing other properties within configuration files, enabling dynamic value composition. This is useful for creating combined settings like full server names.

```properties
serverName=myserver.com
serverPort=80
fullServerName=${serverName}:${serverPort}
```

--------------------------------

### Ninja Framework Testing Philosophy

Source: https://www.ninjaframework.org/documentation/basic_concepts/basic_concepts.html/testing_your_application/getting_started

Ninja emphasizes testing as a core principle, aiming to make application testing simple, fast, and reliable. It advocates for a unified approach to testing, treating all tests as unit tests, whether against mocks or full applications, and ensuring rapid execution.

```text
Testing is THE MOST IMPORTANT THING of Ninja. We put a huge effort into making testing your apps
as simple and quick as possible. The developers of Ninja all had experiences with different web frameworks
that were really hard to test, or where tests were unreliable and slow.

Ninja changes that.

All tests of Ninja run really fast. And they are just plain old JUnit tests. No matter if you are testing against
a mock, or a full blown Ninja application. Forget about Integration tests, and Unit tests. Ninja only knows Unit tests.
```

--------------------------------

### Configure Ninja Cookie Prefix

Source: https://www.ninjaframework.org/documentation/basic_concepts/basic_concepts.html/basic_concepts/sessions

Sets the prefix for all Ninja framework cookies. This property allows customization of the cookie name, for example, changing the default 'NINJA' to 'MYAPP' for specific applications.

```conf
application.cookie.prefix = MYAPP
```

--------------------------------

### Basic Freemarker Template

Source: https://www.ninjaframework.org/documentation/basic_concepts/basic_concepts.html/html_templating/getting_started

Demonstrates a basic Freemarker template file structure for rendering HTML. Freemarker templates in Ninja typically use the `.ftl.html` extension, but this can be configured.

```Freemarker
<html>
    <head>
        <title>My title</title>
    </head>
<html>
```

--------------------------------

### Handling i18n Messages with Placeholders

Source: https://www.ninjaframework.org/documentation/basic_concepts/basic_concepts.html/basic_concepts/flash_scope

Provides a Java example for integrating internationalization (i18n) with flash messages, specifically handling messages with placeholders by retrieving them from a messages source and then setting them on the FlashScope.

```java
public Result flashSuccess(FlashScope flashScope, Context context) {

    Result result = Results.html();

    Optional<String> flashMessage = messages.get("flashSuccess", context, Optional.of(result), "PLACEHOLDER");
    if (flashMessage.isPresent()) {
        flashScope.success(flashMessage.get());
    }

    flashScope.discard();
    return result;

}
```

--------------------------------

### Debug Ninja with Eclipse (m2eclipse)

Source: https://www.ninjaframework.org/documentation/basic_concepts/basic_concepts.html/debugging

This method describes how to debug a Ninja application using Eclipse with the m2eclipse plugin. It involves running the application via a Maven goal that starts the embedded server.

```maven
mvn jetty:run
```

--------------------------------

### Build Fat Jar

Source: https://www.ninjaframework.org/documentation/basic_concepts/basic_concepts.html/deployment/ninja_standalone

Execute the Maven clean, compile, and package lifecycle phases to generate the fat JAR file containing your Ninja application and its dependencies.

```bash
mvn clean compile package
```

--------------------------------

### Define Route with Path Parameters

Source: https://www.ninjaframework.org/documentation/basic_concepts/basic_concepts.html/basic_concepts/routing

Demonstrates how to define a GET route in Ninja Framework that captures variable parts of the URL using curly braces. These parts can then be injected into controller methods.

```java
router.GET().route("/user/{id}/{email}/userDashboard").with(ApplicationController::userDashboard);
```

--------------------------------

### Configure Application Base Package

Source: https://www.ninjaframework.org/documentation/basic_concepts/basic_concepts.html/configuration_and_modes

Sets the base Java package for the application, influencing the location of Routes and Guice configuration modules.

```properties
application.modules.package=com.someorganinization.somepackage
```

--------------------------------

### Load External Configuration File

Source: https://www.ninjaframework.org/documentation/basic_concepts/basic_concepts.html/configuration_and_modes

Specifies an external configuration file to be loaded for deployment, overriding or supplementing `application.conf` values. Ninja searches for this file in multiple locations.

```bash
java -Dninja.external.configuration=conf/production.conf
```

--------------------------------

### Implement Custom Filter Logic

Source: https://www.ninjaframework.org/documentation/basic_concepts/basic_concepts.html/basic_concepts/filters

Provides an example of a custom filter that checks session validity by looking for a 'username' attribute. If not found, it returns a forbidden response; otherwise, it proceeds to the next filter in the chain.

```java
public class SecureFilter implements Filter {

    /** If a username is saved we assume the session is valid */
    public final String USERNAME = "username";

    @Override
    public Result filter(FilterChain chain, Context context) {

        // if we got no cookies we break:
        if (context.getSession() == null
                || context.getSession().get(USERNAME) == null) {

            return Results.forbidden().html().template("/views/forbidden403.ftl.html");

        } else {
            return chain.next(context);
        }

    }
}
```

--------------------------------

### Get Message in Freemarker Template

Source: https://www.ninjaframework.org/documentation/basic_concepts/basic_concepts.html/internationalization

Illustrates how to access internationalized messages directly within Freemarker templates using the ${i18n(...)} function. It shows basic retrieval and automatic formatting with a single parameter.

```Freemarker
<html>
    <head>
        <title>${i18n("casinoRegistrationTitle")}</title>
    </head>
<html>
```

```Freemarker
<html>
    <head>
        <title>${i18n("casinoYourUsername", username)}</title>
    </head>
<html>
```

--------------------------------

### Package Application into WAR File

Source: https://www.ninjaframework.org/documentation/basic_concepts/basic_concepts.html/deployment/war_based_deployment

Execute the Maven package command to build the WAR file for your Ninja application. The resulting artifact will be located in the /target directory.

```bash
mvn package
```

--------------------------------

### Flash Scope and i18n Translation

Source: https://www.ninjaframework.org/documentation/basic_concepts/basic_concepts.html/internationalization

Explains how flash scope values can be automatically translated if their key exists in the messages properties file. It also provides an example of manually translating a flash message with placeholders in the controller.

```Java
public Result flashError(Context context) {

    Result result = Results.html();

    Optional<String> flashMessage = messages.get("flashError", context, Optional.of(result), "PLACEHOLDER");

    if (flashMessage.isPresent()) {
        context.getFlashScope().error(flashMessage.get());
    }

    return result;

}
```

--------------------------------

### Mode-Specific Property Overrides

Source: https://www.ninjaframework.org/documentation/basic_concepts/basic_concepts.html/configuration_and_modes

Demonstrates how Ninja Framework uses prefixes (e.g., %dev., %prod.) to load different property values based on the current application mode, allowing environment-specific configurations.

```properties
database.name=database_production   # Default/prod
%prod.database.name=database_prod
%dev.database.name=database_dev
%test.database.name=database_test
```

--------------------------------

### Configuring Ninja SSL/HTTPS Support

Source: https://www.ninjaframework.org/documentation/basic_concepts/basic_concepts.html/configuration_and_modes

Details how to enable and configure HTTPS support in Ninja Framework, including setting the SSL port, disabling HTTP, and specifying keystore/truststore locations and passwords.

```properties
# Enable SSL on port 8443
ninja.ssl.port=8443

# Disable HTTP connector
ninja.port=-1

# Keystore and Truststore configuration
ninja.ssl.keystore.uri=file:///var/etc/mysite.keystore
ninja.ssl.keystore.password=changeit
ninja.ssl.truststore.uri=file:///var/etc/mysite.truststore
ninja.ssl.truststore.password=changeit
```

```bash
# Maven command to run with SSL port
mvn ninja:run -Dninja.ssl.port=8443
```

--------------------------------

### Ninja Configuration File

Source: https://www.ninjaframework.org/documentation/basic_concepts/basic_concepts.html/configuration_and_modes

Specifies the default location and format for Ninja framework configuration files. `application.conf` is a simple properties file where '#' denotes comments.

```properties
# By convention Ninja will look for a configuration file at conf/application.conf.
# application.conf is a simple properties file with keys and values. “#” is a comment.

```

--------------------------------

### Accessing Implicit Variables

Source: https://www.ninjaframework.org/documentation/basic_concepts/basic_concepts.html/html_templating/implicit_functions

Shows examples of accessing implicit variables available within Ninja Framework templates. These include session data, flash messages, language settings, and the application's context path.

```Jinja2
${session.username}
${flash.success}
${flash.error}
${flash.arbitraryKey}
${lang}
${contextPath}
```

--------------------------------

### Reference Environment Variables in Configuration

Source: https://www.ninjaframework.org/documentation/basic_concepts/basic_concepts.html/configuration_and_modes

Demonstrates how to reference system environment variables within Ninja Framework configuration files using Apache Commons Configuration syntax. This is useful for managing sensitive credentials like database passwords.

```properties
%prod.db.connection.password=${env:DB_PASSWORD}
```

--------------------------------

### Inject and Use NinjaCache in Java

Source: https://www.ninjaframework.org/documentation/basic_concepts/basic_concepts.html/using_the_cache

Demonstrates injecting NinjaCache into a Java class and using its `get` and `set` methods for caching data. It includes a check for cached data before fetching from the DAO and setting an expiration time.

```java
@Inject
NinjaCache ninjaCache;

public Result allPosts() {

    List<Post> posts = ninjaCache.get("posts", List.class);
    if(posts == null) {
        posts = postDao.findAll();
        ninjaCache.set("posts", posts, "30mn");
    }

    return Results.html().render(posts);

}
```

--------------------------------

### Generate New Session Secret

Source: https://www.ninjaframework.org/documentation/basic_concepts/basic_concepts.html/security/getting_started

To generate a new random session secret, delete the `application.secret` entry from your `conf/application.conf` file. Upon restarting the server, Ninja will automatically generate a new secret and add it to the configuration.

```HOCON
# Delete the following line to generate a new secret on restart:
# application.secret = "your-existing-secret-here"
```

--------------------------------

### Basic Ninja Controller Structure

Source: https://www.ninjaframework.org/documentation/basic_concepts/basic_concepts.html/basic_concepts/controllers

Demonstrates the fundamental structure of a Ninja Framework controller. It shows a simple controller class with a method that returns a `Result` object, which is essential for handling HTTP responses.

```java
package controllers;

@Singleton
public class AppController {

    public Result index() {

        return Results.html();
    }

}
```
Tokens:
Raw