上一小节我们完成了数据库的设计和创建，也向数据表中插入了一些初始数据，本小节我们将开始具体业务代码的实现，如果大家还没有完成上一小节的任务，请务必先完成再来学习本节内容。

1. 准备工作

在开始正式编码之前，我们要做一些准备工作，主要是环境的搭建和工具类的引入。

1.1 创建 Maven 工程

打开 idea，点击Create new Project按钮
3.jpg
在左侧栏选择Maven，Project SDK选择14，勾选Create from archetype复选框，再选择maven-archetype-quickstart，表示创建一个简单 Java 应用，点击next按钮
4.jpg
输入项目名称goods，将项目路径设置为本地桌面，GroupId可根据实际情况自定义，此处我设置为com.ouchaochao，其余输入框无需修改，采用默认即可，设置完成后，点击next按钮
1.png
这一步来到Maven配置，idea自带了Maven，我们使用默认的即可，直接点击Finish按钮完成项目创建
2.png
此时，Maven会进行一些初始化配置，右下角对话框选择Enable Auto-import按钮，表示允许自动导入依赖
6.png
稍等片刻，待看到左侧项目的目录结构已经生成好了，及表示已完成项目的初始化工作
1.png

1.2 引入 MySQL 驱动

接下来引入mysql-connector-java驱动，由于我本地安装的MySQL版本为8.0.21，因此mysql-connector-java的版本号也选择8.0.21，大家根据自己实际情况选择对应版本。
打开pom.xml文件，在节点内插入如下xml：

  1. <!-- https://mvnrepository.com/artifact/mysql/mysql-connector-java -->
  2. <dependency>
  3.     <groupId>mysql</groupId>
  4.     <artifactId>mysql-connector-java</artifactId>
  5.     <version>8.0.21</version>
  6. </dependency>

3.jpg
由于我们已经配置了允许自动导入依赖，稍等片刻，mysql-connector-java 8.0.21就会被成功导入。可在idea右侧点击Maven按钮查看项目的依赖关系：
3.jpg

1.3 引入 JDBC 工具类

JDBC 相关操作是本项目的最常用的操作，我封装了一个 JDBC 的工具类，主要通过 Java 的 JDBC API 去访问数据库，提供了加载配置、注册驱动、获得资源以及释放资源等接口。
大家可以到我的Github仓库下载这个 JDBCUtil类；也可以直接复制下面的代码：

  1. package com.ouchaochao.util;
  3. import java.io.IOException;
  4. import java.io.InputStream;
  5. import java.sql.*;
  6. import java.util.Properties;
  8. /**
  9.  * @author colorful@TaleLin
  10.  */
  11. public class JDBCUtil {
  13.     private static final String driverClass;
  14.     private static final String url;
  15.     private static final String username;
  16.     private static final String password;
  18.     static {
  19.         // 加载属性文件并解析
  20.         Properties props = new Properties();
  21.         // 使用类的加载器的方式进行获取配置
  22.         InputStream inputStream = JDBCUtil.class.getClassLoader().getResourceAsStream("jdbc.properties");
  23.         try {
  24.             assert inputStream != null;
  25.             props.load(inputStream);
  26.         } catch (IOException e) {
  27.             e.printStackTrace();
  28.         }
  30.         driverClass = props.getProperty("driverClass");
  31.         url = props.getProperty("url");
  32.         username = props.getProperty("username");
  33.         password = props.getProperty("password");
  34.     }
  36.     /**
  37.      * 注册驱动
  38.      */
  39.     public static void loadDriver() throws ClassNotFoundException{
  40.         Class.forName(driverClass);
  41.     }
  43.     /**
  44.      * 获得连接
  45.      */
  46.     public static Connection getConnection() throws Exception{
  47.         loadDriver();
  48.         return DriverManager.getConnection(url, username, password);
  49.     }
  51.     /**
  52.      * 资源释放
  53.      */
  54.     public static void release(PreparedStatement statement, Connection connection){
  55.         if(statement != null){
  56.             try {
  57.                 statement.close();
  58.             } catch (SQLException e) {
  59.                 e.printStackTrace();
  60.             }
  61.             statement = null;
  62.         }
  63.         if(connection != null){
  64.             try {
  65.                 connection.close();
  66.             } catch (SQLException e) {
  67.                 e.printStackTrace();
  68.             }
  69.             connection = null;
  70.         }
  71.     }
  73.     /**
  74.      * 释放资源 重载方法
  75.      */
  76.     public static void release(ResultSet rs, PreparedStatement stmt, Connection conn){
  77.         if(rs!= null){
  78.             try {
  79.                 rs.close();
  80.             } catch (SQLException e) {
  81.                 e.printStackTrace();
  82.             }
  83.             rs = null;
  84.         }
  85.         if(stmt != null){
  86.             try {
  87.                 stmt.close();
  88.             } catch (SQLException e) {
  89.                 e.printStackTrace();
  90.             }
  91.             stmt = null;
  92.         }
  93.         if(conn != null){
  94.             try {
  95.                 conn.close();
  96.             } catch (SQLException e) {
  97.                 e.printStackTrace();
  98.             }
  99.             conn = null;
  100.         }
  101.     }
  103. }

