java web中分层MVC的意义

在web编程中，由于高内聚、低耦合的特点，需要将多个类实现多层，大致有以下几层：
①entity，实体类，如user,role等，这些类里边包含了私有属性和公共的get、set方法这和数据库中的表相对应，更严格一些，包括字段的顺序和type都要保持一致。
②base，封装了基本的操作数据库的方法(增删改查)
③dao,访问并操作数据库，若想从数据库获取数据，必须调用dao层。dao层没有一点业务逻辑，全是跟数据库操作有关的类
④service，业务逻辑层，里边可以是接口。只要没有访问数据库的操作，都写到service层中。

举个例子说明什么是业务。如做一个分页功能，数据1000条，每页20条，则可以把这个功能写成工具类封装起来，然后在业务层调用这个封装的方法，这才是业务层要做的事。

service层和dao层有什么区别？
再举个例子，如注册用户时，还想往日志表里添加一个日志，那么就要在业务层来实现这个操作，并对该操作添加事务，效果会更好。若不使用service，只用dao的话，那么就要连续使用userDao和logDao，那么万一某一步出错，就可能造成user加进去而log没有添加成功。

⑤action,也就是原来的servlet,位于jsp和service层之间进行交互。主要的操作就是请求(request)和响应(response)。存取某个功能的整体实现方法。

以后不要在servlet中调用dao层，而要写到serviceImpl(对接口的实现层)中，如以前的userServlet中有
private UserDao udao = new UserDaoImpl();//private必须写
以后这一句要写到UserServiceImpl内。

⑥vo，数据传输层，用来转入转出数据，跟前台有关。
⑦util,工具类，用来封装一些公用的方法，如字符串的处理，字符集过滤等。

⑧impl，用来实现接口。一个接口可以有多种实现，用来满足不同需要。

一般的调用情况如下：

贴一张很重要的图，大致说明了各层的继承和implements关系

举一个小项目的例子，实现往数据库增删改查用户。缩略图如下：

其中User.java和UserVO.java现在看起来内容相同，区别在于User类是底层数据，一般不轻易改变。UserVO层业余数据库中内容相对应，将DB中检索出数据，或者要往DB中反映的数据保存在vo实例中。以后若想再有什么扩展，直接在VO层改就行，不用动底层代码。

这里边，UserDao,BaseDao,UserService都是接口类，相应的impl则是对其的实现。

1.BaseDao代码：

1. import java.util.List;
2. /**
3. * 基本的方法
4. * @author Administrator
5. *
6. */
7. public interface BaseDao<Entity> {
8. /**
9. * 保存
10. * @param obj
11. * @throws Exception
12. */
13. void save(Entity entity) throws Exception;
14. /**
15. * 删除
16. * @param id
17. * @throws Exception
18. */
19. void delete(int id) throws Exception;
20. /**
21. * 更新
22. * @param obj
23. * @throws Exception
24. */
25. void update(Entity entity) throws Exception ;
26. /**
27. * 根据id查询指定记录
28. * @param id
29. * @return
30. * @throws Exception
31. */
32. Entity findById(int id) throws Exception;
33. /**
34. * 查询所有记录
35. * @return
36. * @throws Exception
37. */
38. List<Entity> findAll() throws Exception;
39. }

2.BaseDaoImpl代码，利用反射获取数据库数据

