0
0

web三层架构

1.什么是三层架构

三层架构就是把整个软件系统分为三个层次

  • 表现层（Presentation layer）
  • 业务逻辑层（Business Logic Layer）
  • 数据访问层（Data access layer）

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

2.运用三层架构的目的

2.1规范代码

大型软件需要团队配合的时候问题就来了，由于每个程序员风格不一样，而开发软件大量的代码风格不统一就会造成后期调试和维护出现问题，然而软件分层后，每个层合理分工这样的问题便迎刃而解

2.2解耦

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

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

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

实现"高内聚、低耦合"。把问题划分开来各个解决，易于控制，易于延展，易于分配资源。

3.各个层次的任务

3.1web层（表现层)

表现层可以说是距离用户最近的层，主要是用于接收用户输入的数据和显示处理后用户需要的数据。一般表现为界面，用户通过界面输入查询数据和得到需要的数据。

com.by.servlet： servlet包，接受请求控制跳转页面

3.2service 层(业务逻辑层)

业务逻辑层是处于表现层和数据访问层之间，主要是从数据库中得到数据然后对数据进行逻辑处理。

com.by.service：Service接口包

com.by.service.impl：Service接口实现类，处理业务

3.3dao 持久层(数据访问层)

数据访问层是直接和数据库打交道的，对数据进行“增、删、改、查”等基本的操作。

com.by.dao：Dao接口包

com.by.dao.impl： Dao接口实现类，访问数据库

4.结合mybatis简单实例演示

具体目录如图所示：

首先先建立User实体层：

  1. package com.by.pojo;
  3. public class User {
  4.     private Integer id;
  5.     private String username;
  6.     private String password;
  7.     private String sex;
  8.     private String address;
  10.     public Integer getId() {
  11.         return id;
  12.     }
  14.     public void setId(Integer id) {
  15.         this.id = id;
  16.     }
  18.     public String getUsername() {
  19.         return username;
  20.     }
  22.     public void setUsername(String username) {
  23.         this.username = username;
  24.     }
  26.     public String getPassword() {
  27.         return password;
  28.     }
  30.     public void setPassword(String password) {
  31.         this.password = password;
  32.     }
  34.     public String getSex() {
  35.         return sex;
  36.     }
  38.     public void setSex(String sex) {
  39.         this.sex = sex;
  40.     }
  42.     public String getAddress() {
  43.         return address;
  44.     }
  46.     public void setAddress(String address) {
  47.         this.address = address;
  48.     }
  49. }

再设置连接数据库db.properties：

  1. jdbc.driver=com.mysql.jdbc.Driver
  2. #mysql8
  3. #jdbc:mysql://127.0.0.1:3306/mybatis?useSSL=false&serverTimezone=Asia/Shanghai
  4. jdbc.url=jdbc:mysql://127.0.0.1:3305/servlet?characterEncoding=UTF-8
  5. jdbc.username=root
  6. jdbc.password=

mybatis-config.xml:

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
  3.         "http://mybatis.org/dtd/mybatis-3-config.dtd">
  4. <configuration>
  5.     <properties resource="db.properties"></properties>
  6.     <typeAliases>
  7.         <!--<typeAlias type="com.by.pojo.User" alias="User"></typeAlias>-->
  8.         <!--批量给pojo定义别名，推荐使用小写-->
  9.         <package name="com.by.pojo"/>
  10.     </typeAliases>
  11.     <!--使用dev环境-->
  12.     <environments default="dev">
  13.         <environment id="dev">
  14.             <!--事务-->
  15.             <transactionManager type="JDBC"></transactionManager>
  16.             <!--
  17.                 type="POOLED"：连接池
  18.             -->
  19.             <dataSource type="POOLED">
  20.                 <!--mysql8-->
  21.                 <!--
  22.                     <property name="driver" value="com.mysql.cj.jdbc.Driver"/>
  23.                     <property name="url" value="jdbc:mysql://127.0.0.1:3306/mybatis?useSSL=false&amp;serverTimezone=Asia/Shanghai"/>
  24.                 -->
  25.                 <property name="driver" value="${jdbc.driver}"/>
  26.                 <property name="url" value="${jdbc.url}"/>
  27.                 <property name="username" value="${jdbc.username}"/>
  28.                 <property name="password" value="${jdbc.password}"/>
  29.             </dataSource>
  30.         </environment>
  31.     </environments>
  32.     <!--加载mapper映射文件-->
  33.     <mappers>
  34.         <!--直接引入映射文件-->
  35.         <!--<mapper resource="com/by/mapper/UserMapper.xml"></mapper>-->
  36.         <!--按mapper接口的名称引入映射文件，要求 mapper 接口名称和 mapper 映射文件名称相同-->
  37.         <!--<mapper class="com.by.mapper.UserMapper"></mapper>-->
  38.         <!--批量按mapper接口的名称引入映射文件-->
  39.         <package name="com.by.mapper"/>
  40.     </mappers>
  41. </configuration>

