Introducción a Java y Spring

En esta guía aprenderemos los principios básicos del lenguaje de programación Java y su
framework Spring, uno de los más populares para trabajar con Java.

Fundamentos de Java
Sintaxis Básica
Para entender Java, es fundamental conocer su estructura básica. Un programa en Java
siempre empieza con una clase y el método main:

public class Main {

public static void main(String[] args) {
System.out.println("Hola, Mundo!");
}
}

● public class Main Define una clase llamada Main.

● public static void main(String[] args): Define el método principal que se ejecuta al iniciar
el programa.
● System.out.println("Hola, Mundo!"): Imprime "Hola, Mundo!" en la consola.

Variables y Tipos de Datos

Java usa variables para almacenar datos. Aquí algunos tipos de datos básicos:

● int: Números enteros.

● float: Números decimales pequeños.
● double: Números decimales grandes.
● char: Un solo carácter.
● String: Cadena de texto.

Ejemplos:

● int numero = 10;

● float decimal = 5.75f;
● double grande = 19.99;
● char letra = 'A';
● String texto = "Hola";
Manejo de Datos

Condicionales
Los condicionales permiten tomar decisiones en el código basadas en ciertas condiciones.Este
código verifica la edad y muestra un mensaje diferente dependiendo del valor de edad.

int edad = 18;

if (edad < 18) {
System.out.println("Menor de edad");
} else if (edad == 18) {
System.out.println("Justo 18");
} else {
System.out.println("Mayor de edad");
}

Funciones (Métodos)
Las funciones permiten reutilizar código. Definir una función en Java se hace así:

public class Main {

public static void main(String[] args) {
saludar();
}

public static void saludar() {

System.out.println("Hola, Mundo!");
}
}
Este código define una función saludar que imprime "Hola, Mundo!" y la llama desde el
método main.

Trabajar con Fechas y Tiempos

Java tiene varias clases para manejar fechas y tiempos, como Date, Calendar, y
LocalDate.

● Date: Clase básica para trabajar con fechas.

Date fecha = new Date();
 System.out.println(fecha);

● Calendar: Clase avanzada con más funcionalidades.

Calendar calendario = Calendar.getInstance();
System.out.println(calendario.getTime());

● LocalDate: Clase moderna para manejar fechas.

LocalDate hoy = LocalDate.now();
System.out.println(hoy);

Estructuras de Control

Bucles

Los bucles permiten repetir una sección de código varias veces.

● for:
for (int i = 0; i < 5; i++) {
System.out.println(i);
}
Este bucle for imprime los números del 0 al 4.

● while:
int i = 0;
while (i < 5) {
System.out.println(i);
i++;
}
Este bucle while también imprime los números del 0 al 4.

● do-while:
int i = 0;
do {
System.out.println(i);
i++;
} while (i < 5);
Este bucle do-while imprime los números del 0 al 4, asegurando al menos una ejecución.

Manejo de Excepciones
Las excepciones manejan errores en tiempo de ejecución.
 ● Try-catch: Este bloque try-catch captura el error de división por cero y
muestra un mensaje.
try {
int division = 10 / 0;
} catch (ArithmeticException e) {
System.out.println("Error: División por cero");
}

● Throw, throws: throw lanza una excepción y throws declara que un método
puede lanzar excepciones.
public void lanzarExcepcion() throws Exception {
throw new Exception("Mi Excepción");
}

Orientación a Objetos (OOP)

Clases y Objetos

Las clases son plantillas para crear objetos. Esta clase Persona tiene atributos y un
constructor para inicializarlos.

public class Persona {

String nombre;
int edad;

public Persona(String nombre, int edad) {

this.nombre = nombre;
this.edad = edad;
}
}

Persona persona = new Persona("Juan", 30);

Principios OOP
● Herencia: Permite que una clase derive de otra. Perro hereda de Animal y
sobrescribe el método sonido:

public class Animal {

void sonido() {
System.out.println("El animal hace un sonido");
 }
}
public class Perro extends Animal {
void sonido() {
System.out.println("El perro ladra");
}
}

● Polimorfismo: Permite usar una clase derivada como si fuera su clase base. Un
objeto Perro se usa como un Animal y ejecuta su método sonido:

Animal miPerro = new Perro();

miPerro.sonido();

● Encapsulación: Oculta los detalles internos y muestra solo lo necesario.

CuentaBancaria oculta el atributo saldo y proporciona métodos para
interactuar con él:

public class CuentaBancaria {

private double saldo;
public void depositar(double monto) {
saldo += monto;
}
public double obtenerSaldo() {
return saldo;
}
}

● Abstracción: Define clases abstractas y métodos abstractos. Figura es una

clase abstracta con un método abstracto dibujar que Circulo implementa:

abstract class Figura {

abstract void dibujar();

}
class Circulo extends Figura {
void dibujar() {
System.out.println("Dibujando un círculo");
}
}
Manejo de Archivos y APIs

Lectura y Escritura de Archivos

● Leer un archivo
Para leer un archivo en Java, usamos BufferedReader junto con FileReader. Esto nos
permite leer el contenido línea por línea.
BufferedReader reader = new BufferedReader(new
FileReader("archivo.txt"));
String linea;
while ((linea = reader.readLine()) != null) {
System.out.println(linea);
}
reader.close();
Este código abre un archivo llamado "archivo.txt", lee cada línea y la imprime en la consola.

