• 博客项目（前后端分离）（servlet实战演练）

    作者简介：大家好，我是未央；

    博客首页：未央.303

    系列专栏：实战项目

    每日一句：人的一生，可以有所作为的时机只有一次，那就是现在！！！!

    文章目录

    前言

    项目介绍

    一、MVC模式简介

    1.1  MVC 模式含义

    1.2 MVC 的工作流程

    二、项目概述

    2.1 项目的几个页面

    2.2 功能大概流程

    2.3 M层、V层和C层

    三、项目实战

    3.1 创建项目

    3.2 引入依赖

    pom.xml代码

    3.3 创建必要目录

     3.4 编写代码

    3.5 打包和部署：配置Smart Tomcat

    四、模型层

    4.1 🌰User代码：对应数据库中的User表

    4.2 🌰Blog类：对应数据库中的Blog表

    4.3 🌰DButil类：连上数据库

    4.4 🌰BlogDao类：对数据库中的Blog表的操作

    4.5 🌰UserDao类：对数据库中User表的操作

     五、Controller控制层：用来处理我们前端发来的请求。

    5.1 🍑前后端交互接口举例说明

    5.2 🍑BlogServlet代码

    5.3 🍑DeleteBlogServlet代码

    5.4 🍑UserServlet代码

    5.5 🍑LoginServlet代码

    5.6 🍑LoginOutServlet代码

    5.7 🍑RegServlet代码

    六、视图层（view)总代码展示

    6.1 🏀博客登录页

    6.2 🏀博客注册页

    6.3 🏀博客列表页

    6.4 🏀博客详情页

    6.5 🏀博客编辑页

    6.6 🏀视图层对应的css代码

    总结

    前言

    部署好的博客笔记项目链接：博客笔记项目icon-default.png?t=N7T8http://81.70.49.37:8080/BlogSystem/blog_login.html

    项目介绍

    目前现在更主流的开发方式是 "前后端分离" 的方式.
    这种方式下 服务器端不关注页面的内容, 而只是给 网页端提供数据；
    网页端通过 ajax 的方式和服务器之间交互数据, 网页拿到数据之后再根据数据的内容渲染到页面上.从而通过前后端分离的方式来实现博客笔记项目的编写和各种博客笔记功能实现。

    开发一个博客笔记项目，实现博客用户的注册、登录，并且编写博客列表页、博客详情页、博客编辑页等，能够实现博客的编写、查看、保存等功能。

    图示过程说明：

    一、MVC模式简介

    1.1  MVC 模式含义

    在开始介绍这个项目之前，首先我们要知道什么是MVC模式

    MVC 模式，全称为 Model-View-Controller（模型-视图-控制器）模式，它是一种软件架构模式，其目标是将软件的用户界面（即前台页面）和业务逻辑分离，使代码具有更高的可扩展性、可复用性、可维护性以及灵活性；

    通常情况下，一个完整的 Java Web 应用程序，其结构如下图所示：

    ​

    MVC 模式将应用程序划分成模型（Model）、视图（View）、控制器（Controller）等三层，如下图所示。 

    ​ ​

    1.2 MVC 的工作流程

    1. 用户发送请求到服务器；
    2. 在服务器中，请求被控制层（Controller）接收；
    3. Controller 调用相应的 Model 层处理请求；
    4. Model 层处理完毕将结果返回到 Controller；
    5. Controller 再根据 Model 返回的请求处理结果，找到相应的 View 视图；
    6. View 视图渲染数据后最终响应给浏览器。

    可以说，Controller就是View视图层和Model层之间的桥梁，我们接下来的这个小小项目就用到了MVC思想。

    二、项目概述

    2.1 项目的几个页面

    总的来说，我们当前的项目有这样几个页面：

    博客登录页、博客注册页、博客列表页、博客详情页、博客编辑页。

    博客登录页

    博客注册页 

    博客列表页 

    博客详情页 

    博客编辑页

    2.2 功能大概流程

    首先登录注册不用多说

    🌰在博客列表页，看到的左侧的用户名必须是我们当前登录的用户名，右侧了博客列表显示的所有用户所写的博客简介。

    🌰在博客详情页，我们看到的左侧的用户名是我们当前所查看博客的作者，此外如果这篇博客的作者是当前登录的用户的话，该用户还有权限在博客详情页中删除该博客（删除后就跳转到博客列表页，此时博客列表页已经没有了刚才删除的博客简介），反之则没有权限。

    🌰在博客编辑页，当你新写了一篇博客，发布成功后就会跳转到博客列表页，同时在博客列表页的开头就显示出了你刚刚所写的那篇博客的博客简介

    另外，我们要在博客列表页、博客详情页和博客编辑页，检查用户当前的登录状态，如果是为未登录，页面就强制跳转到登录页。

    既然我们是按MVC的模式来写的，那么我们就来看看在这个项目中M层、V层和C层都分别做了什么吧！

    2.3 M层、V层和C层

    Model（模型层）

    首先对于M层，即我们的模型层。他需要接收C(控制层)对他的调控，完成对数据的操作。

    再来看看这张图：

     我们这个项目需要用到两张表：User用户表和Blog博客表，M层应该有分别对应这两张表的实体类User类和Blog类。另外还应该有对这两张表中数据分别处理的UserDao类、BlogDao类，用来对完成数据的处理（新增、删除、查询等）

    View（视图层）

    从上图也可以看出，view负责我们用户界面的展示，其实就是前端（HTML、CSS、JS的相关代码）前端把用提交的数据或或者说操作以HTTP请求的方式通过服务器发给我们的Controller（控制器层），然后控制器再对请求做对应的处理，再把处理的结果以相应的形式返回给前端。

    Controller（控制器层)

    控制器是视图层和模型层之间的桥梁，按前面所说：好像都是控制器层来和视图层（前端）来做交互。那么模型层干什么了呢？

    你可不要误会了模型层，他才是处理数据的幕后之人，我们的控制器层只是把视图层（用户）发来的请求，交给模型层来干，同时把模型层辛辛苦苦处理的数据结果返回视图（view)渲染并展示给用户。

    在这个过程中，Controller 层不会做任何业务数据上处理，它只是 View（视图）层和 Model （模型）层连接的枢纽，负责调度 View 层和 Model 层，将用户界面和业务逻辑合理的组织在一起，起粘合剂的效果。
     

    光说他们三个之间的关系可能还不清楚，让我们来举例说明

    举例说明：

     这个我们博客系统实际这三个层所处的位置关系，

    比如我们现在在进入了博客列表页， 前端（我们的视图层）发来了一个请求要我们返回当前数据库里所有的数据。

    于是我们的控制层（BlogServlet）代码接收了这个请求，并调用了我们的模型层（BlogDao）让我们的模型层处理了这个数据（在数据库中进行了相关的增删查改）。

    之后呢，控制层就把处理结果返回给视图（view)渲染并展示给用户。

    三、项目实战

    3.1 创建项目

    对于Maven来说，我们不用下载，因为idea中内置了线程的Maven，我们之间拿来用就好。

    下面我们主要介绍在Maven在idea中的使用:

    1、新建一个Maven项目

     2、Maven的使用

    首先我们先了解刚刚我们新创建的Maven项目的组成部分

    下面我们以mysql驱动包的引入来说明Maven引入依赖的流程 

    项目图示示例：

    3.2 引入依赖

    依赖引入的方法：

    因为Servlet这个API部署JDK内置的，而是第三方（Tomcat）提供的，所以我们要想使用，就需要额外的引入Servlet依赖 。

    我们借助Maven来引入Servlet依赖——这里我们所导入的第三方库都是从Maven中央仓库中获取

    中央仓库地址：

    链接：Maven Repository: Search/Browse/Explore (mvnrepository.com)

    项目代码图示：

    pom.xml代码

    1. "1.0" encoding="UTF-8"?>
    2. <project xmlns="http://maven.apache.org/POM/4.0.0"
    3.          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    4.          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    5.     <modelVersion>4.0.0modelVersion>
    6.  
    7.     <groupId>org.examplegroupId>
    8.     <artifactId>blog_systemartifactId>
    9.     <version>1.0-SNAPSHOTversion>
    10.  
    11.     <properties>
    12.         <maven.compiler.source>8maven.compiler.source>
    13.         <maven.compiler.target>8maven.compiler.target>
    14.     properties>
    15.     <dependencies>
    16.  
    17.         
    18.         <dependency>
    19.             <groupId>javax.servletgroupId>
    20.             <artifactId>javax.servlet-apiartifactId>
    21.             <version>3.1.0version>
    22.             <scope>providedscope>
    23.         dependency>
    24.  
    25.         
    26.         <dependency>
    27.             <groupId>mysqlgroupId>
    28.             <artifactId>mysql-connector-javaartifactId>
    29.             <version>5.1.49version>
    30.         dependency>
    31.  
    32.         
    33.         <dependency>
    34.             <groupId>com.fasterxml.jackson.coregroupId>
    35.             <artifactId>jackson-databindartifactId>
    36.             <version>2.13.4version>
    37.         dependency>
    38.  
    39.     dependencies> 
    40.  
    41. project>

    3.3 创建必要目录

    虽然当下 Maven 帮我们创建了一些目录，但是还不够。

    当前这个目录还不足以支撑我们写一个 Servlet 项目，我们这个项目是依赖Tomca服务器，为了符合Tomcat的格式，我们就需要手动创建一些目录和文件。

    常见目录和文件：

     3.4 编写代码

    详细代码编写流程见下面模型层；Controller控制层；视图层；

    3.5 打包和部署：配置Smart Tomcat

    详细步骤跳转至博客：http://t.csdn.cn/gruKuicon-default.png?t=N7T8http://t.csdn.cn/gruKu

    四、模型层

    两部分：

    实体类——对应我们数据库中的表；

    业务处理操作类——对应我们对数据库的操作；

    4.1 🌰User代码：对应数据库中的User表

    代码：

    1. package model;
    2. //这个类的对象表示一个用户；
    3. //属于实体类(对应我们数据库表里面的一条记录)
    4. public class User {
    5.     private int userId;// 当前登录的用户id
    6.     private String username;// 用户名字
    7.     private String password;// 用户密码
    8.  
    9.     // 但注意我们这个属性并没有放在数据库中，因为这个是随时都会改变的（随着你当前所查看博客的 
    10.     不同、当前登录用户的不同）
    11.     private int isYourBlog;  // 通过这个属性，在博客详情页，我们判断是否能够删除该博客
    12.  
    13.  
    14.  
    15.     public int getUserId() {
    16.         return userId;
    17.     }
    18.  
    19.     public void setUserId(int userId) {
    20.         this.userId = userId;
    21.     }
    22.  
    23.     public String getUsername() {
    24.         return username;
    25.     }
    26.  
    27.     public void setUsername(String username) {
    28.         this.username = username;
    29.     }
    30.  
    31.     public String getPassword() {
    32.         return password;
    33.     }
    34.  
    35.     public void setPassword(String password) {
    36.         this.password = password;
    37.     }
    38. }

    4.2 🌰Blog类：对应数据库中的Blog表

    代码：

    1. package mode;
    2.  
    3. import java.sql.Timestamp;
    4. import java.text.SimpleDateFormat;
    5. import java.util.SimpleTimeZone;
    6.  
    7.  
    8. // 实体类是我们进行增删改查的基本单位
    9. //这个类的对象表示一篇博客，属于实体类(对应我们数据库表里面的一条记录)
    10. //这里的属性一般就跟着表走；
    11. public class Blog {
    12.     private int blogId;  // 博客id
    13.     private String title;
    14.     private String content;
    15.     private int userId; // 这篇博客的作者的id
    16.     private Timestamp postTime;
    17.  
    18.     public int getBlogId() {
    19.         return blogId;
    20.     }
    21.  
    22.     public void setBlogId(int blogId) {
    23.         this.blogId = blogId;
    24.     }
    25.  
    26.     public String getTitle() {
    27.         return title;
    28.     }
    29.  
    30.     public void setTitle(String title) {
    31.         this.title = title;
    32.     }
    33.  
    34.     public String getContent() {
    35.         return content;
    36.     }
    37.  
    38.     public void setContent(String content) {
    39.         this.content = content;
    40.     }
    41.  
    42.     public int getUserId() {
    43.         return userId;
    44.     }
    45.  
    46.     public void setUserId(int userId) {
    47.         this.userId = userId;
    48.     }
    49.  
    50. //   // 这里返回的不再是一个时间戳，而是格式化好的String
    51. //    public String getDatetime() {
    52. //        // return datetime; 如果我们不改这里返回的是一个时间戳，而不是格式化好的时间
    53. //        // Java中SimpleDateFormat类就可以 进行时间格式的转换，但需要我们在构造方法中指定转换的时间格式
    54. //        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    55. //        return simpleDateFormat.format(this.postTime);
    56. //    }
    57.  
    58.  
    59.     // 把这个方法魔改一下!! 在方法里面把时间戳构造成格式化时间. 以 String 的方式来返回.
    60.     public String getPostTime() {
    61.         SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    62.         return simpleDateFormat.format(this.postTime);
    63.     }
    64.  
    65.  
    66.  
    67.  
    68.  
    69.     public void setPostTime(Timestamp postTime) {
    70.         this.postTime = postTime;
    71.     }
    72. }

    4.3 🌰DButil类：连上数据库

    作用：

    用来连接上数据库（主要因为我们这个项目是要部署到云服务器上的，所以我们连接的也是云服务上的数据库）

    代码示例：

    1. package model;
    2. import com.mysql.jdbc.Connection;
    3. import com.mysql.jdbc.jdbc2.optional.MysqlDataSource;
    4. import javax.sql.DataSource;
    5. import java.sql.PreparedStatement;
    6. import java.sql.ResultSet;
    7. import java.sql.SQLClientInfoException;
    8. import java.sql.SQLException;
    9.  
    10.  
    11. //这个类主要是用来进行封装数据库建立连接/断开连接的操作；
    12. // 这里我们采用了懒汉模式，会有线程安全问题，要注意加锁;
    13. //原因：因为servlet程序天然就是运行在多线程环境的，每一个请求都可能对应着一个线程（Tomcat 是通过多线程的方式来处理很多请求）
    14. public class DBUtil {
    15.     private volatile static DataSource dataSource = null;//此处先创建一个数据源datasource；
    16.  
    17.     //登录数据库，并获取数据源;即对数据源进行初始化的操作；
    18.     private static DataSource getDataSource(){
    19.         if(dataSource == null){          // 锁内外判断，如果已经创建了数据源，就不进行加锁操作了,典型的双重效验锁；
    20.         synchronized (DBUtil.class) {    // 对类对象加锁
    21.             if (dataSource == null) {
    22.                 dataSource = new MysqlDataSource(); //创建datasource实例；
    23.                 //这里需要给datasource设置一些属性；
    24.                 ((MysqlDataSource) dataSource).setURL("jdbc:mysql://127.0.0.1:3306/BlogSystem?characterEncoding=utf8&useSSL=false");//创建一个url属性；
    25.                 ((MysqlDataSource) dataSource).setUser("root");//设置用户名；
    26.                 ((MysqlDataSource) dataSource).setPassword("136982");// 当我们要把代码部署到云服务器上，我们这里设置的密码是云服务器上的mysql的密码;
    27.             }
    28.         }
    29.         }
    30.         return  dataSource;
    31.     }
    32.  
    33.  
    34.  
    35.     // 与数据源（数据库）建立连接;
    36.     public static Connection getconnection() throws SQLException {
    37.         return (Connection) getDataSource().getConnection();
    38.     }
    39.  
    40.  
    41.     // 关闭连接，释放资源;
    42.     public static void close(Connection connection, PreparedStatement statement, ResultSet resultSet){
    43.         //然后依次按照反着的操作进行关闭；
    44.         //resultSet
    45.         if(resultSet != null){
    46.             try {
    47.                 resultSet.close();
    48.             } catch (SQLException e) {
    49.                 e.printStackTrace();
    50.             }
    51.         }
    52.         //statement;
    53.         if(statement != null){
    54.             try {
    55.                 statement.close();
    56.             } catch (SQLException e) {
    57.                 e.printStackTrace();
    58.             }
    59.         }
    60.         //connection;
    61.         if(connection != null){
    62.             try {
    63.                 connection.close();
    64.             } catch (SQLException e) {
    65.                 e.printStackTrace();
    66.             }
    67.         }
    68.     }
    69.  
    70. }

    代码示例图：

    4.4 🌰BlogDao类：对数据库中的Blog表的操作

    1. package model;
    2.  
    3. import com.mysql.jdbc.Connection;
    4.  
    5. import java.sql.PreparedStatement;
    6. import java.sql.ResultSet;
    7. import java.sql.SQLException;
    8. import java.util.ArrayList;
    9. import java.util.List;
    10.  
    11. //针对博客要实现的功能
    12. //1.新增博客（博客编辑页）
    13. //2.查询出博客列表（博客列表页）
    14. //3.查询出指定博客的详细（博客详细页）
    15. //4.删除指定的博客（可以在博客详细页中加入此功能）
    16. public class BlogDao {
    17.     //注意：下列代码都是JDBC操作，代码相似性很好！
    18.     //1.新增博客功能
    19.     public void insert(Blog blog){
    20.         Connection connection = null;
    21.         PreparedStatement preparedStatement = null;
    22.         ResultSet resultSet = null;
    23.         try {
    24.             //1.先和数据库建立链接
    25.              connection = DBUtil.getconnection();
    26.             //2.构造SQL语句
    27.             String sql = "insert into blog values(null, ?, ?, ?, now())";
    28.             preparedStatement = connection.prepareStatement(sql);
    29.             preparedStatement.setString(1, blog.getTitle());
    30.             preparedStatement.setString(2, blog.getContent());
    31.             preparedStatement.setInt(3, blog.getUserId());
    32.             //3.执行SQL语句
    33.             int ret = preparedStatement.executeUpdate();
    34.             if (ret == 1) {
    35.                 System.out.println("插入成功！！！");
    36.             }else{
    37.                 System.out.println("插入失败！！！");
    38.             }
    39.         } catch (SQLException e) {
    40.             e.printStackTrace();
    41.         }
    42.         finally {
    43.             DBUtil.close(connection, preparedStatement, resultSet);
    44.         }
    45.     }
    46.  
    47.  
    48.     //2.查询出博客列表
    49.     //当前这个方法是给博客列表页使用的
    50.     //而博客列表页里面，不需要显示博客的完整正文，只需要有一小部分即可（作为一个摘要）（71，72）
    51.     public List selectAll(){
    52.         Connection connection = null;//定义来为第1步和数据库建立连接
    53.         PreparedStatement Statement = null;//定义来构造第2步的SQL语句
    54.         ResultSet resultSet = null;//定义来执行第3步的SQL语句
    55.         List blogs = new ArrayList<>();//创建一个数组blogs用于存放blog对象的属性（65）
    56.         try {
    57.             //1.先和数据库建立链接
    58.             connection = DBUtil.getconnection();
    59.             //2.构造SQL语句
    60.             String sql = "select * from blog";
    61.             Statement = connection.prepareStatement(sql);
    62.             //3.执行SQL语句
    63.             resultSet = Statement.executeQuery();
    64.             //4.遍历结果集合
    65.             while (resultSet.next()){   //依次遍历resultSet
    66.                 Blog blog = new Blog();//创建一个blog对象访问集合
    67.                 //然后我们给blog对象设置内容，要对应db.sql表中的属性
    68.                 blog.setBlogId(resultSet.getInt("blogId"));
    69.                 blog.setTitle(resultSet.getString("title"));
    70.                 String content =  resultSet.getString("content");
    71.  
    72.                 //通过这个判定长度保证我们在取下标的时候长度是够用的；
    73.                 if(content.length()>=100){
    74.                     content = content.substring(0,100);
    75.                 }
    76.                 blog.setContent(content);//substring是用来截取字符
    77.                 blog.setUserId(resultSet.getInt("userId"));
    78.                 blog.setPostTime(resultSet.getTimestamp("postTime"));
    79.                 blogs.add(blog);
    80.             }
    81.  
    82.         } catch (SQLException e) {
    83.             e.printStackTrace();
    84.         }//5.最后不要忘记了关闭数据库
    85.         finally {
    86.             DBUtil.close(connection,Statement,resultSet);
    87.         }
    88.         return  blogs;//最后直接返回blogs即可
    89.     }
    90.  
    91.  
    92.  
    93.     //3.通过blogId查询出指定的博客的详细
    94.     public Blog selectOne(int blogId){
    95.         Connection connection = null;//定义来为第1步和数据库建立连接
    96.         PreparedStatement Statement = null;//定义来构造第2步的SQL语句
    97.         ResultSet resultSet = null;//定义来执行第3步的SQL语句
    98.         try{
    99.             //1.先和数据库建立链接
    100.             connection = DBUtil.getconnection();
    101.             //2.构造SQL语句
    102.             String sql = "select * from blog where blogId = ?";//此处的？表示的是我们参数传入的博客Id
    103.             Statement = connection.prepareStatement(sql);
    104.             Statement.setInt(1,blogId);
    105.             //3.执行SQL语句
    106.             resultSet = Statement.executeQuery();
    107.             //4.遍历结果集合
    108.             //由于是按照blogId来查询，blogId是自增主键，不能够重复
    109.             //所以此处的查询结果不可能是多条记录，只能是1条或者0条记录
    110.             if (resultSet.next()){
    111.                 Blog blog = new Blog();
    112.                 blog.setBlogId(resultSet.getInt("blogId"));
    113.                 blog.setTitle(resultSet.getString("title"));
    114.                 blog.setContent(resultSet.getString("content"));
    115.                 blog.setUserId(resultSet.getInt("userId"));
    116.                 blog.setPostTime(resultSet.getTimestamp("postTime"));
    117.                 return blog;
    118.             }
    119.         } catch (SQLException e) {
    120.             e.printStackTrace();
    121.         }finally {
    122.             DBUtil.close(connection,Statement,resultSet);
    123.         }
    124.         return null;
    125.     }
    126.  
    127.     //4.通过blogId删除指定的博客
    128.     public Blog delect(int blogId){
    129.         Connection connection = null;
    130.         PreparedStatement Statement = null;
    131.  
    132.         try {
    133.             connection = DBUtil.getconnection();
    134.             String sql = "delect from blog where blogId = ?";
    135.             Statement = connection.prepareStatement(sql);
    136.             Statement.setInt(1,blogId);
    137.             int ret = Statement.executeUpdate();
    138.             if (ret == 1){
    139.                 System.out.println("打印成功！！");
    140.             }else {
    141.                 System.out.println("打印失败！！");
    142.             }
    143.         } catch (SQLException e) {
    144.             e.printStackTrace();
    145.         }
    146.         finally {
    147.             DBUtil.close(connection,Statement,null);
    148.         }
    149.         return null;
    150.     }
    151.  
    152. }

    4.5 🌰UserDao类：对数据库中User表的操作

    代码示例：

    1. package mode;
    2.  
    3. import javax.servlet.annotation.WebServlet;
    4. import java.sql.Connection;
    5. import java.sql.PreparedStatement;
    6. import java.sql.ResultSet;
    7. import java.sql.SQLException;
    8.  
    9. // 这个类我们是来操作用户表，进行用户表的增删改查
    10. public class UserDao {
    11.     // 新增用户
    12.     public static int insertUser(User user) {
    13.         Connection connection = null;
    14.         PreparedStatement statement = null;
    15.         ResultSet resultSet = null;
    16.         try {
    17.             // 1、与数据库建立连接
    18.             connection = DBUtil.getConnection();
    19.             // 2、构造sql语句
    20.             String sql = "insert into user values(null, ?, ?)";
    21.  
    22.             statement = connection.prepareStatement(sql);
    23.             statement.setString(1, user.getUsername());
    24.             statement.setString(2, user.getPassword());
    25.  
    26.  
    27.             // 执行语句
    28.             // 但执行新增用户前，我们要检查当前用户名，是否已经被注册过
    29.             String check = "select * from user where username <=> ?";
    30.             PreparedStatement statementTest = connection.prepareStatement(check);
    31.             statementTest.setString(1, user.getUsername());
    32.             ResultSet test = statementTest.executeQuery();
    33.  
    34.             // 如果test.next()，可以进入说明test不为空，我们在遍历博客列表时，也是通过test.next来遍历查询到的博客列表的
    35.             if (test.next()) { // 因为这个test是ResultSet，我们不能用他是否为null判断查询结果为空
    36.                 // 说明数据库中已经有了该用户，不能重复注册
    37.                 System.out.println("@@@@@@@@@@@@@");
    38.                 return 1;  // 我们用返回值来代表插入的成功与失败，1失败，0成功
    39.             }
    40.             int ret = statement.executeUpdate();
    41.             if (ret == 1) {
    42.                 System.out.println("新增用户成功!");
    43.             }
    44.             else {
    45.                 System.out.println("新增失败！");
    46.             }
    47.         } catch (SQLException e) {
    48.             e.printStackTrace();
    49.         }
    50.         finally {
    51.             DBUtil.close(connection, statement, resultSet);
    52.         }
    53.         return 0; // return 0 说明插入成功：注册用户成功
    54.     }
    55.  
    56.     // 根据用户名，查看用户的详细信息
    57.     public static User selectByName(String name) {
    58.         Connection connection = null;
    59.         PreparedStatement statement = null;
    60.         ResultSet resultSet = null;
    61.  
    62.         try {
    63.             connection = DBUtil.getConnection();
    64.             String sql = "select * from user where username <=> ?";
    65.             statement = connection.prepareStatement(sql);
    66.             statement.setString(1, name);
    67.             // 执行语句
    68.             resultSet = statement.executeQuery();
    69.             if (resultSet.next()) {
    70.                 User user = new User();
    71.                 user.setUserId(resultSet.getInt("userId"));
    72.                 user.setUsername(resultSet.getString("username"));
    73.                 user.setPassword(resultSet.getString("password"));
    74.  
    75.                 return user;
    76.             }
    77.         } catch (SQLException e) {
    78.             e.printStackTrace();
    79.         }
    80.         finally {
    81.             DBUtil.close(connection, statement, resultSet);
    82.         }
    83.         return null;
    84.     }
    85.     // 根据用户id, 查看用户的详细信息
    86.     public static User selectById (int userId) {
    87.         Connection connection = null;
    88.         PreparedStatement statement = null;
    89.         ResultSet resultSet = null;
    90.  
    91.         try {
    92.             connection = DBUtil.getConnection();
    93.             String sql = "select * from user where userId <=> ?";
    94.             statement = connection.prepareStatement(sql);
    95.             statement.setInt(1, userId);
    96.             // 执行语句
    97.             resultSet = statement.executeQuery();
    98.             if (resultSet.next()) {
    99.                 User user = new User();
    100.                 user.setUserId(resultSet.getInt("userId"));
    101.                 user.setUsername(resultSet.getString("username"));
    102.                 user.setPassword(resultSet.getString("password"));
    103.  
    104.                 return user;
    105.             }
    106.         } catch (SQLException e) {
    107.             e.printStackTrace();
    108.         }
    109.         finally {
    110.             DBUtil.close(connection, statement, resultSet);
    111.         }
    112.         return null;
    113.     }
    114. }

     五、Controller控制层：用来处理我们前端发来的请求。

    事实上，在项目中我们如果想要实现一个功能，有以下三步：

    1、约定前后端交互接口

    2、编写服务器端代码（其实主要编写的就是我们这里控制层的代码，即后端代码）

    3、编写客户端代码（即视图层，我们的前端代码）

    接下来，我们大致介绍一下我们这个项目中所用到的交互接口

    5.1 🍑前后端交互接口举例说明

    博客列表获取（博客列表页中） 

    接下来我们对Controller层的这几个类做一下解析:

    5.2 🍑BlogServlet代码

    首先看我们的BlogServlet代码（与博客列表页、博客详情页、博客编辑页相关联）

    BlogServlet代码 :

    1. package controller;
    2.  
    3. import com.fasterxml.jackson.databind.ObjectMapper;
    4. import mode.Blog;
    5. import mode.BlogDao;
    6. import mode.User;
    7.  
    8. import javax.servlet.ServletException;
    9. import javax.servlet.annotation.WebServlet;
    10. import javax.servlet.http.HttpServlet;
    11. import javax.servlet.http.HttpServletRequest;
    12. import javax.servlet.http.HttpServletResponse;
    13. import javax.servlet.http.HttpSession;
    14. import java.io.IOException;
    15. import java.util.List;
    16. // 这个类可以获取博客列表以及指定博客的博客详情
    17. // 同时这个类也处理新博客的发布，前端的博客编辑页通过from表单，把title和content发给我们，方法是post
    18. @WebServlet("/blog")
    19. public class BlogServlet extends HttpServlet {
    20.     @Override
    21.     protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    22.         // 获取博客列表，这个是由我们的blog_home.html发出的get请求
    23.         // 通过jackson使得我们返回的响应的json格式的
    24.         // 告诉服务器如何解析请求，用户输入的可能是中文
    25.         req.setCharacterEncoding("utf8");
    26.         ObjectMapper objectMapper = new ObjectMapper();
    27.         String blogId = req.getParameter("blogId");
    28.         if (blogId == null) { // 说明此时前端是要我们返回博客列表
    29.             // 因为我们子啊BlogDao类中定义的方法是静态的，所以这里我们不用实例化对象就能调用
    30.             List blogs = BlogDao.getList();
    31.             // 把blogs转成json数组的格式
    32.             String respJson = objectMapper.writeValueAsString(blogs);
    33.             // 告诉浏览器以json格式来读取响应数据，如果没写这行，浏览器会把他当作是一个普通的字符串来处理
    34.             resp.setContentType("application/json; charset=utf-8");
    35.             resp.getWriter().write(respJson);
    36.         }
    37.         else {  // 说明前端此时是要我们返回指定blogId的博客详情
    38.             Blog blog = BlogDao.getDetail(Integer.parseInt(blogId));
    39.             String respJson = objectMapper.writeValueAsString(blog);
    40.             // 告诉浏览器以json格式来读取响应数据，如果没写这行，浏览器会把他当作是一个普通的字符串来处理
    41.             resp.setContentType("application/json; charset=utf-8");
    42.             resp.getWriter().write(respJson);
    43.  
    44.         }
    45.     }
    46.  
    47.     @Override
    48.     // 发表新的博客，新增博客
    49.     protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    50.         // 告诉服务器如何解析请求，用户输入的可能是中文
    51.         req.setCharacterEncoding("utf8");
    52.         // 接收前端提交是数据
    53.         String title = req.getParameter("title");
    54.         String content = req.getParameter("content");
    55.         // 我们还需要一个author信息，当前发布该文章的作者就当前的登录用户
    56.         HttpSession session = req.getSession(false);
    57.         User user = (User) session.getAttribute("user");
    58.         int authorId = user.getUserId(); // 因为当前在博客编辑页面，用户一点是登陆过的，所以不用判断当前用户是否登录
    59.  
    60.         // 构建新的博客对象
    61.         Blog blog = new Blog();
    62.         blog.setTitle(title);
    63.         blog.setContent(content);
    64.         blog.setUserId(authorId);
    65.         // 在数据库中添加刚新建的博客
    66.         BlogDao.insertBlog(blog);
    67.         // 新增完成后，跳转到博客列表页
    68.         resp.sendRedirect("blog_home.html");
    69.     }
    70. }

    对应的模板层的代码代码(Blog和BlogDao)在上面，

    下面我们列出对应视图层的代码：

    相关联的视图层代码：博客列表页，博客详情页。

    博客列表页blog_home.html:

    1. html>
    2. <html lang="en">
    3. <head>
    4.   <meta charset="UTF-8">
    5.   <meta http-equiv="X-UA-Compatible" content="IE=edge">
    6.   <meta name="viewport" content="width=device-width, initial-scale=1.0">
    7.   <title>博客主页title>
    8.   <link rel="stylesheet" href="common.css">
    9.   <link rel="stylesheet" href="bologlist.css">
    10.  
    11. head>
    12. <body>
    13.   
    14.   <div class="navigation">
    15.     <img src="image/大头贴.png">
    16.     <span>我的博客系统span>
    17.     
    18.     <span class="space">span>
    19.  
    20.     <a href="blog_home.html">主页a>
    21.     <a href="write_blog.html">写博客a>
    22.     <a href="logout">退出登录a>
    23.     
    24.   div>
    25.   
    26.   <div class="container">
    27.     
    28.     <div class="left">
    29.       
    30.       <div class="card">
    31.         <img src="image/博客头像男.jpg">
    32.         <h3>未央h3>
    33.         <a href="https://blog.csdn.net/weixin_61061381?type=blog">CSDN地址a>
    34.         <div class="counter">
    35.           <span>文章span>
    36.           <span>分类span>
    37.         div>
    38.         <div class="counter">
    39.           <span>67span>
    40.           <span>7span>
    41.         div>
    42.       div>
    43.     div>
    44.     
    45.     <div class="right">
    46.     
    47.     
    48.     div>
    49.    
    50.   div>
    51.   
    52.    
    53.    <script src="https://code.jquery.com/jquery-3.6.1.min.js">script>
    54.    <script>
    55.      // 通过该函数，从后端获取到当前登录的用户是谁，并把它显示在博客列表页上
    56.      function getUser() {
    57.       $.ajax({
    58.         type: 'get',
    59.         url: 'user',
    60.         success: function(body) {
    61.           // 替换条原来的用户信息
    62.           let userDiv = document.querySelector('.card h3');
    63.           // 引入css，因为我们css就是按原来的类选择器来设置样式的
    64.            // 但其实这一步也没什么必要，因为我们只是获取到原来的作者标签，并不是新建的标签，在获取到了后该标签所对应的className本来就是原来的名字，不用担心原来的css样式失效
    65.           userDiv.className = '.card h3';
    66.           userDiv.innerHTML = body.username;
    67.         },
    68.         error: function() {
    69.            // 强行跳转到登录页面. 
    70.            location.assign('blog_login.html');
    71.         }
    72.       });
    73.      }
    74.      // 你要明白一个html文件，在加载的过程中，是可以同时执行多个函数、多个ajax同时发送请求的
    75.      // 通过这个函数, 来从服务器获取到博客列表的数据
    76.      function getBlogList() {
    77.          $.ajax({
    78.              type: 'get',
    79.              url: 'blog',  // servlet path, 在页面加载的过程中就会调用主机ip + contentPath + 这个servlet path(就@WebServlet后的地址)
    80.              //dataType: 'json',
    81.              success: function(body) {
    82.                  // 根据返回的 json 数据, 来构造出页面内容, div.blog
    83.                  // jquery ajax 会自动的把响应得到的 body 按照响应的 Content-Type 进行转换格式. 
    84.                  // 如果响应的 Content-Type 是 json, 此时就会自动把 body 转成 js 的对象
    85.                  let rightDiv = document.querySelector('.right');
    86.                  for (let blog of body) {
    87.                      // 新建博客结点
    88.                      let blogDiv = document.createElement('div');
    89.                      blogDiv.className = 'blog'; // 引入CSS属性
    90.                      // 创建博客标题
    91.                      let titleDiv = document.createElement('div');
    92.                      titleDiv.className = 'title';
    93.                      titleDiv.innerHTML = blog.title;
    94.                      blogDiv.appendChild(titleDiv); // 把博客标题挂到博客结点上
    95.                      // 创建日期
    96.                      let dateDiv = document.createElement('div');
    97.                      dateDiv.className = 'date';
    98.                      dateDiv.innerHTML = blog.postTime;
    99.                      blogDiv.appendChild(dateDiv);  // 把博客日期挂到博客结点上
    100.                      // 创建摘要
    101.                      let descDiv = document.createElement('div');
    102.                      descDiv.className = 'desc';
    103.                      descDiv.innerHTML = blog.content;
    104.                      blogDiv.appendChild(descDiv);  // 把博客摘要挂到博客结点上
    105.                      // 创建查看全文按钮
    106.                      let a = document.createElement('a');
    107.                      a.innerHTML = '查看全文 >>';
    108.                      // a标签跳转的过程就相当于是发了一个get请求，这里我们在跳转的url地址后加上要传递的参数，即QueryString,等下我们在博客详情页也会用到这个参数
    109.                      a.href = 'blog_detail.html?blogId=' + blog.blogId;
    110.                      blogDiv.appendChild(a);
    111.                      // 把 blogDiv 加入外层元素
    112.                      rightDiv.appendChild(blogDiv);  // 把构建好的一篇博客挂到博客列表上
    113.                  }
    114.              },
    115.              error: function() {
    116.               alert("获取博客列表失败！")
    117.              }
    118.          });
    119.      }
    120.      function checkLogin() {
    121.       $.ajax({
    122.         type: 'get',
    123.         url: 'login',
    124.         success: function(body) {
    125.           // 如果用户已经登录就什么也不做
    126.         },
    127.         error: function() {
    128.  
    129.           //alert("当前登录已过期，请重新登录！")
    130.  
    131.           // 403 就会触发 error
    132.             // 强行跳转到登录页面. 
    133.             location.assign('blog_login.html');
    134.         }
    135.       });
    136.      }
    137.      getBlogList(); // 不用忘了调用函数
    138.      checkLogin();
    139.      getUser();
    140.     script>
    141.      
    142. body>
    143. html>
    144.  
    145.  
    146.  
    147.  
    148.  
    149.  
    150.  
    151.  
    152.  
    153.  
    154.

    博客详情页blog_detail代码：

    1. html>
    2. <html lang="en">
    3. <head>
    4.   <meta charset="UTF-8">
    5.   <meta http-equiv="X-UA-Compatible" content="IE=edge">
    6.   <meta name="viewport" content="width=device-width, initial-scale=1.0">
    7.   <title>博客详情页title>
    8.   <link rel="stylesheet" href="common.css">
    9.   <link rel="stylesheet" href="blogdetail.css">
    10.  
    11.    
    12.    <link rel="stylesheet" href="editor.md/css/editormd.min.css" />
    13.    <script src="js/jquery.min.js">script>
    14.    <script src="editor.md/lib/marked.min.js">script>
    15.    <script src="editor.md/lib/prettify.min.js">script>
    16.    <script src="editor.md/editormd.js">script>
    17. head>
    18. <body>
    19.   
    20.   <div class="navigation">
    21.     <img src="image/大头贴.png">
    22.     <span>我的博客系统span>
    23.     
    24.     <span class="space">span>
    25.  
    26.     <a href="blog_home.html">主页a>
    27.     <a href="write_blog.html">写博客a>
    28.     <a href="logout">退出登录a>
    29.     
    30.     
    31.   div>
    32.   
    33.   <div class="container">
    34.     
    35.     <div class="left">
    36.       
    37.       <div class="card">
    38.         <img src="image/博客头像男.jpg">
    39.         <h3>是小鱼儿哈h3>
    40.         <a href="https://blog.csdn.net/weixin_61061381?type=blog">CSDN地址a>
    41.         <div class="counter">
    42.           <span>文章span>
    43.           <span>分类span>
    44.         div>
    45.         <div class="counter">
    46.           <span>67span>
    47.           <span>7span>
    48.         div>
    49.       div>
    50.       
    51.     div>
    52.     
    53.     <div class="right">
    54.       
    55.       <h2>h2>
    56.       
    57.       <div class="date">
    58.         
    59.       div> 
    60.  
    61.        
    62.        <div id="content" style="opacity: 80%">  
    63.                     
    64.       div>
    65.  
    66.     div>  
    67.   div>
    68.     
    69.     <script src="https://code.jquery.com/jquery-3.6.1.min.js">script>
    70.     <script>
    71.       // 通过这个函数，借助blogId，来从后端获取到这篇博客的作者，并把他显示在博客详情页上
    72.       function getAuthor() {
    73.         $.ajax({
    74.           type: 'get',
    75.           url: 'user' + location.search, //JS中可以通过location.search设置或获取网页地址跟在问号后面的部
    76.           
    77.           // 后端在查询失败的时候不要返回200，避免前端触发ajax中的sucess回调函数
    78.           success: function(body) {
    79.             let authorDiv = document.querySelector('.card h3');
    80.             // 但其实这一步也没什么必要，因为我们只是获取到原来的作者标签，并不是新建的标签，在获取到了后该标签所对应的className本来就是原来的名字，不用担心原来的css样式失效
    81.             authorDiv.className = '.card h3';
    82.             authorDiv.innerHTML = body.username;
    83.  
    84.             // 接下来我们根据后端返回的body，来确定是否在导航栏中显示删除该博客这个按键（只有当前博客的作者和登录的用户名一样才能删，只能删自己的）
    85.             // 所以我们就要在对应的后端代码中判断当前要删除的博客是否是自己的博客，在user/locatin.search所对应的后端servlet代码写相应的逻辑
    86.  
    87.             if (body.isYourBlog == 1) {
    88.               // 新增一个a标签
    89.               // alert("进入添加删除博客按钮的那个if语句了呀！"); 可以用了测试是否进入了该条件语句
    90.               let DeleteA = document.createElement('a');
    91.               DeleteA.href = "delete" + location.search; //JS中可以通过location.search设置或获取网页地址跟在问号后面的部分，即queryString
    92.               DeleteA.innerHTML = "删除该博客";
    93.  
    94.               // 注意，在JS中，单引号和双引号是不同的，下面的代码如果你用双引号，你就获取不到该组件
    95.               let navDiv = document.querySelector('.navigation'); 
    96.               // 此时navDiv就代码的类名是class=avigation这个组件，这次赋值后，该组件的名字并没有变
    97.               // 要想改变该组件的名字，还要通过 navDiv.className 来修改，让他被新的css选择器来修饰
    98.              
    99.               navDiv.appendChild(DeleteA);  // 把我们新增的a标签添加到导航栏中
    100.  
    101.  
    102.               // // 在导航栏中加个按钮, 用来删除文章. 
    103.               // let deleteA = document.createElement('a');
    104.               // // location.search 就是当前页面 url 的 query string, 也就是
    105.               // // ?blogId=1 这样的结果. 
    106.               // deleteA.href = 'blogDelete' + location.search;
    107.               // deleteA.innerHTML = '删除';
    108.  
    109.               // let navDiv = document.querySelector('.nav');
    110.               // navDiv.appendChild(deleteA);
    111.  
    112.             }
    113.           },
    114.           error: function() {
    115.             // 强行跳转到登录页面
    116.             location.assign('blog_login.html');
    117.           }
    118.         });
    119.       }
    120.  
    121.  
    122.       // 通过这个函数, 来获取到博客详情
    123.       function getBlogDetail() {
    124.         $.ajax({
    125.           type: 'get',
    126.           url: 'blog' + location.search, // servlet path,和获取博客列表一个地址，但获取博客列表不带blogId，显示博客详情带blogId
    127.           
    128.           // 后端在查询失败的时候不要返回200，避免前端触发ajax中的sucess回调函数
    129.           success: function(body) {
    130.           
    131.             // 根据返回的数据来构造页面
    132.             // rightDiv是我们博客详情，我们具体的博客内容要挂在rightDiv这个结点上
    133.             let rightDiv = document.querySelector('.right'); // 获取我们上面的右侧页面对象，接下来我们就可以对右侧页面对象进行操作来给我们页面添加元素
    134.             rightDiv.className = 'right'; // 引入css
    135.             // 博客标题构建与添加
    136.             // let titleDiv = document.createComment('div');
    137.             // titleDiv.className = 'h2';
    138.             // titleDiv.innerHTML = body.title;
    139.             // rightDiv.appendChild(titleDiv); // 把标题结点挂到博客详情上
    140.  
    141.             // // 创建该篇博客的发布日期，并把日期添加到博客详情rightDiv上
    142.             // let dateDiv = document.createComment('div');
    143.             // dateDiv.className = 'date';
    144.             // dateDiv.innerHTML = body.dateTime;
    145.             // rightDiv.appendChild(dateDiv);
    146.             // 博客标题
    147.             let titleDiv = document.querySelector('.right h2');
    148.             titleDiv.innerHTML = body.title;
    149.             // 发布日期
    150.             let dateDiv = document.querySelector('.right .date');
    151.             dateDiv.innerHTML = body.postTime;
    152.             // 创建内容
    153.             
    154.            
    155.             // 刚才这里是直接把正文内容设置到 innerHTML 中了, 没有渲染的过程的. 
    156.             // let divContent = document.querySelector('#content');
    157.             // divContent.innerHTML = body.content;
    158.             // 靠谱的做法, 应该是先使用 editor.md 进行渲染. 
    159.             // [重要] 这个方法就是 editor.md 提供的一个方法把 markdown 字符串转成格式化的效果. 
    160.             // 第一个参数是一个 div 的 id, 表示要把渲染结果放到哪个 div 中. 
    161.             // 第二个参数是一个 js 对象, 把正文内容传入即可. (还支持很多别的参数属性, 此处暂时不涉及)
    162.             editormd.markdownToHTML('content', {
    163.               markdown: body.content
    164.             });            
    165.           },
    166.           error: function() {
    167.             alert("获取博客详情失败！");
    168.           }
    169.  
    170.         });
    171.       }
    172.  
    173.       function checkLogin() {
    174.         $.ajax({
    175.           type: 'get',
    176.           url: 'login',
    177.           success: function(body) {
    178.             // 如果用户已经登录就什么也不做
    179.           },
    180.           error: function() {
    181.  
    182.           //alert("当前登录已过期，请重新登录！")
    183.  
    184.           // 403 就会触发 error
    185.             // 强行跳转到登录页面. 
    186.             location.assign('blog_login.html');
    187.           }
    188.         });
    189.       }
    190.       getBlogDetail();
    191.       checkLogin();
    192.       getAuthor();
    193.       
    194.      
    195.     script>
    196. body>
    197. html>

    5.3 🍑DeleteBlogServlet代码

    对应了删除操作，处理了前端的博客详情页（blog_detail.html中）发来的get请求。

    当然了在这个类中也少不了对模型层中代码的使用（Blog和BlogDao)

    代码示例：

    1. package controller;
    2.  
    3. import mode.Blog;
    4. import mode.BlogDao;
    5. import mode.User;
    6.  
    7. import javax.servlet.ServletException;
    8. import javax.servlet.annotation.WebServlet;
    9. import javax.servlet.http.HttpServlet;
    10. import javax.servlet.http.HttpServletRequest;
    11. import javax.servlet.http.HttpServletResponse;
    12. import javax.servlet.http.HttpSession;
    13. import java.io.IOException;
    14.  
    15. // 这个类用来删除指定博客，再前端的博客详情可以看到这个按钮
    16. // 但注意我们只能删除我们自己的博客，也就是说要删除的博客作者必须和我们当前登录的用户一致
    17. // 我们要在后端代码做相应的逻辑判断
    18. @WebServlet("/delete")
    19. public class DeleteBlogServlet extends HttpServlet {
    20.     // 因为我们是通过a标签来跳转到这里的，发的请求是get
    21.     // 前端在给我们传HTTP的get请求时，带上了当前博客详情页中，当前所访问的blogId
    22.  
    23.     @Override
    24.     protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    25.         // 告诉浏览器读取响应数据的格式
    26.         resp.setContentType("text/html; charset=utf8");
    27.         HttpSession session = req.getSession(false);
    28.         if (session == null) {
    29.             resp.setStatus(403);
    30.             System.out.println("当前你还未登录，无删除权限！");
    31.             resp.getWriter().write("当前你还未登录，无删除权限");
    32.             return;
    33.         }
    34.         User user = (User) session.getAttribute("user");
    35.         if (user == null) {
    36.             resp.setStatus(403);
    37.             System.out.println("当前你还未登录，无删除权限！");
    38.             resp.getWriter().write("当前你还未登录，无删除权限");
    39.             return;
    40.         }
    41.  
    42.         int blogId = Integer.parseInt(req.getParameter("blogId"));
    43.         Blog blog = BlogDao.getDetail(blogId);
    44.         if (blog == null) {
    45.             resp.setStatus(403);
    46.             System.out.println("没有你要删除的博客，删除失败！");
    47.             resp.getWriter().write("没有你要删除的博客，删除失败");
    48.         }
    49.         else {
    50.             // 其实我们这里判断是否能删除没必要，因为只有在能删除的情况下，前端才会显示删除按键，跳到我们这里
    51.             if (blog.getUserId() == user.getUserId()) {
    52.                 // 此时说明通过blogId而获取的当前的博客作者id和当前登录用户的id相同，可以删除
    53.                 BlogDao.deleteBlog(blogId);
    54.                 // 删除成功后，自动跳转到博客列表页
    55.                 resp.sendRedirect("blog_home.html");
    56.             }
    57.             resp.setStatus(403);
    58.             System.out.println("你要删除的博客不是你自己所写的博客删除失败！");
    59.             resp.getWriter().write("你要删除的博客不是你自己所写的博客, 删除失败");
    60.         }
    61.  
    62.  
    63.  
    64.     }
    65. }

    相关联的视图层代码

    博客详情页（blog_detail.html)]

    1. html>
    2. <html lang="en">
    3. <head>
    4.   <meta charset="UTF-8">
    5.   <meta http-equiv="X-UA-Compatible" content="IE=edge">
    6.   <meta name="viewport" content="width=device-width, initial-scale=1.0">
    7.   <title>博客详情页title>
    8.   <link rel="stylesheet" href="common.css">
    9.   <link rel="stylesheet" href="blogdetail.css">
    10.  
    11.    
    12.    <link rel="stylesheet" href="editor.md/css/editormd.min.css" />
    13.    <script src="js/jquery.min.js">script>
    14.    <script src="editor.md/lib/marked.min.js">script>
    15.    <script src="editor.md/lib/prettify.min.js">script>
    16.    <script src="editor.md/editormd.js">script>
    17. head>
    18. <body>
    19.   
    20.   <div class="navigation">
    21.     <img src="image/大头贴.png">
    22.     <span>我的博客系统span>
    23.     
    24.     <span class="space">span>
    25.  
    26.     <a href="blog_home.html">主页a>
    27.     <a href="write_blog.html">写博客a>
    28.     <a href="logout">退出登录a>
    29.     
    30.     
    31.   div>
    32.   
    33.   <div class="container">
    34.     
    35.     <div class="left">
    36.       
    37.       <div class="card">
    38.         <img src="image/博客头像男.jpg">
    39.         <h3>是小鱼儿哈h3>
    40.         <a href="https://blog.csdn.net/weixin_61061381?type=blog">CSDN地址a>
    41.         <div class="counter">
    42.           <span>文章span>
    43.           <span>分类span>
    44.         div>
    45.         <div class="counter">
    46.           <span>67span>
    47.           <span>7span>
    48.         div>
    49.       div>
    50.       
    51.     div>
    52.     
    53.     <div class="right">
    54.       
    55.       <h2>h2>
    56.       
    57.       <div class="date">
    58.         
    59.       div> 
    60.  
    61.        
    62.        <div id="content" style="opacity: 80%">  
    63.                     
    64.       div>
    65.  
    66.     div>  
    67.   div>
    68.     
    69.     <script src="https://code.jquery.com/jquery-3.6.1.min.js">script>
    70.     <script>
    71.       // 通过这个函数，借助blogId，来从后端获取到这篇博客的作者，并把他显示在博客详情页上
    72.       function getAuthor() {
    73.         $.ajax({
    74.           type: 'get',
    75.           url: 'user' + location.search, //JS中可以通过location.search设置或获取网页地址跟在问号后面的部
    76.           
    77.           // 后端在查询失败的时候不要返回200，避免前端触发ajax中的sucess回调函数
    78.           success: function(body) {
    79.             let authorDiv = document.querySelector('.card h3');
    80.             // 但其实这一步也没什么必要，因为我们只是获取到原来的作者标签，并不是新建的标签，在获取到了后该标签所对应的className本来就是原来的名字，不用担心原来的css样式失效
    81.             authorDiv.className = '.card h3';
    82.             authorDiv.innerHTML = body.username;
    83.  
    84.             // 接下来我们根据后端返回的body，来确定是否在导航栏中显示删除该博客这个按键（只有当前博客的作者和登录的用户名一样才能删，只能删自己的）
    85.             // 所以我们就要在对应的后端代码中判断当前要删除的博客是否是自己的博客，在user/locatin.search所对应的后端servlet代码写相应的逻辑
    86.  
    87.             if (body.isYourBlog == 1) {
    88.               // 新增一个a标签
    89.               // alert("进入添加删除博客按钮的那个if语句了呀！"); 可以用了测试是否进入了该条件语句
    90.               let DeleteA = document.createElement('a');
    91.               DeleteA.href = "delete" + location.search; //JS中可以通过location.search设置或获取网页地址跟在问号后面的部分，即queryString
    92.               DeleteA.innerHTML = "删除该博客";
    93.  
    94.               // 注意，在JS中，单引号和双引号是不同的，下面的代码如果你用双引号，你就获取不到该组件
    95.               let navDiv = document.querySelector('.navigation'); 
    96.               // 此时navDiv就代码的类名是class=avigation这个组件，这次赋值后，该组件的名字并没有变
    97.               // 要想改变该组件的名字，还要通过 navDiv.className 来修改，让他被新的css选择器来修饰
    98.              
    99.               navDiv.appendChild(DeleteA);  // 把我们新增的a标签添加到导航栏中
    100.  
    101.  
    102.               // // 在导航栏中加个按钮, 用来删除文章. 
    103.               // let deleteA = document.createElement('a');
    104.               // // location.search 就是当前页面 url 的 query string, 也就是
    105.               // // ?blogId=1 这样的结果. 
    106.               // deleteA.href = 'blogDelete' + location.search;
    107.               // deleteA.innerHTML = '删除';
    108.  
    109.               // let navDiv = document.querySelector('.nav');
    110.               // navDiv.appendChild(deleteA);
    111.  
    112.             }
    113.           },
    114.           error: function() {
    115.             // 强行跳转到登录页面
    116.             location.assign('blog_login.html');
    117.           }
    118.         });
    119.       }
    120.  
    121.  
    122.       // 通过这个函数, 来获取到博客详情
    123.       function getBlogDetail() {
    124.         $.ajax({
    125.           type: 'get',
    126.           url: 'blog' + location.search, // servlet path,和获取博客列表一个地址，但获取博客列表不带blogId，显示博客详情带blogId
    127.           
    128.           // 后端在查询失败的时候不要返回200，避免前端触发ajax中的sucess回调函数
    129.           success: function(body) {
    130.           
    131.             // 根据返回的数据来构造页面
    132.             // rightDiv是我们博客详情，我们具体的博客内容要挂在rightDiv这个结点上
    133.             let rightDiv = document.querySelector('.right'); // 获取我们上面的右侧页面对象，接下来我们就可以对右侧页面对象进行操作来给我们页面添加元素
    134.             rightDiv.className = 'right'; // 引入css
    135.             // 博客标题构建与添加
    136.             // let titleDiv = document.createComment('div');
    137.             // titleDiv.className = 'h2';
    138.             // titleDiv.innerHTML = body.title;
    139.             // rightDiv.appendChild(titleDiv); // 把标题结点挂到博客详情上
    140.  
    141.             // // 创建该篇博客的发布日期，并把日期添加到博客详情rightDiv上
    142.             // let dateDiv = document.createComment('div');
    143.             // dateDiv.className = 'date';
    144.             // dateDiv.innerHTML = body.dateTime;
    145.             // rightDiv.appendChild(dateDiv);
    146.             // 博客标题
    147.             let titleDiv = document.querySelector('.right h2');
    148.             titleDiv.innerHTML = body.title;
    149.             // 发布日期
    150.             let dateDiv = document.querySelector('.right .date');
    151.             dateDiv.innerHTML = body.postTime;
    152.             // 创建内容
    153.             
    154.            
    155.             // 刚才这里是直接把正文内容设置到 innerHTML 中了, 没有渲染的过程的. 
    156.             // let divContent = document.querySelector('#content');
    157.             // divContent.innerHTML = body.content;
    158.             // 靠谱的做法, 应该是先使用 editor.md 进行渲染. 
    159.             // [重要] 这个方法就是 editor.md 提供的一个方法把 markdown 字符串转成格式化的效果. 
    160.             // 第一个参数是一个 div 的 id, 表示要把渲染结果放到哪个 div 中. 
    161.             // 第二个参数是一个 js 对象, 把正文内容传入即可. (还支持很多别的参数属性, 此处暂时不涉及)
    162.             editormd.markdownToHTML('content', {
    163.               markdown: body.content
    164.             });            
    165.           },
    166.           error: function() {
    167.             alert("获取博客详情失败！");
    168.           }
    169.  
    170.         });
    171.       }
    172.  
    173.       function checkLogin() {
    174.         $.ajax({
    175.           type: 'get',
    176.           url: 'login',
    177.           success: function(body) {
    178.             // 如果用户已经登录就什么也不做
    179.           },
    180.           error: function() {
    181.  
    182.           //alert("当前登录已过期，请重新登录！")
    183.  
    184.           // 403 就会触发 error
    185.             // 强行跳转到登录页面. 
    186.             location.assign('blog_login.html');
    187.           }
    188.         });
    189.       }
    190.       getBlogDetail();
    191.       checkLogin();
    192.       getAuthor();
    193.       
    194.      
    195.     script>
    196. body>
    197. html>

    5.4 🍑UserServlet代码

    代码分析：

    代码示例：

    1. package controller;
    2.  
    3. import com.fasterxml.jackson.databind.ObjectMapper;
    4. import mode.Blog;
    5. import mode.BlogDao;
    6. import mode.User;
    7. import mode.UserDao;
    8.  
    9. import javax.servlet.ServletException;
    10. import javax.servlet.annotation.WebServlet;
    11. import javax.servlet.http.HttpServlet;
    12. import javax.servlet.http.HttpServletRequest;
    13. import javax.servlet.http.HttpServletResponse;
    14. import javax.servlet.http.HttpSession;
    15. import java.io.IOException;
    16. import java.sql.Struct;
    17.  
    18. @WebServlet("/user")
    19. public class UserServlet extends HttpServlet {
    20.     public static boolean isYourBlog = false;
    21.     @Override
    22.     protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    23.         // 返回当前的用户
    24.         // String user
    25.         // 如果前端带的请求中没有带blogId，说明是列表页的
    26.         String blogId = req.getParameter("blogId");
    27.         // 处理博客列表页
    28.         if (blogId == null) {
    29.             HttpSession session = req.getSession(false);
    30.             if (session == null) {
    31.                 resp.setContentType("text/html; charset=utf-8");
    32.                 //resp.getWriter().write("当前用户未登录请重新登录");
    33.                 resp.setStatus(403); // 返回给前端403，让前端在error回调函数中强制跳转到登录页面
    34.                 return;
    35.             }
    36.  
    37.             User user = (User) session.getAttribute("user");
    38.             // 这里的判断是否是多次一举呢？ 我们再登录的servlet代码中，再创建会话的时候，已经把当前登录的user对象给存在session的value中的键值对里了
    39.             // 因为我们接下来的退出登录操作其实就是把session中的user的对象给删除了，但session本身并没有删除，因为req中没有直接提供删session的方法
    40.             // 这样的话，就是即使session存在，但用户还未登录，此时的user为空
    41.             if (user == null) {
    42.                 resp.setContentType("text/html; charset=utf-8");
    43.                 resp.setStatus(403);  // 表示服务器拒绝你的访问，意思的为登录的用户禁止访问该界面
    44.  
    45.             }
    46.             // 为了能用ObjectMapper，我们要在web.xml中引用jackson这个第三方库
    47.             ObjectMapper objectMapper = new ObjectMapper();
    48.             resp.setContentType("application/json; charset=utf-8");
    49.             // 把我们后端要返回的数据转换json格式
    50.             String retJson = objectMapper.writeValueAsString(user);
    51.             resp.getWriter().write(retJson);
    52.         }
    53.  
    54.         // 处理博客详情页,获取到了blogId,根据他获取到当前的博客作者，并返回数据给前端
    55.         else {
    56.             // 告诉浏览器以json格式来读取响应数据，如果没写这行，浏览器会把他当作是一个普通的字符串来处理
    57.             resp.setContentType("application/json; charset=utf-8");
    58.             // 获取该blogId，所对应的博客详情
    59.             Blog blog = BlogDao.getDetail(Integer.parseInt(blogId));
    60.             if (blog == null) {
    61.                 resp.setStatus(403); // 后端在查询失败的时候不要返回200，避免前端触发ajax中的sucess回调函数
    62.                 resp.setContentType("text/html; charset=utf-8");
    63.                 resp.getWriter().write("当前的blogId有误！！");
    64.             }
    65.             else {
    66.  
    67.                 int userId = blog.getUserId();  // 这个userId是我们当前这篇博客的作者Id
    68.                 // 这个userId不仅在博客表里有，在用户表里也有，所以我们就可以借助这个userId,找到该篇博客所对应的作者名，也就是你通过userId在user表中找到用户名
    69.                 User author = UserDao.selectById(userId);
    70.                 if (author == null) {
    71.                     resp.setStatus(403);
    72.                 }
    73.                 HttpSession session = req.getSession(false);
    74.                 if (session == null) {
    75.                     resp.setStatus(403);
    76.                 }
    77.                 User user = (User) session.getAttribute("user");
    78.                 if (user == null) {
    79.                     resp.setStatus(403);
    80.                 }
    81.                 // 当前user.getUserId()的值，就是当前登录用户的id值，如果这两个值一样就说明当前我们查看博客详情的这篇博客的作者id和当前登录用户的id
    82.                 // 是一个人，就可以进行删除操作，所以我们给这个类添加一个属性，来表示可以删除
    83.                 if (author.getUserId() == user.getUserId()) {
    84.                     author.setIsYourBlog(1);  // 接下来我们前端还要依赖这个属性来操作——是否显示删除按钮
    85.                 }
    86.  
    87.  
    88.                 ObjectMapper objectMapper = new ObjectMapper();
    89.  
    90.                 // 把我们后端要返回的数据转换json格式
    91.                 String retJson = objectMapper.writeValueAsString(author);
    92.                 System.out.println(retJson);
    93.                 resp.getWriter().write(retJson);
    94.             }
    95.  
    96.         }
    97.     }
    98.  
    99. }

    与之相关的视图层的代码

    博客列表页（blog_home.html)

    1. html>
    2. <html lang="en">
    3. <head>
    4.   <meta charset="UTF-8">
    5.   <meta http-equiv="X-UA-Compatible" content="IE=edge">
    6.   <meta name="viewport" content="width=device-width, initial-scale=1.0">
    7.   <title>博客主页title>
    8.   <link rel="stylesheet" href="common.css">
    9.   <link rel="stylesheet" href="bologlist.css">
    10.  
    11. head>
    12. <body>
    13.   
    14.   <div class="navigation">
    15.     <img src="image/大头贴.png">
    16.     <span>我的博客系统span>
    17.     
    18.     <span class="space">span>
    19.  
    20.     <a href="blog_home.html">主页a>
    21.     <a href="write_blog.html">写博客a>
    22.     <a href="logout">退出登录a>
    23.     
    24.   div>
    25.   
    26.   <div class="container">
    27.     
    28.     <div class="left">
    29.       
    30.       <div class="card">
    31.         <img src="image/博客头像男.jpg">
    32.         <h3>是小鱼儿哈h3>
    33.         <a href="https://blog.csdn.net/weixin_61061381?type=blog">CSDN地址a>
    34.         <div class="counter">
    35.           <span>文章span>
    36.           <span>分类span>
    37.         div>
    38.         <div class="counter">
    39.           <span>67span>
    40.           <span>7span>
    41.         div>
    42.       div>
    43.     div>
    44.     
    45.     <div class="right">
    46.     
    47.     
    48.     div>
    49.    
    50.   div>
    51.   
    52.    
    53.    <script src="https://code.jquery.com/jquery-3.6.1.min.js">script>
    54.    <script>
    55.      // 通过该函数，从后端获取到当前登录的用户是谁，并把它显示在博客列表页上
    56.      function getUser() {
    57.       $.ajax({
    58.         type: 'get',
    59.         url: 'user',
    60.         success: function(body) {
    61.           // 替换条原来的用户信息
    62.           let userDiv = document.querySelector('.card h3');
    63.           // 引入css，因为我们css就是按原来的类选择器来设置样式的
    64.            // 但其实这一步也没什么必要，因为我们只是获取到原来的作者标签，并不是新建的标签，在获取到了后该标签所对应的className本来就是原来的名字，不用担心原来的css样式失效
    65.           userDiv.className = '.card h3';
    66.           userDiv.innerHTML = body.username;
    67.         },
    68.         error: function() {
    69.            // 强行跳转到登录页面. 
    70.            location.assign('blog_login.html');
    71.         }
    72.       });
    73.      }
    74.      // 你要明白一个html文件，在加载的过程中，是可以同时执行多个函数、多个ajax同时发送请求的
    75.      // 通过这个函数, 来从服务器获取到博客列表的数据
    76.      function getBlogList() {
    77.          $.ajax({
    78.              type: 'get',
    79.              url: 'blog',  // servlet path, 在页面加载的过程中就会调用主机ip + contentPath + 这个servlet path(就@WebServlet后的地址)
    80.              //dataType: 'json',
    81.              success: function(body) {
    82.                  // 根据返回的 json 数据, 来构造出页面内容, div.blog
    83.                  // jquery ajax 会自动的把响应得到的 body 按照响应的 Content-Type 进行转换格式. 
    84.                  // 如果响应的 Content-Type 是 json, 此时就会自动把 body 转成 js 的对象
    85.                  let rightDiv = document.querySelector('.right');
    86.                  for (let blog of body) {
    87.                      // 新建博客结点
    88.                      let blogDiv = document.createElement('div');
    89.                      blogDiv.className = 'blog'; // 引入CSS属性
    90.                      // 创建博客标题
    91.                      let titleDiv = document.createElement('div');
    92.                      titleDiv.className = 'title';
    93.                      titleDiv.innerHTML = blog.title;
    94.                      blogDiv.appendChild(titleDiv); // 把博客标题挂到博客结点上
    95.                      // 创建日期
    96.                      let dateDiv = document.createElement('div');
    97.                      dateDiv.className = 'date';
    98.                      dateDiv.innerHTML = blog.postTime;
    99.                      blogDiv.appendChild(dateDiv);  // 把博客日期挂到博客结点上
    100.                      // 创建摘要
    101.                      let descDiv = document.createElement('div');
    102.                      descDiv.className = 'desc';
    103.                      descDiv.innerHTML = blog.content;
    104.                      blogDiv.appendChild(descDiv);  // 把博客摘要挂到博客结点上
    105.                      // 创建查看全文按钮
    106.                      let a = document.createElement('a');
    107.                      a.innerHTML = '查看全文 >>';
    108.                      // a标签跳转的过程就相当于是发了一个get请求，这里我们在跳转的url地址后加上要传递的参数，即QueryString,等下我们在博客详情页也会用到这个参数
    109.                      a.href = 'blog_detail.html?blogId=' + blog.blogId;
    110.                      blogDiv.appendChild(a);
    111.                      // 把 blogDiv 加入外层元素
    112.                      rightDiv.appendChild(blogDiv);  // 把构建好的一篇博客挂到博客列表上
    113.                  }
    114.              },
    115.              error: function() {
    116.               alert("获取博客列表失败！")
    117.              }
    118.          });
    119.      }
    120.      function checkLogin() {
    121.       $.ajax({
    122.         type: 'get',
    123.         url: 'login',
    124.         success: function(body) {
    125.           // 如果用户已经登录就什么也不做
    126.         },
    127.         error: function() {
    128.  
    129.           //alert("当前登录已过期，请重新登录！")
    130.  
    131.           // 403 就会触发 error
    132.             // 强行跳转到登录页面. 
    133.             location.assign('blog_login.html');
    134.         }
    135.       });
    136.      }
    137.      getBlogList(); // 不用忘了调用函数
    138.      checkLogin();
    139.      getUser();
    140.     script>
    141.      
    142. body>
    143. html>

    博客详情页（blog_detail.html)

    1. html>
    2. <html lang="en">
    3. <head>
    4.   <meta charset="UTF-8">
    5.   <meta http-equiv="X-UA-Compatible" content="IE=edge">
    6.   <meta name="viewport" content="width=device-width, initial-scale=1.0">
    7.   <title>博客详情页title>
    8.   <link rel="stylesheet" href="common.css">
    9.   <link rel="stylesheet" href="blogdetail.css">
    10.  
    11.    
    12.    <link rel="stylesheet" href="editor.md/css/editormd.min.css" />
    13.    <script src="js/jquery.min.js">script>
    14.    <script src="editor.md/lib/marked.min.js">script>
    15.    <script src="editor.md/lib/prettify.min.js">script>
    16.    <script src="editor.md/editormd.js">script>
    17. head>
    18. <body>
    19.   
    20.   <div class="navigation">
    21.     <img src="image/大头贴.png">
    22.     <span>我的博客系统span>
    23.     
    24.     <span class="space">span>
    25.  
    26.     <a href="blog_home.html">主页a>
    27.     <a href="write_blog.html">写博客a>
    28.     <a href="logout">退出登录a>
    29.     
    30.     
    31.   div>
    32.   
    33.   <div class="container">
    34.     
    35.     <div class="left">
    36.       
    37.       <div class="card">
    38.         <img src="image/博客头像男.jpg">
    39.         <h3>是小鱼儿哈h3>
    40.         <a href="https://blog.csdn.net/weixin_61061381?type=blog">CSDN地址a>
    41.         <div class="counter">
    42.           <span>文章span>
    43.           <span>分类span>
    44.         div>
    45.         <div class="counter">
    46.           <span>67span>
    47.           <span>7span>
    48.         div>
    49.       div>
    50.       
    51.     div>
    52.     
    53.     <div class="right">
    54.       
    55.       <h2>h2>
    56.       
    57.       <div class="date">
    58.         
    59.       div> 
    60.  
    61.        
    62.        <div id="content" style="opacity: 80%">  
    63.                     
    64.       div>
    65.  
    66.     div>  
    67.   div>
    68.     
    69.     <script src="https://code.jquery.com/jquery-3.6.1.min.js">script>
    70.     <script>
    71.       // 通过这个函数，借助blogId，来从后端获取到这篇博客的作者，并把他显示在博客详情页上
    72.       function getAuthor() {
    73.         $.ajax({
    74.           type: 'get',
    75.           url: 'user' + location.search, //JS中可以通过location.search设置或获取网页地址跟在问号后面的部
    76.           
    77.           // 后端在查询失败的时候不要返回200，避免前端触发ajax中的sucess回调函数
    78.           success: function(body) {
    79.             let authorDiv = document.querySelector('.card h3');
    80.             // 但其实这一步也没什么必要，因为我们只是获取到原来的作者标签，并不是新建的标签，在获取到了后该标签所对应的className本来就是原来的名字，不用担心原来的css样式失效
    81.             authorDiv.className = '.card h3';
    82.             authorDiv.innerHTML = body.username;
    83.  
    84.             // 接下来我们根据后端返回的body，来确定是否在导航栏中显示删除该博客这个按键（只有当前博客的作者和登录的用户名一样才能删，只能删自己的）
    85.             // 所以我们就要在对应的后端代码中判断当前要删除的博客是否是自己的博客，在user/locatin.search所对应的后端servlet代码写相应的逻辑
    86.  
    87.             if (body.isYourBlog == 1) {
    88.               // 新增一个a标签
    89.               // alert("进入添加删除博客按钮的那个if语句了呀！"); 可以用了测试是否进入了该条件语句
    90.               let DeleteA = document.createElement('a');
    91.               DeleteA.href = "delete" + location.search; //JS中可以通过location.search设置或获取网页地址跟在问号后面的部分，即queryString
    92.               DeleteA.innerHTML = "删除该博客";
    93.  
    94.               // 注意，在JS中，单引号和双引号是不同的，下面的代码如果你用双引号，你就获取不到该组件
    95.               let navDiv = document.querySelector('.navigation'); 
    96.               // 此时navDiv就代码的类名是class=avigation这个组件，这次赋值后，该组件的名字并没有变
    97.               // 要想改变该组件的名字，还要通过 navDiv.className 来修改，让他被新的css选择器来修饰
    98.              
    99.               navDiv.appendChild(DeleteA);  // 把我们新增的a标签添加到导航栏中
    100.  
    101.  
    102.               // // 在导航栏中加个按钮, 用来删除文章. 
    103.               // let deleteA = document.createElement('a');
    104.               // // location.search 就是当前页面 url 的 query string, 也就是
    105.               // // ?blogId=1 这样的结果. 
    106.               // deleteA.href = 'blogDelete' + location.search;
    107.               // deleteA.innerHTML = '删除';
    108.  
    109.               // let navDiv = document.querySelector('.nav');
    110.               // navDiv.appendChild(deleteA);
    111.  
    112.             }
    113.           },
    114.           error: function() {
    115.             // 强行跳转到登录页面
    116.             location.assign('blog_login.html');
    117.           }
    118.         });
    119.       }
    120.  
    121.  
    122.       // 通过这个函数, 来获取到博客详情
    123.       function getBlogDetail() {
    124.         $.ajax({
    125.           type: 'get',
    126.           url: 'blog' + location.search, // servlet path,和获取博客列表一个地址，但获取博客列表不带blogId，显示博客详情带blogId
    127.           
    128.           // 后端在查询失败的时候不要返回200，避免前端触发ajax中的sucess回调函数
    129.           success: function(body) {
    130.           
    131.             // 根据返回的数据来构造页面
    132.             // rightDiv是我们博客详情，我们具体的博客内容要挂在rightDiv这个结点上
    133.             let rightDiv = document.querySelector('.right'); // 获取我们上面的右侧页面对象，接下来我们就可以对右侧页面对象进行操作来给我们页面添加元素
    134.             rightDiv.className = 'right'; // 引入css
    135.             // 博客标题构建与添加
    136.             // let titleDiv = document.createComment('div');
    137.             // titleDiv.className = 'h2';
    138.             // titleDiv.innerHTML = body.title;
    139.             // rightDiv.appendChild(titleDiv); // 把标题结点挂到博客详情上
    140.  
    141.             // // 创建该篇博客的发布日期，并把日期添加到博客详情rightDiv上
    142.             // let dateDiv = document.createComment('div');
    143.             // dateDiv.className = 'date';
    144.             // dateDiv.innerHTML = body.dateTime;
    145.             // rightDiv.appendChild(dateDiv);
    146.             // 博客标题
    147.             let titleDiv = document.querySelector('.right h2');
    148.             titleDiv.innerHTML = body.title;
    149.             // 发布日期
    150.             let dateDiv = document.querySelector('.right .date');
    151.             dateDiv.innerHTML = body.postTime;
    152.             // 创建内容
    153.             
    154.            
    155.             // 刚才这里是直接把正文内容设置到 innerHTML 中了, 没有渲染的过程的. 
    156.             // let divContent = document.querySelector('#content');
    157.             // divContent.innerHTML = body.content;
    158.             // 靠谱的做法, 应该是先使用 editor.md 进行渲染. 
    159.             // [重要] 这个方法就是 editor.md 提供的一个方法把 markdown 字符串转成格式化的效果. 
    160.             // 第一个参数是一个 div 的 id, 表示要把渲染结果放到哪个 div 中. 
    161.             // 第二个参数是一个 js 对象, 把正文内容传入即可. (还支持很多别的参数属性, 此处暂时不涉及)
    162.             editormd.markdownToHTML('content', {
    163.               markdown: body.content
    164.             });            
    165.           },
    166.           error: function() {
    167.             alert("获取博客详情失败！");
    168.           }
    169.  
    170.         });
    171.       }
    172.  
    173.       function checkLogin() {
    174.         $.ajax({
    175.           type: 'get',
    176.           url: 'login',
    177.           success: function(body) {
    178.             // 如果用户已经登录就什么也不做
    179.           },
    180.           error: function() {
    181.  
    182.           //alert("当前登录已过期，请重新登录！")
    183.  
    184.           // 403 就会触发 error
    185.             // 强行跳转到登录页面. 
    186.             location.assign('blog_login.html');
    187.           }
    188.         });
    189.       }
    190.       getBlogDetail();
    191.       checkLogin();
    192.       getAuthor();
    193.       
    194.      
    195.     script>
    196. body>
    197. html>

    5.5 🍑LoginServlet代码

    LoginServlet用来处理前端登录页（blog_login.html)发来的发来的post请求：

    此外这个类还额外处理了一个验证当前用户是否已经登录的get请求

    （前端的博客列表页blog.home、博客详情页blog_detail.html和博客编辑页都发送一个这样的验证用户是否登录的get请求）

    用到了模型层的User、UserDao 

    代码示例：

    1. package controller;
    2.  
    3. import mode.User;
    4. import mode.UserDao;
    5.  
    6. import javax.servlet.ServletException;
    7. import javax.servlet.annotation.WebServlet;
    8. import javax.servlet.http.HttpServlet;
    9. import javax.servlet.http.HttpServletRequest;
    10. import javax.servlet.http.HttpServletResponse;
    11. import javax.servlet.http.HttpSession;
    12. import java.io.IOException;
    13.  
    14. @WebServlet("/login")
    15. public class LoginServlet extends HttpServlet {
    16.     @Override
    17.     // 处理用户提交登录登陆信息，进行302跳转，跳转到博客列表页，即博客首页
    18.     protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    19.         resp.setContentType("text/html; charset=utf-8");
    20.         // 告诉服务器如何解析请求，用户输入的密码可能是中文
    21.         req.setCharacterEncoding("utf8");
    22.         String username = req.getParameter("username");
    23.         String password = req.getParameter("password");
    24.         if (username == null || password == null) {
    25.             resp.getWriter().write("你输入的账号或密码错误");
    26.             return;
    27.         }
    28.         User user = UserDao.selectByName(username);
    29.         if (user == null || !user.getPassword().equals(password)) {
    30.             System.out.println("这是因为浏览器默认按GDK来解读我们HTTP请求发过来的参数吗");
    31.             resp.getWriter().write("你输入的账号或密码错误");
    32.         }
    33.         else {
    34.             // tomcat把会话存到 内存中，服务器一重启，会话就消失了
    35.             // 登录之后，构造会话
    36.             HttpSession session = req.getSession(true); // 参数为true说明如果当前没有会话，就新建立一个会话
    37.             // 把刚才获取到的user对象给存到session里，方便后续使用
    38.             session.setAttribute("user", user);
    39.             // 返回一个重定向报文，跳转到博客列表页
    40.             resp.sendRedirect("blog_home.html");
    41.         }
    42.  
    43.     }
    44.  
    45.     @Override
    46.     // 检查用户是否登录，没登陆强转返回登录页面
    47.     protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    48.         // 看能不能从请求中取到session，也接是看看请求中有没有cookie，是否存了sessionId
    49.         HttpSession session = req.getSession(false);
    50.         if (session == null) {
    51.             // resp.sendRedirect("blog_login.html"); 为啥在后端就直接跳转不了，的确302了，但就是跳转不了
    52.             // 当前用户还为登录，可以在这里跳转，也可以设置设置一个状态值，返回给前端，让前端跳转
    53.             resp.setStatus(403);
    54.  
    55.             //resp.sendRedirect("blog_login.html"); // 强转跳转到登录页面
    56.         }
    57.  
    58.         else {
    59.             // 不做任何处理
    60.  
    61.             // resp.setStatus(200);
    62.         }
    63.     }
    64. }

    相关联的视图层的代码

    博客登录页（blog_login.html)：

    1. html>
    2. <html lang="en">
    3. <head>
    4.   <meta charset="UTF-8">
    5.   <meta http-equiv="X-UA-Compatible" content="IE=edge">
    6.   <meta name="viewport" content="width=device-width, initial-scale=1.0">
    7.   <title>用户登录title>
    8.   <link rel="stylesheet" href="common.css">
    9.   <link rel="stylesheet" href="bloglogin.css">
    10. head>
    11. <body>
    12.   
    13.   <div class="navigation">
    14.     <img src="image/大头贴.png">
    15.     <span>我的博客系统span>
    16.     
    17.     <span class="space">span>
    18.  
    19.     <a href="blog_home.html">主页a>
    20.     <a href="write_blog.html">写博客a>
    21.  
    22.   div>
    23.  
    24.    
    25.   <div class="container_login">
    26.     <form action="login" method="post">
    27.       <div class="dialog">
    28.         <h3 >登录h3>
    29.         <div class="row"> 
    30.           <span>用户名span>
    31.           
    32.           
    33.           <input type="text" id="username" name="username"> 
    34.         div>
    35.         <div class="row">
    36.           <span>密码span>
    37.           <input type="password" id="password" name="password">
    38.         div>
    39.         <div class="row">
    40.         <input type="submit" id="submit" value="登录">
    41.         div>
    42.         
    43.         <div class="row">
    44.           <div id="reg">
    45.             <a href="blog_reg.html">注册a>
    46.           div>
    47.          
    48.         div>
    49.       div>
    50.     form>
    51.  
    52.    
    53.  
    54.     
    55.   div>
    56. body>
    57. html>

    博客列表页（blog_detail.html)：

    1. html>
    2. <html lang="en">
    3. <head>
    4.   <meta charset="UTF-8">
    5.   <meta http-equiv="X-UA-Compatible" content="IE=edge">
    6.   <meta name="viewport" content="width=device-width, initial-scale=1.0">
    7.   <title>博客详情页title>
    8.   <link rel="stylesheet" href="common.css">
    9.   <link rel="stylesheet" href="blogdetail.css">
    10.  
    11.    
    12.    <link rel="stylesheet" href="editor.md/css/editormd.min.css" />
    13.    <script src="js/jquery.min.js">script>
    14.    <script src="editor.md/lib/marked.min.js">script>
    15.    <script src="editor.md/lib/prettify.min.js">script>
    16.    <script src="editor.md/editormd.js">script>
    17. head>
    18. <body>
    19.   
    20.   <div class="navigation">
    21.     <img src="image/大头贴.png">
    22.     <span>我的博客系统span>
    23.     
    24.     <span class="space">span>
    25.  
    26.     <a href="blog_home.html">主页a>
    27.     <a href="write_blog.html">写博客a>
    28.     <a href="logout">退出登录a>
    29.     
    30.     
    31.   div>
    32.   
    33.   <div class="container">
    34.     
    35.     <div class="left">
    36.       
    37.       <div class="card">
    38.         <img src="image/博客头像男.jpg">
    39.         <h3>是小鱼儿哈h3>
    40.         <a href="https://blog.csdn.net/weixin_61061381?type=blog">CSDN地址a>
    41.         <div class="counter">
    42.           <span>文章span>
    43.           <span>分类span>
    44.         div>
    45.         <div class="counter">
    46.           <span>67span>
    47.           <span>7span>
    48.         div>
    49.       div>
    50.       
    51.     div>
    52.     
    53.     <div class="right">
    54.       
    55.       <h2>h2>
    56.       
    57.       <div class="date">
    58.         
    59.       div> 
    60.  
    61.        
    62.        <div id="content" style="opacity: 80%">  
    63.                     
    64.       div>
    65.  
    66.     div>  
    67.   div>
    68.     
    69.     <script src="https://code.jquery.com/jquery-3.6.1.min.js">script>
    70.     <script>
    71.       // 通过这个函数，借助blogId，来从后端获取到这篇博客的作者，并把他显示在博客详情页上
    72.       function getAuthor() {
    73.         $.ajax({
    74.           type: 'get',
    75.           url: 'user' + location.search, //JS中可以通过location.search设置或获取网页地址跟在问号后面的部
    76.           
    77.           // 后端在查询失败的时候不要返回200，避免前端触发ajax中的sucess回调函数
    78.           success: function(body) {
    79.             let authorDiv = document.querySelector('.card h3');
    80.             // 但其实这一步也没什么必要，因为我们只是获取到原来的作者标签，并不是新建的标签，在获取到了后该标签所对应的className本来就是原来的名字，不用担心原来的css样式失效
    81.             authorDiv.className = '.card h3';
    82.             authorDiv.innerHTML = body.username;
    83.  
    84.             // 接下来我们根据后端返回的body，来确定是否在导航栏中显示删除该博客这个按键（只有当前博客的作者和登录的用户名一样才能删，只能删自己的）
    85.             // 所以我们就要在对应的后端代码中判断当前要删除的博客是否是自己的博客，在user/locatin.search所对应的后端servlet代码写相应的逻辑
    86.  
    87.             if (body.isYourBlog == 1) {
    88.               // 新增一个a标签
    89.               // alert("进入添加删除博客按钮的那个if语句了呀！"); 可以用了测试是否进入了该条件语句
    90.               let DeleteA = document.createElement('a');
    91.               DeleteA.href = "delete" + location.search; //JS中可以通过location.search设置或获取网页地址跟在问号后面的部分，即queryString
    92.               DeleteA.innerHTML = "删除该博客";
    93.  
    94.               // 注意，在JS中，单引号和双引号是不同的，下面的代码如果你用双引号，你就获取不到该组件
    95.               let navDiv = document.querySelector('.navigation'); 
    96.               // 此时navDiv就代码的类名是class=avigation这个组件，这次赋值后，该组件的名字并没有变
    97.               // 要想改变该组件的名字，还要通过 navDiv.className 来修改，让他被新的css选择器来修饰
    98.              
    99.               navDiv.appendChild(DeleteA);  // 把我们新增的a标签添加到导航栏中
    100.  
    101.  
    102.               // // 在导航栏中加个按钮, 用来删除文章. 
    103.               // let deleteA = document.createElement('a');
    104.               // // location.search 就是当前页面 url 的 query string, 也就是
    105.               // // ?blogId=1 这样的结果. 
    106.               // deleteA.href = 'blogDelete' + location.search;
    107.               // deleteA.innerHTML = '删除';
    108.  
    109.               // let navDiv = document.querySelector('.nav');
    110.               // navDiv.appendChild(deleteA);
    111.  
    112.             }
    113.           },
    114.           error: function() {
    115.             // 强行跳转到登录页面
    116.             location.assign('blog_login.html');
    117.           }
    118.         });
    119.       }
    120.  
    121.  
    122.       // 通过这个函数, 来获取到博客详情
    123.       function getBlogDetail() {
    124.         $.ajax({
    125.           type: 'get',
    126.           url: 'blog' + location.search, // servlet path,和获取博客列表一个地址，但获取博客列表不带blogId，显示博客详情带blogId
    127.           
    128.           // 后端在查询失败的时候不要返回200，避免前端触发ajax中的sucess回调函数
    129.           success: function(body) {
    130.           
    131.             // 根据返回的数据来构造页面
    132.             // rightDiv是我们博客详情，我们具体的博客内容要挂在rightDiv这个结点上
    133.             let rightDiv = document.querySelector('.right'); // 获取我们上面的右侧页面对象，接下来我们就可以对右侧页面对象进行操作来给我们页面添加元素
    134.             rightDiv.className = 'right'; // 引入css
    135.             // 博客标题构建与添加
    136.             // let titleDiv = document.createComment('div');
    137.             // titleDiv.className = 'h2';
    138.             // titleDiv.innerHTML = body.title;
    139.             // rightDiv.appendChild(titleDiv); // 把标题结点挂到博客详情上
    140.  
    141.             // // 创建该篇博客的发布日期，并把日期添加到博客详情rightDiv上
    142.             // let dateDiv = document.createComment('div');
    143.             // dateDiv.className = 'date';
    144.             // dateDiv.innerHTML = body.dateTime;
    145.             // rightDiv.appendChild(dateDiv);
    146.             // 博客标题
    147.             let titleDiv = document.querySelector('.right h2');
    148.             titleDiv.innerHTML = body.title;
    149.             // 发布日期
    150.             let dateDiv = document.querySelector('.right .date');
    151.             dateDiv.innerHTML = body.postTime;
    152.             // 创建内容
    153.             
    154.            
    155.             // 刚才这里是直接把正文内容设置到 innerHTML 中了, 没有渲染的过程的. 
    156.             // let divContent = document.querySelector('#content');
    157.             // divContent.innerHTML = body.content;
    158.             // 靠谱的做法, 应该是先使用 editor.md 进行渲染. 
    159.             // [重要] 这个方法就是 editor.md 提供的一个方法把 markdown 字符串转成格式化的效果. 
    160.             // 第一个参数是一个 div 的 id, 表示要把渲染结果放到哪个 div 中. 
    161.             // 第二个参数是一个 js 对象, 把正文内容传入即可. (还支持很多别的参数属性, 此处暂时不涉及)
    162.             editormd.markdownToHTML('content', {
    163.               markdown: body.content
    164.             });            
    165.           },
    166.           error: function() {
    167.             alert("获取博客详情失败！");
    168.           }
    169.  
    170.         });
    171.       }
    172.  
    173.       function checkLogin() {
    174.         $.ajax({
    175.           type: 'get',
    176.           url: 'login',
    177.           success: function(body) {
    178.             // 如果用户已经登录就什么也不做
    179.           },
    180.           error: function() {
    181.  
    182.           //alert("当前登录已过期，请重新登录！")
    183.  
    184.           // 403 就会触发 error
    185.             // 强行跳转到登录页面. 
    186.             location.assign('blog_login.html');
    187.           }
    188.         });
    189.       }
    190.       getBlogDetail();
    191.       checkLogin();
    192.       getAuthor();
    193.       
    194.      
    195.     script>
    196. body>
    197. html>

    博客详情页（blog_detail.html)：

    1. html>
    2. <html lang="en">
    3. <head>
    4.   <meta charset="UTF-8">
    5.   <meta http-equiv="X-UA-Compatible" content="IE=edge">
    6.   <meta name="viewport" content="width=device-width, initial-scale=1.0">
    7.   <title>博客详情页title>
    8.   <link rel="stylesheet" href="common.css">
    9.   <link rel="stylesheet" href="blogdetail.css">
    10.  
    11.    
    12.    <link rel="stylesheet" href="editor.md/css/editormd.min.css" />
    13.    <script src="js/jquery.min.js">script>
    14.    <script src="editor.md/lib/marked.min.js">script>
    15.    <script src="editor.md/lib/prettify.min.js">script>
    16.    <script src="editor.md/editormd.js">script>
    17. head>
    18. <body>
    19.   
    20.   <div class="navigation">
    21.     <img src="image/大头贴.png">
    22.     <span>我的博客系统span>
    23.     
    24.     <span class="space">span>
    25.  
    26.     <a href="blog_home.html">主页a>
    27.     <a href="write_blog.html">写博客a>
    28.     <a href="logout">退出登录a>
    29.     
    30.     
    31.   div>
    32.   
    33.   <div class="container">
    34.     
    35.     <div class="left">
    36.       
    37.       <div class="card">
    38.         <img src="image/博客头像男.jpg">
    39.         <h3>是小鱼儿哈h3>
    40.         <a href="https://blog.csdn.net/weixin_61061381?type=blog">CSDN地址a>
    41.         <div class="counter">
    42.           <span>文章span>
    43.           <span>分类span>
    44.         div>
    45.         <div class="counter">
    46.           <span>67span>
    47.           <span>7span>
    48.         div>
    49.       div>
    50.       
    51.     div>
    52.     
    53.     <div class="right">
    54.       
    55.       <h2>h2>
    56.       
    57.       <div class="date">
    58.         
    59.       div> 
    60.  
    61.        
    62.        <div id="content" style="opacity: 80%">  
    63.                     
    64.       div>
    65.  
    66.     div>  
    67.   div>
    68.     
    69.     <script src="https://code.jquery.com/jquery-3.6.1.min.js">script>
    70.     <script>
    71.       // 通过这个函数，借助blogId，来从后端获取到这篇博客的作者，并把他显示在博客详情页上
    72.       function getAuthor() {
    73.         $.ajax({
    74.           type: 'get',
    75.           url: 'user' + location.search, //JS中可以通过location.search设置或获取网页地址跟在问号后面的部
    76.           
    77.           // 后端在查询失败的时候不要返回200，避免前端触发ajax中的sucess回调函数
    78.           success: function(body) {
    79.             let authorDiv = document.querySelector('.card h3');
    80.             // 但其实这一步也没什么必要，因为我们只是获取到原来的作者标签，并不是新建的标签，在获取到了后该标签所对应的className本来就是原来的名字，不用担心原来的css样式失效
    81.             authorDiv.className = '.card h3';
    82.             authorDiv.innerHTML = body.username;
    83.  
    84.             // 接下来我们根据后端返回的body，来确定是否在导航栏中显示删除该博客这个按键（只有当前博客的作者和登录的用户名一样才能删，只能删自己的）
    85.             // 所以我们就要在对应的后端代码中判断当前要删除的博客是否是自己的博客，在user/locatin.search所对应的后端servlet代码写相应的逻辑
    86.  
    87.             if (body.isYourBlog == 1) {
    88.               // 新增一个a标签
    89.               // alert("进入添加删除博客按钮的那个if语句了呀！"); 可以用了测试是否进入了该条件语句
    90.               let DeleteA = document.createElement('a');
    91.               DeleteA.href = "delete" + location.search; //JS中可以通过location.search设置或获取网页地址跟在问号后面的部分，即queryString
    92.               DeleteA.innerHTML = "删除该博客";
    93.  
    94.               // 注意，在JS中，单引号和双引号是不同的，下面的代码如果你用双引号，你就获取不到该组件
    95.               let navDiv = document.querySelector('.navigation'); 
    96.               // 此时navDiv就代码的类名是class=avigation这个组件，这次赋值后，该组件的名字并没有变
    97.               // 要想改变该组件的名字，还要通过 navDiv.className 来修改，让他被新的css选择器来修饰
    98.              
    99.               navDiv.appendChild(DeleteA);  // 把我们新增的a标签添加到导航栏中
    100.  
    101.  
    102.               // // 在导航栏中加个按钮, 用来删除文章. 
    103.               // let deleteA = document.createElement('a');
    104.               // // location.search 就是当前页面 url 的 query string, 也就是
    105.               // // ?blogId=1 这样的结果. 
    106.               // deleteA.href = 'blogDelete' + location.search;
    107.               // deleteA.innerHTML = '删除';
    108.  
    109.               // let navDiv = document.querySelector('.nav');
    110.               // navDiv.appendChild(deleteA);
    111.  
    112.             }
    113.           },
    114.           error: function() {
    115.             // 强行跳转到登录页面
    116.             location.assign('blog_login.html');
    117.           }
    118.         });
    119.       }
    120.  
    121.  
    122.       // 通过这个函数, 来获取到博客详情
    123.       function getBlogDetail() {
    124.         $.ajax({
    125.           type: 'get',
    126.           url: 'blog' + location.search, // servlet path,和获取博客列表一个地址，但获取博客列表不带blogId，显示博客详情带blogId
    127.           
    128.           // 后端在查询失败的时候不要返回200，避免前端触发ajax中的sucess回调函数
    129.           success: function(body) {
    130.           
    131.             // 根据返回的数据来构造页面
    132.             // rightDiv是我们博客详情，我们具体的博客内容要挂在rightDiv这个结点上
    133.             let rightDiv = document.querySelector('.right'); // 获取我们上面的右侧页面对象，接下来我们就可以对右侧页面对象进行操作来给我们页面添加元素
    134.             rightDiv.className = 'right'; // 引入css
    135.             // 博客标题构建与添加
    136.             // let titleDiv = document.createComment('div');
    137.             // titleDiv.className = 'h2';
    138.             // titleDiv.innerHTML = body.title;
    139.             // rightDiv.appendChild(titleDiv); // 把标题结点挂到博客详情上
    140.  
    141.             // // 创建该篇博客的发布日期，并把日期添加到博客详情rightDiv上
    142.             // let dateDiv = document.createComment('div');
    143.             // dateDiv.className = 'date';
    144.             // dateDiv.innerHTML = body.dateTime;
    145.             // rightDiv.appendChild(dateDiv);
    146.             // 博客标题
    147.             let titleDiv = document.querySelector('.right h2');
    148.             titleDiv.innerHTML = body.title;
    149.             // 发布日期
    150.             let dateDiv = document.querySelector('.right .date');
    151.             dateDiv.innerHTML = body.postTime;
    152.             // 创建内容
    153.             
    154.            
    155.             // 刚才这里是直接把正文内容设置到 innerHTML 中了, 没有渲染的过程的. 
    156.             // let divContent = document.querySelector('#content');
    157.             // divContent.innerHTML = body.content;
    158.             // 靠谱的做法, 应该是先使用 editor.md 进行渲染. 
    159.             // [重要] 这个方法就是 editor.md 提供的一个方法把 markdown 字符串转成格式化的效果. 
    160.             // 第一个参数是一个 div 的 id, 表示要把渲染结果放到哪个 div 中. 
    161.             // 第二个参数是一个 js 对象, 把正文内容传入即可. (还支持很多别的参数属性, 此处暂时不涉及)
    162.             editormd.markdownToHTML('content', {
    163.               markdown: body.content
    164.             });            
    165.           },
    166.           error: function() {
    167.             alert("获取博客详情失败！");
    168.           }
    169.  
    170.         });
    171.       }
    172.  
    173.       function checkLogin() {
    174.         $.ajax({
    175.           type: 'get',
    176.           url: 'login',
    177.           success: function(body) {
    178.             // 如果用户已经登录就什么也不做
    179.           },
    180.           error: function() {
    181.  
    182.           //alert("当前登录已过期，请重新登录！")
    183.  
    184.           // 403 就会触发 error
    185.             // 强行跳转到登录页面. 
    186.             location.assign('blog_login.html');
    187.           }
    188.         });
    189.       }
    190.       getBlogDetail();
    191.       checkLogin();
    192.       getAuthor();
    193.       
    194.      
    195.     script>
    196. body>
    197. html>

    5.6 🍑LoginOutServlet代码

    LoginOutServlet用来应对视图层发来的注销登录的请求，当然也用到了模型层（User、UserDao)

    代码示例：

    1. package controller;
    2.  
    3. import javax.servlet.ServletException;
    4. import javax.servlet.annotation.WebServlet;
    5. import javax.servlet.http.HttpServlet;
    6. import javax.servlet.http.HttpServletRequest;
    7. import javax.servlet.http.HttpServletResponse;
    8. import javax.servlet.http.HttpSession;
    9. import java.io.IOException;
    10.  
    11. @WebServlet("/logout")
    12. public class LoginOutServlet extends HttpServlet {
    13.     // 我们是通过a标签跳转到这里来的，所以这里是get方法
    14.     @Override
    15.     protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    16.         // 获取当前的session，因为只有在用户以及登录的情况下，才会出现这个退出登录的按键，所以这里我们不考虑session为空
    17.         // 因为在req类中没有直接提供删除session的操作，所以为了简便我们这里就不删session
    18.         // 我们这里的退出登录只是把session里的user键值对中的值给删除了，但session还在，sessionId还在，也就是请求中的cookie还在
    19.         // 这也是为啥我们在判断当前用户是否登录是还要专门判断session在的user的值还在不在（user是否为空），如果不再说明我们已经通过这种方式，退出了登录
    20.         HttpSession session = req.getSession(false);
    21.         session.setAttribute("user", null);
    22.         // 重定向报文，强制跳转到登录页面，既然以及退出登录了，肯定要重新登录呀！！
    23.         resp.sendRedirect("blog_login.html");
    24.     }
    25. }

    5.7 🍑RegServlet代码

    RegServlet代码用来注册用户，当然和视图层（注册页）和模型层（User、UserDao)也有联系

    代码示例：

    1. package controller;
    2.  
    3. import mode.User;
    4. import mode.UserDao;
    5.  
    6. import javax.servlet.ServletException;
    7. import javax.servlet.annotation.WebServlet;
    8. import javax.servlet.http.HttpServlet;
    9. import javax.servlet.http.HttpServletRequest;
    10. import javax.servlet.http.HttpServletResponse;
    11.  
    12. import java.io.IOException;
    13.  
    14.  
    15. // 处理用户注册
    16. @WebServlet("/reg")
    17. public class RegServlet extends HttpServlet {
    18.     @Override
    19.     protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    20.  
    21.         req.setCharacterEncoding("utf-8");
    22.  
    23.  
    24.         String username = req.getParameter("username");
    25.         String password1 = req.getParameter("password1");
    26.         String password2 = req.getParameter("password2");
    27.  
    28.         if (username == null | password1 == null | password2 == null) {
    29.             resp.setStatus(403);
    30.             resp.setContentType("text/html; charset=utf-8");
    31.             resp.getWriter().write("你的输入不能为空！请重新输入！！");
    32.             // resp.sendRedirect("blog_reg.html");
    33.             // 因为我们是用from表单提交的，前端跳转后，我们无法给用户提示信息
    34.             // 在有跳转的情况下，我们的提示信息显示不出来，所以我们干脆就不跳转，让用户手动跳转，重新注册
    35.  
    36.         }
    37.         // 密码不一致也不行
    38.         else if (!password1.equals(password2)) { // 注意因为这里是字符所以我们，要用equals
    39.             resp.setStatus(403);
    40.             resp.setContentType("text/html; charset=utf-8");
    41.             // 下面是返回了一个js弹窗
    42.             //resp.getWriter().write("");
    43.  
    44.             resp.getWriter().write("两次输入的密码不一致！请重新输入！！");
    45.             //resp.sendRedirect("blog_reg.html");
    46.  
    47.         } else {
    48.             // 如果程序走到这里说明，说明用户的提交没什么问题，我们可以开始给用户注册了
    49.             User user = new User();
    50.             user.setUsername(username);
    51.             user.setPassword(password1);
    52.             int ret = UserDao.insertUser(user);
    53.             if (ret == 0) {
    54.                 // 注册成功，跳转到登录页面
    55.                 System.out.println("注册成功！");
    56.                 resp.sendRedirect("blog_login.html");
    57.             }
    58.             else {
    59.                 // 注册失败，新增用户失败，当前用户名已经被注册过了
    60.                 resp.setStatus(403);
    61.                 System.out.println("注册失败！");
    62.                 resp.setContentType("text/html; charset=utf-8");
    63.                 resp.getWriter().write("当前用户已存在，请重新输入！！");
    64.                 //resp.sendRedirect("blog_reg.html");
    65.             }
    66.  
    67.         }
    68.     }
    69. }

    六、视图层（view)总代码展示

    6.1 🏀博客登录页

    1. html>
    2. <html lang="en">
    3. <head>
    4.   <meta charset="UTF-8">
    5.   <meta http-equiv="X-UA-Compatible" content="IE=edge">
    6.   <meta name="viewport" content="width=device-width, initial-scale=1.0">
    7.   <title>用户登录title>
    8.   <link rel="stylesheet" href="common.css">
    9.   <link rel="stylesheet" href="bloglogin.css">
    10. head>
    11. <body>
    12.   
    13.   <div class="navigation">
    14.     <img src="image/大头贴.png">
    15.     <span>我的博客系统span>
    16.     
    17.     <span class="space">span>
    18.  
    19.     <a href="blog_home.html">主页a>
    20.     <a href="write_blog.html">写博客a>
    21.  
    22.   div>
    23.  
    24.    
    25.   <div class="container_login">
    26.     <form action="login" method="post">
    27.       <div class="dialog">
    28.         <h3 >登录h3>
    29.         <div class="row"> 
    30.           <span>用户名span>
    31.           
    32.           
    33.           <input type="text" id="username" name="username"> 
    34.         div>
    35.         <div class="row">
    36.           <span>密码span>
    37.           <input type="password" id="password" name="password">
    38.         div>
    39.         <div class="row">
    40.         <input type="submit" id="submit" value="登录">
    41.         div>
    42.         
    43.         <div class="row">
    44.           <div id="reg">
    45.             <a href="blog_reg.html">注册a>
    46.           div>
    47.          
    48.         div>
    49.       div>
    50.     form>
    51.  
    52.    
    53.  
    54.     
    55.   div>
    56. body>
    57. html>
    58.  
    59.  
    60.  
    61.  
    62.  
    63.  
    64.  
    65.  
    66.  
    67.  
    68.

    6.2 🏀博客注册页

    1. html>
    2. <html lang="en">
    3. <head>
    4.   <meta charset="UTF-8">
    5.   <meta http-equiv="X-UA-Compatible" content="IE=edge">
    6.   <meta name="viewport" content="width=device-width, initial-scale=1.0">
    7.   <title>用户注册title>
    8.   <link rel="stylesheet" href="common.css">
    9.   <link rel="stylesheet" href="blogreg.css">
    10. head>
    11. <body>
    12.   
    13.   <div class="navigation">
    14.     <img src="image/大头贴.png">
    15.     <span>我的博客系统span>
    16.     
    17.     <span class="space">span>
    18.     
    19.     <a href="blog_login.html">登录a>
    20.     
    21.  
    22.   div>
    23.  
    24.    
    25.   <div class="container_reg">
    26.     <form action="reg" method="post">
    27.       <div class="dialog">
    28.         <h3 >注册h3>
    29.         <div class="row"> 
    30.           <span>用户名span>
    31.           
    32.           
    33.           <input type="text" id="username" name="username"> 
    34.         div>
    35.         <div class="row">
    36.           <span>密码span>
    37.           <input type="password" id="password1" name="password1">
    38.         div>
    39.         <div class="row">
    40.             <span>确认密码span>
    41.             <input type="password" id="password2" name="password2">
    42.           div>
    43.  
    44.         <div class="row">
    45.         <input type="submit" id="submit" value="注册">
    46.         div>
    47.         
    48.       
    49.       div>
    50.     form>
    51.  
    52.    
    53.  
    54.     
    55.   div>
    56. body>
    57. html>
    58.  
    59.  
    60.  
    61.  
    62.  
    63.  
    64.  
    65.  
    66.  
    67.  
    68.

    6.3 🏀博客列表页

    1. html>
    2. <html lang="en">
    3. <head>
    4.   <meta charset="UTF-8">
    5.   <meta http-equiv="X-UA-Compatible" content="IE=edge">
    6.   <meta name="viewport" content="width=device-width, initial-scale=1.0">
    7.   <title>博客主页title>
    8.   <link rel="stylesheet" href="common.css">
    9.   <link rel="stylesheet" href="bologlist.css">
    10.  
    11. head>
    12. <body>
    13.   
    14.   <div class="navigation">
    15.     <img src="image/大头贴.png">
    16.     <span>我的博客系统span>
    17.     
    18.     <span class="space">span>
    19.  
    20.     <a href="blog_home.html">主页a>
    21.     <a href="write_blog.html">写博客a>
    22.     <a href="logout">退出登录a>
    23.     
    24.   div>
    25.   
    26.   <div class="container">
    27.     
    28.     <div class="left">
    29.       
    30.       <div class="card">
    31.         <img src="image/博客头像男.jpg">
    32.         <h3>未央h3>
    33.         <a href="https://blog.csdn.net/weixin_61061381?type=blog">CSDN地址a>
    34.         <div class="counter">
    35.           <span>文章span>
    36.           <span>分类span>
    37.         div>
    38.         <div class="counter">
    39.           <span>67span>
    40.           <span>7span>
    41.         div>
    42.       div>
    43.     div>
    44.     
    45.     <div class="right">
    46.     
    47.     
    48.     div>
    49.    
    50.   div>
    51.   
    52.    
    53.    <script src="https://code.jquery.com/jquery-3.6.1.min.js">script>
    54.    <script>
    55.      // 通过该函数，从后端获取到当前登录的用户是谁，并把它显示在博客列表页上
    56.      function getUser() {
    57.       $.ajax({
    58.         type: 'get',
    59.         url: 'user',
    60.         success: function(body) {
    61.           // 替换条原来的用户信息
    62.           let userDiv = document.querySelector('.card h3');
    63.           // 引入css，因为我们css就是按原来的类选择器来设置样式的
    64.            // 但其实这一步也没什么必要，因为我们只是获取到原来的作者标签，并不是新建的标签，在获取到了后该标签所对应的className本来就是原来的名字，不用担心原来的css样式失效
    65.           userDiv.className = '.card h3';
    66.           userDiv.innerHTML = body.username;
    67.         },
    68.         error: function() {
    69.            // 强行跳转到登录页面. 
    70.            location.assign('blog_login.html');
    71.         }
    72.       });
    73.      }
    74.      // 你要明白一个html文件，在加载的过程中，是可以同时执行多个函数、多个ajax同时发送请求的
    75.      // 通过这个函数, 来从服务器获取到博客列表的数据
    76.      function getBlogList() {
    77.          $.ajax({
    78.              type: 'get',
    79.              url: 'blog',  // servlet path, 在页面加载的过程中就会调用主机ip + contentPath + 这个servlet path(就@WebServlet后的地址)
    80.              //dataType: 'json',
    81.              success: function(body) {
    82.                  // 根据返回的 json 数据, 来构造出页面内容, div.blog
    83.                  // jquery ajax 会自动的把响应得到的 body 按照响应的 Content-Type 进行转换格式. 
    84.                  // 如果响应的 Content-Type 是 json, 此时就会自动把 body 转成 js 的对象
    85.                  let rightDiv = document.querySelector('.right');
    86.                  for (let blog of body) {
    87.                      // 新建博客结点
    88.                      let blogDiv = document.createElement('div');
    89.                      blogDiv.className = 'blog'; // 引入CSS属性
    90.                      // 创建博客标题
    91.                      let titleDiv = document.createElement('div');
    92.                      titleDiv.className = 'title';
    93.                      titleDiv.innerHTML = blog.title;
    94.                      blogDiv.appendChild(titleDiv); // 把博客标题挂到博客结点上
    95.                      // 创建日期
    96.                      let dateDiv = document.createElement('div');
    97.                      dateDiv.className = 'date';
    98.                      dateDiv.innerHTML = blog.postTime;
    99.                      blogDiv.appendChild(dateDiv);  // 把博客日期挂到博客结点上
    100.                      // 创建摘要
    101.                      let descDiv = document.createElement('div');
    102.                      descDiv.className = 'desc';
    103.                      descDiv.innerHTML = blog.content;
    104.                      blogDiv.appendChild(descDiv);  // 把博客摘要挂到博客结点上
    105.                      // 创建查看全文按钮
    106.                      let a = document.createElement('a');
    107.                      a.innerHTML = '查看全文 >>';
    108.                      // a标签跳转的过程就相当于是发了一个get请求，这里我们在跳转的url地址后加上要传递的参数，即QueryString,等下我们在博客详情页也会用到这个参数
    109.                      a.href = 'blog_detail.html?blogId=' + blog.blogId;
    110.                      blogDiv.appendChild(a);
    111.                      // 把 blogDiv 加入外层元素
    112.                      rightDiv.appendChild(blogDiv);  // 把构建好的一篇博客挂到博客列表上
    113.                  }
    114.              },
    115.              error: function() {
    116.               alert("获取博客列表失败！")
    117.              }
    118.          });
    119.      }
    120.      function checkLogin() {
    121.       $.ajax({
    122.         type: 'get',
    123.         url: 'login',
    124.         success: function(body) {
    125.           // 如果用户已经登录就什么也不做
    126.         },
    127.         error: function() {
    128.  
    129.           //alert("当前登录已过期，请重新登录！")
    130.  
    131.           // 403 就会触发 error
    132.             // 强行跳转到登录页面. 
    133.             location.assign('blog_login.html');
    134.         }
    135.       });
    136.      }
    137.      getBlogList(); // 不用忘了调用函数
    138.      checkLogin();
    139.      getUser();
    140.     script>
    141.      
    142. body>
    143. html>
    144.  
    145.  
    146.  
    147.  
    148.  
    149.  
    150.  
    151.  
    152.  
    153.  
    154.

    6.4 🏀博客详情页

    1. html>
    2. <html lang="en">
    3. <head>
    4.   <meta charset="UTF-8">
    5.   <meta http-equiv="X-UA-Compatible" content="IE=edge">
    6.   <meta name="viewport" content="width=device-width, initial-scale=1.0">
    7.   <title>博客详情页title>
    8.   <link rel="stylesheet" href="common.css">
    9.   <link rel="stylesheet" href="blogdetail.css">
    10.  
    11.    
    12.    <link rel="stylesheet" href="editor.md/css/editormd.min.css" />
    13.    <script src="js/jquery.min.js">script>
    14.    <script src="editor.md/lib/marked.min.js">script>
    15.    <script src="editor.md/lib/prettify.min.js">script>
    16.    <script src="editor.md/editormd.js">script>
    17. head>
    18. <body>
    19.   
    20.   <div class="navigation">
    21.     <img src="image/大头贴.png">
    22.     <span>我的博客系统span>
    23.     
    24.     <span class="space">span>
    25.  
    26.     <a href="blog_home.html">主页a>
    27.     <a href="write_blog.html">写博客a>
    28.     <a href="logout">退出登录a>
    29.     
    30.     
    31.   div>
    32.   
    33.   <div class="container">
    34.     
    35.     <div class="left">
    36.       
    37.       <div class="card">
    38.         <img src="image/博客头像男.jpg">
    39.         <h3>未央h3>
    40.         <a href="https://blog.csdn.net/weixin_61061381?type=blog">CSDN地址a>
    41.         <div class="counter">
    42.           <span>文章span>
    43.           <span>分类span>
    44.         div>
    45.         <div class="counter">
    46.           <span>67span>
    47.           <span>7span>
    48.         div>
    49.       div>
    50.       
    51.     div>
    52.     
    53.     <div class="right">
    54.       
    55.       <h2>h2>
    56.       
    57.       <div class="date">
    58.         
    59.       div> 
    60.  
    61.        
    62.        <div id="content" style="opacity: 80%">  
    63.                     
    64.       div>
    65.  
    66.     div>  
    67.   div>
    68.     
    69.     <script src="https://code.jquery.com/jquery-3.6.1.min.js">script>
    70.     <script>
    71.       // 通过这个函数，借助blogId，来从后端获取到这篇博客的作者，并把他显示在博客详情页上
    72.       function getAuthor() {
    73.         $.ajax({
    74.           type: 'get',
    75.           url: 'user' + location.search, //JS中可以通过location.search设置或获取网页地址跟在问号后面的部
    76.           
    77.           // 后端在查询失败的时候不要返回200，避免前端触发ajax中的sucess回调函数
    78.           success: function(body) {
    79.             let authorDiv = document.querySelector('.card h3');
    80.             // 但其实这一步也没什么必要，因为我们只是获取到原来的作者标签，并不是新建的标签，在获取到了后该标签所对应的className本来就是原来的名字，不用担心原来的css样式失效
    81.             authorDiv.className = '.card h3';
    82.             authorDiv.innerHTML = body.username;
    83.  
    84.             // 接下来我们根据后端返回的body，来确定是否在导航栏中显示删除该博客这个按键（只有当前博客的作者和登录的用户名一样才能删，只能删自己的）
    85.             // 所以我们就要在对应的后端代码中判断当前要删除的博客是否是自己的博客，在user/locatin.search所对应的后端servlet代码写相应的逻辑
    86.  
    87.             if (body.isYourBlog == 1) {
    88.               // 新增一个a标签
    89.               // alert("进入添加删除博客按钮的那个if语句了呀！"); 可以用了测试是否进入了该条件语句
    90.               let DeleteA = document.createElement('a');
    91.               DeleteA.href = "delete" + location.search; //JS中可以通过location.search设置或获取网页地址跟在问号后面的部分，即queryString
    92.               DeleteA.innerHTML = "删除该博客";
    93.  
    94.               // 注意，在JS中，单引号和双引号是不同的，下面的代码如果你用双引号，你就获取不到该组件
    95.               let navDiv = document.querySelector('.navigation'); 
    96.               // 此时navDiv就代码的类名是class=avigation这个组件，这次赋值后，该组件的名字并没有变
    97.               // 要想改变该组件的名字，还要通过 navDiv.className 来修改，让他被新的css选择器来修饰
    98.              
    99.               navDiv.appendChild(DeleteA);  // 把我们新增的a标签添加到导航栏中
    100.  
    101.  
    102.               // // 在导航栏中加个按钮, 用来删除文章. 
    103.               // let deleteA = document.createElement('a');
    104.               // // location.search 就是当前页面 url 的 query string, 也就是
    105.               // // ?blogId=1 这样的结果. 
    106.               // deleteA.href = 'blogDelete' + location.search;
    107.               // deleteA.innerHTML = '删除';
    108.  
    109.               // let navDiv = document.querySelector('.nav');
    110.               // navDiv.appendChild(deleteA);
    111.  
    112.             }
    113.           },
    114.           error: function() {
    115.             // 强行跳转到登录页面
    116.             location.assign('blog_login.html');
    117.           }
    118.         });
    119.       }
    120.  
    121.  
    122.       // 通过这个函数, 来获取到博客详情
    123.       function getBlogDetail() {
    124.         $.ajax({
    125.           type: 'get',
    126.           url: 'blog' + location.search, // servlet path,和获取博客列表一个地址，但获取博客列表不带blogId，显示博客详情带blogId
    127.           
    128.           // 后端在查询失败的时候不要返回200，避免前端触发ajax中的sucess回调函数
    129.           success: function(body) {
    130.           
    131.             // 根据返回的数据来构造页面
    132.             // rightDiv是我们博客详情，我们具体的博客内容要挂在rightDiv这个结点上
    133.             let rightDiv = document.querySelector('.right'); // 获取我们上面的右侧页面对象，接下来我们就可以对右侧页面对象进行操作来给我们页面添加元素
    134.             rightDiv.className = 'right'; // 引入css
    135.             // 博客标题构建与添加
    136.             // let titleDiv = document.createComment('div');
    137.             // titleDiv.className = 'h2';
    138.             // titleDiv.innerHTML = body.title;
    139.             // rightDiv.appendChild(titleDiv); // 把标题结点挂到博客详情上
    140.  
    141.             // // 创建该篇博客的发布日期，并把日期添加到博客详情rightDiv上
    142.             // let dateDiv = document.createComment('div');
    143.             // dateDiv.className = 'date';
    144.             // dateDiv.innerHTML = body.dateTime;
    145.             // rightDiv.appendChild(dateDiv);
    146.             // 博客标题
    147.             let titleDiv = document.querySelector('.right h2');
    148.             titleDiv.innerHTML = body.title;
    149.             // 发布日期
    150.             let dateDiv = document.querySelector('.right .date');
    151.             dateDiv.innerHTML = body.postTime;
    152.             // 创建内容
    153.             
    154.            
    155.             // 刚才这里是直接把正文内容设置到 innerHTML 中了, 没有渲染的过程的. 
    156.             // let divContent = document.querySelector('#content');
    157.             // divContent.innerHTML = body.content;
    158.             // 靠谱的做法, 应该是先使用 editor.md 进行渲染. 
    159.             // [重要] 这个方法就是 editor.md 提供的一个方法把 markdown 字符串转成格式化的效果. 
    160.             // 第一个参数是一个 div 的 id, 表示要把渲染结果放到哪个 div 中. 
    161.             // 第二个参数是一个 js 对象, 把正文内容传入即可. (还支持很多别的参数属性, 此处暂时不涉及)
    162.             editormd.markdownToHTML('content', {
    163.               markdown: body.content
    164.             });            
    165.           },
    166.           error: function() {
    167.             alert("获取博客详情失败！");
    168.           }
    169.  
    170.         });
    171.       }
    172.  
    173.       function checkLogin() {
    174.         $.ajax({
    175.           type: 'get',
    176.           url: 'login',
    177.           success: function(body) {
    178.             // 如果用户已经登录就什么也不做
    179.           },
    180.           error: function() {
    181.  
    182.           //alert("当前登录已过期，请重新登录！")
    183.  
    184.           // 403 就会触发 error
    185.             // 强行跳转到登录页面. 
    186.             location.assign('blog_login.html');
    187.           }
    188.         });
    189.       }
    190.       getBlogDetail();
    191.       checkLogin();
    192.       getAuthor();
    193.       
    194.      
    195.     script>
    196. body>
    197. html>

    6.5 🏀博客编辑页

    1. html>
    2. <html lang="en">
    3. <head>
    4.   <meta charset="UTF-8">
    5.   <meta http-equiv="X-UA-Compatible" content="IE=edge">
    6.   <meta name="viewport" content="width=device-width, initial-scale=1.0">
    7.   <title>开始书写吧title>
    8.   <link rel="stylesheet" href="common.css">
    9.   <link rel="stylesheet" href="writeblog.css">
    10.    
    11.    <link rel="stylesheet" href="editor.md/css/editormd.min.css" />
    12.    <script src="js/jquery.min.js">script>
    13.    <script src="editor.md/lib/marked.min.js">script>
    14.    <script src="editor.md/lib/prettify.min.js">script>
    15.    <script src="editor.md/editormd.js">script>
    16. head>
    17. <body>
    18.   
    19.   <div class="navigation">
    20.     <img src="image/大头贴.png">
    21.     <span>我的博客系统span>
    22.     
    23.     <span class="space">span>
    24.  
    25.     <a href="blog_home.html">主页a>
    26.     <a href="write_blog.html">写博客a>
    27.     <a href="logout">退出登录a>
    28.   div>
    29.   <div class="blog-edit-container"> 
    30.     
    31.     <form action="blog" method="post" style="height: 100%">
    32.        
    33.       <div class="title">
    34.       
    35.         <input type="text" id="title" placeholder="请输入文章标题", name="title">
    36.         <input type="submit" id="submit" value="发布文章">
    37.       div>
    38.     
    39.       
    40.       <div id="editor">
    41.         
    42.         
    43.         <textarea name="content" style="display: none;">textarea>
    44.       div>
    45.     form>
    46.  
    47.     <script>
    48.       // 初始化编辑器
    49.       var editor = editormd("editor", {
    50.           // 这里的尺寸必须在这里设置. 设置样式会被 editormd 自动覆盖掉. 
    51.           width: "100%",
    52.           // 设定编辑器高度,这个100%是相对于父元素的高度，此时editor的父元素的from, 但form没高度，所以我们要把from的高度设置一下
    53.           height: "calc(100% - 50px)",
    54.           // 编辑器中的初始内容
    55.           markdown: "# 在这里写下一篇博客",
    56.           // 指定 editor.md 依赖的插件路径
    57.           path: "editor.md/lib/",
    58.           // 加上这个属性，效果就是把编辑器里的内容给自动保存到textarea里
    59.           saveHTMLToTextarea:true,
    60.       });
    61.  
    62.       // 检查当前用户是否登录，如果未登录就强制跳转到登录界面
    63.       function checkLogin() {
    64.         $.ajax({
    65.         type: 'get',
    66.         url: 'login',
    67.         success: function(body) {
    68.           // 如果用户已经登录就什么也不做
    69.         },
    70.         error: function() {
    71.  
    72.           //alert("当前登录已过期，请重新登录！")
    73.  
    74.           // 403 就会触发 error
    75.             // 强行跳转到登录页面. 
    76.             location.assign('blog_login.html');
    77.         }
    78.         });
    79.       }
    80.       // 别忘了函数调用
    81.       checkLogin() // 这样函数在页面加载的时候就会调用
    82.     script>
    83.   div>
    84.   
    85.   
    86. body>
    87. html>

    6.6 🏀视图层对应的css代码

    还有他们各自对应的css代码，

    注意：css代码和html代码在同一个目录下，共同的样式common.css;

    1. /* 导航栏的样式 */
    2. * {
    3.   margin: 0;
    4.   padding: 0;
    5.   box-sizing: border-box;
    6. }
    7. html, body {
    8.   height: 100%;
    9.   background-image: url(image/未来风\(1\).jpg);
    10.   background-repeat: no-repeat;
    11.   background-position: center center;
    12.   background-size: cover;
    13. }
    14. .navigation {
    15.   width: 100%;
    16.   height: 50px;
    17.   background-color: rgba(50, 50, 50, 0.4);
    18.   color: rgb(255, 255, 255);
    19.   display: flex;
    20.   /* 实现元素垂直居中 */
    21.   align-items: center;
    22. }
    23. .navigation img {
    24.   height: 40px;
    25.   width: 40px;
    26.   border-radius: 50%;
    27.   margin-left: 30px;
    28.   margin-right: 10px;
    29. }
    30. .navigation .space {
    31.   width: 68%;
    32. }
    33. .navigation a {
    34.   /* 去掉下划线 */
    35.   text-decoration: none;
    36.   color: rgb(255, 255, 255);
    37.   justify-content: space-between;
    38.   padding: 0 10px;
    39.   display: flex;
    40.   
    41. }
    42. .container {
    43.   width: 1000px;
    44.   height: calc(100% - 50px);
    45.   /* 要弄成弹性布局，要不然右块内容就另起一行了 */
    46.   display: flex;
    47.   /* 水平居中 */
    48.   margin: 0 auto;
    49.   /* 左右两块中间留出间距 */
    50.   justify-content: space-between;
    51.   /* 想一下为啥justify-content: center不能让两块居中; */
    52.   
    53. }
    54. .container .left {
    55.   height: 100%;
    56.   width: 200px;
    57.   
    58. }
    59. .container .right {
    60.   height: 100%;
    61.   width: 795px;
    62.   background-color: rgba(255, 255, 255, 0.7);
    63.   border-radius: 10px;
    64.   /* 处理异常问题 */
    65.   overflow:auto;
    66. }
    67. .card {
    68.   /* card的宽度默认是200px,与父类相同 */
    69.   background-color: rgba(255, 255, 255, 0.7);
    70.   /* 注意棱角 */
    71.   border-radius: 10px;
    72.   /* 通过内边距使得头像水平居中，200 = 140 + 2 * 30 */
    73.   padding: 30px;
    74. }
    75.  
    76. /* 用户头像 */
    77. .card img {
    78.   width: 140px;
    79.   height: 140px;
    80.   border-radius: 70px;
    81. }
    82. .card h3 {
    83.   text-align: center;
    84.   margin: 5px;
    85. }
    86. .card a{
    87.   /* 行级元素变成块级元素，因为行级元素无法指定大小 */
    88.   display: block;
    89.   /* 去掉下划线 */
    90.   text-decoration: none;
    91.   /* 文本居中 */
    92.   text-align: center;
    93.   color: rgba(50, 50, 50, 0.4);
    94.   padding: 5px;
    95. }
    96. .card .counter {
    97.   display: flex;
    98.   /* 使得他们左右进行分离排列 */
    99.   justify-content: space-around;
    100.   margin: 5px;
    101. }
    102.

    博客登录页所对应的css代码:

    1. .container_reg {
    2.   width: 100%;
    3.   /* 要注意减去导航栏的高度 */
    4.   height: calc(100% - 50px);
    5.   display: flex;
    6.  
    7.   align-items: center;
    8.   justify-content: center;
    9. }
    10. .container_reg .dialog {
    11.   width: 400px;
    12.   height: 400px;
    13.   background-color: rgba(255, 255, 255, 0.6);
    14.   /* 边框圆角 */
    15.   border-radius: 10px;
    16. }
    17. .dialog h3 {
    18.   margin: 30px;
    19.   text-align: center;
    20. }
    21.  
    22. .dialog .row {
    23.   width: 100%;
    24.   height: 50px;
    25.   display: flex;
    26.   justify-content: center;
    27.   align-items: center;
    28.   padding: 20px;
    29. }
    30. .dialog .row span {
    31.   display: block;
    32.  
    33.   width: 100px;
    34.   height: 40px;
    35.   font-weight: 700;
    36.   /* 文本水平居中 */
    37.   text-align: center;
    38.   padding-top: 10px;
    39.   padding-bottom: 10px;
    40.  
    41. }
    42. .dialog .row #username, #password1, #password2 {
    43.   display: block;
    44.   width: 200px;
    45.   height: 40px;
    46.   border-radius: 10px;
    47.  
    48.   /* 设置左内边距，使得输入的数据与边框隔开 */
    49.   padding-left: 10px;
    50.   /* 去掉边框线,和轮廓线 */
    51.   border: none;
    52.   outline: none;
    53.   /* 设置字体大小，和输入时字体的位置 */
    54.   font-size: 22px;
    55.   /* 文本垂直居中 */
    56.   line-height: 40px;
    57. }
    58. /*注册提交框*/
    59. .dialog .row #submit {
    60.   width: 300px;
    61.   height: 40px;
    62.   margin-left: 50px;
    63.   margin-right: 30px;
    64.   background-color: rgb(0, 189, 189);
    65.   font-size: large;
    66.   /*设置边框中的文本位置*/
    67.   text-align: center;
    68.   padding-top: 5px;
    69.   padding-bottom: 5px;
    70.  
    71. }

    博客注册页对应的css:

    1. .container_reg {
    2.   width: 100%;
    3.   /* 要注意减去导航栏的高度 */
    4.   height: calc(100% - 50px);
    5.   display: flex;
    6.  
    7.   align-items: center;
    8.   justify-content: center;
    9. }
    10. .container_reg .dialog {
    11.   width: 400px;
    12.   height: 400px;
    13.   background-color: rgba(255, 255, 255, 0.6);
    14.   /* 边框圆角 */
    15.   border-radius: 10px;
    16. }
    17. .dialog h3 {
    18.   margin: 30px;
    19.   text-align: center;
    20. }
    21.  
    22. .dialog .row {
    23.   width: 100%;
    24.   height: 50px;
    25.   display: flex;
    26.   justify-content: center;
    27.   align-items: center;
    28.   padding: 20px;
    29. }
    30. .dialog .row span {
    31.   display: block;
    32.  
    33.   width: 100px;
    34.   height: 40px;
    35.   font-weight: 700;
    36.   /* 文本水平居中 */
    37.   text-align: center;
    38.   padding-top: 10px;
    39.   padding-bottom: 10px;
    40.  
    41. }
    42. .dialog .row #username, #password1, #password2 {
    43.   display: block;
    44.   width: 200px;
    45.   height: 40px;
    46.   border-radius: 10px;
    47.  
    48.   /* 设置左内边距，使得输入的数据与边框隔开 */
    49.   padding-left: 10px;
    50.   /* 去掉边框线,和轮廓线 */
    51.   border: none;
    52.   outline: none;
    53.   /* 设置字体大小，和输入时字体的位置 */
    54.   font-size: 22px;
    55.   /* 文本垂直居中 */
    56.   line-height: 40px;
    57. }
    58. /*注册提交框*/
    59. .dialog .row #submit {
    60.   width: 300px;
    61.   height: 40px;
    62.   margin-left: 50px;
    63.   margin-right: 30px;
    64.   background-color: rgb(0, 189, 189);
    65.   font-size: large;
    66.   /*设置边框中的文本位置*/
    67.   text-align: center;
    68.   padding-top: 5px;
    69.   padding-bottom: 5px;
    70.  
    71. }

    博客列表页对应的css:

    1. /* 博客主页中博客概述、博客列表中的页面个数 */
    2. .blog {
    3.   width: 100%;
    4.   /* blog的宽度和父元素right是一样的，
    5.   而高度如果不设定的话，就取决于内容高度的总和
    6.   所以我们在这里不设置高度 */
    7.   padding: 10px;
    8.   /* 当我们要注意设置每一篇博客的间距 */
    9. }
    10. .blog .title {
    11.   /* 设置字体大小和粗细 */
    12.   font-size: 18px;
    13.   font-weight: 600;
    14.   /* 居中 */
    15.   text-align: center;
    16.   padding-top: 10px;
    17.   padding-bottom: 5px;
    18. }
    19. .blog .date {
    20.   padding: 5px;
    21.   color: darkgoldenrod;
    22.   text-align: center;
    23. }
    24. .blog .desc, p{
    25.   /* 首行缩进, 注意在博客详情页的每一段落也要首行缩进*/
    26.   text-indent: 2em;
    27. }
    28. .blog a {
    29.   width: 140px;
    30.   height: 40px;
    31.   text-decoration: none;
    32.   color: #000;
    33.  
    34.   /* 行级元素无法改变高度和宽度 */
    35.   display: block;
    36.   font-size: 15px;
    37.   font-weight: 300px;
    38.   /* 文本内容水平居中 */
    39.   text-align: center;
    40.   /* 文本框垂直居中 */
    41.   line-height: 40px;
    42.  
    43.   /* 边框的上下边距5px,水平居中 */
    44.   margin: 5px auto;
    45.   display: flex;
    46.  
    47.   /* 边框线条粗细2px,颜色黑色，边框线条：实线 */
    48.   border: 2px black solid;
    49.   /* 当用户点击文本框：查看全文时，产生渐变效果 */
    50.   transition: all 1.5s;
    51. }
    52. .blog a:hover {
    53.   /* 设置渐变效果的颜色 */
    54.   background-color: orange;
    55. }

    博客详情页对应的css:

    1. /* 博客详情页的格式 */
    2.  
    3. p {
    4.   text-indent: 2em;
    5.   /* 给自然段和自然段之间设置间距 */
    6.   padding: 10px;
    7. }
    8. .right h2 {
    9.   padding: 15px;
    10.   text-align: center;
    11. }
    12. .right .date {
    13.   text-align: center;
    14.   color: orange;
    15.   /* 水平居中 */
    16.   padding-top: 0x;
    17.   padding-bottom: 15px;
    18. }

    博客编辑页对应的css:

    1. .blog-edit-container {
    2.   width: 1000px;
    3.   height: calc(100% - 50px);
    4.   /* 水平居中 */
    5.   margin: 0 auto;
    6. }
    7. .blog-edit-container .title {
    8.   width: 100%;
    9.   height: 50px;
    10.   /* 垂直居中 */
    11.   align-self: center;
    12.   display: flex;
    13.   /* 使子元素输入框和按钮靠两边放置，中间留个缝 */
    14.   justify-content: space-between;
    15.  
    16.  
    17. }
    18. .title #title {
    19.   width: 790px;
    20.   height: 40px;
    21.   border-radius: 10px;
    22.   display: block;
    23.   /* 去掉边框和轮廓线条 */
    24.   border: none;
    25.   outline: none;
    26.   padding-left: 10px;
    27.   font-size: large;
    28.   background-color: rgba(255, 255, 255, 0.75);
    29.   align-items: center;
    30. }
    31. .title #submit {
    32.   width: 200px;
    33.   height: 40px;
    34.   background-color: rgba(255, 165, 0, 0.7);
    35.   border-radius: 10px;
    36.   font-size: large;
    37.   font-weight: 600;
    38.   display: block;
    39.   /* 去掉边框和轮廓线条 */
    40.   border: none;
    41.   outline: none;
    42. }
    43.  
    44. .blog-edit-container #editor {
    45.   border-radius: 10px;
    46.   background-color: rgba(255, 255, 255, 0.7);
    47.   /* 设置半透明 */
    48.   opacity: 85%;
    49. }

    博客项目gitee代码链接：https://gitee.com/weiyangc/blog-project.giticon-default.png?t=N7T8https://gitee.com/weiyangc/blog-project.git

    总结

  • 相关阅读:
    讯飞大数据竞赛2022 汽车领域多语种迁移学习 打卡博客
    Optional用法与争议点
    区块链论文速读A会-ISSTA 2023（1/2）法律协议如何变成智能合约代码？
    【RTOS学习】优先级 | Tick | 任务状态 | 空闲任务 | 任务调度
    【从小白到大白01】c++类和对象
    Nginx基本使用(反向代理，负载均衡，动静分离)
    Flink 中的 Window (窗口)
    70.爬楼梯
    【String 类 常用方法详解和归类】全网最细总结
    【域适应十九】CDTRANS: CROSS-DOMAIN TRANSFORMER FOR UN-SUPERVISED DOMAIN ADAPTATION
  • 原文地址：https://blog.csdn.net/qq_64861334/article/details/130712167