全程配图超清晰的JAVA后台控制(maven+Tomcat+JDBC)第三期–前后端链接–第一阶段的最终章
上一期我们实现了链接真正的数据库，并新建了一个简单的表单验证，从而实现了从前端获取数据并且和后端数据库链接，详情请见(全程配图超清晰的JAVA后台控制(maven+Tomcat+JDBC)第二期.)。后来导师告诉我不能自己写这种前端页面，因为前后端要真正的分离，所以我们引入一个新的测试工具，Postman。这一期我们要真正的把接口都写出来，并且发布到服务器上，并用Postman测试一下。实现真正的后端接口。
在IDEA实现后端接口并发布在服务器上
目录结构
具体的目录创建的过程在上一期已经详细介绍过，在这里就不再赘述，目录结构就是下面这样子。
代码实现
pom.xml
- 因为这个项目会导入很多依赖，所以这里不一一介绍，简言之有mysql数据库的链接，还有druid连接池的导入，当然还有一些最基本的servlet导入，下面给出总体代码
<?xml version="1.0" encoding="UTF-8"?>
<!--
Licensed to the Apache Software Foundation (ASF) under one
or more contributor license agreements. See the NOTICE file
distributed with this work for additional information
regarding copyright ownership. The ASF licenses this file
to you under the Apache License, Version 2.0 (the
"License"); you may not use this file except in compliance
with the License. You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing,
software distributed under the License is distributed on an
"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
KIND, either express or implied. See the License for the
specific language governing permissions and limitations
under the License.
-->
<!-- $Id: pom.xml 642118 2008-03-28 08:04:16Z reinhard $ -->
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
<modelVersion>4.0.0</modelVersion>
<packaging>war</packaging>
<name>cookie</name>
<groupId>org.example</groupId>
<artifactId>cookie</artifactId>
<version>1.0-SNAPSHOT</version>
<build>
<plugins>
<plugin>
<groupId>org.mortbay.jetty</groupId>
<artifactId>maven-jetty-plugin</artifactId>
<version>6.1.7</version>
<configuration>
<connectors>
<connector implementation="org.mortbay.jetty.nio.SelectChannelConnector">
<port>8888</port>
<maxIdleTime>30000</maxIdleTime>
</connector>
</connectors>
<webAppSourceDirectory>${project.build.directory}/${pom.artifactId}-${pom.version}</webAppSourceDirectory>
<contextPath>/</contextPath>
</configuration>
</plugin>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<configuration>
<source>6</source>
<target>6</target>
</configuration>
</plugin>
</plugins>
</build>
<dependencies>
<!--dependency>
<groupId>org.example</groupId>
<artifactId>[the artifact id of the block to be mounted]</artifactId>
<version>1.0-SNAPSHOT</version>
</dependency-->
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.11</version>
<scope>test</scope>
</dependency>
<!-- https://mvnrepository.com/artifact/javax.servlet/javax.servlet-api -->
<dependency>
<groupId>javax.servlet</groupId>
<artifactId>javax.servlet-api</artifactId>
<version>4.0.0</version>
<scope>provided</scope>
</dependency>
<!-- https://mvnrepository.com/artifact/mysql/mysql-connector-java -->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>5.1.44</version>
</dependency>
<!-- https://mvnrepository.com/artifact/com.alibaba/druid -->
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>druid</artifactId>
<version>1.0.9</version>
</dependency>
<!-- https://mvnrepository.com/artifact/com.alexkasko.springjdbc/springjdbc-iterable -->
<dependency>
<groupId>com.alexkasko.springjdbc</groupId>
<artifactId>springjdbc-iterable</artifactId>
<version>1.0.3</version>
</dependency>
<dependency>
<groupId>org.junit.jupiter</groupId>
<artifactId>junit-jupiter</artifactId>
<version>RELEASE</version>
<scope>compile</scope>
</dependency>
<dependency>
<groupId>org.testng</groupId>
<artifactId>testng</artifactId>
<version>RELEASE</version>
<scope>compile1</scope>
</dependency>
<!-- https://mvnrepository.com/artifact/commons-beanutils/commons-beanutils -->
<dependency>
<groupId>commons-beanutils</groupId>
<artifactId>commons-beanutils</artifactId>
<version>1.8.0</version>
</dependency>
<!-- https://mvnrepository.com/artifact/com.google.code.gson/gson -->
<dependency>
<groupId>com.google.code.gson</groupId>
<artifactId>gson</artifactId>
<version>2.8.5</version>
</dependency>
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<version>1.18.0</version>
</dependency>
<dependency>
<groupId>com.thetransactioncompany</groupId>
<artifactId>cors-filter</artifactId>
<version>2.4</version>
</dependency>
<dependency>
<groupId>com.thetransactioncompany</groupId>
<artifactId>java-property-utils</artifactId>
<version>1.9.1</version>
</dependency>
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>fastjson</artifactId>
<version>1.2.58</version>
</dependency>
</dependencies>
</project>
doMain层（Javabean实例）
- 众所周知，java中会建立一个对象来存储数据库里的信息，一般是一个表对应一个类对象，这一点比较方便，对于后面的调用来说，下面给出代码片
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
@AllArgsConstructor
@Data
@NoArgsConstructor
public class UserInfo {
String user_name;
String user_phone;
String user_password;
String user_e_mail;
@Override
public String toString() {
return "UserInfo{" +
"userName='" + user_name + '\'' +
", telephone='" + user_phone + '\'' +
", password='" + user_password + '\'' +
", e_mail='" + user_e_mail + '\'' +
'}';
}
}
- R规范，就是返回给前端的一个数据规范，分为三个板块，第一个就是code，及状态码，然后第二个就是message，及信息，比如说是否成功，我习惯在这里放一个字符串，最后一个部分就是一个用户信息，比如说token值，或者是用户的用户名，下面给出代码片
package com.doMain;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
@AllArgsConstructor
@Data
@NoArgsConstructor
public class R {
private int code;
private Object message;
private Object data;
}
声明一下，这里的注释就是用来自动创建get 和 set 方法的，当然还有构造方法，只要在pom文件里添加了相应的依赖就可以用这种快捷方法
util层（JDBC链接工具）
- 众所周知，我们在用druid链接池链接jdbc的时候要通过一个工具类把一些方法给封装起来，然后再直接通过调用这个类里的方法，从而快速的获取数据库链接，和关闭数据库链接，等操作，下面给出代码片
import com.alibaba.druid.pool.DruidDataSourceFactory;
import javax.sql.DataSource;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.Properties;
/**
* JDBC工具类，使用Druid连接池
*/
public class JBDCUtils {
private static DataSource ds;
static{
//1.加载配置文件
Properties pro = new Properties();
try {
//用ClassLoader来加载配置文件，获取字节输入流，键值对集合
pro.load(JBDCUtils.class.getClassLoader().getResourceAsStream("Druid1.properties"));
//初始化连接池对象，返回DataSource资源
ds = DruidDataSourceFactory.createDataSource(pro);
} catch (Exception e) {
e.printStackTrace();
}
}
/**
* 获取Connection对象
* @return
* @throws SQLException
*/
public static Connection getConnection() throws SQLException {
return ds.getConnection();
}
/**
* 关闭资源的方法
* @param rs
* @param stmt
* @param conn
*/
public static void close(ResultSet rs, Statement stmt, Connection conn){
if(rs != null){
try {
rs.close();
} catch (SQLException throwables) {
throwables.printStackTrace();
}
}
if(stmt != null){
try {
stmt.close();
} catch (SQLException throwables) {
throwables.printStackTrace();
}
}
if(conn != null){
try {
conn.close(); //归还链接
} catch (SQLException throwables) {
throwables.printStackTrace();
}
}
}
public static void close1( Statement stmt, Connection conn){
close(null,stmt,conn);
}
/**
* 获取连接池对象
* @return DataSource资源
*/
public static DataSource getdatasourse() {
return ds;
}
}
- 同时在于java同级目录”resource“目录下新建一个文件名为”Druid1.properties“这是Druid的配置文件，这里面要写你想要链接数据库的信息，用户名还有密码等一些数据。下面给出代码片。
driverClassName=com.mysql.jdbc.Driver
url=jdbc:mysql://123.57.143.40:3306/test
username=root
password=2Lm54J7b7C8y97
# 初始化连接数量
initialSize=5
# 最大连接数
maxActive=10
# 最大超时时间
maxWait=3000
UserDao层
- 这一层是用来写一些操作数据库的方法，话不多说，这就给出代码块儿。
package com.dao;
import com.doMain.UserInfo;
import com.util.JBDCUtils;
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.JdbcTemplate;
/**
* 操作User类
*/
public class UserDao {
//声明JBDCTemplate对象来公用
private final JdbcTemplate template = new JdbcTemplate(JBDCUtils.getdatasourse());
public UserInfo searchAll(){
try {
String sql = "select * from userInfo";
//调用query方法
UserInfo users = template.queryForObject(sql,
new BeanPropertyRowMapper<UserInfo>(UserInfo.class));
return users;
}catch (Exception e){
e.printStackTrace();
return null;
}
}
/**
* 注册方法
*/
public boolean register(UserInfo user){
try {
String sql = "insert into userInfo (user_name,user_phone,user_password,e_mail) values(?,?,?,?)";
//调用query方法
template.update(sql,user.getUser_name(),user.getUser_phone(),user.getUser_password(),user.getUser_e_mail());
return true;
}catch (Exception e){
e.printStackTrace();
return false;
}
}
/**
* 设置token方法
*/
public boolean set_token(UserInfo user,String token){
try {
String sql = "update `userInfo` set `user_token`=? where `user_name`=?;";
//调用query方法
template.update(sql,token,user.getUser_name());
return true;
}catch (Exception e){
e.printStackTrace();
return false;
}
}
}
main层
- loginServlet，登录接口代码
// A code block
var foo = 'bar';
```package com.mian;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.dao.UserDao;
import com.doMain.R;
import com.doMain.UserInfo;
import com.util.JBDCUtils;
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.JdbcTemplate;
import javax.servlet.ServletContext;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.List;
import java.util.UUID;
@WebServlet("/login")
public class LoginServlet extends HttpServlet {
private final JdbcTemplate template = new JdbcTemplate(JBDCUtils.getdatasourse());
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
resp.setCharacterEncoding("UTF-8");
resp.setContentType("text/html;charset=UTF-8");
resp.setHeader("Access-Control-Allow-Origin","*");
resp.setHeader("Access-Control-Allow-Method","POST,GET");
BufferedReader br = new BufferedReader(new InputStreamReader(req.getInputStream(), "utf-8"));
StringBuffer sb = new StringBuffer("");
String temp;
while ((temp = br.readLine()) != null) {
sb.append(temp);
}
br.close();
String param = sb.toString();
JSONObject json = JSONObject.parseObject(param);
String username = (String) json.get("username"); // 从 request 中获取名为 username 的参数的值
String password = (String) json.get("password"); // 从 request 中获取名为 password 的参数的值
String captcha = (String) json.get("code"); // 从 request 中获取名为 captcha 的参数的值
ServletContext application=req.getServletContext();
String real_captcha = (String)application.getAttribute("real_captcha");
PrintWriter out = resp.getWriter();
System.out.println("code:" + captcha + "\nreal_captcha:" + real_captcha);
System.out.println("username:" + username + "\npassword:" + password); // 打印出来看一看
resp.setContentType("text/html;charset=utf-8"); // 设置响应报文的编码格式
/**
* 连接数据库，进行登陆操作
*/
if (!captcha.equals(real_captcha)) {
R r = new R(105, "验证码错误", username);
String info = JSON.toJSONString(r);
// 打印出檢查
System.out.println(info);
// 返回給前端
out.write(info);
} else {
UserDao userDao = new UserDao();
String item1, item2;
boolean flag = true;
String sql12 = "select * from userInfo";
List<UserInfo> list = template.query(sql12, new BeanPropertyRowMapper<UserInfo>(UserInfo.class));
for (UserInfo users : list) {
System.out.println(users.getUser_name() + " " + users.getUser_password());
// if (users.getUserName().equals(username) && users.getUser_password().equals(password)) {
item1 = users.getUser_name();
item2 = users.getUser_password();
if (username.equals(item1) && password.equals(item2)) {
String token = UUID.randomUUID() + "";
flag = false;
userDao.set_token(users,token);
R r = new R(200, "success", token);
String info = JSON.toJSONString(r);
// 打印出檢查
System.out.println(info);
// 返回給前端
out.write(info);
break;
}
}
if (flag) {
R r = new R(104, "fail", username);
String info = JSON.toJSONString(r);
// 打印出檢查
System.out.println(info);
// 返回給前端
out.write(info)；
}
}
}
}
2. registerServlet登录接口代码
package com.mian;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.dao.UserDao;
import com.doMain.R;
import com.doMain.UserInfo;
import com.util.JBDCUtils;
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.JdbcTemplate;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.List;
@WebServlet("/register")
public class registerServlet extends HttpServlet {
private final JdbcTemplate template = new JdbcTemplate(JBDCUtils.getdatasourse());
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
resp.setCharacterEncoding("UTF-8");
resp.setContentType("text/html;charset=UTF-8");
BufferedReader br = new BufferedReader(new InputStreamReader(req.getInputStream(), "utf-8"));
StringBuffer sb = new StringBuffer("");
String temp;
while ((temp = br.readLine()) != null) {
sb.append(temp);
}
br.close();
String param = sb.toString();
JSONObject json = JSONObject.parseObject(param);
String username = (String) json.get("username"); // 从 request 中获取名为 account 的参数的值
String password = (String) json.get("password"); // 从 request 中获取名为 password 的参数的值
String telephone = (String) json.get("telephone"); // 从 request 中获取名为 account 的参数的值
String e_mail = (String) json.get("e_mail"); // 从 request 中获取名为 password 的参数的值
String result = null;
resp.setContentType("text/html;charset=UTF-8");
PrintWriter out = resp.getWriter();
boolean flag = true;String item;
R r = null;
String sql12 = "select * from userInfo";
List<UserInfo> list = template.query(sql12, new BeanPropertyRowMapper<UserInfo>(UserInfo.class));
for (UserInfo users : list) {
System.out.println(users.getUser_name() + " " + users.getUser_password());
item = users.getUser_name();
if (username.equals(item)){
result = "抱歉，此用户名已经注册过，不能再次注册";
System.out.println(result);
r = new R(104, "fail", username);
flag = false;
break;
}
}
if(flag){
UserInfo userInfo = new UserInfo(username,telephone,password,e_mail);
UserDao userDao = new UserDao();
boolean register = userDao.register(userInfo);
if(register){
result = "注册成功";
}else{
result = "注册失败";
}
System.out.println(result);
r = new R(200, "success", username);
}
String info = JSON.toJSONString(r);
out.write(info);
out.close();
}
}
3. CaptchaServlet验证码接口代码（传递一个图像给前台）
package com.mian;
import javax.imageio.ImageIO;
import javax.servlet.ServletContext;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.awt.*;
import java.awt.image.BufferedImage;
import java.io.IOException;
import java.util.Random;
/**
-
验证码验证信息
/
@WebServlet("/captcha")
public class CaptchaServlet extends HttpServlet {
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
resp.setCharacterEncoding(“UTF-8”);
resp.setContentType(“text/html;charset=UTF-8”);
System.out.println(“demo6_doPost运行中”);
int width=100,height=50;
StringBuffer sb = new StringBuffer();
//创建对象，存入验证码(验证码对象)
BufferedImage image = new BufferedImage(width,height,BufferedImage.TYPE_INT_RGB);
//美化图片，美滋滋
Graphics g = image.getGraphics();
g.setColor(Color.PINK);
g.fillRect(0,0,width,height);
//画出来边框
g.setColor(Color.BLUE);
g.drawRect(0,0,width-1,height-1);
String str = “QWERTYUIOPASDFGHJKLZXCVBNMqwertyuiopasdfghjklzxcvbnm0123456789”;
//生成随机角标，然后通过随机角标来确定这四个字母
Random ran = new Random();
for (int i = 1; i <= 4; i++) {
int index = ran.nextInt(str.length());
char ch = str.charAt(index);
sb.append(ch);
g.drawString(ch+"",width/5i,height/2);
}
ServletContext application=req.getServletContext();
application.setAttribute(“real_captcha”,sb.toString());//画干扰线 g.setColor(Color.GREEN); for (int i = 0; i < 10; i++) { int x1 = ran.nextInt(width); int x2 = ran.nextInt(width); int y1 = ran.nextInt(width); int y2 = ran.nextInt(width); g.drawLine(x1,y1,x2,y2); } //将图片输出到页面进行展示 ImageIO.write(image,"jpg",resp.getOutputStream());}
}
4. searchallServlet接口代码
package com.mian;
import com.alibaba.fastjson.JSON;
import com.doMain.R;
import com.doMain.UserInfo;
import com.util.JBDCUtils;
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.JdbcTemplate;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.List;
@WebServlet("/searchall")
public class SearchAllServlet extends HttpServlet {
private final JdbcTemplate template = new JdbcTemplate(JBDCUtils.getdatasourse());
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
resp.setCharacterEncoding("UTF-8");
resp.setContentType("text/html;charset=UTF-8");
String sql12 = "select * from userInfo";
List<UserInfo> list = template.query(sql12, new BeanPropertyRowMapper<UserInfo>(UserInfo.class));
R r ;
if(!list.isEmpty()) {
r = new R(200, "success", list);
}else{
r = new R(104, "success", "无用户");
}
PrintWriter out = resp.getWriter();
String info = JSON.toJSONString(r);
// 打印出檢查
System.out.println(info);
// 返回給前端
out.write(info);
}
这些main层中的代码进行了大部分的操作，例如用JSONObject json = JSONObject.parseObject(param);等代码，将前台传递给后台的JSON格式的数据转化为正常的数据，然后再放到数据库中进行比较，其中验证码的后端接口会传递一个图像给前台，同时把真正的验证码传递给登录接口，进行验证码的验证。在写完这些代码之后，打包进行上传服务器就行了，或者可以直接在IDEA上运行Tomcat在本地测试，如果打包到服务器上，就进行服务器的真正测试。
测试（Postman）
Postman安装
- 官网下载：地址：https://www.getpostman.com/downloads/，选择页面中的“Download”，根据自己电脑配置，选择32位下载还是64位下载
- 下载好之后直接双击安装包，因为是免费软件，所以安装比较简单，在此不再赘述，安装好了之后如果出现以下界面，则说明安装完成。
Postman使用教程
- 小试牛刀：打开Postman之后先新建一个测试，就是工具栏下面那个加号，就可以快速创建一个测试，然后这几个地方需要注意，一就是先选项请求的方法，Get方法还是Post方法，然后就是输入URL地址，这个URL地址是有很多部分构成的：协议+IP+端口号+虚拟路径+请求参数。接下来我会详细的讲述一下这个URL地址的每个部分的内容。
协议：我们这里用http协议，如果默认使用https协议就容易报错。
IP地址：如果在本机上测试IP地址就是localhost，如果是在服务器上就是你服务器的IP地址。
端口号：这个端口号指的是你在Tomocat中设置的端口号，而且要注意一定要在服务器上把这个端口号也打开，要不然会报错。
虚拟路径：这个也是有两种情况，如果在本机上的话，在IDER中就可以设置虚拟路径的前半段就是下图标注的地方，可以设置虚拟路径，同时你的每个Servlet也会有一个虚拟路径，那个是后半段，本机上的虚拟路径就是这么组成的。
例如我这里的虚拟路径前半段为空然后我在Servlet中设置的虚拟路径为“/login”，在这时，就需要在Postman中输入路径：“http://localhost:8080/register”，当然我们在服务器上的路径大部分的内容和这里一样，唯一需要注意的地方就是虚拟路径前面必须加上打包之后的文件的名称在加上虚拟路径的后半段，这样才能准确的访问到这个接口，例如我打包之后的文件名为javaweb然后我的URL路径就是“http://123.57.143.89:8080/javaweb/register”，当然我这里的IP地址不是真的，你需要在这里写上你自己服务器上的IP地址。 
-
参数传递：这一块儿困扰了我好久，是一个大坑，第一次接触前后端交互的我一头栽进了这个大坑中，无法脱身，还好有导师的指导才得以解决这个比较浅显又难以察觉的问题，第一种参数是这种，一个值一个值传递的这种参数，如图
还有一种参数是以JSON格式传递的，大部分的前后端交互的时候都是这种JSON形式的参数传递，毕竟JSON这种数据就是用来做前后端交互的，前端给后端的时候是JSON，同理，后端给前端的时候也是JSON格式的数据，如图
-
实现接口：现在，万事俱备，只欠东风，点击右侧的Send按钮，提交数据，如果出现下面图像说明接口链接成功，返回了三个值，一个code是状态码，这个状态码如果是200则代表参数请求成功，如果是别的则代表请求失败，例如我这里就是注册的接口，我这里规定的是不能有重复的用户名，如果用户名重复则返回104说明参数传递失败，如果用户注册成功，返回200，还有这个用户的用户名，还有一个字符串“success” 。
最后总结
那么现在我们就实现了在本机和服务器上的接口实现，当然服务器部分内容在这里没有细说，因为那块儿确实东西比较多，我会另外做一期番外篇讲一讲服务器的一些操作，细说(suo)细说(suo)。这篇文章是第一阶段的最终章，下面就要开始Spring以及Mybatis的学习了，我也会不定期的坚持更新。这算上我写的一个真正的后端代码，尽管其中的分层不是很严密，没有明显的Controller层和Service层，有的地方查询也比较费时，但是这些小细节在以后的后端代码中一定会注意。还希望喜欢后端的朋友们不要放弃，坚持学习，一定会得到自己想要的成果，你我共勉，加油。
4444
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
