MVC

MVC指：Model模型、View视图、Controller控件器。

其中，各自的功能为：

View视图：为用户提供使用界面，与用户直接进行交互。

Model模型：承载数据，并对用户提交请求进行计算的模块。其分为两类，一类称为数据承载Bean，一类称为业务处理Bean。所谓数据承载Bean是指实体类，专门承载业务数据的，如Student、User等。而业务处理Bean则是指Service或Dao对象，专门用于处理用户提交请求的。

Controller控制器：用于将yoghurt请求转发给相应的Model进行处理，并处理Model的计算结果向用户提供相应响应。

MVC架构程序的工作流程：

（1）用户通过View页面向服务器端提出请求，可以是表单请求、超链接请求、AJAX请求等。

（2）服务端Controller控制器接收到请求后对请求进行解析，找到相应的Model对用户请求进行处理。

（3）Model处理后，将处理结果再交给Controller。

（4）Controller在接到处理结果后，根据处理结构找到要作为向客户端发回的View页面。页面经渲染（数据填充）后，再发送给客户端。

springmvc 中dao层和service层的区别

这个知识点转载自：

http://blog.csdn.net/dopamy_busymonkey/article/details/51422392

service是业务层，dao是数据访问层。

小白：在service里直接调用dao，service里面就new一个dao类对象，调用。

标准主流现在的编程方式都是采用MVC综合设计模式，MVC本身不属于设计模式的一种，它描述的是一种结构，最终目的达到解耦，解耦说的意思是你更改某一层代码，不会影响我其他层代码，如果你会像spring这样的框架，你会了解面向接口编程，表示层调用控制层，控制层调用业务层，业务层调用数据访问层。初期也许都是new对象去调用下一层，比如你在业务层new一个DAO类的对象，调用DAO类方法访问数据库，这样写是不对的，因为在业务层中是不应该含有具体对象，最多只能有引用，如果有具体对象存在，就耦合了。当那个对象不存在，我还要修改业务的代码，这不符合逻辑。好比主板上内存坏了，我换内存，没必要连主板一起换。我不用知道内存是哪家生产，不用知道多大容量，只要是内存都可以插上这个接口使用。这就是MVC的意义。

关于MVC与三层架构的解析学习参照之前转的博客：

http://blog.csdn.net/an1090239782/article/details/72804908

项目实践

以下就是实战，利用MVC设计模式场景，实现一个小的登录功能。

项目目录：

项目实现流程：

1：首先进入登录页面，输入用户名和密码。

2：将用户名和密码通过form表单提交给Controller进行操作，调研Javabean将数据传至接口LoginServiceImpl中。

3：在LoginServiceImpl中，该类实现接口LoginDaoImpl中的login方法。并将数据传至UserDaoImpl接口。

4：在UserDaoImpl接口实现对数据的相关操作，根据数据结果进行相关判断及使用。其中UserDaoImpl实现接口UserDao。

5：UserDao接口定义查询方法，查询数据库中是否存在该用户。

Login.jsp——>LoginServelet—–>LoginServiceImpl—–>UserDao—–>UserDaoImp。

JSP登录页面（View层）

JSP登录页面:

在登录页面填写用户名和密码，通过form表单提交请求给Login.action。

  1. <body>
  2.     <form action="login.action">
  3.         用户名：<input type="text" name="uname" value="${param.uname }"><br/>
  4.         密码：<input type="password" name="pwd" value="${param.pwd }"><br/>
  5.         <input type="submit" value="登录"><br/>
  6.         <span style="color: red;">${requestScope.error }</span>
  7.     </form>
  8.     <a href="register.jsp">没有账号，立即注册</a>
  9.   </body>

LoginServlet.java（Controller控制层）

通过登录页面将数据传至LoginServlet,java。

通过注解配置LoginServlet.java。

  1. @WebServlet(value="/login.action")

