Java web 2022跟学尚硅谷(八)qqzone项目完整版开源分享

最新推荐文章于 2024-04-23 09:36:04 发布
最新推荐文章于 2024-04-23 09:36:04 发布
阅读量813 收藏 8
点赞数 2
分类专栏： java web 文章标签： java 前端 开源
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sinat_38316216/article/details/128285931
版权

Java web 2022跟学尚硅谷 八qqzone完整版

项目说明

跟学尚硅谷最新版本2022，完成了qqzone项目的制作，项目所有源码给出，方便所有需要学习的朋友，项目给出，Gitee码云的连接，可以自行fork。麻烦顺手给文章点个赞谢谢啦！
qqzone项目完整版

  1. 数据库连接池:Druid跟学韩顺平老师的项目，这里没按照视频老师的方式配置，所以Service中有些代码的地方是按照自己的实际情况写的。
  2. 源码和素材可以去看视频底下有获取方式

项目结构

项目结构
项目结构2

界面展示

用户的登录

还没有账号，这个功能暂时没有实现
用户的登录

主界面

主界面

进入朋友空间

当前登录用户是Jim，现在点击左侧好友列表，进入kate的空间，可以查看kate发表的日志
进入朋友空间

针对朋友发表的日志进行回复

在朋友的日志下，可以进行回复
针对朋友发表的日志进行回复

主人回复

在当前登录的用户日志列表中，鼠标靠近别人的回复，可以直接添加主人回复，这里是用form表单实现，因为超链接跳转隐藏form表单的方法不是太会，就用了这种方式，大家可以自行尝试
主人回复

添加日志

点击日志列表右上角的“发表新日志，即可跳转发表新日志”
添加日志

数据库相关sql

CREATE DATABASE `qqzonedb2` CHAR SET utf8;

USE qqzonedb2;
`t_friend``t_friend`
CREATE TABLE `t_user_basic` (
  `id` INT(11) NOT NULL AUTO_INCREMENT,
  `loginId` VARCHAR(20) NOT NULL,
  `nickName` VARCHAR(50) NOT NULL,
  `pwd` VARCHAR(20) NOT NULL,
  `headImg` VARCHAR(20) DEFAULT NULL,
  PRIMARY KEY (`id`),
  UNIQUE KEY `loginId` (`loginId`)
) ENGINE=INNODB AUTO_INCREMENT=6 DEFAULT CHARSET=utf8;

INSERT  INTO `t_user_basic`(`id`,`loginId`,`nickName`,`pwd`,`headImg`) VALUES (1,'u001','jim','ok','h1.jpeg'),(2,'u002','tom','ok','h2.jpeg'),(3,'u003','kate','ok','h3.jpeg'),(4,'u004','lucy','ok','h4.jpeg'),(5,'u005','张三丰','ok','h5.jpeg');


CREATE TABLE `t_friend` (
  `id` INT(11) NOT NULL AUTO_INCREMENT,
  `uid` INT(11) DEFAULT NULL,
  `fid` INT(11) DEFAULT NULL,
  PRIMARY KEY (`id`),
  KEY `FK_friend_basic_uid` (`uid`),
  KEY `FK_friend_basic_fid` (`fid`),
  CONSTRAINT `FK_friend_basic_fid` FOREIGN KEY (`fid`) REFERENCES `t_user_basic` (`id`),
  CONSTRAINT `FK_friend_basic_uid` FOREIGN KEY (`uid`) REFERENCES `t_user_basic` (`id`)
) ENGINE=INNODB AUTO_INCREMENT=11 DEFAULT CHARSET=utf8;

SELECT * FROM t_friend;

INSERT  INTO `t_friend`(`id`,`uid`,`fid`) VALUES (1,1,2),(2,1,3),(3,1,4),(4,1,5),(5,2,3),(6,2,1),(7,2,4),(8,3,1),(9,3,2),(10,5,1);

CREATE TABLE `t_topic` (
  `id` INT(11) NOT NULL AUTO_INCREMENT,
  `title` VARCHAR(100) NOT NULL,
  `content` VARCHAR(500) NOT NULL,
  `topicDate` DATETIME NOT NULL,
  `author` INT(11) NOT NULL,
  PRIMARY KEY (`id`),
  KEY `FK_topic_basic` (`author`),
  CONSTRAINT `FK_topic_basic` FOREIGN KEY (`author`) REFERENCES `t_user_basic` (`id`)
) ENGINE=INNODB AUTO_INCREMENT=9 DEFAULT CHARSET=utf8;

INSERT  INTO `t_topic`(`id`,`title`,`content`,`topicDate`,`author`) 
VALUES 
(3,'我的空间开通了，先做自我介绍！','大家好，我是铁锤妹妹！','2021-06-18 11:25:30',2),
(8,'我的空间','我的空间','2021-07-14 16:16:40',1);

CREATE TABLE `t_reply` (
  `id` INT(11) NOT NULL AUTO_INCREMENT,
  `content` VARCHAR(500) NOT NULL,
  `replyDate` DATETIME NOT NULL,
  `author` INT(11) NOT NULL,
  `topic` INT(11) NOT NULL,
  PRIMARY KEY (`id`),
  KEY `FK_reply_basic` (`author`),
  KEY `FK_reply_topic` (`topic`),
  CONSTRAINT `FK_reply_basic` FOREIGN KEY (`author`) REFERENCES `t_user_basic` (`id`),
  CONSTRAINT `FK_reply_topic` FOREIGN KEY (`topic`) REFERENCES `t_topic` (`id`)
) ENGINE=INNODB AUTO_INCREMENT=6 DEFAULT CHARSET=utf8;