1. import java.lang.reflect.Field;
2. import java.lang.reflect.Method;
3. import java.lang.reflect.ParameterizedType;
4. import java.sql.Connection;
5. import java.sql.PreparedStatement;
6. import java.sql.ResultSet;
7. import java.util.ArrayList;
8. import java.util.List;
9. import com.bjsxt.util.DBUtil;
10. public class BaseDaoImpl<Entity> implements BaseDao<Entity> {
11. protected Class clazz;
12. public BaseDaoImpl(){
13. ParameterizedType pz = (ParameterizedType) this.getClass().getGenericSuperclass();
14. //利用反射返回当前类的父类的类型，并强制转换
15. clazz = (Class) pz.getActualTypeArguments()[0];
16. //返回此类型实际类型参数的Type对象数组的第一个
17. //这两步的作用就是获取父类泛型参数的实际类型
18. System.out.println(clazz + "这是测试代码，打印出来的");
19. }
20. @Override
21. public void save(Entity entity) throws Exception {
22. Connection conn = DBUtil.getConn();//连接数据库
23. String sql = "insert into " + clazz.getSimpleName() + " values(null";
24. Field[] fs = clazz.getDeclaredFields();
25. for (int i = 0; i < fs.length; i++) {
26. sql += ",?";
27. }
28. sql = sql + ")";
29. PreparedStatement ps = DBUtil.getPs(conn, sql);
30. //user.setUsername(rs.getString("username"));
31. for (int i = 0; i < fs.length; i++) {
32. String methodName = "get" + Character.toUpperCase(fs[i].getName().charAt(0)) + fs[i].getName().substring(1);
33. //假如有个实体user类，含有uname属性，则获取uname的方法默认会为getUname(),会将uname的首字母大写，其余不变
34. //Character.toUpperCase就是将字符大写，然后将除首字母以外的截取出来，拼到一起，构成类似于getUname()的方法
35. //user.setUsername(uForm.getUsername);
36. //该处用get是因为要把对象保存进数据库里，用get获取属性
37. Method m = clazz.getDeclaredMethod(methodName);
38. ps.setObject(i,m.invoke(entity));
39. //setObject用来给"?"赋值。invoke则是在不知道具体类的情况下利用字符串去调用方法
40. //正常情况下是user.getUsername,m.invoke(entity)中m是一个方法，类似于getUsername()，entity相当于user.
41. //invoke是从实体里边找方法，那句话的意思就是从实体里边调用方法
42. }
43. ps.executeUpdate();
44. DBUtil.close(ps);
45. DBUtil.close(conn);
46. }
47. @Override
48. public void view(Entity entity) throws Exception {
49. // TODO Auto-generated method stub
50. }
51. @Override
52. public void update(Entity entity) throws Exception {
53. Connection conn = DBUtil.getConn();
54. String sql = "update " + clazz.getSimpleName() + "set";
55. Field[] fs = clazz.getDeclaredFields();
56. for (int i = 0; i < fs.length; i++) {
57. sql += fs[i].getName() + " = ?,";
58. }
59. sql = sql.substring(0,sql.length()-1) + " where id = ?"; //减去最后的逗号
60. PreparedStatement ps = DBUtil.getPs(conn, sql);
61. for (int i = 0; i < fs.length; i++) {
62. String methodName = "get" + Character.toUpperCase(fs[i].getName().charAt(0)) + fs[i].getName().substring(1);
63. Method m = clazz.getDeclaredMethod(methodName);
64. ps.setObject(i, m.invoke(entity));
65. }
66. Method getId = clazz.getDeclaredMethod("getId");//更新需要知道id
67. ps.setInt(fs.length, (Integer) getId.invoke(entity));//因为id在sql语句最后一个问号处，所以要用fs.length
68. ps.executeUpdate();
69. DBUtil.close(ps);
70. DBUtil.close(conn);
71. }
72. @Override
73. public void delete(int id) throws Exception {
74. Connection conn = DBUtil.getConn();
75. String sql = "delete from " + clazz.getSimpleName() + " where id = ?" + id;
76. PreparedStatement ps = DBUtil.getPs(conn, sql);
77. ps.executeUpdate();
78. DBUtil.close(ps);
79. DBUtil.close(conn);
80. }
81. @Override
82. public Entity findById(int id) throws Exception {
83. Connection conn = DBUtil.getConn();
84. String sql = "select * from " + clazz.getSimpleName() + " where id= ? ";
85. PreparedStatement ps = DBUtil.getPs(conn, sql);
86. ps.setInt(1,id);
87. ResultSet rs = ps.executeQuery();
88. Entity entity = (Entity) clazz.newInstance();//利用无参构造函数新建实例
89. Field[] fs = clazz.getDeclaredFields();
90. if(rs.next()){
91. for (int i = 0; i < fs.length; i++) {
92. String methodName = "set" + Character.toUpperCase(fs[i].getName().charAt(0)) + fs[i].getName().substring(1);
93. Method m = clazz.getDeclaredMethod(methodName, fs[i].getType());
94. m.invoke(entity, rs.getObject(fs[i].getName()));
95. }
96. }
97. DBUtil.close(rs);
98. DBUtil.close(ps);
99. DBUtil.close(conn);
100. return entity;
101. }
102. @Override
103. public List<Entity> findAll() throws Exception {
104. Connection conn = DBUtil.getConn();
105. String sql = "select * from " + clazz.getSimpleName();
106. PreparedStatement ps = DBUtil.getPs(conn, sql);
107. ResultSet rs = ps.executeQuery();
108. List<Entity> enList = new ArrayList<Entity>();
109. while(rs.next()){
110. Entity en = (Entity) clazz.newInstance();
111. //user.setUsername(rs.getString("username"));
112. Field[] fs = clazz.getDeclaredFields();
113. for (int i = 0; i < fs.length; i++) {
114. String methodName = "set" + Character.toUpperCase(fs[i].getName().charAt(0)) + fs[i].getName().substring(1);
115. Method m = clazz.getDeclaredMethod(methodName, fs[i].getType());
116. m.invoke(en, rs.getObject(fs[i].getName()));
117. }
118. enList.add(en);
119. }
120. DBUtil.close(rs);
121. DBUtil.close(ps);
122. DBUtil.close(conn);
123. return enList;
124. }
125. }

