JavaWeb自学笔记O基础菜鸟名词解释第一课：花生壳+tomcat建一个公网web服务器（2021.12.23）第二课：用EclipseEE + Servlet + tomcat建web服务器（2021.12.24）第三课：servlet获取参数与返回响应（2021.12.27）第四课：动态web（2021.12.29）第五课：安装MySQL数据库（2022.01.04）第六课：CRUD数据库查询（2022.01.07）第七课：CRUD数据库增删改（2022.01.10）第八课：http协议实

81 阅读 0 评论 54 点赞

我是靠谱客的博主苗条鸵鸟，最近开发中收集的这篇文章主要介绍JavaWeb自学笔记O基础菜鸟名词解释第一课：花生壳+tomcat建一个公网web服务器（2021.12.23）第二课：用EclipseEE + Servlet + tomcat建web服务器（2021.12.24）第三课：servlet获取参数与返回响应（2021.12.27）第四课：动态web（2021.12.29）第五课：安装MySQL数据库（2022.01.04）第六课：CRUD数据库查询（2022.01.07）第七课：CRUD数据库增删改（2022.01.10）第八课：http协议实，觉得挺不错的，现在分享给大家，希望可以做个参考。

概述

JavaWeb学习笔记目录

O基础菜鸟
名词解释
第一课：花生壳+tomcat建一个公网web服务器（2021.12.23）
- 1.第一步：安装JDK1.8
- 2.第二步：安装部署tomcat
- 3.第三步：花生壳映射http
- 4.第四步：新建.html文件
- 4.第五步：用浏览器访问自建web服务器
第二课：用EclipseEE + Servlet + tomcat建web服务器（2021.12.24）
- 1.第一步：安装配置Eclipse EE
- 2.第二步：建立Eclipse EE与tomcat联系
- 3.第三步：用浏览器访问web服务器
第三课：servlet获取参数与返回响应（2021.12.27）
- 1.第一步：在web目录下新建login.html文件
- 2.第二步：右键工程创建名为LoginServlet的java类
- 3.第三步：映射LoginServlet到路径login
- 4.第四步：重启tomcat服务后浏览器访问
第四课：动态web（2021.12.29）
- 1.第一步：在Eclipse EE中新建一个Dynamic Web工程
- 2.第二步：在j2ee工程中创建名为HelloServlet的类
- 3.第三步：解决找不到servlet-api.jar报错问题
- 4.第四步：解决java版本不匹配报错问题
- 5.第五步：新建web.xml
- 6.第六步：通过Eclipse启动Tomcat-Run On Server
- 7.第七步：在浏览器中输入地址验证效果
第五课：安装MySQL数据库（2022.01.04）
- 1.第一步：下载MySQL
- 2.第二步：安装MySQL
- 3.第三步：配置MySQL
- 4.第四步：验证MySQL是否安装配置成功
- 5.第五步：MySQL简单操作：
第六课：CRUD数据库查询（2022.01.07）
- 1.第一步：为项目导入mysql-jdbc.jar包
- 2.第二步：创建Hero类，包名为bean
- 3.第三步：创建HeroDAO类，包名为dao
- 4.第四步：创建HeroListServlet类，包名为servlet
- 5.第五步：配置web.xml
- 6.第六步：在MySQL中创建数据表及数据
- 7.第七步：浏览器验证效果
第七课：CRUD数据库增删改（2022.01.10）
- 1.数据库增加
- 2.数据库删除
- 3.数据库修改
第八课：http协议实验（2022.1.13）
- 1.名词解释
- 2.简单的传输流程
- 3.EclipseEE TCP/IP Monitor监控服务端http协议数据
第九课：接收电信AEP平台http订阅消息（2022.1.20）
- 1.在电信AEP平台订阅管理中增加HTTP订阅，URL为接收端地址
- 2.在MySQL数据库中新建一个名为bb55的数据库
- 3.在java程序中修改数据库连接名，由test改为bb55
- 4.在java程序中依次增加bb55参数
- 5.在HeroAddServlet.java中增加接收http消息的代码
- 6.将解完base64码的json数据存入数据库
第十课：JAVA基础知识（2022.1.24）
- 1.new的意思
- 2.类和对象
- 3.集合类
- 4.读写.txt文本
- 5.四字节16进制浮点数转10进制浮点数
- 6.四字节16进制时间戳转10进制日期时间格式
第十一课：人人开源问题（2022.2.21）
- 1.菜单栏中文乱码
- 2.后端部署（花生壳内网透穿）
- 3.前端部署（花生壳内网透穿+Tomcat）
- 4.内网透传出现：Invalid Host header
第十二课：生产部署，打包jar
- 1.idea打包
第十三课：Linux(centOS8.5)搭建Web开发环境
- 1.安装JDK1.8
- 2.安装MySQL数据库
- - 2.1 使用命令行导入sql文件：
  - 2.2 修改用户密码：
  - 2.3 关闭MySql的反向DNS:
- 3.安装RabbitMQ3.8.16
- 4.安装redis
- - 4.1 win10后台启动redis
- 5.启动.jar
- 6.Centos设置80端口映射8080/8081(Nginx反向代理)
7.安装配置Tomcat
第十三课：jar包启动产生的错误及问题汇总
- 1.错误：连不上MySQL
- 2.错误：数据库已存在的定时任务导致启动失败
- 3.错误：“SQL监控”页面显示错误
- 4.问题：DTU平台页面访问慢
- 5.问题：jar包后台运行问题
- 6.问题：redis怎么使用
- 7.问题：centOS8.5开机即运行Web所有环境
- 8.问题： quartz定时任务启动失败
- 9.问题：以restart.sh文件启动项目
- 10.问题：DTU平台与管控平台数据对接
第十四课：App后台
- 1.API数据接口
- 2.app发布
第十五课：企业版源码分析
第十六课：SpringBoot对接电信AEP平台
- 1.AEP平台
- - 1).创建产品
  - 2).添加设备
  - 3).创建http订阅
  - 4).创建应用
- 2.SpringBoot开发
- - 1).安装AEP平台应用管理中下载的jar包
  - 2).接收AEP平台http协议的订阅消息
  - 3).向AEP平台发送http协议的命令

O基础菜鸟

不错的java自学网址：
https://how2j.cn/?p=47726

名词解释

1.jsp:？
2.html/css:制作网页的语言/
3.JavaScrip:？
4.MySQL:数据库
5.JDBC:java操作数据库的中间件
6.Servlet:
7.JavaBean:？
8.AJAX:？
9.Struts2:？
10.http:客户端和服务器之间的传输协议

第一课：花生壳+tomcat建一个公网web服务器（2021.12.23）

1.第一步：安装JDK1.8

安装配置如下：
下载地址：https://how2j.cn/k/helloworld/helloworld-jdk/141.html
注意win10修改变量 Path，新建 %JAVA_HOME%bin时一定不能加‘;’号
效果如下图：效果如上图

2.第二步：安装部署tomcat

过程参考如下：
下载及部署：https://how2j.cn/k/tomcat/tomcat-tutorial/541.html
注意server.xml配置
在这里插入图片描述

效果如下图：
在这里插入图片描述

3.第三步：花生壳映射http

设置如下图：
在这里插入图片描述

效果如下图：
在这里插入图片描述
注意：需要先启动tomcat服务，再启动花生壳映射，如果不先启动tomcat会导致花生壳找不到本机端口报错，不建议本机使用80端口

4.第四步：新建.html文件

1）. 在安装tomcat的webapps文件夹下新建一个ROOT文件夹
请添加图片描述

2）. 在ROOT文件夹下新建一个TXT文本，名为‘hello’，然后把扩展名由.txt改为.html
3) . 用记事本打开hello.html,添加如下代码，保存退出：
代码如下：

<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
</head> 

<html>
  <body>
    	<p>Hello HTML 啊哈哈</p>
	<!--align属性用于对齐-->
	<h1 align="center"> 欢迎来到我的Web服务器 </h1>
	<h2>小一点的标题</h2>
	<h3>再小一点的标题</h3>
	<h4>更小一点的标题</h4>
	<h>小一点的标题</h2>
  </body>
