一个的DAO数据访问层的实现

ＤＡＯ数据库操作类实现在配置文件中的工厂化管理

一、搭建 Hibernate 环境

二、创建数据库操作接口和实现类

1、 接口

基类接口（所有接口都继承该接口）：

package fr.itris.glips.dbconn.module.dao;

import java.io.Serializable;

import java.util.*;

import fr.itris.glips.dbconn.util.HibernateUtil;

public interface DAO {

public void save(Object obj);

public void saveOrUpdate(Object obj);

public List<Object[]> listBySql(String sql);

public List listAll();

public List listAll(Class c);

public List list(String hql);

public List list( String hql, Object[] values);

public Class getEntiryClass();

public Object get( Serializable id);

public Object load( Serializable id);

public Object get(Class c, Serializable id);

public Object load(Class c,Serializable id);

}

实体类接口：

package fr.itris.glips.dbconn.module.dao;

public interface StationDAO extends DAO{

}

2、 实现类：

基类抽象实现类（所有实现类都继承该类）：

package fr.itris.glips.dbconn.module.dao.impl;

import java.io.Serializable;

import java.util.List;

import fr.itris.glips.dbconn.module.dao.DAO;

import fr.itris.glips.dbconn.util.HibernateUtil;

public abstract class AbstractDAO implements DAO{

@Override

public void save(Object entity) {

// TODO Auto-generated method stub

HibernateUtil.save(entity);

}

@Override

public void saveOrUpdate(Object entity) {

// TODO Auto-generated method stub

HibernateUtil.saveOrUpdate(entity);

}

@Override

public List listBySql(String sql) {

// TODO Auto-generated method stub

return HibernateUtil.listBySql(sql);

}

@Override

public java.util.List listAll() {

// TODO Auto-generated method stub

return listAll(getEntiryClass());

}

public java.util.List listAll(Class c) {

// TODO Auto-generated method stub

return HibernateUtil.listAll(c);

}

@Override

public List list(String hql) {

// TODO Auto-generated method stub

return HibernateUtil.list(hql);

};

@Override

public List list(String hql, Object[] values) {

// TODO Auto-generated method stub

return HibernateUtil.list(hql,values);

}

public Object get( Serializable id){

return get(getEntiryClass(), id);

}

public Object load( Serializable id){

return load(getEntiryClass(), id);

}

public Object get(Class c, Serializable id){

return HibernateUtil.get(c, id);

}

public Object load(Class c,Serializable id){

return HibernateUtil.load(c, id);

}

abstract public Class getEntiryClass();

}

基类实现类：

package fr.itris.glips.dbconn.module.dao.impl;

import java.io.Serializable;

import java.util.List;

import fr.itris.glips.dbconn.module.dao.DAO;

import fr.itris.glips.dbconn.util.*;

