简单理解：

DAO数据库访问对象 实现连接数据库 修改、添加等细节 
service服务层 面向功能 把一个整个服务 细化 调用DAO
其实service其中都是一些方法 去调用DAO 甚至方法名都和DAO中一样的
如某个service是用作用户注册的
其中可能包括检测用户名是否存在和插入用户数据两部分
分别调用DAO中具体实现 操纵数据库
看起来逻辑更清晰而已

进一步说明：

Dao层实现是简单的CRUD操作。相当于sql中的单条select,insert,upate,delete语句。
而service层就是具体业务的实现。一般多次组合dao层的方法(dao层方法达到了重用目的)，是多个数据库操作的集合，可以看做数据库中的存储过程，而且事务一般控制在service层。这些数据库操作一起提交或回滚。
当然，简单的系统完全可以不划分service层，只用dao层。但那这样的话，代码从用性就不高。

用户的Dao层

Java code

 

?

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
public class UserDaoHibernate extends BaseDaoHibernate implements
        IUserDao {
 
    /**
     * 增加用户
     * 
     * @param user
     */
    public Long addUser(User user) {
        return addEntityRetVal(user);
    }
 
    /**
     * 通过id删除用户
     * 
     * @param user
     */
    public void deleteUser(Long id) {
        User userPO = (User) getHibernateTemplate().load(
                User.class, id);
        deleteEntity(userPO);
    }
 
    /**
     * 删除用户
     * 
     * @param user
     */
    public void deleteUser(User user) {
        User userPO = (User) getHibernateTemplate().load(
                User.class, user.getUserid());
        deleteEntity(userPO);
    }
 
    /**
     * 更新用户
     * 
     * @param user
     */
    public void updateUser(User user) {
        User userPO = (User) getHibernateTemplate().load(
                User.class, user.getUserid());
        BeanUtil.copyProperties(userPO, user);
        updateEntity(userPO);
    }
 
    /**
     * 通过id查询用户
     * 
     * @param id
     * @return
     */
    public User queryUserById(Long id) {
        return (User) getHibernateTemplate().load(User.class, id);
    }
     
    /**
     * 通过用户名字查询用户实体   -- 这个方法存在SQL注入攻击问题
     * @param usernme
     * @return
     */
    public User queryUserByName(String username){
        String hql = "select u from User u where u.username = '" + username + "'";
        return (User) this.queryObjectByHql(hql);
    }
 
    /**
     * 查询所有用户
     * 
     * @return
     */
    public List<User> queryAllUser() {
        return queryAllEntitys(User.class);
    }
 
    /**
     * 分页查询用户
     */
    public List<User> queryAllUser(String hql, int currentPage,
            int pageSize) {
        return queryAllEntitys(currentPage,pageSize,hql);  //调用的是有currentPage的分页方法
    }
 
    /**
     * 
     * 通过用户id查询用户名称,查不到返回 null 
     * @param id
     * @return
     */
    public String queryNameById(Long id){
        String hql = " from User d where d.userId = ?";
        List<?> users = getHibernateTemplate().find(hql,id);
        if(users.size()>0){
           return ((User)users.get(0)).getUsername();
        }else{
           return null;
        }
         
    }
     
 
    /**
     * 得到用户分页记录总数
     * @param parentId
     * @return
     */
    /*
    public Long queryTotalNumberOfUser(){
        String hql = "select count(*) from User";
        List<?> childNumber = getHibernateTemplate().find(hql);
        return (Long)childNumber.get(0);
    }*/
     
    public int queryAllUserNubmer(String hql){
        return queryAllEntitysNumer(hql);
    }
     
    /**
     * 查询用户的权限
     * @param userId
     * @return
     */
    public List<UserAuth> queryFunctionOnlyByUserId(Long userId){
        String hql = "select ua from UserAuth ua where ua.userid = " + userId;
        List<UserAuth>  userAuths = queryAllObjectByHql(hql);
        return userAuths;
    }
 
    /**
     * 查询用户的角色
     * @param userId
     * @return
     */
    @SuppressWarnings("unchecked")
    public List<UserRole> queryRoleOnlyByUserId(Long userId){
        String hql = "select ur from UserRole ur where ur.userid = " + userId;
        List<UserRole>  userAuths =  queryAllObjectByHql(hql);
        return userAuths;
    }
     
     
}

service层，又可细化为查询业务UserHelper，还有增加，更新，删除业务集中在UserFacade中。这里贴出UserHelper.java

Java code

 

?

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
@WebService
public class UserHelper implements IUserHelper {
 
    private IUserDao userDao = null;
    private IDepartmentDao departDao = null;
    private IFunctionHelper functionHelper = null;
    private IRoleHelper roleHelper = null;
 