我本地将这个类放在了 com.ouchaochao.util包下，大家可根据自身情况随意放置。另外，由于该类在静态代码块中加载了配置文件jdbc.properties，需要在resource下面新建一个 jdbc.properties文件，并写入一下内容：

  1. driverClass=com.mysql.cj.jdbc.Driver
  2. url=jdbc:mysql:///im_goods_cms?serverTimezone=Asia/Shanghai&characterEncoding=UTF8
  3. username=root
  4. password=123456

我将数据放到了本地系统中，并且启动端口是默认 3306，大家根据自己的MySQL实际配置自行修改。

1.4 测试代码

为了测试我们的数据库配置以及 JDBCUtil 类是否成功引入，现在到 test 目录下，新建一个 JDBCTest 类：

  1. package com.ouchaochao;
  3. import com.ouchaochao.util.JDBCUtil;
  4. import org.junit.Test;
  6. import java.sql.Connection;
  7. import java.sql.PreparedStatement;
  8. import java.sql.ResultSet;
  9. import java.sql.Timestamp;
  11. public class JDBCTest {
  13.     @Test
  14.     public void testJDBC() {
  15.         Connection connection = null;
  16.         PreparedStatement preparedStatement = null;
  17.         ResultSet resultSet = null;
  18.         try {
  19.             // 获得链接
  20.             connection = JDBCUtil.getConnection();
  21.             // 编写 SQL 语句
  22.             String sql = "SELECT * FROM `im_user` where `id` = ?";
  23.             // 预编译 SQL
  24.             preparedStatement = connection.prepareStatement(sql);
  25.             // 设置参数
  26.             preparedStatement.setInt(1, 1);
  27.             resultSet = preparedStatement.executeQuery();
  28.             if (resultSet.next()) {
  29.                 int id = resultSet.getInt("id");
  30.                 String nickname = resultSet.getString("nickname");
  31.                 Timestamp createTime = resultSet.getTimestamp("create_time");
  32.                 System.out.println("id=" + id);
  33.                 System.out.println("nickname=" + nickname);
  34.                 System.out.println("createTime=" + createTime);
  35.             }
  36.         } catch (Exception e) {
  37.             e.printStackTrace();
  38.         } finally {
  39.             // 释放资源
  40.             JDBCUtil.release(resultSet, preparedStatement, connection);
  41.         }
  42.     }
  44. }

如果配置成功，运行单元测试，将得到如下运行结果：

  1. id=1
  2. nickname=小慕
  3. createTime=2020-07-20 16:53:19.0

下面为运行截图：
1.png