INSERT  INTO `t_reply`(`id`,`content`,`replyDate`,`author`,`topic`) VALUES (3,'回复','2021-07-14 16:16:54',2,8),(4,'回复2222','2021-07-14 16:17:11',3,8),(5,'这里是第三个回复','2021-07-14 16:30:49',1,8);

CREATE TABLE `t_host_reply` (
  `id` INT(11) NOT NULL AUTO_INCREMENT,
  `content` VARCHAR(500) NOT NULL,
  `hostReplyDate` DATETIME NOT NULL,
  `author` INT(11) NOT NULL,
  `reply` INT(11) NOT NULL,
  PRIMARY KEY (`id`),
  KEY `FK_host_basic` (`author`),
  KEY `FK_host_reply` (`reply`),
  CONSTRAINT `FK_host_basic` FOREIGN KEY (`author`) REFERENCES `t_user_basic` (`id`),
  CONSTRAINT `FK_host_reply` FOREIGN KEY (`reply`) REFERENCES `t_reply` (`id`)
) ENGINE=INNODB DEFAULT CHARSET=utf8;

CREATE TABLE `t_user_detail` (
  `id` INT(11) NOT NULL,
  `realName` VARCHAR(20) DEFAULT NULL,
  `tel` VARCHAR(11) DEFAULT NULL,
  `email` VARCHAR(30) DEFAULT NULL,
  `birth` DATETIME DEFAULT NULL,
  `star` VARCHAR(10) DEFAULT NULL,
  PRIMARY KEY (`id`),
  CONSTRAINT `FK_detail_basic` FOREIGN KEY (`id`) REFERENCES `t_user_basic` (`id`)
) ENGINE=INNODB DEFAULT CHARSET=utf8;

相关代码

具体相关代码可以直接fork上面的项目，这里只放出一些关键核心的java代码

BasicDAO 调用德鲁伊连接池，完成sql执行

因为表中很多是多表连接，这里就改造了一些方法，具体多表连接的方式可以参考韩老师发的连接，当然这里我自己也有用到，可以参考这篇博主的文章
DButils数据库连接池多表关联处理方式

package com.atguigu.qqzone.basic;

import com.atguigu.qqzone.exceptions.DAOException;
import com.atguigu.qqzone.pojo.HostReply;
import com.atguigu.qqzone.pojo.Reply;
import com.atguigu.qqzone.pojo.Topic;
import com.atguigu.qqzone.pojo.UserBasic;
import com.atguigu.utils.DruidUtils;
import org.apache.commons.dbutils.QueryRunner;
import org.apache.commons.dbutils.handlers.BeanHandler;
import org.apache.commons.dbutils.handlers.BeanListHandler;
import org.apache.commons.dbutils.handlers.MapListHandler;
import org.apache.commons.dbutils.handlers.ScalarHandler;

import java.sql.Connection;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;

/**
 * @ClassName: BasicDAO
 * @Description:
 * @Author: wty
 * @Date: 2022/12/5
 */

public class BasicDAO<T> {
    private QueryRunner queryRunner = new QueryRunner();

    /**
     * @param
     * @return int
     * @description //TODO
     * @param: sqlStr
     * @param: params
     * @date 2022/12/4 17:53
     * @author wty
     **/
    public int dml(String sqlStr, Object... params) {
        Connection connection = null;

        int affectedrows = 0;

        try {
            connection = DruidUtils.getConnection();
            affectedrows = queryRunner.update(connection, sqlStr, params);

        } catch (SQLException e) {
            e.printStackTrace();
            throw new DAOException("BasicDAO dml出错!");
        } finally {
            DruidUtils.close(null, null, connection);
        }
        return affectedrows;

    }

    /**
     * @return java.util.List<T>
     * @description 返回多行结果
     * @param: sqlStr
     * @param: clazz
     * @param: params
     * @date 2022/12/4 17:59
     * @author wty
     **/
    public List<T> queryMulti(String sqlStr, Class<T> clazz, Object... params) {
        Connection connection = null;
        List<T> list = null;

        try {
            connection = DruidUtils.getConnection();
            list = queryRunner.query(connection, sqlStr, new BeanListHandler<T>(clazz), params);
        } catch (Exception e) {
            e.printStackTrace();
            throw new DAOException("BasicDAO queryMulti出错!");
        } finally {
            DruidUtils.close(null, null, connection);
        }
        return list;
    }

    /**
     * @param
     * @return T
     * @description 返回单行多列数据
     * @param: sqlStr
     * @param: clazz
     * @param: params
     * @date 2022/12/4 18:01
     * @author wty
     **/
    public T querySingle(String sqlStr, Class<T> clazz, Object... params) {
        Connection connection = null;
        T t = null;
        try {
            connection = DruidUtils.getConnection();
            t = queryRunner.query(connection, sqlStr, new BeanHandler<T>(clazz), params);
        } catch (Exception e) {
            e.printStackTrace();
            throw new DAOException("BasicDAO querySingle出错!");
        } finally {
            DruidUtils.close(null, null, connection);
        }
        return t;
    }

    public Object queryScalar(String sqlStr, Object... params) {
        Connection connection = null;
        Object o = null;

        try {
            connection = DruidUtils.getConnection();
            o = queryRunner.query(connection, sqlStr, new ScalarHandler(), params);
        } catch (Exception e) {
            e.printStackTrace();
            throw new DAOException("BasicDAO queryScalar出错!");
        } finally {
            DruidUtils.close(null, null, connection);
        }
        return o;
    }

