Java Tomcat Pool Datasources Resources

JAVA POOL DATASOURCES desde TOMCAT !!

    Vamos a ver cómo configurar un Datasource (conexión a Base de datos) para acceder a él desde nuestro código, pero configurado en Tomcat. Además, contaremos con un POOL de conexiones, de manera que los accesos a base de datos serán más eficientes.

En el fichero /conf/context.xml de TOMCAT, dentro de la sentencia <Context>, añadir el datasource:

<Resource name="jdbc/ConexionMySQL" auth="Container" type="javax.sql.DataSource"

       maxActive="20" maxIdle="10" maxWait="5000"

       username="xxxxx" password="xxxx#" driverClassName="com.mysql.jdbc.Driver"

       url="jdbc:mysql://xxxxxxxx:3306/xxxxxxx"/>

Por otro lado, en el /WEB-INF/web.xml, añadir lo siguiente dentro de <web-app>

<resource-ref>
   <description>Pool conexiones MySQL</description>
   <res-ref-name>jdbc/ConexionMySQL</res-ref-name>
   <res-type>javax.sql.DataSource</res-type>
   <res-auth>Container</res-auth>
</resource-ref>

Por último, así es como se obtiene conexión

public boolean conectar() {

   Context initContext;
   try {
       initContext = new InitialContext();
       DataSource ds = (DataSource) initContext.lookup("java:/comp/env/jdbc/ConexionMySQL");
       myCon = ds.getConnection();
       return true;
   } catch (SQLException ex) {
       logger.error("Error (" + ex.getErrorCode() + "): " + ex.getMessage());
       return false;
   } catch (NamingException ex) {
       logger.error("Error al intentar obtener el DataSource: " + ex.getMessage());
       return false;
   }

}

Java Tomcat embebido

Cómo embeber un Tomcat en código Java para ser ejecutado mediante un ejecutable .jar.
Además, cargaremos una web en dicho Tomcat, la cual tendremos previamente empaquetada en un fichero.war, para que sea accesible desde el navegador una vez ejecutada la aplicación. Utilizaremos Maven, Log4j y fichero de Properties, para hacer una aplicación lo más completa posible.

Objetivo: Tener un empaquetado .jar con TODO incluido, es decir, su propio Tomcat que despliega la aplicación .war, de manera que ejecutándolo, podemos acceder a la aplicación web en nuestro navegador. A mí no me suena mal, ya que permite mayor grado de limpieza en la máquina.


A continuación, parte del fichero "pom" de Maven


<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>
        <tomcat.version>8.5.5</tomcat.version>
    </properties>

    <dependencies>
  
        <dependency>
            <groupId>org.apache.tomcat</groupId>
            <artifactId>tomcat-catalina</artifactId>
            <version>${tomcat.version}</version>
        </dependency>
        <dependency>
            <groupId>org.apache.tomcat</groupId>
            <artifactId>tomcat-util</artifactId>
            <version>${tomcat.version}</version>
        </dependency>
        <dependency>
            <groupId>org.apache.tomcat.embed</groupId>
            <artifactId>tomcat-embed-core</artifactId>
            <version>${tomcat.version}</version>
        </dependency>
        <dependency>
            <groupId>org.apache.tomcat.embed</groupId>
            <artifactId>tomcat-embed-jasper</artifactId>
            <version>${tomcat.version}</version>
        </dependency>
  
         <dependency>
            <groupId>org.apache.tomcat.embed</groupId>
            <artifactId>tomcat-embed-websocket</artifactId>
            <version>${tomcat.version}</version>
        </dependency>
  
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>1.2.17</version>
        </dependency>

    </dependencies>
  
  
    <build>
        <sourceDirectory>src</sourceDirectory>
        <plugins>
    
            <plugin>
                <groupId>org.apache.tomcat.maven</groupId>
                <artifactId>tomcat7-maven-plugin</artifactId>
                <version>2.2</version>
                <configuration>
                    <port>8080</port>
                    <path>/</path>
                </configuration>
            </plugin>
    
            <plugin>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>3.5.1</version>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                </configuration>
            </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>directorio.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>



Y en el fichero de properties:

log.properties=log4j.properties
web.path=/My_App
web.war=C:\\.........\\My_App.war
web.port=8080
web.workingdir=/




El fichero log4j.properties, con la configuración de log4j para que nos escriba un fichero de log y además, nos escriba por consola:


# Root logger option
log4j.rootLogger=DEBUG, file, stdout

# Direct log messages to a log file
log4j.appender.file=org.apache.log4j.RollingFileAppender
log4j.appender.file.File=C:\\LOGS\\mylog.log
log4j.appender.file.MaxFileSize=10MB
log4j.appender.file.MaxBackupIndex=10
log4j.appender.file.layout=org.apache.log4j.PatternLayout
log4j.appender.file.layout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss} %-5p %c{1}:%L - %m%n

# Direct log messages to stdout
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.Target=System.out
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss} %-5p %c{1}:%L - %m%n



Por último, nuestro Main:


 public static void main(String[] args) {

        Properties properties = getProperties();
        if (properties != null) {
            try {

                // carga fichero de configuracion de log
                PropertyConfigurator.configure(new FileInputStream(properties.getProperty("log.properties")));
                Logger logger = LogManager.getLogger(Main.class);                

                String mWorkingDir = properties.getProperty("web.workingdir");

                Tomcat tomcat = new Tomcat();
                tomcat = new Tomcat();
                int port = Integer.parseInt(properties.getProperty("web.port"));
                tomcat.setPort(port);
                tomcat.setBaseDir(mWorkingDir);
                tomcat.getHost().setAppBase(mWorkingDir);
                tomcat.getHost().setAutoDeploy(true);
                tomcat.getHost().setDeployOnStartup(true);

                try {
                    tomcat.start();
                } catch (LifecycleException e) {                   
                    logger.error("Tomcat could not be started: LifecycleException in Main class");
                    e.printStackTrace();
                }
                logger.debug("Tomcat started on " + tomcat.getHost());

                // Alternatively, you can specify a WAR file as last parameter in the following call e.g. "C:\\Users\\admin\\Desktop\\app.war"
                Context appContext = tomcat.addWebapp(tomcat.getHost(), properties.getProperty("web.path"), properties.getProperty("web.war"));
                logger.debug("Deployed " + appContext.getBaseName() + " as " + appContext.getBaseName());

               
                tomcat.getServer().await();
            } catch (Exception e) {
                System.out.println("Unable to start Tomcat_Embedded_War_Loader.");
                e.printStackTrace();
            }
        }

    }

public static Properties getProperties() {
        Properties prop = new Properties();
        InputStream input = null;

        try {

            input = new FileInputStream("config.properties");
            
            // load a properties file
            prop.load(input);
            

            return prop;
        } catch (IOException ex) {
            ex.printStackTrace();
            return null;
        } finally {
            if (input != null) {
                try {
                    input.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

    }