2. 系统架构

本商品管理系统的包结构如下：

  1. src
  2. ├── main       
  3. │   ├── java    # 源码目录
  4. │   │   └── com
  5. │   │       └── ouchaochao
  6. │   │           ├── App.java    # 入口文件
  7. │   │           ├── dao         # 数据访问对象（Data Access Object，提供数据库操作的一些方法)
  8. │   │           ├── model       # 实体类（类字段和数据表字段一一对应）
  9. │   │           ├── service     # 服务层（提供业务逻辑层服务）
  10. │   │           └── util        # 一些帮助类
  11. │   └── resources
  12. │       ├── im_goods_cms.sql # 建表的 SQL 文件
  13. │       └── jdbc.properties     # jdbc 配置文件
  14. └── test       # 单元测试目录
  15.     └── java
  16.         └── com
  17.             └── ouchaochao
  18.                 ├── AppTest.java
  19.                 └── JDBCTest.java

大家可以提前熟悉一下本项目的项目结构，下面我们会一一讲解。

3. 实体类

实体类的作用是存储数据并提供对这些数据的访问。在我们这个项目中，实体类统一被放到了model包下，通常情况下，实体类中的属性与我们的数据表字段一一对应。当我们编写这些实体类的时候，建议对照着数据表的字段以防疏漏。

3.1 BaseModel

在我们数据表中，有几个公共的字段，可以提取出一个实体类的父类 BaseModel ，并提供 getter 和 setter，源码如下：

  1. package com.ouchaochao.model;
  3. import java.sql.Timestamp;
  5. public class BaseModel {
  7.     private Integer id;
  9.     private Timestamp createTime;
  11.     private Timestamp updateTime;
  13.     private Timestamp deleteTime;
  15.     public Integer getId() {
  16.         return id;
  17.     }
  19.     public void setId(Integer id) {
  20.         this.id = id;
  21.     }
  23.     public Timestamp getCreateTime() {
  24.         return createTime;
  25.     }
  27.     public void setCreateTime(Timestamp createTime) {
  28.         this.createTime = createTime;
  29.     }
  31.     public Timestamp getUpdateTime() {
  32.         return updateTime;
  33.     }
  35.     public void setUpdateTime(Timestamp updateTime) {
  36.         this.updateTime = updateTime;
  37.     }
  39.     public Timestamp getDeleteTime() {
  40.         return deleteTime;
  41.     }
  43.     public void setDeleteTime(Timestamp deleteTime) {
  44.         this.deleteTime = deleteTime;
  45.     }
  47. }

值得注意的是，Timestamp是java.sql下的类。

3.2 实体类编写

接下来，再在model包下新建 3 个类：User、Goods 和 Category，并提供getter 和 setter 。如下是每个类的代码：

  1. package com.ouchaochao.model;
  3. public class User extends BaseModel {
  5.     private String userName;
  7.     private String nickName;
  9.     private String password;
  11.     public String getUserName() {
  12.         return userName;
  13.     }
  15.     public void setUserName(String userName) {
  16.         this.userName = userName;
  17.     }
  19.     public String getNickName() {
  20.         return nickName;
  21.     }
  23.     public void setNickName(String nickName) {
  24.         this.nickName = nickName;
  25.     }
  27.     public String getPassword() {
  28.         return password;
  29.     }
  31.     public void setPassword(String password) {
  32.         this.password = password;
  33.     }
  35. }
  1. package com.ouchaochao.model;
  3. public class Goods extends BaseModel {
  5.     private String name;
  7.     private String description;
  9.     private Integer categoryId;
  11.     private Double price;
  13.     private Integer stock;
  15.     public String getName() {
  16.         return name;
  17.     }
  19.     public void setName(String name) {
  20.         this.name = name;
  21.     }
  23.     public String getDescription() {
  24.         return description;
  25.     }
  27.     public void setDescription(String description) {
  28.         this.description = description;
  29.     }
  31.     public Integer getCategoryId() {
  32.         return categoryId;
  33.     }
  35.     public void setCategoryId(Integer categoryId) {
  36.         this.categoryId = categoryId;
  37.     }
  39.     public Double getPrice() {
  40.         return price;
  41.     }
  43.     public void setPrice(Double price) {
  44.         this.price = price;
  45.     }
  47.     public Integer getStock() {
  48.         return stock;
  49.     }
  51.     public void setStock(Integer stock) {
  52.         this.stock = stock;
  53.     }
  55. }
  1. package com.ouchaochao.model;
  3. public class Category extends BaseModel {
  5.     private String name;
  7.     private String description;
  9.     public String getName() {
  10.         return name;
  11.     }
  13.     public void setName(String name) {
  14.         this.name = name;
  15.     }
  17.     public String getDescription() {
  18.         return description;
  19.     }
  21.     public void setDescription(String description) {
  22.         this.description = description;
  23.     }
  25. }