    /**
     * @return java.util.List<T>
     * @description 返回多行结果--用于多表查询
     * @param: sqlStr
     * @param: clazz
     * @param: params
     * @date 2022/12/4 17:59
     * @author wty
     **/
    public List<Topic> queryMultiListAndMap(String sqlStr, List<Topic> list, Object... params) {
        Connection connection = null;

        try {
            connection = DruidUtils.getConnection();
            MapListHandler mapListHandler = new MapListHandler();
            List<Map<String, Object>> query = queryRunner.query(connection, sqlStr, mapListHandler, params);

            for (Map<String, Object> map : query) {
                UserBasic userBasic = new UserBasic();
                Topic topic = new Topic();

                userBasic.setId((Integer) map.get("author"));

                topic.setAuthor(userBasic);
                topic.setId((Integer) map.get("id"));
                topic.setTitle((String) map.get("title"));
                topic.setContent((String) map.get("content"));
                topic.setTopicDate((java.util.Date) map.get("topicDate"));

                list.add(topic);
            }

        } catch (Exception e) {
            e.printStackTrace();
            throw new DAOException("BasicDAO queryMultiListAndMap出错!");
        } finally {
            DruidUtils.close(null, null, connection);
        }
        return list;
    }

    /**
     * @param
     * @return java.util.List<com.atguigu.qqzone.pojo.Topic>
     * @description 返回多行结果--用于多表查询
     * @param: sqlStr
     * @param: list
     * @param: params
     * @date 2022/12/10 17:24
     * @author wty
     **/
    public List<Reply> queryMultiListAndMapReply(String sqlStr, List<Reply> list, Object... params) {
        Connection connection = null;

        try {
            connection = DruidUtils.getConnection();
            MapListHandler mapListHandler = new MapListHandler();
            List<Map<String, Object>> query = queryRunner.query(connection, sqlStr, mapListHandler, params);

            for (Map<String, Object> map : query) {
                Topic topic = new Topic();
                Reply reply = new Reply();
                UserBasic userBasic = new UserBasic();

                topic.setId((Integer) map.get("topic"));
                userBasic.setId((Integer) map.get("author"));

                reply.setTopic(topic);
                reply.setAuthor(userBasic);

                reply.setId((Integer) map.get("id"));
                reply.setContent((String) map.get("content"));
                reply.setReplyDate((java.util.Date) map.get("replyDate"));

                list.add(reply);
            }

        } catch (Exception e) {
            e.printStackTrace();
            throw new DAOException("BasicDAO queryMultiListAndMapReply出错!");
        } finally {
            DruidUtils.close(null, null, connection);
        }
        return list;
    }


    /**
     * @param
     * @return T
     * @description 返回单行记录，用于Topic
     * @param: sqlStr
     * @param: clazz
     * @param: params
     * @date 2022/12/10 17:43
     * @author wty
     **/
    public Topic querySingleTopic(String sqlStr, Object... params) {
        Connection connection = null;
        Topic topic = new Topic();
        try {
            connection = DruidUtils.getConnection();
            MapListHandler mapListHandler = new MapListHandler();
            List<Map<String, Object>> map = queryRunner.query(connection, sqlStr, mapListHandler, params);
            if (map.size() == 0) {
                return null;
            }

            UserBasic userBasic = new UserBasic();

            userBasic.setId((Integer) map.get(0).get("author"));

            topic.setAuthor(userBasic);
            topic.setId((Integer) map.get(0).get("id"));
            topic.setTitle((String) map.get(0).get("title"));
            topic.setContent((String) map.get(0).get("content"));
            topic.setTopicDate((java.util.Date) map.get(0).get("topicDate"));

        } catch (Exception e) {
            e.printStackTrace();
            throw new DAOException("BasicDAO querySingleTopic出错!");
        } finally {
            DruidUtils.close(null, null, connection);
        }
        return topic;
    }

    /**
     * @param
     * @return T
     * @description 单行查询--HostReply
     * @param: sqlStr
     * @param: clazz
     * @param: params
     * @date 2022/12/10 18:05
     * @author wty
     **/
    public HostReply querySingleHostReply(String sqlStr, Object... params) {
        Connection connection = null;
        HostReply hostReply = new HostReply();
        try {
            connection = DruidUtils.getConnection();
            MapListHandler mapListHandler = new MapListHandler();
            List<Map<String, Object>> map = queryRunner.query(connection, sqlStr, mapListHandler, params);

            if (map.size() == 0) {
                return null;
            }
            UserBasic userBasic = new UserBasic();
            Reply reply = new Reply();

            userBasic.setId((Integer) map.get(0).get("author"));
            hostReply.setAuthor(userBasic);

            reply.setId((Integer) map.get(0).get("reply"));
            hostReply.setReply(reply);

            hostReply.setId((Integer) map.get(0).get("id"));
            hostReply.setContent((String) map.get(0).get("content"));
            hostReply.setHostReplyDate((java.util.Date) map.get(0).get("hostReplyDate"));

        } catch (Exception e) {
            e.printStackTrace();
            throw new DAOException("BasicDAO querySingle出错!");
        } finally {
            DruidUtils.close(null, null, connection);
        }
        return hostReply;
    }

