企业管理系统定制开发制作表白墙，给TA一个惊喜吧

目录

展示

1. 创建Maven 项目

使用 IDEA 创建一个 Maven 项目

1) 菜单 -> 文件 -> 新建项目 -> Maven

 2) 企业管理系统定制开发项目创建完毕

企业管理系统定制开发创建好之后，企业管理系统定制开发会生成一些默认的目录

3）添加文件

企业管理系统定制开发我们需要手动添加6个文件，

一个是在java 企业管理系统定制开发路径下建一个ConfessionServlet 文件，企业管理系统定制开发用来存放服务器代码。

在Java路径下创建 文件，用来与MySQL之间的交互

然后再 main 路径下创建一个webapp文件夹

再在webapp文件夹下创建一个WEB_INF文件夹 、一个 .html文件（用来存放客户端代码）、 一个 .jpg 文件（存放背景图，可以根据自己的喜好来选择图片）

在WEB_INF文件夹下创建 web.xml 文件

 

 2.源代码

2.1 web.xml

  1. <!DOCTYPE web-app PUBLIC
  2.         "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
  3.         "http://java.sun.com/dtd/web-app_2_3.dtd" >
  4. <web-app>
  5.     <display-name>Archetype Created Web Application</display-name>
  6. </web-app>

2.2 pom.xml

在pom.xml文件下增加以下代码片段，如果代码出现报红出错状态的话，点击右上角Maven 的刷新图标，等待即可。

  1. <dependencies>
  2.         <!-- https://mvnrepository.com/artifact/javax.servlet/javax.servlet-api -->
  3.         <dependency>
  4.             <groupId>javax.servlet</groupId>
  5.             <artifactId>javax.servlet-api</artifactId>
  6.             <version>3.1.0</version>
  7.             <scope>provided</scope>
  8.         </dependency>
  9.  
  10.         <!-- https://mvnrepository.com/artifact/com.fasterxml.jackson.core/jackson-databind -->
  11.         <dependency>
  12.             <groupId>com.fasterxml.jackson.core</groupId>
  13.             <artifactId>jackson-databind</artifactId>
  14.             <version>2.12.6.1</version>
  15.         </dependency>
  16.  
  17.         <!-- 引入  mysql  驱动包       -->
  18.         <!-- https://mvnrepository.com/artifact/mysql/mysql-connector-java -->
  19.         <dependency>
  20.             <groupId>mysql</groupId>
  21.             <artifactId>mysql-connector-java</artifactId>
  22.             <version>5.1.47</version>
  23.         </dependency>
  24.  
  25.     </dependencies>

2.3 ConfessionServelet 类

 用来存在服务器代码。