    public void setUserDao(IUserDao userDao) {
        this.userDao = userDao;
    }
 
    public void setFunctionHelper(IFunctionHelper functionHelper) {
        this.functionHelper = functionHelper;
    }
 
    public void setDepartDao(IDepartmentDao departDao) {
        this.departDao = departDao;
    }
 
    public void setRoleHelper(IRoleHelper roleHelper) {
        this.roleHelper = roleHelper;
    }
 
    /**
     * 通过id查询权限,没有则返回null
     * 
     * @param id
     * @return
     */
    public UserVO queryUserById(Long id) throws GeneralException {
        User user = null;
        try {
            user = userDao.queryUserById(id);
        } catch (Exception e) {
            e.printStackTrace();
            throw new GeneralException("error.userDeatil", "通过id查询权限时出错！");
        }
        // PO 转 VO
        UserVO userVO = userPoToVo(user);
        return userVO;
    }
 
    /**
     * 得到所有权限的集合,没有则返回 null
     * 
     * @return
     */
    public List<UserVO> queryAllUser() throws GeneralException {
        List<UserVO> allFuncVOs = new ArrayList<UserVO>();
        List<User> allFuncs = null;
        try {
            allFuncs = userDao.queryAllUser();
        } catch (Exception e) {
            throw new GeneralException("error.userList", "得到所有权限的集合时出错！");
        }
        for (Iterator<?> iterator = allFuncs.iterator(); iterator.hasNext();) {
            User user = (User) iterator.next();
            // PO 转 VO
            UserVO userVO = userPoToVo(user);
            allFuncVOs.add(userVO);
        }
        return allFuncVOs;
    }
 
 
    /**
     * 权限的PO 到 VO 转换的方法
     * 
     * @param user
     * @return
     */
    public UserVO userPoToVo(User user) throws GeneralException {
        UserVO userVO = new UserVO();
        BeanUtil.copyProperties(userVO, user);
        try {
            userVO.setDepartName(departDao.queryNameById(user.getDepartid())); // 设置部门名称
        } catch (Exception e) {
            throw new GeneralException("error.user", " 权限的PO 到 VO 转换时出错！");
        }
        if(userVO.getStatus().equals("1")){
            userVO.setStatus("可用");
        }else{
            userVO.setStatus("不可用");
        }
        userVO.setRegisterName("ZHANG");
        userVO.setChangerName("ZHANG");
        return userVO;
 
    }
 
    /**
     * 通过分页查询权限信息集合
     * 
     * @param hql
     * @param currentPage
     * @param pageSize
     * @return
     * @throws GeneralException
     */
    public List<UserVO> queryUserByPage(String hql, int currentPage,
            int pageSize) throws GeneralException {
        List<UserVO> allFuncVOs = new ArrayList<UserVO>();
        List<User> allFuncs = null;
        try {
            allFuncs = userDao.queryAllUser(hql, currentPage, pageSize);
        } catch (Exception e) {
            throw new GeneralException("error.userList", "分页得到权限的集合时出错！");
        }
        for (Iterator<?> iterator = allFuncs.iterator(); iterator.hasNext();) {
            User user = (User) iterator.next();
            // PO 转 VO
            UserVO userVO = userPoToVo(user);
            allFuncVOs.add(userVO);
        }
        return allFuncVOs;
    }
 
    /**
     * 返回User分页对象
     * 
     * @param currentPage
     * @return
     */
    public Pagination getPagination(int currentPage, String hql) {
        return new Pagination(currentPage,
                DisplayRecordCount.DISPLAY_IN_USER_LIST, userDao
                        .queryAllUserNubmer(hql));
    }
 
    /**
     * 查到用户的所有角色ID
     * 
     * @param userId
     * @return
     * @throws GeneralException
     */
    public List<Long> queryAllRoleidsOfUser(Long userId)
            throws GeneralException {
        List<Long> rolesOfUser = new ArrayList<Long>();
        List<UserRole> userRoles = null;
        try {
            userRoles = userDao.queryRoleOnlyByUserId(userId); // 查到角色权限
        } catch (Exception e) {
            throw new GeneralException("error.userRoleidsList",
                    "得到用户的角色ID集合出错！");
        }
        for (Iterator<?> iterator = userRoles.iterator(); iterator.hasNext();) {
            UserRole userRole = (UserRole) iterator.next();
            Long roleid = userRole.getRoleid();
            rolesOfUser.add(roleid);
 
        }
        return rolesOfUser;
    }
 