    /**
     * @param
     * @return com.atguigu.qqzone.pojo.Topic
     * @description 返回单行记录，用于Reply
     * @param: sqlStr
     * @param: params
     * @date 2022/12/11 23:53
     * @author wty
     **/
    public Reply querySingleReply(String sqlStr, Object... params) {
        Connection connection = null;
        Reply reply = new Reply();
        try {
            connection = DruidUtils.getConnection();
            MapListHandler mapListHandler = new MapListHandler();
            List<Map<String, Object>> map = queryRunner.query(connection, sqlStr, mapListHandler, params);
            if (map.size() == 0) {
                return null;
            }

            UserBasic userBasic = new UserBasic();
            Topic topic = new Topic();
            HostReply hostReply = new HostReply();

            userBasic.setId((Integer) map.get(0).get("author"));
            reply.setAuthor(userBasic);

            topic.setId((Integer) map.get(0).get("topic"));
            reply.setTopic(topic);

            hostReply.setId((Integer) map.get(0).get("id"));
            reply.setHostReply(hostReply);

            reply.setId((Integer) map.get(0).get("id"));
            reply.setContent((String) map.get(0).get("content"));
            reply.setReplyDate((java.util.Date) map.get(0).get("replyDate"));

        } catch (Exception e) {
            e.printStackTrace();
            throw new DAOException("BasicDAO querySingleTopic出错!");
        } finally {
            DruidUtils.close(null, null, connection);
        }
        return reply;
    }
}

HostReplyController 主人回复

package com.atguigu.qqzone.controller;

import com.atguigu.qqzone.pojo.HostReply;
import com.atguigu.qqzone.pojo.Reply;
import com.atguigu.qqzone.pojo.Topic;
import com.atguigu.qqzone.pojo.UserBasic;
import com.atguigu.qqzone.service.impl.HostReplyServiceImpl;

import javax.servlet.http.HttpSession;
import java.util.Date;

/**
 * @ClassName: HostReplyController
 * @Description:
 * @Author: wty
 * @Date: 2022/12/11
 */

public class HostReplyController {
    private HostReplyServiceImpl hostReplyServiceImpl;

    public String addHostReply(String content, Integer replyId, HttpSession session) {
        UserBasic author = (UserBasic) session.getAttribute("userBasic");
        Reply reply = new Reply(replyId);

        HostReply hostReply = new HostReply(content, new Date(), author, reply);

        hostReplyServiceImpl.addHostReply(hostReply);

        // 重定向返回日志详情
        Topic topic = (Topic) session.getAttribute("topic");
        return "redirect:topic.do?operate=topicDetail&id=" + topic.getId();

    }
}

ReplyController 回复

package com.atguigu.qqzone.controller;

import com.atguigu.qqzone.pojo.Reply;
import com.atguigu.qqzone.pojo.Topic;
import com.atguigu.qqzone.pojo.UserBasic;
import com.atguigu.qqzone.service.impl.ReplyServiceImpl;

import javax.servlet.http.HttpSession;
import java.util.Date;

/**
 * @ClassName: ReplyController
 * @Description:
 * @Author: wty
 * @Date: 2022/12/10
 */

public class ReplyController {
    private ReplyServiceImpl replyServiceImpl;

    public String addReply(String content, Integer topicId, HttpSession session) {
        // 当前作者
        UserBasic author = (UserBasic) session.getAttribute("userBasic");


        Reply reply = new Reply(content, new Date(), author, new Topic(topicId));

        replyServiceImpl.addReply(reply);

        return "redirect:topic.do?operate=topicDetail&id=" + topicId;

    }

    public String delReply(Integer replyId, Integer topicId) {
        replyServiceImpl.delReply(replyId);
        return "redirect:topic.do?operate=topicDetail&id=" + topicId;
    }

}

TopicController 日志

package com.atguigu.qqzone.controller;

import com.atguigu.qqzone.pojo.Reply;
import com.atguigu.qqzone.pojo.Topic;
import com.atguigu.qqzone.pojo.UserBasic;
import com.atguigu.qqzone.service.impl.ReplyServiceImpl;
import com.atguigu.qqzone.service.impl.TopicServiceImpl;

import javax.servlet.http.HttpSession;
import java.time.LocalDateTime;
import java.util.Date;
import java.util.List;

/**
 * @ClassName: TopicController
 * @Description:
 * @Author: wty
 * @Date: 2022/12/10
 */

public class TopicController {
    private TopicServiceImpl topicServiceImpl;

    public String topicDetail(Integer id, HttpSession session) {
        Topic topic = topicServiceImpl.getTopicById(id);

        //List<Reply> replyList = replyServiceImpl.getReplyListByTopicId(id);
        //topic.setReplyList(replyList);

        session.setAttribute("topic", topic);
        return "frames/detail";
    }

    public String delTopic(Integer topicId) {
        topicServiceImpl.delTopic(topicId);
        return "redirect:topic.do?operate=getTopicList";
    }

    public String getTopicList(HttpSession session) {
        // 从session中获取当前用户信息
        UserBasic userBasic = (UserBasic) session.getAttribute("userBasic");
        // 再次查询当前用户关联的所有日志
        List<Topic> topicList = topicServiceImpl.getTopicList(userBasic);

        // 设置关联的日志列表
        /**
         * <tr th:unless="${#lists.isEmpty(session.friend.topicList)}" th:each="topic : ${session.friend.topicList}">
         */
        // 重新覆盖
        userBasic.setTopicList(topicList);
        session.setAttribute("friend", userBasic);
        return "frames/main";
    }

    public String addTopic(String title, String content, HttpSession session) {
        UserBasic userBasic = (UserBasic) session.getAttribute("userBasic");
        Topic topic = new Topic(title, content, new Date(), new UserBasic(userBasic.getId()));
        topicServiceImpl.addTopic(topic);
        return "redirect:topic.do?operate=getTopicList";
    }

}

UserController用户信息以及登录

package com.atguigu.qqzone.controller;

import com.atguigu.qqzone.pojo.Topic;
import com.atguigu.qqzone.pojo.UserBasic;
import com.atguigu.qqzone.service.impl.TopicServiceImpl;
import com.atguigu.qqzone.service.impl.UserBasicServiceImpl;