其中 @WebServlet("/confession")  是客户端向服务器约定好的请求方式

  1. import com.fasterxml.jackson.databind.ObjectMapper;
  2.  
  3. import javax.servlet.ServletException;
  4. import javax.servlet.annotation.WebServlet;
  5. import javax.servlet.http.HttpServlet;
  6. import javax.servlet.http.HttpServletRequest;
  7. import javax.servlet.http.HttpServletResponse;
  8. import java.io.IOException;
  9. import java.sql.Connection;
  10. import java.sql.PreparedStatement;
  11. import java.sql.ResultSet;
  12. import java.sql.SQLException;
  13. import java.util.ArrayList;
  14. import java.util.List;
  15.  
  16. class Confession {
  17.     public String from;
  18.     public String to;
  19.     public String confession;
  20. }
  21.  
  22. @WebServlet("/confession")
  23. public class ConfessionServlet extends HttpServlet {
  24.     private ObjectMapper objectMapper = new ObjectMapper();
  25.     @Override
  26.     protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
  27.         //处理提交消息请求
  28.         Confession confession = objectMapper.readValue(req.getInputStream(),Confession.class);
  29.         //保存到内存中
  30.         // 通过 ContentType 来告知页面, 返回的数据是 json 格式.
  31.         // 有了这样的声明, 此时 jquery ajax 就会自动的帮我们把字符串转成 js 对象.
  32.         // 如果没有, jquery ajax 就只是当成字符串来处理的
  33.         save(confession);
  34.         resp.setContentType("application/json; charset=utf8");
  35.         resp.getWriter().write("{\"ok\":true}");
  36.     }
  37.  
  38.     @Override
  39.     protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
  40.         //获取到消息列表，只要把消息列表中的内容整个都返回给客户端即可
  41.         //此处需要使用objectMapper 把 Java 对象，转换成json 格式的字符串
  42.         List<Confession> confessions = load();
  43.         String jsonString = objectMapper.writeValueAsString(confessions);
  44.         System.out.println("jsonString: " + jsonString);
  45.         resp.setContentType("application/json; charset=utf8");
  46.         resp.getWriter().write(jsonString);
  47.     }
  48.  
  49.     private void save(Confession confession)  {
  50.         //把第一条消息保存到数据库中
  51.         Connection connection = null;
  52.         PreparedStatement statement = null;
  53.  
  54.         //1.和数据库建立连接
  55.         try {
  56.             connection = DBUtil.getConnection();
  57.             //2.构造 SQL
  58.             String sql = "insert into confession values(?, ?, ?)";
  59.             statement = connection.prepareStatement(sql);
  60.             statement.setString(1,confession.from);
  61.             statement.setString(2,confession.to);
  62.             statement.setString(3,confession.confession);
  63.             //3.执行SQL
  64.             statement.executeUpdate();
  65.         } catch (SQLException e) {
  66.             e.printStackTrace();
  67.         } finally {
  68.             //关闭连接，释放资源
  69.             DBUtil.close(connection,statement,null);
  70.         }
  71.     }
  72.  
  73.     private List<Confession> load() {
  74.         //从数据库中获取到所有的消息
  75.         List<Confession> confessions = new ArrayList<>();
  76.         Connection connection = null;
  77.         PreparedStatement statement = null;
  78.         ResultSet resultSet = null;
  79.         try {
  80.             connection = DBUtil.getConnection();
  81.             String sql = "select * from confession";
  82.             statement = connection.prepareStatement(sql);
  83.             resultSet = statement.executeQuery();
  84.             while (resultSet.next()) {
  85.                 Confession confession = new Confession();
  86.                 confession.from = resultSet.getString("from");
  87.                 confession.from = resultSet.getString("to");
  88.                 confession.from = resultSet.getString("confession");
  89.                 confessions.add(confession);
  90.             }
  91.         } catch (SQLException throwables) {
  92.             throwables.printStackTrace();
  93.         } finally {
  94.             DBUtil.close(connection, statement, resultSet);
  95.         }
  96.         return confessions;
  97.     }
  98.  
  99. }

2.4 DBUtil 类

这个类是用来与Mysql 建立连接，将表白的话存放到 Mysql 中，使用到的是JDBC编程。

使用JDBC基本流程:
1.创建数据源
2.和数据库建立连接
3.构造sq|语句
4.执行sq|语句
5.如果是查询语句,需要遍历结果集.如果是插入/删除/修改,则不需要
6.关闭连接,释放资源 

  1. import com.mysql.jdbc.jdbc2.optional.MysqlDataSource;
  2. import javax.sql.DataSource;
  3. import java.sql.Connection;
  4. import java.sql.PreparedStatement;
  5. import java.sql.ResultSet;
  6. import java.sql.SQLException;
  7.  
  8. public class DBUtil {
  9.     //与数据库建立连接
  10.     private static final String URL = "jdbc:mysql://127.0.0.1:3306/java?characterEncoding=utf8&useSSL=false";
  11.     private static final String USERNAME = "root";
  12.     private static final String PASSWORD = "123456";
  13.  
  14.     private volatile static DataSource dataSource = null;
  15.  
  16.     private static DataSource getDataSource() {
  17.         if (dataSource == null) {
  18.             synchronized (DBUtil.class) {
  19.                 if (dataSource == null) {
  20.                     dataSource = new MysqlDataSource();
  21.                     ((MysqlDataSource)dataSource).setUrl(URL);
  22.                     ((MysqlDataSource)dataSource).setUser(USERNAME);
  23.                     ((MysqlDataSource)dataSource).setPassword(PASSWORD);
  24.                 }
  25.             }
  26.         }
  27.         return dataSource;
  28.     }
  29.  
  30.     public static Connection getConnection() throws SQLException {
  31.         return getDataSource().getConnection();
  32.     }
  33.  
  34.     public static void close(Connection connection, PreparedStatement statement, ResultSet resultSet) {
  35.         if (resultSet != null) {
  36.             try {
  37.                 resultSet.close();
  38.             } catch (SQLException e) {
  39.                 e.printStackTrace();
  40.             }
  41.         }
  42.         if (statement != null) {
  43.             try {
  44.                 statement.close();
  45.             } catch (SQLException e) {
  46.                 e.printStackTrace();
  47.             }
  48.         }
  49.         if (connection != null) {
  50.             try {
  51.                 connection.close();
  52.             } catch (SQLException e) {
  53.                 e.printStackTrace();
  54.             }
  55.         }
  56.     }
  57. }