注意：String methodName在何处用get，何处用set

3.UserDao代码

1. import java.util.List;
2. import com.bjsxt.base.BaseDao;
3. import com.bjsxt.entity.User;
4. public interface UserDao  extends BaseDao<User>{
5. List<User> findByPageList(int currentPage, int pageSize) throws Exception;
6. Long getTotal() throws Exception;
7. }

4.UserDaoImpl代码

1. import java.sql.Connection;
2. import java.sql.PreparedStatement;
3. import java.sql.ResultSet;
4. import java.util.ArrayList;
5. import java.util.List;
6. import sun.nio.cs.US_ASCII;
7. import com.bjsxt.base.BaseDaoImpl;
8. import com.bjsxt.dao.UserDao;
9. import com.bjsxt.entity.User;
10. import com.bjsxt.util.DBUtils;
11. public class UserDaoImpl extends BaseDaoImpl<User> implements UserDao{
12. @Override
13. public List<User> findByPageList(int currentPage, int pageSize)
14. throws Exception {
15. Connection conn = DBUtils.getConn();
16. String sql = "select * from user limit " + (currentPage-1)*pageSize + "," +pageSize;
17. PreparedStatement ps = DBUtils.getPs(conn, sql);
18. ResultSet rs = ps.executeQuery();
19. List<User> userlist =new ArrayList<User>();
20. while(rs.next()){
21. User user = new User();
22. user.setId(rs.getInt("id"));
23. user.setUsername(rs.getString("username"));
24. user.setPassword(rs.getString("password"));
25. user.setAge(rs.getInt("age"));
26. user.setSex(rs.getString("sex"));
27. user.setBirthday(rs.getString("birthday"));
28. user.setSalary(rs.getString("salary"));
29. user.setDescription(rs.getString("description"));
30. userlist.add(user);
31. }
32. DBUtils.close(rs);
33. DBUtils.close(ps);
34. DBUtils.close(conn);
35. return userlist;
36. }
37. @Override
38. public Long getTotal() throws Exception {
39. Connection conn = DBUtils.getConn();
40. String sql = "select count(*) from user";
41. PreparedStatement ps = DBUtils.getPs(conn, sql);
42. ResultSet rs =ps.executeQuery();
43. if(rs.next()){
44. return ((Number)rs.getInt(1)).longValue();
45. }
46. return ((Number)0).longValue();
47. }
48. }

5.User代码，下边的UserVO先和它一样，就不贴了。

