001: /*
002: * Created on 19/05/2004
003: *
004: * Swing Components - visit http://sf.net/projects/gfd
005: *
006: * Copyright (C) 2004 Igor Regis da Silva Simões
007: *
008: * This program is free software; you can redistribute it and/or
009: * modify it under the terms of the GNU General Public License
010: * as published by the Free Software Foundation; either version 2
011: * of the License, or (at your option) any later version.
012: *
013: * This program is distributed in the hope that it will be useful,
014: * but WITHOUT ANY WARRANTY; without even the implied warranty of
015: * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
016: * GNU General Public License for more details.
017: *
018: * You should have received a copy of the GNU General Public License
019: * along with this program; if not, write to the Free Software
020: * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
021: *
022: */
023:
024: package br.com.gfpshare.db;
025:
026: import java.math.BigDecimal;
027: import java.sql.Date;
028: import java.sql.ResultSet;
029: import java.sql.SQLException;
030: import java.sql.Timestamp;
031: import java.util.ArrayList;
032: import java.util.EventListener;
033: import java.util.HashMap;
034: import java.util.Map;
035:
036: import javax.swing.event.EventListenerList;
037:
038: import br.com.gfpshare.plugin.core.DynamicClassLoader;
039:
040: /**
041: * Definição abstrata de um controller que intermedia a conexão com um banco de dados e os objetos de negócio
042: * @author Igor Regis da Silva Simoes
043: */
044: public abstract class AbstractDAO<E extends PersistentObject>
045: implements DAO<E> {
046: /**
047: * Indica se esta sendo feita a operação de insersão de dados
048: */
049: private boolean adicionandoNovo = false;
050:
051: /**
052: *
053: * @return Retorna a lista de listeners
054: */
055: protected abstract EventListenerList getListeners();
056:
057: /**
058: * @see br.com.gfpshare.db.DAO#getBy(br.com.gfpshare.db.PersistentObject)
059: */
060: public synchronized E getBy(E argumento) throws SQLException {
061: //resultadoBO should be of type E but ants give me a error so lets use the PersistentObject
062: E resultadoBO = null;
063: ResultSet resultado = null;
064: argumento.setDataBase(DataBaseManager.getDataBaseManager()
065: .getPropriedade(DataBaseManager.NOME_BANCO_DE_DADOS));
066:
067: try {
068: resultado = DataBaseManager.getDataBaseManager()
069: .executarConsulta(argumento.getSelectSQL(),
070: argumento.getParametrosSQL());
071:
072: resultado.first();
073:
074: Map<String, Object> dados = new HashMap<String, Object>();
075:
076: for (int i = 1; i <= resultado.getMetaData()
077: .getColumnCount(); i++) {
078: if (resultado.getObject(i) instanceof Date)
079: dados.put(resultado.getMetaData().getColumnName(i),
080: new java.util.Date(((Date) resultado
081: .getObject(i)).getTime()));
082: else if (resultado.getObject(i) instanceof Timestamp)
083: dados.put(resultado.getMetaData().getColumnName(i),
084: new java.util.Date(((Timestamp) resultado
085: .getObject(i)).getTime()));
086: else if (resultado.getObject(i) instanceof BigDecimal)
087: dados.put(resultado.getMetaData().getColumnName(i),
088: new Double(((BigDecimal) resultado
089: .getObject(i)).doubleValue()));
090: else
091: dados.put(resultado.getMetaData().getColumnName(i),
092: resultado.getObject(i));
093: }
094:
095: try {
096: resultadoBO = (E) argumento.getClass().newInstance();
097: resultadoBO.setDados(dados);
098: } catch (Exception e1) {
099: argumento.setDados(dados);
100: }
101: } catch (SQLException sqle) {
102: throw sqle;
103: } finally {
104: DataBaseManager.getDataBaseManager().fecharConexao(
105: resultado);
106: }
107:
108: if (resultadoBO != null) {
109: fireSelecionando(resultadoBO);
110: return resultadoBO;
111: }
112: fireSelecionando(argumento);
113: return argumento;
114: }
115:
116: /**
117: * @see br.com.gfpshare.db.DAO#filterBy(java.sql.ResultSet, br.com.gfpshare.db.PersistentObject)
118: */
119: public synchronized ResultSet filterBy(ResultSet old, E argumento)
120: throws SQLException {
121: argumento.setDataBase(DataBaseManager.getDataBaseManager()
122: .getPropriedade(DataBaseManager.NOME_BANCO_DE_DADOS));
123:
124: try {
125: if (old != null)
126: DataBaseManager.getDataBaseManager().fecharConexao(old);
127:
128: old = DataBaseManager.getDataBaseManager()
129: .executarConsulta(argumento.getSelectSQL(),
130: argumento.getParametrosSQL());
131:
132: fireFiltrando(argumento);
133:
134: return old;
135: } catch (SQLException sqle) {
136: //TODO Exceção
137: System.out.println(sqle);
138: }
139: return null;
140: }
141:
142: public synchronized ArrayList<E> getAllBy(E argumento)
143: throws SQLException {
144: ResultSet resultado = null;
145: ArrayList<E> retorno = new ArrayList<E>();
146: argumento.setDataBase(DataBaseManager.getDataBaseManager()
147: .getPropriedade(DataBaseManager.NOME_BANCO_DE_DADOS));
148:
149: try {
150: resultado = DataBaseManager.getDataBaseManager()
151: .executarConsulta(argumento.getSelectSQL(),
152: argumento.getParametrosSQL());
153:
154: resultado.beforeFirst();
155:
156: ArrayList<Map<String, Object>> vetorResultado = new ArrayList<Map<String, Object>>();
157:
158: while (resultado.next()) {
159: Map<String, Object> dados = new HashMap<String, Object>();
160: for (int i = 1; i <= resultado.getMetaData()
161: .getColumnCount(); i++) {
162: if (resultado.getObject(i) instanceof Date)
163: dados.put(resultado.getMetaData()
164: .getColumnName(i), new java.util.Date(
165: ((Date) resultado.getObject(i))
166: .getTime()));
167: else if (resultado.getObject(i) instanceof Timestamp)
168: dados.put(resultado.getMetaData()
169: .getColumnName(i), new java.util.Date(
170: ((Timestamp) resultado.getObject(i))
171: .getTime()));
172: else if (resultado.getObject(i) instanceof BigDecimal)
173: dados.put(resultado.getMetaData()
174: .getColumnName(i), new Double(
175: ((BigDecimal) resultado.getObject(i))
176: .doubleValue()));
177: else
178: dados.put(resultado.getMetaData()
179: .getColumnName(i), resultado
180: .getObject(i));
181: }
182: vetorResultado.add(dados);
183: }
184:
185: vetorResultado.trimToSize();
186: for (Map<String, Object> dado : vetorResultado) {
187: E instancia = (E) DynamicClassLoader.getClassLoader()
188: .loadClass(argumento.getClass().getName())
189: .newInstance();
190: instancia.setDados(dado);
191: retorno.add(instancia);
192: }
193: } catch (Exception sqle) {
194: throw new SQLException(sqle.getMessage());
195: } finally {
196: DataBaseManager.getDataBaseManager().fecharConexao(
197: resultado);
198: }
199:
200: fireSelecionando(argumento);
201:
202: return retorno;
203:
204: }
205:
206: /**
207: * @see br.com.gfpshare.db.DAO#getAll(java.sql.ResultSet, br.com.gfpshare.db.PersistentObject)
208: */
209: public synchronized ResultSet getAll(ResultSet old, E type) {
210: try//TODO Retirar try
211: {
212: return filterBy(old, type);
213:
214: } catch (SQLException sqle) {
215: //TODO Exceção
216: System.out.println(sqle);
217: }
218: return null;
219: }
220:
221: /**
222: * @see br.com.gfpshare.db.DAO#adicionarNovo(br.com.gfpshare.db.PersistentObject)
223: */
224: public synchronized boolean adicionarNovo(E novoRegistro)
225: throws SQLException {
226: novoRegistro.validate();
227: novoRegistro.setDataBase(DataBaseManager.getDataBaseManager()
228: .getPropriedade(DataBaseManager.NOME_BANCO_DE_DADOS));
229:
230: int retorno = -1;
231: retorno = DataBaseManager.getDataBaseManager()
232: .executarAtualizacao(novoRegistro.getInsertSQL(),
233: novoRegistro.getParametrosSQL());
234:
235: try {
236: fireAdicionandoNovo(getBy(novoRegistro));
237: } catch (SQLException e) {
238: fireAdicionandoNovo(novoRegistro);
239: }
240:
241: return retorno > 0;
242: }
243:
244: /**
245: * @see br.com.gfpshare.db.DAO#deletar(br.com.gfpshare.db.PersistentObject)
246: */
247: public synchronized boolean deletar(E aSerDeletado)
248: throws SQLException {
249: aSerDeletado.setDataBase(DataBaseManager.getDataBaseManager()
250: .getPropriedade(DataBaseManager.NOME_BANCO_DE_DADOS));
251:
252: int retorno = -1;
253: retorno = DataBaseManager.getDataBaseManager()
254: .executarAtualizacao(aSerDeletado.getDeleteSQL(),
255: aSerDeletado.getParametrosSQL());
256:
257: fireDeletando(aSerDeletado);
258:
259: return retorno > 0;
260: }
261:
262: /**
263: * @see br.com.gfpshare.db.DAO#atualizar(br.com.gfpshare.db.PersistentObject)
264: */
265: public synchronized boolean atualizar(E atualizacao)
266: throws SQLException {
267: atualizacao.validate();
268: atualizacao.setDataBase(DataBaseManager.getDataBaseManager()
269: .getPropriedade(DataBaseManager.NOME_BANCO_DE_DADOS));
270:
271: int retorno = -1;
272: retorno = DataBaseManager.getDataBaseManager()
273: .executarAtualizacao(atualizacao.getUpdateSQL(),
274: atualizacao.getParametrosSQL());
275:
276: fireAtualizando(atualizacao);
277:
278: return retorno > 0;
279: }
280:
281: /**
282: * @see br.com.gfpshare.db.DAO#isAdicionandoNovo()
283: */
284: public boolean isAdicionandoNovo() {
285: return adicionandoNovo;
286: }
287:
288: /**
289: * @see br.com.gfpshare.db.DAO#setAdicionandoNovo(boolean)
290: */
291: public void setAdicionandoNovo(boolean adicionandoNovo) {
292: this .adicionandoNovo = adicionandoNovo;
293: }
294:
295: /**
296: * @see br.com.gfpshare.db.DAO#freeResource(java.sql.ResultSet)
297: */
298: public synchronized void freeResource(ResultSet old)
299: throws SQLException {
300: DataBaseManager.getDataBaseManager().fecharConexao(old);
301: }
302:
303: /**
304: * @param argumento
305: * @param sql
306: * @param incluirWhere
307: * @param incluirOrderBy
308: * @return
309: * @throws SQLException
310: */
311: protected synchronized ResultSet executarSQL(E argumento,
312: String sql, boolean incluirWhere, boolean incluirOrderBy)
313: throws SQLException {
314: argumento.setDataBase(DataBaseManager.getDataBaseManager()
315: .getPropriedade(DataBaseManager.NOME_BANCO_DE_DADOS));
316: if (sql.toLowerCase().startsWith("select"))
317: return DataBaseManager.getDataBaseManager()
318: .executarConsulta(
319: ((AbstractPersistentObject) argumento)
320: .getSQL(sql, incluirWhere,
321: incluirOrderBy),
322: argumento.getParametrosSQL());
323: else
324: DataBaseManager.getDataBaseManager().executarAtualizacao(
325: ((AbstractPersistentObject) argumento).getSQL(sql,
326: incluirWhere, incluirOrderBy),
327: argumento.getParametrosSQL());
328: return null;
329: }
330:
331: /**
332: * Adiciona um listener que será avisado dos eventos deste controller
333: * @param listener ControllerListener
334: */
335: public void addControllerListener(DAOListener listener) {
336: getListeners().add(DAOListener.class, listener);
337: }
338:
339: /**
340: * Remove um listener que seria avisado dos eventos deste controller
341: * @param listener ControllerListener
342: */
343: public void removeControllerListener(DAOListener listener) {
344: getListeners().remove(DAOListener.class, listener);
345: }
346:
347: private void fireAdicionandoNovo(E po) {
348: EventListener[] listenerList = getListeners().getListeners(
349: DAOListener.class);
350:
351: DAOEvent<E> e = new DAOEvent<E>(po);
352:
353: for (int i = 0; i < listenerList.length; i++) {
354: ((DAOListener<E>) listenerList[i]).adicionadoNovo(e);
355: }
356: }
357:
358: private void fireAtualizando(E po) {
359: EventListener[] listenerList = getListeners().getListeners(
360: DAOListener.class);
361:
362: DAOEvent<E> e = new DAOEvent<E>(po);
363:
364: for (int i = 0; i < listenerList.length; i++) {
365: ((DAOListener<E>) listenerList[i]).atualizado(e);
366: }
367: }
368:
369: private void fireDeletando(E po) {
370: EventListener[] listenerList = getListeners().getListeners(
371: DAOListener.class);
372:
373: DAOEvent<E> e = new DAOEvent<E>(po);
374:
375: for (int i = 0; i < listenerList.length; i++) {
376: ((DAOListener<E>) listenerList[i]).deletado(e);
377: }
378: }
379:
380: private void fireFiltrando(E po) {
381: EventListener[] listenerList = getListeners().getListeners(
382: DAOListener.class);
383:
384: DAOEvent<E> e = new DAOEvent<E>(po);
385:
386: for (int i = 0; i < listenerList.length; i++) {
387: ((DAOListener<E>) listenerList[i]).filtrado(e);
388: }
389: }
390:
391: private void fireSelecionando(E po) {
392: EventListener[] listenerList = getListeners().getListeners(
393: DAOListener.class);
394:
395: DAOEvent<E> e = new DAOEvent<E>(po);
396:
397: for (int i = 0; i < listenerList.length; i++) {
398: ((DAOListener<E>) listenerList[i]).selecionado(e);
399: }
400: }
401: }
|