三层架构_三层架构搭建 - CSDN
三层架构 订阅
三层架构就是为了符合“高内聚,低耦合”思想,把各个功能模块划分为表示层(UI)、业务逻辑层(BLL)和数据访问层(DAL)三层架构,各层之间采用接口相互访问,并通过对象模型的实体类(Model)作为数据传递的载体,不同的对象模型的实体类一般对应于数据库的不同表,实体类的属性与数据库表的字段名一致。 [1]  三层架构区分层次的目的是为了 “高内聚,低耦合”。开发人员分工更明确,将精力更专注于应用系统核心业务逻辑的分析、设计和开发,加快项目的进度,提高了开发效率,有利于项目的更新和维护工作。 [2] 展开全文
三层架构就是为了符合“高内聚,低耦合”思想,把各个功能模块划分为表示层(UI)、业务逻辑层(BLL)和数据访问层(DAL)三层架构,各层之间采用接口相互访问,并通过对象模型的实体类(Model)作为数据传递的载体,不同的对象模型的实体类一般对应于数据库的不同表,实体类的属性与数据库表的字段名一致。 [1]  三层架构区分层次的目的是为了 “高内聚,低耦合”。开发人员分工更明确,将精力更专注于应用系统核心业务逻辑的分析、设计和开发,加快项目的进度,提高了开发效率,有利于项目的更新和维护工作。 [2]
信息
优    点
降低层与层之间的依赖 标准化 [1]
外文名
3-tier architecture [3]
分    类
表示层(UI)、业务逻辑层(BLL)和数据访问层(DAL) [1]
中文名
三层架构 [3]
目    的
“高内聚,低耦合”的思想 [2]
应    用
应用服务器、应用客户端等 [1]
三层架构含义
三层架构主要是指将业务应用规划中的表示层 UI、数据访问层 DAL 以及业务逻辑层 BLL,其分层的核心任务是“高内聚低耦合”的实现。在整个软件架构中,分层结构是常见和普通的软件结构框架,同时也具有非常重要的地位和意义。这种三层架构可以在软件开发的过程中,划分技术人员和开发人员的具体开发工作,重视核心业务系统的分析、设计以及开发,提高信息系统开发质量和开发效率,进而为信息系统日后的更新与维护提供很大的方便。 [4] 
收起全文
精华内容
参与话题
  • 三层架构(软件设计架构)

    千次阅读 2019-08-22 11:51:03
    三层架构结构 1. 三层架构的概念 三层架构就是将整个业务应用划分为:界面层、业务逻辑层、数据访问层。区分层次的目的是为了 “高内聚低耦合” 的思想。 2. 三层架构结构 界面层(表示层):用户看到的界面。...

    1. 三层架构的概念

    三层架构就是将整个业务应用划分为:界面层、业务逻辑层、数据访问层。区分层次的目的是为了 “高内聚低耦合” 的思想。

    2. 三层架构的结构

    1. 界面层(表示层):用户看到的界面。用户可以通过界面上的组件和服务器进行交互
    2. 业务逻辑层:处理业务逻辑的
    3. 数据访问层:操作数据存储文件

    在这里插入图片描述

    展开全文
  • JavaWeb三层架构详解

    万次阅读 多人点赞 2018-12-13 09:50:08
    什么是三层架构三层架构(3-tier architecture) 通常意义上的三层架构就是将整个业务应用划分为:界面层(User Interface layer)、业务逻辑层(Business Logic Layer)、数据访问层(Data access layer)。区分...

    什么是三层架构?

    三层架构(3-tier architecture) 通常意义上的三层架构就是将整个业务应用划分为:界面层(User Interface layer)、业务逻辑层(Business Logic Layer)、数据访问层(Data access layer)。区分层次的目的即为了高内聚低耦合的思想。在软件体系架构设计中,分层式结构是最常见,也是最重要的一种结构。微软推荐的分层式结构一般分为三层,从下至上分别为:数据访问层(又称为持久层)业务逻辑层(又或称为领域层)表示层

     

    表示层(UI层):

    表示层也称为界面层,位于最外层(最上层),离用户最近。用于显示数据和接收用户输入的数据,为用户提供一种交互式操作的界面。

     

    业务逻辑层(BLL层):

    负责关键业务的处理和数据的传递。复杂的逻辑判断和涉及到数据库的数据验证都需要在此做出处理。主要是针对具体的问题的操作,也可以理解成对数据层的操作,对数据业务逻辑处理,如果说数据层是积木,那逻辑层就是对这些积木的搭建。

     

    数据访问层(DAL层):

    主要负责对数据库的直接访问为业务逻辑层提供数据,根据传入的值来操作数据库,增、删、改、查。

     

    为什么要用三层架构呢?

    1.团队开发,便于管理

    三层架构使得合作开发成为可能,由于各层相互独立,一个小组只需负责一小块就可以。结构化的编程方法面对大型的项目会感到力不从心,因为结构化设计必定会使程序变的错综复杂。逻辑主要在BLL层,就使得UI层也就是客户端不承担太多的职责,即使更新业务逻辑,也无需修改客户端,不用重新部署。

     

    2.解耦

    上一层依赖于下一层,如果测试下一层没有问题,那么问题就只有可能发现在本层了,便于发现和改正BUG。体现了高内聚,低耦合的思想。比如楼房是分层的,我们要到哪一层楼非常方便,只需在电梯里按下那个楼层的层号即可。而三层架构就好比开发的软件“楼”,哪层出现Bug,哪层有问题,我们作为开发人员能够随时找到,并修正。 各个层次分工明确,将一个复杂问题简单拆分了。

     

     3.代码的复用和劳动成本的减少

     分层的根本在于代码的复用和劳动成本的减少。分层的最理想化的结果是实现层与层之间的互不依赖的内部实现,所谓的即插即用!

     

    当然啦,三层架构也是有一定的缺点,但是总的来说,利大于弊。

     

    那么下面写一个小项目来具体地深入了解一下三层架构

     

    项目目录如下:

     

    表示层Model:

    package com.gpnu.book.entity;
    
    public class Books {
    	@Override
    	public String toString() {
    		return "Books [book_id=" + book_id + ", book_name=" + book_name + ", isbn=" + isbn + ", author=" + author + "]";
    	}
    	public Books() {
    	}
    	public Books(int book_id, String book_name, String isbn, String author) {
    		super();
    		this.book_id = book_id;
    		this.book_name = book_name;
    		this.isbn = isbn;
    		this.author = author;
    	}
    	private int book_id;
    	private String book_name;
    	private String isbn;
    	private String author;
    	public int getBook_id() {
    		return book_id;
    	}
    	public void setBook_id(int book_id) {
    		this.book_id = book_id;
    	}
    	public String getBook_name() {
    		return book_name;
    	}
    	public void setBook_name(String book_name) {
    		this.book_name = book_name;
    	}
    	public String getIsbn() {
    		return isbn;
    	}
    	public void setIsbn(String isbn) {
    		this.isbn = isbn;
    	}
    	public String getAuthor() {
    		return author;
    	}
    	public void setAuthor(String author) {
    		this.author = author;
    	}
    }
    

     

    表示层Controller:

    BooksServlet.java

    package com.gpnu.book.servlet;
    
    import java.io.IOException;
    import java.util.List;
    
    import javax.servlet.RequestDispatcher;
    import javax.servlet.ServletException;
    import javax.servlet.annotation.WebServlet;
    import javax.servlet.http.HttpServlet;
    import javax.servlet.http.HttpServletRequest;
    import javax.servlet.http.HttpServletResponse;
    
    import com.gpnu.book.entity.Books;
    import com.gpnu.book.service.BooksService;
    import com.gpnu.book.service.impl.BooksServiceImpl;
    
    /**
     * Servlet implementation class Books
     */
    @WebServlet("/BooksServlet")
    public class BooksServlet extends HttpServlet {
    	private static final long serialVersionUID = 1L;
        
    	BooksService booksService = BooksServiceImpl.getInstance();
        /**
         * @see HttpServlet#HttpServlet()
         */
        public BooksServlet() {
            super();
            // TODO Auto-generated constructor stub
        }
    
    	/**
    	 * @see HttpServlet#doGet(HttpServletRequest request, HttpServletResponse response)
    	 */
    	protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
    		// TODO Auto-generated method stub
    		response.getWriter().append("Served at: ").append(request.getContextPath());
    		doPost(request, response);
    	}
    
    	/**
    	 * @see HttpServlet#doPost(HttpServletRequest request, HttpServletResponse response)
    	 */
    	protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
    		request.setCharacterEncoding("UTF-8");
    		String action = request.getParameter("action");
    		System.out.println("action:" + action);
    		if (action.equals("add")) {
    			doAddBooks(request, response);
    			response.sendRedirect("index.jsp");
    		}else if (action.equals("select")) {
    			response.sendRedirect(request.getContextPath() + "/Books/selBooks.jsp");
    		}else if (action.equals("remove")) {
    			doDelBooks(request, response);
    			response.sendRedirect("SelBooksServlet");
    		}
    	}
    	
    	
    	private void doAddBooks(HttpServletRequest request, HttpServletResponse response) throws IOException {
    		Books book = new Books();
    		//book.setBook_id(Integer.parseInt(request.getParameter("book_id")));
    		book.setBook_name(request.getParameter("book_name"));
    		book.setIsbn(request.getParameter("isbn"));
    		book.setAuthor(request.getParameter("author"));
    		int result = booksService.addBooks(book);
    		if (result > 0)
    			System.out.println("添加book成功");
    		else
    			System.out.println("添加book失败");
    	}
    	
    	private void doDelBooks(HttpServletRequest request, HttpServletResponse response) throws IOException {
    		int id = Integer.parseInt(request.getParameter("id"));
    		int result = booksService.delBooks(id);
    		if (result > 0)
    			System.out.println("删除book成功");
    		else
    			System.out.println("删除book失败");
    
    	}
    }
    

     

    SelBooksServlet.java

    package com.gpnu.book.servlet;
    
    import java.io.IOException;
    import java.util.ArrayList;
    import java.util.List;
    
    import javax.servlet.RequestDispatcher;
    import javax.servlet.ServletException;
    import javax.servlet.annotation.WebServlet;
    import javax.servlet.http.HttpServlet;
    import javax.servlet.http.HttpServletRequest;
    import javax.servlet.http.HttpServletResponse;
    
    import com.gpnu.book.entity.Books;
    import com.gpnu.book.service.BooksService;
    import com.gpnu.book.service.impl.BooksServiceImpl;
    
    /**
     * Servlet implementation class SelBooksServlet
     */
    @WebServlet("/SelBooksServlet")
    public class SelBooksServlet extends HttpServlet {
    	private static final long serialVersionUID = 1L;
    	BooksService booksService = BooksServiceImpl.getInstance();
    	
        /**
         * @see HttpServlet#HttpServlet()
         */
        public SelBooksServlet() {
            super();
            // TODO Auto-generated constructor stub
        }
    
    	/**
    	 * @see HttpServlet#doGet(HttpServletRequest request, HttpServletResponse response)
    	 */
    	protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
    		// TODO Auto-generated method stub
    		response.getWriter().append("Served at: ").append(request.getContextPath());
    		doPost(request, response);
    	}
    
    	/**
    	 * @see HttpServlet#doPost(HttpServletRequest request, HttpServletResponse response)
    	 */
    	private static String keyword = "";
    	protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
    		request.setCharacterEncoding("UTF-8");
    		keyword = request.getParameter("keyword");
    		System.out.println("keyword:" + keyword);
    		if (keyword == "")
    			doSelAllBooks(request, response);
    		else
    			doSelBooks(request, response);
    	}
    
    	private void doSelAllBooks(HttpServletRequest request, HttpServletResponse response) throws IOException, ServletException {
    		List<Books> list = booksService.selAllBooks();
    		request.setAttribute("books", list);
    		System.out.println("查询所有");
    		RequestDispatcher view = request.getRequestDispatcher("/Books/selResult.jsp");
    		view.forward(request, response);
    	}  
     
    	private void doSelBooks(HttpServletRequest request, HttpServletResponse response) throws IOException, ServletException {
    		Books book = booksService.selBooks(keyword);
    		List list = new ArrayList();
    		list.add(book);
    		request.setAttribute("books", list);
    		System.out.println("条件查询");
    		RequestDispatcher view = request.getRequestDispatcher("/Books/selResult.jsp");
    		view.forward(request, response);
    	}
    	
    }
    

     

    表示层View:

    index.jsp

    <%@ page language="java" contentType="text/html; charset=UTF-8"
        pageEncoding="UTF-8"%>
    <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
    <html>
    <head>
    <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
    <title>Insert title here</title>
    </head>
    <body>
    <a href="Books/addBooks.jsp">添加</a>
    <a href="BooksServlet?action=select">查询</a>
    </body>
    </html>

    addBooks.jsp

    <%@ page language="java" contentType="text/html; charset=UTF-8"
        pageEncoding="UTF-8"%>
    <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
    <html>
    <head>
    <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
    <title>Insert title here</title>
    </head>
    <body>
    <form action="/book/BooksServlet?action=add" method="post">
    <table border="1" cellspacing="0" cellpadding="0" style="align:center;">
        <tr><td>图书名称:</td><td><input type="text" name="book_name"></td></tr>
        <tr><td>国际标准书号:</td><td><input type="text" name="isbn"></td></tr>
        <tr><td>作者:</td><td><input type="text" name="author"></td></tr>
        <tr><td><input type="submit" value="提交"></td><td><input type="button" value="返回"></td>
     	</tr>
     </table>
     </form>
    </body>
    </html>

    selBooks.jsp

    <%@ page language="java" contentType="text/html; charset=UTF-8"
        pageEncoding="UTF-8"%>
    <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
    <html>
    <head>
    <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
    <title>Insert title here</title>
    </head>
    <body>
    <form action="/book/SelBooksServlet" method="post">
    <input type="text" name="keyword"><input type="submit" value="查询">
    </form>
    </body>
    </html>

    selResult.jsp

    <%@ page language="java" contentType="text/html; charset=UTF-8"
        pageEncoding="UTF-8"%>
    <%@ page import="com.gpnu.book.entity.Books,java.util.List" %>
    <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
    <html>
    <head>
    <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
    <title>Insert title here</title>
    </head>
    <body>
    <a href="Books/addBooks.jsp">新增</a>
    <br>
    <table border="1" cellspacing="0" cellpadding="0" style="align:center;">
        <tr bgcolor="ff9900" style="font-weight:bold;">
        <th>图书编号</th><th>图书名称</th><th>国际标准号</th><th>作者</th></tr>
    <%
    	List<Books> book = (List)request.getAttribute("books");
    	if(book.size()!=0){
        	for(int i=0;i<book.size();i++) {
           		pageContext.setAttribute("book",book.get(i)); 
    %>  
    	<tr>
          <td>${book.book_id }</td>    
          <td>${book.book_name }</td>
          <td>${book.isbn }</td>
          <td>${book.author }</td>
          <td>|<a href="BooksServlet?action=remove&id=${book.book_id }" onclick='return confirm("确定要删除吗?")'
              >删除</a></td>
       </tr> 
         <%
          }
        }else{
         %>
    <tr><td colspan="6">数据库中没有数据!</td></tr>
        <%
        }
        %>
    </table>
    </body>
    </html>

     

    持久层接口:

    package com.gpnu.book.dao;
    
    import java.util.List;
    
    import com.gpnu.book.entity.Books;
    
    public interface BooksDao {
    	List<Books> selAllBooks();
    	Books selBooks(String keyword);
    	int addBooks(Books book);
    	int delBooks(int book_id);
    	int booksCount();
    }
    

     

    持久层实现类:

    package com.gpnu.book.dao.impl;
    
    import java.sql.Connection;
    import java.sql.PreparedStatement;
    import java.sql.ResultSet;
    import java.sql.SQLException;
    import java.util.ArrayList;
    import java.util.List;
    
    import com.gpnu.book.dao.BooksDao;
    import com.gpnu.book.entity.Books;
    import com.gpnu.book.common.DBUtils;
    
    public class BooksDaoImpl implements BooksDao {
    
    	private Connection conn;
    	
    	public BooksDaoImpl(Connection conn) {
    		this.conn = conn;
    	}
    	
    	@Override
    	public List<Books> selAllBooks() {
    		List list = new ArrayList();
    		PreparedStatement pstam = null;
    		ResultSet rs = null;
    		Books book = null;		try {
    			pstam = conn.prepareStatement("select * from tbl_book");
    			rs = pstam.executeQuery();
    			while (rs.next()) {
    				book = new Books();
    				book.setBook_id(rs.getInt("book_id"));
    				book.setBook_name(rs.getString("book_name"));
    				book.setIsbn(rs.getString("isbn"));
    				book.setAuthor(rs.getString("author"));
    				list.add(book);
    			}
    		} catch (SQLException e) {
    			System.out.println("在查询全部book的时候出错了.错误信息是 :" + e.getMessage());
    		} finally {
    			DBUtils.closeStatement(rs, pstam);
    		}
    		return list;
    	}
    
    	@Override
    	public int booksCount() {
    		// TODO Auto-generated method stub
    		return 0;
    	}
    
    	@Override
    	public Books selBooks(String keyword) {
    		Books book = new Books();
    		PreparedStatement pStatement = null;
    		ResultSet rSet = null;
    		try {
    			pStatement = conn.prepareStatement("select * from tbl_book where book_name like ?");
    			pStatement.setString(1, "%" + keyword + "%");
    			rSet = pStatement.executeQuery();
    			if (rSet.next()) {
    				book.setBook_id(rSet.getInt("book_id"));
    				book.setBook_name(rSet.getString("book_name"));	
    				book.setIsbn(rSet.getString("isbn"));
    				book.setAuthor(rSet.getString("author"));
    			}
    		} catch (SQLException e) {
    			e.printStackTrace();
    		} finally {
    			DBUtils.closeStatement(rSet, pStatement);
    		}
    		return book;
    	}
    
    	@Override
    	public int addBooks(Books book) {
    		int result = 0;
    		PreparedStatement pstam = null;
    		try {
    			pstam = conn.prepareStatement("insert into tbl_book(book_name,isbn,author) values(?,?,?)");
    			//pstam.setInt(1, book.getBook_id());
    			pstam.setString(1, book.getBook_name());
    			pstam.setString(2, book.getIsbn());
    			pstam.setString(3, book.getAuthor());
    			result = pstam.executeUpdate();
    		} catch (SQLException e) {
    			System.out.println("添加book出错.错误信息是 :" + e.getMessage());
    		} finally {
    			DBUtils.closeStatement(null, pstam);
    		}
    		return result;
    	}
    
    	@Override
    	public int delBooks(int book_id) {
    		int result = 0;
    		PreparedStatement pstam = null;
    		try {
    			pstam = conn.prepareStatement("DELETE FROM tbl_book WHERE book_id =?");
    			pstam.setInt(1, book_id);
    			result = pstam.executeUpdate();
    		} catch (SQLException e) {
    			System.out.println("删除book出错.错误信息是 :" + e.getMessage());
    		} finally {
    			DBUtils.closeStatement(null, pstam);
    		}
    		return result;
    	}
    
    }
    

     

    业务逻辑层接口:

    package com.gpnu.book.service;
    
    import java.util.List;
    
    import com.gpnu.book.entity.Books;
    
    public interface BooksService {
    	List<Books> selAllBooks();
    	Books selBooks(String keyword);
    	int addBooks(Books book);
    	int delBooks(int book_id);
    }
    

     

    业务逻辑层实现类

    package com.gpnu.book.service.impl;
    
    import java.sql.Connection;
    import java.util.List;
    
    import com.gpnu.book.entity.Books;
    import com.gpnu.book.service.BooksService;
    import com.gpnu.book.common.DBUtils;
    import com.gpnu.book.dao.BooksDao;
    import com.gpnu.book.dao.impl.BooksDaoImpl;
    
    public class BooksServiceImpl implements BooksService {
    
    	private static final BooksService instance = new BooksServiceImpl();
    	public static BooksService getInstance() {
    		return instance;
    	}
    	
    	@Override
    	public List<Books> selAllBooks() {
    		Connection conn = null;
    		List list = null;
    		try {
    			conn = DBUtils.getConnection();
    			DBUtils.beginTransaction(conn);
    			BooksDao booksDao = new BooksDaoImpl(conn);
    			list = booksDao.selAllBooks();
    			DBUtils.commit(conn);
    		} catch (Exception e) {
    			System.out.println("查询所有books错误" + e.getMessage());
    		} finally {
    			DBUtils.closeConnection(conn);
    		}
    		return list;
    	}
    
    	@Override
    	public Books selBooks(String keyword) {
    		Connection conn = null;
    		Books book = null;
    		try {
    			conn = DBUtils.getConnection();
    			DBUtils.beginTransaction(conn);
    			BooksDao booksDao = new BooksDaoImpl(conn);
    			book = booksDao.selBooks(keyword);
    			DBUtils.commit(conn);
    		} catch (Exception e) {
    			System.out.println("条件查询books错误" + e.getMessage());
    		} finally {
    			DBUtils.closeConnection(conn);
    		}
    		return book;
    	}
    
    	@Override
    	public int addBooks(Books book) {
    		Connection conn = null;
    		int result = 0;
    		try {
    			conn = DBUtils.getConnection();
    			DBUtils.beginTransaction(conn);
    			BooksDao booksDao = new BooksDaoImpl(conn);
    			result = booksDao.addBooks(book);
    			DBUtils.commit(conn);
    		} catch (Exception e) {
    			System.out.println("增加books错误" + e.getMessage());
    		} finally {
    			DBUtils.closeConnection(conn);
    		}
    		return result;
    	}
    
    	@Override
    	public int delBooks(int book_id) {
    		Connection conn = null;
    		int result = 0;
    		try {
    			conn = DBUtils.getConnection();
    			DBUtils.beginTransaction(conn);
    			BooksDao booksDao = new BooksDaoImpl(conn);
    			result = booksDao.delBooks(book_id);
    			DBUtils.commit(conn);
    		} catch (Exception e) {
    			System.out.println("删除books错误" + e.getMessage());
    		} finally {			DBUtils.closeConnection(conn);
    		}
    		return result;
    	}
    
    }
    

     

    我们启动一下项目,我们作为用户直接看到的就是表示层的视图了

     

    而当我们点击查询,会跳转到查询的视图

     

    点击查询,我们会跳转到表示层的控制器,也就是Servlet,此时Servle会调用业务逻辑层的方法

     

    而业务逻辑层则会调用持久层(DAO层)的方法

     

    最后持久层连接到数据库,读取数据库的数据,保存为一个Model类

     

    将结果原路返回给表示层的视图View

     

    整个运行过程可以浓缩为一张图:

     

     

     

    展开全文
  • 三层架构(我的理解及详细分析)

    万次阅读 多人点赞 2014-07-23 20:52:19
    三层架构已经学了一段时间,一直想做一个比较完整、比较完美的总结。但是左思右想,不知道如何下笔。都说万事开头难嘛,今天整理了一下凌乱的思路,哎,还是没整理好,想到哪就说到哪吧。   初学者很不理解: 1,...

    三层架构已经学了一段时间,一直想做一个比较完整、比较完美的总结。但是左思右想,不知道如何下笔。都说万事开头难嘛,今天整理了一下凌乱的思路,哎,还是没整理好,想到哪就说到哪吧。

     

    初学者很不理解:

    1,什么是三层?

    2,为什么使用三层?

    3,三层与以往使用的两层相比有什么不同?它的优势在哪里?

    4,如何学好三层?如何应用三层?

    ……

    这篇博客里我会给大家一一解释一下,略懂皮毛忘大家见谅!!!

    米老师一直强调:让学习和生活结合,把学习和生活联系,这样的学习才叫会学习,会生活。

    对于三层我左思右想,如何与实际相联系。好嘛,昨晚突然有了“灵感”。还记得大话设计模式里第23章大鸟和小菜吃羊肉串的故事——由在小摊吃到饭店吃引来的一个命令模式(当然今天不是研究命令模式)。服务员、厨师、采购员。

    这不就是个典型的三层架构吗???( o )啊!哈哈(这个后面再做解释)

     

     

    先了解:

     

    1,什么是三层?

    UI(表现层):主要是指用户交互的界面。用于接收用户输入的数据和显示处理后用户需要的数据。

     

    BLL:(业务逻辑层):UI层和DAL层之间的桥梁实现业务逻辑。业务逻辑具体包含:验证、计算、业务规则等等。

     

    DAL:(数据访问层):与数据库打交道。主要实现对数据的增、删、改、查。将存储在数据库中的数据提交给业务层,同时将业务层处理的数据保存到数据库。(当然这些操作都是基于UI层的。用户的需求反映给界面(UI),UI反映给BLLBLL反映给DALDAL进行数据的操作,操作后再一一返回,直到将用户所需数据反馈给用户)

    每一层都各负其责,那么该如何将三层联系起来呢?

    1>单项引用(见下图)

    2>这时候实体层(Entity)来了。(注:当然,实体层的作用不止这些)

     

    Entity(实体层):它不属于三层中的任何一层,但是它是必不可少的一层。

     

    Entity在三层架构中的作用:

    1,实现面向对象思想中的"封装";

    2,贯穿于三层,在三层之间传递数据;

    注:确切的说实体层贯穿于三层之间,来连接三层)

    3,对于初学者来说,可以这样理解:每张数据表对应一个实体,即每个数据表中的字段对应实体中的属性(注:当然,事实上不是这样。为什么?1>,可能我们需要的实体在数据表对应的实体中并不存在;2>,我们完全可以将所有数据表中的所有字段都放在一个实体里)

    4,每一层(UI>BLL>DAL)之间的数据传递(单向)是靠变量或实体作为参数来传递的,这样就构造了三层之间的联系,完成了功能的实现。

    但是对于大量的数据来说,用变量做参数有些复杂,因为参数量太多,容易搞混。比如:我要把员工信息传递到下层,信息包括:员工号、姓名、年龄、性别、工资....用变量做参数的话,那么我们的方法中的参数就会很多,极有可能在使用时,将参数匹配搞混。这时候,如果用实体做参数,就会很方便,不用考虑参数匹配的问题,用到实体中哪个属性拿来直接用就可以,很方便。这样做也提高了效率。

     

    注:这里为什么说可以暂时理解为每个数据表对应一个实体??答:大家都知道,我们做系统的目的,是为用户提供服务,用户可不关心你的系统后台是怎么工作的,用户只关心软件是不是好用,界面是不是符合自己心意。用户在界面上轻松的增、删、改、查,那么数据库中也要有相应的增、删、改、查,而增删改查具体操作对象就是数据库中的数据,说白了就是表中的字段。所以,将每个数据表作为一个实体类,实体类封装的属性对应到表中的字段,这样的话,实体在贯穿于三层之间时,就可以实现增删改查数据了)

     

    综上所述:三层及实体层之间的依赖关系:

     

    思想来源于生活:

     

     

    服务员:只管接待客人;

    厨师:只管做客人点的菜;

    采购员:只管按客人点菜的要求采购食材;

     

    他们各负其职,服务员不用了解厨师如何做菜,不用了解采购员如何采购食材;厨师不用知道服务员接待了哪位客人,不用知道采购员如何采购食材;同样,采购员不用知道服务员接待了哪位客人,不用知道厨师如何做菜。

     

    他们三者是如何联系的?

    比如:厨师会做:炒茄子、炒鸡蛋、炒面——此时构建三个方法( cookEggplant()cookEgg()cookNoodle())

     

    顾客直接和服务员打交道,顾客和服务员(UI层)说:我要一个炒茄子,而服务员不负责炒茄子,她就把请求往上递交,传递给厨师(BLL层),厨师需要茄子,就把请求往上递交,传递给采购员(DAL层),采购员从仓库里取来茄子传回给厨师,厨师响应cookEggplant()方法,做好炒茄子后,又传回给服务员,服务员把茄子呈现给顾客。

    这样就完成了一个完整的操作。

     

    在此过程中,茄子作为参数在三层中传递,如果顾客点炒鸡蛋,则鸡蛋作为参数(这是变量做参数)。如果,用户增加需求,我们还得在方法中添加参数,一个方法添加一个,一个方法设计到三层;何况实际中并不止设计到一个方法的更改。所以,为了解决这个问题,我们可以把茄子、鸡蛋、面条作为属性定义到顾客实体中,一旦顾客增加了炒鸡蛋需求,直接把鸡蛋属性拿出来用即可,不用再去考虑去每层的方法中添加参数了,更不用考虑参数的匹配问题。

     

    这样讲,不知道大家是不是可以明白。(待会实例解释吧)

     

    2,为什么使用三层?

    使用三层架构的目的:解耦!!!

    同样拿上面饭店的例子来讲:

    1)服务员(UI层)请假——另找服务员;厨师(BLL层)辞职——招聘另一个厨师;采购员(DAL)辞职——招聘另一个采购员;

    2)顾客反映:1>你们店服务态度不好——服务员的问题。开除服务员;

    2>你们店菜里有虫子——厨师的问题。换厨师;

     

    任何一层发生变化都不会影响到另外一层!!!

     

    3,与两层的区别??

    两层:

     

    (当任何一个地方发生变化时,都需要重新开发整个系统。“多层”放在一层,分工不明确耦合度高——难以适应需求变化,可维护性低、可扩展性低)

     

    三层:

     

     

    (发生在哪一层的变化,只需更改该层,不需要更改整个系统。层次清晰,分工明确,每层之间耦合度低——提高了效率,适应需求变化,可维护性高,可扩展性高)

     

    综上:三层架构的

    优势:1,结构清晰、耦合度低,2,可维护性高,可扩展性高;3,利于开发任务同步进行;容易适应需求变化

     

    劣势:1、降低了系统的性能。这是不言而喻的。如果不采用分层式结构,很多业务可以直接造访数据库,以此获取相应的数据,如今却必须通过中间层来完成。

    2、有时会导致级联的修改。这种修改尤其体现在自上而下的方向。如果在表示层中需要增加一个功能,为保证其设计符合分层式结构,可能需要在相应的业务逻辑层和数据访问层中都增加相应的代码

    3、增加了代码量,增加了工作量

     

    4,三层的具体表现形式??

     

    UI

    (大家不要误会,UI层不只是一个个用户界面,也是需要有代码的)

     

    (1,功能:用户输入数据、反馈给用户数据;2,大家观察代码:没有涉及到业务逻辑,直接传参、函数、方法调用,没有涉及到与数据库打交道的SQL语句和ADO.net)

     

    BLL

     

    1BLL是表示层与数据访问层之间的桥梁,负责数据处理、传递;2,大家观察代码,没有涉及到界面上的控件,没有涉及到SQL语句和ADO.net

     

    DAL

     

     

     

     

    (1,以上是DAL层中DbUtil类、user_DA类和workRecord_DA类中的代码;2,大家观察代码,没有涉及到界面控件,没有涉及到业务逻辑;只有与数据库打交道的SQL语句和ADO.net)

     

    EntityModel)层:

    (定义了实体类user

    观察以上三层:

    1,实体类user作为参数贯穿于三层之间;

    2,通过传参、方法调用来实现功能;

    3,各层之间各负其责;互不影响

     

    对比两层结构,让大家深刻体会三层的极大好处:

    还是以机房收费系统的登陆为例:

    (观察上面的两层的代码:将业务逻辑、数据访问都展现在用户表现层,当需求需要改变时,需要改变整个系统。比如,我把文本框txtPassWord的名称改为txtPwd的话,大家观察一下得需要更改多少地方。这样的改动算是小的,如果真的有业务需求上的改动才叫麻烦复杂,程序员不跳楼才怪。呵呵、、开个玩笑)

    与如此难以适应需求变化的两层相比,大家再次观察三层代码,再次思考,三层架构有什么好处呢?自己思考。。。。。

     

    自己去发掘吧!!!

    展开全文
  • 三层架构简介

    千次阅读 2018-07-29 23:41:35
      三层架构(3-tier architecture) 通常意义上的三层架构就是将整个业务应用划分为: 界面层(User Interface layer) UI(表现层):主要是指与用户交互的界面。用于接收用户输入的数据和显示处理后用户需要的...

    1、什么是三层?
      三层架构(3-tier architecture) 通常意义上的三层架构就是将整个业务应用划分为:

    • 界面层(User Interface layer)
      UI(表现层):主要是指与用户交互的界面。用于接收用户输入的数据和显示处理后用户需要的数据。

    • 业务逻辑层(Business Logic Layer)
      BLL:(业务逻辑层):UI层和DAL层之间的桥梁。实现业务逻辑。业务逻辑具体包含:验证、计算、业务规则等等。

    • 数据访问层(Data access layer)
      DAL:(数据访问层):与数据库打交道。主要实现对数据的增、删、改、查。将存储在数据库中的数据提交给业务层,同时将业务层处理的数据保存到数据库。(当然这些操作都是基于UI层的。用户的需求反映给界面(UI),UI反映给BLL,BLL反映给DAL,DAL进行数据的操作,操作后再一一返回,直到将用户所需数据反馈给用户)

         区分层次的目的即为了“高内聚低耦合”的思想。在软件体系架构设计中,分层式结构是最常见,也是最重要的一种结构。微软推荐的分层式结构一般分为三层,从下至上分别为:数据访问层、业务逻辑层(又或称为领域层)、表示层。
        由于层是一种弱耦合结构,层与层之间的依赖是向下的,底层对于上层而言是“无知”的,改变上层的设计对于其调用的底层而言没有任何影响。
      2、为什么使用三层?
      举个例子
           顾客到商场购买肉食品

        商场负责接待购买肉食品的顾客

        商场从食品加工工厂批量购入食品

          食品加工厂为商场提供肉食品

        兔子在场负责提供原材料给食品加工厂

      食品加工企业将整个企业业务分为三部分来实现,这样做的好 处是:其中一个环节发生变化,不会影响到整个企业的业务, 只需要其他环节略微变化即可
    3、Entity在三层架构中的作用:

      1、实现面向对象思想中的”封装”;

      2、贯穿于三层,在三层之间传递数据;

      (注:确切的说实体层贯穿于三层之间,来连接三层)

      3、每一层(UI—>BLL—>DAL)之间的数据传递(单向)是靠变量或实体作为参数来传递的,这样就构造了三层之间的联系,完成了功能的实现。

    但是对于大量的数据来说,用变量做参数有些复杂,因为参数量太多,容易搞混。比如:我要把员工信息传递到下层,信息包括:员工号、姓名、年龄、性别、工资....用变量做参数的话,那么我们的方法中的参数就会很多,极有可能在使用时,将参数匹配搞混。这时候,如果用实体做参数,就会很方便,不用考虑参数匹配的问题,用到实体中哪个属性拿来直接用就可以,很方便。这样做也提高了效率。

    (注:我们为什么使用实体层? 因为我们是为用户提供服务,用户不关心你的系统后台是怎么工作的,用户只关心软件是不是好用,界面是不是符合自己心意。用户在界面上轻松的增、删、改、查,那么数据库中也要有相应的增、删、改、查,而增删改查具体操作对象就是数据库中的数据,说白了就是表中的字段。所以,将每个数据表作为一个实体类,实体类封装的属性对应到表中的字段,这样的话,实体在贯穿于三层之间时,就可以实现增删改查数据了)

    这就是我们的三层模型
    这里写图片描述

    展开全文
  • 三层架构

    千次阅读 热门讨论 2014-04-27 15:18:43
    认识三层架构、三层之间的关系与引用 什么是三层? 首先要知道三层不是一项实际的技术、他是一中设计软件的思想、这种思想就是把软件分为三层、或者说三个类、分别是表现层(UI)、业务逻辑层(BLL)、数据访问层...
  • 三层架构详细介绍

    2019-07-12 18:25:11
    一、分层架构-3层架构-多层架构 逻辑关系图 架构:  架构一般是针对整个系统的,并非对某个单独的问题(单独的问题可以用模式等来解决)  针对整个系统的“一张蓝图”,对系统的抽象。架构与具体的语言平台...
  • 三层架构(3-tierarchitecture) 通常意义上的三层架构就是将整个业务应用划分为:表现层(Presentation layer)、业务逻辑层(Business Logic Layer)、数据访问层(Data access layer)。区分层次的目的即为了“高...
  • 三 层结构是一种严格分层方法,即数据访问层(DAL)只能被业务逻辑层(BLL)访问,业务逻辑层只能被表示层(UI)访问,用户通过表示层将请求传送给业 务逻辑层,业务逻辑层完成相关业务规则和逻辑,并...三层架构结构图 ...
  • JavaEE 三层架构的浅谈

    万次阅读 2016-08-16 20:49:05
    三层架构 三层架构(3-tier architecture) 通常意义上的三层架构就是将整个业务应用划分为:表现层(UI)、业务逻辑层(BLL)、数据访问层(DAL)。区分层次的目的即为了“高内聚,低耦合”的思想。 1.概念简介: 1、...
  • 软件三层架构

    千次阅读 2018-05-29 09:12:33
    三层架构编辑词条三层架构(2)三层架构(3-tier architecture) 通常意义上的三层架构就是将整个业务应用划分为:表现层(UI)、业务逻辑层(BLL)、数据访问层(DAL)。区分层次的目的即为了“高内聚,低耦合”的思想...
  • 软件的三层架构

    万次阅读 2013-03-05 12:43:05
    基于软件三层架构的研究报告 引言 三层结构是传统的客户/服务器结构的发展,代表了企业级应用的未来,典型的有Web下的应用。多层结构和三层结构的含义是一样的,只是细节有所不同。之所以会有双层、三层这些提法...
  • 三层架构和MVC的区别

    万次阅读 多人点赞 2018-11-15 15:35:29
    首先分别了解三层架构和MVC 很简单,百度搜索(不喜勿喷,我给自己看的) 一、三层架构 三层架构(3-tier architecture) 通常意义上的三层架构就是将整个业务应用划分为:界面层(User Interface layer)、业务...
  • C#三层架构

    万次阅读 2018-11-13 17:14:26
    三层架构 三层架构(3-tier architecture) 通常意义上的三层架构就是将整个业务应用划分为:界面层(User Interface layer)、业务逻辑层(Business Logic Layer)、数据访问层(Data access layer)。区分层次的...
  • JavaEE三层架构

    千次阅读 2017-09-16 22:55:38
    三层架构 三层架构(3-tier architecture) 通常意义上的三层架构就是将整个业务应用划分为:表现层(UI)、业务逻辑层(BLL)、数据访问层(DAL)。区分层次的目的即为了“高内聚,低耦合”的思想。 1.概念...
  • Servlet——web三层架构

    千次阅读 2018-10-30 22:22:14
    *三层架构中的包结构 User实体类 三层架构一般都是从实体类开始写的,在domain包中,新建User实体类,用来封装数据查到的休息 UserDao 编写好User类后,再在dao包下新建UserDao类,并添加查询数据库的方法,方法...
  • 【三层】三层架构开发项目

    千次阅读 热门讨论 2016-03-11 13:14:29
    三层架构的优点在于不必为了业务逻辑上的微小变化而迁至整个程序的修改,只需要修改商 业逻辑层中的一个函数或一个过程;增强了代码的可重用性;便于不同层次的开发人员之间的合作,只要遵循一定的接口标准就可以...
  • MVC与三层架构

    千次阅读 2017-05-27 15:09:25
    一、简述在软件开发中,MVC与三层架构这两个专业词汇经常耳闻,同时总有很多人将它们混为一谈,认为三层架构就是指MVC,给它画上等号,但实际上,这是错误的认知,并不是说它们没有任何关系,而是MVC与三层架构不是...
  • 关于J2EE开发三层架构

    千次阅读 2014-03-28 16:13:53
    现在开发web大多都是基于MVC的三层架构三层架构优势什么呢?  三层架构(3-tier application) 通常意义上的三层架构就是将整个业务应用划分为:表现层(UI)、业务逻辑层(BLL)、数据访问层(DAL)。区分层次...
  • 三层网络架构

    千次阅读 2018-04-06 19:25:39
    三层网络架构是采用层次化架构三层网络。 三层网络架构采用层次化模型设计,即将复杂的网络设计分成几个层次,每个层次着重于某些特定的功能,这样就能够使一个复杂的大问题变成许多简单的小问题。三层网络架构...
  • 三层架构和MVC是两个东西。 非要相关的话: 三层架构中"表现层"的aspx页面对应MVC中的View(继承的类不一样) 三层架构中"表现层"的aspx.cs页面(类)对应MVC中的Controller 三层架构中业务逻辑层和数据访问...
1 2 3 4 5 ... 20
收藏数 1,150,057
精华内容 460,022
关键字:

三层架构