在上述代码中

2.5 confessWall.html

这个代码是客户端代码

  1. <!DOCTYPE html>
  2. <html lang="en">
  3.  
  4. <head>
  5.     <meta charset="UTF-8">
  6.     <meta http-equiv="X-UA-Compatible" content="IE=edge">
  7.     <meta name="viewport" content="width=device-width, initial-scale=1.0">
  8.     <title>表白墙</title>
  9. </head>
  10.  
  11. <body>
  12.     <style>
  13.         /* 整个页面放背景图的，html, 不可少*/
  14.         
  15.         html,
  16.         body {
  17.             height: 100%;
  18.         }
  19.         
  20.         body {
  21.             background-image: url(wall.jpg);
  22.             background-repeat: no-repeat;
  23.             background-position: center center;
  24.             background-size: cover;
  25.         }
  26.         
  27.         * {
  28.             margin: 0;
  29.             padding: 0;
  30.             box-sizing: border-box;
  31.         }
  32.         
  33.         .container {
  34.             width: 100%;
  35.         }
  36.         
  37.         h3 {
  38.             text-align: center;
  39.             padding: 30px 0;
  40.             font-size: 24px;
  41.             color: black;
  42.         }
  43.         
  44.         p {
  45.             text-align: center;
  46.             color: rgb(241, 236, 35);
  47.             padding: 10px 0;
  48.         }
  49.         
  50.         .row {
  51.             width: 400px;
  52.             height: 50px;
  53.             margin: 0 auto;
  54.             display: flex;
  55.             justify-content: center;
  56.             align-items: center;
  57.         }
  58.         
  59.         .row span {
  60.             width: 60px;
  61.             font-size: 20px;
  62.             /* color: azure; */
  63.         }
  64.         
  65.         .row input {
  66.             width: 300px;
  67.             height: 40px;
  68.             line-height: 40px;
  69.             font-size: 20px;
  70.             text-indent: 0.5em;
  71.             /* 去掉输入框的轮廓线 */
  72.             outline: none;
  73.         }
  74.         
  75.         .row #submit {
  76.             width: 200px;
  77.             height: 40px;
  78.             font-size: 20px;
  79.             line-height: 40px;
  80.             margin: 0 auto;
  81.             color: white;
  82.             background-color: rgb(241, 238, 35);
  83.             /* 去掉框的轮廓线 */
  84.             border: none;
  85.             border-radius: 10px;
  86.         }
  87.         
  88.         .row #submit:active {
  89.             background-color: gray;
  90.         }
  91.     </style>
  92.  
  93.  
  94.     <div class="container">
  95.         <h3>表白墙</h3>
  96.         <p>欢迎来到表白墙，勇敢说出你心灵深处的爱吧！</p>
  97.         <div class="row">
  98.             <span>谁：</span>
  99.             <input type="text">
  100.         </div>
  101.         <div class="row">
  102.             <span>对谁：</span>
  103.             <input type="text">
  104.         </div>
  105.         <div class="row">
  106.             <span>说：</span>
  107.             <input type="text">
  108.         </div>
  109.         <div class="row">
  110.             <button id="submit">提交</button>
  111.         </div>
  112.     </div>
  113.  
  114.     <script src="https://cdn.bootcdn.net/ajax/libs/jquery/3.6.0/jquery.min.js"></script>
  115.     <script>
  116.         //加入Ajax的代码，此处加入的逻辑有两部分
  117.         //1) 点击按钮提交的时候，Ajax 要构造数据发送给服务器，
  118.         // 2） 页面加载的时候，从服务器获取消息列表，并在界面上显示
  119.         function getMessages() {
  120.             $.ajax({
  121.                 type: 'get',
  122.                 url: 'confession',
  123.                 success: function(body) {
  124.                     //当前body 已经是一个js 对象数组了，Ajax 会根据响应的 content type 来进行解析
  125.                     //如果服务器返回的content-type 已经是application/json 了，Ajax就会把body自动转换成js对象
  126.                     //如果客户端没有自动链接，也可以通过JSON.parse() 这个函数自动转换
  127.  
  128.                     //依次来取数组转换的每个元素
  129.                     let container = document.querySelector('.container');
  130.                     for (let confession of body) {
  131.                         let div = document.createElement('div');
  132.                         div.innerHTML = from + ' 对 ' + to + ' 说: ' + msg;
  133.                         div.className = 'row';
  134.                         container.appendChild(div);
  135.                     }
  136.                 }
  137.             });
  138.         }
  139.         //加上函数调用
  140.         getMessages();
  141.  
  142.         // 当用户点击 submit, 就会获取到 input 中的内容, 从而把内容构造成一个 div, 插入到页面末尾
  143.         let submitBtn = document.querySelector('#submit');
  144.         submitBtn.onclick = function() {
  145.             // 1.获取到3个input中的内容
  146.             let inputs = document.querySelectorAll('input');
  147.             let from = inputs[0].value;
  148.             let to = inputs[1].value;
  149.             let msg = inputs[2].value;
  150.             if (from == '' || to == '' || msg == '') {
  151.                 //用户没填写完，暂时部提交数据
  152.                 ruturn;
  153.             }
  154.             // 2. 生成一个新的 div, 内容就是 input 里的内容. 把这个新的 div 加到页面中. 
  155.             let div = document.createElement('div');
  156.             div.innerHTML = from + ' 对 ' + to + ' 说: ' + msg;
  157.             div.className = 'row';
  158.             let container = document.querySelector('.container');
  159.             container.appendChild(div);
  160.             // 3. 清空之前输入框的内容. 
  161.             for (let i = 0; i < inputs.length; i++) {
  162.                 inputs[i].value = '';
  163.             }
  164.  
  165.             //4.把当前获取到的输入框内容，构造成一个HTTP post 请求，通过Ajax 发送给服务器
  166.             let body = {
  167.                 from: from,
  168.                 to: to,
  169.                 confession: msg
  170.             };
  171.             $.ajax({
  172.                 type: "post",
  173.                 url: "confession",
  174.                 contentType: "application/json;charset=utf8",
  175.                 data: JSON.stringify(body),
  176.                 success: function(body) {
  177.                     alert("表白成功");
  178.  
  179.                 },
  180.                 error: function() {
  181.                     alert("表白失败");
  182.                 }
  183.             })
  184.         }
  185.     </script>
  186. </body>
  187.  
  188. </html>

