• 实现一个博客系统----使用模板引擎技术

    主要思路:

    1)服务器渲染，基于模板引擎(我们在这里实现第一种)

    2)前后端分离，基于AJAX，服务器给前端返回json格式的数据，前端自己进行拼接HTML片段；

    1)博客列表页(动态页面)<---------渲染页面

    1.1提供所有的博客信息(渲染右侧每一个div博客):OperatorBlog中的SelectAll()方法------------来自于数据库

    1.2提供登陆者的个人信息:---------->获取登录者的用户身份信息------>HttpSession中的键值对当点击文章的标题，给服务器发送GET请求，带上BlogID，访问博客详情页

    2)博客详情页(动态页面)<---------渲染页面

    1.1提供具体的博客数据------>根据blogID通过OperatorBlog中的SelectOne方法来查询到博客进行渲染------>来源于数据库

    1.2获取文章中的作者信息---->根据blogID通过OperatorBlog中的SelectorOne方法查询到blog,在进行获取到blog中的userID，再根据调用OperatorUser中的selectByUserID来查询到文章的作者----->来源于数据库

    3)实现博客编辑页(静态页面)------->把用户编写好的博客标题和内容交给服务器

    先进行构造一个Blog对象，在想数据库里面进行插入数据-------->MYSQL

    4)实现博客登录页(静态页面)------->把输入框中的用户名和密码提交给服务器

    4.1根据用户名来进行查询用户信息(查询到User对象)------>MYSQL

    4.2把用户信息(User对象)写到HttpSession里面

    5)实现注销功能(没有单独的界面，只是在导航栏里面)

    根据a标签向服务器发送一个Http的Get请求，直接进行删除了会话中保存的用户的身份信息

    6)实现删除博客的功能(没有单独的界面，在博客详情页这里会多出一个删除按钮，前提是当前登录的作者就是文章的作者)

    通过超链接像服务发送请求，请求中带上blogID这样的参数，然后实现删除博客------>操作数据库

    1.创建maven项目:

    1)我们进行引入Servlet的依赖，引入Thymeleaf和MYSQL的依赖

    2)在main目录下创建webapp目录，在webapp目录里面创建web.xml文件,在webapp里面创建WEB-INF目录，再从WEB-INF里面创建template目录，把我们之前写的博客系统的前端页面全部拷贝过来

    3)使用Smart-Tomact进行打包部署

    2.设计数据库

    我们要把博客信息和用户的身份信息给储存到数据库里面

    1)我们进行创建博客表

    先创建数据库----Java200，博客列表:博客ID，博客标题，博客正文(在这里面使用mediumetext表示的数据范围要比varchar要长一些)，博客发布时间，一篇博客对应的作者(用一个ID来进行标识)

    1. 创建博客表
    2.  create table blog(
    3.     blogID int primary key auto_increment,//每一篇博客的身份标识
    4.     title varchar(1024),//每一篇博客的文章
    5.     content mediumtext,//每一篇博客的正文
    6.     postTime datetime,//每一篇博客的发布时间
    7.     userID int);//每一篇博客的作者

    2)我们进行创建用户表

    用户的身份标识ID，用户的姓名，用户的密码，况且我们的用户表里面的用户身份标识ID和博客表中的userID也是可以用外键来进行关联的;

    1.  create table user(
    2.      userID int,
    3.      name varchar(20),
    4.      password varchar(30));

    3)封装数据库操作，JDBC代码，下面我们来写一些MYSQL中的常用方法 

    我们在Java里面创建一个包叫做MYSQL

    1)我们创建第一个类，叫做ConnectionDatabase，里面存放JDBC链接MYSQL的代码，之前都写过

    1. package MYSQL;
    2.  
    3. import com.mysql.jdbc.jdbc2.optional.MysqlDataSource;
    4.  
    5. import javax.sql.DataSource;
    6. import java.sql.Connection;
    7. import java.sql.PreparedStatement;
    8. import java.sql.ResultSet;
    9. import java.sql.SQLException;
    10.  
    11. public class ConnectionDatabase {
    12.     private static final String url="jdbc:mysql://127.0.0.1:3306/java200?characterEncoding=utf-8&userSSL=true";
    13.     private static final String password="12503487";
    14.     private static  final String user="root";
    15.     public static   DataSource datasource=null;
    16.     public static DataSource getDataSource()
    17.     {
    18.         if(datasource==null)
    19.         {
    20.             synchronized(Object.class)
    21.             {
    22.                 if(datasource==null)
    23.                 {
    24.                     datasource=new MysqlDataSource();
    25.                     ((MysqlDataSource)datasource).setURL(url);
    26.                     ((MysqlDataSource)datasource).setUser(user);
    27.                     ((MysqlDataSource)datasource).setPassword(password);
    28.                 }
    29.             }
    30.         }
    31.         return datasource;
    32.     }
    33.     public static Connection getConnection() throws SQLException {
    34.         return getDataSource().getConnection();
    35.     }
    36.     public void close(ResultSet resultSet, PreparedStatement statement, Connection connection) throws SQLException {
    37.         resultSet.close();
    38.         statement.close();
    39.         connection.close();
    40.     }
    41. }

    2. 创建实体类，通过每一个实体类对象，来进行代表表中的一条记录数据；我们分别进行创建Blog这样的类和User这样的类来进行代表;类中的各种属性和数据库中的各种属性是相对应的,并针对里面的属性提供Set和Get方法-----他们都是根据数据库中的内容来进行创建的类；我们在MYSQL这个包中，创建Blog和User类;

    1)注意在java当中表示时间可以用timestamp类型，还可以使用java.sql.Date,但是这个Date类型只能表示日期，是不可以进行表示时，分，秒的

    2)在MYSQL中表示时间可以用String，但是不确定当前表示的时间是否是合法时间，我们还可以使用datetime和timestamp类型(到了2038年恐怕就不够用了)

    3.在进行创建一些类，来进行通过一些JDBC代码来实现数据库的一些操作；

    1.我们进行创建第一个类，来实现对Blog对象的一些操作；

    1)新增一篇博客----我们在前端代码里面有发布文章这样的功能

    2)获取到所有博客列表页-----就对应我们的博客列表页，作用是显示所有博客;

    3)根据博客ID可以查找到对应的博客，主要是为了在博客列表页里面点击查看全文之后，可以看到一篇博客的具体文章详情;

    4)根据博客ID来进行删除博客;

    5)我们可以写一些测试用例来验证我们上面的操作；

    1. package MYSQL;
    2. import java.sql.*;
    3. import java.util.ArrayList;
    4. import java.util.List;
    5.  
    6.  
    7. public class OperateBlog {
    8.     public void insert(Blog blog) throws SQLException, SQLException {
    9.         System.out.println("进行新增一篇博客");
    10.         //1与数据库建立连接
    11.         Connection connection=null;
    12.         connection=ConnectionDatabase.getConnection();
    13.         String SQL="insert into blog values(null,?,?,?,?)";
    14.         //2创建SQL语句
    15.         PreparedStatement statement=connection.prepareStatement(SQL);
    16.         statement.setString(1,blog.getTitle());
    17.         statement.setString(2,blog.getContent());
    18.         statement.setTimestamp(3,blog.getPostTime());
    19.         statement.setInt(4,blog.getUserID());
    20.         //3执行SQL语句
    21.         int ret=statement.executeUpdate();
    22.         if(ret==1)
    23.         {
    24.             System.out.println("新增博客成功");
    25.         }else{
    26.             System.out.println("新增博客失败");
    27.         }
    28.  
    29.    ConnectionDatabase.close(null,statement,connection);
    30.  
    31.     }
    32.     public List<Blog> SelectAll() throws SQLException {
    33.         System.out.println("开始查找所有博客");
    34.          List<Blog> list=new ArrayList<>();
    35.          Connection connection=ConnectionDatabase.getConnection();
    36.          String SQL="select * from blog";
    37.          PreparedStatement statement=connection.prepareStatement(SQL);
    38.         ResultSet set=statement.executeQuery();
    39.         //遍历里面的结构集合
    40.         while(set.next())
    41.         {
    42.             Blog blog=new Blog();
    43.             blog.setBlogID(set.getInt("blogID"));
    44.             blog.setTitle(set.getString("title"));
    45.             blog.setContent(set.getString("content"));
    46.             blog.setPostTime(set.getTimestamp("postTime"));
    47.             blog.setUserID(set.getInt("userID"));
    48.             list.add(blog);
    49.         }
    50.      ConnectionDatabase.close(set,statement,connection);
    51.         return list;
    52.     }
    53.     public Blog SelectOne(int blogID) throws SQLException {
    54.         System.out.println("开始查找指定博客");
    55.         Connection connection=null;
    56.         PreparedStatement statement=null;
    57.         connection=ConnectionDatabase.getConnection();
    58.         String SQL="select * from blog where blogID = ?";
    59.         statement=connection.prepareStatement(SQL);
    60.        statement.setInt(1,blogID);
    61.         ResultSet set=statement.executeQuery();
    62.  
    63.         if(set.next()) {//条件不要写错 if(set!=null)
    64.             Blog blog = new Blog();
    65.             //遍历结果集和,此处是基于自增主键来进行查询的,要么是1条记录要么是0条记录;
    66.             blog.setBlogID(set.getInt("blogID"));
    67.             blog.setTitle(set.getString("title"));
    68.             blog.setContent(set.getString("content"));
    69.             blog.setPostTime(set.getTimestamp("postTime"));
    70.             blog.setUserID(set.getInt("userID"));
    71.             ConnectionDatabase.close(set, statement, connection);
    72.             return blog;
    73.         }
    74.         return null;
    75.     }
    76.     public void DeleteBlog(int blogID) throws SQLException {
    77.         Connection connection=null;
    78.         PreparedStatement statement=null;
    79.         connection=ConnectionDatabase.getConnection();
    80.         String SQL="delete from blog where blogID = ?";
    81.         statement=connection.prepareStatement(SQL);
    82.         statement.setInt(1,blogID);
    83.         int len=statement.executeUpdate();
    84.         if(len==1)
    85.         {
    86.             System.out.println("删除成功");
    87.         }
    88.     }
    89.  
    90.     public static void main(String[] args) throws SQLException {
    91.        //1测试插入功能
    92.         Blog blog=new Blog();
    93.         blog.setUserID(1);
    94.         blog.setBlogID(1);
    95.         blog.setTitle("ABCDEFG");
    96.         blog.setContent("I am a boy");
    97.         blog.setPostTime(new Timestamp(System.currentTimeMillis()));//必须是java.sql里面的包
    98.         //setPostTime里面需要一个Timestamp类型,里面就需要new一个Timestamp对象,Timestamp里面参数是一个时间戳
    99.         // statement设置下标的时候是从0下标开始进行设置的
    100.         OperateBlog blogdemo=new OperateBlog();
    101.         blogdemo.insert(blog);
    102.         //2.测试查找所有博客功能
    103.         List<Blog> list=blogdemo.SelectAll();
    104.        // System.out.println(list);
    105.         //3查找指定博客
    106.         Blog blog1=blogdemo.SelectOne(1);
    107.         System.out.println(blog1);
    108.     }
    109. }

    2.我们进行创建第二个对象，来进行对user来进行操作

    1)实现新增用户，来进行实现注册功能(向数据库中插入数据)

    2)根据用户名来查找到用户对象，登陆的时候要根据用户名来查找用户对象，来判断进行对比，输入框输入的密码和查找到的用户密码进行相对比，从而是否是正确的；

    3)根据用户ID(根据博客列表页就可以)来进行查找用户对象，当我们点击查看全文的时候，在博客页面上显示作者的具体身份信息(点击博客详情页之后)；

    我们要知道，在博客列表页显示的是登陆者的身份信息，但是点击博客列表页之后，显示的是这篇文章对应作者的身份信息；

    4)注册的时候，一个用户名只有一个user对象，用户名是不重复的；

    1. package MYSQL;
    2.  
    3. import java.sql.Connection;
    4. import java.sql.PreparedStatement;
    5. import java.sql.ResultSet;
    6. import java.sql.SQLException;
    7.  
    8. public class OperateUser {
    9.     public void insert(User user) throws SQLException {
    10.          Connection connection=null;
    11.         PreparedStatement statement=null;
    12.         connection=ConnectionDatabase.getConnection();
    13.         String SQL="insert into user values(?,?,?)";
    14.         statement=connection.prepareStatement(SQL);
    15.         statement.setInt(1,user.getUserID());
    16.         statement.setString(2, user.getName());
    17.         statement.setString(3, user.getPassword());
    18.         int len=statement.executeUpdate();
    19.         if(len==1)
    20.         {
    21.             System.out.println("插入成功");
    22.         }else{
    23.             System.out.println("插入失败");
    24.         }
    25.  
    26.  
    27.     }
    28.     public User selectByName(String username) throws SQLException {
    29.           Connection connection=null;
    30.           PreparedStatement statement=null;
    31.           connection=ConnectionDatabase.getConnection();
    32.           String SQL="select * from user where name = ?";
    33.           statement= connection.prepareStatement(SQL);
    34.           statement.setString(1,username);
    35.           ResultSet set=statement.executeQuery();
    36.         if(set.next())
    37.         {
    38.             User user=new User();
    39.             user.setPassword(set.getString("password"));
    40.             user.setName(username);
    41.             user.setUserID(set.getInt("userID"));
    42.             return user;
    43.         }
    44.         return null;
    45.     }
    46.     public User selectByUserID(int userID) throws SQLException {
    47.         Connection connection=null;
    48.         PreparedStatement statement=null;
    49.         connection=ConnectionDatabase.getConnection();
    50.         String SQL="select * from user where userID = ?";
    51.         statement=connection.prepareStatement(SQL);
    52.         statement.setInt(1,userID);
    53.         ResultSet set=statement.executeQuery();
    54.         if(set.next())
    55.         {
    56.             User user=new User();
    57.             user.setUserID(userID);
    58.             user.setName(set.getString("name"));
    59.             user.setPassword(set.getString("password"));
    60.             return user;
    61.         }
    62.         return null;
    63.     }
    64. }

    4.我们此时开始写实现页面的操作，我们让服务器基于模板引擎，来把从数据库中查找到的数据，返回到网页上面

    1)先进行初始化Thymeleaf

    2)实现博客列表页

    3)实现博客详情页

    4)实现博客登录页

    5)实现博客编辑页 

     1.进行初始化模板引擎

    我们要把把初始化代码放到ServletContextListener中，然后把TemplateEngine初始化好了之后放到ServletContext里面;

    1. import org.thymeleaf.TemplateEngine;
    2. import org.thymeleaf.templateresolver.ServletContextTemplateResolver;
    3.  
    4. import javax.servlet.ServletContext;
    5. import javax.servlet.ServletContextEvent;
    6. import javax.servlet.ServletContextListener;
    7. import javax.servlet.annotation.WebListener;
    8.  
    9. @WebListener//一定要加注释
    10. public class StartThymeleaf implements ServletContextListener {
    11.     @Override
    12.     public void contextInitialized(ServletContextEvent servletContextEvent) {
    13.         System.out.println("开始进行初始化模板引擎");
    14.         //1创建TemplateEngine对象和resolver对象
    15.         ServletContext context=servletContextEvent.getServletContext();
    16.         TemplateEngine engine=new TemplateEngine();
    17.         ServletContextTemplateResolver solver=new ServletContextTemplateResolver(context);
    18.         solver.setPrefix("/WEB-INF/template/");
    19.         solver.setSuffix(".html");
    20.         solver.setCharacterEncoding("utf-8");
    21.         //2将resolver对象和engine对象进行关联
    22.         engine.setTemplateResolver(solver);
    23.         //3将我们创建好的engine对象放到ServletContext对象里面
    24.         context.setAttribute("engine",engine);
    25.         System.out.println("初始化模板引擎的操作结束");
    26.     }
    27.  
    28.     @Override
    29.     public void contextDestroyed(ServletContextEvent servletContextEvent) {
    30.  
    31.     }
    32. }

    2.实现博客列表页

    1)在博客列表页里面，我们在页面上面写的每一篇博客就都不能是一个写死的数据，而是应该在数据库中进行查找得到的每一条记录，每一篇博客都是一个class=blog的div，况且没一篇博客里面还有标题，发布时间，内容，这些属性都是和我们的数据库中的blog表中对应的字段是相同的；我们在前端页面就可以用th:each,根据服务器传过来的blog数组，依次遍历到每一个blog，再把它构建到我们的列表页面上；

    2)我们详情页的链接就不能全叫blog2.html,在href属性里面加上blogID，这样我们的服务器就知道当前访问的是哪一篇博客列表了;

    3)我们把每一篇博客对应的查看全文的a标签换成了，这个blogID在QueryString进行设置

      <a href="'blog2.html?blogID='+blog.blogID" class="detail" target="_blank">查看全文&gt;&gt;</a>

    当我们进行访问每一篇博客的博客详情页的时候，都带上一个blogID，这样服务器就知道了我们具体访问的是哪一篇博客了;

    4)我们在写后端Servlet代码的时候，WebServlet中所进行关联的路径，是可以包含点的，后面再去浏览器访问blog1.html的时候，就不是一个静态的页面了，而是一个动态生成的页面

    5)如果内容太多了导致溢出，就自动加上一个滚动条overflow:auto;如果说博客正文太长，我们就从博客列表页进行截取一段，一部分(直接截取前面的若干个字就可以了),我们直接可以在数据库操作Blog的那个类中，进行获取到所有博客的时候，判断博客内容长度是否超过90，超过90个字符，就调用subString方法进行截取;在拼接字符串".......";

    我们再进行查询数据库的时候，就直接获取到正文之后就进行判定，如果太长，直接进行截断

    1. <!-- 右侧是博客列表页 -->
    2.         <div class="right">
    3.             <!-- 在右侧,我们表示的是一篇一篇的博客 -->
    4.             <div class="blog" th:each="blog : ${blogs}">
    5.                 <!-- 文章标题 -->
    6.                 <h2 class="title" th:text="${blog.title}"></h2>
    7.                 <!-- 发布日期 -->
    8.                 <div class="date" th:text="${blog.postTime}"></div>
    9.                 <!-- 文章内容 -->
    10.              <div class="text" th:text="${blog.content}"></div>
    11.              <!-- 查看全文按钮 -->
    12.              <a href="${'blog2.html?blogID'+blog.blogID}" class="detail" target="_blank">查看全文&gt;&gt;</a>
    13.         </div> 
    14.             </div>
    15. 这里面的内容都是依靠模板渲染的,后端传递过来一个blogs数组或者list,我们就会自动遍历到这里面的每一个blog,取出里面的每一个属性,然后再去进行渲染操作;
    1.   OperateBlog operateBlog=new OperateBlog();
    2.    //1从数据库拿到所有的博客列表
    3.         List<Blog> list= null;
    4.         try {
    5.             list = operateBlog.SelectAll();
    6.         } catch (SQLException e) {
    7.             e.printStackTrace();
    8.         }
    9.         resp.setContentType("text/html;charset=utf-8");
    10.         //2拿到模板引擎对象,进行页面渲染操作
    11.         ServletContext context=req.getServletContext();
    12.         TemplateEngine engine=(TemplateEngine)context.getAttribute("engine");
    13.    //3创建WebContext对象,进行设置键值对
    14.         WebContext webContext=new WebContext(req,resp,context);
    15.         webContext.setVariable("blogs",list);
    16.    //4进行渲染
    17.         String html= engine.process("blog1",webContext);
    18.         resp.getWriter().write(html);

    3.实现博客详情页 

    1)在博客列表页，我们是显式指定所有博客，进行获取到所有博客就可以了，但是在博客详情页里面，我们要根据a标签中的请求中的BlogID来进行指定到底是哪一篇博客，再根据blogID来进行查询数据库,从而我们就得到了博客的详细情况；这个blogID是被设置在QueryString里面的

    2)当前我们还差一个地方，那就是说在当前的博客详情页，里面显示的内容，不是按照Markdown的语法来进行渲染的，例如说此处的三级标题还是不能正常的进行显示；

    1.  <!-- 右侧是博客详情页,这个div表示右侧版新的整个背景-->
    2.             <div class="right">
    3. <!--这里面不用写th:each-->
    4.                   <div class="blog">
    5.                     <!-- 文章标题 -->
    6.                     <h3 th:text="${blog.title}"></h3>
    7.                     <!-- 博客发布时间 -->
    8.                     <div class="date" th:text="${blog.postTime}">2022年12月3日</div>
    9.                     <P th:text="${blog.content}"></P>
    10.                 </div>        
    11.            </div>
    12. 我们希望在博客详情页里面,能够传过来一个blog对象，找到对应的属性进行渲染
    1.   resp.setContentType("text/html;charset=utf-8");
    2.         OperateBlog operateBlog=new OperateBlog();
    3.         String blogID=req.getParameter("blogID");
    4.         if(blogID==""||blogID.equals(""))
    5.         {
    6.             String html="<h3>blogID字段缺失</h3>";
    7.             resp.getWriter().write(html);
    8.         }
    9.         Blog blog= null;
    10.         try {
    11.             blog = operateBlog.SelectOne(Integer.parseInt(blogID));
    12.         } catch (SQLException e) {
    13.             e.printStackTrace();
    14.         }
    15.         if(blog==null)
    16.         {
    17.             String html="<h3>根据博客ID获取到的当前博客不存在</h3>";
    18.             resp.getWriter().write(html);
    19.         }
    20.         ServletContext context=req.getServletContext();
    21.         TemplateEngine engine=(TemplateEngine)context.getAttribute("engine");
    22.         WebContext webContext=new WebContext(req,resp,context);
    23.         webContext.setVariable("blog",blog);
    24.         String html=engine.process("blog2",webContext);
    25.         resp.getWriter().write(html);
    26.     }

     4.实现博客登陆界面 

    1)登陆页面的HTML是不用进行动态替换的，也就是说这里面的内容是固定的，不需要模板进行动态替换，页面里面没有需要进行动态生成的内容

    2)实现一个Servlet来进行实现登录请求(静态页面直接放到webapp里面，不用放到模板引擎的文件里面)

    3)我们还需要对页面进行微调，当我们进行点击按钮的时候，可以发送一个HTTP请求，里面的input标签加上name属性，只能用一个form表单来进行包裹;

    4)再进行实现服务器的代码的时候，我们写的逻辑是这样的,直接用loginServlet来进行实现

    一:先从请求中读取出用户名和密码

    二:再从数据库中根据用户名读出User，再对比密码是否正确，输入正确，那么就登录成功，把当前的user对象放到HttpSession中，以备后用

    三:登录成功之后，我们直接302重定向到博客列表页

    5)我们要针对博客列表页，博客详情页，是否已经进行登录进行一个校验，此处就约定，如果当前处于未登录状态，就不可以进行访问博客列表页和博客详情页，此时如果进行访问，就要重定向到博客登录页;此事后要修改我们之前写的，两个Servlet；

    我们进行性判断用户是否进行登陆的标准就是看看当前能不能拿到一个合适的session，并且能够拿到这里面的user对象，就说明用户正在处于登录状态；

    6)把下面代码放到blog1Servlet和blog2Servlet里面，在我们进行重定向操作的时候，一定要结束当前的程序;

    7)当我们进行重启服务器之后，直接访问blog1.html或者blog2.html，都会跳转到博客登录页，让当前用户进行登录;

    8)我们为什么在登陆之后可以拿到登陆的user对象呢？那是因为我们在实现博客登录页之后，我们自己在httpsession存放了一个user对象在里面;

    实现具体登陆页面的代码: 

    1. import MYSQL.OperateUser;
    2. import MYSQL.User;
    3.  
    4. import javax.servlet.ServletException;
    5. import javax.servlet.annotation.WebServlet;
    6. import javax.servlet.http.HttpServlet;
    7. import javax.servlet.http.HttpServletRequest;
    8. import javax.servlet.http.HttpServletResponse;
    9. import javax.servlet.http.HttpSession;
    10. import java.io.IOException;
    11. import java.sql.SQLException;
    12.  
    13. @WebServlet("/login")
    14. public class LoginServlet extends HttpServlet {
    15.     @Override
    16.     protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    17.  
    18.         //1.获取请求中的参数
    19.         resp.setContentType("text.html;charset=utf-8");
    20.         req.setCharacterEncoding("utf-8");
    21.         String username=req.getParameter("name");
    22.         String password=req.getParameter("password");
    23.         System.out.println(username);
    24.         System.out.println(password);
    25.         if(username==null||password==null||username.equals("")||password.equals(""))
    26.         {  String html="<h3>当前请求中的用户名或者密码缺失</h3>";
    27.             resp.getWriter().write(html);
    28.             return;
    29.         }
    30.         OperateUser operateUser=new OperateUser();
    31.         //2从数据库中查询用户
    32.         User user=null;
    33.         try {
    34.              user=operateUser.selectByName(username);
    35.         } catch (SQLException e) {
    36.             e.printStackTrace();
    37.         }
    38.         //3进行校验,不存在直接重定向到登陆界面,下面是登陆失败的几种情况,查不到user或者密码不匹配
    39.         if(user==null)
    40.         {
    41.             String html="<h3>用户名错误或者密码错误</h3>";
    42.             resp.getWriter().write(html);
    43.             return;
    44.         }
    45.  
    46.         if(!user.getPassword().equals(password))
    47.         {
    48.            String html="<h3>用户名错误或者密码错误</h3>";
    49.            resp.getWriter().write(html);
    50.            return;
    51.         }
    52.         //4把user对象寸放大HttpSession里面
    53.         HttpSession httpSession=req.getSession(true);
    54.         httpSession.setAttribute("user",user);
    55.         resp.sendRedirect("blog1.html");
    56.     }
    57. }

    再进行访问每一个页面之前，进行判断用户是否进行登陆的代码:

    1.  //判断当前用户是否登录
    2.         HttpSession session=req.getSession(false);
    3.         if(session==null||session.equals(""))
    4.         {
    5.             System.out.println("当前用户未登录");
    6.             //未登录状态
    7.             resp.sendRedirect("blog3.html");
    8.             return;
    9.         }
    10.         User userx= (User) session.getAttribute("user");
    11.         if(userx==null)
    12.         {
    13.             System.out.println("当前用户未登录");
    14.             //未登录状态
    15.             resp.sendRedirect("blog3.html");
    16.             return;
    17.         }

     1)上面的HttpSession对象是根据同一个SessionID进行找到的对象,当我们执行到req.getSession()的时候，我们就会根据SessionID来进行查找Session对象了；

    2)但是在当前我们还是发现了一些问题，在我们进行登陆成功之后，我们在左边的个人信息列表中的数据是写死的，当我们进入到博客详情页，显示的文章作者也是写死的；前面之所以这些信息是写死的那是因为我们之前没有实现登录功能，也就没有办法拿到用户信息，现在已经可以登录，接下来就可以把当前页面上的身份信息，基于模板引擎来进行动态替换;

    如果是在博客列表页，那么此处的用户信息就显示当前登陆者的用户信息；

    如果实在博客详情页，那么此时的用户信息就显示当前文章作者的用户信息；

    当前还没有进行实现修改头像以及gitup这样的功能，这些实现和动态替换用户名没啥区别，只不过是需要在数据库里面扩充字段来保存这些信息; 

    例如说我们想要保存头像，可以在数据库里面进行存放一些一个图片的路径，到时候就可以把这个图片路径返回到前端页面了;img标签里面的src属性即可

    我们先进行修改博客列表页； 

     此处的所设置的userx是我们在刚才检查登陆状态的时候，从session里面中读的user，这个userx正是当前用户进行登陆的用户的信息；

    我们每一次服务器进行重启的时候，服务器内存中的那一个保存会话的hash表也就没了，所以之前的登陆状态也就没有了(因为这个哈希表是保存在内存里面的)，当下一次我们的客户端访问服务器的时候Cookie字段的中的sessionID服务器也不会认识,就只能认定是未登录状态；

    但是在实际上不是所有的会话信息都在内存里面，Servlet默认的会话是在内存里面的，想要把hash表存放到文件或者数据库里面，就要通过代码进行实现;

    修改博客详情页: 

    前端修改方式是一样的:

     后端代码:

    此处我们就不可以在webContext里面设置成从session里面读取到的user,而是根据我们之前再去之前在博客列表页传过来的blogID来进行查询用户user，这个user才是我们需要进行模板渲染的user；

    上面写法是错误的，怎么可以根据blogID来进行查询到User呢？下面是正确的:

    1.    OperateUser operateUser=new OperateUser();
    2.         try {
    3.          User user=operateUser.selectByUserID(blog.getUserID());
    4.             webContext.setVariable("user",user);
    5.         } catch (SQLException e) {
    6.             e.printStackTrace();
    7.         }

    5.实现注销功能 

    1)我们在这里面期望，当我们进行点击注销按钮之后，就可以退出登录状态了，我们在之前判断用户是否进行登录的时候，现根据SessionID来进行查找出HttpSession对象，再取出里面的user；

    2)我们必须取到一个user才算登陆成功，取user取不到，或者说取不到session都是登陆失败；

    3)当前我们的注销按钮是一个a标签，里面有一个路径，咱们可以写一个Servlet来进行处理这里面的请求，在代码中我们可以根据SessionID来进行找到储存在Session里面的User对象，然后把这个User对象给删了;在HttpSession中提供了一个removeAttribute()这样的方法;然后直接重定向到登陆界面即可;

    4)我们在服务器这边在java目录里面创建deleteServlet来进行处理注销请求;

      <a href="delete" target="_blank">注销</a>
    1.  
    2. import MYSQL.User;
    3.  
    4. import javax.servlet.ServletException;
    5. import javax.servlet.annotation.WebServlet;
    6. import javax.servlet.http.HttpServlet;
    7. import javax.servlet.http.HttpServletRequest;
    8. import javax.servlet.http.HttpServletResponse;
    9. import javax.servlet.http.HttpSession;
    10. import java.io.IOException;
    11.  
    12. @WebServlet("/delete")
    13. public class deleteServlet extends HttpServlet {
    14.     @Override
    15.     protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    16.         //判断当前用户是否登录
    17.         HttpSession session=req.getSession(false);
    18.         if(session==null||session.equals(""))
    19.         {
    20.             System.out.println("当前用户未登录");
    21.             //未登录状态
    22.             resp.sendRedirect("blog3.html");
    23.             return;
    24.         }
    25.         User userx= (User) session.getAttribute("user");
    26.         if(userx==null)
    27.         {
    28.             System.out.println("当前用户未登录");
    29.             //未登录状态
    30.             resp.sendRedirect("blog3.html");
    31.             return;
    32.         }
    33.         resp.setContentType("text/html;charset=utf-8");
    34.         session.removeAttribute("user");
    35.         //重定向登陆界面
    36.         resp.sendRedirect("blog3.html");
    37.     }
    38. }

    6.实现博客发布功能

    1)针对博客编辑页进行调整，当前我们的博客编辑页，是不需要进行动态替换的，就和之前的登陆界面差不多，只需要加上form表单，只需要最后点击提交按钮，触发HTTP请求，来进行提交；

    我们要在input标签里面加上name属性，方便与后面服务器可以获取到这个文章的标题，然后提交按钮要进行修改；

    2)另外我们还需要自己写一个Servlet来针对提交博客的请求，来进行处理；

    3)每一次进行修改的功能，开发新的逻辑，都是需要前后端进行搭配进行的，这就导致前后端进行交互不能彻底地进行分离开

    4)但是Markdown编译器中的内容如何进行提交呢？

    我们可以在id="editor"的div标签里面加上一个隐藏的textarea标签，里面加上name属性，这个东西不需要进行显示，只是为了后面的表单来进行构造数据

    5)我们还需要进行一步操作，把我们markDown编译器里面的内容放到textarea里面，方便进行提交；我们只需要在初始化editor的时候，在script标签里面加上saveHTMLToTextarea:true,就是直接可以让editor.md实时的将编辑框里面的内容给存到用户自己写的textarea里面了；于是进一步的进行提交表单就可以带上博客的正文了；

    前端代码: 

    1.  <!-- 这就是博客编辑页的版心 -->
    2.    <form action="edit" method="post">
    3.     <div class="edit">
    4.         <div class="writetitle">     
    5.                 <input type="text" id="title" name="title">
    6.                 <input type="submit" value="点击发布文章" id="submit">
    7.         </div>
    8.         <div id="editor">
    9.             <textarea name="content" style="display:none"></textarea>
    10.         </div>
    11.    </form>
    12.   
    13.    </div>
    14.    <script>
    15.     //首先要初始化编译器
    16.     //先创建出一个textinner对象
    17.     //editormd相当于是一个函数，生成一个editor对象
    18.     //第一个参数是要指定放到哪一个html标签中,元一个html标签关联，参数就是对应的ID；
    19.     var editor=editormd("editor", {
    20.         //这里的尺寸必须在这里设置,不能依靠CSS进行设置
    21.         width:"100%",
    22.         // 这是计算makdown正文的高度
    23.         height:"1000px",
    24.         //编辑器的初始内容
    25.         markdown:"#在这里写一下第一篇博客",
    26.         //编译器所用的插件所在的路径
    27.         path:"editor.md/lib/",
    28.         saveHTMLToTextarea:true
    29.     });

    后端代码: 

    1. import MYSQL.Blog;
    2. import MYSQL.OperateBlog;
    3. import MYSQL.User;
    4.  
    5. import javax.servlet.ServletException;
    6. import javax.servlet.annotation.WebServlet;
    7. import javax.servlet.http.HttpServlet;
    8. import javax.servlet.http.HttpServletRequest;
    9. import javax.servlet.http.HttpServletResponse;
    10. import javax.servlet.http.HttpSession;
    11. import java.io.IOException;
    12. import java.sql.SQLException;
    13. import java.sql.Timestamp;
    14.  
    15. @WebServlet("/edit")
    16. public class editServlet extends HttpServlet {
    17.     @Override
    18.     protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    19.         //判断当前用户是否登录
    20.         HttpSession session=req.getSession(false);
    21.         if(session==null||session.equals(""))
    22.         {
    23.             System.out.println("当前用户未登录");
    24.             //未登录状态
    25.             resp.sendRedirect("blog3.html");
    26.             return;
    27.         }
    28.         User userx= (User) session.getAttribute("user");
    29.         if(userx==null)
    30.         {
    31.             System.out.println("当前用户未登录");
    32.             //未登录状态
    33.             resp.sendRedirect("blog3.html");
    34.             return;
    35.         }
    36.         req.setCharacterEncoding("utf-8");
    37.         resp.setContentType("text/html;charset=utf-8");
    38. //2获取请求中的文章标题和文章内容
    39.         String content=req.getParameter("content");
    40.         String title=req.getParameter("title");
    41.  if(content==null||content.equals("")||title==null||title.equals(""))
    42.         {
    43.             String html="<h3>发布博客失败,文章标题或者文章内容是空</h3>";
    44.             resp.getWriter().write(html);
    45.             return;
    46.         }
    47. //3构建一个blog对象，插入到数据库里面
    48.         Blog blog=new Blog();
    49.         blog.setContent(content);
    50. //注意当前的文章作者正是当前的登陆者
    51.         blog.setUserID(userx.getUserID());
    52.         blog.setTitle(title);
    53.         blog.setPostTime(new Timestamp(System.currentTimeMillis()));
    54.         OperateBlog operateBlog=new OperateBlog();
    55.         try {
    56.             operateBlog.insert(blog);
    57.         } catch (SQLException e) {
    58.             e.printStackTrace();
    59.         }
    60. //4重定向到博客列表页
    61.         resp.sendRedirect("blog1.html");
    62.     }
    63. }

    7.当前我们发现，博客详情页显示的是博客的原始的Markdown内容，而不是渲染后的markdown，一级标题，二级标题都没有进行显示出来

    一个#会被渲染成一级标题，三个#会被渲染成三级标题(左侧写文字，右边显示具体渲染后的结果)

    我们此时要针对我们的博客详情页进行调整，同时也需要在这个页面中引入editor.md这个库，然后在这个库里面有一个操作markdownHTML,这个方法的作用是把原始的markDown文本给进行渲染成一个HTML

    1. <script>
    2.     //首先要初始化编译器
    3.     //先创建出一个textinner对象
    4.     //editormd相当于是一个函数，生成一个editor对象
    5.     //第一个参数是要指定放到哪一个html标签中,元一个html标签关联，参数就是对应的ID；
    6.     var editor=editormd("editor", {
    7.         //这里的尺寸必须在这里设置,不能依靠CSS进行设置
    8.         width:"100%",
    9.         // 这是计算makdown正文的高度
    10.         height:"1000px",
    11.         //编辑器的初始内容
    12.         markdown:"#在这里写一下第一篇博客",
    13.         //编译器所用的插件所在的路径
    14.         path:"editor.md/lib/",
    15.         saveHTMLToTextarea:true
    16.     });
    17.    
    18. </script>

    在博客详情页里面，有一个代码:

    <P th:text="${blog.content}"></P>这个div里面就包含了markDown的原始报文

    markdown的原始内容，就在这个div里面，我们就可以把这个div里面的内容给取出来，然后再通过刚才的markdownToHTML方法(这个方法在script标签里面)进行转换，然后再把转换的结果给些回到刚才的这个div中；

    1.     <div id="content"th:text="${blog.content}"></div>
    2. <script>
    3.             function rendMo(){
    4.                 //1先取出div里面的内容
    5.                 let markDownDiv=document.querySelector("#content");
    6.                 let markdown=markDownDiv.innerHTML;
    7.                 console.log(markdown);
    8.                 //2把div里面的内容设成空
    9.                 markDownDiv.innerHTML="";
    10.                 //3进行替换
    11.                 editormd.markdownToHTML('content',{
    12.                     markdown:markdown
    13.                 });//第一个参数表示ID
    14.             }
    15.             rendMo();
    16.         </script>

    8.我们完成了上述的调整之后，就发现当前这个代码确实可以运行了也可以进行渲染出来了，但是这里面的背景和之前的半透明效果，显得格格不入；

    此处可以给刚才的div设置一个纯透明背景(back-groundcolor里面的rgbc是可以进行设置透明度的;

    1.   <div id="content"th:text="${blog.content}" style="background-color:transparent;"></div>
    2. 这个style属性表示完全透明,看到的背景就是一个父亲元素的背景;

     之前我们的博客列表这里面不太科学，因为新的博客出现在最下边，一般是新的博客在上边，我们就修改了数据库中的查找所有博客的查询语句，加上order by postTime desc属性

    9.我们进行实现删除博客的功能

    1)你只能删除自己写的博客，例如说A用户进行登陆之后是不可以进行删除B作者的博客的

    2)我们在博客详情页中的导航栏加上一个删除博客的按钮，我们已进行点击这个删除博客，就会给后端的服务器发送一个请求，写一个Servlet,服务器就会把这篇博客进行删除了;

    3)如果当前这个博客的作者是当前登陆的用户本身，那么就显示这个删除按钮，否则不显示

     <a  target="_blank" th:if="${showdeleteButton}"th:href="${'deleteblog?blogID='+blog.blogID}"></a>

    1)我们在前端加上这样的代码，首先我们肯定要进行判断当前进行登录的用户和文章作者的用户是不是相同的，就用th:if来进行判断，如果相同，就把showdeleteButton设成true，并显示在页面上;否则就会设置成false;

    2)当我们进行点击a标签的时候，传递过来的参数肯定要带上blogID这样我们才可以在后面的服务器上面根据blogID来进行删除;

    我们在blog2Servlet中修改的代码:

        webContext.setVariable("showdeleteButton",user.getUserID()==userx.getUserID());

    我们用的deleteblogServlet中的代码

    1. import MYSQL.Blog;
    2. import MYSQL.OperateBlog;
    3. import MYSQL.OperateUser;
    4. import MYSQL.User;
    5. import org.thymeleaf.TemplateEngine;
    6. import org.thymeleaf.context.WebContext;
    7.  
    8. import javax.servlet.ServletContext;
    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.SQLException;
    17.  
    18. @WebServlet("/blog2.html")
    19. public class Blog2Servlet extends HttpServlet {
    20.     @Override
    21.     protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException{
    22.         //判断当前用户是否登录
    23.         HttpSession session=req.getSession(false);
    24.         if(session==null||session.equals(""))
    25.         {
    26.             System.out.println("当前用户未登录");
    27.             //未登录状态
    28.             resp.sendRedirect("blog3.html");
    29.             return;
    30.         }
    31.         User userx= (User) session.getAttribute("user");
    32.         if(userx==null)
    33.         {
    34.             System.out.println("当前用户未登录");
    35.             //未登录状态
    36.             resp.sendRedirect("blog3.html");
    37.             return;
    38.         }
    39.        resp.setContentType("text/html;charset=utf-8");
    40.         OperateBlog operateBlog=new OperateBlog();
    41.         String blogID=req.getParameter("blogID");
    42.         if(blogID==""||blogID.equals(""))
    43.         {
    44.             String html="<h3>blogID字段缺失</h3>";
    45.             resp.getWriter().write(html);
    46.         }
    47.         Blog blog= null;
    48.         try {
    49.             blog = operateBlog.SelectOne(Integer.parseInt(blogID));
    50.         } catch (SQLException e) {
    51.             e.printStackTrace();
    52.         }
    53.         if(blog==null)
    54.         {
    55.             String html="<h3>根据博客ID获取到的当前博客不存在</h3>";
    56.             resp.getWriter().write(html);
    57.         }
    58.         ServletContext context=req.getServletContext();
    59.         TemplateEngine engine=(TemplateEngine)context.getAttribute("engine");
    60.         WebContext webContext=new WebContext(req,resp,context);
    61.         OperateUser operateUser=new OperateUser();
    62.         try {
    63.             User user=operateUser.selectByUserID(blog.getUserID());
    64.             webContext.setVariable("user",user);
    65.             webContext.setVariable("showdeleteButton",user.getUserID()==userx.getUserID());
    66.         } catch (SQLException e) {
    67.             e.printStackTrace();
    68.         }
    69.  
    70.         webContext.setVariable("blog",blog);
    71.         String html=engine.process("blog2",webContext);
    72.         resp.getWriter().write(html);
    73.     }
    74. }

    10.项目总结: 

    一:已经实现的功能:

    1)实现了博客列表的展示

    2)实现了博客详情的展示

    3)实现了登录，用户注销，针对登陆状态的验证，用户信息的显示，发布博客，博客详情页能够显示渲染后的markdown效果

    4)实现了删除博客的功能

    二:仍然还没有实现的功能

    1)用户的头像功能(上传头像，不同用户显示不同的头像)

    2)用户的gitup显示，当前是写死的

    3)支持文章分类,针对数据库创建一个分类表，允许用户发布文章的时候指定一个分类

    4)实现编辑博客，修改博客内容，在博客详情页里面加上修改这样的按钮，点击之后进入到博客编辑页，把刚才博客里面的内容给带过去

    5)评论.......

    先修改前端代码，再进行修改后端代码;

  • 相关阅读:
    关于ubuntu开发环境配置
    【黑马程序员】Maven 进阶
    【问题解决】Linux-conda环境下安装PyKDL无法链接.so动态库
    Python实现直方图梯度提升回归模型(HistGradientBoostingRegressor算法)并基于网格搜索进行优化同时绘制PDP依赖图项目实战
    POI报表的高级应用
    销售人员应关注的 5 个指标
    go语言｜数据结构：二叉树（1）创建与遍历方法
    网页在移动端的适配中单位的选择
    谈谈Dubbo的那些事
    Docker：容器
  • 原文地址：https://blog.csdn.net/weixin_61518137/article/details/125569468