Spring Boot utilizar su logger

Vamos a ver cómo podemos utilizar el logger de Spring Boot para poder sacar nuestros mensajes de debug sin reinventar la rueda y utilizando el sistema de log de Spring Boot.
La llamada en sí misma al logger no tiene mucho de especial, se hace de la manera habitual, pero hay que hacer un par de ajustes en configuración.


import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class SBLogger{
    private final Logger logger = LoggerFactory.getLogger(this.getClass());

    public static void main(String[] args) throws Exception {

                // arrancar Spring Boot
                SpringApplication.run(this.getClass(), args);

                logger.debug("Sample debug message");              
logger.info("Sample info message");
logger.warn("Sample warn message");
logger.error("Sample error message");

   }
}



En nuestro fichero pom.xml, entre otras cosas, habrá que añadir lo siguiente

        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
            <version>1.7.19</version>
        </dependency>
        <dependency>
            <groupId>org.apache.logging.log4j</groupId>
            <artifactId>log4j-slf4j-impl</artifactId>
            <version>2.5</version>
        </dependency>
        <dependency>
            <groupId>org.apache.logging.log4j</groupId>
            <artifactId>log4j-api</artifactId>
            <version>2.5</version>
        </dependency>
        <dependency>
            <groupId>org.apache.logging.log4j</groupId>
            <artifactId>log4j-core</artifactId>
            <version>2.5</version>
        </dependency>
        <dependency>
            <groupId>org.apache.logging.log4j</groupId>
            <artifactId>log4j-jcl</artifactId>
            <version>2.5</version>
        </dependency>



Como siempre, si no utilizamos Maven, habrá que importar las librerías a mano, entre ellas Spring Boot y las de logging que aparecen en el pom.xml anterior.
Por otro lado, habrá que tocar un poco la configuración de Spring Boot, por lo tanto, en el archivo application.properties, habrá que incluir las siguientes claves.


logging.file=my_file.log
logging.level.org.springframework.web=INFO
logging.level.guru.springframework.blogs.controllers=INFO
logging.level.org.hibernate=ERROR
log4j.logger.org.thymeleaf=DEBUG



Por cierto, si no tienes un fichero de application.properties, deberás crearlo a mano. Spring Boot lo buscará y si lo encuentra, le hará caso a la hora de arrancar. Deberás ubicarlo en /src/main/resources

Spring Boot iniciar Tomcat y un servicio

Vamos a ver cómo utilizar Spring Boot para embeber (incluir insertado) un Tomcat que despliegue un servicio sin tener que instalar y configurar Tomcat en el equipo. Al final el ejecutable será un .jar el cual ejecutaremos mediante "java -jar". Y sin necesidad de tener previamente un Tomcat instalado en el equipo, podremos disponer de él para desplegar nuestro servicio.

Utilizaremos Maven y el sistema de log de Spring Boot para incluir nuestros mensajes de log. Por otro lado, incluiremos un fichero de properties de configuración de Spring Boot al cual también podemos añadir nuestras propias claves de configuración.