public class BaseDAO extends AbstractDAO{

@Override

public Class getEntiryClass() {

// TODO Auto-generated method stub

return null;

}

实体类实现类：

package fr.itris.glips.dbconn.module.dao.impl;

import fr.itris.glips.dbconn.module.bean.SVGConfigure;

import fr.itris.glips.dbconn.module.bean.SVGElement;

import fr.itris.glips.dbconn.module.bean.Station;

import fr.itris.glips.dbconn.module.dao.SVGConfigureDAO;

import fr.itris.glips.dbconn.module.dao.SVGElementDAO;

import fr.itris.glips.dbconn.module.dao.StationDAO;

public class StationDAOImpl extends AbstractDAO implements StationDAO{

public Class getEntiryClass(){return Station.class;};

}

三、创建工厂管理 DAO 数据库操作类

1 创建 dao.xml ， key 代表接口， value 代表实现类

<?xml version="1.0" encoding="UTF-8"?>

</section>

</configuration>

2、 创建 ResourcesManager （管理资源文件的类）

package fr.itris.glips.dbconn.resources;

import fr.itris.glips.library.*;

import fr.itris.glips.svgeditor.*;

import org.apache.batik.dom.svg.*;

import org.w3c.dom.*;

import javax.xml.parsers.*;

import java.util.*;

import java.io.*;

import javax.swing.*;

import java.net.*;

import java.awt.*;

import java.util.prefs.*;

/**

* @author ITRIS, Jordi SUC

* The class managing the resources

public class ResourcesManager {

/**

* the map associating the name of a xml document to this document

private final static HashMap<String, Document> cachedXMLDocuments=

new HashMap<String, Document>();

/**

* create a document from tthe given file in the resource files

* @param name the name of the xml file

* @return the document

public static Document getXMLDocument(String name){

Document doc=null;

if(name!=null && ! name.equals("")){

if(cachedXMLDocuments.containsKey(name)){

doc=cachedXMLDocuments.get(name);

}else{

DocumentBuilderFactory docBuildFactory=

DocumentBuilderFactory.newInstance();

String path="";

try{

//parses the XML file

DocumentBuilder docBuild=docBuildFactory.newDocumentBuilder();

path=getPath("xml/"+name);

doc=docBuild.parse(path);

}catch (Exception ex){ex.printStackTrace();}

if(doc!=null){

cachedXMLDocuments.put(name, doc);

}

return doc;

}

public static String getPath(String resource){

String path="";

//System.out.println("resource="+resource);

try{

path=ResourcesManager.class.getResource(resource).toExternalForm();

}catch (Exception ex){

ex.printStackTrace();

path="";

}

//System.out.println("path="+path);

return path;

}

3、 创建 DAOConfig 类（解析 dao.xml 文件的类）

package fr.itris.glips.dbconn.resources;

import java.util.Enumeration;

import java.util.HashMap;

import java.util.Properties;

import org.apache.log4j.Logger;

import org.w3c.dom.Document;

import org.w3c.dom.Element;

import org.w3c.dom.Node;

import fr.itris.glips.dbconn.util.*;

import fr.itris.glips.svgeditor.NodeIterator;

public class DAOConfig {

private static final String DAO_CONFIG_FILE="dao.xml";

private static final String DAO_CONFIG_SECTION="DAO";

public static synchronized HashMap load(){

Document doc=ResourcesManager.getXMLDocument(DAO_CONFIG_FILE);

Element root=doc.getDocumentElement();

HashMap<Class,Class> map=new HashMap<Class,Class> ();

if(root!=null){

Node current=null;

for(current=root.getFirstChild(); current!=null; current=current.getNextSibling()){

String attr_name;

if(current!=null && current instanceof Element){

//System.out.println(current.getNodeName());

if(current.getNodeName()!=null &&current.getNodeName().equals("section")){

attr_name=((Element)current).getAttribute("name");

Node current2;

if(attr_name!=null && attr_name.equals(DAO_CONFIG_SECTION)){

for(NodeIterator it2=new NodeIterator(current); it2.hasNext();){

current2=it2.next();

if(current2!=null && current2 instanceof Element){

if(current2.getNodeName()!=null&&current2.getNodeName().equals("entry")){

String daoIface=((Element)current2).getAttribute("key");

//System.out.println("daoIface=="+daoIface);

String daoImpl=((Element)current2).getAttribute("value");

try{

Class iface=ClassToolKit.loadClass(daoIface);

Class impl=ClassToolKit.loadClass(daoImpl);

map.put(iface, impl);

}catch(ClassNotFoundException e){

e.printStackTrace();

}

return map;

}

public static void main(String[] args){

load();

}

4、 创建 DAO 工厂类

package fr.itris.glips.dbconn.factory;

import java.util.*;

import fr.itris.glips.dbconn.exception.DataAccessException;

import fr.itris.glips.dbconn.module.dao.*;

import fr.itris.glips.dbconn.module.dao.impl.BaseDAO;

import fr.itris.glips.dbconn.resources.DAOConfig;

public class DaoFactory {

private static HashMap<Class,Class> daoClassMap =null;

static Map<String,DAO> daoMap=new HashMap<String,DAO>();

static {

initial();

}

public static synchronized void initial(){

if(null==daoClassMap){

daoClassMap=DAOConfig.load();

}

System.out.println("daoMap.size="+daoClassMap.size());

}

/**

* 获取 DAO 数据库操作类

* @param daoInterface DAO 接口

* @return 实现类

public static DAO getDAO(Class daoInterface){

DAO dao=daoMap.get(daoInterface.getName());

if(dao==null){

try {

Class daoCl=getDAOClass(daoInterface);

dao=(DAO) daoCl.newInstance();

daoMap.put(daoInterface.getName(), dao);

} catch ( Exception e) {

// TODO Auto-generated catch block

e.printStackTrace();

return null;

}

return dao;

}

public static Class getDAOClass(Class daoInterface) {

Class dao=daoClassMap.get(daoInterface);

if(null==dao){

System.out.println("No Implementation found of DAO interface=?"+daoInterface.getName());

}

return dao;

}

public static void main(String[] args){

System.out.println("getClass="+DaoFactory.getDAO( DAO.class));

String sql="select name,aliasname from svgconfigure";

DAO dao=new BaseDAO();

List list=dao.listBySql(sql);

for(Object arr:list){

//System.out.println(arr[0]+","+arr[1]);

}

四、辅助类

1 、工具类

HibernateUtil 类（ Hibernate 数据库操作类用到得工具类）

package fr.itris.glips.dbconn.util;

import java.io.Serializable;

import java.lang.reflect.InvocationTargetException;

import java.lang.reflect.Type;

import java.util.Collection;

import java.util.Iterator;

import java.util.List;

import org.apache.commons.beanutils.BeanUtils;

import org.hibernate.*;

import org.hibernate.cfg.*;

import fr.itris.glips.dbconn.page.PageInfo;

public class HibernateUtil {

private static ThreadLocal<Session> threadLocal=new ThreadLocal<Session>();

private static SessionFactory sessionFactory=null;

static {

initial();

}

public static void initial(){

if(sessionFactory==null){

try{

sessionFactory=new Configuration().configure().buildSessionFactory();

/*Configuration cfg=new Configuration()

.addClass(events.Event.class)

.setProperty("hibernate.dialect","org.hibernate.dialect.MySQLInnoDBDialect")

.setProperty("hibernate.connection.datasource","java:com/env/jdbc/sample")

.setProperty("hibernate.order_update","true");

sessionFactory=cfg.buildSessionFactory();*/

}catch(Throwable ex)