import javax.servlet.http.HttpSession;
import java.util.List;

/**
 * @ClassName: QqZoneController
 * @Description:
 * @Author: wty
 * @Date: 2022/12/9
 */

public class UserController {
    private UserBasicServiceImpl userBasicServiceImpl;
    private TopicServiceImpl topicServiceImpl;

    /**
     * @param
     * @return java.lang.String
     * @description 注册
     * @param: loginId
     * @param: pwd
     * @param: session
     * @date 2022/12/9 18:29
     * @author wty
     **/
    public String login(String loginId, String pwd, HttpSession session) {
        UserBasic userBasic = userBasicServiceImpl.login(loginId, pwd);
        if (null != userBasic) {
            // 获取好友列表
            List<UserBasic> friendList = userBasicServiceImpl.getFriendList(userBasic);
            // 获取日志列表
            List<Topic> topicList = topicServiceImpl.getTopicList(userBasic);

            userBasic.setFriendList(friendList);
            userBasic.setTopicList(topicList);

            // userBasic这个key保存的是登录者的信息
            session.setAttribute("userBasic", userBasic);
            // friend这个key保存的是登录者的信息
            session.setAttribute("friend", userBasic);
            // 验证成功,跳转主界面
            return "index";
        } else {
            // 验证失败,跳转注册界面
            return "login";
        }
    }


    public String friend(Integer id, HttpSession session) {
        // 1.根据id获取指定的用户信息
        UserBasic currendFriend = userBasicServiceImpl.getUserBasicById(id);

        if (null != currendFriend) {
            // 获取日志列表
            List<Topic> topicList = topicServiceImpl.getTopicList(currendFriend);

            currendFriend.setTopicList(topicList);

            // friend这个key保存的是登录者的信息
            session.setAttribute("friend", currendFriend);
            // 验证成功,跳转主界面
            return "index";
        } else {
            // 验证失败,跳转注册界面
            return "login";
        }
    }
}

DAOException自定义异常

package com.atguigu.qqzone.exceptions;

/**
 * @ClassName: 抛出异常整合
 * @Description:
 * @Author: wty
 * @Date: 2022/12/9
 */

public class DAOException extends RuntimeException {
    public DAOException(String msg) {
        super(msg);
    }
}

DispatcherServletException中央控制器自定义异常

package com.atguigu.qqzone.exceptions;

/**
 * @ClassName: DispatcherServletException
 * @Description:
 * @Author: wty
 * @Date: 2022/12/9
 */

public class DispatcherServletException extends RuntimeException {
    public DispatcherServletException(String msg) {
        super(msg);
    }
}

HostReplyServiceImpl主人回复实现

package com.atguigu.qqzone.service.impl;

import com.atguigu.qqzone.dao.HostReplyDAO;
import com.atguigu.qqzone.pojo.HostReply;
import com.atguigu.qqzone.service.HostReplyService;

import java.util.List;

/**
 * @ClassName: HostReplyServiceImpl
 * @Description:
 * @Author: wty
 * @Date: 2022/12/9
 */

public class HostReplyServiceImpl implements HostReplyService {
    private HostReplyDAO hostReplyDAO;

    @Override
    public HostReply getHostReplyByReplyId(Integer replyId) {
        String sqlStr = "SELECT * FROM qqzonedb2.`t_host_reply` a WHERE a.`reply` = ?";
        return hostReplyDAO.querySingleHostReply(sqlStr, replyId);
    }

    @Override
    public void addHostReply(HostReply hostReply) {
        String sqlStr = "INSERT INTO qqzonedb2.`t_host_reply` VALUES (0,?,?,?,?)";
        hostReplyDAO.dml(sqlStr, hostReply.getContent(), hostReply.getHostReplyDate(), hostReply.getAuthor().getId(), hostReply.getReply().getId());
    }

    @Override
    public void delHostReply(Integer id) {
        String sqlStr = "DELETE FROM qqzonedb2.`t_host_reply` WHERE id = ?";
        hostReplyDAO.dml(sqlStr, id);
    }


}

ReplyServiceImpl 回复实现

package com.atguigu.qqzone.service.impl;

import com.atguigu.qqzone.dao.HostReplyDAO;
import com.atguigu.qqzone.dao.ReplyDAO;
import com.atguigu.qqzone.pojo.HostReply;
import com.atguigu.qqzone.pojo.Reply;
import com.atguigu.qqzone.pojo.Topic;
import com.atguigu.qqzone.pojo.UserBasic;
import com.atguigu.qqzone.service.ReplyService;

import java.util.ArrayList;
import java.util.List;

/**
 * @ClassName: ReplyServiceImpl
 * @Description:
 * @Author: wty
 * @Date: 2022/12/9
 */

public class ReplyServiceImpl implements ReplyService {
    private ReplyDAO replyDAO;
    /**
     * 调用hostReplyServiceImpl的实现
     */
    private HostReplyServiceImpl hostReplyServiceImpl;
    private UserBasicServiceImpl userBasicServiceImpl;

    @Override
    public List<Reply> getReplyListByTopicId(Integer topicId) {
        String sqlStr = "SELECT a.* FROM qqzonedb2.`t_reply` a,qqzonedb2.`t_topic` b,qqzonedb2.`t_user_basic` c WHERE a.`topic` = b.`id`  AND a.`author` = c.`id` AND a.`topic` = ?";
        ArrayList<Reply> list = new ArrayList<>();

        List<Reply> replyList = replyDAO.queryMultiListAndMapReply(sqlStr, list, topicId);
        for (int i = 0; i < replyList.size(); i++) {
            Reply reply = replyList.get(i);
            // 1.将关联的作者设置进去
            UserBasic author = userBasicServiceImpl.getUserBasicById(reply.getAuthor().getId());
            reply.setAuthor(author);

            // 2.将关联的hostReplyByReplyId设置
            HostReply hostReplyByReplyId = hostReplyServiceImpl.getHostReplyByReplyId(reply.getId());
            reply.setHostReply(hostReplyByReplyId);
        }
        return replyList;
    }

