style="display:inline-block;width:728px;height:90px"
data-ad-client="ca-pub-5164839828746352"
data-ad-slot="7563230308">

Java Standard Edition

Guardar Archivos en SQL Server

A continuación les comparto un ejemplo de cómo guardar archivos en una BD SQL Server, adicionalmente pueden leer el mime del archivo para la hora de la decodificación.

public String GuardarDocumento(String nombre, String valor, String path_img, int id_movimiento) throws SQLException, FileNotFoundException {
        Conexion objConexion = new Conexion();
        String salida = "";
        int len;
        String query = "insert into documentos(nombre_documento,ruta_documento,movimiento,archivo_binario) values(?,?,?,?)";
        PreparedStatement ps = objConexion.Conectar().prepareStatement(query, PreparedStatement.RETURN_GENERATED_KEYS);
        try {            
            File file = new File(path_img);
            FileInputStream fis = new FileInputStream(file);
            len = (int) file.length();
            ps.setString(1, nombre);//Nombre del Documento
            ps.setString(2, valor);//ruta al doc
            ps.setInt(3, id_movimiento);//id_movimiento            
            ps.setBinaryStream(4, fis, len);
            ps.executeUpdate();
            ps.close();
            salida = "OK";
        } catch (Exception e) {

Dagger 2

Inyección de dependencias con Dagger 2

Dagger 2 es un framework de inyección de dependencias que se diferencia de otros en que la inyección se hace en tiempo de compilación con código generado en vez de en tiempo de ejecución utilizando reflection, esto tiene como ventajar principal la mejora en el desempeño de la aplicación pero tambien tiene otros como una mejor trazabilidad en los stacktraces cuando algo sale mal ( en vez de solo ver Method.invoke, invoke por todos lados ) o que se puede obtener errores de dependencias durante la fase de compilación en vez de en runtime.

Aquí hay un video donde se explica que es, cómo se compara con otros ( Guice, Spring, Dagger 1) y los beneficios que tiene.

Ejemplo

Voy a hacer un ejemplo que espero me salga sencillo:

Digamos que tengo una app para buscar palabras en páginas web, lo componen tres clases:

- SearchApp contiene el main
- SearchInPage hace la búsqueda
- HttpClient obtiene el contenido de una página

Log4j para Creación de Eventos de Log

  • Log4j, un framework especializado para el logging o creación de bitácoras en las aplicaciones Java.
  • Log4j es un framework que ofrece una forma jerárquica de insertar sentencias de log dentro de una aplicación Java. Con él, se tienen disponibles múltiples formatos de salida, y múltiples niveles de información de log.
  • Los loggers pueden tener niveles asignados. Los niveles normales que puede tener un logger son, de menor a mayor prioridad:

  • TRACE: Se usa para información más detallada que el nivel debug.
  • DEBUG: Se utiliza para mensajes de información detallada que son útiles para debugear una aplicación.
  • INFO: Se utiliza para mensajes de información que resaltan el progreso de la aplicación de una forma general.
  • WARN: Se utiliza para situaciones que podrían ser potencialmente dañinas.
  • ERROR: Se usa para eventos de error que podrían permitir que la aplicación continúe ejecutándose.
  • FATAL: Se usa para errores muy graves, que podrían hacer que la aplicación dejara de funcionar.
  • Bueno crearemos un ejemplo sencillo de la utilización en una clase.

    AYUDA POR FAVOR

    NECESITO AYUDA PORFAVOR ANDO HACIENDO UN PROGRAMA Q QUE ME TENGA QUE REALIZAR LA SIGUIENTE FUNCION: INGRESAR POR TECLADO CUALQUIER NOMBRE Y QUE TE CREE UNA MATRIZ DEL TAMAÑA DE ESE NOMBRE Y APARTE QUE DIGA CUANTAS LETRAS TIENE ESE NOMBRE Y DIGA CUAL ES LA DIAGONAL DE ESA MATRIZ...!!!!

    ESTO ES LO QUE TENGO ECHO PORFAVOR LE AGRADECERIA LA AYUDA

    package primer_1;
    import java.util.*;
    import javax.swing.JOptionPane;
    public class diagonal{

            public static void main(String[] args) {
                    // TODO Auto-generated method stub
                   
                    String nombre=JOptionPane.showInputDialog("Ingrese su nombre: ");
                   
                            System.out.println("Mi nombre " + nombre +" tiene" +" "+ nombre.length()+" letras. ");
                   
                                    for(int i=0; i<nombre.length(); i++){
                                           
                                           
                                            int [][] matriz= new int[i][i];
                                           
                                                    System.out.print(nombre.charAt(i) +"");
                                                   
                                   
                                    }
            }
    }

    Obtener la version del JDK utilizada en la compilación

    Hoy fue uno de esos días en que tuve que lidiar con un proyecto legacy el cual está construido con Java 5, la sorpresa que tuve cuando comencé a compilar fue que varias bibliotecas (JAR) estaban compiladas con una version superior. Como necesitaba saber exactamente cuales eran las que necesitaba hacer Downgrade de versión y eran bastantes los JAR's escribí este script que después pensé que seria util para la comunidad.

    Básicamente lo que hace es tomar cada archivo y lo descomprime en una carpeta X y obtiene el primer archivo *.class y se ejecuta el comando javap para obtener la version, como eso retorna algo similar a   version: 52 entonces quité lo que no es numero para asignarlo a la variable $v y utilizando arrays asociativos es que se mapea el valor para obtener la versión.

    TO_DO:
    Mejoraría bastante el performance si se descomprimiera solo el primer archivo *.class que encuentre.

    #!/bin/bash
     
    LIB_HOME=/path/to/lib/*.jar
     
    version['45.3']=1.1
    version['46']=1.2
    version['47']=1.3
    version['48']=1.4
    version['49']=5
    version['50']=6
    version['51']=7
    version['52']=8
     
    for JAR_FILE in $LIB_HOME
    do

    Java 9 estaría llegando en septiembre de 2016

    Java 9 estaría llegando el 22 de Septiembre de 2016, de acuerdo al calendario propuesto para Java 9, publicado hace algunos días por Mark Reinhold, arquitecto en jefe de la plataforma Java en Oracle.


    * Imagen de http://modomatic.smugmug.com/Selected-Work-of-Moriza/Life-Underground/i-...

    Dos características resaltan en esta nueva versión: la modularización de la plataforma Java y la introducción de un sistema de módulos.

    De acuerdo con Reinhold (1), entre los objetivos del Proyecto Jigsaw (JSR 376) está diseñar:

    Un sistema de módulos estándar para la plataforma Java facilitará la construcción, mantenimiento y distribución de aplicaciones de gran tamaño, por fin permitiendo a los desarrolladores escapar del “Infierno JAR” del frágil y propenso a errores mecanismo llamado class-path.

    Desarrollo de libreria para consultas DDL y DML

    Tengo un tiempo desarrollando una libreria para facilitar el acceso y manipulacion de bases de datos, se que ya existen muchas soluciones pero creo que la mayoria estan enfocadas para grandes proyectos y son bastante complejas por eso lo empeze como un proyecto personal pero creo que esta en un buen punto para compartirlo con la comunidad. Por el momento solo tiene soporte para mysql y h2 aunque todavia hace falta hacer pruebas y documentar bastante, si alguien esta interesado puede contribuir con el desarrollo.
    https://github.com/luischavez/database/tree/dev

    Database database = Database.use("mysql");
    database.create("users", table -> {
        table.integer("id").incremented();
        table.string("username", 32);
     
        table.primary("id");
    });
     
    if (database.exists("users")) {
        database.insert("users", "username", "luischavez");
        Row user = database.query("users").first();
        database.drop("users");
    }

    Imprimir año en formato calendario (ejercicio)

    Ya es viernes! así que algo entretenido.

    Siguiendo el espíritu de esta pregunta:
    http://www.javamexico.org/blogs/jsrivero22/crear_un_calendario

    El ejercicio es imprimir el calendario del año así:

                                 2015
    
          January               February               March
    Su Mo Tu We Th Fr Sa  Su Mo Tu We Th Fr Sa  Su Mo Tu We Th Fr Sa
                 1  2  3   1  2  3  4  5  6  7   1  2  3  4  5  6  7
     4  5  6  7  8  9 10   8  9 10 11 12 13 14   8  9 10 11 12 13 14
    11 12 13 14 15 16 17  15 16 17 18 19 20 21  15 16 17 18 19 20 21
    18 19 20 21 22 23 24  22 23 24 25 26 27 28  22 23 24 25 26 27 28
    25 26 27 28 29 30 31                        29 30 31
                                                
           April                  May                   June
    Su Mo Tu We Th Fr Sa  Su Mo Tu We Th Fr Sa  Su Mo Tu We Th Fr Sa
              1  2  3  4                  1  2      1  2  3  4  5  6
     5  6  7  8  9 10 11   3  4  5  6  7  8  9   7  8  9 10 11 12 13
    12 13 14 15 16 17 18  10 11 12 13 14 15 16  14 15 16 17 18 19 20
    19 20 21 22 23 24 25  17 18 19 20 21 22 23  21 22 23 24 25 26 27
    26 27 28 29 30        24 25 26 27 28 29 30  28 29 30

    crear un calendario.!!

    lo que quiero es q me pueda mostrar los nombres de la semana dias y mes osea algo asi: ---> Lunes 4 de Febrero pero el problema que tengo es que no me muestra los dias de manera seguida..!!!

    package meses;

    public class mese {

            public static void main(String[] args) {
           
                    String[] dias = {"Lunes", "Martes", "Miercoles", "Jueves", "Viernes", "Sabado", "Domingo"};
                           
                                                           
                            for (int E=1; E<=31; ){
                                    for (int i = 0; i < dias.length;i++) {
                                            if (E<=31){
                                                    System.out.println(dias[i]+" "+E+" enero");
                                            }
                                            else{
                                                    break;
                                            }                                                                      
                                            E++;
                                    }              
                            }
                           
                            for (int f=1; f<=28;){
                                    for (int i = 0 ; i < dias.length;i++) {
                                            if (f<=28){
                                                    System.out.println(dias[i]+" "+f+" febrero");
                                            }
                                            else{
                                                    break;
                                            }                                                                      
                                            f++;
                                    }              
                            }
                           
                            for (int m=1; m<=31;){
                                    for (int i = 0; i < dias.length;i++) {
                                            if (m<=31){
                                                    System.out.println(dias[i]+" "+m+" marzo");
                                            }
                                            else{
                                                    break;
                                            }                                                                      
                                            m++;
                                    }              
                            }
                           
                            for (int a=1; a<=30;){
                                    for (int i = 3; i < dias.length;i++) {

    Argumentos Variadicos (Varargs)

    Desde Java 5 se incorporo la posibilidad de tener argumentos variádicos (varargs) en métodos y constructores, dichos argumentos permiten al desarrollador ahorrarse la sobrecarga de métodos o constructores que contienen de 0 a N argumentos del mismo tipo.

    Antes de Java 5, había de dos sopas, se tenía que sobrecargar el método, con la límitante para el desarrollador de saber la cantidad máxima y mínima del número de argumentos:

    public class VarargsExample {

            public static void main(String[] args) {

                    Greeting greet = new Greeting();
                    greet.greetings("Hugo", "Paco", "Luis");
                    greet.greetings("Hugo", "Paco");
                    greet.greetings("Hugo");

            }

    }

    class Greeting {

            public void greetings(String name1) {
                    System.out.println("Hi " + name1);
            }

            public void greetings(String name1, String name2) {
                    System.out.println("Hi " + name1 + ", " + name2);
            }

            public void greetings(String name1, String name2, String name3) {
                    System.out.println("Hi " + name1 + ", " + name2 + ", " + name3);
            }
    }

    Y la segunda sopa sería tener definidos los elementos dentro de un arreglo:

    public class VarargsExample {
    Distribuir contenido

    style="display:inline-block;width:728px;height:90px"
    data-ad-client="ca-pub-5164839828746352"
    data-ad-slot="7563230308">