第8关：博客系统之博客查询（三）

于 2024-12-30 00:54:53 发布
阅读量621 收藏 10
点赞数 26
分类专栏： 软件项目设计专题学期实训 文章标签： 开发语言 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/2202_75727406/article/details/144803408
版权

任务描述
本关任务：实现根据博客标题模糊查询博客。

相关数据说明
MySQL 数据库 mydb；

博客表 t_blog；

列名    类型    非空    注释
blogId    int    √    博客 ID 主键 自增
blogTitle    varchar    √    博客标题
blogContent    varchar    √    博客内容
userId    varchar    √    创建人 ID，也就是用户 ID
typeId    varchar    √    类型 ID，也就是博客类型
MySQL 连接配置：

Driver：com.mysql.jdbc.Driver；

URL：jdbc:mysql://localhost:3306/mydb?characterEncoding=UTF-8；

user：root；

password：123123。

编程要求
仔细阅读右侧编辑区内给出的代码框架及注释，在 Begin-End 中实现博客系统中实现根据博客标题模糊查询的功能，具体要求如下：

用户进入查询博客模块后，将原先的输出修改为：“查询所有博客请按1，查询自己的博客请按2，查询指定博客请按3，根据博客标题查询博客请按4，返回请按其它键”，然后获取键盘输入的信息；

如果用户输入的为 4，输出：“请输入你要查询的博客标题”，获取键盘输入的博客标题，然后调用 findBlogByTitle(String blogTitle) 方法模糊查询博客，输出：“blogId    blogTitle    blogContent    typeName    userName”，中间分隔符为 \t，然后按照上述格式输出查询数据。

测试说明
平台将使用测试集运行你编写的程序代码，若全部的运行结果正确，则通关。
可在右侧“测试结果”区查看具体的测试集详情。

测试输入：

1
yechen
147258369
2
4
java
5
3
预期输出：

**********欢迎进入博客系统**********
**********1. 登录**********
**********2. 注册**********
**********3. 退出系统**********
请输入你要进行的操作：
请输入你的用户名
请输入你的密码
1. 创建博客
2. 查看博客
3. 删除博客
4. 修改博客
5. 返回上一级菜单
请输入你要进行的操作：
查询所有博客请按1，查询自己的博客请按2，查询指定博客请按3，返回请按其它键
请输入你要查询的博客标题
blogId    blogTitle    blogContent    typeName    userName
2    Java简介    Java是一门面向对象编程语言，不仅吸收了C++语言的各种优点，还摒弃了C++里难以理解的多继承、指针等概念，因此Java语言具有功能强大和简单易用两个特征。    Java    sunfeng
3    Java基础语法    一个 Java 程序可以认为是一系列对象的集合，而这些对象通过调用彼此的方法来协同工作。    Java    sunfeng
1. 创建博客
2. 查看博客
3. 删除博客
4. 修改博客
5. 返回上一级菜单
请输入你要进行的操作：
**********欢迎进入博客系统**********
**********1. 登录**********
**********2. 注册**********
**********3. 退出系统**********
请输入你要进行的操作：
退出系统！

step8/com/menu/Menu.java

