/Users/detro/workspace-nb/JAEBI/src/java/org/jaebi/server/service/BackEndHandlerImpl.java

Vai alla documentazione di questo file.
00001 /*
00002  * BackEndHandlerImpl.java
00003  *
00004  * Created on June 5, 2005, 8:12 PM
00005  * Created by Detro - 566/2145
00006  */
00007 
00008 package org.jaebi.server.service;
00009 
00010 import java.io.FileInputStream;
00011 import java.io.IOException;
00012 import java.sql.Connection;
00013 import java.sql.Driver;
00014 import java.sql.DriverManager;
00015 import java.sql.ResultSet;
00016 import java.sql.SQLException;
00017 import java.sql.Statement;
00018 import java.util.ArrayList;
00019 import java.util.HashMap;
00020 import java.util.Iterator;
00021 import java.util.Properties;
00022 import java.util.Set;
00023 
00024 import org.jaebi.server.service.exception.BackEndHandlerGenericException;
00025 import org.jaebi.server.service.exception.BackEndHandlerInitException;
00026 import org.jaebi.server.service.exception.BackEndHandlerSQLCreationException;
00027 
00039 public class BackEndHandlerImpl implements BackEndHandler {
00041     private final String DSN;
00043     private final String username;
00045     private final String password;
00050     private final String JDBCDriverName;
00052     private static String defaultPropertyFilePath = 
00053             "/Users/detro/workspace-nb/L2-Project-JAEBI/JAEBI/BackEndHandlerImpl.properties";
00055     private final String loadedPropertyFilePath;
00056     private static final String exceptionPrefix = "[BackEndHandlerImpl Exception]: ";
00058     private final Class driverClass;
00060     private final Connection DBConnection;
00061         
00070     public BackEndHandlerImpl() throws BackEndHandlerInitException {
00071         this( defaultPropertyFilePath );
00072     }
00073     
00082     public BackEndHandlerImpl(String propertyFilePath) throws BackEndHandlerInitException {
00083         // Load the Property File
00084         Properties config = new Properties();
00085 
00086         try {
00087             FileInputStream configStream = new FileInputStream(propertyFilePath);
00088             config.load(configStream);
00089             configStream.close();
00090         } catch (IOException ec) {
00091             throw new BackEndHandlerInitException( exceptionPrefix + ec );
00092         }
00093         
00094         DSN = config.getProperty("DSN");
00095         username = config.getProperty("username");
00096         password = config.getProperty("password");
00097         JDBCDriverName = config.getProperty("JDBCDriverName");
00098         loadedPropertyFilePath = propertyFilePath;
00099 
00100         // Driver Registration
00101         try {
00102             driverClass = Class.forName(JDBCDriverName);
00103             DriverManager.registerDriver((Driver)driverClass.newInstance());
00104             DBConnection = DriverManager.getConnection(
00105                             DSN, username, password);
00106         } catch (SQLException sqle) {
00107             throw new BackEndHandlerInitException( exceptionPrefix + sqle );
00108         } catch ( ClassNotFoundException cnfe ) {
00109             throw new BackEndHandlerInitException( exceptionPrefix + cnfe );
00110         } catch ( IllegalAccessException iae ) {
00111             throw new BackEndHandlerInitException( exceptionPrefix + iae );
00112         } catch ( InstantiationException ie ) {
00113             throw new BackEndHandlerInitException( exceptionPrefix + ie );
00114         }
00115 
00116     }
00117     
00126     private ResultSet getData(String sqlQuery) throws BackEndHandlerGenericException {
00127         Statement stat = null;
00128         ResultSet rset = null;
00129 
00130         /* Query Execution */
00131         try {
00132             stat = DBConnection.createStatement();
00133             rset = stat.executeQuery(sqlQuery);
00134         } catch (SQLException sqle) {
00135             throw new BackEndHandlerGenericException( exceptionPrefix + sqle );
00136         }
00137         return rset;
00138     }
00139     
00148     private int execute(String sqlQuery) throws BackEndHandlerGenericException {
00149         Statement stat = null;
00150         int result;
00151         
00152         /* Query Execution */
00153         try {
00154             stat = DBConnection.createStatement();
00155             result = stat.executeUpdate(sqlQuery);
00156         } catch (SQLException sqle) {
00157             throw new BackEndHandlerGenericException( exceptionPrefix + sqle );
00158         }
00159         return result;
00160     }
00161     
00173     public ResultSet select(String tableName) 
00174         throws BackEndHandlerGenericException, BackEndHandlerSQLCreationException {
00175         
00176         return select( tableName, null, null );
00177     }
00178     
00196     public ResultSet select(String tableName, ArrayList columnsName) 
00197         throws BackEndHandlerGenericException, BackEndHandlerSQLCreationException {
00198         
00199         return select( tableName, columnsName, null );
00200     }
00201     
00224     public ResultSet select(String tableName, ArrayList columnsName, HashMap whereValues) 
00225         throws BackEndHandlerGenericException, BackEndHandlerSQLCreationException {
00226         
00227         if ( columnsName != null && columnsName.size() < 1 ) {
00228             throw new BackEndHandlerSQLCreationException( exceptionPrefix + 
00229                     "SELECT Creation Exception - No \"//Columns/Column/Name\" founded\n");
00230         } else {
00231             StringBuffer query = new StringBuffer();
00232             Iterator colIter;
00233             StringBuffer whereConditions = new StringBuffer();
00234             Set colSet = null;
00235             Iterator colSetIter = null;
00236             String currColumn;
00237             
00238             query.append(" SELECT ");
00239             
00240             if ( columnsName == null ) {
00241                 query.append(" * ");
00242             } else {
00243                 colIter = columnsName.iterator();
00244                 
00245                 query.append( (String)colIter.next() );
00246 
00247                 while ( colIter.hasNext() ) {
00248                     query.append( " , " + (String)colIter.next() );
00249                 }
00250             }
00251             query.append(" FROM ");
00252             query.append(tableName);
00253             
00255             if ( whereValues != null && whereValues.size() > 0  ) {
00256                 // Retrieve Columns Name
00257                 colSet = whereValues.keySet();
00258                 colSetIter = colSet.iterator();
00259 
00260                 // Construct Updates to be done
00261                 currColumn = (String)colSetIter.next();
00262                 whereConditions.append( currColumn + " = " + 
00263                         " '"+(String)whereValues.get(currColumn)+"' " );
00264 
00265                 while ( colSetIter.hasNext() ) {
00266                     currColumn = (String)colSetIter.next();
00267                     whereConditions.append( " AND " + currColumn + " = " + 
00268                             " '"+(String)whereValues.get(currColumn)+"' " );
00269                 }
00270                 
00271                 query.append( " WHERE " );
00272                 query.append( whereConditions );
00273             }
00274             
00275             return getData( query.toString() );
00276         }
00277     }
00278     
00293     public int insert(String tableName, HashMap values) 
00294         throws BackEndHandlerGenericException, BackEndHandlerSQLCreationException {
00295         
00296         if ( values == null || values.size() < 1 ) {
00297             throw new BackEndHandlerSQLCreationException( exceptionPrefix + 
00298                     "INSERT Creation Exception - No \"//Columns/Column/Value\" founded\n");
00299         } else {
00300             StringBuffer query = new StringBuffer();
00301             
00302             StringBuffer columns = new StringBuffer();
00303             StringBuffer colValues = new StringBuffer();
00304             String currColumn = null;
00305             
00306             // Retrieve Columns Name
00307             Set colSet = values.keySet();
00308             Iterator colSetIter = colSet.iterator();
00309                         
00310             // Construct braces with Columns and Values
00311             currColumn = (String)colSetIter.next();
00312             columns.append( " ( " + currColumn );
00313             colValues.append( " ( " + 
00314                     " '"+(String)values.get(currColumn)+"' " );
00315             
00316             while ( colSetIter.hasNext() ) {
00317                 currColumn = (String)colSetIter.next();
00318                 columns.append( ", " + currColumn );
00319                 colValues.append( ", " + 
00320                         " '"+(String)values.get(currColumn)+"' " );
00321             }
00322             
00323             columns.append( " ) " );
00324             colValues.append( " ) " );
00325             
00326             // Construct the final SQL INSERT Statement
00327             query.append(" INSERT INTO ");
00328             query.append( tableName );
00329             query.append( columns );
00330             query.append( " VALUES " );
00331             query.append( colValues );
00332 
00333             return execute( query.toString() );
00334         }
00335     }
00336     
00357     public int update(String tableName, HashMap values)
00358         throws BackEndHandlerGenericException, BackEndHandlerSQLCreationException {
00359         
00360         return update(tableName, values, null);
00361     }
00362     
00387     public int update(String tableName, HashMap values, HashMap whereValues)
00388         throws BackEndHandlerGenericException, BackEndHandlerSQLCreationException {
00389         
00390         if ( values == null || values.size() < 1 ) {
00391             throw new BackEndHandlerSQLCreationException( exceptionPrefix + 
00392                     "UPDATE Creation Exception - No \"//Columns/Column/Value\" founded\n");
00393         } else {
00394             StringBuffer query = new StringBuffer();
00395             
00396             StringBuffer updates = new StringBuffer();
00397             StringBuffer whereConditions = new StringBuffer();
00398             String currColumn = null;
00399             Set colSet = null;
00400             Iterator colSetIter = null;
00401             
00403             // Retrieve Columns Name
00404             colSet = values.keySet();
00405             colSetIter = colSet.iterator();
00406                         
00407             // Construct Updates to be done
00408             currColumn = (String)colSetIter.next();
00409             updates.append( currColumn + " = " + 
00410                     " '"+(String)values.get(currColumn)+"' " );
00411                         
00412             while ( colSetIter.hasNext() ) {
00413                 currColumn = (String)colSetIter.next();
00414                 updates.append( ", " + currColumn + " = " + 
00415                         " '"+(String)values.get(currColumn)+"' " );
00416             }
00417             
00419             if ( whereValues != null && whereValues.size() > 0  ) {
00420                 // Retrieve Columns Name
00421                 colSet = whereValues.keySet();
00422                 colSetIter = colSet.iterator();
00423 
00424                 // Construct Updates to be done
00425                 currColumn = (String)colSetIter.next();
00426                 whereConditions.append( currColumn + " = " + 
00427                         " '"+(String)whereValues.get(currColumn)+"' " );
00428 
00429                 while ( colSetIter.hasNext() ) {
00430                     currColumn = (String)colSetIter.next();
00431                     whereConditions.append( " AND " + currColumn + " = " + 
00432                             " '"+(String)whereValues.get(currColumn)+"' " );
00433                 }
00434             }
00435             
00436             // Construct the final SQL INSERT Statement
00437             query.append(" UPDATE ");
00438             query.append( tableName );
00439             query.append(" SET ");
00440             query.append( updates );
00441             if ( whereConditions.length() > 3 ) {
00442                 query.append( " WHERE " );
00443                 query.append( whereConditions );
00444             }
00445 
00446                 System.out.println("Query. " + query.toString() );
00447             return execute( query.toString() );
00448         }
00449     }
00450     
00466     public int delete( String tableName ) 
00467         throws BackEndHandlerGenericException {
00468         
00469         return delete( tableName,  null );
00470     }
00471     
00491     public int delete(String tableName, HashMap whereValues)
00492         throws BackEndHandlerGenericException {
00493         
00494         StringBuffer query = new StringBuffer();
00495 
00496         StringBuffer whereConditions = new StringBuffer();
00497         String currColumn = null;
00498         Set colSet = null;
00499         Iterator colSetIter = null;
00500 
00502         if ( whereValues != null && whereValues.size() > 0  ) {
00503             // Retrieve Columns Name
00504             colSet = whereValues.keySet();
00505             colSetIter = colSet.iterator();
00506 
00507             // Construct Updates to be done
00508             currColumn = (String)colSetIter.next();
00509             whereConditions.append( currColumn + " = " + 
00510                     " '"+(String)whereValues.get(currColumn)+"' " );
00511 
00512             while ( colSetIter.hasNext() ) {
00513                 currColumn = (String)colSetIter.next();
00514                 whereConditions.append( " AND " + currColumn + " = " + 
00515                         " '"+(String)whereValues.get(currColumn)+"' " );
00516             }
00517         }
00518 
00519         // Construct the final SQL INSERT Statement
00520         query.append(" DELETE FROM ");
00521         query.append( tableName );
00522         if ( whereConditions.length() > 3 ) {
00523             query.append( " WHERE " );
00524             query.append( whereConditions );
00525         }
00526 
00527         return execute( query.toString() );
00528     }
00529     
00530     /*
00531     public Object sql(String sqlQueryString) {
00532         
00533     }
00534     */
00535     
00536     public String toString() {
00537         StringBuffer result = new StringBuffer("BackEndHandlerImpl: DataBase Wrapper\n");
00538         result.append( "- DSN: " + DSN + "\n");
00539         result.append( "- username: " + username + "\n");
00540         result.append( "- password: " + ";-)" + "\n");
00541         result.append( "- JDBCDriverName: " + JDBCDriverName + "\n");
00542         result.append( "- Loaded Property file path: " + loadedPropertyFilePath + "\n");
00543         
00544         return result.toString();
00545     }
00546 }

Generato il Mon Jun 27 22:50:37 2005 per JAEBI - JAva Enterprice BackEnd Interfacement da  doxygen 1.4.3