设置公用代码MyServletContextListener：

  1. package com.by.listener;
  3. import org.apache.ibatis.io.Resources;
  4. import org.apache.ibatis.session.SqlSession;
  5. import org.apache.ibatis.session.SqlSessionFactory;
  6. import org.apache.ibatis.session.SqlSessionFactoryBuilder;
  8. import javax.servlet.ServletContext;
  9. import javax.servlet.ServletContextEvent;
  10. import javax.servlet.ServletContextListener;
  11. import java.io.InputStream;
  13. //作用：监听servletContext对象的创建和销毁
  14. public class MyServletContextListener implements ServletContextListener {
  16.     //servletContext对象创建后会调用此方法
  17.     @Override
  18.     public void contextInitialized(ServletContextEvent sce) {
  19.         try {
  20.             //加载mybatis的运行环境
  21.             //加载mybatis-config.xml
  22.             String resource = "mybatis-config.xml";
  23.             InputStream inputStream = Resources.getResourceAsStream(resource);
  25.             //创建sqlSessionFactory
  26.             SqlSessionFactory sessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
  28.             //创建sqlSession
  29.             SqlSession sqlSession = sessionFactory.openSession();
  30.             System.out.println("tomcat启动并加载mybatis环境：" + sqlSession);
  32.             //把sqlSession对象撞到servletContext中
  33.             ServletContext servletContext = sce.getServletContext();
  34.             servletContext.setAttribute("sqlSession", sqlSession);
  35.         }catch (Exception e){
  36.             e.printStackTrace();
  37.         }
  38.     }
  40.     @Override
  41.     public void contextDestroyed(ServletContextEvent sce) {
  43.     }
  44. }

编写jsp代码：

  1. <%@ page contentType="text/html;charset=UTF-8" language="java" %>
  2. <html>
  3.   <head>
  4.     <title>$Title$</title>
  5.   </head>
  6.   <body>
  7.   <h1>用户管理系统</h1>
  8.   <form action="login" method="post">
  9.     账号：<input type="text" name="username"><br>
  10.     密码：<input type="text" name="password"><br>
  11.     <input type="submit" value="登录">
  12.   </form>
  13.   </body>
  14. </html>
  1. <%@ page contentType="text/html;charset=UTF-8" language="java" %>
  2. <html>
  3. <head>
  4.     <title>Title</title>
  5. </head>
  6. <body>
  7.   <h1>人，总得有个活着的理由。</h1>
  8. </body>
  9. </html>