Nuestro fichero "pom" de Maven

   <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>1.5.4.RELEASE</version>
    </parent>
    
    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <maven.compiler.source>1.8</maven.compiler.source>
        <maven.compiler.target>1.8</maven.compiler.target>
        <!-- Spring boot main class -->
        <start-class>nombre.de.paquetes.hasta.el.Main****</start-class>
    </properties>
    
    
    <dependencies>
        
        <dependency>          
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>              
        </dependency>
        
        
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
            <version>1.7.19</version>
        </dependency>
        <dependency>
            <groupId>org.apache.logging.log4j</groupId>
            <artifactId>log4j-slf4j-impl</artifactId>
            <version>2.5</version>
        </dependency>
        <dependency>
            <groupId>org.apache.logging.log4j</groupId>
            <artifactId>log4j-api</artifactId>
            <version>2.5</version>
        </dependency>
        <dependency>
            <groupId>org.apache.logging.log4j</groupId>
            <artifactId>log4j-core</artifactId>
            <version>2.5</version>
        </dependency>
        <dependency>
            <groupId>org.apache.logging.log4j</groupId>
            <artifactId>log4j-jcl</artifactId>
            <version>2.5</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-security</artifactId>
            <exclusions>
                <exclusion>
                    <groupId>ch.qos.logback</groupId>
                    <artifactId>logback-classic</artifactId>
                </exclusion>
            </exclusions>
        </dependency>

    </dependencies>
    
    
    <build>
        <resources>
            <resource>
                <directory>src/main/resources</directory>
                <targetPath>${project.build.directory}</targetPath>
                <includes>
                    <include>log4j.properties</include>
                    <include>application.properties</include>
                </includes>
            </resource>
        </resources>
        <plugins>
            
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>                
            </plugin>
            
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-assembly-plugin</artifactId>
                <version>2.4.1</version>
                <configuration>
                    <!-- get all project dependencies -->
                    <descriptorRefs>
                        <descriptorRef>jar-with-dependencies</descriptorRef>
                    </descriptorRefs>
                    <!-- MainClass in mainfest make a executable jar -->
                    <archive>
                        <manifest>
                            <mainClass>nombre.de.paquetes.hasta.el.Main****</mainClass>
                        </manifest>
                    </archive>

                </configuration>
                <executions>
                    <execution>
                        <id>make-assembly</id>
                        <!-- bind to the packaging phase -->
                        <phase>package</phase>
                        <goals>
                            <goal>single</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>






A continuación, nuestro fichero "application.properties", el cual se situará en /src/main/resources

# puerto donde se despliega este servicio
server.port=8012
logging.file=ecall.log
security.basic.enabled=false
logging.level.org.springframework.web=INFO
logging.level.guru.springframework.blogs.controllers=INFO
logging.level.org.hibernate=ERROR
log4j.logger.org.thymeleaf=DEBUG





A continuación, la clase Main, donde definiremos el servicio a llamar para ser registrado en Spring Boot y que éste lo reconozca al iniciarse.


@Controller
@EnableAutoConfiguration
public class MainClass {


    @RequestMapping("/")
    @ResponseBody
    String home() {
        // este método define lo que aparecerá cuando en el navegador accedamos a la dirección localhost:puerto/
        return "Hello World! Spring Boot working !!";
    }


    /*
        A continuación es la manera de registrar un servlet en Spring Boot, en este caso en /recepcion
    */    
    @Bean
    public ServletRegistrationBean registro() {
        return new ServletRegistrationBean(new NombreDeNuestroServlet(), "/recepcion");
    }


     public static void main(String[] args) throws Exception {
        
        // load properties
         Properties properties = getProperties();
        try {
            

                SpringApplication.run(MainClass.class, args);

            } catch (Exception e) {
                System.out.println("Unable to start SPRING BOOT ");                
                e.printStackTrace();
            }
        
    }

}




Por último, nuestro Servlet, que es absolutamente común, pero por probar algo en su llamada, haremos una llamada al logger para introducir algún mensaje y comprobar que al acceder a localhost:puerto/recepcion , realmente accede a este servlet y ejecuta su código.



public class NombreDeNuestroServlet extends HttpServlet {

    private final Logger logger = LoggerFactory.getLogger(this.getClass());
    
    public void doPost(HttpServletRequest req, HttpServletResponse res) throws ServletException, IOException {

        logger.debug("Sample debug message");                
logger.info("Sample info message");
logger.warn("Sample warn message");
logger.error("Sample error message");

        
       
        // Obtenemos un objeto Print Writer para enviar respuesta
        res.setContentType("text/html");
        PrintWriter pw = res.getWriter();
        pw.println("200 OK");
        pw.close();
    }

    public void doGet(HttpServletRequest req, HttpServletResponse res) throws ServletException, IOException {
        doPost(req, res);

    }
    


}

Finalmente, al hacer un clean and build, nuestro IDE nos creará un .jar, el cual simplemente ejecutando con java -jar, nos desplegará el Tomcat y nuestro servicio, quedando ya listo para su acceso. Al final, queda un código muy simple y elegante que nos permite tener la máquina servidor más limpia ya que no es necesario instalar Tomcat. Cada aplicación es muy bien "educada" y se trae su propio Tomcat, su propia configuración, se autodespliega y cuando finaliza su ejecución, no quedan rastros...

Una maravilla, no?