</html>

4.第五步：用浏览器访问自建web服务器

在浏览器中输入：花生壳域名/hello.html
在这里插入图片描述

第二课：用EclipseEE + Servlet + tomcat建web服务器（2021.12.24）

1.第一步：安装配置Eclipse EE

下载地址：https://www.eclipse.org/downloads/packages/
“变量名”：JAVA_HOME
“变量值”：C:Program FilesJavajdk1.7.0_07//你安装的jdk的磁盘路径

“变量名”：Path
“变量值”：%Java_Home%bin;%Java_Home%jrebin;

“变量名”：ClassPath
“变量值”：.;%Java_Home%bin;%Java_Home%libdt.jar;%Java_Home%libtools.jar
注意：环境变量和java se相同，参数不要和jdk重复
在这里插入图片描述

2.第二步：建立Eclipse EE与tomcat联系

参考教程：https://how2j.cn/k/servlet/servlet-eclipse/558.html#nowhere

3.第三步：用浏览器访问web服务器

效果如下：每刷新一次，时间戳更新一次

第三课：servlet获取参数与返回响应（2021.12.27）

1.第一步：在web目录下新建login.html文件

在这里插入图片描述
添加如下代码：（访问时显示的页面）

<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>登录页面</title>
</head>
<body>
  
<form action="login" method="post">
账号: <input type="text" name="name"> <br>
密码: <input type="password" name="password"> <br>
<input type="submit" value="登录">
</form>
  
</body>
</html>

2.第二步：右键工程创建名为LoginServlet的java类

在这里插入图片描述
添加如下代码：（代码照抄，很多不明白）

import java.io.IOException;
 
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
  
public class LoginServlet extends HttpServlet {
    protected void doPost(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {
        String name = request.getParameter("name");
        String password = request.getParameter("password");
  
        System.out.println("name:" + name);
        System.out.println("password:" + password);
        String html = null;
        
        if ("admin".equals(name) && "123".equals(password))
            html = "<div style='color:green'>success</div>";
        else
            html = "<div style='color:red'>fail</div>";
  
        PrintWriter pw = response.getWriter();
        pw.println(html);
    }
}

3.第三步：映射LoginServlet到路径login

在web.xml中新增映射

<?xml version="1.0" encoding="UTF-8"?>
<web-app>
 
    <servlet>
        <servlet-name>HelloServlet</servlet-name>
        <servlet-class>HelloServlet</servlet-class>
    </servlet>
 
    <servlet-mapping>
        <servlet-name>HelloServlet</servlet-name>
        <url-pattern>/hello</url-pattern>
    </servlet-mapping>
     
    <servlet>
        <servlet-name>LoginServlet</servlet-name>
        <servlet-class>LoginServlet</servlet-class>
    </servlet>
 
    <servlet-mapping>
        <servlet-name>LoginServlet</servlet-name>
        <url-pattern>/login</url-pattern>
    </servlet-mapping>   
 
</web-app>

4.第四步：重启tomcat服务后浏览器访问

输入账号和密码
在这里插入图片描述
登录后的响应页面（成功和失败响应，也可以分为两个html文件）

tomcat控制台获取到账号和密码
在这里插入图片描述

第四课：动态web（2021.12.29）

1.第一步：在Eclipse EE中新建一个Dynamic Web工程

File->New->Other->Web->Dynamic Web Project
工程名为：j2ee
在这里插入图片描述
javaSE-1.6改为1.8：该文件右键修改即可

2.第二步：在j2ee工程中创建名为HelloServlet的类

在这里插入图片描述
copy以下代码：

import java.io.IOException;
import java.util.Date;
  
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
  
public class HelloServlet extends HttpServlet{
  