LoginServlet.java实现代码：

  1. @WebServlet(value="/login.action")
  2. public class LoginServlet extends HttpServlet {
  4.     private LoginService service;
  6.     public void doGet(HttpServletRequest request, HttpServletResponse response)
  7.             throws ServletException, IOException {
  8.         doPost(request, response);
  9.     }
  11.     public void doPost(HttpServletRequest request, HttpServletResponse response)
  12.             throws ServletException, IOException {
  13.         String uname=request.getParameter("uname");
  14.         String pwd=request.getParameter("pwd");
  15.         //调用javabean
  16.         service=new LoginServiceImpl();
  17.         User user=service.login(uname, pwd);
  18.         //跳转jsp
  19.         if(user!=null) {
  20.             request.getSession().setAttribute("user", user);
  21.             response.sendRedirect("welcome.jsp");
  22.         } else {
  23.             request.setAttribute("error", "登录失败请重新输入");
  24.             request.getRequestDispatcher("login.jsp").forward(request, response);
  25.         }
  26.     }
  27. }

LoginServiceImpl.java（实现接口LoginService）

LoginServiceImpl.java实现代码：

  1. public class LoginServiceImpl implements LoginService {
  3.     private UserDao dao=new UserDaoImpl();
  4.     @Override
  5.     public User login(String uname, String pwd) {
  6.         // TODO Auto-generated method stub
  7.         //业务处理
  8.         User user=new User(uname,pwd);
  9.         return dao.findUser(user);
  10.     }
  12. }

UserDao.java

接口UserDao,java中实现关于用户的数据访问的相关方法。

实现代码：

  1. public interface UserDao {
  3.     //查询
  4.     User findUser(User user);
  6.     //删除
  8. }

UserDaoImp.java(继承自Oracle数据库连接池，实现接口UserDao)

UserDaoImpl,java继承了JNDIBaseDao，实现从数据库中查找是否存在该数据，实现方法为UserDao中的查询方法。

  1. public class UserDaoImpl extends JNDIBaseDao implements UserDao

实现代码：

  1. public class UserDaoImpl extends JNDIBaseDao implements UserDao {
  3.     @Override
  4.     public User findUser(User user) {
  5.         // TODO Auto-generated method stub
  6.         //3.执行sql语句
  7.         //4.获取结果集
  8.         String sql = "select * from user where 1=1";
  9.         ArrayList list = new ArrayList();
  10.         if(user.getUname()!=null&&!user.getUname().equals("")){
  11.             sql+=" and uname=? ";
  12.             list.add(user.getUname());
  13.         }
  14.         ResultSet rs=executeQuery(sql, list.toArray());
  15.         //访问数据库查询是否存在该用户
  16.         try {
  17.             //登录成功
  18.             if(rs.next()) {
  19.                 //把结果集转换成实体类
  20.                 user.setUname(rs.getString("uname"));
  21.                 user.setPwd(rs.getString("pwd"));
  22.                 user.setId(rs.getInt("id"));
  23.                 user.setSex(rs.getString("sex"));
  24.                 user.setEmail(rs.getString("email"));
  25.                 return user;
  26.             }
  27.         } catch (SQLException e) {
  28.             // TODO Auto-generated catch block
  29.             e.printStackTrace();
  30.         }
  31.         //不存在该用户
  32.         return null;
  33.     }
  35. }

JNDIBaseDao.java

在JNDIBaseDao中，通过连接池方法实现与Oracle数据库的交互，并实现对数据库之中的相关操作，如增删改查等。