4. 实现用户鉴权

4.1 登录方式

想要使用系统进行商品管理，第一步要做的就是登录。
我们的系统使用用户名和密码进行登录校验，上一小节我们已经建立了im_user表，并向表中插入了一个用户 admin，其密码为 123456 。显然，通过如下SQL就可以查询到该用户：

  1. SELET * FROM `im_user` WHERE `username` = 'admin' AND password = '123456';

如果查询到这个用户，就表示用户名密码通过校验，用户可执行后续操作，如果没有查到，就要提示用户重新输入账号和密码。

4.2 数据访问对象

我们先不管用户是如何输入账号密码的，接下来要编写的业务代码就是根据用户名和密码去查询用户。那么涉及到数据库查询的代码应该放到哪里呢？参考上面的系统架构图，DAO是数据访问对象，我们可以在dao包下面新建一个UserDAO，并写入如下代码：

  1. package com.ouchaochao.dao;
  3. import com.ouchaochao.model.User;
  4. import com.ouchaochao.util.JDBCUtil;
  6. import java.sql.Connection;
  7. import java.sql.PreparedStatement;
  8. import java.sql.ResultSet;
  10. public class UserDAO {
  12.     public User selectByUserNameAndPassword(String username, String password) {
  13.         Connection connection = null;
  14.         PreparedStatement preparedStatement = null;
  15.         ResultSet resultSet = null;
  16.         User user = new User();
  17.         try {
  18.             // 获得链接
  19.             connection = JDBCUtil.getConnection();
  20.             // 编写 SQL 语句
  21.             String sql = "SELECT * FROM `im_user` where `username` = ? AND `password` = ? AND `delete_time` is null ";
  22.             // 预编译 SQL
  23.             preparedStatement = connection.prepareStatement(sql);
  24.             // 设置参数
  25.             preparedStatement.setString(1, username);
  26.             preparedStatement.setString(2, password);
  27.             resultSet = preparedStatement.executeQuery();
  28.             if (resultSet.next()) {
  29.                 user.setId(resultSet.getInt("id"));
  30.                 String nickname = resultSet.getString("nickname");
  31.                 if (nickname.equals("")) {
  32.                     nickname = "匿名";
  33.                 }
  34.                 user.setNickName(nickname);
  35.                 user.setUserName(resultSet.getString("username"));
  36.             } else {
  37.                 user = null;
  38.             }
  39.         } catch (Exception e) {
  40.             e.printStackTrace();
  41.         } finally {
  42.             // 释放资源
  43.             JDBCUtil.release(resultSet, preparedStatement, connection);
  44.         }
  45.         return user;
  46.     }
  48. }

