LightPIT: comparison src/main/java/de/uapcore/lightpit/AbstractLightPITServlet.java

-:fecda0f466e6
+:cf85ef18f231
 * POSSIBILITY OF SUCH DAMAGE.
 *
 */
 package de.uapcore.lightpit;
+import de.uapcore.lightpit.dao.DataAccessObjects;
+import de.uapcore.lightpit.dao.postgres.PGDataAccessObjects;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import javax.servlet.ServletException;
 import javax.servlet.http.HttpServlet;
 import javax.servlet.http.HttpServletResponse;
 import javax.servlet.http.HttpSession;
 import java.io.IOException;
 import java.lang.reflect.Method;
 import java.lang.reflect.Modifier;
+import java.sql.Connection;
+import java.sql.SQLException;
 import java.util.*;
 /**
 * A special implementation of a HTTPServlet which is focused on implementing
 * the necessary functionality for {@link LightPITModule}s.
 private LightPITModule.ELProxy moduleInfo = null;
 @FunctionalInterface
 private interface HandlerMethod {
-ResponseType apply(HttpServletRequest t, HttpServletResponse u) throws IOException;
+ResponseType apply(HttpServletRequest request, HttpServletResponse response, DataAccessObjects dao) throws IOException, SQLException;
 }
 /**
 * Invocation mapping gathered from the {@link RequestMapping} annotations.
 * <p>
 */
 protected final ModuleManager getModuleManager() {
 return (ModuleManager) getServletContext().getAttribute(ModuleManager.SC_ATTR_NAME);
 }
-/**
-* Gives implementing modules access to the {@link DatabaseFacade}.
+/**
+* Creates a set of data access objects for the specified connection.
 *
-* @return the database facade
+* @param connection the SQL connection
-*/
+* @return a set of data access objects
-protected final DatabaseFacade getDatabaseFacade() {
+*/
-return (DatabaseFacade) getServletContext().getAttribute(DatabaseFacade.SC_ATTR_NAME);
+private DataAccessObjects createDataAccessObjects(Connection connection) throws SQLException {
-}
+final var df = (DatabaseFacade) getServletContext().getAttribute(DatabaseFacade.SC_ATTR_NAME);
+switch (df.getSQLDialect()) {
-private ResponseType invokeMapping(Method method, HttpServletRequest req, HttpServletResponse resp) throws IOException {
+case Postgres:
+return new PGDataAccessObjects(connection);
+default:
+throw new AssertionError("Non-exhaustive switch - this is a bug.");
+}
+}
+private ResponseType invokeMapping(Method method, HttpServletRequest req, HttpServletResponse resp, DataAccessObjects dao) throws IOException {
 try {
 LOG.trace("invoke {}#{}", method.getDeclaringClass().getName(), method.getName());
-return (ResponseType) method.invoke(this, req, resp);
+return (ResponseType) method.invoke(this, req, resp, dao);
 } catch (ReflectiveOperationException | ClassCastException ex) {
-LOG.error(String.format("invocation of method %s failed", method.getName()), ex);
+LOG.error("invocation of method {} failed: {}", method.getName(), ex.getMessage());
+LOG.debug("Details: ", ex);
 resp.sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
 return ResponseType.NONE;
 }
 }
 );
 continue;
 }
 Class<?>[] params = method.getParameterTypes();
-if (params.length == 2
+if (params.length == 3
 && HttpServletRequest.class.isAssignableFrom(params[0])
-&& HttpServletResponse.class.isAssignableFrom(params[1])) {
+&& HttpServletResponse.class.isAssignableFrom(params[1])
+&& DataAccessObjects.class.isAssignableFrom(params[2])) {
 final String requestPath = "/" + mapping.get().requestPath();
 if (mappings.computeIfAbsent(mapping.get().method(), k -> new HashMap<>()).
 putIfAbsent(requestPath,
-(req, resp) -> invokeMapping(method, req, resp)) != null) {
+(req, resp, dao) -> invokeMapping(method, req, resp, dao)) != null) {
 LOG.warn("{} {} has multiple mappings",
 mapping.get().method(),
 mapping.get().requestPath()
 );
 }
 default:
 throw new AssertionError("ResponseType switch is not exhaustive - this is a bug!");
 }
 }
-private void doProcess(HttpMethod method, HttpServletRequest req, HttpServletResponse resp)
+private void doProcess(HttpMethod method, HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
-throws ServletException, IOException {
 // choose the requested language as session language (if available) or fall back to english, otherwise
 HttpSession session = req.getSession();
 if (session.getAttribute(Constants.SESSION_ATTR_LANGUAGE) == null) {
 Optional<List<String>> availableLanguages = Functions.availableLanguages(getServletContext()).map(Arrays::asList);
 // set some internal request attributes
 req.setAttribute(Constants.REQ_ATTR_PATH, Functions.fullPath(req));
 req.setAttribute(Constants.REQ_ATTR_MODULE_CLASSNAME, this.getClass().getName());
 Optional.ofNullable(moduleInfo).ifPresent((proxy) -> req.setAttribute(Constants.REQ_ATTR_MODULE_INFO, proxy));
+// obtain a connection and create the data access objects
-// call the handler, if available, or send an HTTP 404 error
+final var db = (DatabaseFacade) req.getServletContext().getAttribute(DatabaseFacade.SC_ATTR_NAME);
-Optional<HandlerMethod> mapping = findMapping(method, req);
+try (final var connection = db.getDataSource().getConnection()) {
-if (mapping.isPresent()) {
+final var dao = createDataAccessObjects(connection);
-forwardAsSpecified(mapping.get().apply(req, resp), req, resp);
+// call the handler, if available, or send an HTTP 404 error
-} else {
+final var mapping = findMapping(method, req);
-resp.sendError(HttpServletResponse.SC_NOT_FOUND);
+if (mapping.isPresent()) {
+forwardAsSpecified(mapping.get().apply(req, resp, dao), req, resp);
+} else {
+resp.sendError(HttpServletResponse.SC_NOT_FOUND);
+}
+} catch (SQLException ex) {
+LOG.error("Database exception (Code {}): {}", ex.getErrorCode(), ex.getMessage());
+LOG.debug("Details: ", ex);
+resp.sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR, "Database Error - Code:" + ex.getErrorCode());
 }
 }
 @Override
 protected final void doGet(HttpServletRequest req, HttpServletResponse resp)

Mercurial > hg > LightPIT / file comparison

comparison: src/main/java/de/uapcore/lightpit/AbstractLightPITServlet.java

src/main/java/de/uapcore/lightpit/AbstractLightPITServlet.java