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,添加如下代码，保存退出：
代码如下：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16<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文件
添加如下代码：（访问时显示的页面）
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17<!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类
添加如下代码：（代码照抄，很多不明白）
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27import 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中新增映射
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25<?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以下代码：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22import 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中添加如下代码：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15<?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
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33package 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
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167package 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
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39package 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上，然后保存项目，刷新项目
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26<?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;
1
2
3
4
5
6
7
8CREATE 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.添加数据：
1
2
3INSERT 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.新建一个用于增加数据的页面
1
2
3
4
5
6
7
8
9
10
11<!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类，用于操作数据库（增加）
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32package 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类
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33<?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超链？？不明白）
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39package 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
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25package 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映射
1
2
3
4
5
6
7
8
9
10<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.修改显示
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41package 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
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41package 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
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32package 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
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20<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代码：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44package 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代码：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147public 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消息的代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25将解完码的字符串转成十六进制字符串的方法 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数据：
将需要的数据存入数据库：
1
2
3
4
5
6
7Hero 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.类和对象
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36public 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
参考
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34import 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文本中读取数据：
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30// 读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文本不存在，则会自动创建）
1
2
3
4
5
6File file = new File("D:/bb55login/AEPdata.txt"); // 打开对应路径的文件 BufferedWriter writer = new BufferedWriter(new FileWriter(file)); writer.write(decodeStr); writer.flush(); writer.close();
5.四字节16进制浮点数转10进制浮点数
1
2
3
4
5
6
7
8
9
10
11
12public 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进制日期时间格式
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24/** * 时间戳转换成日期格式字符串 * * @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，然后在进入数据库中输入以下代码
1
2
3mysql> 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文件，运行该文件
1
2java -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，如下：
1
2
3
4
5
6
7
8const 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
2
3(1) use yourDatabase; //yourDatabase:你的数据库名，例如：use wumao_charge; (2) source filepath; //你的sql文件绝对路径，例如：source /wmdata/wumao-iot/charge.sql;
2.2 修改用户密码：
1
2
3
4
5
6
7
8
9(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:
1
2
3
4
5方法：/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
1
2
3
4
5
6
7
8
9
10
11
12官网匹配表（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
1
2
3
4
5
6
7windows 下后台启动 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
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25server { 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/
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34# 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
报错：
1
2org.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
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17package 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
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36package 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接口
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26/** * 设备命令下发 */ 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 ); }
4.调用或访问controller接口即可实现设备命令下发
最后
以上就是苗条鸵鸟最近收集整理的关于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）第二课：用EclipseEE内容请搜索靠谱客的其他文章。
发表评论 取消回复