实现代码：

  1. public class JNDIBaseDao {
  3.     private DataSource source;
  4.     private Connection connection;
  5.     private PreparedStatement ps;
  6.     private ResultSet rs;
  8.     {
  9.         try {
  10.             Context ic = new InitialContext();
  11.             source = (DataSource)ic.lookup("java:comp/env/jdbc/test");
  12.         } catch (NamingException e) {
  13.             // TODO Auto-generated catch block
  14.             e.printStackTrace();
  15.         }
  16.     }
  18.     public void getConnection() {
  19.         try {
  20.             connection=source.getConnection();
  21.         } catch (SQLException e) {
  22.             // TODO Auto-generated catch block
  23.             e.printStackTrace();
  24.         }
  25.     }
  27.     /**
  28.      * 增删改操作
  29.      * @param sql
  30.      * @param objs
  31.      * @return 影响行数
  32.      */
  33.     public int executeUpdate(String sql,Object... objs) {
  34.         if(connection==null) {
  35.             getConnection();
  36.         }
  37.         int res=-1;
  38.         try {
  39.             //设置手动提交事务
  40.             connection.setAutoCommit(false);
  41.             connection.setTransactionIsolation(Connection.TRANSACTION_READ_COMMITTED);
  42.             ps=connection.prepareStatement(sql);
  43.             if(objs!=null) {
  44.                 for(int i=0;i<objs.length;i++) {
  45.                     ps.setObject(i+1, objs[i]);
  46.                 }
  47.             }
  48.             res=ps.executeUpdate();
  49.             //手动提交事务
  50.             connection.commit();
  51.         } catch (SQLException e) {
  52.             // TODO Auto-generated catch block
  53.             e.printStackTrace();
  54.             try {
  55.                 connection.rollback();
  56.             } catch (SQLException e1) {
  57.                 // TODO Auto-generated catch block
  58.                 e1.printStackTrace();
  59.             }
  60.         } finally {
  61.             if(ps!=null) {
  62.                 try {
  63.                     ps.close();
  64.                 } catch (SQLException e) {
  65.                     // TODO Auto-generated catch block
  66.                     e.printStackTrace();
  67.                 }
  68.             }
  69.         }
  70.         return res;
  71.     }
  73.     /**
  74.      * 查询操作
  75.      * @param sql
  76.      * @param objs
  77.      * @return
  78.      */
  79.     public ResultSet executeQuery(String sql,Object... objs) {
  80.         if(connection==null) {
  81.             getConnection();
  82.         }
  83.         try {
  84.             ps=connection.prepareStatement(sql);
  85.             if(objs!=null) {
  86.                 for(int i=0;i<objs.length;i++) {
  87.                     ps.setObject(i+1, objs[i]);
  88.                 }
  89.             }
  90.             rs=ps.executeQuery();
  91.             return rs;
  92.         } catch (SQLException e) {
  93.             // TODO Auto-generated catch block
  94.             e.printStackTrace();
  95.         }
  96.         return null;
  97.     }
  99.     public void closeAll() {
  100.         try {
  101.             if(rs!=null) {
  102.                 rs.close();
  103.             }
  104.             if(ps!=null) {
  105.                 ps.close();
  106.             }
  107.         } catch (SQLException e) {
  108.             // TODO Auto-generated catch block
  109.             e.printStackTrace();
  110.         }
  111.     }
  112. }

BaseDao(JDBC交互数据库)