package com.menu;
import com.dao.BlogDao;
import com.dao.BlogTypeDao;
import com.dao.UserDao;
import com.pojo.Blog;
import com.pojo.BlogType;
import com.pojo.User;
import java.util.Scanner;
public class Menu {
    public static void main(String[] args) {
        UserDao userDao = new UserDao();
        boolean flag = true;
        User user;
        Blog blog;
        BlogType blogType;
        BlogDao blogDao = new BlogDao();
        BlogTypeDao blogTypeDao = new BlogTypeDao();
        Scanner sc = new Scanner(System.in);
        do {
            System.out.println("**********欢迎进入博客系统**********");
            System.out.println("**********1. 登录**********");
            System.out.println("**********2. 注册**********");
            System.out.println("**********3. 退出系统**********");
            System.out.println("请输入你要进行的操作：");
            int x = sc.nextInt();
            String userName;
            String passWord;
            String phone;
            switch (x) {
                case 1:
                    // 获取键盘输入的用户信息
                    System.out.println("请输入你的用户名");
                    userName = sc.next();
                    System.out.println("请输入你的密码");
                    passWord = sc.next();
                    user = userDao.login(userName,passWord);
                    if (user != null) {
                        boolean flag1 = true;
                        do{
                            System.out.println("1. 创建博客");
                            System.out.println("2. 查看博客");
                            System.out.println("3. 删除博客");
                            System.out.println("4. 修改博客");
                            System.out.println("5. 返回上一级菜单");
                            System.out.println("请输入你要进行的操作：");
                            int y = sc.nextInt();
                            int blogId;
                            String blogTitle;
                            String blogContent;
                            String typeName;
                            switch (y){
                                case 1:
                                    // 获取键盘输入的用户信息
                                    System.out.println("请输入你要创建的博客标题");
                                    blogTitle = sc.next();
                                    System.out.println("请输入你要创建的博客内容");
                                    blogContent = sc.next();
                                    System.out.println("请输入你的博客类型");
                                    typeName = sc.next();
                                    // 查询博客类型是否存在
                                    blogType = blogTypeDao.findBlogType(typeName);
                                    if (blogType != null){
                                        // 将博客信息放入博客对象中
                                       blog = new Blog();
                                       blog.setBlogTitle(blogTitle);
                                       blog.setBlogContent(blogContent);
                                       blog.setUser(user);
                                       blog.setBlogType(blogType);
                                       // 验证博客是否创建成功
                                        boolean b = blogDao.addBlog(blog);
                                        if (b){
                                            System.out.println("博客创建成功！");
                                        }else{
                                            System.out.println("博客创建失败！");
                                        }
                                    }else {
                                        System.out.println("博客类型不存在！");
                                    }
                                    break;
                                // 请在下面的Begin-End之间按照注释中给出的提示编写正确的代码
                                /********** Begin **********/
                                case 2:
                                    System.out.println("查询所有博客请按1，查询自己的博客请按2，查询指定博客请按3，根据博客标题查询博客请按4，返回请按其它键");
                                    String find = sc.next();
                                    // 查询所有的博客
                                    if ("1".equals(find)){
                                        blogDao.findAllBlogs();
                                    // 查询自己的博客
                                    }else if ("2".equals(find)){
                                        blogDao.findMyBlogs(user);
                                    }else if ("3".equals(find)){
                                        // 获取键盘输入的博客 ID
                                        System.out.println("请输入你要查询的博客ID");
                                        blogId = sc.nextInt();
                                        // 查询博客
                                        blogDao.findBlogById(blogId);
                                    }else if ("4".equals(find)){
                                        // 获取键盘输入的博客标题
                                        System.out.println("请输入你要查询的博客标题");
                                        blogTitle = sc.next();
                                        // 查询博客
                                        blogDao.findBlogByTitle(blogTitle);
                                        
                                    }
                                    break;

                                /********** End **********/
                                case 3:
                                    System.out.println("请输入你要删除的博客ID");
                                    blogId = sc.nextInt();
                                    // 删除博客
                                    blogDao.deleteBlog(blogId, user);
                                    break;
                                case 4:
                                    // 获取用户键盘输入信息
                                    System.out.println("请输入你要修改的博客ID");
                                    blogId = sc.nextInt();
                                    System.out.println("请输入修改后的博客标题");
                                    blogTitle = sc.next();
                                    System.out.println("请输入修改后的博客内容");
                                    blogContent = sc.next();
                                    System.out.println("请输入修改后的博客类型");
                                    typeName = sc.next();
                                    // 查询博客类型是否存在
                                    blogType = blogTypeDao.findBlogType(typeName);
                                    if (blogType != null){
                                        // 将博客信息存入博客对象中
                                        blog = new Blog();
                                        blog.setBlogId(blogId);
                                        blog.setBlogTitle(blogTitle);
                                        blog.setBlogContent(blogContent);
                                        blog.setUser(user);
                                        blog.setBlogType(blogType);
                                        // 修改博客
                                        blogDao.updateBlog(blog);
                                    }else {
                                        System.out.println("博客类型不存在！");
                                    }
                                    break;
                                case 5:
                                    flag1 = false;
                                    break;
                                default:
                                    System.out.println("你的输入有误，请重新输入！");
                                    break;
                            }
                        }while (flag1);
                    }else{
                        System.out.println("用户名或密码不正确！");
                    }
                    break;
                case 2:
                    user = new User();
                    // 获取键盘输入的用户信息
                    System.out.println("请输入你要注册的用户名");
                    userName = sc.next();
                    System.out.println("请输入你要注册的密码");
                    passWord = sc.next();
                    System.out.println("请输入你要注册的手机号");
                    phone = sc.next();
                    // 将用户信息存入用户对象中
                    user.setUserName(userName);
                    user.setPassWord(passWord);
                    user.setPhone(phone);
                    // 调用 register 方法，将用户信息传入其中，判断注册是否成功
                    boolean result = userDao.register(user);
                    if (result) {
                        System.out.println("注册成功！");
                    }else{
                        System.out.println("注册失败！");
                    }
                    break;
                case 3:
                    // 设置状态为 false，退出系统
                    flag = false;
                    System.out.println("退出系统！");
                    break;
                default:
                    System.out.println("你的输入有误，请重新输入！");
                    break;
            }
        } while (flag);
    }
}

