MVC 三层架构案例详细讲解

MVC 三层架构案例详细讲解


@
目录

• MVC 三层架构案例详细讲解
  
  
  
  • 每博一文案
    
  • 1. MVC 概述
    
  • 2. MVC设计思想
    
  • 3. 三层架构
    
  • 4. MVC 与 三层架构的关系：
    
  • 5. 案例举例：用户账户转账
    
    
    
    • 5.1 M（Model ：数据/业务处理层）
      
    • 5.2 C (Controller : 控制层)
      
    • 5.3 V (View ：视图/展示)
      
    
    
  • 6. 总结:
    
  • 7. 最后:
    
  
  

每博一文案

1. 多读书，书中有，你对生活，困难所解不开的答案
2. 比如：《杀死一只是更鸟》中提到的
3. 对应我们：我们努力中考,高考,升本，考研，每天都在努力学习，但是某天突然想到万一没有考上的话，那现在的努力又有什么意义呢？
4. 答案：在《杀死一只是更鸟》里有这样一段话：
5. > 勇敢是，当你还未开始，你就知道自己会输，可你依然要去做，而且无论如何都要把它坚持到底，你很少能赢，但有时也会。努力的这个过程本身就是有意义，能够获得理想的结果当然很好，但如果失败了也没关系。因为你的勇敢，从未辜负你的青春，而黎明的光亮，总有一刻，会照亮穿梭于黑暗之中的自己。况且，你还不一定会输呢。

复制代码

1. MVC 概述

