`
BestUpon
  • 浏览: 291417 次
  • 性别: Icon_minigender_1
  • 来自: 兰州
社区版块
存档分类
最新评论

框架底层综合+快速开发+代码重用框架-设计(Dao层)

 
阅读更多

 

二、Dao

Dao层是数据化持久层,以前我们习惯使用JDBC做链接,现在我们使用JPA,结合Spring的优势,使用连接池来配置、以及与数据库的同步!我们使用JAP+Spring,只需要建立数据库即可以,使用所谓的“逆向工程”——老程序员们都这样称呼它,我觉得这样才是真正的面向对象的设计。

1、基础抽象接口DAO,以后让所对象的Dao都来实现这个借口。

对于一个dao层来说,是处理Service传递进来的数据与数据库同步的,所以一般的方法就是CRUD的方法,对于每一种对象来说,都是需要进行增删改查,然而在Model层中,不同的对象经过JPA的映射之后会生成不同的表,所以我们dao层就需要针对不同的对象都有增删改查,所以使用反射式比较适合的选择(这个抽象类中包含了通用的CRUD的方法)。

该类是其他所有Dao的接口,应该具备以下几个通用的操作:

 

1.//增加一个实体对象	
public abstract void add(T paramT);
	2.//删除一个实体
public abstract void delete(Integer paramInteger);
	3.//修改一个对象
public abstract void modify(T paramT);
	4.//查询单个对象(通过Model.id)
public abstract T query(Integer paramInteger);
	5.//分页查询
public abstract ModelSet<T> queryAll(int firstindex, int maxresult, String wherejpql, Object[] queryParams, LinkedHashMap<String, String> orderby);
	6.//Compass全文检索
public abstract List<T> search(String paramString);
	7.//反射获取Class
public abstract Class<T> getModelClass();

 

 //参见如下的代码。

package com.jxs.sys.core.base.dao;

import java.util.LinkedHashMap;
import java.util.List;

import com.jxs.sys.core.base.model.Model;
import com.jxs.sys.core.base.model.ModelSet;
/**
 * 
 * @目的 数据持久层接口	
 * @时间 Apr 24, 2010
 * @作者 BestUpon
 * @邮箱 bestupon@foxmail.com
 *
 * @param <T>
 */

public abstract interface Dao<T extends Model> {
	public abstract void add(T paramT);

	public abstract void delete(Integer paramInteger);

	public abstract void modify(T paramT);

	public abstract T query(Integer paramInteger);

	public abstract ModelSet<T> queryAll(int firstindex, int maxresult, String wherejpql, Object[] queryParams, LinkedHashMap<String, String> orderby);

	public abstract List<T> search(String paramString);

	public abstract Class<T> getModelClass();
}

2、写一个真正的处理数据的Dao层类-DaoOperation

DaoOperation 这个类是真正的处理和数据库同步的类,由于们使用的JPAHibernate实现,所以我们要构建一个实体管理器,EnteryManager

例如:

 

//持久化上下文	
@PersistenceContext
protected EntityManager em;

 使用这个实体管理器去操作所有的实体对象。

 

我们针对public abstract interface Dao<T extends Model>{}这个类中的所有方法,要在DaoOperation 这个类中去真正的操作数据,所以我们要对外公开一下几个方法:

 

1.//删除实体对象
public <T> void delete(Class<T> entityClass, Object entityid);
2.//查询试题对象
public <T> T find(Class<T> entityClass, Object entityId);
3.//持久化实体对象
public void save(Object object);
4.//统计实体对象个数
public <T> int getCount(Class<T> entityClass);
5.//修改更新实体对象
public void update(Object object)
6.//分页+排序查询
public <T> ModelSet<T> getScrollData(Class<T> entityClass, int firstindex, int maxresult, LinkedHashMap<String, String> orderby);
7.//分页+JPQL 查询
public <T> ModelSet<T> getScrollData(Class<T> entityClass, int firstindex, int maxresult, String wherejpql, Object[] queryParams);
8.//单纯分页整体查询
public <T> ModelSet<T> getScrollData(Class<T> entityClass, int firstindex, int maxresult);
9.//无分页,整体查询
public <T> ModelSet<T> getScrollData(Class<T> entityClass);
10.//分页+JPQL+排序查询
public <T> ModelSet<T> getScrollData(Class<T> entityClass, int firstindex, int maxresult, String wherejpql, Object[] queryParams, LinkedHashMap<String, String> orderby);
这样一个底层持久化操作类,实现了所有的同步操作。
11.//清缓存方法
clear();

 

 还有两个属性:

 

//ehCache缓存管理器
	@Resource(name = "ehCache")
	private Cache cache;
	//Compass搜索索引管理器
	@Resource(name = "indexManager")
	private IndexManager indexManager;

 说明:上面有有个ModelSet,这个对象是是查询到的数据的集合,大家想想应该这么设计呢?

 

我是这样设计的:

 

1.//将查询到的结果转换成一个这个对象的List集合,方便前台,操作(例如Struts2标签中的操作,DisplayTag显示数据的需要数据等)
 private List<T> resultlist = new ArrayList<T>();
2.//返回一个总体记录数,分页等需要
private long totalrecord = 0L;
3.//查询判断一些不需要的对象在里面,或者需要的对象在里面,这样过滤一些对象的时候需要
private List<String> includeids = new ArrayList<String>();

 上面的方法都给出了,接下来就需要对其实现了,怎么个实现法呢?——很简单,就是拼JPQL查询字符串。

实现代码,参见如下:

 

package com.jxs.sys.core.base.dao;

import java.beans.Introspector;
import java.beans.PropertyDescriptor;
import java.lang.reflect.Method;
import java.util.LinkedHashMap;

import javax.annotation.Resource;
import javax.persistence.EmbeddedId;
import javax.persistence.Entity;
import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;

import net.sf.ehcache.Cache;

import org.hibernate.ejb.QueryImpl;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;

import com.jxs.sys.core.base.model.ModelSet;
import com.jxs.sys.core.global.cache.ClearCache;
import com.jxs.sys.core.global.config.utils.ConfigHolder;
import com.jxs.sys.core.search.compass.IndexManager;
/**
 * 
 *@TO 数据同步基础类
 *@des  
 *@author BestUpon
 *@date Sep 20, 2010 4:31:20 PM
 *@version since 1.0
 */
@Transactional
public abstract class DaoOperation {
	protected final Logger log = LoggerFactory.getLogger(super.getClass());

	@PersistenceContext
	protected EntityManager em;

	@Resource(name = "ehCache")
	private Cache cache;

	@Resource(name = "indexManager")
	private IndexManager indexManager;

	public void clear() {
		this.em.clear();
	}

	private <T> void del(Class<T> entityClass, Object entityid) {
		this.em.remove(this.em.getReference(entityClass, entityid));
	}

	@Transactional(readOnly = true, propagation = Propagation.NOT_SUPPORTED)
	public <T> void delete(Class<T> entityClass, Object entityid) {
		del(entityClass, entityid);

		if (isIndexable()) {
			this.indexManager.deleteIndex(entityClass, entityid);
		}
		if (isOperationSearchResult()) {
			this.log.info("删除对象,删除搜索缓存");
			ClearCache.clear(this.cache, "search" + entityClass.getName());
		}
	}

	@Transactional(readOnly = true, propagation = Propagation.NOT_SUPPORTED)
	public <T> T find(Class<T> entityClass, Object entityId) {
		return this.em.find(entityClass, entityId);
	}

	public void save(Object object) {
		this.em.persist(object);
		if (isIndexable())
			this.indexManager.createIndex(object);
	}

	@Transactional(readOnly = true, propagation = Propagation.NOT_SUPPORTED)
	public <T> int getCount(Class<T> entityClass) {
		javax.persistence.Query query = this.em.createQuery("select count(" + getCountField(entityClass) + ") from " + getEntityName(entityClass) + " o");

		setQueryCache(query);

		return ((Integer) query.getSingleResult()).intValue();
	}

	public void update(Object object) {
		this.em.merge(object);

		if (isOperationSearchResult()) {
			this.log.info("更新对象,删除搜索缓存");
			ClearCache.clear(this.cache, "search" + object.getClass().getName());
		}
		if (isIndexable())
			this.indexManager.updateIndex(object);
	}

	@Transactional(readOnly = true, propagation = Propagation.NOT_SUPPORTED)
	public <T> ModelSet<T> getScrollData(Class<T> entityClass, int firstindex, int maxresult, LinkedHashMap<String, String> orderby) {
		return getScrollData(entityClass, firstindex, maxresult, null, null, orderby);
	}

	@Transactional(readOnly = true, propagation = Propagation.NOT_SUPPORTED)
	public <T> ModelSet<T> getScrollData(Class<T> entityClass, int firstindex, int maxresult, String wherejpql, Object[] queryParams) {
		return getScrollData(entityClass, firstindex, maxresult, wherejpql, queryParams, null);
	}

	@Transactional(readOnly = true, propagation = Propagation.NOT_SUPPORTED)
	public <T> ModelSet<T> getScrollData(Class<T> entityClass, int firstindex, int maxresult) {
		return getScrollData(entityClass, firstindex, maxresult, null, null, null);
	}

	@Transactional(readOnly = true, propagation = Propagation.NOT_SUPPORTED)
	public <T> ModelSet<T> getScrollData(Class<T> entityClass) {
		return getScrollData(entityClass, -1, -1);
	}

	@Transactional(readOnly = true, propagation = Propagation.NOT_SUPPORTED)
	public <T> ModelSet<T> getScrollData(Class<T> entityClass, int firstindex, int maxresult, String wherejpql, Object[] queryParams, LinkedHashMap<String, String> orderby) {
		return queryData(entityClass, firstindex, maxresult, wherejpql, queryParams, orderby);
	}

	private void setQueryCache(javax.persistence.Query query) {
		if ((!(isCacheable())) || (!(query instanceof QueryImpl)))
			return;
		((QueryImpl) query).getHibernateQuery().setCacheable(true);
	}

	private <T> ModelSet<T> queryData(Class<T> entityClass, int firstindex, int maxresult, String wherejpql, Object[] queryParams, LinkedHashMap<String, String> orderby) {
		ModelSet<T> qr = new ModelSet<T>();
		String entityname = getEntityName(entityClass);
		javax.persistence.Query query = this.em.createQuery("select o from " + entityname + " o " + ((wherejpql == null) ? "" : new StringBuilder("where ").append(wherejpql).toString()) + buildOrderby(orderby));
		setQueryParams(query, queryParams);
		if ((firstindex != -1) && (maxresult != -1)) {
			query.setFirstResult(firstindex).setMaxResults(maxresult);
		}

		setQueryCache(query);
		qr.setResultlist(query.getResultList());
		query = this.em.createQuery("select count(" + getCountField(entityClass) + ") from " + entityname + " o " + ((wherejpql == null) ? "" : new StringBuilder("where ").append(wherejpql).toString()));
		setQueryParams(query, queryParams);

		setQueryCache(query);
		qr.setTotalrecord(((Long) query.getSingleResult()).longValue());
		return qr;
	}

	protected void setQueryParams(javax.persistence.Query query, Object[] queryParams) {
		if ((queryParams != null) && (queryParams.length > 0))
			for (int i = 0; i < queryParams.length; ++i)
				query.setParameter(i + 1, queryParams[i]);
	}

	protected String buildOrderby(LinkedHashMap<String, String> orderby) {
		StringBuffer orderbyql = new StringBuffer("");
		if ((orderby != null) && (orderby.size() > 0)) {
			orderbyql.append(" order by ");
			for (String key : orderby.keySet()) {
				orderbyql.append("o.").append(key).append(" ").append((String) orderby.get(key)).append(",");
			}
			orderbyql.deleteCharAt(orderbyql.length() - 1);
		}
		return orderbyql.toString();
	}

	protected <T> String getEntityName(Class<T> entityClass) {
		String entityname = entityClass.getSimpleName();
		Entity entity = (Entity) entityClass.getAnnotation(Entity.class);
		if ((entity.name() != null) && (!("".equals(entity.name())))) {
			entityname = entity.name();
		}
		return entityname;
	}

	protected <T> String getCountField(Class<T> clazz) {
		String out = "o";
		try {
			PropertyDescriptor[] propertyDescriptors = Introspector.getBeanInfo(clazz).getPropertyDescriptors();
			for (PropertyDescriptor propertydesc : propertyDescriptors) {
				Method method = propertydesc.getReadMethod();
				if ((method != null) && (method.isAnnotationPresent(EmbeddedId.class))) {
					PropertyDescriptor[] ps = Introspector.getBeanInfo(propertydesc.getPropertyType()).getPropertyDescriptors();
					out = "o." + propertydesc.getName() + "." + ((!(ps[1].getName().equals("class"))) ? ps[1].getName() : ps[0].getName());
					break;
				}
			}
		} catch (Exception e) {
			e.printStackTrace();
		}
		return out;
	}

	public static boolean isCacheable() {
		return ConfigHolder.getConfig().isUseCache();
	}

	public static boolean isIndexable() {
		return ConfigHolder.getConfig().isUseIndex();
	}

	public static boolean isOperationSearchResult() {
		return ConfigHolder.getConfig().isOperationSearchResult();
	}
}

 大家也学觉得很莫名其妙,为什么只给出两个抽象类呢?接下来我们将这两个类“串起来”,看看会有什么效果呢?我先给出类来,大家看看,要怎么实现呢?public abstract class DaoSupport<T extends Model> extends DaoOperation implements Dao<T> {}

 

 也学大家会很奇怪,怎么又一个抽象类呢?能不能弄点新鲜玩意,就会写抽象类呢?嘿嘿。。。慢慢向下看。

看到了没有,上面有个:implements Dao<T>,这就意味着,在这个类中就Dao 这几个方法,如果让你实现反射的话,或许有更好的方法,个人是这样实现的,利用一下构造方法。

public DaoSupport() {
		this.modelClass = ReflectionUtils.getSuperClassGenricType(super.getClass());
	}
 这样做的有什么好处呢?巧妙的运用的Spring的注入的时候,利用空构造函数实例化一个对象,巧借给这个对象的modelClass 赋值。
这里主要是讲解一种思路,具体的反射,如有需要,以后在讨论。
由于前面的DaoOperation这个类已经要将做的所有事情都做完了,这里直接使用super.xxx(xxx);这样的方式很轻松的就做好了。参见如下代码:

 package com.jxs.sys.core.base.dao;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.LinkedHashMap;
import java.util.List;

import javax.annotation.Resource;

import net.sf.ehcache.Cache;
import net.sf.ehcache.Element;

import org.apache.commons.beanutils.BeanComparator;
import org.apache.commons.lang.StringUtils;
import org.compass.core.Compass;
import org.compass.core.CompassHits;
import org.compass.core.CompassSession;
import org.compass.core.CompassTemplate;
import org.perf4j.aop.Profiled;

import com.jxs.sys.core.base.event.AddEvent;
import com.jxs.sys.core.base.event.ModifyEvent;
import com.jxs.sys.core.base.listeners.AuditListener;
import com.jxs.sys.core.base.model.Model;
import com.jxs.sys.core.base.model.ModelSet;
import com.jxs.sys.core.base.utils.ReflectionUtils;
import com.jxs.sys.core.base.utils.WebUtil;
import com.jxs.sys.core.global.cache.ClearCache;
import com.jxs.sys.core.security.model.User;
import com.jxs.sys.core.security.userholder.UserHolder;

/**
 * 
 * @TO 数据操作支持类
 * @des
 * @author BestUpon
 * @date Sep 20, 2010 4:33:28 PM
 * @version since 1.0
 * @param <T>
 */
public abstract class DaoSupport<T extends Model> extends DaoOperation implements Dao<T> {

	@Resource(name = "compassTemplate")
	private CompassTemplate compassTemplate;

	@Resource(name = "ehCache")
	private Cache cache;
	/**
	 * 这个属性是权限管理用的,这里不需要管他
	 */
	@Resource(name = "auditListener")
	private AuditListener auditListener;
	private Class<T> modelClass;

	@Profiled(tag = "DaoSupport")
	public DaoSupport() {
		this.modelClass = ReflectionUtils.getSuperClassGenricType(super.getClass());
	}

	public Class<T> getModelClass() {
		return this.modelClass;
	}

	@Profiled(tag = "addInDao", message = "model = {$0}")
	public void add(T model) {
		AddEvent addEvent = new AddEvent(model);
		this.auditListener.onEvent(addEvent, this);

		super.save(model);
	}

	@Profiled(tag = "deleteInDao", message = "modelId = {$0}")
	public void delete(Integer modelId) {
		super.delete(getModelClass(), modelId);
	}

	@Profiled(tag = "modifyInDao", message = "model = {$0}")
	public void modify(T model) {
		ModifyEvent modifyEvent = new ModifyEvent(model);
		this.auditListener.onEvent(modifyEvent, this);

		super.update(model);
	}

	@Profiled(tag = "queryInDao", message = "modelId = {$0}")
	public T query(Integer modelId) {
		return (T) ((Model) super.find(getModelClass(), modelId));
	}

	@Profiled(tag = "queryAllInDao", message = "firstindex = {$0}, maxresult = {$1}, wherejpql = {$1}, queryParams = {$1}, orderby = {$1}")
	public ModelSet<T> queryAll(int firstindex, int maxresult, String wherejpql, Object[] queryParams, LinkedHashMap<String, String> orderby) {
		return super.getScrollData(getModelClass(), firstindex, maxresult, wherejpql, queryParams, orderby);
	}

	@Profiled(tag = "searchInDao", message = "queryString = {$0}")
	public List<T> search(String queryString) {
		User user = UserHolder.getCurrentLoginUser();
		ModelSet<T> qr = null;
		Element element = null;

		Compass compass = this.compassTemplate.getCompass();

		CompassSession session = compass.openSession();
		List models = null;

		CompassHits hits = session.find(queryString);
		this.log.info("命中:" + hits.getLength());
		this.log.info("查询字符串:" + queryString);

		models = hightlight(hits);

		session.close();

		Comparator comparter = new BeanComparator("id");
		Collections.sort(models, comparter);
		Collections.reverse(models);

		qr = new ModelSet();
		qr.setResultlist(models);
		qr.setTotalrecord(models.size());

		ClearCache.clear(this.cache, user.getCacheName() + "search" + getModelClass().getName());

		element = new Element(user.getCacheName() + "search" + getModelClass().getName(), qr);
		this.cache.put(element);

		return models;
	}

	@Profiled(tag = "hightlightInDao", message = "hits = {$0}")
	private List<T> hightlight(CompassHits hits) {
		List models = new ArrayList();
		for (int i = 0; i < hits.length(); ++i) {
			Model model = null;
			if (hits.data(i).getClass() == getModelClass()) {
				model = (Model) hits.data(i);

				for (String searchProperty : model.getSearchProperties()) {
					try {
						String[] multiLevelProperties = searchProperty.split(":");
						String value = hits.highlighter(i).fragment(multiLevelProperties[0]);
						if (!(StringUtils.isEmpty(value))) {
							String[] searchExpressions = multiLevelProperties[0].split("_");
							String realProperty = searchExpressions[(searchExpressions.length - 1)];
							String[] properties = (String[]) null;
							if (multiLevelProperties.length > 1) {
								properties = multiLevelProperties[1].split("_");
							}
							List<Model> objs = new ArrayList<Model>();
							objs.add(model);

							if (properties != null) {
								for (String props : properties) {
									List now = new ArrayList();
									for (Model temp : objs) {
										if (props.endsWith("$")) {
											List temps = (List) ReflectionUtils.getFieldValue(temp, props.substring(0, props.length() - 1));
											now.addAll(temps);
										} else {
											Model next = (Model) ReflectionUtils.getFieldValue(temp, props);
											now.add(next);
										}
									}
									objs = now;
								}
							}

							for (Model obj : objs)
								try {
									Object o = ReflectionUtils.getFieldValue(obj, realProperty);
									if (o != null) {
										String oldValue = o.toString();
										String newValue = WebUtil.removeHightlight(value);
										if ((StringUtils.isNotEmpty(oldValue)) && (StringUtils.isNotEmpty(newValue)) && (newValue.equals(oldValue)))
											ReflectionUtils.setFieldValue(obj, realProperty, value);
									}
								} catch (Exception e) {
									this.log.info("添加高亮,给对象【" + obj.getMetaData() + "】设置属性【" + realProperty + "】失败,值为:【" + value + "】");
								}
						}
					} catch (Exception e) {
						this.log.info("处理" + searchProperty + "高亮抛出异常,忽略,原因:" + e.getCause());
					}
				}

				models.add(model);
			} else {
				this.log.info("搜索出不是" + getModelClass() + "的实例" + hits.data(i));
			}
		}

		return models;
	}
}

 那么其他的对象的Dao需要怎么做呢?

UserDao
package com.jxs.sys.core.security.dao;

import com.jxs.sys.core.base.dao.Dao;
import com.jxs.sys.core.security.model.User;

public abstract interface UserDao extends Dao<User> {
	public abstract User queryUserByName(String paramString);
}
那么他的实现呢?
package com.jxs.sys.core.security.dao.jpa;

import java.util.List;

import org.springframework.stereotype.Repository;

import com.jxs.sys.core.base.dao.DaoSupport;
import com.jxs.sys.core.security.dao.UserDao;
import com.jxs.sys.core.security.model.User;

@Repository("userDao")
public class UserDaoJpa extends DaoSupport<User> implements UserDao {
	public User queryUserByName(String userName) {
		String wherejpql = " o.username=?1";
		String[] par = new String[]{userName};
		this.log.info("查找username为 " + userName + " 的用户");
		List<User> users = super.getScrollData(User.class, -1, -1, wherejpql, par).getResultlist();

		if ((users == null) || (users.size() != 1)) {
			this.log.info("不存在用户名为 【" + userName + "】的用户");
			return null;
		}
		return ((User) users.get(0));
	}
}
 

是不是很简单呢?几乎 不需要你写什么代码,所有的CURD的方法都有了!
为什么要举这个例子呢?
1、前面的所有例子都是使用CRUD的简单例子,现在多了一个业务逻辑——按UserName查询?怎么做呢?
很简单,看见没有,UserDao. queryUserByName(String username);就是例子,在UserDaoJpa. queryUserByName(String username);将其实现了,就好了。一般的业务逻辑都是查询,增加一般都是逐条记录的增加。这样是不是很省事呢?
期待:Service层整理中。
 

 

 

 

 

分享到:
评论
5 楼 shmily2038 2010-09-21  
差不多,平时都是这样设计的,没新意。
4 楼 weir2009 2010-09-20  
看看巴巴运动网视频一切都那么的easy。
3 楼 liuyupy 2010-09-20  
dao层和service层设计差不多,不过使用的ibatis
2 楼 BestUpon 2010-09-20  
<div class="quote_title">nothink 写道</div>
<div class="quote_div">HI,看了model和dao层。觉得从思想上面并没有太大的突破。跟springside的差不多。还是泛型dao的思路</div>
<p><br>SpringSide没有使用过!不了解!<br><span style="color: #ff0000;"><span style="font-size: medium;"><strong><br>由于“s H i t”是JE的敏感词汇,不让提交,所以C o m p a s s H i s就是敏感词汇了,所以在这里不同其他层的连接:</strong></span></span></p>
<p>
</p>
<p style="margin: 0px;"><a href="/topic/767593"><span style="font-size: medium;"><span style="color: #0000ff;"><strong><span style="color: #008000;"><span style="color: #008000;">框架底层综合+快速开发+代码重用框架-设计(Model层)</span></span></strong></span></span></a></p>
<p class="MsoNormal" style="margin: 0px;"><a href="/topic/768368"><span style="font-size: medium;"><span style="color: #0000ff;"><strong><span style="color: #008000;"><span style="color: #008000;">框架底层综合+快速开发+代码重用框架-设计(Dao层)</span></span></strong></span></span></a></p>
<p class="MsoNormal" style="margin: 0px;"><span style="font-size: medium;"><span style="color: #0000ff;"><strong><a href="/topic/768409"><span style="color: #008000;"><span style="color: #008000;">框架底层综合+快速开发+代码重用框架-设计(Service层)</span></span></a></strong></span></span></p>
<p class="MsoNormal" style="margin: 0px;"><span style="font-size: medium;"><strong><span style="color: #008000;"><a href="/topic/768428"><span style="color: #008000;">框架底层综合+快速开发+代码重用框架-设计(Action层)</span></a></span></strong></span></p>
1 楼 nothink 2010-09-20  
HI,看了model和dao层。觉得从思想上面并没有太大的突破。跟springside的差不多。还是泛型dao的思路

相关推荐

    开发者突击_Java+Web主流框架整合开发_J2EE+Struts+Hibernate+Spring+源代码

    因此,"开发者突击_Java+Web主流框架整合开发_J2EE+Struts+Hibernate+Spring+源代码"这个资源对于初学者和有经验的开发者来说都是宝贵的参考资料,能帮助他们快速上手并精通SSH2框架的整合开发。

    hibernate3.jar、ibatis-dao-2.jar、spring.jar、struts.jar、log4j-1.2.9.jar

    SSH和SSI是两种广泛使用的Java企业级开发框架组合,它们简化了开发过程,提高了代码的可维护性和可重用性。 1. **Spring.jar**:这是Spring框架的核心库,包含IoC(Inversion of Control,控制反转)和AOP(Aspect-...

    struts + DAO + Hbernate的脚本

    DAO模式是一种设计模式,用于将底层的数据访问操作与高层的业务逻辑进行解耦。通过定义一个抽象的数据访问层,DAO模式允许开发者在不修改上层业务逻辑的情况下更换不同的数据访问实现,比如从JDBC切换到Hibernate或...

    Dao设计模式教程

    它提供了一种方式来封装对底层数据源的操作,使得业务层代码无需直接与数据库进行交互,而是通过调用DAO对象的方法来完成数据的增删改查操作。 2. **DAO设计模式的优点** - **解耦**:DAO模式分离了数据访问逻辑和...

    一个PB_ORACLE开发框架的项目(源码)

    6. **代码重用与模块化**: 通过将业务逻辑和数据访问层封装在可重用的组件中,框架可以提高代码的复用性,降低维护成本。在PB_ORACLE框架中,开发者可以快速构建新功能,而不必从头开始编写所有底层代码。 7. **...

    44-使用Struts + DAO + Hibernate完成用户登陆(120M)

    在本篇文章中,我们将深入探讨如何使用Struts框架结合DAO(Data Access Object)设计模式以及Hibernate ORM(Object Relational Mapping)技术实现一个完整的用户登录系统。这个系统不仅能够有效地处理用户的登录...

    DAO设计模式辅助资料

    DAO(Data Access Object)设计模式是一种在Java编程中常见的软件设计模式,主要目的是为了将业务逻辑与数据访问操作分离,从而提高代码的可重用性和可维护性。这个压缩包文件"DAO设计模式辅助资料"显然是为了帮助...

    J2EE之DAO设计模式

    DAO(Data Access Object)设计模式是Java开发中用于数据库访问的一种常见模式,它在J2EE应用程序中扮演着至关重要的角色。DAO模式的主要目的是将业务逻辑层与数据存储层进行解耦,使得代码更加模块化,易于维护和...

    DAO设计模式.rar

    DAO模式在实际开发中有着广泛的应用,尤其是在Java EE应用程序中,它可以使得业务代码不受数据库实现的影响,提高代码的可重用性和可测试性。 在"DAO设计模式"项目中,我们可能看到以下几个关键部分: 1. **用户...

    DAO 设计模式经典实例

    DAO(Data Access Object)设计模式是一种在软件工程中用于数据库访问的常见模式,它将业务逻辑与数据操作分离开来,提高代码的可重用性和可测试性。在这个经典实例中,我们将深入探讨DAO模式的核心概念、实现方式...

    DAO 数据访问对象

    总结来说,DAO模式是软件设计中的一个重要概念,它在数据访问和业务逻辑之间建立了一个清晰的边界,有助于提高代码的可重用性、可扩展性和可测试性。在Java开发中,DAO模式通常结合Spring框架和其他ORM(对象关系...

    SSM框架详细阐述.pdf

    这个框架的详细阐述主要涵盖了四个层面:持久层(DAO层)、业务层(Service层)、表现层(Controller层)和视图层(View层),以及它们之间的相互联系和整合方式。 1. **持久层(DAO层)**: DAO层是数据访问对象...

    JAVA DAO模式浅析.pdf

    DAO(数据访问对象)模式是Java项目开发中常见的设计模式,主要用于处理数据库交互,实现业务逻辑层与数据访问层的解耦,以及跨数据库平台的移植。该模式的核心思想是将对数据库的操作封装在独立的DAO类中,从而隐藏...

    2000_Delphi最新三层源码_delphi三层架构_DELPHI三层_三层_源码

    5. **Delphi的三层架构优势**:使用Delphi开发三层架构应用有以下优点:提高代码的可重用性,因为各层职责明确;提高系统的可扩展性,新功能的添加只需修改或增加相应的服务层和DAO层代码;提高系统的可维护性,各层...

    Don’t repeat the DAO!

    但根据标题,我们可以推测博主林诗权可能在文章中讨论了在实际项目中如何避免DAO层的冗余代码,分享了最佳实践和经验,可能包括如何通过抽象、继承、工厂模式或使用ORM(对象关系映射)框架来优化DAO的设计。...

    DAO的设计模式 里面transfer 数据库的映射

    DAO(Data Access Object)设计模式是一种在软件工程中用于封装对数据库操作的模式,它的主要目的是将业务逻辑层与数据访问层分离,提高代码的可重用性、可测试性和可维护性。在这个主题中,我们将深入探讨DAO设计...

    DAO设计模式

    DAO(Data Access Object)设计模式是软件开发中用于处理数据访问的一种常见模式,尤其是在Java应用程序中。DAO模式的主要目标是将业务逻辑与数据存取逻辑分离,提供一个抽象层来处理底层的数据存储机制,比如数据库...

    Spring框架Jar包里面有ioc、aop、mvc、dao、orm几项

    Spring还支持多种ORM框架,如Hibernate和MyBatis,这些框架可以进一步简化DAO层的开发。 5. **对象关系映射(ORM,Object-Relational Mapping)**: ORM是一种技术,它允许开发者使用面向对象的方式来操作数据库,...

    JAVA公共资源模块的设计与开发(源代码+LW).zip

    本资料包"JAVA公共资源模块的设计与开发(源代码+LW)"提供了详细的实现示例,对于Java学习者,尤其是进行毕业设计或课业设计的学生,具有很高的参考价值。 首先,我们需要理解公共资源模块的核心概念。在Java中,...

Global site tag (gtag.js) - Google Analytics