    public void doGet(HttpServletRequest request, HttpServletResponse response){
          
        try {
            response.getWriter().println("<h1>Hello Servlet!</h1>");
            response.getWriter().println(new Date().toLocaleString());
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
      
}

3.第三步：解决找不到servlet-api.jar报错问题

把tomcat中lib目录下servlet-api.jar文件copy到D:projectj2eesrcmainwebappWEB-INFlib目录下
在这里插入图片描述

然后刷新项目，该报错消除，但还有一个java版本不匹配错误

4.第四步：解决java版本不匹配报错问题

改完下面三个地方错误消除
在这里插入图片描述

5.第五步：新建web.xml

在WEB-INF目录中创建 web.xml
在这里插入图片描述
在Source中添加如下代码：

<?xml version="1.0" encoding="UTF-8"?>
<web-app>
 
    <servlet>
        <servlet-name>HelloServlet</servlet-name>
        <servlet-class>HelloServlet</servlet-class>
    </servlet>
 
    <servlet-mapping>
        <servlet-name>HelloServlet</servlet-name>
        <url-pattern>/hello</url-pattern>
    </servlet-mapping>
 
</web-app>

6.第六步：通过Eclipse启动Tomcat-Run On Server

首先右键项目 -> Run As -> Run on Server
在这里插入图片描述

注意：tomcat配置文件server.xml中不需要指定web路径

7.第七步：在浏览器中输入地址验证效果

日期那里有乱码，没解决。。。
在这里插入图片描述
在HelloServlet.java中加入：response.setContentType(“text/html; charset=UTF-8”);这句即可

在这里插入图片描述

第五课：安装MySQL数据库（2022.01.04）

1.第一步：下载MySQL

MySQL下载地址：https://dev.mysql.com/downloads/mysql/
在这里插入图片描述

2.第二步：安装MySQL

在这里插入图片描述

3.第三步：配置MySQL

注意： 1.安装完成后，点击Finish会弹出一个界面，让你选择是否配置MySQL，点击是即开始配置导向
2.在MySQL安装目录下的bin目录中双击MySQLInstanceConfig.exe文件启动配置导向（D:Program FilesMySQLMySQL Server 5.5binMySQLInstanceConfig.exe）

在这里插入图片描述

4.第四步：验证MySQL是否安装配置成功

在开始菜单中到到MySQL 5.5 Command Line Client程序，点击进入
在这里插入图片描述
输入配置MySQL设置的root用户密码

出现下图画面，表示安装配置成功

5.第五步：MySQL简单操作：

1.创建数据库：CREATE DATABASE 数据库名称；
2.查看已经存在的数据库：SHOW DATABASES;
3.查看某个数据的信息：SHOW CREATE DATABASE 数据库名称；
4.删除某个数据库：DROP DATABASE 数据库名称；
5.使用某个数据库：USE 数据库名称；
6.创建数据表：
CREATE TABLE 表名
(
字段名1，数据类型[完整性约束条件]，
字段名2，数据类型[完整性约束条件]，
…
字段名3，数据类型[完整性约束条件]，
）
7.查看数据表：SHOW CREATE TABLE 表名；
8.使用DESCRIBE语句查看数据表：DESCRIBE 表名；（简写：DESC 表名；）
9.删除数据表：DROP TABLE 表名；
10.INSERT语句添加数据：
INSERT INTO 表名(字段名1，字段名2，字段名3，…)
VALUES(值1,值2,值3，…);
11.SELECT语句查看数据表数据：SELECT * FROM 表名；

第六课：CRUD数据库查询（2022.01.07）

利用JDBC技术可以实现java操作MySQL数据库
重点:导入mysql-jdbc.jar包

1.第一步：为项目导入mysql-jdbc.jar包

jar下载下载地址：https://how2j.cn/k/servlet/servlet-query/563.html
1.在上一个项目中导入：把mysql-connector-java-5.0.8-bin.jar包复制到D:projectj2eelib和D:projectj2eesrcmainwebappWEB-INFlib目录下
2.为java项目添加mysql-connector-java-5.0.8-bin.jar
在这里插入图片描述
3.保存项目，刷新项目

2.第二步：创建Hero类，包名为bean

在这里插入图片描述

package bean;
public class Hero {
    public int id;
    public String name;
    public float hp;
    public int damage;
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public float getHp() {
        return hp;
    }
    public void setHp(float hp) {
        this.hp = hp;
    }
    public int getDamage() {
        return damage;
    }
    public void setDamage(int damage) {
        this.damage = damage;
    }
     
}

3.第三步：创建HeroDAO类，包名为dao

在这里插入图片描述

package dao;
  
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.ArrayList;
import java.util.List;
 
import bean.Hero;
  
public class HeroDAO {
  
    public HeroDAO() {
        try {
            Class.forName("com.mysql.jdbc.Driver");
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
  
    public Connection getConnection() throws SQLException {
        return DriverManager.getConnection("jdbc:mysql://127.0.0.1:3306/how2java?characterEncoding=UTF-8", "root",
                "admin");
    }
  
    public int getTotal() {
        int total = 0;
        try (Connection c = getConnection(); Statement s = c.createStatement();) {
  
            String sql = "select count(*) from hero";
  
            ResultSet rs = s.executeQuery(sql);
            while (rs.next()) {
                total = rs.getInt(1);
            }
  
            System.out.println("total:" + total);
  
        } catch (SQLException e) {
  
            e.printStackTrace();
        }
        return total;
    }
  
    public void add(Hero hero) {
  
        String sql = "insert into hero values(null,?,?,?)";
        try (Connection c = getConnection(); PreparedStatement ps = c.prepareStatement(sql);) {
  
            ps.setString(1, hero.name);
            ps.setFloat(2, hero.hp);
            ps.setInt(3, hero.damage);
  
            ps.execute();
  
            ResultSet rs = ps.getGeneratedKeys();
            if (rs.next()) {
                int id = rs.getInt(1);
                hero.id = id;
            }
        } catch (SQLException e) {
  
            e.printStackTrace();
        }
    }
  
    public void update(Hero hero) {
  
        String sql = "update hero set name= ?, hp = ? , damage = ? where id = ?";
        try (Connection c = getConnection(); PreparedStatement ps = c.prepareStatement(sql);) {
  
            ps.setString(1, hero.name);
            ps.setFloat(2, hero.hp);
            ps.setInt(3, hero.damage);
            ps.setInt(4, hero.id);
  
            ps.execute();
  
        } catch (SQLException e) {
  
            e.printStackTrace();
        }
  
    }
  
    public void delete(int id) {
  
        try (Connection c = getConnection(); Statement s = c.createStatement();) {
  
            String sql = "delete from hero where id = " + id;
  
            s.execute(sql);
  
        } catch (SQLException e) {
  
            e.printStackTrace();
        }
    }
  
    public Hero get(int id) {
        Hero hero = null;
  
        try (Connection c = getConnection(); Statement s = c.createStatement();) {
  
            String sql = "select * from hero where id = " + id;
  
            ResultSet rs = s.executeQuery(sql);
  
            if (rs.next()) {
                hero = new Hero();
                String name = rs.getString(2);
                float hp = rs.getFloat("hp");
                int damage = rs.getInt(4);
                hero.name = name;
                hero.hp = hp;
                hero.damage = damage;
                hero.id = id;
            }
  
        } catch (SQLException e) {
  
            e.printStackTrace();
        }
        return hero;
    }
  
    public List<Hero> list() {
        return list(0, Short.MAX_VALUE);
    }
  
    public List<Hero> list(int start, int count) {
        List<Hero> heros = new ArrayList<Hero>();
  
        String sql = "select * from hero order by id desc limit ?,? ";
  
        try (Connection c = getConnection(); PreparedStatement ps = c.prepareStatement(sql);) {
  
            ps.setInt(1, start);
            ps.setInt(2, count);
  
            ResultSet rs = ps.executeQuery();
  
            while (rs.next()) {
                Hero hero = new Hero();
                int id = rs.getInt(1);
                String name = rs.getString(2);
                float hp = rs.getFloat("hp");
                int damage = rs.getInt(4);
                hero.id = id;
                hero.name = name;
                hero.hp = hp;
                hero.damage = damage;
                heros.add(hero);
            }
        } catch (SQLException e) {
  
            e.printStackTrace();
        }
        return heros;
    }
  
}

4.第四步：创建HeroListServlet类，包名为servlet

在这里插入图片描述

package servlet;
 
import java.io.IOException;
import java.util.List;
 
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
 
import bean.Hero;
import dao.HeroDAO;
 
public class HeroListServlet extends HttpServlet {
 
    protected void service(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {
        response.setContentType("text/html; charset=UTF-8");
         
        List<Hero> heros = new HeroDAO().list();
 
        StringBuffer sb = new StringBuffer();
        sb.append("<table align='center' border='1' cellspacing='0'>rn");
        sb.append("<tr><td>id</td><td>name</td><td>hp</td><td>damage</td></tr>rn");
 
        String trFormat = "<tr><td>%d</td><td>%s</td><td>%f</td><td>%d</td></tr>rn";
 
        for (Hero hero : heros) {
            String tr = String.format(trFormat, hero.getId(), hero.getName(), hero.getHp(), hero.getDamage());
            sb.append(tr);
        }
 
        sb.append("</table>");
 
        response.getWriter().write(sb.toString());
 
    }
}

5.第五步：配置web.xml

在web.xml中把路径 listHero映射到HeroListServlet上，然后保存项目，刷新项目

<?xml version="1.0" encoding="UTF-8"?>
<web-app>
 
    <servlet>
        <servlet-name>HelloServlet</servlet-name>
        <servlet-class>HelloServlet</servlet-class>
    </servlet>
 
    <servlet-mapping>
        <servlet-name>HelloServlet</servlet-name>
        <url-pattern>/hello</url-pattern>
    </servlet-mapping>
    
    
    <servlet>
        <servlet-name>HeroListServlet</servlet-name>
        <servlet-class>servlet.HeroListServlet</servlet-class>
    </servlet>
 
    <servlet-mapping>
        <servlet-name>HeroListServlet</servlet-name>
        <url-pattern>/listHero</url-pattern>
    </servlet-mapping> 
 
</web-app>

6.第六步：在MySQL中创建数据表及数据

1.创建数据表：
DROP TABLE IF EXISTS hero;

CREATE TABLE `hero` (
  `id` int(11) NOT NULL AUTO_INCREMENT,
  `name` varchar(30) DEFAULT NULL,
  `hp` float DEFAULT NULL,
  `damage` int(11) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8;

2.添加数据：

 INSERT INTO hero(id,name,hp,damage)    
VALUES(143,'zhangshan',999,54),(144,'zhangshan',999,54),(145,'zhangshan',999,54),(146,'zhangshan',999,54),(147,'zhangshan',999,54);

3.查看数据：SELECT * FROM hero;
在这里插入图片描述

7.第七步：浏览器验证效果

输入网址：你的域名或IP地址/j2ee/listHero
在这里插入图片描述
注：
JDK 1.5开始对for语句进行了改进，为更好遍历数组和集合，改进后的for语句格式如下：
for(数据类型循环变量 : 数组名或表达式){
…
}
如：

char b[]={‘a’,‘b’,‘c’};
for(char ch : b){
System.out.println(ch); //输出数组b中的所有元素
}

第七课：CRUD数据库增删改（2022.01.10）

1.数据库增加

1.新建一个用于增加数据的页面
在这里插入图片描述

<!DOCTYPE html>
 
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
 
<form action="addHero" method="post">
     名字 ： <input type="text" name="name"> <br>
血量 ： <input type="text" name="hp"> <br>
伤害： <input type="text" name="damage"> <br>
         <input type="submit" value="增加 ">
</form>

2.新建一个java类，用于操作数据库（增加）
在这里插入图片描述

package servlet;
 
import java.io.IOException;
 
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
 
import bean.Hero;
import dao.HeroDAO;
 
public class HeroAddServlet extends HttpServlet {
 
    protected void service(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {
 
        request.setCharacterEncoding("UTF-8");
 
        Hero hero = new Hero();
        hero.setName(request.getParameter("name"));
        hero.setHp(Float.parseFloat(request.getParameter("hp")));
        hero.setDamage(Integer.parseInt(request.getParameter("damage")));
         
        new HeroDAO().add(hero);
 
        response.sendRedirect("/j2ee/listHero");
         
    }
}

3.配置web.xml映射该java类

<?xml version="1.0" encoding="UTF-8"?>
<web-app>
 
    <servlet>
        <servlet-name>HelloServlet</servlet-name>
        <servlet-class>HelloServlet</servlet-class>
    </servlet>
    <servlet-mapping>
        <servlet-name>HelloServlet</servlet-name>
        <url-pattern>/hello</url-pattern>
    </servlet-mapping>
    
    
    <servlet>
        <servlet-name>HeroListServlet</servlet-name>
        <servlet-class>servlet.HeroListServlet</servlet-class>
    </servlet>
    <servlet-mapping>
        <servlet-name>HeroListServlet</servlet-name>
        <url-pattern>/listHero</url-pattern>
    </servlet-mapping> 
    
       <servlet>
        <servlet-name>HeroAddServlet</servlet-name>
        <servlet-class>servlet.HeroAddServlet</servlet-class>
    </servlet>
    <servlet-mapping>
        <servlet-name>HeroAddServlet</servlet-name>
        <url-pattern>/addHero</url-pattern>
    </servlet-mapping>  
 
</web-app>

4.浏览器验证
在这里插入图片描述

2.数据库删除

1.在HeroListServlet中增加delete显示（为table新增加一列delete,对于每条hero数据，增加一个delete超链？？不明白）

package servlet;
 
import java.io.IOException;
import java.util.List;
 
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
 
import bean.Hero;
import dao.HeroDAO;
 
public class HeroListServlet extends HttpServlet {
 
    protected void service(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {
        response.setContentType("text/html; charset=UTF-8");
         
        List<Hero> heros = new HeroDAO().list();
 
        StringBuffer sb = new StringBuffer();
        sb.append("<table align='center' border='1' cellspacing='0'>rn");
        sb.append("<tr><td>id</td><td>name</td><td>hp</td><td>damage</td><td>delete</td></tr>rn");
 
        String trFormat = "<tr><td>%d</td><td>%s</td><td>%f</td><td>%d</td><td><a href='deleteHero?id=%d'>delete</a></td></tr>rn";
 
        for (Hero hero : heros) {
            String tr = String.format(trFormat, hero.getId(), hero.getName(), hero.getHp(), hero.getDamage(),hero.getId());
            sb.append(tr);
        }
 
        sb.append("</table>");
 
        response.getWriter().write(sb.toString());
 
    }
}

2.新建一个java类，用于删除操作（创建HeroDeleteServlet类）
首先获取参数id
然后通过HeroDAO根据id，删除该对象
然后客户端跳转到/j2ee /listHero

package servlet;
 
import java.io.IOException;
 
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
 
import dao.HeroDAO;
 
public class HeroDeleteServlet extends HttpServlet {
 
    protected void service(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {
 
        int id = Integer.parseInt(request.getParameter("id"));
         
        new HeroDAO().delete(id);
 
        response.sendRedirect("/j2ee/listHero");
         
    }
}

3.配置web.xml增加HeroDeleteServlet映射

    <servlet>
        <servlet-name>HeroDeleteServlet</servlet-name>
        <servlet-class>servlet.HeroDeleteServlet</servlet-class>
    </servlet>
 
    <servlet-mapping>
        <servlet-name>HeroDeleteServlet</servlet-name>
        <url-pattern>/deleteHero</url-pattern>
    </servlet-mapping>

4.浏览器验证
在这里插入图片描述

3.数据库修改

同上
1.修改显示

package servlet;

import java.io.IOException;
import java.util.List;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import bean.Hero;
import dao.HeroDAO;

public class HeroListServlet extends HttpServlet {

	protected void service(HttpServletRequest request, HttpServletResponse response)
			throws ServletException, IOException {
        response.setContentType("text/html; charset=UTF-8");
        
		List<Hero> heros = new HeroDAO().list();

		StringBuffer sb = new StringBuffer();
		sb.append("<table align='center' border='1' cellspacing='0'>rn");
		sb.append("<tr><td>id</td><td>name</td><td>hp</td><td>damage</td><td>edit</td><td>delete</td></tr>rn");

		String trFormat = "<tr><td>%d</td><td>%s</td><td>%f</td><td>%d</td><td><a href='editHero?id=%d'>edit</a></td><td><a href='deleteHero?id=%d'>delete</a></td></tr>rn";

		for (Hero hero : heros) {
			String tr = String.format(trFormat, hero.getId(), hero.getName(), hero.getHp(), hero.getDamage(),hero.getId(),hero.getId());
			
			sb.append(tr);
		}

		sb.append("</table>");

		response.getWriter().write(sb.toString());

	}
}

2.新建java类，用于编辑HeroEditServlet

package servlet;
 
import java.io.IOException;
 
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
 
import bean.Hero;
import dao.HeroDAO;
 
public class HeroEditServlet extends HttpServlet {
 
    protected void service(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {
 
        int id = Integer.parseInt(request.getParameter("id"));
 
        Hero hero = new HeroDAO().get(id);
 
        StringBuffer format = new StringBuffer();
        response.setContentType("text/html; charset=UTF-8");
 
        format.append("<!DOCTYPE html>");
 
        format.append("<form action='updateHero' method='post'>");
        format.append("名字 ： <input type='text' name='name' value='%s' > <br>");
        format.append("血量 ： <input type='text' name='hp'  value='%f' > <br>");
        format.append("伤害： <input type='text' name='damage'  value='%d' > <br>");
        format.append("<input type='hidden' name='id' value='%d'>");
        format.append("<input type='submit' value='更新'>");
        format.append("</form>");
 
        String html = String.format(format.toString(), hero.getName(), hero.getHp(), hero.getDamage(), hero.getId());
 
        response.getWriter().write(html);
 
    }
}

3.新建java类，用于更新HeroUpdateServlet

package servlet;
 
import java.io.IOException;
 
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
 
import bean.Hero;
import dao.HeroDAO;
 
public class HeroUpdateServlet extends HttpServlet {
 
    protected void service(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {
 
        request.setCharacterEncoding("UTF-8");
 
        Hero hero = new Hero();
        hero.setId(Integer.parseInt(request.getParameter("id")));
        hero.setName(request.getParameter("name"));
        hero.setHp(Float.parseFloat(request.getParameter("hp")));
        hero.setDamage(Integer.parseInt(request.getParameter("damage")));
 
        new HeroDAO().update(hero);
 
        response.sendRedirect("/j2ee/listHero");
 
    }
}

4.配置web.xml

    <servlet>
        <servlet-name>HeroEditServlet</servlet-name>
        <servlet-class>servlet.HeroEditServlet</servlet-class>
    </servlet>
 
    <servlet-mapping>
        <servlet-name>HeroEditServlet</servlet-name>
        <url-pattern>/editHero</url-pattern>
    </servlet-mapping>
    
    <servlet>
        <servlet-name>HeroUpdateServlet</servlet-name>
        <servlet-class>servlet.HeroUpdateServlet</servlet-class>
    </servlet>
 
    <servlet-mapping>
        <servlet-name>HeroUpdateServlet</servlet-name>
        <url-pattern>/updateHero</url-pattern>
    </servlet-mapping>

4.浏览器验证
在这里插入图片描述

第八课：http协议实验（2022.1.13）

漫漫长路之研究了两天http协议，没有大佬带是真迷茫

1.名词解释

http：超文本传输协议（客户端和服务端之间的超文本传输协议）
URL：统一资源定位器

2.简单的传输流程

在这里插入图片描述

客户端请求数据格式：
在这里插入图片描述
服务端响应数据格式：

3.EclipseEE TCP/IP Monitor监控服务端http协议数据

1.配置EclipseEE TCP/IP Monitor监测经过服务器的http协议
在这里插入图片描述

2.请求和响应数据包格式
用下面http调试助手向服务器发数据：
在这里插入图片描述
下图是服务器监测到的http数据：

结果显示：

响应格式：

第九课：接收电信AEP平台http订阅消息（2022.1.20）

1.在电信AEP平台订阅管理中增加HTTP订阅，URL为接收端地址

在这里插入图片描述

2.在MySQL数据库中新建一个名为bb55的数据库

在该数据库中新建一个hero表，表中新建5个参数分别为：
id;name;hp;damage;bb55;
（其中bb55参数200字节的字符串类型）
在这里插入图片描述

3.在java程序中修改数据库连接名，由test改为bb55

在这里插入图片描述

4.在java程序中依次增加bb55参数

hero.java代码：

package bean;

public class Hero {
    public int id;
    public String name;
    public float hp;
    public int damage;
    public String bb55;
    
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public float getHp() {
        return hp;
    }
    public void setHp(float hp) {
        this.hp = hp;
    }
    public int getDamage() {
        return damage;
    }
    public void setDamage(int damage) {
        this.damage = damage;
    }

    public String getBb55() {
        return bb55;
    }
    public void setBb55(String bb55) {
        this.bb55 = bb55;
    }
     
}

heroDAO.java代码：

 public int getTotal() {
        int total = 0;
        try (Connection c = getConnection(); Statement s = c.createStatement();) {
  
            String sql = "select count(*) from hero"; //获取表hero的所有数据
  
            ResultSet rs = s.executeQuery(sql);
            while (rs.next()) {
                total = rs.getInt(1);
            }
  
            System.out.println("total:" + total);
  
        } catch (SQLException e) {
  
            e.printStackTrace();
        }
        return total;
    }
  
    public void add(Hero hero) {
  
        String sql = "insert into hero values(null,?,?,?,?)";
        try (Connection c = getConnection(); PreparedStatement ps = c.prepareStatement(sql);) {
  
            ps.setString(1, hero.name);
            ps.setFloat(2, hero.hp);
            ps.setInt(3, hero.damage);
            ps.setString(4, hero.bb55);
            ps.execute();
  
            ResultSet rs = ps.getGeneratedKeys();
            if (rs.next()) {
                int id = rs.getInt(1);
                hero.id = id;
            }
        } catch (SQLException e) {
  
            e.printStackTrace();
        }
    }
  
    public void update(Hero hero) {
  
        String sql = "update hero set name= ?, hp = ? , damage = ?  , bb55 = ? where id = ?";
        try (Connection c = getConnection(); PreparedStatement ps = c.prepareStatement(sql);) {
  
            ps.setString(1, hero.name);
            ps.setFloat(2, hero.hp);
            ps.setInt(3, hero.damage);
            ps.setString(4, hero.bb55);
            ps.setInt(5, hero.id);
            
           
  
            ps.execute();
  
        } catch (SQLException e) {
  
            e.printStackTrace();
        }
  
    }
  
    public void delete(int id) {
  
        try (Connection c = getConnection(); Statement s = c.createStatement();) {
  
            String sql = "delete from hero where id = " + id;
  
            s.execute(sql);
  
        } catch (SQLException e) {
  
            e.printStackTrace();
        }
    }
  
    public Hero get(int id) {
        Hero hero = null;
  
        try (Connection c = getConnection(); Statement s = c.createStatement();) {
  
            String sql = "select * from hero where id = " + id;
  
            ResultSet rs = s.executeQuery(sql);
  
            if (rs.next()) {
                hero = new Hero();
                String name = rs.getString(2);
                String bb55 = rs.getString(5);
                float hp = rs.getFloat("hp");
                int damage = rs.getInt(4);
                hero.name = name;
                hero.bb55 = bb55;
                hero.hp = hp;
                hero.damage = damage;
                hero.id = id;
            }
  
        } catch (SQLException e) {
  
            e.printStackTrace();
        }
        return hero;
    }
  
    public List<Hero> list() {
        return list(0, Short.MAX_VALUE);
    }
  
    public List<Hero> list(int start, int count) {
        List<Hero> heros = new ArrayList<Hero>();
  
        String sql = "select * from hero order by id desc limit ?,? ";
  
        try (Connection c = getConnection(); PreparedStatement ps = c.prepareStatement(sql);) {
  
            ps.setInt(1, start);
            ps.setInt(2, count);
  
            ResultSet rs = ps.executeQuery();
  
            while (rs.next()) {
                Hero hero = new Hero();
                int id = rs.getInt(1);
                String name = rs.getString(2);
                String bb55 = rs.getString(5);
                float hp = rs.getFloat("hp");
                int damage = rs.getInt(4);
                hero.id = id;
                hero.name = name;
                hero.hp = hp;
                hero.damage = damage;
                hero.bb55 = bb55;
                heros.add(hero);
            }
        } catch (SQLException e) {
  
            e.printStackTrace();
        }
        return heros;
    }
  
}

5.在HeroAddServlet.java中增加接收http消息的代码

将解完码的字符串转成十六进制字符串的方法
    private static final char[] DIGITS = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'};
    private static final String toHex(byte[] data) {
        final StringBuffer sb = new StringBuffer(data.length * 2);
        for (int i = 0; i < data.length; i++) {
            sb.append(DIGITS[(data[i] >>> 4) & 0x0F]);
            sb.append(DIGITS[data[i] & 0x0F]);
        }
        return sb.toString().toLowerCase();
    }
    	// 读取请求内容，可行20220118
        BufferedReader br = new BufferedReader(new InputStreamReader(request.getInputStream()));
        String line = null;
        StringBuilder sb = new StringBuilder();
        while((line = br.readLine())!=null){
            sb.append(line);
        }
        String reqBody = sb.toString();  // 将接收到的数据转成字符串

        String bb = reqBody.substring(179,259); //BB55完整数据（base64加密）
        String imei = reqBody.substring(389,411);//IMEI码数据
    
        byte[] decode = Base64.getDecoder().decode(bb); //base64解码
        String decodeStr = HeroAddServlet.toHex(decode); //将解完码的字符串转成十六进制字符串

6.将解完base64码的json数据存入数据库

需要解码的json数据：

将需要的数据存入数据库：

        Hero hero = new Hero(); 
        hero.setBb55(decodeStr);
        hero.setName( imei);
        hero.setHp(Float.parseFloat("12"));
        hero.setDamage(Integer.parseInt("12")); 
        new HeroDAO().add(hero); //存入数据库

结果如下：
在这里插入图片描述

第十课：JAVA基础知识（2022.1.24）

1.new的意思

java是面向对象的语言，new是用于类的实例化；

String类的实例化：
String a = new String(“hello”);
创建了String类的一个实例，名叫a的对象。

那么也就是String a = new String(“hello”);前半部分，String a的意思是，在内存中分配一个变量，名字叫a，这个变量是String类型的;后半部分，new String(“hello”);这就是new关键字和构造方法来创建一个对象,参数为“hello”，String()是构造方法的名字。
参考：https://zhidao.baidu.com/question/55121438.html

2.类和对象

public class hero {
	//类的属性
	String name; 
	float hp;
	float damage;
	int moveSpeed;

	//类的方法
	void keng() { //无参数，无返回值的方法
		System.out.println("坑！");
	}

	float getHp() { //无参数，有返回值的方法
		return this.hp;
	}

	int Addspeed(int speed) {  //有参数，有返回值的方法
		moveSpeed += speed;
		return moveSpeed;
	}

	public static void main(String[] args) {
		hero bich = new hero(); //创建一个hero类的对象
		bich.name = "二哈"; 				//给对象的属性赋值
		bich.hp = (float) 250.9;		//给对象的属性赋值
		bich.damage = (float) 250.7;	//给对象的属性赋值

		System.out.print("rn" + bich.name + bich.hp); //输出对象的属性
		System.out.println("rn" + bich.getHp()); 		//调用对象的方法，输出结果
		bich.keng();//调用对象的方法
		bich.moveSpeed = 300;
		System.out.println(bich.moveSpeed); 		//调用对象的方法，输出结果
		System.out.println(bich.Addspeed(100)); 	//调用对象的方法，输出结果
	}
}

输出结果如下：
在这里插入图片描述

3.集合类

1).Map
2).Set
3).List
参考

import java.util.*;

public class listtest {

	public static void main(String[] args) {

		List<String> list = new ArrayList<>(); //创建集合对象list，数据类型为字符串（实例化集合对象）
		List<String> list2 = new ArrayList<>();//创建集合对象list2，数据类型为字符串（实例化集合对象）

		list.add("a" + 12); //向集合中添加元素
		list.add("b090900bbbb");
		list.add("c");
		list.add(3, "uuuu");//向集合中指定索引添加元素

		list2.add("dd");
		list2.add("rr");
		list2.add("tt");
		list2.add(3, "ff");

		list.addAll(3, list2); //将list2全部元素插入list指定索引3后
		
		for (int n = 0;n < list.size() ;n++ ) {
			System.out.print(list.get(n)); //循环遍历集合
		}
		
		System.out.print(list.size()); 	//打印出list所有元素个数
		
		System.out.print("n"+list);  	//打印出list所有元素
		
		System.out.print("n"+list2);  	//打印出list2所有元素个数
	}

}

输出结果如下：
在这里插入图片描述

4.读写.txt文本

从TXT文本中读取数据：

	// 读TXT文本
	public static String readFileContent(String fileName) {
		File file = new File(fileName);
		BufferedReader reader = null;
		StringBuffer sbf = new StringBuffer();
		try {
			reader = new BufferedReader(new FileReader(file));
			String tempStr;
			while ((tempStr = reader.readLine()) != null) {
				sbf.append(tempStr);
			}
			reader.close();
			return sbf.toString();
		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			if (reader != null) {
				try {
					reader.close();
				} catch (IOException e1) {
					e1.printStackTrace();
				}
			}
		}
		return sbf.toString();
	}
	
	//调用读方法
	String bbdata = AEPTest.readFileContent("D:/bb55login/AEPdata.txt");

向TXT文本中写入数据：（如果txt文本不存在，则会自动创建）

		File file = new File("D:/bb55login/AEPdata.txt"); // 打开对应路径的文件
		BufferedWriter writer = new BufferedWriter(new FileWriter(file));
		writer.write(decodeStr);
		writer.flush();
		writer.close();

5.四字节16进制浮点数转10进制浮点数

	public static String HextoFloat(String data) {
		Long l2 = Long.parseLong(data.trim(), 16);
		Float f2 = Float.intBitsToFloat(l2.intValue());
		DecimalFormat decimalFormat2 = new DecimalFormat("0.000");
		String VALUE = decimalFormat2.format(f2);// format 返回的是字符串
		return VALUE;
	}
	
	//调用方法
	String vol = AEPTest.HextoFloat("436AF812");// 获取电压值
	//vol的值为:234.969

6.四字节16进制时间戳转10进制日期时间格式

	/**
	 * 时间戳转换成日期格式字符串
	 * 
	 * @param seconds   精确到秒的字符串
	 * @param formatStr
	 * @return
	 */
	public static String timeStamp2Date(String s, String format) {
		int time = Integer.parseInt(s, 16);
		String seconds = Integer.toString(time, 10);
		if (seconds == null || seconds.isEmpty() || seconds.equals("null")) {
			return "";
		}
		if (format == null || format.isEmpty()) {
			format = "yyyy-MM-dd HH:mm:ss";
		}
		SimpleDateFormat sdf = new SimpleDateFormat(format);
		return sdf.format(new Date(Long.valueOf(seconds + "000")));
	}
	
	//调用:
	String timecuo = AEPTest.timeStamp2Date("61F24373", "yyyy-MM-dd HH:mm:ss");
	//timecuo的值为：2022-01-27 15:02:11

第十一课：人人开源问题（2022.2.21）

1.菜单栏中文乱码

注意：打开SQL文件时是否有乱码
在这里插入图片描述
解决办法：
1.首先全部字符编码都改为UTF8，然后在进入数据库中输入以下代码

mysql> set names gbk;
Query OK, 0 rows affected (0.00 sec)

2.修改表的编码方式：ALTER TABLE test DEFAULT CHARACTER SET utf8;该命令用于将表test的编码方式改为utf8；
3.以上都不行，则进行以下操作(不建议)：
a.打开控制台，输入chcp，如果是936，就修改
b.更改日期和时间
在这里插入图片描述

重启即可

2.后端部署（花生壳内网透穿）

1.修改MySQL数据库账户、密码、域名
在这里插入图片描述
2.tomcat端口号保持默认8080
3.在pom.xml上右键选择maven install运行打包

4.在后端代码文件夹renren-fasttarget下会出现一个renren-fast.jar文件，该文件既是打包好的后端文件

5.用dos进入renren-fasttarget文件，运行该文件

java -jar renren-fast.jar --spring.profiles.active=test

在这里插入图片描述
6.验证，出现下图说明成功了
执行命令后浏览器打开http://localhost:8080/renren-fast/swagger/index.html#/

3.前端部署（花生壳内网透穿+Tomcat）

1.配置后端API地址
在这里插入图片描述

2.改tomcat连接端口

3.修改/src/router/index.js，如下：

const router = new Router({
  base: '/Test/',		//**在tomcat的webapps文件夹下新建同名目录，打包后文件放置其中
  mode: 'history',		//**hash修改为history后，可去除url上的#号
  scrollBehavior: () => ({ y: 0 }),
  isAddDynamicMenuRoutes: false, // 是否已经添加动态(菜单)路由
  routes: globalRoutes.concat(mainRoutes)
})

4.进入renren-fast-vue目录，命令行执行npm run build进行打包
5.把生成的文件拷贝到tomcat路径D:tomcatwebappsROOTTest下
在这里插入图片描述

6.启动tomcat后在浏览器中输入网址，出现下图即为成功

4.内网透传出现：Invalid Host header

解决：
https://blog.csdn.net/Cookysurongbin/article/details/86077241

4.renren-generator（代码生成器）

第十二课：生产部署，打包jar

1.idea打包

在这里插入图片描述
工程目录下会出现：Target文件夹，文件夹里就有jar文件

报错：
在这里插入图片描述
解决：在项目根文件中进行打包

第十三课：Linux(centOS8.5)搭建Web开发环境

1.安装JDK1.8

https://blog.csdn.net/xiaoyu19910321/article/details/106291856

2.安装MySQL数据库

2.1 使用命令行导入sql文件：

(1) use yourDatabase; //yourDatabase:你的数据库名，例如：use wumao_charge;
(2) source filepath; //你的sql文件绝对路径，例如：source /wmdata/wumao-iot/charge.sql;

2.2 修改用户密码：

(1) 进入数据库：mysql -uroot -p
(2) 修改本地密码：
方法1：ALTER USER 'root'@'localhost' IDENTIFIED BY 'root123';
方法2：set password for root@localhost = password('123456');
(3) 修改远程密码：grant all privileges on *.* to 'root'@'%' identified by '123456' with grant option;
如报错则执行下面语句（密码规则）：
set global validate_password_policy=0;
set global validate_password_length=1;

2.3 关闭MySql的反向DNS:

方法：/etc/my.cnf文件的[mysqld]下加入skip-name-resolve语句保存，重启MySql;
查看MySQL启动状态：systemctl status mysqld;
启动MySQL服务：systemctl start mysqld;
停止MySQL服务：systemctl stop mysqld;

创建数据库：CREATE DATABASE IF NOT EXISTS yourDatabaseName DEFAULT CHARSET utf8mb4 COLLATE utf8mb4_general_ci;

https://www.cnblogs.com/cui830608/p/15078771.html
在这里插入图片描述
失败原因：
GPG对于包的源key的验证没有通过
解决办法：
在yum install 版本后面加上 --nogpgcheck，即可绕过GPG验证成功安装。比如
yum install mysql-community-server --nogpgcheck
重启MySQL：systemctl restart mysqld.service

千万不要用Navicat导sql文件，真TM的慢！

3.安装RabbitMQ3.8.16

官网匹配表（RabbitMQ与erlang）
[https://www.rabbitmq.com/which-erlang.html](https://www.rabbitmq.com/which-erlang.html)
教程：
[https://www.cnblogs.com/zgq7/p/14752263.html](https://www.cnblogs.com/zgq7/p/14752263.html)

**配置web端访问账号密码和权限:**
默认网页是不允许访问的，需要增加一个用户修改一下权限，代码如下：
//添加用户，后面两个参数分别是用户名和密码，我这都用superrd了
 rabbitmqctl add_user admin 123456 
rabbitmqctl set_permissions -p / admin ".*" ".*" ".*" //添加权限
rabbitmqctl set_user_tags admin administrator  //修改用户角色

4.安装redis

https://www.cnblogs.com/angelasp/p/12853446.html

4.1 win10后台启动redis

windows 下后台启动 redis：
(1).在进入Redis的安装目录,输入CMD打开DOS
(2).输入：redis-server --service-install redis.windows.conf --loglevel verbose ( 安装redis服务 )
(3).输入：redis-server --service-start ( 启动服务 )
(4).输入：redis-server --service-stop （停止服务）
启动指定的配置文件:redis-server --service-start redis.windows-service.conf

5.启动.jar

java -jar xxx.jar //前台运行
nohup java -jar xxx.jar & //后台运行

6.Centos设置80端口映射8080/8081(Nginx反向代理)

不开防火墙
1.查询转发规则：
iptables -t nat -L -n --line-numbers
在这里插入图片描述
iptables -L -n --line-numbers --将所有iptables以序号标记显示

2.设置转发规则：
iptables -t nat -A PREROUTING -p tcp --dport 80 -j REDIRECT --to-port 8080
3.删除转发规则：
iptables -t nat -D PREROUTING 1
（1代表要删除规则的序号）
开启防火墙
firewall-cmd --state --查看防火墙状态
systemctl stop firewalld.service --停止防火墙
systemctl start firewalld.service --开启防火墙
systemctl disable firewalld.service --禁止开机启动防火墙
systemctl enable firewalld.service --开机启动防火墙
systemctl is-enabled firewalld.service;echo $? --查看服务是否开机启动
firewall-cmd --reloadl --重启防火墙

firewall-cmd --zone=public --list-ports --查看防火墙所有开放的端口
firewall-cmd --zone=public --add-port=80/tcp --permanent --开放指定端口
firewall-cmd --zone=public --remove-port=80/tcp --permanent --关闭指定端口
firewall-cmd --reload – 配置立即生效

netstat -lnpt --查看监听的端口
netstat -lnpt |grep 5672 --检查端口被哪个进程占用
ps 6832 --查看进程的详细信息
kill -9 6832 --中止进程

Nginx反向代理：
安装：Nginx
配置：nginx.conf
在这里插入图片描述
http:
访问地址：http://你的IP//wumao-dtu

    server {
        listen 80;
        client_max_body_size 100m;
        charset utf-8;
        server_name  localhost 你的服务器ip;

        location / {
           	        index  index.html index.htm;
        }
		location ^~ /wumao-dtu/ {
					proxy_pass http://127.0.0.1:8082/wumao-dtu/;
            		proxy_set_header Host $host;
            		proxy_set_header X-Real-IP $remote_addr;
            		proxy_set_header REMOTE-HOST $remote_addr;
            		proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
		}
		location ^~ /wumao-admin/ {
					proxy_pass http://127.0.0.1:8080/wumao-admin/;
            		proxy_set_header Host $host;
            		proxy_set_header X-Real-IP $remote_addr;
            		proxy_set_header REMOTE-HOST $remote_addr;
            		proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
		}
   }

https:
访问地址：https://你的域名/wumao-dtu/

# HTTPS server
	#http强制跳转https
	server {
	    listen 80;
	    server_name 你的域名;
	    rewrite ^(.*) https://$server_name$1 permanent;
	}
	server {
    		listen  443 ssl;
    		server_name 你的域名;
			ssl on;
    		ssl_certificate   /usr/local/nginx/cert/XXX.pem; //ssl证书文件
    		ssl_certificate_key  /usr/local/nginx/cert/XXX.key;  //ssl证书文件
    		ssl_session_timeout 5m;
    		ssl_ciphers ECDHE-RSA-AES128-GCM-SHA256:ECDHE:ECDH:AES:HIGH:!NULL:!aNULL:!MD5:!ADH:!RC4;    #加密算法
    		ssl_protocols TLSv1 TLSv1.1 TLSv1.2;
    		ssl_prefer_server_ciphers on;
			location ^~ /wumao-dtu/ {
			proxy_pass http://127.0.0.1:8082/wumao-dtu/;
	            		proxy_set_header Host $host;
	            		proxy_set_header X-Real-IP $remote_addr;
	            		proxy_set_header REMOTE-HOST $remote_addr;
	            		proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
			}
			location ^~ /wumao-charge/ {
			proxy_pass http://127.0.0.1:8080/wumao-charge/;
		
	            		proxy_set_header Host $host;
	            		proxy_set_header X-Real-IP $remote_addr;
	            		proxy_set_header REMOTE-HOST $remote_addr;
	            		proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
			}
	}

解决：
https://www.cnblogs.com/powerbear/p/15921728.html

7.安装配置Tomcat

https://cloud.tencent.com/developer/article/1333879

在运营项目：
在这里插入图片描述

第十三课：jar包启动产生的错误及问题汇总

1.错误：连不上MySQL

ERROR c.alibaba.druid.pool.DruidDataSource - init datasource error, url: jdbc:mysql://127.0.0.1:3306/wumao_dtu?useUnicode=true&characterEncoding=UTF-8&serverTimezone=Asia/Shanghai
解决：
去官网查询mysql-connector-java的最新版本：https://mvnrepository.com/artifact/mysql/mysql-connector-java
将最新版本写入pom.xml中：
在这里插入图片描述

2.错误：数据库已存在的定时任务导致启动失败

在这里插入图片描述
解决：
先清空定时任务数据库，再启动程序

3.错误：“SQL监控”页面显示错误

SQL监控页面出现：
Sorry, you are not permitted to view this page.
在这里插入图片描述
解决：安装Nginx后正常

4.问题：DTU平台页面访问慢

解决如下：
在这里插入图片描述

结果：
在这里插入图片描述

5.问题：jar包后台运行问题

执行命令：
nohup java -jar xxx.jar &
nohup java -jar xxx.jar >xxx.txt &（指定输出文件）
(等程序运行起来再访问)
结束后台运行程序：
1.找到java后台程序的进程号：
ps aux|grep xxx.jar
在这里插入图片描述

2.结束该进程号：
kill 111218
在这里插入图片描述

6.问题：redis怎么使用

7.问题：centOS8.5开机即运行Web所有环境

8.问题： quartz定时任务启动失败

https://blog.csdn.net/u014799292/article/details/79990241
报错：

org.quartz.JobPersistenceException: Couldn't retrieve trigger: Table 'leo_quartz.QRTZ_TSSDRS' does

原因： Linux大小写敏感
解决：
在/etc/my.cnf文件中添加：lower_case_table_names=1
重启Mysql即可

9.问题：以restart.sh文件启动项目

在这里插入图片描述
app: 需要运行的xxx.jar文件
bak： 备份的xxx.jar文件
config： tomcat、mysql、rabbitmq、运行日志等配置
log： 运行日志
restart.sh xxx.jar启动文件

10.问题：DTU平台与管控平台数据对接

解答：DTU平台获取的数据经过处理后存入数据库中，管控平台从数据库中提取数据进行处理

第十四课：App后台

1.API数据接口

接口地址：
http://你的IP/wumao-admin/swagger-ui.html#/
在这里插入图片描述

2.app发布

HBuilder编译日志：
[HBuilder] 20:21:42.452 项目 ‘wumao-power-uniapp’ 开始编译…
[HBuilder] 20:21:43.403 编译器版本：3.3.13
[HBuilder] 20:21:43.406 正在编译中…
[HBuilder] 20:21:53.682 DONE Build complete.
[HBuilder] 20:21:53.684 项目 ‘wumao-power-uniapp’ 编译成功。
[HBuilder] 20:25:38.974 项目 ‘wumao-power-uniapp’ 开始编译…
[HBuilder] 20:25:39.922 编译器版本：3.3.13
[HBuilder] 20:25:39.923 正在编译中…
[HBuilder] 20:25:50.200 DONE Build complete.
[HBuilder] 20:25:50.201 项目 ‘wumao-power-uniapp’ 编译成功。
[HBuilder] 20:29:43.493 项目 ‘wumao-power-uniapp’ 开始编译…
[HBuilder] 20:29:44.442 编译器版本：3.3.13
[HBuilder] 20:29:44.443 正在编译中…
[HBuilder] 20:29:54.719 DONE Build complete.
[HBuilder] 20:29:54.725 项目 ‘wumao-power-uniapp’ 编译成功。
[广告] 20:29:56.794 DCloud 2022新春招聘开启，欢迎前端、Android、C++/QT来投简历! 详情点击

[HBuilder] 20:29:57.336 项目 wumao-power-uniapp [__UNI__B8380AE]的打包状态：
[HBuilder] 20:29:57.336 时间: 2022-03-28 20:29:55 类型: Android自有证书准备打包
[HBuilder] 20:29:57.336

[HBuilder] 20:29:57.336 打包成功后会自动返回下载链接。
[HBuilder] 20:29:57.336 打包过程查询请点菜单发行-查看云打包状态。
[HBuilder] 20:29:57.336 周五傍晚等高峰期打包排队较长，请耐心等待。
[HBuilder] 20:29:57.336 如果是为了三方SDK调试，请使用自定义调试基座（菜单运行-手机或模拟器-制作自定义调试基座），不要反复打包。

[HBuilder] 20:29:57.343 项目 wumao-power-uniapp [__UNI__B8380AE]的打包状态：
[HBuilder] 20:29:57.343 时间: 2022-03-28 20:29:55 类型: Android自有证书准备打包

[HBuilder] 20:30:56.027 项目 wumao-power-uniapp [__UNI__B8380AE]的打包状态：
[HBuilder] 20:30:56.027 时间: 2022-03-28 20:29:55 类型: Android自有证书打包成功下载地址: https://ide.dcloud.net.cn/build/download/c608f760-ae92-11ec-bcb4-413ab8febcfa [一键上传到uniCloud（免费cdn、长期稳定）]
[HBuilder] 20:30:56.028 HBuilderX已支持App cli自动化打包, 详情参考:https://hx.dcloud.net.cn/cli/pack [不再提示]

[HBuilder] 20:30:56.028 项目 wumao-power-uniapp [__UNI__B8380AE]打包成功：

[HBuilder] 20:30:56.028 类型: Android自有证书下载地址: https://ide.dcloud.net.cn/build/download/c608f760-ae92-11ec-bcb4-413ab8febcfa （注意该地址为临时下载地址，只能下载5次） [一键上传到uniCloud（免费cdn、长期稳定）]
[HBuilder] 20:30:56.028 HBuilderX已支持App cli自动化打包, 详情参考:https://hx.dcloud.net.cn/cli/pack [不再提示]

第十五课：企业版源码分析

1.renren-admin（后台模块）

2.renren-common（公共模块）

3.renren-api（接口模块）
作用：简化微信小程序、app开发

第十六课：SpringBoot对接电信AEP平台

视频教程

1.AEP平台

1).创建产品

在这里插入图片描述

2).添加设备

在这里插入图片描述

3).创建http订阅

在这里插入图片描述

4).创建应用

在这里插入图片描述

2.SpringBoot开发

1).安装AEP平台应用管理中下载的jar包

1.解压生成下面四个文件，并把他们放到你的Springboot工程目录中
在这里插入图片描述
2.安装jar
电信安装教程
在目录中打开cmd窗口，输入以下命令：
mvn install:install-file -Dfile=ag-sdk-biz-62257.tar.gz-20220416.183912-SNAPSHOT.jar -DpomFile=ag-sdk-biz-62257.tar.gz-20220416.183912-SNAPSHOT.pom.xml
mvn install:install-file -Dfile=ctg-ag-sdk-core-2.5.0-20211018.013334-41.jar -DpomFile=ctg-ag-sdk-core-2.5.0-20211018.013334-41.pom.xml

3.maven依赖设置
在这里插入图片描述
注意：需添加以下依赖，否则，jar打包的时候不能将该jar添到工程中

在这里插入图片描述

2).接收AEP平台http协议的订阅消息

1.接收消息格式：
{
“upPacketSN”:-1,
“upDataSN”:-1,
“topic”:“v1/up/ad”,
“timestamp”:1642055247442, //时间戳
“tenantId”:“2000040400”, //租户ID
“serviceId”:“”,
“protocol”:“lwm2m”, //设备与AEP平台之间的通信协议
“productId”:“15133427”, //产品ID
“payload”:{“APPdata”:“u1UAFwDwVSASKTSaHRwCAAAAAWHfxlFycwX9”}, //APPdata：设备发送的数据，经过base64加密
“messageType”:“dataReport”, //消息类型：上线、离线、删除设备、添加设备、数据变换
“deviceType”:“”,
“deviceId”:“00e1d886d1ab4b01b2100c59be61bdda”, //AEP平台给每个设备生成的唯一ID
“assocAssetId”:“”,
“IMSI”:“undefined”,
“IMEI”:“866002058776997”
}
2.SpringBoot处理AEP平台http推送的消息
在这里插入图片描述

3).向AEP平台发送http协议的命令

https://www.ctwing.cn/channel-help-api.htm?api=99#/callback
1.创建dto

package iot.wumao.dto;

import lombok.Data;
import java.util.Map;

@Data
public class CreateCommandDTO {

    private Map<String,Object> content;
    private String deviceId;
    private String operator;
    private Integer productId;
    private Integer ttl;
    private Integer deviceGroupId;
    private Integer level;
}

2.创建utils

package iot.wumao.utils;


import com.alibaba.fastjson.JSON;
import iot.wumao.dto.CreateCommandDTO;
import com.ctg.ag.sdk.biz.AepDeviceCommandClient;
import com.ctg.ag.sdk.biz.aep_device_command.CreateCommandRequest;
import com.ctg.ag.sdk.biz.aep_device_command.CreateCommandResponse;


//指令下发
public class CtWing {

    public final static String APP_Key = "11111";
    public final static String APP_SECRET = "22222";

    public  String CreateCommand(CreateCommandDTO createCommandDTO,String  masterKey){
        AepDeviceCommandClient client = AepDeviceCommandClient.newClient().appKey(APP_Key).appSecret(APP_SECRET).build();
        CreateCommandRequest request = new CreateCommandRequest();

        request.setParamMasterKey(masterKey);
        byte[] bytes = JSON.toJSONBytes(createCommandDTO);
        request.setBody(bytes);	//具体格式见前面请求body说明
        CreateCommandResponse response = null;
        try {
            response = client.CreateCommand(request);
        }catch (Exception e) {
            e.printStackTrace();
        }
        String responseBody = new String(response.getBody());
        client.shutdown();

        return responseBody;
    }
}

3.创建controller接口

    /**
     * 设备命令下发
     */
    public String createCommand(String deviceID,String data){

        String MastKey = "a4f5cf953a1946d59e4c2ae5a99a6a6e";
        JSONObject other = new JSONObject();
        //content
        HashMap<String,Object> content = new HashMap<>();
        content.put("dataType",2);
        content.put("payload",data);
        CtWing createCommand = new CtWing();

        //公共
        CreateCommandDTO ccreateCommandDTO = new CreateCommandDTO();
        ccreateCommandDTO.setContent(content);
        //ccreateCommandDTO.setDeviceId("111111111");
        ccreateCommandDTO.setDeviceId(deviceID);
        ccreateCommandDTO.setOperator("阿汤哥");
        ccreateCommandDTO.setProductId(15079360);
        ccreateCommandDTO.setTtl(7200);
//        ccreateCommandDTO.getDeviceGroupId(100);

        return createCommand.CreateCommand(ccreateCommandDTO,MastKey );
    }