    @Override
    public void addReply(Reply reply) {
        String sqlStr = "INSERT INTO qqzonedb2.`t_reply` VALUES(0,?,?,?,?)";
        replyDAO.dml(sqlStr, reply.getContent(), reply.getReplyDate(), reply.getAuthor().getId(), reply.getTopic().getId());
    }

    @Override
    public void delReply(Integer id) {
        String sqlStr = "";
        // 1.根据id获取到reply
        Reply reply = getReply(id);
        // 2.如果reply有关联的hostreply那么需要删除hostreply
        if (null != reply) {
            HostReply hostReply = hostReplyServiceImpl.getHostReplyByReplyId(reply.getId());
            if (null != hostReply) {
                hostReplyServiceImpl.delHostReply(hostReply.getId());
            }
            // 3.最后再删除reply
            sqlStr = "DELETE FROM qqzonedb2.`t_reply` WHERE id = ?";
            replyDAO.dml(sqlStr, id);
        }
    }

    @Override
    public Reply getReply(Integer id) {
        String sqlStr = "SELECT a.* FROM qqzonedb2.`t_reply` a WHERE a.id = ?";
        return replyDAO.querySingleReply(sqlStr, id);
    }

    @Override
    public void delReplyList(Topic topic) {
        List<Reply> replyList = getReplyListByTopicId(topic.getId());
        if (null != replyList) {
            for (Reply reply : replyList) {
                delReply(reply.getId());
            }
        }
    }
}

TopicServiceImpl日志实现类

package com.atguigu.qqzone.service.impl;

import com.atguigu.qqzone.dao.TopicDAO;
import com.atguigu.qqzone.pojo.Reply;
import com.atguigu.qqzone.pojo.Topic;
import com.atguigu.qqzone.pojo.UserBasic;
import com.atguigu.qqzone.service.TopicService;

import java.util.ArrayList;
import java.util.List;

/**
 * @ClassName: TopicServiceImpl
 * @Description:
 * @Author: wty
 * @Date: 2022/12/9
 */

public class TopicServiceImpl implements TopicService {
    private TopicDAO topicDAO;
    /**
     * 引入ReplyServiceImpl
     */
    private ReplyServiceImpl replyServiceImpl;
    private UserBasicServiceImpl userBasicServiceImpl;

    @Override
    public List<Topic> getTopicList(UserBasic userBasic) {
        String sqlStr = "SELECT a.* FROM qqzonedb2.`t_topic` a INNER JOIN qqzonedb2.`t_user_basic` b ON a.`author` = b.`id` AND a.`author` = ?";
        ArrayList<Topic> list = new ArrayList<>();
        return topicDAO.queryMultiListAndMap(sqlStr, list, userBasic.getId());
    }

    @Override
    public void addTopic(Topic topic) {
        String sqlStr = "INSERT INTO qqzonedb2.`t_topic` VALUES (0,?,?,?,?)";
        topicDAO.dml(sqlStr, topic.getTitle(), topic.getContent(), topic.getTopicDate(), topic.getAuthor().getId());
    }

    @Override
    public void delTopic(Topic topic) {
        String sqlStr = "DELETE FROM qqzonedb2.`t_topic` WHERE id = ?";
        topicDAO.dml(sqlStr, topic.getId());
    }

    @Override
    public void delTopic(Integer id) {
        Topic topic = getTopic(id);
        if (null != topic) {
            // 删除所有日志中的回复
            replyServiceImpl.delReplyList(topic);

            // 删除所有日志
            delTopic(topic);
        }
    }

    @Override
    public Topic getTopic(Integer id) {
        String sqlStr = "SELECT * FROM qqzonedb2.`t_topic` a WHERE a.`id` = ?";
        Topic topic = topicDAO.querySingleTopic(sqlStr, id);
        UserBasic author = topic.getAuthor();
        author = userBasicServiceImpl.getUserBasicById(author.getId());
        topic.setAuthor(author);
        return topic;
    }

    @Override
    public Topic getTopicById(Integer id) {
        Topic topic = getTopic(id);

        List<Reply> replyList = replyServiceImpl.getReplyListByTopicId(topic.getId());
        topic.setReplyList(replyList);

        return topic;
    }
}

UserBasicServiceImpl用户功能实现类

package com.atguigu.qqzone.service.impl;

import com.atguigu.qqzone.dao.UserBasicDAO;
import com.atguigu.qqzone.pojo.UserBasic;
import com.atguigu.qqzone.service.UserBasicService;

import java.util.ArrayList;
import java.util.List;

/**
 * @ClassName: UserBasicServiceImpl
 * @Description:
 * @Author: wty
 * @Date: 2022/12/9
 */

public class UserBasicServiceImpl implements UserBasicService {
    private UserBasicDAO userBasicDAO;

    @Override
    public UserBasic getUserBasic(String loginId, String pwd) {
        String sqlStr = "SELECT * FROM t_user_basic a WHERE a.loginId = ? AND a.pwd = ?";
        return userBasicDAO.querySingle(sqlStr, UserBasic.class, loginId, pwd);
    }