    /**
     * 查到用户的所有角色
     * 
     * @param userId
     * @return
     * @throws GeneralException
     */
    public List<RoleVO> queryAllRoleOfUser(Long userId) throws GeneralException {
        List<Long> rolesOfUser = new ArrayList<Long>();
        List<RoleVO> userRoles = new ArrayList<RoleVO>();
        try {
            rolesOfUser = queryAllRoleidsOfUser(userId);
            for (Iterator<?> iterator = rolesOfUser.iterator(); iterator
                    .hasNext();) {
                Long roleid = (Long) iterator.next();
                RoleVO roleVO = roleHelper.queryRoleById(roleid);
                userRoles.add(roleVO);
            }
        } catch (Exception e) {
            e.printStackTrace();
            throw new GeneralException("error.userRoleList",
                    "得到用户的角色集合出错！");
        }
        return userRoles;
    }
 
    /**
     * 查询用户的所有权限 1.查询所有用户的权限 2.查询所有用户的角色 3.查询所有用户的权限+角色的权限-共同的权限
     * 
     * @param userId
     * @return
     */
    public List<FunctionVO> queryAllFunctionOfUser(Long userId,String system)
            throws GeneralException {
        Set<FunctionVO> userAllFuncs = new HashSet<FunctionVO>();
        List<FunctionVO> userAllFuncsList = new ArrayList<FunctionVO>();
        try {
            List<UserAuth> userFuncs = userDao
                    .queryFunctionOnlyByUserId(userId); // 查到权限
 
            if (userFuncs != null) {
                for (Iterator<?> iterator = userFuncs.iterator(); iterator
                        .hasNext();) {
                    UserAuth userFunc = (UserAuth) iterator.next();
                    Long funcId = userFunc.getFuncid();
                    FunctionVO funcVO = functionHelper
                            .queryFunctionById(funcId);
                    userAllFuncs.add(funcVO);
                }
            }
 
            List<UserRole> userRoles = userDao.queryRoleOnlyByUserId(userId); // 查到角色
 
            if (userRoles != null) {
                // 查到所有角色的所有权限，将权限放入到userAllFuncs中
                for (Iterator<?> iterator = userRoles.iterator(); iterator
                        .hasNext();) {
                    UserRole userRole = (UserRole) iterator.next();
                    Long roleId = userRole.getRoleid();
                    List<FunctionVO> funcVOs = roleHelper
                            .queryFunctionOfRole(roleId);
                    for (Iterator<?> iterator2 = funcVOs.iterator(); iterator2
                            .hasNext();) {
                        FunctionVO functionVO = (FunctionVO) iterator2.next();
                        userAllFuncs.add(functionVO);
                    }
                }
            }
 
            // 将筛选了数据的无序Set集合转换为有序的List集合.一定要从小到大，否则权限树显示就会有问题
 
            for (Iterator<?> iterator = userAllFuncs.iterator(); iterator
                    .hasNext();) {
                 
                FunctionVO userAllFun = (FunctionVO) iterator.next();
                if(system.equals("crm")){
                    if(userAllFun.getFuncid()>=20000000l){
                        userAllFuncsList.add(userAllFun);
                    }
                }else if(system.equals("hr")){
                    if(userAllFun.getFuncid()<20000000l){
                        userAllFuncsList.add(userAllFun);
                    }
                }
            }
 
            FunctionComparator fc = new FunctionComparator();
            Collections.sort(userAllFuncsList, fc);
        } catch (Exception e) {
            e.printStackTrace();
            throw new GeneralException("error.userAllFuncsList", "得到用户的权限集合出错！");
        }
        return userAllFuncsList;
    }
 
}
dao层是sql的增删改查
service层是给dao层得到结果添加业务逻辑
以‘用户登录’为例
dao层只负责查询用户名是username、密码是password的用户返回list
service层添加逻辑判断，list的size如果大于0，返回用户；size小于0，提示‘用户名或密码错误’