1. public class User {
2. private int id ;
3. private String username ;
4. private String password ;
5. private int age ;
6. private String sex ;
7. private String birthday ;
8. private String salary ;
9. private String description ;
10. public User() {
11. super();
12. // TODO Auto-generated constructor stub
13. }
14. public User(int id, String username, String password, int age, String sex,
15. String birthday, String salary, String description) {
16. super();
17. this.id = id;
18. this.username = username;
19. this.password = password;
20. this.age = age;
21. this.sex = sex;
22. this.birthday = birthday;
23. this.salary = salary;
24. this.description = description;
25. }
26. public int getId() {
27. return id;
28. }
29. public void setId(int id) {
30. this.id = id;
31. }
32. public String getUsername() {
33. return username;
34. }
35. public void setUsername(String username) {
36. this.username = username;
37. }
38. public String getPassword() {
39. return password;
40. }
41. public void setPassword(String password) {
42. this.password = password;
43. }
44. public int getAge() {
45. return age;
46. }
47. public void setAge(int age) {
48. this.age = age;
49. }
50. public String getSex() {
51. return sex;
52. }
53. public void setSex(String sex) {
54. this.sex = sex;
55. }
56. public String getBirthday() {
57. return birthday;
58. }
59. public void setBirthday(String birthday) {
60. this.birthday = birthday;
61. }
62. public String getSalary() {
63. return salary;
64. }
65. public void setSalary(String salary) {
66. this.salary = salary;
67. }
68. public String getDescription() {
69. return description;
70. }
71. public void setDescription(String description) {
72. this.description = description;
73. }
74. }

6.UserService代码，只提供接口，不实现任何方法，只让UserServiceImpl来实现

1. import java.util.List;
2. import com.bjsxt.util.DataGrid;
3. import com.bjsxt.vo.UserVO;
4. public interface UserService {
5. void saveUser(UserVO userVO) throws Exception ;
6. void deleteUser(int id) throws Exception ;
7. void updateUser(UserVO userVO) throws Exception ;
8. UserVO findById(int id) throws Exception ;
9. List<UserVO> findAll() throws Exception ;
10. DataGrid findByPage(int currentPage , int PageSize) throws Exception ;
11. }

7.UserServiceImpl代码，方法还没完全实现，只完成一种。

1. import java.nio.channels.DatagramChannel;
2. import java.util.ArrayList;
3. import java.util.Iterator;
4. import java.util.List;
5. import com.bjsxt.dao.UserDao;
6. import com.bjsxt.dao.impl.UserDaoImpl;
7. import com.bjsxt.entity.User;
8. import com.bjsxt.service.UserService;
9. import com.bjsxt.util.DataGrid;
10. import com.bjsxt.vo.UserVO;
11. public class UserServiceImpl implements UserService {
12. private UserDao userDao  = new UserDaoImpl();
13. @Override
14. public void saveUser(UserVO userVO) throws Exception {
15. }
16. @Override
17. public void deleteUser(int id) throws Exception {
18. }
19. @Override
20. public void updateUser(UserVO userVO) throws Exception {
21. }
22. @Override
23. public UserVO findById(int id) throws Exception {
24. return null;
25. }
26. @Override
27. public List<UserVO> findAll() throws Exception {
28. return null;
29. }
30. @Override
31. public DataGrid findByPage(int currentPage, int PageSize)
32. throws Exception {
33. List<UserVO> uservolist = new ArrayList<UserVO>();
34. List<User> userList = this.userDao.findByPageList(currentPage ,PageSize);
35. for (Iterator iterator = userList.iterator(); iterator.hasNext();) {
36. User user = (User) iterator.next();
37. UserVO uvo = new UserVO();
38. uvo.setId(user.getId());
39. uvo.setUsername(user.getUsername());
40. uvo.setPassword(user.getPassword());
41. uvo.setAge(user.getAge());
42. uvo.setBirthday(user.getBirthday());
43. uvo.setSalary(user.getSalary());
44. uvo.setSex(user.getSex());
45. uvo.setDescription(user.getDescription());
46. uservolist.add(uvo);
47. }
48. Long total = this.userDao.getTotal();
49. DataGrid datagrid = new DataGrid();
50. datagrid.setRows(uservolist);
51. datagrid.setTotal(total);
52. return datagrid;
53. }
54. }

8.DataGrid代码

1. import java.util.List;
2. public class DataGrid {
3. private Long total ;    //总记录数
4. private List rows  ;    //返回的数据条目
5. public Long getTotal() {
6. return total;
7. }
8. public void setTotal(Long total) {
9. this.total = total;
10. }
11. public List getRows() {
12. return rows;
13. }
14. public void setRows(List rows) {
15. this.rows = rows;
16. }
17. }

9.DBUtil代码

