Avancement BDD

src/db/Database.java

@@ -6,6 +6,7 @@ import java.util.logging.Logger;
 
 import java.sql.Connection;
 import java.sql.DriverManager;
+import java.sql.PreparedStatement;
 import java.sql.ResultSet;
 import java.sql.SQLException;
 
@@ -18,6 +19,7 @@ public class Database {
 		ini();
 		unset();
 		setup();
+		execute("Insert into Espace(LIBELLE) Values('test')");
 	}
 	
 	public static void ini() {
@@ -69,11 +71,22 @@ public class Database {
 		});
 	}
 	
-	public static Optional<ResultSet> query(String sql) {
+	public static boolean query(String sql) {
 		try(Statement st = db.createStatement()) {
 			ResultSet result = st.executeQuery(sql);
-			return Optional.of(result);
-		} catch (SQLException e) {
+			return true;
+		} catch (SQLException | IllegalStateException e) {
+			LOGGER.warning(e.getMessage());
+			return false;
+		}
+	}
+	
+	public static <T extends Persistable> Optional<T> query(String sql, Mapper<T> mapper) {
+		try(Statement st = db.createStatement()) {
+			ResultSet result = st.executeQuery(sql);
+			T obj = mapper.map(result);
+			return Optional.of(obj);
+		} catch (SQLException | IllegalStateException e) {
 			LOGGER.warning(e.getMessage());
 			return Optional.empty();
 		}
@@ -90,7 +103,7 @@ public class Database {
 	}
 	
 	public static boolean isSet() {
-		return query("Select * From Espace").isPresent();
+		return query("Select * From Espace");
 	}
 	
 	public static Connection getDb() {

src/db/Mapper.java

@@ -0,0 +1,10 @@
+package db;
+
+import java.sql.ResultSet;
+
+@FunctionalInterface
+public interface Mapper<T extends Persistable> {
+
+	public T map(ResultSet data);
+	
+}

src/db/Persistable.java

@@ -0,0 +1,6 @@
+package db;
+
+public interface Persistable {
+
+    long getId();
+}

src/db/Table.java

@@ -0,0 +1,120 @@
+package db;
+
+import java.lang.reflect.Field;
+import java.lang.reflect.InvocationTargetException;
+import java.sql.SQLException;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Optional;
+
+import db.annotation.DbField;
+import db.annotation.DbId;
+import db.annotation.DbTable;
+
+public abstract class Table<T extends Persistable> {
+	
+	protected Map<Long, T> cacheMap = new HashMap<>();
+	
+	public Optional<T> findById(long id) {
+		if (cacheMap.containsKey(id)) {
+			return Optional.of(cacheMap.get(id));
+		}
+		Optional<T> obj = getFromDb(id);
+		if(obj.isPresent()) {
+			cache(obj.get());
+		}
+		return obj;
+	}
+	
+	public T refresh(long id) {
+		if (!cacheMap.containsKey(id)) {
+			throw new IllegalArgumentException("Entity is not load, can't refresh");
+		}
+		Optional<T> optObj = getFromDb(id);
+		if(optObj.isEmpty()) {
+			throw new IllegalStateException("Unable to find entity in the database");
+		}
+		T obj = optObj.get();
+		cache(obj);
+		return obj;
+	}
+	
+	public T refresh(T obj) {
+		return refresh(obj.getId());
+	}
+	
+	public void save(T obj) {
+		if (cacheMap.containsKey(obj.getId())) {
+			update(obj);
+		} else {
+			insert(obj);
+		}
+	}
+	
+	public final void delete(long id) {
+		
+	}
+	
+	public void delete(T obj) {
+		delete(obj.getId());
+	}
+	
+	private void cache(T obj) {
+		if (cacheMap.containsKey(obj.getId())) {
+			cacheMap.replace(obj.getId(), obj);
+		} else {
+			cacheMap.put(obj.getId(), obj);
+		}
+	}
+	
+	private Optional<T> getFromDb(long id) {
+		Class<?> clazz = this.getClass();
+		// Recupération info anotation DbTable
+		if (!clazz.isAnnotationPresent(DbTable.class)) {
+			throw new IllegalStateException("Unable ton find DbTable annotation");
+		}
+		DbTable dbTable = clazz.getAnnotation(DbTable.class);
+		// Cherche l'id
+		String idField = null;
+		for(Field field : dbTable.entity().getFields()) {
+			if(field.isAnnotationPresent(DbId.class)) {
+				if(field.isAnnotationPresent(DbField.class)) {
+					idField = field.getAnnotation(DbField.class).name();
+				} else {
+					throw new IllegalStateException("Unable to find DbField annotation on id");
+				}
+			}
+		}
+		if (idField == null) {
+			throw new IllegalStateException("Unable to find find DbField annotation");
+		}
+		// Requete sql
+		String sql = "Select * From " + dbTable.name() + " Where " + idField + " = " + id;
+		Optional<T> result = Database.query(sql, rs -> {
+			try {
+				T obj = (T) dbTable.entity().getConstructor().newInstance();
+				rs.next();
+				for(Field field : dbTable.entity().getFields()) {
+					if(!field.isAnnotationPresent(DbField.class)) {
+						continue;
+					}
+					obj.getClass().getField(field.getName()).set(obj, rs.getObject(field.getAnnotation(DbField.class).name()));
+				}
+				return obj;
+			} catch (InstantiationException | IllegalAccessException | IllegalArgumentException | InvocationTargetException | NoSuchMethodException | SecurityException | NoSuchFieldException | SQLException e) {
+				throw new IllegalStateException("Unable to map value to the entity");
+			}
+		});
+		// Return
+		return result;
+	}
+	
+	private void insert(T obj) {
+		
+	}
+	
+	private void update(T obj) {
+		
+	}
+
+}

src/db/annotation/DbField.java

@@ -0,0 +1,14 @@
+package db.annotation;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Retention(RetentionPolicy.RUNTIME)
+@Target(ElementType.FIELD)
+public @interface DbField {
+	
+	public String name();
+
+}

src/db/annotation/DbId.java

@@ -0,0 +1,12 @@
+package db.annotation;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Retention(RetentionPolicy.RUNTIME)
+@Target(ElementType.FIELD)
+public @interface DbId {
+
+}

src/db/annotation/DbTable.java

@@ -0,0 +1,18 @@
+package db.annotation;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+import db.Persistable;
+
+@Retention(RetentionPolicy.RUNTIME)
+@Target(ElementType.TYPE)
+public @interface DbTable {
+	
+	public String name();
+	
+	public Class<? extends Persistable> entity();
+
+}

src/db/table/EspaceTable.java

@@ -0,0 +1,10 @@
+package db.table;
+
+import db.Table;
+import db.annotation.DbTable;
+import entity.Espace;
+
+@DbTable(name = "Espace", entity = Espace.class)
+public class EspaceTable extends Table<Espace>{
+
+}

src/entity/Espace.java

@@ -0,0 +1,22 @@
+package entity;
+
+import db.Persistable;
+import db.annotation.DbField;
+import db.annotation.DbId;
+
+public class Espace implements Persistable {
+	
+	@DbId
+	@DbField(name = "ID")
+	public long id;
+	
+	@DbField(name = "LIBELLE")
+	public String libelle;
+
+	@Override
+	public long getId() {
+		return id;
+	}
+	
+
+}

src/servlets/TestDb.java

@@ -11,6 +11,8 @@ import javax.servlet.http.HttpServletRequest;
 import javax.servlet.http.HttpServletResponse;
 
 import db.Database;
+import db.ManageTable;
+import db.table.EspaceTable;
 
 /**
  * Servlet implementation class TestDb
@@ -31,8 +33,8 @@ public class TestDb extends HttpServlet {
 	 * @see HttpServlet#doGet(HttpServletRequest request, HttpServletResponse response)
 	 */
 	protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
-		Optional<ResultSet> result = Database.query("Select * From lol");
-		System.out.println(result.isEmpty());
+		EspaceTable et = new EspaceTable();
+		et.findById(1);
 		response.getWriter().append("Served at: ").append(request.getContextPath());
 	}