● Escribir un archivo
Para escribir en un archivo, usamos BufferedWriter junto con FileWriter. Esto nos
permite escribir texto en el archivo.
BufferedWriter writer = new BufferedWriter(new
FileWriter("archivo.txt"));
writer.write("Hola, Mundo!");
writer.close();
Este código crea (o abre) un archivo llamado "archivo.txt" y escribe "Hola, Mundo!" en él.

Uso de APIs
Las APIs permiten a nuestras aplicaciones interactuar con otros servicios en internet y obtener
datos. Aquí te mostramos cómo hacer una solicitud HTTP GET a una API.

URL url = new URL("https://api.ejemplo.com/datos");

HttpURLConnection con = (HttpURLConnection) url.openConnection();
con.setRequestMethod("GET");

BufferedReader in = new BufferedReader(new

InputStreamReader(con.getInputStream()));
String inputLine;
StringBuffer content = new StringBuffer();
while ((inputLine = in.readLine()) != null) {
content.append(inputLine);
}
in.close();
 con.disconnect();
Este código se conecta a una URL, envía una solicitud GET, y lee la respuesta línea por línea.
Los datos obtenidos se almacenan en content.

Un paso por Spring

Ya revisado los fundamentos de Java, como la sintaxis básica, manejo de datos y estructuras
de control podemos ver que Spring se construye sobre estos conceptos y los extiende para
facilitar el desarrollo de aplicaciones empresariales complejas.

Introducción a Spring Framework

Spring es un framework que ayuda a desarrollar aplicaciones Java de manera más eficiente.
Proporciona una estructura sólida y herramientas útiles para manejar aspectos comunes del
desarrollo de software.

Arquitectura de Spring

Diagrama de arquitectura de Spring según su página oficinal

Este diagrama muestra cómo Spring organiza y gestiona diferentes partes de una aplicación,
desde la base de datos hasta la web y pruebas, para facilitar el desarrollo en Java.

1. Core Container: Maneja la configuración y el ciclo de vida de los objetos (beans)

usando Inversión de Control (IoC).
○ Beans: Gestiona objetos en Spring.
○ Core: Funciones básicas de Spring.
○ Context: Extiende el Core con más características.
○ Expression Language: Permite manejar valores dinámicos.
2. AOP: Permite separar funcionalidades transversales, como la gestión de transacciones
y la seguridad.
○ AOP: Maneja aspectos transversales como logging.
○ Aspects: Implementa esos aspectos.
○ Instrumentation: Permite modificar clases y bytecode.
3. Data Access/Integration
○ JDBC: Accede a bases de datos.
○ ORM: Integra con frameworks como Hibernate.
○ OXM: Trabaja con XML.
○ JMS: Soporte de mensajería.
○ Transactions: Maneja transacciones.
4. Web
○ Web: Soporte para aplicaciones web.
○ Servlet, Portlet, Struts: Herramientas específicas para web.
5. Test
○ Facilita las pruebas de aplicaciones.

Configuración de Spring
● XML: La configuración tradicional de Spring se hace usando archivos XML. En estos
archivos, defines cómo se crean y configuran los diferentes componentes (beans) de tu
aplicación. Es como una lista de instrucciones externas al código, que Spring lee y sigue
para montar la aplicación.
● Anotaciones: La configuración moderna de Spring usa anotaciones directamente en el
código. En lugar de escribir todo en archivos XML, colocas pequeñas etiquetas
(anotaciones) en las clases y métodos. Esto hace que la configuración sea más simple y
más fácil de mantener, ya que está integrada directamente en el código que estás
escribiendo.

Ejemplo de configuración con anotaciones:

@Configuration
public class AppConfig {
@Bean
public MyService myService() {
 return new MyServiceImpl();
}
}

Spring Core

● Inversión de Control (IoC) y Inyección de Dependencias (DI): IoC permite que el

contenedor de Spring maneje la creación y gestión de objetos, mientras que DI permite
inyectar dependencias en estos objetos.

@Component
public class MyService {
private final MyRepository myRepository;
@Autowired
public MyService(MyRepository myRepository) {
this.myRepository = myRepository;
}
}

● Beans y el Contenedor de Spring: Los beans son objetos administrados por el

contenedor de Spring. El ciclo de vida de un bean incluye su creación, inicialización y
destrucción.

Spring MVC (Model-View-Controller)

● Controladores: Manejan las solicitudes del usuario y devuelven las respuestas

apropiadas.

@Controller
public class MyController {
@RequestMapping("/hello")
public String sayHello() {
return "hello";
}
}

● Vistas: Integración con tecnologías de vistas como JSP y Thymeleaf para renderizar el
contenido de las respuestas.

Acceso a Datos con Spring

● Spring JDBC: Facilita la interacción con bases de datos usando JDBC.

 @Autowired
private JdbcTemplate jdbcTemplate;
public void queryData() {
List<Map<String, Object>> rows =
jdbcTemplate.queryForList("SELECT * FROM my_table");
}

● Spring Data JPA: Simplifica el uso de JPA para manejar datos persistentes.

public interface MyRepository extends JpaRepository<MyEntity,

Long> {

● Transacciones: Gestión de transacciones para asegurar la integridad de los datos.

@Transactional
public void performTransaction() {
// Código de la transacción
}