    @Override
    public List<UserBasic> getUserBasicList(UserBasic userBasic) {
        String sqlStr = "SELECT a.fid AS id FROM t_friend a WHERE a.uid = ?";
        return userBasicDAO.queryMulti(sqlStr, UserBasic.class, userBasic.getId());
    }

    @Override
    public UserBasic getUserBasicById(Integer id) {
        String sqlStr = "SELECT * FROM t_user_basic a WHERE a.id = ?";
        return userBasicDAO.querySingle(sqlStr, UserBasic.class, id);
    }

    /**
     * @param
     * @return com.atguigu.qqzone.pojo.UserBasic
     * @description 注册
     * @param: loginId
     * @param: pwd
     * @date 2022/12/9 18:22
     * @author wty
     **/
    public UserBasic login(String loginId, String pwd) {
        UserBasic userBasic = getUserBasic(loginId, pwd);
        return userBasic;
    }

    /**
     * @param
     * @return java.util.List<com.atguigu.qqzone.pojo.UserBasic>
     * @description 获取好友列表
     * @param: userBasic
     * @date 2022/12/9 18:23
     * @author wty
     **/
    public List<UserBasic> getFriendList(UserBasic userBasic) {
        List<UserBasic> userBasicList = getUserBasicList(userBasic);
        List<UserBasic> friendList = new ArrayList<>(userBasicList.size());
        for (int i = 0; i < userBasicList.size(); i++) {
            UserBasic friend = userBasicList.get(i);
            friend = getUserBasicById(friend.getId());
            friendList.add(friend);
        }
        return friendList;
    }


}

DruidUtils德鲁伊连接池

package com.atguigu.utils;

import com.alibaba.druid.pool.DruidDataSourceFactory;
import org.apache.commons.dbutils.handlers.ColumnListHandler;

import javax.sql.DataSource;
import java.io.FileInputStream;
import java.io.InputStream;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.Properties;

/**
 * @ClassName: DruidUtils
 * @Description:
 * @Author: wty
 * @Date: 2022/12/5
 */

public class DruidUtils {
    private static DataSource dataSource;
    private static ThreadLocal<Connection> threadLocal = new ThreadLocal<>();