{

ex.printStackTrace();

}

public static SessionFactory getSessionFactory(){

return sessionFactory;

}

public static Session getSession(){

//String f="sd/df";

return sessionFactory.openSession();

}

public static Session getCurrentSession(){

Session s=threadLocal.get();

if(s==null ){

s=sessionFactory.openSession();

threadLocal.set(s);

}

return s;

}

public static void closeCurrentSession(){

Session s=threadLocal.get();

if(s!=null){

s.close();

//s=null;

threadLocal.set(null);

}

//----------- 保存 --------

/**

* save 后数据进入一级缓存，不会进入二级缓存

* @param entity

public static synchronized void save(Object entity){

Session session=getCurrentSession();

//Transaction tran=session.beginTransaction();

session.save(entity);

//tran.commit();

}

public static synchronized void saveOrUpdate(Object entity){

Session session=getCurrentSession();

//Transaction tran=session.beginTransaction();

session.saveOrUpdate (entity);

// tran.commit();

}

public void saveOrUpdateAll(final Collection entities){

Session session=getCurrentSession();

for (Iterator it = entities.iterator(); it.hasNext();) {

session.saveOrUpdate(it.next());

}

public void persist( final Object entity) {

Session session=getCurrentSession();

session.persist( entity);

}

public Object merge(final Object entity) {

Session session=getCurrentSession();

return session.merge( entity);

}

//---------------- 修改 --------

public void update(final Object entity ) {

Session session=getCurrentSession();

session.update(entity);

}

/**

* @param hql 也可用于删除，如： sql="delete TUser"

* @return

public static int executeUpdate(String hql){

Session session=getCurrentSession();

//Transaction tran=session.beginTransaction();

Query query=session.createQuery(hql);

int n= query.executeUpdate();

//tran.commit();

return n;

}

public static void delete(Object obj){

Session session=getCurrentSession();

//Transaction tran=session.beginTransaction();

session.delete(obj);

//tran.commit();

}

/**

* @param sql 例如： sql="from TUser"

public static void delete(String hql){

Session session=getCurrentSession();

//Transaction tran=session.beginTransaction();

session.delete(hql);

//tran.commit();

}

public void deleteAll(final Collection entities){

Session session=getCurrentSession();

for (Iterator it = entities.iterator(); it.hasNext();) {

session.delete(it.next());

}

public static void deleteById(Class cl,Serializable id){

Object obj=load(cl,id);

delete(obj);

}

public static int deleteAsScroll(String hql){

Session session=getCurrentSession();

Query query=session.createQuery(hql);

ScrollableResults scRes=query.scroll();

int i=0;

//Transaction tran=session.beginTransaction();

while(scRes.next()){

session.delete(scRes.get(i++));

}

//tran.commit();

return i;

}

//------------- 查询

/**

* 内部缓存和二级缓存查找

* 可返回代理类实例

* @param cl

* @param serializable

* @return

public static Object load(Class cl,Serializable serializable){

Session session=getCurrentSession();

return session.load(cl, serializable);

}

/**

* 内部缓存查找

* 返回实体类

* @param cl

* @param serializable

* @return

public static Object get(Class cl,Serializable serializable){

Session session=getCurrentSession();

return session.get(cl, serializable);

}

/**

* 一次取出所有数据

* 如果 hibernate.cache.use_query_cache 为 FALSE （系统默认），则不会利用缓存

* 否则，如果满足（ 1 、完全相同的 SQL 重复执行， 2 、两次查询期间，对应的表没有发生过改变），利用缓存， key 为 sql 语句

* @param sql

* @return

public static List list(String hql){

Session session=getCurrentSession();

Query query=session.createQuery(hql);

// 设置二级缓存

query.setCacheable(true);

return query.list();

}

/**

* Execute an HQL query, binding one value to a "?" parameter in the query string.

* @param queryString

* @param values

* @return

public static List list(final String queryString, final Object[] values){

Session session=getCurrentSession();

Query queryObject = session.createQuery(queryString);

if (values != null) {

for (int i = 0; i < values.length; i++) {

queryObject.setParameter(i, values[i]);

}

return queryObject.list();

}

/**

* 一次取出一条数据

* *iterate 可充分利用缓存（ key 为主键 Id ），但是如果缓存中查询不到，会出现 N+1 次查询 **

* * 首先执行一条 Select SQL 以获得所有符合条件的数据 id( 先在缓存中查找，如果查找不到就到数据库中查找 ) ，

* 随即， iterate 方法首先在本地缓存中根据 id 查找对应的实体对象是否存在（类似 Session.load() 方法），

* 如果缓存已经存在对应的数据，则直接以此数据对象作为查询结果，

* 如果没找到，再执行相应的 Select 语句获得对应的库表记录

* */

public static Iterator iterate(String sql){

Session session=getCurrentSession();

Query query=session.createQuery(sql);

// 设置二级缓存

query.setCacheable(true);

return query.iterate();

}

public static List listAll(Class c){

Session session=getCurrentSession();

Criteria criteria=session.createCriteria(c);

// 设置二级缓存

criteria.setCacheable(true);

return criteria.list();

}

/**

* 基于游标的数据遍历

* @param sql

* @return

public static ScrollableResults scroll(String hql){

Session session=getCurrentSession();

Query query=session.createQuery(hql);

return query.scroll();

}

/**

* @param sql

* @return

public static List listBySql (String sql){

Session session=getCurrentSession();

SQLQuery query=session.createSQLQuery(sql );

// 设置二级缓存

//query.setCacheable(true);

return query.list();

}

public static PageInfo pageQuery(Class c,PageInfo page){

Session session=getCurrentSession();

Criteria criteria=session.createCriteria(c);

// 设置二级缓存

criteria.setCacheable(true);

// 总数

page.setTotalRows(criteria.list().size());

int startIndex=(page.getPageNo()-1)*page.getPageSize();

criteria.setFirstResult(startIndex);

criteria.setMaxResults(page.getPageSize());

page.setPageContent(criteria.list());

return page;

}

public static PageInfo pageQuery(String hql,PageInfo page){

Session session=getCurrentSession();

Query query=session.createQuery(hql);

// 设置二级缓存

query.setCacheable(true);

page.setTotalRows(query.list().size());

int startIndex=(page.getPageNo()-1)*page.getPageSize();

query.setFirstResult(startIndex);

query.setMaxResults(page.getPageSize());

page.setPageContent(query.list());

return page;

}

public static void main(String[] args){

System.out.println("session=="+HibernateUtil.getSession());

}

ClassToolKit 类（根据类名生成类的类）：

package fr.itris.glips.dbconn.util;

public class ClassToolKit{

public static Class loadClass(String className)throws ClassNotFoundException{

Class cls=null;

try{

cls=Thread.currentThread().getContextClassLoader().loadClass(className);

}catch(Exception e){

e.printStackTrace();

}

if(cls==null){

cls=Class.forName(className);

}

return cls;

}

3、 异常类

package fr.itris.glips.dbconn.exception;

public class DAOException extends RuntimeException{

private Throwable throwable;

public DAOException(String errorMassage){

super(errorMassage);

}

public DAOException(Throwable throwable){

this.throwable=throwable;

}

public DAOException(String errorMassage,Throwable throwable){

super(errorMassage);

this.throwable=throwable;

}

@Override

public void printStackTrace() {

if(throwable!=null){

System.err.println("A dao error has occured:");

throwable.printStackTrace();

}

类图：

一个的DAO数据访问层的实现

猜你喜欢