MVC下的DAO接口类和SERVICE接口类区别？的更多相关文章

  1. 在网页中运用统计Web Service接口

    (2017-02-10 银河统计) 在"统计随机数及临界值Web Service接口"一文中介绍了常用统计分布四类Web Service接口(随机数.分位数.密度函数和累积分布函数 ...

  2. tomcat源码阅读之Server和Service接口解析

    tomcat中的服务器组件接口是Server接口,服务接口是Service,Server接口表示Catalina的整个servlet引擎,囊括了所有的组件,提供了一种优雅的方式来启动/关闭Catali ...

  3. DAO,Service接口与实现类设计

    DAO接口 为每个DAO声明接口的好处在于 1. 可以在尚未实现具体DAO的时候编写上层代码,如Service里对DAO的调用 2. 可以为DAO进行多实现,例如有JDBCDAO实现,MyBatisD ...

  4. Spring-mybatis没有了XXXmapper.java和Dao的实现类还有Service的实现类

    对于刚学过框架的同学可能知道,mybatis有两种主要的配置文件: SqlMapConfig.xml(mybatis全局配置文件,名称不固定,用来配置运行环境(数据源.事务) XXXmapper.xm ...

  5. AutoFac mvc和WebAPI 注册Service (接口和实现)

    AutoFac  mvc和WebAPI  注册Service (接口和实现) 1.准备组件版本:Autofac 3.5.0    Autofac.Integration.Mvc 3.3.0.0  (I ...

  6. Java web中为什么要用Service接口和DAO接口？

    面向接口:依赖倒转原理----使用service接口的原因是为了让表示层不依赖于业务层的具体实现,使用dao接口的原理也是如此,而且便于spring ioc容器,当修改dao层,时不需要修改servi ...

  7. [MyBatis]DAO层只写接口，不用写实现类

    团队开发一个项目,由老大架了一个框架,遇到了DAO层不用写接口了,我也是用了2次才记住这个事的,因为自己一直都是习惯于写DAO层的实现类,所以,习惯性的还是写了个实现类.于是遇到错误了. 找不到那个方 ...

  8. controller层负责创建类传递类给service；service层负责逻辑编写调用dao层 将编写后的类传递到dao层，保证事务的正确性；dao层负责数据的持久化

    controller层负责创建类传递类给service:service层负责逻辑编写调用dao层 将编写后的类传递到dao层,保证事务的正确性:dao层负责数据的持久化

  9. 项目中一个普通的Java类如何获取service接口（一）

    在普通的Java类中获取service接口目的是调用接口中的方法,实现数据的持久化等操作: Java类中的获取service接口方法: IfaceDetectService faceDetectSer ...

随机推荐

  1. Spring_Spring集成Quartz定时任务框架介绍和Cron表达式详解

    在JavaEE系统中,我们会经常用到定时任务,比如每天凌晨生成前天报表,每一小时生成汇总数据等等.我们可以使用java.util.Timer结合java.util.TimerTask来完成这项工作,但 ...

  2. 开发npm模块经验总结

    1.在windows下开发的package.json的bin链接的全局命令可能会在linux下报错:“没有那个文件或目录”之类的错误...此时可以在linux下用vim打开bin链接的js文件,设置s ...

  3. POJ 1470 Closest Common Ancestors （LCA，离线Tarjan算法）

    Closest Common Ancestors Time Limit: 2000MS   Memory Limit: 10000K Total Submissions: 13372   Accept ...

  4. 【Go入门教程4】变量（var），常量（const），内置基础类型（Boolean、数值 byte,int,rune、字符串、错误类型），分组，iota枚举，array（数值），slice（切片），map（字典），make/new操作，零值

    这小节我们将要介绍如何定义变量.常量.Go 内置类型以及 Go 程序设计中的一些技巧. 定义变量 Go 语言里面定义变量有多种方式. 使用 var 关键字是 Go 最基本的定义变量方式,与 C 语言不 ...

  5. Oracle手工生成段建议（Segment Advisor）

    一.描写叙述 从oracle 10g開始,oracle引入了段顾问(Segment Advisor),用于检查数据库中是否有与存储空间相关的建议,而且从10gR2開始,oracle自己主动调度并执行一 ...

  6. Python之定义可变参数

    如果想让一个函数能接受任意个参数,我们就可以定义一个可变参数: def fn(*args):    print args 可变参数的名字前面有个 * 号,我们可以传入0个.1个或多个参数给可变参数: ...

  7. Android定制争夺战 三大主流ROM横评

    随着MIUI在广大“机油”们心目中位置的逐渐攀升,越来越多的厂商也相继推出了属于自己的定制Android ROM,想以此来抢占这一新兴市场,像点心OS.腾讯的Tita以及近期比较热门的百度云ROM等等 ...

  8. EasyUI相同的Tab只打开一个（即EasyUI方法的调用方法）

    function addTabA(title){ if ($('#tt').tabs('exists', title)){ $('#tt').tabs('select', title); } else ...

  9. Go 语言简介（上）— 语法

    周末天气不好,只能宅在家里,于是就顺便看了一下Go语言,觉得比较有意思,所以写篇文章介绍一下.我想写一篇你可以在乘坐地铁或公交车上下班时就可以初步了解一门语言的文章.所以,下面的文章主要是以代码和注释 ...

  10. 在Ubuntu 12.04 桌面上设置启动器（快捷方式）

    在Ubuntu 12.04 桌面上设置启动器(快捷方式)过程讲解: 如下图所示,Eclipse 和 SQLDeveloper 都可以直接双击打开,这些应用程序的启动器都在 /usr/share/app ...