Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /* Copyright 2013 David Wolverton
   * 
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   * 
   *     http://www.apache.org/licenses/LICENSE-2.0
   * 
   * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
 package com.googlecode.genericdao.dao.hibernate.original;
 
 import java.util.List;
 
 

This is an implementation of GeneralDAO that delegates to other DAOs depending on what entity class is being processed.

Set the specificDAOs Map in order to configure which DAO will be used for which entity class. If the map contains no entry for a given class, the generalDAO is used.

For example to dispatch operation on com.myproject.model.Customer to a DAO called customerDAO, set the map like this. (Of course tools like Spring can be used to do this configuration more elequently.)

 Map<String,Object> specificDAOs = new HashMap<String,Object>();
 specificDAOs.put("com.myproject.model.Customer", customerDAO);
 
 DAODispatcher dispatcher = new DAODispatcher();
 dispatcher.setSpecificDAOs(specificDAOs);
 

Author(s):
dwolverton
 
 @SuppressWarnings("unchecked")
 public class DAODispatcher extends BaseDAODispatcher implements GeneralDAO {
 
 	protected GeneralDAO generalDAO;

GeneralDAO has default implementations for the standard DAO methods. Which model class it uses is specified when calling the particular method.
 
 	public void setGeneralDAO(GeneralDAO generalDAO) {
 		this. = generalDAO;
 	}
 	
 	public void create(Object object) {
 		Object specificDAO = getSpecificDAO(object.getClass().getName());
 		if (specificDAO != null) {
 			if (specificDAO instanceof GenericDAO) {
 				((GenericDAOspecificDAO).create(object);
 			} else {
 				callMethod(specificDAO"create"object);
 			}
 		} else {
 			.create(object);
 		}
 	}
 
 	public boolean createOrUpdate(Object object) {
 		Object specificDAO = getSpecificDAO(object.getClass().getName());
 		if (specificDAO != null) {
 			if (specificDAO instanceof GenericDAO) {
 				return ((GenericDAOspecificDAO).createOrUpdate(object);
 			} else {
 				return (BooleancallMethod(specificDAO"createOrUpdate"object);
 			}
 		} else {
 			return .createOrUpdate(object);
 		}
 	}
 
 	public boolean deleteById(Class<?> klassSerializable id) {
 		Object specificDAO = getSpecificDAO(klass.getName());
 		if (specificDAO != null) {
 			if (specificDAO instanceof GenericDAO) {
 				return ((GenericDAOspecificDAO).deleteById(id);
 			} else {
 				return (BooleancallMethod(specificDAO"deleteById"id);
 			}
 		} else {
			return .deleteById(klassid);
		}
	}
	public boolean deleteEntity(Object object) {
		Object specificDAO = getSpecificDAO(object.getClass().getName());
		if (specificDAO != null) {
			if (specificDAO instanceof GenericDAO) {
				return ((GenericDAOspecificDAO).deleteEntity(object);
else {
				return (BooleancallMethod(specificDAO"deleteEntity"object);
			}
else {
			return .deleteEntity(object);
		}
	}
	public <T> T fetch(Class<T> klassSerializable id) {
		Object specificDAO = getSpecificDAO(klass.getName());
		if (specificDAO != null) {
			if (specificDAO instanceof GenericDAO) {
				return (T) ((GenericDAOspecificDAO).fetch(id);
else {
				return (T) callMethod(specificDAO"fetch"id);
			}
else {
			return .fetch(klassid);
		}
	}
	public <T> List<T> fetchAll(Class<T> klass) {
		Object specificDAO = getSpecificDAO(klass.getName());
		if (specificDAO != null) {
			if (specificDAO instanceof GenericDAO) {
				return ((GenericDAOspecificDAO).fetchAll();
else {
				return (List<T>) callMethod(specificDAO"fetchAll");
			}
else {
			return .fetchAll(klass);
		}
	}

Deprecated:
use flush(Class<?>)
	public void flush() {
				"The flush() method cannot be used with DAODispatcher because it could does not include a Class type to dispatch to. Use flush(Class<?>).");
	}
	public void flush(Class<?> klass) {
		Object specificDAO = getSpecificDAO(klass.getName());
		if (specificDAO != null) {
			if (specificDAO instanceof GenericDAO) {
				((GenericDAOspecificDAO).flush();
else {
				callMethod(specificDAO"flush");
			}
else {
		}
	}
	public boolean isConnected(Object object) {
		Object specificDAO = getSpecificDAO(object.getClass().getName());
		if (specificDAO != null) {
			if (specificDAO instanceof GenericDAO) {
				return ((GenericDAOspecificDAO).isConnected(object);
else {
				return (BooleancallMethod(specificDAO"isConnected"object);
			}
else {
			return .isConnected(object);
		}
	}
	public void refresh(Object object) {
		Object specificDAO = getSpecificDAO(object.getClass().getName());
		if (specificDAO != null) {
			if (specificDAO instanceof GenericDAO) {
				((GenericDAOspecificDAO).refresh(object);
else {
				callMethod(specificDAO"refresh"object);
			}
else {
		}
	}
	public List search(ISearch search) {
		Object specificDAO = getSpecificDAO(search.getSearchClass().getName());
		if (specificDAO != null) {
			if (specificDAO instanceof GenericDAO) {
				return ((GenericDAOspecificDAO).searchGeneric(search);
else {
				try {
					return (ListcallMethod(specificDAO"searchGeneric"search);
catch (DAODispatcherException ex) {
					if (ex.getCause() instanceof NoSuchMethodException) {
						return (ListcallMethod(specificDAO"search"search);
else {
						throw ex;
					}
				}
			}
else {
			return .search(search);
		}
	}
	public SearchResult searchAndCount(ISearch search) {
		Object specificDAO = getSpecificDAO(search.getSearchClass().getName());
		if (specificDAO != null) {
			if (specificDAO instanceof GenericDAO) {
				return ((GenericDAOspecificDAO).searchAndCount(search);
else {
				return (SearchResultcallMethod(specificDAO,
						"searchAndCount"search);
			}
else {
			return .searchAndCount(search);
		}
	}
	public int count(ISearch search) {
		Object specificDAO = getSpecificDAO(search.getSearchClass().getName());
		if (specificDAO != null) {
			if (specificDAO instanceof GenericDAO) {
				return ((GenericDAOspecificDAO).count(search);
else {
				return (IntegercallMethod(specificDAO"count"search);
			}
else {
			return .count(search);
		}
	}
		Object specificDAO = getSpecificDAO(search.getSearchClass().getName());
		if (specificDAO != null) {
			if (specificDAO instanceof GenericDAO) {
				return ((GenericDAOspecificDAO).searchUnique(search);
else {
				return callMethod(specificDAO"searchUnique"search);
			}
else {
			return .searchUnique(search);
		}
	}
	public void update(Object object) {
		Object specificDAO = getSpecificDAO(object.getClass().getName());
		if (specificDAO != null) {
			if (specificDAO instanceof GenericDAO) {
				((GenericDAOspecificDAO).update(object);
else {
				callMethod(specificDAO"update"object);
			}
else {
		}
	}
	public Filter getFilterFromExample(Object example) {
		Object specificDAO = getSpecificDAO(example.getClass().getName());
		if (specificDAO != null) {
			if (specificDAO instanceof GenericDAO) {
				return ((GenericDAOspecificDAO).getFilterFromExample(example);
else {
				return (FiltercallMethod(specificDAO"getFilterFromExample"example);
			}
else {
		}
	}
	public Filter getFilterFromExample(Object exampleExampleOptions options) {
		Object specificDAO = getSpecificDAO(example.getClass().getName());
		if (specificDAO != null) {
			if (specificDAO instanceof GenericDAO) {
				return ((GenericDAOspecificDAO).getFilterFromExample(exampleoptions);
else {
				return (FiltercallMethod(specificDAO"getFilterFromExample"exampleoptions);
			}
else {
			return .getFilterFromExample(exampleoptions);
		}
	}
New to GrepCode? Check out our FAQ X