JDBC方式连接数据库与数据库实现相关交互操作。

  1. public class BaseDao {
  3.     private String driver="oracle.jdbc.driver.OracleDriver";
  4.     private String url="jdbc:oracle:thin:@localhost:1521:jredu";
  5.     private String username="test";
  6.     private String password="Jredu12345";
  7.     private Connection connection;
  8.     private PreparedStatement ps;
  9.     private ResultSet rs;
  11.     public void getConnection() {
  12.         try {
  13.             Class.forName(driver);
  14.             connection=DriverManager.getConnection(url,username,password);
  15.         } catch (ClassNotFoundException e) {
  16.             // TODO Auto-generated catch block
  17.             e.printStackTrace();
  18.         } catch (SQLException e) {
  19.             // TODO Auto-generated catch block
  20.             e.printStackTrace();
  21.         }
  22.     }
  24.     /**
  25.      * 增删改操作
  26.      * @param sql
  27.      * @param objs
  28.      * @return 影响行数
  29.      */
  30.     public int executeUpdate(String sql,Object... objs) {
  31.         if(connection==null) {
  32.             getConnection();
  33.         }
  34.         try {
  35.             ps=connection.prepareStatement(sql);
  36.             if(objs!=null) {
  37.                 for(int i=0;i<objs.length;i++) {
  38.                     ps.setObject(i+1, objs[i]);
  39.                 }
  40.             }
  41.             return ps.executeUpdate();
  42.         } catch (SQLException e) {
  43.             // TODO Auto-generated catch block
  44.             e.printStackTrace();
  45.         } finally {
  46.             closeStatement();
  47.         }
  48.         return 0;
  49.     }
  51.     /**
  52.      * 查询操作
  53.      * @param sql
  54.      * @param objs
  55.      * @return
  56.      */
  57.     public ResultSet executeQuery(String sql,Object... objs) {
  58.         if(connection==null) {
  59.             getConnection();
  60.         }
  61.         try {
  62.             ps=connection.prepareStatement(sql);
  63.             if(objs!=null) {
  64.                 for(int i=0;i<objs.length;i++) {
  65.                     ps.setObject(i+1, objs[i]);
  66.                 }
  67.             }
  68.             rs=ps.executeQuery();
  69.             return rs;
  70.         } catch (SQLException e) {
  71.             // TODO Auto-generated catch block
  72.             e.printStackTrace();
  73.         }
  74.         return null;
  75.     }
  77.     /**
  78.      * 关闭声明
  79.      */
  80.     public void closeStatement() {
  81.         try {
  82.             if (ps != null) {
  83.                 ps.close();
  84.             }
  85.         } catch (SQLException e) {
  86.             // TODO Auto-generated catch block
  87.             e.printStackTrace();
  88.         }
  90.     }
  92.     /**
  93.      * 把结果集和声明同时关闭
  94.      */
  95.     public void closeAll() {
  96.         try {
  97.             if(rs!=null) {
  98.                 rs.close();
  99.             }
  100.             if(ps!=null) {
  101.                 ps.close();
  102.             }
  103.             if(connection!=null) {
  104.                 connection.close();
  105.             }
  106.         } catch (SQLException e) {
  107.             // TODO Auto-generated catch block
  108.             e.printStackTrace();
  109.         }
  110.     }
  111. }

至此，一个完整的MVC开发流程描述完毕，具体相关代码及操作，如有疑问可留言讨论，新手小白学习，还望大佬们赐教。如有雷同，纯属巧合。

MVC架构 项目实践的更多相关文章

  1. 使用Asp.Net Core MVC 开发项目实践[第一篇:项目结构说明]

    先从下图看整体项目结构: Mango.Manager: 为后台管理项目 Mango.Web: 为前台项目 Mango.Framework.Core: 为常用的基础操作类项目 Mango.Framewo ...

  2. 使用Asp.Net Core MVC 开发项目实践[第五篇:缓存的使用]

    项目中我们常常会碰到一些数据,需要高频率用到但是又不会频繁变动的这类,我们就可以使用缓存把这些数据缓存起来(比如说本项目的导航数据,帖子频道数据). 我们项目中常用到有Asp.Net Core 本身提 ...

  3. Asp.Net MVC大型项目实践整合 NHibernate与Json序列化

    通过NHibernate我们多表查询是实现了 但由于查询出来的集合中的对象“不是平的”,如何在送到UI绑定成了问题.ExtJs UI组件的数据绑定支持多种格式,如简单数组,Json,Xml.在本项目中 ...

  4. 使用Asp.Net Core MVC 开发项目实践[第三篇:基于EF Core的扩展]

    上篇我们说到了EFCore的基础使用,这篇我们将讲解下基于EFCore的扩展. 我们在Mango.Framework.EFCore类库项目中创建一个类名EFExtended的扩展类,并且引入相关的命名 ...

  5. 使用Asp.Net Core MVC 开发项目实践[第二篇:EF Core]

    在项目中使用EF Core还是比较容易的,在这里我们使用的版本是EF Core 2.2. 1.使用nuget获取EF Core包 这个示例项目使用的是SQLSERVER,所以还需要下载Microsof ...

  6. 使用Asp.Net Core MVC 开发项目实践[第四篇:基于EF Core的扩展2]

    上篇我们说到了基于EFCore的基础扩展,这篇我们讲解下基于实体结合拉姆达表达式的自定义更新以及删除数据. 先说下原理:其实通过实体以及拉姆达表达式生成SQL语句去执行 第一种更新扩展: 自定义更新字 ...

  7. MVC项目实践,在三层架构下实现SportsStore,从类图看三层架构

    在"MVC项目实践,在三层架构下实现SportsStore-02,DbSession层.BLL层"一文的评论中,博友浪花一朵朵建议用类图来理解本项目的三层架构.于是就有了本篇: I ...

  8. MVC项目实践,在三层架构下实现SportsStore-02,DbSession层、BLL层

    SportsStore是<精通ASP.NET MVC3框架(第三版)>中演示的MVC项目,在该项目中涵盖了MVC的众多方面,包括:使用DI容器.URL优化.导航.分页.购物车.订单.产品管 ...

  9. MVC项目实践,在三层架构下实现SportsStore-01,EF Code First建模、DAL层等

    SportsStore是<精通ASP.NET MVC3框架(第三版)>中演示的MVC项目,在该项目中涵盖了MVC的众多方面,包括:使用DI容器.URL优化.导航.分页.购物车.订单.产品管 ...