在上述代码中

  

3. Tomcat 部署 

4.创建库

在MySQL创建一个库，然后再库里创建一个表，来保存表白的数据。

其中 from 和 to  使用的是反引号。在键盘的左上角。

  1. create database if not exists confession_wall;
  2.  
  3. use confession_wall;
  4.  
  5. drop table if exists confession;
  6. create table confession (
  7.     `from` varchar(1024),
  8.     `to` varchar(1024),
  9.     message varchar(4096)
  10. );

5. 部署到上

5.1 数据库的部署

将库和表创建到云服务器上，即 xshell 软件

 5.1 打包

1）先在pom.xml 中增加 war 包的名字

  1. <packaging>war</packaging>
  2.     <build>
  3.         <finalName>confession</finalName>
  4.     </build>

2）DBUtil 类中的密码去掉，如下

  1.  private static final String USERNAME = "root";
  2.  private static final String PASSWORD = "";

 3) 打包

在右上角Maven处找到如下双击打包

 然后再左边目录栏就可以生成 confession.war 包，然后操作如下

 就可以打开  confession.war 所在的文件夹位置

 4）部署到云服务器

先在 xshell 中输入以下命令，即打开Tomcat

  1. //打开Tomcat所在的目录
  2.  
  3. cd java/
  4.  
  5. //打开安装的Tomcat
  6.  
  7. cd apache-tomcat-8.5.78/
  8.  
  9.  
  10. //打开webapps
  11.  
  12. cd webapps/

然后 将打包的 confession.war 包拖到 xshell 

这样子就部署完成

6.效果

因为我们已经约定好交互方式并且部署好了，所以就可以生成连接：（如果想让别人也放访问到，就需要与云服务器连接，云服务连接在开头。不然只能直接创建项目来部署，自己访问，自己访问连接如下）

 表白的数据存储在数据库

7.特别说明

在文中 1-4段 和第6 段是可以单独在idea上面部署的，不过结果只能自己看。第5段是在云服务器上面部署的，部署了别就可以通过连接看到。

网站建设定制开发 软件系统开发定制 定制软件开发 软件开发定制 定制app开发 app开发定制 app开发定制公司 电商商城定制开发 定制小程序开发 定制开发小程序 客户管理系统开发定制 定制网站 定制开发 crm开发定制 开发公司 小程序开发定制 定制软件 收款定制开发 企业网站定制开发 定制化开发 android系统定制开发 定制小程序开发费用 定制设计 专注app软件定制开发 软件开发定制定制 知名网站建设定制 软件定制开发供应商 应用系统定制开发 软件系统定制开发 企业管理系统定制开发 系统定制开发