MVC开始是存在于桌面程序中的，M是指业务模型，V是指用户界面，C则是控制器，使用MVC的目的是将M和V的实现代码分离，从而使同一个程序可以使用不同的表现形式。比如一批统计数据可以分别用柱状图、饼图来表示。C存在的目的则是确保M和V的同步，一旦M改变，V应该同步更新。 [1-2]
模型－视图－控制器（MVC）是[Xerox PARC](https://baike.baidu.com/item/Xerox PARC/10693263?fromModule=lemma_inlink)在二十世纪八十年代为编程语言Smalltalk－80发明的一种软件设计模式，已被广泛使用。后来被推荐为Oracle旗下Sun公司[Java EE](https://baike.baidu.com/item/Java EE/2180381?fromModule=lemma_inlink)平台的设计模式，并且受到越来越多的使用ColdFusion和PHP的开发者的欢迎。模型－视图－控制器模式是一个有用的工具箱，它有很多好处，但也有一些缺点。
2. MVC设计思想

MVC（Model View Controller）是软件工程中的一种软件架构模式，它把软件系统分为模型、视图和控制器三个基本部分。用一种业务逻辑、数据、界面显示分离的方法组织代码，将业务逻辑聚集到一个部件里面，在改进和个性化定制界面及用户交互的同时，不需要重新编写业务逻辑。

MVC 主要的核心就是：分层：希望专人干专事，各司其职，职能分工要明确，这样可以让代码耦合度降低，扩展力增强，组件的可复用性增强。
MVC 从字面意思我们就可以看到：是分为了三层的，M(Mode 模型)，V(View 视图),C(Controller 控制器)

M即model模型：是指模型表示业务规则。在MVC的三个部件中，模型拥有最多的处理任务。被模型返回的数据是中立的，模型与数据格式无关，这样一个模型能为多个视图提供数据，由于应用于模型的代码只需写一次就可以被多个视图重用，所以减少了代码的重复性。
V即View视图：是指用户看到并与之交互的界面。比如由html元素组成的网页界面，或者软件的客户端界面。MVC的好处之一在于它能为应用程序处理很多不同的视图。在视图中其实没有真正的处理发生，它只是作为一种输出数据并允许用户操作的方式。
C即controller控制器：是指控制器接受用户的输入并调用模型和视图去完成用户的需求，控制器本身不输出任何东西和做任何处理。它只是接收请求并决定调用哪个模型构件去处理请求，然后再确定用哪个视图来显示返回的数据。
M(Model ：数据/业务) V (View ：视图/展示) C (Controller : 控制层)
C(是核心，是控制器，是司令官)
M（处理业务/处理数据的一个秘书）
V（负责页面展示的一个秘书）
MVC(一个司令官，调度两个秘书，去做这件事)，仅仅只做事务上的调度，而不做其他的操作


优点：

• 耦合性低，方便维护，可以利于分工协作
  
• 重用性高
  

缺点：

• 使得项目架构变得复杂，对开发人员要求高
  

3. 三层架构

三层架构(3-tier architecture) 通常意义上的三层架构就是将整个业务应用划分为：界面层[表示层]（User Interface layer）、业务逻辑层（Business Logic Layer）、数据访问层（Data access layer）。
区分层次的目的即为了“高内聚低耦合” 的思想。在软件体系架构设计中，分层式结构是最常见，也是最重要的一种结构。



三层架构每层之间的逻辑关系：

三层架构的优点

• 开发人员可以只关注整个结构中的其中某一层；
  
• 可维护性高，可扩展性高
  
• 可以降低层与层之间的依赖；
  
• 有利于标准化；
  
• 利于各层逻辑的复用
  

三层架构的缺点：

• 降低了系统的性能。如果不采用分层式结构，很多业务可以直接造访数据库，以此获取相应的数据，如今却必须通过中间层来完成
  
• 有时会导致级联的修改，这种修改尤其体现在自上而下的方向。如果在表示层中需要增加一个功能，为保证其设计符合分层式结构，可能需要在相应的业务逻辑层和数据访问层中都增加相应的代码
  
• 增加了开发成本
  

4. MVC 与 三层架构的关系：

MVC的也可以被说成是 MVC三层架构，说白了，它们其实都是一个东西，只是在一些细节上有稍微的不同，大致设计思想都是一样的：“高内聚，低耦合”。

其实，无论是MVC还是三层架构，都是一种规范，都是奔着"高内聚，低耦合"的思想来设计的。三层中的UI和Servlet来分别对应MVC中的View和Controller，业务逻辑层是来组合数据访问层的原子性功能的。
5. 案例举例：用户账户转账

如下我们，实现一个用户账户转账操作的一个案例：
准备工作：创建表，创建数据

1. CREATE DATABASE mvc;
3. USE mvc;
5. SHOW TABLES;
7. CREATE TABLE t_act (
8.    id BIGINT PRIMARY KEY AUTO_INCREMENT,
9.    actno VARCHAR(255) NOT NULL,
10.    balance DECIMAL(10,2)
11. );
15. INSERT INTO t_act(actno,balance)
16. VALUES('act001',50000.00),('act002',0.00);
18. SELECT *
19. FROM t_act;

复制代码

5.1 M（Model ：数据/业务处理层）

javaBean :Account 封装数据
账户实体类，封装账户信息的

• 一般是一张表一个。
  
• pojo 对象
  
• 有的人也会把这种专门封装数据的对象，称为："bean对象" (javabean对象，咖啡豆)
  
• 有的人也会把这种专门封装数据的对象，称为领域模型对象，domain对象
  
• 不同的程序员不同的习惯
  

1. package com.RainbowSea.bank.mvc;
3. import java.io.Serializable;
4. import java.util.Objects;
7. /**
8. * 账户实体类，封装账户信息的
9. * 一般是一张表一个。
10. * pojo 对象
11. * 有的人也会把这种专门封装数据的对象，称为："bean对象" (javabean对象，咖啡豆)
12. * 有的人也会把这种专门封装数据的对象，称为领域模型对象，domain对象
13. * 不同的程序员不同的习惯。
14. */
15. public class Account implements Serializable {  // 这种普通的简单的对象被成为pojo对象
16.     // 注意我们这里定义的数据类型，使用引用数据类型
17.     // 因为我们数据库中可能存在 null 值，而基本数据类型是不可以存储 null值的
19.     private Long id = null;  // id
20.     private String actno;  // 账号
21.     private Double balance; // 余额
23.     // 反序列化
24.     private static final long serialVersionUID = 1L;
26.     public Account() {
27.     }
30.     public Account(Long id, String actno, Double balance) {
31.         this.id = id;
32.         this.actno = actno;
33.         this.balance = balance;
34.     }
37.     public Long getId() {
38.         return id;
39.     }
41.     public void setId(Long id) {
42.         this.id = id;
43.     }
45.     public String getActno() {
46.         return actno;
47.     }
49.     public void setActno(String actno) {
50.         this.actno = actno;
51.     }
53.     public Double getBalance() {
54.         return balance;
55.     }
57.     public void setBalance(Double balance) {
58.         this.balance = balance;
59.     }
61.     @Override
62.     public boolean equals(Object o) {
63.         if (this == o) return true;
64.         if (!(o instanceof Account)) return false;
65.         Account account = (Account) o;
66.         return Objects.equals(getId(), account.getId()) && Objects.equals(getActno(), account.getActno()) && Objects.equals(getBalance(), account.getBalance());
67.     }
69.     @Override
70.     public int hashCode() {
71.         return Objects.hash(getId(), getActno(), getBalance());
72.     }
74.     @Override
75.     public String toString() {
76.         return "Account{" +
77.                 "id=" + id +
78.                 ", actno='" + actno + '\'' +
79.                 ", balance=" + balance +
80.                 '}';
81.     }
82. }

复制代码

DB连接数据库的工具：

1. driver=com.mysql.jdbc.Driver
2. url=jdbc:mysql://localhost:3306/mvc
3. user=root
4. password=MySQL

复制代码

1. package com.RainbowSea.bank.utils;
4. import java.sql.Connection;
5. import java.sql.DriverManager;
6. import java.sql.PreparedStatement;
7. import java.sql.ResultSet;
8. import java.sql.SQLException;
9. import java.util.ResourceBundle;
11. public class DBUtil {
13.     // resourceBundle 只能读取到 properties 后缀的文件，注意不要加文件后缀名
14.     private static ResourceBundle resourceBundle = ResourceBundle.getBundle("resources/jdbc");
15.     private static String driver = resourceBundle.getString("driver");
16.     private static String url = resourceBundle.getString("url");
17.     private static String user = resourceBundle.getString("user");
18.     private static String password = resourceBundle.getString("password");
21.     // DBUtil 类加载注册驱动
22.     static {
23.         try {
24.             Class.forName(driver);
25.         } catch (ClassNotFoundException e) {
26.            e.printStackTrace();
27.         }
29.     }
32.     // 将构造器私有化，不让创建对象，因为工具类中的方法都是静态的，不需要创建对象
33.     // 为了防止创建对象，故将构造方法私有化
34.     private DBUtil() {
36.     }
38.     /**
39.      * 这里没有使用数据库连接池，直接创建连接对象
40.      */
41.     public static Connection getConnection()  {
42.         Connection connection = null;
43.         try {
44.             connection = DriverManager.getConnection(url, user, password);
45.         } catch (SQLException e) {
46.             throw new RuntimeException(e);
47.         }
48.         return  connection;
49.     }
52.     /**
53.      * 资源的关闭
54.      * 最后使用的最先关闭，逐个关闭，防止存在没有关闭的
55.      */
56.     public static void close(Connection connection , PreparedStatement preparedStatement, ResultSet resultSet) {
58.         if (resultSet != null) {
59.             try {
60.                 resultSet.close();
61.             } catch (SQLException e) {
62.                 throw new RuntimeException(e);
63.             }
64.         }
67.         if (preparedStatement!=null) {
68.             try {
69.                 preparedStatement.close();
70.             } catch (SQLException e) {
71.                 throw new RuntimeException(e);
72.             }
73.         }
76.         if (connection != null) {
77.             try {
78.                 connection.close();
79.             } catch (SQLException e) {
80.                 throw new RuntimeException(e);
81.             }
82.         }
83.     }
84. }

复制代码

对应Account数据表的DAO操作工具类
AccountDao 是负责Account 数据的增上改查
什么是DAO ？

• Data Access Object （数据访问对象）
  
• DAO实际上是一种设计模式，属于 JavaEE的设计模式之一，不是 23种设计模式
  
• DAO只负责数据库表的CRUD ,没有任何业务逻辑在里面
  
• 没有任何业务逻辑，只负责表中数据增上改查的对象，有一个特俗的称谓：DAO对象
  

为什么叫做 AccountDao 呢？

• 这是因为DAO是专门处理t_act 这张表的
  
• 如果处理t_act 表的话，可以叫做：UserDao
  
• 如果处理t-student表的话，可以叫做 StudentDao
  

主要定义如下：增删改查方法（）

1. int insert() ;
2. int deleteByActno();
3. int update() ;
4. Account selectByActno();
5. List<Account> selectAll();

复制代码

1. package com.RainbowSea.bank.mvc;
4. import com.RainbowSea.bank.utils.DBUtil;
6. import java.sql.Connection;
7. import java.sql.PreparedStatement;
8. import java.sql.ResultSet;
9. import java.sql.SQLException;
10. import java.util.Collection;
11. import java.util.List;
13. /**
14. * AccountDao 是负责Account 数据的增上改查
15. * <p>
16. * 1. 什么是DAO ？
17. * Data Access Object （数据访问对象）
18. * 2. DAO实际上是一种设计模式，属于 JavaEE的设计模式之一，不是 23种设计模式
19. * 3.DAO只负责数据库表的CRUD ,没有任何业务逻辑在里面
20. * 4.没有任何业务逻辑，只负责表中数据增上改查的对象，有一个特俗的称谓：DAO对象
21. * 5. 为什么叫做 AccountDao 呢？
22. * 这是因为DAO是专门处理t_act 这张表的
23. * 如果处理t_act 表的话，可以叫做：UserDao
24. * 如果处理t-student表的话，可以叫做 StudentDao
25. * <p>
26. * int insert() ;
27. * int deleteByActno();
28. * int update() ;
29. * Account selectByActno();
30. * List<Account> selectAll();
31. */
32. public class AccountDao {
35.     /**
36.      * 插入数据
37.      *
38.      * @param account
39.      * @return
40.      */
41.     public int insert(Account account) {
42.         Connection connection = DBUtil.getConnection();
43.         PreparedStatement preparedStatement = null;
44.         int count = 0;
45.         try {
46.             String sql = "insert into t_act(actno,balance) values(?,?)";
47.             preparedStatement = connection.prepareStatement(sql);
48.             preparedStatement.setString(1, account.getActno());
49.             preparedStatement.setDouble(2, account.getBalance());
50.             count = preparedStatement.executeUpdate();
53.         } catch (SQLException e) {
54.             throw new RuntimeException(e);
55.         } finally {
56.             DBUtil.close(connection, preparedStatement, null);
57.         }
60.         return count;
62.     }
65.     /**
66.      * 通过Id删除数据
67.      *
68.      * @param id
69.      * @return
70.      */
71.     public int deleteById(String id) {
72.         Connection connection = DBUtil.getConnection();
73.         int count = 0;
74.         PreparedStatement preparedStatement = null;
75.         try {
76.             String sql = "delete from t_act where id = ?";
77.             preparedStatement = connection.prepareStatement(sql);
78.             preparedStatement.setString(1, id);
79.             count = preparedStatement.executeUpdate();
80.         } catch (SQLException e) {
81.             throw new RuntimeException(e);
82.         } finally {
83.             DBUtil.close(connection, preparedStatement, null);
84.         }
86.         return count;
88.     }
91.     /**
92.      * 更新数据
93.      *
94.      * @param account
95.      * @return
96.      */
97.     public int update(Account account) {
98.         Connection connection = DBUtil.getConnection();
99.         PreparedStatement preparedStatement = null;
100.         int count = 0;
102.         try {
103.             String sql = "update t_act set balance = ?, actno = ? where id = ?";
104.             preparedStatement = connection.prepareStatement(sql);
106.             //注意设置的 set类型要保持一致。
107.             preparedStatement.setDouble(1, account.getBalance());
108.             preparedStatement.setString(2, account.getActno());
109.             preparedStatement.setLong(3, account.getId());
111.             count = preparedStatement.executeUpdate();
112.         } catch (SQLException e) {
113.             throw new RuntimeException(e);
114.         } finally {
115.             DBUtil.close(connection, preparedStatement, null);
116.         }
118.         return count;
119.     }
122.     /**
123.      * 通过 actno 查找账户信息
124.      *
125.      * @param actno
126.      * @return
127.      */
128.     public Account selectByActno(String actno) {
129.         Connection connection = DBUtil.getConnection();
130.         PreparedStatement preparedStatement = null;
131.         ResultSet resultSet = null;
132.         Account account = new Account();
134.         try {
135.             String sql = "select id,actno,balance from t_act where actno = ?";
136.             preparedStatement = connection.prepareStatement(sql);
138.             //注意设置的 set类型要保持一致。
139.             preparedStatement.setString(1, actno);
141.            resultSet = preparedStatement.executeQuery();
143.             if (resultSet.next()) {
144.                 Long id = resultSet.getLong("id");
145.                 Double balance = resultSet.getDouble("balance");
146.                 // 将结果集封装到java 对象中
147.                 account.setActno(actno);
148.                 account.setId(id);
149.                 account.setBalance(balance);
151.             }
153.         } catch (SQLException e) {
154.             throw new RuntimeException(e);
155.         } finally {
156.             DBUtil.close(connection, preparedStatement, resultSet);
157.         }
159.         return account;
160.     }
163.     /**
164.      * 查询所有的账户信息
165.      *
166.      * @return
167.      */
168.     public List<Account> selectAll() {
169.         Connection connection = DBUtil.getConnection();
170.         PreparedStatement preparedStatement = null;
171.         ResultSet resultSet = null;
172.         List<Account> list = null;
174.         try {
175.             String sql = "select id,actno,balance from t_act";
176.             preparedStatement = connection.prepareStatement(sql);
178.             resultSet = preparedStatement.executeQuery();
180.             while (resultSet.next()) {
181.                 String actno = resultSet.getString("actno");
182.                 Long id = resultSet.getLong("id");
183.                 Double balance = resultSet.getDouble("balance");
184.                 // 将结果集封装到java 对象中
185.                 Account account = new Account(id,actno,balance);
187.                 // 添加到List集合当中
188.                 list.add(account);
190.             }
192.         } catch (SQLException e) {
193.             throw new RuntimeException(e);
194.         } finally {
195.             DBUtil.close(connection, preparedStatement, resultSet);
196.         }
198.         return list;
199.     }
202. }

复制代码

对指定的数据表的数据进行service 业务逻辑处理操作：
service 翻译为：业务。

• AccountService 专门处理Account业务的一个类
  
• 在该类中应该编写纯业务代码。（只专注域业务处理，不写别的，不和其他代码混合在一块）
  
• 只希望专注业务，能够将业务完美实现，少量bug.
  
• 业务类一般起名：XXXService,XXXBiz...
  

1. package com.RainbowSea.bank.mvc;
4. /**
5. * service 翻译为：业务。
6. * AccountService 专门处理Account业务的一个类
7. * 在该类中应该编写纯业务代码。（只专注域业务处理，不写别的，不和其他代码混合在一块）
8. * 只希望专注业务，能够将业务完美实现，少量bug.
9. * <p>
10. * 业务类一般起名：XXXService,XXXBiz...
11. */
12. public class AccountService {
14.     // 这里的方法起名，一定要体现出，你要处理的是什么业务：
15.     // 我们要提供一个能够实现转账的业务的方法（一个业务对应一个方法）
16.     // 比如：UserService StudentService OrderService
18.     // 处理Account 转账业务的增删改查的Dao
19.     private AccountDao accountDao = new AccountDao();
21.     /**
22.      * 完成转账的业务逻辑
23.      *
24.      * @param fromActno 转出账号
25.      * @param toActno   转入账号
26.      * @param money     转账金额
27.      */
28.     public void transfer(String fromActno, String toActno, double money) throws MoneyNotEnoughException, AppException {
29.         // 查询余额是否充足
30.         Account fromAct = accountDao.selectByActno(fromActno);
31.         if (fromAct.getBalance() < money) {
32.             throw new MoneyNotEnoughException("对不起，余额不足");
33.         }
35.         // 程序到这里说明余额充足
36.         Account toAct = accountDao.selectByActno(toActno);
38.         // 修改金额,先从内存上修改，再从硬盘上修改
39.         fromAct.setBalance(fromAct.getBalance() - money);
40.         toAct.setBalance(toAct.getBalance() + money);
43.         // 从硬盘数据库上修改
44.         int count = accountDao.update(fromAct);
45.         count += accountDao.update(toAct);
47.         if(count != 2) {
48.             throw new AppException("账户转账异常，请联系管理员");
49.         }
51.     }
52. }

复制代码

异常处理类：

1. package com.RainbowSea.bank.mvc;
4. /**
5. * 余额不足异常
6. */
7. public class AppException extends Exception{
9.         public AppException() {
11.         }
13.         public AppException(String msg) {
14.             super(msg);
15.         }
17. }

复制代码

1. package com.RainbowSea.bank.mvc;
4. /**
5. * 余额不足异常
6. */
7. public class MoneyNotEnoughException extends Exception{
8.     public MoneyNotEnoughException() {
10.     }
12.     public MoneyNotEnoughException(String msg) {
13.         super(msg);
14.     }
15. }

复制代码

5.2 C (Controller : 控制层)

仅仅负责调度 M业务处理层，V视图显示层，而不做其他操作。

1. package com.RainbowSea.bank.mvc;
3. import jakarta.servlet.ServletException;
4. import jakarta.servlet.annotation.WebServlet;
5. import jakarta.servlet.http.HttpServlet;
6. import jakarta.servlet.http.HttpServletRequest;
7. import jakarta.servlet.http.HttpServletResponse;
9. import java.io.IOException;
12. /**
13. * 账户小程序
14. * AccountServlet 是一个司令官，他负责调度其他组件来完成任务。
15. *
16. */
17. @WebServlet("/transfer")
18. public class AccountServlet extends HttpServlet { // AccountServlet 作为一个 Controller 司令官
20.     @Override
21.     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException,
22.             IOException {
24.         // 获取数据
25.         String fromActno = request.getParameter("fromActno");
26.         String toActno = request.getParameter("toActno");
27.         double money = Double.parseDouble(request.getParameter("money"));
29.         // 调用业务方法处理业务（调度Model处理业务,其中是对应数据表的 CRUD操作）
30.         AccountService accountService = new AccountService();
31.         try {
32.             accountService.transfer(fromActno,toActno,money);
33.             // 执行到这里说明，成功了，
34.             // 展示处理结束(调度 View 做页面展示)
36.             response.sendRedirect(request.getContextPath()+"/success.jsp");
37.         } catch (MoneyNotEnoughException e) {
38.             // 执行到种类，说明失败了，（余额不足
39.             // 展示处理结束（调度 View 做页面展示）
40.             response.sendRedirect(request.getContextPath()+"/error.jsp");
42.         } catch (AppException e) {
43.             // 执行到种类，说明失败了，转账异常
44.             // 展示处理结束（调度 View 做页面展示）
45.             response.sendRedirect(request.getContextPath()+"/error.jsp");
47.         }
49.         // 页面的展示 （调度View做页面展示）
52.     }
53. }

复制代码

5.3 V (View ：视图/展示)

index.jsp 转账页面：

1. <%@ page contentType="text/html;charset=UTF-8" language="java" %>
2. <html>
3. <head>
4.   <title>银行账号转账</title>
5. </head>
6. <body>
7. <form action="<%=request.getContextPath()%>/transfer" method="post">
8.   转出账户: <input type="text" name="fromActno" />
   
10.   转入账户: <input type="text" name="toActno" />
    
12.   转账金额: <input type="text" name="money" />
    
14.   <input type="submit" value="转账" />
15. </form>
16. </body>
17. </html>

复制代码

success转账成功的页面显示：

1. <%@ page contentType="text/html;charset=UTF-8" language="java" %>
2. <html>
3. <head>
4.     <title>转账成功</title>
5. </head>
6. <body>
8. <h3>转账成功</h3>
9. </body>
10. </html>

复制代码

error 转账失败的页面显示：

1. <%@ page contentType="text/html;charset=UTF-8" language="java" %>
2. <html>
3. <head>
4.     <title>转账失败</title>
5. </head>
6. <body>
7. <h3>转账失败</h3>
8. </body>
9. </html>

复制代码

虽然上述：代码成功实现的了用户转账的操作，但是并没有进行事务的处理。

如下是运用 TreadLocal 进行事务的处理：
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！