随机推荐

  1. APP逆向案例---x会app

    步骤一 抓个包 其中m_d,m_e为加密参数 步骤二(已经看了是360加固我们脱壳一下) # Author: hluwa <hluwa888@gmail.com> # HomePage: ...

  2. Logstash学习之路（一）Logstash的安装

    一.Logstash简介 Logstash 是一个实时数据收集引擎,可收集各类型数据并对其进行分析,过滤和归纳.按照自己条件分析过滤出符合数据导入到可视化界面.它可以实现多样化的数据源数据全量或增量传 ...

  3. PHP 获取重复数组中 第二多的元素

    $target = ["重复项目", "repeat", "repeat", "重复", "重复项目" ...

  4. Java的nanoTime()方法

    java有两个获取和时间相关的秒数方法,一个是广泛使用的 System.currentTimeMillis() 返回的是从一个长整型结果,表示毫秒. 另一个是 System.nanoTime() 返回 ...

  5. 一文读懂 SuperEdge 边缘容器架构与原理

    前言 superedge是腾讯推出的Kubernetes-native边缘计算管理框架.相比openyurt以及kubeedge,superedge除了具备Kubernetes零侵入以及边缘自治特性, ...

  6. LeetCode225 用队列实现栈

    使用队列实现栈的下列操作: push(x) -- 元素 x 入栈 pop() -- 移除栈顶元素 top() -- 获取栈顶元素 empty() -- 返回栈是否为空 注意: 你只能使用队列的基本操作 ...

  7. 无限重置IDE过期时间插件 亲测可以使用

    相信破解过IDEA的小伙伴,都知道jetbrains-agent这个工具,没错,就是那个直接拖入到开发工具界面,一键搞定,so easy的破解工具!这个工具目前已经停止更新了,尽管还有很多小伙伴在使用 ...

  8. 5.1中repair table

    mysql> repair table xs;+---------+--------+----------+----------+| Table | Op | Msg_type | Msg_te ...

  9. Oracle 10g 如何调整 sga_max_size 与 sga_target

    sga_max_size是相对于操作系统来讲的,当启动oracle时,一次性分配给oracle实例的sga不会超过sga_max_size值:而sga_target是相对于oracle这个正在运行的应 ...

  10. kubernets之statefulset资源

    一  了解Statefulset 1.1  对比statefulset与RS以及RC的区别以及相同点 Statefulset是有状态的,而RC以及RS等是没有状态的 Statefulset是有序的,拥 ...