    static {
        Properties properties = new Properties();
        try {
            InputStream inputStream = DruidUtils.class.getClassLoader().getResourceAsStream("druid.properties");
            properties.load(inputStream);
            dataSource = DruidDataSourceFactory.createDataSource(properties);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * @Description: 获取链接
     * @Author: wty
     * @Date: 2022/12/4
     */
    public static Connection getConnection() {
        Connection connection = null;
        try {
            connection = threadLocal.get();
            if (null == connection) {
                connection = dataSource.getConnection();
                threadLocal.set(connection);
            }

        } catch (SQLException e) {
            throw new RuntimeException(e);
        }
        return threadLocal.get();
    }

    public static void close(ResultSet resultSet, Statement statement, Connection connection) {
        //try {
        //
        //    if (null != resultSet) {
        //        resultSet.close();
        //    }
        //    if (null != statement) {
        //        statement.close();
        //    }
        //    if (null != connection) {
        //        connection.close();
        //    }
        //} catch (SQLException e) {
        //    throw new RuntimeException(e);
        //}
    }

    public static void closeConnection() throws SQLException {
        Connection connection = threadLocal.get();
        if (null == connection) {
            return;
        }
        if (!connection.isClosed()) {
            connection.close();
            threadLocal.set(null);
            // 或者remove也可以
            //threadLocal.remove();
        }
    }
}
心向阳光的天域
关注
  • 2
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 5
    评论
专栏目录
QQZone项目（额外功能已实现）
05-28
具体关于项目部署运行，可以看我另一篇文章，《实现浏览器 - Servlet - 数据库交互操作》，具体是如何实现的可以看这篇博客《JavaWeb新版教程08-QQZone项目的实现》。 本项目使用的是MySQL 8.0版本，JDBC连接 8.0.29版本，Tomcat 9.0.62版本，JDK 17版本。
从尚硅谷QQzone项目谈IOC&DI
weixin_64972949的博客
03-17 254
IOC顾名思义是将控制权反转，那么是将谁的控制权反转呢？对！是将对象的控制权反转，最开始对象的控制权是在程序员的手中，
探索QQZone：一款开源的QQ空间爬虫框架
最新发布
gitblog_00018的博客
04-23 466
探索QQZone：一款开源的QQ空间爬虫框架 项目地址:https://gitcode.com/jerry-sc/QQZone 在数字化时代，社交媒体数据成为了研究社交行为、市场趋势的重要资源。QQZone 是一个基于Python的开源项目，专为爬取和解析QQ空间信息而设计。它提供了一个强大且易于使用的工具，帮助开发者和研究人员获取QQ空间的公开数据，进行深度分析和应用。 项目简介 QQZone是...
【尚硅谷】新web项目-QQZone代码及详细解析
weixin_52355727的博客
09-01 300
QQZone源码及解析。
Java web 2022跟学尚硅谷书城项目完整开源分享
心向阳光的天域的博客
12-16 1528
Java web 2022跟学尚硅谷书城项目完整开源分享
（尚硅谷）JavaWeb新版教程09-QQZone项目总结
qq_42148002的博客
05-30 1036
5、目前我们进行 javaweb 项目开发的“套路”是这样的： 导入 myssm.jar 包 新建配置文件 applicationContext.xml 或者可以不叫这个名字，在 web.xml 中指定文件名 在 web.xml 文件中配置： 配置前缀和后缀，这样 thymeleaf 引擎就可以根据我们返回的字符串进行拼接，再跳转 <context-param> <param-name>view-prefix</param-name> <param-va
QQzone的sql文件
04-08
补充QQzone项目源代码中的...注：该项目是尚硅谷22版JavaWEB课程中的第二个项目，自己亲手跟着敲了一遍，其中有自己写的主人回复功能，而且优化了进入朋友空间后，左侧会实时显示成给朋友自己的朋友列表，可供大家参考
项目QQzone
03-24
【项目QQzone】是一个以源码和工具为主题的项目，它可能是开发者为了研究、学习或分享QQ空间（QQzone）的相关功能和技术实现而创建的。由于描述中提到的是一个博客链接，我们可以推测这个项目可能包含了作者在开发...
QQzone项目源代码
04-06
1. **Web开发框架**：QQzone项目可能使用了某种Web开发框架，如Spring Boot、Django或Vue.js等。这些框架简化了开发过程，提供了路由、模板引擎、数据管理等功能。了解所使用的框架将有助于理解代码结构和工作流程。...
QQZone项目（学生时代作品）
01-14
QQZone是我写的小项目，主要是仿照腾讯的QQ空间做的，包含功能：用户管理，好友管理，说说管理，日志管理，相册管理（包含照片的单张上传和批量上传），动态显示（也就是腾讯QQ空间刚进去的好友动态），以及你可以对...
（尚硅谷）JavaWeb新版教程08-QQZone项目的实现
qq_42148002的博客
05-26 2227
目录1、熟悉 QQZone 业务需求2、数据库设计1. 抽取实体2. 分析其中的属性3. 分析实体之间的关系4. 数据库的范式 1、熟悉 QQZone 业务需求 用户登录 登录成功，显示主界面。左侧显示好友列表；上端显示欢迎词。如果不是自己的空间，显示超链接：返回自己的空间； 下端显示日志列表 查看日志详情： 日志本身的信息（作者头像、昵称、日志标题、日志内容、日志的日期） 回复列表（回复者的头像、昵称、回复内容、回复日期） 主人回复信息 删除日志 删除特定回复 删除特定主
java 仿qq空间_Java实现模拟QQ空间图片上传
weixin_42510201的博客
02-16 224
Java实现模拟QQ空间图片上传首先看效果:首先编写我们的上传jsp代码，如下:pageEncoding="UTF-8"%>htmlPUBLIC"-//W3C//DTDHTML4.01Transitional//EN""http://www.w3.org/TR/html4/loose.dtd">Java实现开发QQ空间上传body{background:url("p_w_...
JavaWeb项目1-QQZone
weixin_52972575的博客
03-31 2519
一.项目需求 1.登录功能。 2.进入自己的空间，左侧显示好友列表，右侧显示日志列表。 3.点击日志，进入日志详情。 4.日志详情下面是好友回复，空间主人可以对好友回复进行主人回复，一个好友回复主人只能回复一次。 5.添加回复功能，在每个人的空间或自己的空间都可以添加回复 6.删除日志，日志关联的所有回复和回复的主人回复都要删除 二.数据库设计 1.抽取实体 用户信息：用户基本信息+用户详细信息 日志 回复 主人回复 2.分析实体属性 用户基本信息：账号，密码.
java程序模拟QQ空间登录 - 并模拟刷说说的赞
08-27 6844
Java程序模拟QQ空间登录 - 并模拟刷说说的赞 注意：腾讯修改了加密算法，已失效（2015-01-31） 背景：在2013-10-25的一天，有个friend在QQ问我："post登陆QQ空间抓取不到post的数据"。于是故事就开始了，他做过模拟百度登录，我想应该没问题啊，都是一样的程序嘛。于是简单的看了下，好像QQ登录的密码P是加密过的。并且最近也需要这样一个程序，于
JavaWeb项目之QQ Zone：（二）对象封装
sd_960614的博客
07-09 357
数据库查询能够自动赋值pojo中自定义类型的属性
基于Javaweb的小项目(类似于qqzone) 4 ——通用代码模块 - 过滤器、异常处理、servlet通用代码块
kuaixiao0217的博客
05-02 385
对通用代码块的剩余部分进行介绍——主要包括过滤器、异常处理、servlet通用代码块
基于Javaweb的小项目(类似于qqzone)1——设计数据库
kuaixiao0217的博客
05-02 822
使用javaweb技术实现类似于qqzone的系统，这是第一步设计数据库
Q-Zone空间实用代码三例(转)
cuemes08808的博客
06-01 163
Q-Zone空间实用代码三例(转) 　　没特别说明，所有代码的使用方法都是在版块中建立新栏目窗口中的“评论”部分中。　　所有代码须配合“解决切换页面提示保存方案”代码使用，否则会出现要求保存方案提示。 　　?查看物品ID的方...
JavaWeb-QQ空间项目解析
L13158562070的博客
04-01 1566
1.熟悉QQZone业务需求 1) 用户登录 2) 登录成功，显示主界面。左侧显示好友列表；上端显示欢迎词。如果不是自己的空间，显示超链接：返回自己的空间；下端显示日志列表 3) 查看日志详情： - 日志本身的信息（作者头像、昵称、日志标题、日志内容、日志的日期） - 回复列表（回复者的头像、昵称、回复内容、回复日期） - 主人回复信息 4) 删除日志 5) 删除特定回复 6) 删除特定主人回复 7) 添加日志、添加回复、添加主人回...
uniapp分享到qq空间
09-08
1. 在uniapp项目根目录使用命令行安装社交分享插件： ``` npm install uni-share ``` 2. 在你需要触发分享的页面的`<script>`标签中，引入插件并初始化配置： ```javascript import uniShare from 'uni-share' ...
评论 5
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

心向阳光的天域

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值