博客分类：
Service 层的代码
public class GeneralService extends AbstractService {
private GeneralDao generalD
public void setGeneralDao(GeneralDao generalDao) {
this.generalDao = generalD
public void saveResourceSale(ResourceItemFormbean resourceItem)
throws Exception {
generalDao.saveResourceSale(resourceItem);
public List selectTodayResource(Map params) throws Exception {
return generalDao.selectTodayResource(params);
public List selectTdPrintInfo(Integer ddid, Integer linkmanid)
throws Exception {
return generalDao.selectTdPrintInfo(ddid, linkmanid);
public List selectTdPrintItems(Integer ddid) throws Exception {
return generalDao.selectTdPrintItems(ddid);
public List selectTodayBuy(Map params) throws Exception {
return generalDao.selectTodayBuy(params);
public List selectStockKgzy(Integer ptid, Integer prodid, Integer cmdeptid,Integer page)
throws Exception {
return generalDao.selectStockKgzy(ptid, prodid, cmdeptid,page);
public List selectStockXqzy(Integer ptid, Integer prodid, Integer cmdeptid,
Integer page) throws Exception {
return generalDao.selectStockXqzy(ptid, prodid, cmdeptid, page);
public void deletePublishedResource(Integer pkid) throws Exception {
generalDao.deletePublishedResource(pkid);
public void saveXqResourcePublish(XqZyfbModel data) throws Exception {
generalDao.saveXqResourcePublish(data);
public XqZyfbModel selectXqResourceDetail(Integer pkid) throws Exception {
return generalDao.selectXqResourceDetail(pkid);
DAO 层的代码
public class GeneralDao extends AbstractDao {
public void saveResourcePublish(ZyfbModel data) throws Exception {
getSqlMapClientTemplate().update("MainProcedure.saveResourcePublish",
public void updateResourcePublish(ZyfbModel data) throws Exception {
getSqlMapClientTemplate().update("MainProcedure.updateResourcePublish",
public void deletePublishedResource(Integer pkid) throws Exception {
getSqlMapClientTemplate().update("MainProcedure.deletePublishedResource",
public List selectStockXqzy(Integer ptid, Integer prodid, Integer cmdeptid,
Integer page) throws Exception {
Map params = new HashMap();
params.put("ptid", ptid);
params.put("prodid", prodid);
params.put("cmdeptid", cmdeptid);
params.put("row", new Integer(15));
params.put("page", page);
return getSqlMapClientTemplate().queryForList(
"MainProcedure.selectStockXqzy", params);
public void saveXqResourcePublish(XqZyfbModel data) throws Exception {
getSqlMapClientTemplate().update("MainProcedure.saveXqResourcePublish",
public XqZyfbModel selectXqResourceDetail(Integer pkid) throws Exception {
return (XqZyfbModel) getSqlMapClientTemplate().queryForObject(
"MainProcedure.selectXqResourceDetail", pkid);
迷惑的是在上面的代码中，Service 并没有什么业务逻辑，似乎可有可无，是否上面的代码可以将Service层省略，直接在DAO层操作和事务拦截，只有涉及到具体业务逻辑的时候使用Service,当然这会造成Controller和DAO层之间的紧耦合，大家在项目中遇到如上情况都是如何做的？
浏览 19160
论坛回复 /
(28 / 20837)
目前有一个想法，前面有人说过用DaoHelper，不过我比较不喜欢直接调用Helper类，因此有这样一个想法：
将DaoHelper注入到AbstractService 中，然后针对DaoHelper的每一个方法调用在AbstractService 进行代理，也就是说所有的操作都需要通过Service不可以绕行，而且这样也不需要Service继承Dao,Service继承Dao总是感觉很奇怪。
当然缺点就是对于每一个Service都需要注入这样一个DaoHelper。
我记得这个问题在阎宏在《java与模式》曾经讲过：要尽量使用合成/聚合，尽量不使用继承。
而在我们这个问题上刚好是最佳注脚
Dao跟service本身就不是在一个层次上 让他们继承实在有些牵强，而采用合成/聚合则使dao层和service层有更松散的耦合，所以就耦合性来讲 采用合成聚合方式更为合理。
但是采用合成聚合方式会在xxxService类中多出一个daoHelper对象，好像是增加了复杂度。
其实只要明白了这个道理就行了，怎么简单怎么来啦
目前我的BaseDao是这样的
public abstract class AbstractDao extends SqlMapClientDaoSupport {
protected final static Log log = LogFactory.getLog(AbstractDao.class);
public int updateEntity(Object entity, String statementId)
throws Exception {
return getSqlMapClientTemplate().update(statementId, entity);
public int insertEntity(Object entity, String statementId)
throws Exception {
return getSqlMapClientTemplate().update(statementId, entity);
public int deleteEntity(Object entity, String statementId) throws Exception {
return getSqlMapClientTemplate().delete(statementId, entity);
public Object queryForObject(Integer pkid, String statementid)
throws Exception {
return getSqlMapClientTemplate().queryForObject(statementid, pkid);
public List queryForList(Object params, String statementid)
throws Exception {
return getSqlMapClientTemplate().queryForList(statementid, params);
然后BaseService这样
public abstract class AbstractService extends AbstractDao {
省略Dao层!
同意这种方式
我曾经在项目中这样用过
这样写法的用意是怎样？
AbstractDao 为什么要 extends 一个 SqlMapClientDaoSupport ？
SqlMapClientDaoSupport是什么？
看代码还是太detail，没有办法overview,虽然从直觉上我觉得你现在这样做有些复杂了，但是还没有充分的直接的理由下结论。能否把架构图展示一下先？
SqlMapClientDaoSupport 是 org.springframework.orm.ibatis.support.SqlMapClientDaoS
我的代码很复杂吗?可能我没有表述清楚.
所有的Service继承AbstractService,
所有的Dao继承AbstractDao,
CRUD的简单操作不用在Service和Dao层定义,简单的Query直接写在Service中.
复杂的逻辑如isChecked(),count等直接和业务逻辑相关又不是简单的CRUD操作,才放置在DAO中.
不妨看看我以前写的一篇文章，里面有代码和guide，
对于你的疑问，我的看法是（摘自原文）：
引用
分层架构：分层架构有助于将大系统分解成子任务，每个子任务限制在一个特定的层次上，层间从上到下依赖，从下到上是松耦合。TCP/IP分层模型是它的最好证明。正如OSI 7层模型的实用模型是TCP/IP 4层模型。MiniFramework中，用户接触到的是两层：表示层和业务层，是J2EE和.NET架构的一种折中。在用MiniFramework开发时，持久层被封装起来，成为一些简单的Helper类，不是独立的一层。
之所以我去掉了持久层，只保留的dao helper，是因为，我发现业务比较简单的系统，往往开发人员喜欢在持久层里面写所有的业务，service层只是dao的一个delegate，非常 thin。要是这样，我就干脆去掉一层算了，这便是dao helper的由来。
严格的分层，可以让表示层的UI用Dreamweaver开发，业务层容器外测试，实现敏捷开发。
接口：在分层模型中，一般都非常强调接口，因为可以让上层只依赖于下层的接口，而不是实现，这样实现可以任意替换和变更，在网络开发，特别是和协议打交道的时候，我们会体会到这种设计的优雅。另外，在组件式开发中，我们也倾向于提供接口。
但是，应用MiniFramework，我们倾向于纵向开发，也就是说，某个模块从表示层到持久层都是一人开发，而不是横向：表示层的去调用业务层开发人员的业务层。这时候，纵向开发就不太适合用接口了，因为接口规范完全由本人把握。这时接口很可能只会带来臃肿，和难维护，一点改动往往牵一动百。当然，在某些情况，如开发Mock测试，Web Services，接口还是很有必要。另外，有人说，我用接口可以实现任意层替换啊？譬如我现在用Hibernate，以后换成IBatis。这完全是一个谎言，至少我看到的大多数应用，将Hibernate换成IBatis的成本绝不亚于重新开发，因为耦合太大。另外，我有个疑问：需要更换的可能性有 1％吗？
个人觉得，接口比较适合于系统软件开发，而不是商业软件开发；而抽象类的继承机制比较适合商业软件开发，而不是系统软件开发。为了复用，系统软件开发倾向于组合，而不是继承。 其实，对于业务逻辑简单的系统，省略掉一层我觉得非常有必要，当然前提是我选择了简单而不是规范，就如楼上所说，如此thin 的 service层真的没有必要！
lingxu_lingxu 写道
你有没有想过,写 一些简单的业务逻辑是可以放在DAO里,但要是整个系统很大,业务逻辑很复杂,你会怎么处理呢,我现在在做交行的基金托管项目,业务出奇的复杂,涉及了个方面的知识,有财务会计,证券,股票,基金等等,我觉得还是分开来比较好!!
因为service层已经对CRUD进行了很好的封装了阿,复杂的业务逻辑为什么不可以?CRUD有了,复杂的逻辑需要的原子操作已经有了阿.
温柔一刀 写道
如果系统业务简单
可以抽象出通用的dao层(也就一个类)
让业务层继承通用的dao
看了大家的讨论,我现在的想法是干脆将DAO层舍弃,直接由Service来承担,这样最简单.
DigitalSonic 写道
为什么不考虑这里用泛型?
范型意味着多个method的声明,那用不用范型没有区别.
分层架构：分层架构有助于将大系统分解成子任务，每个子任务限制在一个特定的层次上，层间从上到下依赖，从下到上是松耦合。TCP/IP分层模型是它的最好证明。正如OSI 7层模型的实用模型是TCP/IP 4层模型。MiniFramework中，用户接触到的是两层：表示层和业务层，是J2EE和.NET架构的一种折中。在用MiniFramework开发时，持久层被封装起来，成为一些简单的Helper类，不是独立的一层。
之所以我去掉了持久层，只保留的dao helper，是因为，我发现业务比较简单的系统，往往开发人员喜欢在持久层里面写所有的业务，service层只是dao的一个delegate，非常 thin。要是这样，我就干脆去掉一层算了，这便是dao helper的由来。
严格的分层，可以让表示层的UI用Dreamweaver开发，业务层容器外测试，实现敏捷开发。
接口：在分层模型中，一般都非常强调接口，因为可以让上层只依赖于下层的接口，而不是实现，这样实现可以任意替换和变更，在网络开发，特别是和协议打交道的时候，我们会体会到这种设计的优雅。另外，在组件式开发中，我们也倾向于提供接口。
但是，应用MiniFramework，我们倾向于纵向开发，也就是说，某个模块从表示层到持久层都是一人开发，而不是横向：表示层的去调用业务层开发人员的业务层。这时候，纵向开发就不太适合用接口了，因为接口规范完全由本人把握。这时接口很可能只会带来臃肿，和难维护，一点改动往往牵一动百。当然，在某些情况，如开发Mock测试，Web Services，接口还是很有必要。另外，有人说，我用接口可以实现任意层替换啊？譬如我现在用Hibernate，以后换成IBatis。这完全是一个谎言，至少我看到的大多数应用，将Hibernate换成IBatis的成本绝不亚于重新开发，因为耦合太大。另外，我有个疑问：需要更换的可能性有 1％吗？
个人觉得，接口比较适合于系统软件开发，而不是商业软件开发；而抽象类的继承机制比较适合商业软件开发，而不是系统软件开发。为了复用，系统软件开发倾向于组合，而不是继承。
xuni 写道写一个service和DAO的基类不就成了吗,service中有一个BaseDAO的实例,service基类的save方法调用dao的save方法,我一直以为Service层的接口声明应该是清晰，你这样所有的save,update,delete之类的参数都是Object类型的参数了！
为什么不考虑这里用泛型?
直接使用dao层是比较不合理的，dao层封装的通常是原子化的操作，业务层是组织业务逻辑的，目前service层可能只是简单的调用dao层的方法，不代表逻辑变化之后需要更加复杂的逻辑，这时不可能直接修改dao层，有可能破坏别的service方法对当前调用的dao的逻辑。
过度设计！
真遇到这种变态需求变化只改变service层就行了？？
foxhon 写道
例如：原来有个客户保存的dao方法，被一个service方法调用，同时这个dao方法直接暴露给前台，这时如果直接暴露的方法要预先做个判断客户的某个条件，而原先引用这个dao的service方法不需要这个逻辑，难道直接修改这个dao方法吗？
难道不能按照需要增加个中间层么？
foxhon 写道
系统开始可能觉的这样比较烦人，但是要有长远的考虑。
先跑起来，而且要简单
jamesby 写道
将如上代码放入DAO的超类中,这样我每一个DAO就不需要重复写这些功能雷同的代码!不知道有什么不合适之处.
无论怎么简化dao层，dao对外的接口是不变的，最终业务层还是要是调用dao层的方法，还是会出现楼主的问题
我觉得既然项目业务比较简单，省掉业务层也未尝不可， 在web层直接调用dao 。
如果遇到业务操作就写在dao层，或者web层。
对的，其实除了简单的crud操作之外，还与很多query之类的操作，感觉通过Service 就是走过场！
我在 DAO 层所简化的也只是在DAO层把最基本的crud操作简单封装了一下，避免在所有的dao中进行crud的编写！
看来这是一个在简单和规范之间进行的选择，要简单，直接dao,要规范，加层service.
将如上代码放入DAO的超类中,这样我每一个DAO就不需要重复写这些功能雷同的代码!不知道有什么不合适之处.
无论怎么简化dao层，dao对外的接口是不变的，最终业务层还是要是调用dao层的方法，还是会出现楼主的问题
我觉得既然项目业务比较简单，省掉业务层也未尝不可， 在web层直接调用dao 。
如果遇到业务操作就写在dao层，或者web层。
xly_971223 写道一种折中的办法是业务层继承dao层 业务对象要用到多个dao时会麻烦一些
像cms系统就是这种情况，大多数的操作是crud，要是按照上面的写法还不疯了
可以参考一下springside2中的方法业务层继承DAO层,Service 肯定要访问多个DAO的,这个继承的方案有些行不通,现在已经快疯了:)
giscat 写道视情况而定，简单的合并
复杂的分分层
现在的业务基本都是这种简单的情况,因为复杂的方式要求写存储过程. 简单情况如何合并?不是很理解
& 简单情况直接在action里调持久层代码
&&&&&&&& 如
&&&&&&&&& JdbcUtil.save(objet);
&&&&&&&& JdbcUtil.update(objet);
&&&&&&&& JdbcUtil.query(sql,params);
&& JdbcUtil可以是对hibernate,ibatis,spring jdbctemplate,dbutil，jdbc等的封装
&&&&& 如果比较复杂，涉及多个实体操作，事务之类的，
&&&&&&&&&&& 再整个service出来，
&&&&&
写一个service和DAO的基类不就成了吗,service中有一个BaseDAO的实例,service基类的save方法调用dao的save方法,我一直以为Service层的接口声明应该是清晰，你这样所有的save,update,delete之类的参数都是Object类型的参数了！
& 上一页 1
浏览: 343899 次
You are using old notation for
你好 你这个工程压缩包是不是有问题啊？根本不能导入？
[list][*]dsadsa[*]dsadsa[*]dsad ...
和 weblogic 有个毛线关系？？？？？？？
(window.slotbydup=window.slotbydup || []).push({
id: '4773203',
container: s,
size: '200,200',
display: 'inlay-fix'service和dao的区别_中华文本库
② 而在 springMVC 配置文件中(dispatcher-servlet.xml)将 Service 和 Dao 的注解给过 滤掉 ,只扫描装配 Controller。 (2)、 当前端用 ajax 请求, 返回类型...
Service层和DAO层解析_IT/计算机_专业资料。Service层和DAO层解析dao...根据不同项目的复杂度来确定是否需要分层,如果是小项目的话,2 层应该就够了,...
Dao = userD 这样,Spring 会找到 id 为 userServiceImpl 和 userDao 的 ...和@PostConstruct 区别在于:@PostConstruct 注释的方法将在 类实例化后调用,而...
Axis2 webservice 发布教程 ,整合到自己的项目中_计算机软件及应用_IT/计算机_专业资料。Axis2,webservice,发布 ,教程 Web Project 项目整合 Axis2 网上的教程全...
Dao层与Model之间的关系_计算机软件及应用_IT/计算机_专业资料。1. Action 用 service,service 用 dao,dao 用 model 2. Spring 提倡的是面向接口即抽象编程,...
Service层的业务实现,具体要调用到已定义的DAO层的接口,封装Service层的业务逻辑有利于通用的业务逻辑的独立性和重复利用性,程序显得非常简洁。 Controller层:...
jax-ws 方式的 webservice 部署到 tomcat 中会遇到的问题 1 启动服务器后,报如下错误: 解决方法:在项目的构建路径中加入 jax-ws 的相关 jar 包 2 出现如下...
如果使用 SERVICE 层把 DAO 和 ACTION 层进行分离,通过 SERVICE 层将 层进行分离, 类似的业务放在一起, 类似的业务放在一起,在不同的 ACTION 中如果需要对相似...
ibatis和mybatis的区别_计算机软件及应用_IT/计算机_专业资料。ibatis 和 mybatis...service 里面直接调用 dao 就可以了,但是 ibatis 则不可以,必须要写 dao 的...
java 开发Dao层的经典实现_计算机软件及应用_IT/...(); list = pservice.selAllPersons(); for(...java DAO 12页 免费
Java中DAO模式的设计与实.....博客分类：
因为DAO层基本的就是CRUD操作，变化不是很大，要是有变化的那就是查询。而确实没有必要为每一个实体写一个完整的DAO，但是没有还不行，那就“抽取”出来吧。而Service依赖与DAO层，有时就是简单调用一下，也确实没有必要每个都写。总之，不爱写多个，那就写一个通用的，而其他的继承或实现这个通用的可以了。
还是用代码说话吧。
package org.monday.
import java.io.S
import java.util.L
* BaseDAO 定义DAO的通用操作
* @author Monday
public interface BaseDao&T& {
public void save(T entity);
public void update(T entity);
public void delete(Serializable id);
public T findById(Serializable id);
public List&T& findByHQL(String hql, Object... params);
上面的DAO只定义了一些常见的方法，有需要通用的方法，可以随便加，然后实现它就行了。
package org.monday.dao.
import java.io.S
import java.lang.reflect.ParameterizedT
import java.util.L
import javax.annotation.R
import org.hibernate.Q
import org.hibernate.S
import org.hibernate.SessionF
import org.monday.dao.BaseD
* BaseDaoImpl 定义DAO的通用操作的实现
* @author Monday
@SuppressWarnings("unchecked")
public class BaseDaoImpl&T& implements BaseDao&T& {
private Class&T&
* 通过构造方法指定DAO的具体实现类
public BaseDaoImpl() {
ParameterizedType type = (ParameterizedType) this.getClass().getGenericSuperclass();
clazz = (Class&T&) type.getActualTypeArguments()[0];
System.out.println("DAO的真实实现类是：" + this.clazz.getName());
* 向DAO层注入SessionFactory
private SessionFactory sessionF
* 获取当前工作的Session
protected Session getSession() {
return this.sessionFactory.getCurrentSession();
public void save(T entity) {
this.getSession().save(entity);
public void update(T entity) {
this.getSession().update(entity);
public void delete(Serializable id) {
this.getSession().delete(this.findById(id));
public T findById(Serializable id) {
return (T) this.getSession().get(this.clazz, id);
public List&T& findByHQL(String hql, Object... params) {
Query query = this.getSession().createQuery(hql);
for (int i = 0; params != null && i & params. i++) {
query.setParameter(i, params);
return query.list();
以上是BaseDao和它的实现类。
那下面以CustomerDao与OrderDao为例,编写具体的Dao
package org.monday.
import org.monday.domain.C
* 客户DAO继承BaseDAO
* @author Monday
public interface CustomerDao extends BaseDao&Customer& {
* 若BaseDAO 没有定义的方法，可以在这里添加
package org.monday.dao.
import org.monday.dao.CustomerD
import org.monday.domain.C
import org.springframework.stereotype.R
* 客户DAO的实现类 继承BaseDaoImpl 显示客户DAO接口
* @author Monday
@Repository(value = "customerDao")
public class CustomerDaoImpl extends BaseDaoImpl&Customer& implements CustomerDao {
* 若CustomerDao 定义了BaseDAO没有的方法，则可以在这里实现
package org.monday.
import org.monday.domain.O
* 订单DAO继承BaseDAO
* @author Monday
public interface OrderDao extends BaseDao&Order& {
* 若BaseDAO 没有定义的方法，可以在这里添加
package org.monday.dao.
import org.monday.dao.OrderD
import org.monday.domain.O
import org.springframework.stereotype.R
* 订单DAO的实现类 继承BaseDaoImpl 显示订单DAO接口
* @author Monday
@Repository(value = "orderDao")
public class OrderDaoImpl extends BaseDaoImpl&Order& implements OrderDao {
* 若OrderDao 定义了BaseDAO没有的方法，则可以在这里实现
至于具体的Service怎么写呢？看下面：
package org.monday.
import java.io.S
import java.util.L
* BaseService 定义Service的通用操作
* @author Monday
public interface BaseService&T& {
public void save(T entity);
public void update(T entity);
public void delete(Serializable id);
public T getById(Serializable id);
public List&T& getByHQL(String hql, Object... params);
package org.monday.service.
import java.io.S
import java.util.L
import javax.annotation.R
import org.monday.dao.BaseD
import org.monday.service.BaseS
import org.springframework.transaction.annotation.T
* BaseServiceImpl 定义Service的通用操作的实现
* @author Monday
@Transactional
public class BaseServiceImpl&T& implements BaseService&T& {
* 注入BaseDao
private BaseDao&T&
public void setDao(BaseDao&T& dao) {
this.dao =
public void save(T entity) {
dao.save(entity);
public void update(T entity) {
dao.update(entity);
public void delete(Serializable id) {
dao.delete(id);
public T getById(Serializable id) {
return dao.findById(id);
public List&T& getByHQL(String hql, Object... params) {
return dao.findByHQL(hql, params);
package org.monday.
import org.monday.domain.C
* 客户Service继承BaseService
* @author Monday
public interface CustomerService extends BaseService&Customer& {
* 若BaseService 没有定义的方法，可以在这里添加
package org.monday.service.
import javax.annotation.R
import org.monday.dao.BaseD
import org.monday.domain.C
import org.monday.service.CustomerS
import org.springframework.stereotype.S
import org.springframework.transaction.annotation.T
* 客户Service的实现类 继承BaseServiceImpl 显示客户Service接口
* @author Monday
@Service("customerService")
@Transactional
public class CustomerServiceImpl extends BaseServiceImpl&Customer& implements CustomerService {
@Resource(name = "customerDao")
public void setDao(BaseDao&Customer& dao) {
super.setDao(dao);
* 若CustomerService 定义了BaseService没有的方法，则可以在这里实现
package org.monday.
import org.monday.domain.O
* 订单Service继承BaseService
* @author Monday
public interface OrderService extends BaseService&Order& {
* 若BaseService 没有定义的方法，可以在这里添加
package org.monday.service.
import javax.annotation.R
import org.monday.dao.BaseD
import org.monday.domain.O
import org.monday.service.OrderS
import org.springframework.stereotype.S
import org.springframework.transaction.annotation.T
* 订单Service的实现类 继承BaseServiceImpl 显示订单Service接口
* @author Monday
@Service(value = "orderService")
@Transactional
public class OrderServiceImpl extends BaseServiceImpl&Order& implements OrderService {
@Resource(name = "orderDao")
public void setDao(BaseDao&Order& dao) {
super.setDao(dao);
* 若CustomerService 定义了BaseService没有的方法，则可以在这里实现
这里只是提供了一个思路。可能代码还有不严谨的地方，欢迎补充指正。
容易出现的两个异常：
1.org.hibernate.HibernateException: No Hibernate Session bound to thread, and configuration does not allow creation of non-transactional one here
答案：要加@Transactional注解
除了要在这里加注解
@Service("customerService")@Transactional
public class CustomerServiceImpl extends BaseServiceImpl&Customer& implements CustomerService {}
这里也要加
@Transactional
public class BaseServiceImpl&T& implements BaseService&T& {}
2.org.springframework.beans.factory.BeanCreationException: Error creating bean with name 'customerService': Injection of re nested exception is org.springframework.beans.factory.NoSuchBeanDefinitionException: No unique bean of type [org.monday.dao.BaseDao] is defined:expected single matching bean but found 2: [customerDao, orderDao]
注入具体的DAO
@Resource(name="customerDao") public void setDao(BaseDao&Customer& dao) {
super.setDao(dao); }
PS：画个图好了。
浏览 29544
拿不到clazz怎么破我是用的楼主的通用dao，但是拿不到泛型实际类型
@Service(value = "orderService")& @Transactional& public class OrderServiceImpl extends BaseServiceImpl&Order& implements OrderService {& & &&& /** &&&& * 注入DAO &&&& */& &&& @Resource(name = "orderDao")& &&& public void setDao(BaseDao&Order& dao) {& &&&&&&& super.setDao(dao);& &&& }& & &&& /** &&&& * 若CustomerService 定义了BaseService没有的方法，则可以在这里实现 &&&& */& 如果在这里注入了多个DAO会出错，它总是记录着最后一个被注入的DAO . 求解决　？ws 写道@Service(value = "orderService")& @Transactional& public class OrderServiceImpl extends BaseServiceImpl&Order& implements OrderService {& & &&& /** &&&& * 注入DAO &&&& */& &&& @Resource(name = "orderDao")& &&& public void setDao(BaseDao&Order& dao) {& &&&&&&& super.setDao(dao);& &&& }& & &&& /** &&&& * 若CustomerService 定义了BaseService没有的方法，则可以在这里实现 &&&& */& 如果在这里注入了多个DAO会出错，它总是记录着最后一个被注入的DAO . 求解决　？如果想实现注入多个Dao& 解决方法是@Service(value = "orderService")& @Transactional& public class OrderServiceImpl extends BaseServiceImpl&Order& implements OrderService {& & &&& /** &&&& * 注入DAO &&&& */& &&& @Resource(name = "orderDao")& &&& public void setDao(BaseDao&Order& dao) {& &&&&&&& super.setDao(dao);& &&& }& & &&& /** &&&& * 若CustomerService 定义了BaseService没有的方法，则可以在这里实现 &&&& */& }& 去掉 extends BaseServiceImpl&Order& 即可。原因是，继承过来&& /** &&&& * 注入BaseDao &&&& */& &&& private BaseDao&T&& &&& @Resource& &&& public void setDao(BaseDao&T& dao) {& &&&&&&& this.dao =& &&& }& & 中的dao。&&& @Resource&& 没有注入任何dao。所以会搜索所有的Dao进行注入，因此导致异常No unique bean of type 。上面的方法可以解决多daozhuru2.没有验证过，只是提供解决思路：如果非要extends BaseServiceImpl&Order& ，& 解决方法， * 注入BaseDao &&&& */& &&& private BaseDao&T&& &&& @Resource& &&& public void setDao(BaseDao&T& dao) {& &&&&&&& this.dao =& &&& }& 中@Resource 必须注入一个T类型的Dao动态的进行注入。应该利用反射等知识。反正这种假设不太对。如果非得继承extends BaseServiceImpl&Order&&& 那最好去掉private BaseDao&T&& &&& @Resource& &&& public void setDao(BaseDao&T& dao) {& &&&&&&& this.dao =& &&& } 。然后在自己的子类中进行注入 @Resource(name="customerDao") private BaseDao&Customer& customerD @Resource(name="orderDao") private& BaseDao&Order& orderD &
周一Monday
浏览: 259159 次
来自: 上海
感谢，很实用
虽然通过接口方式省了一些代码，但每一个实体还是要写一个DAO， ...
spring mvc demo教程源代码下载，地址：http: ...
&div class=&quote_title ...
真心简单是啊吧
(window.slotbydup=window.slotbydup || []).push({
id: '4773203',
container: s,
size: '200,200',
display: 'inlay-fix'}