step8/com/dao/BlogDao.java

package com.dao;

import com.pojo.Blog;
import com.pojo.BlogType;
import com.pojo.User;
import com.util.DBConnection;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;

public class BlogDao {
    static Connection conn = null; // 连接对象
    static PreparedStatement ps = null; // 预编译
    static ResultSet rs = null; // 结果集

    public boolean addBlog(Blog blog) {
        boolean result = false;
        // 插入博客数据到博客表中
        try {
            conn = DBConnection.getConnection();
            String sql = "insert into t_blog (blogTitle,blogContent,userId,typeId) values (?,?,?,?)";
            ps = conn.prepareStatement(sql);
            ps.setString(1, blog.getBlogTitle());
            ps.setString(2, blog.getBlogContent());
            ps.setInt(3, blog.getUser().getUserId());
            ps.setInt(4, blog.getBlogType().getTypeId());
            int i = ps.executeUpdate();
            // 判断是否添加成功
            if (i == 1) {
                result = true;
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return result;
    }

    /**
     * 功能：查询所有博客
     */
    public void findAllBlogs() {
        // 通过三表关联查询，查询所有的博客
        try {
            conn = DBConnection.getConnection();
            String sql = "select t.blogId blogId,t.blogTitle blogTitle,t.blogContent blogContent,t.typeName,t_user.userName userName from(select t_blog.*,blog_type.typeName from t_blog left join blog_type on t_blog.typeId = blog_type.typeId) t left join t_user on t.userId = t_user.userId;";
            ps = conn.prepareStatement(sql);
            rs = ps.executeQuery();
            // 输出查询结果
            System.out.println("blogId\tblogTitle\tblogContent\ttypeName\tuserName");
            while (rs.next()){
                int blogId = rs.getInt("blogId");
                String blogTitle = rs.getString("blogTitle");
                String blogContent = rs.getString("blogContent");
                String typeName = rs.getString("typeName");
                String userName = rs.getString("userName");
                System.out.println(blogId+"\t"+blogTitle+"\t"+blogContent+"\t"+typeName+"\t"+userName);
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    /**
     * 功能 查询自己创建的博客
     * 参数 user
     */
    public void findMyBlogs(User user) {
        // 通过三表关联查询，查询自己创建的博客
        try {
            conn = DBConnection.getConnection();
            String sql = "select blog.*,blog_type.typeName from (select * from t_blog where userId = ?)blog left join blog_type on blog.typeId = blog_type.typeId";
            ps = conn.prepareStatement(sql);
            ps.setInt(1,user.getUserId());
            rs = ps.executeQuery();
            // 输出查询结果
            System.out.println("我创建的博客如下：");
            System.out.println("blogId\tblogTitle\tblogContent\ttypeName");
            while (rs.next()){
                int blogId = rs.getInt("blogId");
                String blogTitle = rs.getString("blogTitle");
                String blogContent = rs.getString("blogContent");
                String typeName = rs.getString("typeName");
                System.out.println(blogId+"\t"+blogTitle+"\t"+blogContent+"\t"+typeName);
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
    /**
     * 功能 根据指定博客 ID 删除自己所创建的博客
     * 参数 blogId
     * 参数 user
     */
    public void deleteBlog(int blogId, User user) {
        // 根据用户 ID 和 博客 ID 删除对应的博客信息
        try {
            conn = DBConnection.getConnection();
            String sql = "delete from t_blog where userId = ? and blogId = ?";
            ps = conn.prepareStatement(sql);
            ps.setInt(1, user.getUserId());
            ps.setInt(2, blogId);
            int i = ps.executeUpdate();
            // 判断是否删除成功
            if (i == 1) {
                System.out.println("博客删除成功！");
            }else {
                System.out.println("博客删除失败！");
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    /**
     * 功能 根据博客 ID 修改自己创建的博客
     * 参数 blog
     */
    public void updateBlog(Blog blog) {
        try {
            conn = DBConnection.getConnection();
            String sql = "update t_blog set blogTitle = ?,blogContent = ?,typeId = ? where userId = ? and blogId = ?";
            ps = conn.prepareStatement(sql);
            ps.setString(1,blog.getBlogTitle());
            ps.setString(2,blog.getBlogContent());
            ps.setInt(3, blog.getBlogType().getTypeId());
            ps.setInt(4, blog.getUser().getUserId());
            ps.setInt(5, blog.getBlogId());
            int i = ps.executeUpdate();
            // 判断是否删除成功
            if (i == 1) {
                System.out.println("博客修改成功！");
            }else {
                System.out.println("博客修改失败！");
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    /**
     * 功能 根据博客 ID 查询指定博客
     * 参数 blogId
     */
    public void findBlogById(int blogId) {
        // 根据博客 ID 查询指定博客
        try {
            conn = DBConnection.getConnection();
            String sql = "select t.blogTitle blogTitle,t.blogContent blogContent,t.typeName,t_user.userName userName from(select blog.*,blog_type.typeName from (select * from t_blog where blogId = ?)blog left join blog_type on blog.typeId = blog_type.typeId) t left join t_user on t.userId = t_user.userId;";
            ps = conn.prepareStatement(sql);
            ps.setInt(1,blogId);
            rs = ps.executeQuery();
            // 输出查询结果
            System.out.println("blogId\tblogTitle\tblogContent\ttypeName\tuserName");
            while (rs.next()){
                String blogTitle = rs.getString("blogTitle");
                String blogContent = rs.getString("blogContent");
                String typeName = rs.getString("typeName");
                String userName = rs.getString("userName");
                System.out.println(blogId+"\t"+blogTitle+"\t"+blogContent+"\t"+typeName+"\t"+userName);
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }

    }
    // 请在下面的Begin-End之间按照注释中给出的提示编写正确的代码
    /********** Begin **********/
    /**
     * 功能 根据博客标题模糊查询博客
     * 参数 blogTitle
     */
    public void findBlogByTitle(String blogTitle) {
        // 根据博客标题模糊查询博客
        try {
            conn = DBConnection.getConnection();
            String sql = "select t.blogId blogId,t.blogTitle blogTitle,t.blogContent blogContent,t.typeName,t_user.userName userName from(select blog.*,blog_type.typeName from (select * from t_blog where blogTitle like ?)blog left join blog_type on blog.typeId = blog_type.typeId) t left join t_user on t.userId = t_user.userId;";
            ps = conn.prepareStatement(sql);
            ps.setString(1,"%"+blogTitle+"%");
            rs = ps.executeQuery();
            // 输出查询结果
            System.out.println("blogId\tblogTitle\tblogContent\ttypeName\tuserName");
            while (rs.next()){
                int blogId = rs.getInt("blogId");
                String b = rs.getString("blogTitle");
                String blogContent = rs.getString("blogContent");
                String typeName = rs.getString("typeName");
                String userName = rs.getString("userName");
                System.out.println(blogId+"\t"+b+"\t"+blogContent+"\t"+typeName+"\t"+userName);
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }

            


    }

    /********** End **********/
}

 

 

博客系统第3关：博客系统之创建博客
popoywei的博客
12-29 636
如果不为 null，将创建博客所需信息、用户对象和博客类型对象放入博客对象中，调用 BlogDao.addBlog(Blog blog) 方法判断博客是否创建成功，如果返回 true，则输出：“博客创建成功！”，否则输出：“博客创建失败”；用户进入创建博客模块后，输出：“请输入你要创建的博客标题”、“请输入你要创建的博客内容”、“请输入你的博客类型”，然后获取键盘输入的信息，调用 BookTypeDao 类的 findBlogType(String blogType) 方法获取博客类型信息；
博客系统第1关：博客系统之用户注册
popoywei的博客
12-27 1829
如果用户进入注册模块，依次输出：“请输入你要注册的用户名”、“请输入你要注册的密码”、“请输入你要注册的手机号”，然后依次获取键盘输入的相关用户信息，将其放入 User 对象中，将 user 参数传入 UserDao 类的 register(User user) 方法中，判断用户注册是否成功，如果成功，请输出“注册成功！”，否则，输出：“注册失败！register() 实现将用户信息添加到 t_user 表中，如果用户名不存在，将其插入用户表中，返回 true，否则直接返回 false；
数据库设计 - 博客系统
我写写哈的博客
04-28 3748
数据库整体设计 一个博客系统会有哪些功能呢，肯定会有的是博客列表，博客详情，评论，登陆注册等等这些功能，那应该建多少张表呢？应该给这些表添加哪些字段呢？字段的约束怎么设计呢？表与表之间的关联关系应该怎样设计呢？ 这是你在开始本实训之前要思考的问题。 博客系统数据库的整体设计如下图所示：总共涉及到五张表： 用户信息表； 博客信息表； 博客类型表； 博客评论表； 博客标签表。 用户信息表（t_user） 设计用户信息表是设计数据库的第一步，和一般的网站类似，博客系统的用户信息有如下内容： 编程要求 请仔细阅
博客系统数据库设计与实现
weixin_63009852的博客
10-28 2329
仔细阅读右侧编辑区内给出的代码框架及注释，在 Begin-End 中通过 JDBC 的方式查询 MySQL 表 t_user 中的数据，输出查询结果时，用 \t 将查询字段结果分隔，格式：“userId userName passWord”，其中这些都分别对应着查询结果的值。在注册驱动前我们需要装载特定厂商的数据库驱动程序，导入 mysq-connector-java 的 jar 包，方法是在项目中建立 lib 目录，在其下放入 jar 包（平台已准备好 jar 包，无需自己放入）。
博客系统的SQL Server数据库设计与实现
weixin_35414260的博客
09-05 2073
本文还有配套的精品资源，点击获取 简介：博客系统依赖于关系型数据库来存储和管理文章、评论、用户信息等关键数据。本文介绍了一个博客系统数据库的设计，包括主要表的结构和它们之间的关系。重点讨论了SQL Server数据库管理工具的使用、数据库文件的组织、表结构的设计、外键约束、索引优化、性能提升策略，以及数据库的备份和维护。通过这些方法，保证了博客系统数据库的稳定性和可扩展性，...
以博客系统为例的数据库分析与设计之分析篇
Magaret的博客
07-08 5281
https://blog.youkuaiyun.com/Lockey23/article/details/73468418 系统分析 作为一个微型博客系统，不需要像微博或者csdn这样的大网站每天承受数以N万计的用户访问，也不需要展示丰富繁杂的内容，所以我们就按最简来进行数据库的设计，这样相对而言系统承载要小的很多很多，数据库条目关系以及储存占用也很小，也便于基础学习者理解。 服务器和数据库我们一...
基于数据库的个人博客的设计与实现
12-19
该资源主要是基于数据库开发的一款应用系统，便于对数据库sql server课程设计与实现，从而对数据库及所学知识有个很好的掌握。
博客系统第4关：博客系统之查询博客（一）
popoywei的博客
12-29 497
如果用户输入的为 2，则调用 BlogDao 类的 findMyBlogs(user) 方法，将用户信息传入，查询自己创建的博客，依次输出：“我创建的博客如下：”、“blogId blogTitle blogContent typeName”，中间分隔符为 \t，然后按照上述格式输出查询数据；用户进入查询博客模块后，输出：“查询所有博客请按1，查询自己的博客请按2，返回请按其它键”，然后获取键盘输入的信息；本关任务：在上一关卡中，我们实现了创建博客的功能，本关主要实现查询博客的功能。博客表 t_blog；
博客系统第11关：博客系统之查询博客评论
popoywei的博客
12-29 581
当用户进入查看评论模块后，首先，我们判断博客 ID 是否为 0，如果为 0，输出：“请输入你要查看评论的博客ID”，获取键盘输入的博客 ID，如果不为 0，则使用该博客 ID，调用 CommentDao 的 findCommentById(int BlogId)，根据博客 ID 查询这个博客的所有评论；用户查询完博客后，可以进行发布评论和查询评论，在之前的关卡中，当用户输入 1 后会进入发布评论，这里我们需要实现当用户输入 2 后可以查看该博客的所有评论；”后，进入用户查询该博客所有评论的模块。
博客系统第13关：博客系统之修改删除博客
popoywei的博客
12-29 664
BlogDao 类的 deleteBlog(int blogId, User user) 方法是用来删除博客的，现在我们需要对其进行修改；本关任务：在之前的关卡中，我们实现了删除博客的功能，如今我们需要改进删除博客的功能，本关要求实现删除博客的同时删除博客下面的评论的功能。最后，我们再删除博客，如果删除成功，输出：“博客删除成功！”，否则输出：“博客删除失败！首先，我们需要根据博客 ID、用户名 ID 确定该博客是否可以被删除；然后，我们需要先删除这条博客下面的所有评论；博客评论表 t_comment；
个人博客系统的设计与实现【源码+数据库+论文+视频讲解+部署】.rar
09-12
个人博客系统主要用于发表个人博客，记录个人生活日常，学习心得，技术分享等，供他人浏览，查阅，评论等。本系统结构如下： （1）博主端： 登录模块：登入后台管理系统：首先进入登录页面，需要输入账号和密码。它会使用Shiro进行安全管理，对前台输入的密 码进行加密运算，然后与数据库中的进行比较。成功后才能登入后台系统。 博客管理模块： 博客管理功能分为写博客和博客信息管理。写博客是博主用来发表编写博客的，需要博客标题，然后选择博 客类型，最后将博客内容填入百度的富文本编辑器中，点击发布博客按钮即可发布博客。 博客类别管理模块：博主类别管理系统可以添加，修改和删除博客类型名称和排序序号。将会显示到首页的按日志类别区域。 游客可以从这里查找相关的感兴趣的博客内容 评论信息管理模块：评论管理功能分为评论审核和评论信息管理两部分。评论审核是当有游客或自己发表了评论之后，博主需 要在后台管理系统中审核评论。若想将此评论显示在页面上则点击审核通过，否则点击审核不通过。 个人信息管理模块：修改博主的个人信息，可以修改昵称，个性签名，可以添加个人头像，修改个人简介； 系统管理功能模块：友情链接管理，修改密码，刷新系统缓存和安全退出，友情链接管理可以添加，修改，删除友情链接网址 （2）游客端： 查询博客： 查询具体哪一篇博客 查看博客内容： 查看博客内容 查看博主个人信息：查看博主个人简介 发表评论： 可以评论具体某篇博客 友情链接： 查看友情链接
个人博客系统设计与实现
qq_61141142的博客
09-20 1950
1.1数据库的选择SQL Server 2005 是一个全面的数据库平台，使用集成的商业智能 (BI) 工具提供了企业级的数据管理。SQL Server 2005 数据库引擎为关系型数据和结构化数据提供了更安全可靠的存储功能，使您可以构建和管理用于业务的高可用和高性能的数据应用程序。SQL Server 2005 基于 SQL Server 2000 的强大功能之上，提供了一个完整的数据管理和分析解决方案，它将会给不同规模的组织带来帮助：•构建、部署和管理企业应用程序，使其更加安全、伸缩性更强和更可靠。
博客系统数据库设计与实现之修改(java)
m0_65420451的博客
10-16 1920
根据用户 ID 修改用户的名称和密码。首先，我们需要加载（注册）数据库驱动（到 JVM ）；Class.forName("com.mysql.jdbc.Driver");建立（获取）数据库连接；//参数：1.JDBC URL 2.数据库用户名 2. 数据库密码Connection con = DriverManager.getConnection(url,以上就是今天要讲的内容，本文仅仅简单介绍了博客系统数据库设计与实现，以及相关的数据库的创建、数据库的连接、Java与数据库的增删改查等操作。
【项目实战】博客系统设计与实现
qq_52183856的博客
06-01 6358
前端：展示文章，文章分类，评论，用户登录。后端 ：系统管理：用户管理，菜单管理，角色管理。内容管理：文章管理，分类管理，标签管理数据库：mysql8.0.28项目结构：maven数据库连接池：Druid前端框架：Vue后端框架：SpringBoot，SpringSecurity语言：Javajdk版本：17编写的IDE：IDEA。
博客系统第8关：博客系统之博客查询（三）
popoywei的博客
12-29 453
如果用户输入的为 4，输出：“请输入你要查询的博客标题”，获取键盘输入的博客标题，然后调用 findBlogByTitle(String blogTitle) 方法模糊查询博客，输出：“blogId blogTitle blogContent typeName userName”，中间分隔符为 \t，然后按照上述格式输出查询数据。用户进入查询博客模块后，将原先的输出修改为：“查询所有博客请按1，查询自己的博客请按2，查询指定博客请按3，根据博客标题查询博客请按4，返回请按其它键”，然后获取键盘输入的信息；
基于SSM的个人博客系统的设计与实现（附源码+课件+数据库+视频）
hutubiancheng的博客
08-19 1294
个人博客是人们在网络上展现自己个性的一种方式。自从互联网走进千家万户，大受人们喜爱。大家都喜欢通过网络来获取各种各样的信息。而在网络上，你也可以畅所欲言，而个人博客也是其中一种。在个人博客上，你可以发表自己的心路旅程，发表自己的工作经验，发表技术博客等等。首先介绍一下什么是博客，它也被称为网络日志。博客其实就是一个网页，它是由各种各样的帖子组成。这些帖子可以是你某一天观看电影的感慨，也可以是阅读到某篇书籍的读后感，更可以是你在自己技术领域的心得。
博客系统 - 数据库设计（一）
热门推荐
qq_44745905的博客
10-28 1万+
@R星校长 第1关：数据库表设计 - 用户信息表 数据库整体设计 一个博客系统会有哪些功能呢，肯定会有的是博客列表，博客详情，评论，登陆注册等等这些功能，那应该建多少张表呢？应该给这些表添加哪些字段呢？字段的约束怎么设计呢？表与表之间的关联关系应该怎样设计呢？ 这是你在开始本实训之前要思考的问题。 博客系统数据库的整体设计如下图所示：总共涉及到五张表： 用户信息表； 博客信息表； 博客类型表； 博客评论表； 博客标签表。 用户信息表（t_user） 设计用户信息表是设计数据库的第一步，和一般的网站类.
个人博客系统的设计与实现_博客网站的设计与实现（工具篇）
weixin_39588209的博客
12-03 3067
一、系统的设计目标目标：能够注册用户，用户可以创建自己的博客，而且用户间可以互动。 二、开发工具及安装配置==MyEclipse==,==Navicat for MySQL==1.1 MyEclipse1、简介：MyEclipse是在eclipse 基础上加上自己的插件开发而成的功能强大的企业级集成开发环境，主要用于Java、Java EE以及移动应用的开发。2、下载安装步骤1）在官网下载m...
博客-评论系统数据库设计及实现
三明治文鱼的博客
07-05 1万+
最近在开发一个小型个人博客，在数据库设计方面遇到了一些问题，这里做一个记录。 博客包含博客的基本信息，包括标题、内容等，此外还包括博客的标签、类型和评论。 对象关系 一篇博客可能对应多个标签，一个标签可以被多篇博客对包含。（多对多） 一篇博客只能对应一个分类，一个分类可以被多篇博客对包含。（一对多） 一篇博客可能对应多条评论，一条评论只能对应一篇博客。（一对多） 一篇博客只能对应一个用户，一个用户可能拥有多篇博客。（一对多） 一条评论可能包含多条子评论，一条评论只能对应一条父评论。（一对多） 上面关系里：
第1关：Hexo博客系统的部署
最新发布
12-12
Hexo是一个快速、简洁且高效的博客框架，基于Node.js开发。以下是如何在本地环境中部署Hexo博客系统的步骤： ### 1. 安装Node.js和Git 首先，确保你的系统已经安装了Node.js和Git。你可以通过以下命令来检查是否已经安装： ```bash node -v git --version ``` 如果未安装，请访问[Node.js官网](https://nodejs.org/)和[Git官网](https://git-scm.com/)下载安装包并安装。 ### 2. 安装Hexo CLI 使用npm（Node.js包管理器）全局安装Hexo CLI： ```bash npm install -g hexo-cli ``` ### 3. 初始化Hexo博客 在本地创建一个新的文件夹作为你的博客目录，并初始化Hexo： ```bash mkdir my-hexo-blog cd my-hexo-blog hexo init npm install ``` ### 4. 生成静态文件 使用以下命令生成静态文件： ```bash hexo generate ``` ### 5. 启动本地服务器 启动本地服务器并预览博客： ```bash hexo server ``` 打开浏览器并访问 `http://localhost:4000`，你应该可以看到你的Hexo博客。 ### 6. 部署到GitHub Pages 首先，在GitHub上创建一个新的仓库，命名为 `your-username.github.io`。然后，在你的博客目录下安装 `hexo-deployer-git` 插件： ```bash npm install hexo-deployer-git --save ``` 编辑 `_config.yml` 文件，添加以下配置： ```yaml deploy: type: git repo: https://github.com/your-username.github.io.git branch: main ``` 最后，使用以下命令部署博客： ```bash hexo deploy ``` ### 7. 配置自定义域名（可选） 如果你有自己的域名，可以在GitHub仓库中创建一个 `CNAME` 文件，并添加你的域名。然后，在你的域名提供商处配置DNS记录，将域名指向GitHub Pages的IP地址。 ### 8. 常用命令 - 清理生成的静态文件： ```bash hexo clean ``` - 生成静态文件并部署： ```bash hexo generate --deploy ```
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值