编写serviet的代码：

  1. package com.by.servlet;
  3. import com.by.pojo.User;
  4. import com.by.service.UserService;
  5. import com.by.service.impl.UserServiceImpl;
  7. import javax.servlet.ServletException;
  8. import javax.servlet.http.HttpServlet;
  9. import javax.servlet.http.HttpServletRequest;
  10. import javax.servlet.http.HttpServletResponse;
  11. import java.io.IOException;
  12. //表现层
  13. public class LoginServlet extends HttpServlet {
  15.     @Override
  16.     protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
  17.         doPost(req, resp);
  18.     }
  20.     @Override
  21.     protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
  22.         //根据input标签的name属性获取前端提交的参数
  23.         String username = req.getParameter("username");
  24.         String password = req.getParameter("password");
  26.         //调用service
  27.         UserService userService = new UserServiceImpl(this);
  28.         User user = userService.login(username, password);
  30.         if(user != null){
  31.             //如果登录成功，则跳转到select_list.jsp
  32.             req.getRequestDispatcher("select_list.jsp").forward(req, resp);
  33.         }else{
  34.             //如果登录失败，则跳转到login.jsp
  35.             req.getRequestDispatcher("login.jsp").forward(req, resp);
  36.         }
  37.     }
  38. }

实现service下的接口和实现类：

UserService接口：

  1. package com.by.service;
  3. import com.by.pojo.User;
  5. public interface UserService {
  6.     User login(String username, String password);
  7. }

UserServicelmpl.java:

  1. package com.by.service.impl;
  3. import com.by.mapper.UserMapper;
  4. import com.by.pojo.User;
  5. import com.by.service.UserService;
  6. import com.by.servlet.LoginServlet;
  7. import org.apache.ibatis.session.SqlSession;
  9. import javax.servlet.ServletContext;
  11. //业务层
  12. public class UserServiceImpl implements UserService {
  14.     private UserMapper userMapper;
  16.     public UserServiceImpl(LoginServlet loginServlet) {
  17.         System.out.println(loginServlet);
  18.         ServletContext servletContext = loginServlet.getServletContext();
  19.         SqlSession sqlSession = (SqlSession) servletContext.getAttribute("sqlSession");
  20.         userMapper = sqlSession.getMapper(UserMapper.class);
  21.     }
  23.     @Override
  24.     public User login(String username, String password) {
  25.         //业务逻辑...
  26.         //调用dao层
  27.         return userMapper.login(username, password);
  28.     }
  29. }

书写sql语句：

UserMapper：

  1. public interface UserMapper {
  2.     User login(@Param("username") String username, @Param("password") String password);
  3. }

UserMapper.xml:

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
  3.         "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
  4. <mapper namespace="com.by.mapper.UserMapper">
  5.     <select id="login" resultType="com.by.pojo.User">
  6.         SELECT * FROM user WHERE username=#{username} AND password=#{password}
  7.     </select>
  8. </mapper>

wab.xml文件的配置：

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
  3.          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4.          xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
  5.          version="4.0">
  6.     <!--配置监听器-->
  7.     <listener>
  8.         <listener-class>com.by.listener.MyServletContextListener</listener-class>
  9.     </listener>
  10.     
  11.     <servlet>
  12.         <servlet-name>login</servlet-name>
  13.         <servlet-class>com.by.servlet.LoginServlet</servlet-class>
  14.     </servlet>
  15.     <servlet-mapping>
  16.         <servlet-name>login</servlet-name>
  17.         <url-pattern>/login</url-pattern>
  18.     </servlet-mapping>
  19.     
  20.     <welcome-file-list>
  21.         <welcome-file>login.jsp</welcome-file>
  22.     </welcome-file-list>
  23. </web-app>

数据库：

输入账号密码进行跳转：

标签： 架构
本文转载自: https://blog.csdn.net/2301_77072336/article/details/135263779
版权归原作者 yxwCat 所有， 如有侵权，请联系我们删除。
登录后发布评论

“web三层架构”的评论:

还没有评论
关于作者
...
overfit同步小助手
文章同步
相关阅读

网络安全法-网络运行安全

使用selenium/drissionpage时如何阻止chrome自动跳转http到https

docker desktop 里部署的Open WebUI 管理员密码忘记了的处理方法

在ubuntu20.04中搭建onsite比赛运行环境

利用开源的低代码表单设计器FcDesigner高效管理和渲染复杂表单结构

Kafka学习笔记

【前端】浏览器输入url到页面呈现发生了什么？