UserDAO 类下面有一个 selectByUserNameAndPassword()方法， 接收两个参数 username 和 password，返回值类型是实体类 User，如果没有查询到，返回的是一个 null。
完成了 UserDAO 的编写，我们需要到服务层 service包下，新建一个 UserService ，并写入如下代码：

  1. package com.ouchaochao.service;
  3. import com.ouchaochao.dao.UserDAO;
  4. import com.ouchaochao.model.User;
  6. public class UserService {
  8.     private final UserDAO userDAO = new UserDAO();
  10.       // 登陆
  11.     public User login(String username, String password) {
  12.         return userDAO.selectByUserNameAndPassword(username, password);
  13.     }
  15. }

到这里大家可能有些疑问，这个类下面的login()方法，直接调用了我们刚刚编写的 DAO 下面的 selectByUserNameAndPassword() 方法，为什么还要嵌套这么一层么？这不是多此一举么？
要讨论 service 层的封装是不是过度设计，就要充分理解设计服务层的概念和意义，服务层主要是对业务逻辑的封装，对于更为复杂的项目，用户登录会有更多的方式，因此在服务层，会封装更多的业务逻辑。如果没有服务层，这些复杂的逻辑不得不都写在数据访问层，显然这是不合理的。我们现在这个项目没有使用任何框架，等到后面大家学习了Spring这种框架，一定会对这样的分层的好处有所体会。

4.3 使用 Scanner 类与用户交互

完成了上面一系列的封装，就剩下我们和用户的交互了，本项目中，我们使用 Scanner 类来接收用户的输入，并使用print()方法向屏幕输出。
打开 App.java 入口文件，创建UserService实例，编写一个主流程方法 run()，并在入口方法 main()中调用该方法：

  1. package com.ouchaochao;
  3. import com.ouchaochao.model.User;
  4. import com.ouchaochao.service.UserService;
  6. import java.util.Scanner;
  8. /**
  9.  * Im Goods
  10.  */
  11. public class App {
  13.     private static final UserService userService = new UserService();
  15.     /**
  16.      * 主流程方法
  17.      */
  18.     public static void run() {
  19.         User user = null;
  20.         System.out.println("欢迎使用商品管理系统，请输入用户名和密码：");
  21.         do {
  22.             Scanner scanner = new Scanner(System.in);
  23.             // 登录
  24.             System.out.println("用户名：");
  25.             String username = scanner.nextLine();
  26.             System.out.println("密码：");
  27.             String password = scanner.nextLine();
  28.             user = userService.login(username, password);
  29.             if (user == null) {
  30.                 System.out.println("用户名密码校验失败，请重新输入！");
  31.             }
  32.         } while (user == null);
  33.         System.out.println("欢迎您！" + user.getNickName());
  34.         // TODO 登录成功，编写后续逻辑
  35.     }
  37.     public static void main( String[] args )
  38.     {
  39.         run();
  40.     }
  41. }

run()方法中有一个 do … while循环，循环的条件是 user 对象为 null。
我们知道，do… while循环会首先执行 do 中的循环体，循环体中创建了一个 Scanner 类的实例，获取到用户的输入后，我们会调用用户服务层的login()方法，该方法返回实体类对象User，如果其为 null表示用户名密码校验失败，需要用户重新输入， user == null，满足循环的条件，会一直执行循环体中的代码。直到循环体中的 user不为 null （也就是用户登录校验成功后）才终止循环。
3.jpg
如果用户名密码检验错误，就要反复输入用户名密码重新登录。
如下为登录成功的截图：
4.jpg

5. 小结

在本小节，我们成功搭建了项目工程，通过实现一个用户鉴权模块，介绍了整体的系统架构。我们在编写实体类的同时，复习了面向对象的继承性；在数据访问层，也复习了 JDBC API 的使用；在编写程序入口文件的同时，也复习了 Scanner 类的使用和循环的使用。
关于系统鉴权，这里还有一个待优化的地方，大家下去之后可以思考一下，在下一小节的开头，我将带领大家一起来优化。下一小节也将主要讲解最后剩余的商品模块和分类模块的实现，也会复习到很多其他方面的基础知识。