1. import java.sql.Connection;
2. import java.sql.DriverManager;
3. import java.sql.PreparedStatement;
4. import java.sql.ResultSet;
5. import java.sql.SQLException;
6. /**
7. * 链接数据库的
8. * @author Administrator
9. *
10. */
11. public class DBUtils {
12. /**
13. * 获得connection对象
14. * @return
15. */
16. public static  Connection getConn(){
17. Connection conn = null;
18. try {
19. Class.forName("com.mysql.jdbc.Driver");
20. conn = DriverManager.getConnection("jdbc:mysql://localhost/ext_001", "root", "root");
21. } catch (ClassNotFoundException e) {
22. e.printStackTrace();
23. } catch (SQLException e) {
24. // TODO Auto-generated catch block
25. e.printStackTrace();
26. }
27. return conn;
28. }
29. /**
30. * 预编译sql
31. * @param conn
32. * @param sql
33. * @return
34. */
35. public static PreparedStatement getPs(Connection conn , String sql){
36. PreparedStatement ps = null;
37. try {
38. ps = conn.prepareStatement(sql);
39. } catch (SQLException e) {
40. e.printStackTrace();
41. }
42. return ps;
43. }
44. /**
45. * 一系列关闭对象的close
46. * @param conn
47. */
48. public static void close(Connection conn){
49. if(conn != null){
50. try {
51. conn.close();
52. } catch (SQLException e) {
53. e.printStackTrace();
54. }
55. }
56. }
57. public static  void close(PreparedStatement ps){
58. if(ps != null){
59. try {
60. ps.close();
61. } catch (SQLException e) {
62. e.printStackTrace();
63. }
64. }
65. }
66. public static  void close(ResultSet rs){
67. if(rs != null){
68. try {
69. rs.close();
70. } catch (SQLException e) {
71. e.printStackTrace();
72. }
73. }
74. }
75. }

最后粘一篇百度知道上的内容，关于service层和dao层的，供参考。

首先，service层会很大，方法很多。 
第二，试想，所有DAO都有增删改查四个基本方法。假设在DAO层（如StudentDAO.java）里student.add(),student.delete().student.update(),student.query()。
而如果应用增加了service层（如ApplictionServiceImpl.java），需要在service层中加上 
applicationService.addStudent(),deleteStudent(),updateStudent(),queryStudent()四个方法。
这时你需要更新service层的接口类ApplicationService.Java，加上这四个方法。然后再更新service层的实现类ApplicationServiceImpl，加上这四个方法，最后你发现这四个方法每个方法里都只有一句话（以addStudent()为例）
public int addStudent(Student student){ 
    return student.add(); 
} 
这样是不是太傻了点，还不如在action中直接调用StudentDAO中的student.add()。 
以上是我的个人看法，请各位指点

这么来讲好了 按你所说 在action中直接调用StudentDAO中的student.add()。 现在有客户A 客户B

客户A的需求是 addStudent 这个和你所说的情况一致

客户B的需求是 addStudent 前去加一个动作 将学生父母的信息也插入数据库

这时如果按照只调用DAO的方法的话，你需要从新建立一个action 
CustomerBAction 
再重新写一个DAO 因为这个DAO里要有添加父母的方法 student.addStudentAndParentInfo()。

CustomerBAction 去调用 student.addStudentAndParentInfo()。

这样加大了很多工作量

如果中间有service层的话 action始终用一个action
而调用的也是service接口 只要对接口注入不同的实现就可以满足 不同客户的需求了

知识要活学活用，要按照自己项目以后的发展趋势来搭设环境，别人家说什么就用什么。其实有时候javabean+jsp 也很好用啊，因为jsp不用重启服务 开发速度很快。我做小项目就是这种模式，以后小项目的更改也会很少，所以不用搭建的过于复杂。

补充：

entity和vo的不同还可以通过下边这个例子说明。如有user.java和userVO.java
user的属性为

1. private int id ;
2. private String username ;
3. private String password ;

而userVO的属性则可为：

1. private int id ;
2. private String username ;
3. private String password1 ;  //第一次输入密码
4. private String password2 ;  //确认密码

在表单验证时，password1和password2相同时才会被提交。这样不用改entity类，只需修改vo层即可。当然，这里的password1和password2也得写上get和set方法。