Tu propio Hibernate: un mini ORM con anotaciones y reflexión

1import java.lang.annotation.*;
2import java.lang.reflect.*;
3import java.util.*;
4
5// ── Las anotaciones del ORM (como @Entity, @Table, @Column e @Id de JPA) ──
6@Retention(RetentionPolicy.RUNTIME) @Target(ElementType.TYPE)
7@interface Entidad { String tabla(); }
8
9@Retention(RetentionPolicy.RUNTIME) @Target(ElementType.FIELD)
10@interface Columna { String nombre(); int longitud() default 255; boolean nula() default true; }
11
12@Retention(RetentionPolicy.RUNTIME) @Target(ElementType.FIELD)
13@interface Id { }
14
15// ── Las clases mapeadas ──
16@Entidad(tabla = "alumnos")
17class Alumno {
18    @Id @Columna(nombre = "id_alumno") private int id;
19    @Columna(nombre = "nombre", longitud = 60, nula = false) private String nombre;
20    @Columna(nombre = "nota") private double nota;
21    @Columna(nombre = "repetidor") private boolean repetidor;
22    private String apodo;               // sin @Columna: no se guarda (como @Transient)
23}
24
25@Entidad(tabla = "cursos")
26class Curso {
27    @Id @Columna(nombre = "codigo", longitud = 10) private String codigo;
28    @Columna(nombre = "titulo", longitud = 80, nula = false) private String titulo;
29    @Columna(nombre = "horas") private int horas;
30    @Columna(nombre = "plazas") private Integer plazas;    // Integer, no int: admite NULL
31}
32
33class Profesor {                        // sin @Entidad: el ORM no sabe guardarla
34    private String nombre;
35}
36
37class Orm {
38
39    /** Los atributos con @Columna, en el orden en que están declarados. */
40    static List<Field> columnas(Class<?> c) {
41        List<Field> r = new ArrayList<>();
42        for (Field f : c.getDeclaredFields()) {
43            if (f.isAnnotationPresent(Columna.class)) {
44                f.setAccessible(true);
45                r.add(f);
46            }
47        }
48        return r;
49    }
50
51    static String tipoSql(Field f) {
52        Class<?> t = f.getType();
53        if (t == int.class || t == Integer.class) return "INT";
54        if (t == long.class || t == Long.class) return "BIGINT";
55        if (t == double.class || t == Double.class) return "DOUBLE";
56        if (t == boolean.class || t == Boolean.class) return "BOOLEAN";
57        if (t == String.class) return "VARCHAR(" + f.getAnnotation(Columna.class).longitud() + ")";
58        throw new IllegalArgumentException("tipo no soportado: " + t.getSimpleName());
59    }
60
61    static String crearTabla(Class<?> c) {
62        List<String> defs = new ArrayList<>();
63        for (Field f : columnas(c)) {
64            Columna col = f.getAnnotation(Columna.class);
65            String d = col.nombre() + " " + tipoSql(f);
66            if (f.isAnnotationPresent(Id.class)) d += " PRIMARY KEY";
67            else if (!col.nula() || f.getType().isPrimitive()) d += " NOT NULL";   // un int nunca es null
68            defs.add(d);
69        }
70        return "CREATE TABLE " + c.getAnnotation(Entidad.class).tabla() + " (" + String.join(", ", defs) + ");";
71    }
72
73    /** Convierte el texto al tipo del atributo; «null» es NULL salvo en los tipos primitivos. */
74    static Object convertir(String valor, Class<?> t) {
75        if (valor.equalsIgnoreCase("null")) {
76            if (t.isPrimitive()) throw new IllegalArgumentException("no puede ser NULL (el atributo es " + t.getSimpleName() + ")");
77            return null;
78        }
79        try {
80            if (t == int.class || t == Integer.class) return Integer.parseInt(valor);
81            if (t == long.class || t == Long.class) return Long.parseLong(valor);
82            if (t == double.class || t == Double.class) return Double.parseDouble(valor);
83        } catch (NumberFormatException e) {
84            throw new IllegalArgumentException("«" + valor + "» no es un " + t.getSimpleName());
85        }
86        if (t == boolean.class || t == Boolean.class) {
87            if (valor.equalsIgnoreCase("true")) return true;
88            if (valor.equalsIgnoreCase("false")) return false;
89            throw new IllegalArgumentException("«" + valor + "» no es un " + t.getSimpleName());
90        }
91        return valor;
92    }
93
94    /** Crea el objeto con su constructor sin parámetros y rellena cada atributo con su columna de la fila. */
95    static <T> T cargar(Class<T> c, Map<String, String> fila) throws ReflectiveOperationException {
96        String tabla = c.getAnnotation(Entidad.class).tabla();
97        List<Field> cols = columnas(c);
98        for (String nombre : fila.keySet()) {
99            if (cols.stream().noneMatch(f -> f.getAnnotation(Columna.class).nombre().equals(nombre)))
100                throw new IllegalArgumentException("la tabla " + tabla + " no tiene la columna " + nombre);
101        }
102        T obj = c.getDeclaredConstructor().newInstance();
103        for (Field f : cols) {
104            Columna col = f.getAnnotation(Columna.class);
105            boolean id = f.isAnnotationPresent(Id.class);
106            String texto = fila.get(col.nombre());
107            if (texto == null) {
108                if (id || !col.nula()) throw new IllegalArgumentException("falta la columna " + col.nombre());
109                continue;               // se queda el valor por defecto: 0, false o null
110            }
111            Object valor;
112            try {
113                valor = convertir(texto, f.getType());
114            } catch (IllegalArgumentException e) {
115                throw new IllegalArgumentException(col.nombre() + ": " + e.getMessage());
116            }
117            if (valor == null && id) throw new IllegalArgumentException(col.nombre() + ": no puede ser NULL (es la clave primaria)");
118            if (valor == null && !col.nula()) throw new IllegalArgumentException(col.nombre() + ": no puede ser NULL (la columna es NOT NULL)");
119            f.set(obj, valor);
120        }
121        return obj;
122    }
123
124    static String sql(Object v) {
125        if (v == null) return "NULL";
126        if (v instanceof String s) return "'" + s.replace("'", "''") + "'";
127        if (v instanceof Boolean b) return b ? "TRUE" : "FALSE";
128        return v.toString();
129    }
130
131    static String insertar(Object o) throws IllegalAccessException {
132        List<String> cols = new ArrayList<>(), valores = new ArrayList<>();
133        for (Field f : columnas(o.getClass())) {
134            cols.add(f.getAnnotation(Columna.class).nombre());
135            valores.add(sql(f.get(o)));
136        }
137        return "INSERT INTO " + o.getClass().getAnnotation(Entidad.class).tabla()
138                + " (" + String.join(", ", cols) + ") VALUES (" + String.join(", ", valores) + ");";
139    }
140
141    /** Todos los atributos del objeto, mapeados o no: Alumno{id=1, nombre=Ana, ...}. */
142    static String describir(Object o) throws IllegalAccessException {
143        List<String> partes = new ArrayList<>();
144        for (Field f : o.getClass().getDeclaredFields()) {
145            f.setAccessible(true);      // los atributos son private
146            partes.add(f.getName() + "=" + f.get(o));
147        }
148        return o.getClass().getSimpleName() + "{" + String.join(", ", partes) + "}";
149    }
150}
151
152public class Main {
153    static final List<Class<?>> CLASES = List.of(Alumno.class, Curso.class, Profesor.class);
154
155    public static void main(String[] args) throws Exception {
156        for (Class<?> c : CLASES) {
157            if (c.isAnnotationPresent(Entidad.class)) System.out.println(Orm.crearTabla(c));
158        }
159        Scanner sc = new Scanner(System.in);
160        int insertados = 0, errores = 0;
161        while (sc.hasNextLine()) {
162            String linea = sc.nextLine().trim();
163            if (linea.isEmpty()) continue;
164            String[] p = linea.split("\\s+", 2);
165            Class<?> c = CLASES.stream().filter(k -> k.getSimpleName().equals(p[0])).findFirst().orElse(null);
166            if (c == null) {
167                System.out.println("Clase desconocida: " + p[0]);
168                errores++;
169                continue;
170            }
171            if (!c.isAnnotationPresent(Entidad.class)) {
172                System.out.println(p[0] + " no es una entidad (le falta @Entidad)");
173                errores++;
174                continue;
175            }
176            Map<String, String> fila = new LinkedHashMap<>();
177            if (p.length > 1) {
178                for (String par : p[1].split(";")) {
179                    int i = par.indexOf('=');
180                    if (i > 0) fila.put(par.substring(0, i).trim(), par.substring(i + 1).trim());
181                }
182            }
183            try {
184                Object o = Orm.cargar(c, fila);
185                System.out.println(Orm.describir(o));
186                System.out.println(Orm.insertar(o));
187                insertados++;
188            } catch (IllegalArgumentException e) {
189                System.out.println("Error en " + p[0] + ": " + e.getMessage());
190                errores++;
191            }
192        }
193        System.out.println(insertados + " insertados, " + errores + " con errores");
194    }
195}