【2023】Kotlin教程第四篇项目实战第25章项目实战1：开发PetStore宠物商店项目 25.4 任务3：编写数据持久层代码

比眉伴天荒 2024-03-23 15:35 30阅读 0赞

### 【2023】Kotlin教程 ###

#### 文章目录 ####

*   *  【2023】Kotlin教程
     *   *  第四篇 项目实战
         *  第25章 项目实战1：开发PetStore宠物商店项目
         *   *  25.4 任务3：编写数据持久层代码
             *   *  25.4.1 迭代3.1：编写实体类
                 *  25.4.2 迭代3.2：编写DAO接口
                 *  25.4.3 迭代3.3：创建数据表类
                 *  25.4.4 迭代3.4：编写DAO实现类

![在这里插入图片描述][c7a364c1351c4c5098ae9d70da387f04.png_pic_center]

#### 第四篇 项目实战 ####

#### 第25章 项目实战1：开发PetStore宠物商店项目 ####

##### 25.4 任务3：编写数据持久层代码 #####

项目创建并初始化完成后，可以先编写数据持久层代码。

###### 25.4.1 迭代3.1：编写实体类 ######

无论是数据库设计还是面向对象的架构设计都会“实体”，“实体”是系统中的“人”、“事”、“物”等名词，如用户、商品、订单和订单明细等。在数据库设计时它将演变为表，如用户表（accounts）、商品表（products）、订单表（orders）和订单明细表（ordersdetails），在面向对象的架构设计时，实体将演变为“实体类”，如图28-10所示是PetStore宠物商店项目中的实体类，实体类属性与数据库表字段在是相似的，事实上它们描述的同一个事物，当然具有相同的属性，只是它们分别采用不同设计理念，实体类采用对象模型，表采用关系模式。

![在这里插入图片描述][337a9180a4634b55a7cfb94f40eb14fb.png_pic_center]

实体类没有别的操作，只有一些属性可以设计成为数据类。订单明细实体类OrderDetail代码如下：

package com.dingjiaxiong.petstore.domain
    
    /**
     * @Projectname: PetStore
     * @Classname: OrderDetail
     * @Author: Ding Jiaxiong
     * @Data:2023/4/6 20:49
     */
    
    import java.math.BigDecimal
    
    //订单明细
    data class OrderDetail(
        var orderid: Long = 0,          // 订单Id
        var productid: String? = null,  // 商品Id
        var quantity: Int = 0,          // 商品数量
        var unitcost: BigDecimal = BigDecimal(0)   // 单价
    )

订单实体类Order的代码如下：

package com.dingjiaxiong.petstore.domain
    
    /**
     * @Projectname: PetStore
     * @Classname: Order
     * @Author: Ding Jiaxiong
     * @Data:2023/4/6 20:50
     */
    
    import java.math.BigDecimal
    import java.util.*
    
    data class Order(
        var orderid: Long = 0,          // 订单Id
        var userid: String? = null,             // 下订单的用户Id
        var orderdate: Date? = null,            // 下订单时间
        var status: Int = 0,            // 订单付款状态 0待付款 1已付款
        var amount: BigDecimal = BigDecimal(0)       // 订单应付金额
    )

用户实体类Account的代码如下：

package com.dingjiaxiong.petstore.domain
    
    /**
     * @Projectname: PetStore
     * @Classname: Account
     * @Author: Ding Jiaxiong
     * @Data:2023/4/6 20:50
     */
    
    data class Account(
        var userid: String? = null,     // 用户Id
        var username: String? = null,   // 用户名
        var password: String? = null,   // 用户密码
        var phone: String? = null,      // 电话号码
        var country: String? = null,    //国家
        var city: String? = null,       // 所在城市
        var addr: String? = null,       // 地址
        var email: String? = null      // 用户Email
    )

商品实体类Product的代码如下：

package com.dingjiaxiong.petstore.domain
    
    /**
     * @Projectname: PetStore
     * @Classname: Product
     * @Author: Ding Jiaxiong
     * @Data:2023/4/6 20:51
     */
    
    import java.math.BigDecimal
    
    data class Product(
        var productid: String? = null,// 商品Id
        var category: String? = null,// 商品类别
        var cname: String? = null,// 商品中文名
        var ename: String? = null,// 商品英文名
        var image: String? = null,// 商品描述
        var descn: String? = null,// 商品描述
        var listprice: BigDecimal = BigDecimal(0),// 商品市场价
        var unitcost: BigDecimal = BigDecimal(0)// 商品单价
    )

###### 25.4.2 迭代3.2：编写DAO接口 ######

![在这里插入图片描述][3c1c4015ef5f4a6d9e04abaae4e438ba.png_pic_center]

根据类图编写持久层DAO 接口。

【1】用户管理DAO接口代码如下：

package com.dingjiaxiong.petstore.dao
    
    import com.dingjiaxiong.petstore.domain.Account
    
    /**
     * @Projectname: PetStore
     * @Classname: AccountDao
     * @Author: Ding Jiaxiong
     * @Data:2023/4/6 20:53
     */
    
    //用户管理DAO
    interface AccountDao {
        
    
        // 查询所有的用户信息
        fun findAll(): List<Account>
    
        // 根据主键查询用户信息
        fun findById(userid: String): Account?
    
        // 创建用户信息
        fun create(account: Account)
    
        // 修改用户信息
        fun modify(account: Account)
    
        // 删除用户信息
        fun remove(account: Account)
    }

【2】商品管理DAO接口代码如下：

package com.dingjiaxiong.petstore.dao
    
    import com.dingjiaxiong.petstore.domain.Product
    
    /**
     * @Projectname: PetStore
     * @Classname: ProductDao
     * @Author: Ding Jiaxiong
     * @Data:2023/4/6 20:54
     */
    
    //商品管理DAO
    interface ProductDao {
        
        // 查询所有的商品信息
        fun findAll(): List<Product>
    
        // 根据主键查询商品信息
        fun findById(productid: String): Product?
    
        // 根据按照列表查询商品信息
        fun findByCategory(category: String): List<Product>
    
        // 创建商品信息
        fun create(product: Product)
    
        // 修改商品信息
        fun modify(product: Product)
    
        // 删除商品信息
        fun remove(product: Product)
    
    }

【3】订单接口代码如下：

package com.dingjiaxiong.petstore.dao
    
    import com.dingjiaxiong.petstore.domain.Order
    
    /**
     * @Projectname: PetStore
     * @Classname: OrderDao
     * @Author: Ding Jiaxiong
     * @Data:2023/4/6 20:55
     */
    
    //订单管理DAO
    interface OrderDao {
        
        // 查询所有的订单信息
        fun findAll(): List<Order>
    
        // 根据主键查询订单信息
        fun findById(orderid: Long): Order?
    
        // 创建订单信息
        fun create(order: Order)
    
        // 修改订单信息
        fun modify(order: Order)
    
        // 删除订单信息
        fun remove(order: Order)
    
    }

【4】订单详细DAO接口代码如下：

package com.dingjiaxiong.petstore.dao
    
    import com.dingjiaxiong.petstore.domain.OrderDetail
    
    /**
     * @Projectname: PetStore
     * @Classname: OrderDetailDao
     * @Author: Ding Jiaxiong
     * @Data:2023/4/6 20:56
     */
    
    //订单明细管理DAO
    interface OrderDetailDao {
        
    
        // 查询所有的订单明细信息
        fun findAll(): List<OrderDetail>
    
        // 根据主键查询订单明细信息
        fun findByPK(orderid: Long, productid: String): OrderDetail?
    
        // 创建订单明细信息
        fun create(orderDetail: OrderDetail)
    
        // 修改订单明细信息
        fun modify(orderDetail: OrderDetail)
    
        // 删除订单明细信息
        fun remove(orderDetail: OrderDetail)
    }

###### 25.4.3 迭代3.3：创建数据表类 ######

使用Exposed框架还需要编写与数据库对应的数据表类。具体实现代码如下：

DBSchema.kt

package com.dingjiaxiong.petstore.dao.mysql
    
    /**
     * @Projectname: PetStore
     * @Classname: DBSchema
     * @Author: Ding Jiaxiong
     * @Data:2023/4/6 20:57
     */
    
    import org.jetbrains.exposed.sql.*
    
    const val URL = "jdbc:mysql://localhost:3306/petstore?serverTimezone=UTC&useUnicode=true&characterEncoding=utf-8"
    const val DRIVER_CLASS = "com.mysql.cj.jdbc.Driver"
    const val DB_USER = "root"
    const val DB_PASSWORD = "123456"
    
    /* 用户表 */
    object Accounts : Table() {
        
        //声明表中字段
        val userid = varchar("userid", length = 80) /* 用户Id  */
        override val primaryKey = PrimaryKey(userid, name = "PK_User_ID")
        val password = varchar("password", length = 25)         /* 用户密码 */
        val email = varchar("email", length = 80)               /* 用户Email */
        val name = varchar("name", length = 80)                 /* 用户名 */
        val addr = varchar("addr", length = 80)                 /* 地址 */
        val city = varchar("city", length = 80)                 /* 所在城市 */
        val country = varchar("country", length = 20)           /* 国家 */
        val phone = varchar("phone", length = 80)               /* 电话号码 */
    }
    
    /* 商品表 */
    object Products : Table() {
        
        val productid = varchar("productid", length = 10)          /* 商品Id */
        override val primaryKey = PrimaryKey(productid, name = "PK_Produc_ID")
        val category = varchar("category", length = 10)              /* 商品类别 */
        val cname = varchar("cname", length = 80)                    /* 商品中文名 */
        val ename = varchar("ename", length = 80)                    /* 商品英文名 */
        val image = varchar("image", length = 20)                    /* 商品图片 */
        val descn = varchar("descn", length = 255)                   /* 商品描述 */
        val listprice = decimal("listprice", 10, 2)     /* 商品市场价 */
        val unitcost = decimal("unitcost", 10, 2)       /* 商品单价 */
    }
    
    /* 订单表 */
    object Orders : Table() {
        
        val orderid = long("orderid")                    /* 订单Id */
        override val primaryKey = PrimaryKey(orderid, name = "PK_Order_ID")
    
        val userid = varchar("userid", length = 80)             /* 下订单的用户Id */
        val orderdate = long("orderdate")                       /* 下订单时间 */
        val status = integer("status")                          /* 商品单价 */
        val amount = decimal("amount", 10, 2)     /* 订单应付金额 */
    }
    
    /* 订单明细表 */
    object Orderdetails : Table() {
        
        val orderid = long("orderid")                       /* 订单Id */
        val productid = varchar("productid", length = 10)   /* 商品Id */
    
        override val primaryKey = PrimaryKey(orderid, productid, name = "PK_Orderdetails_productid")
    
        val quantity = integer("quantity")                     /* 商品数量 */
        val unitcost = decimal("unitcost", 10, 2)/* 商品单价 */
    }

与数据库设计模型中的表结构一致。

###### 25.4.4 迭代3.4：编写DAO实现类 ######

编写DAO类就没有实体类那么简单了，数据持久层开发的主要工作量主要是DAO类。下图是DAO实现类图。

![在这里插入图片描述][5a29840d93994156819f0f5d9a123da5.png_pic_center]

【1】用户管理DAO

用户管理AccountDao实现类AccountDaoImp代码如下：

package com.dingjiaxiong.petstore.dao.mysql
    
    import com.dingjiaxiong.petstore.dao.AccountDao
    import com.dingjiaxiong.petstore.domain.Account
    import org.jetbrains.exposed.sql.Database
    import org.jetbrains.exposed.sql.StdOutSqlLogger
    import org.jetbrains.exposed.sql.addLogger
    import org.jetbrains.exposed.sql.select
    import org.jetbrains.exposed.sql.transactions.transaction
    
    /**
     * @Projectname: PetStore
     * @Classname: AccountDaoImp
     * @Author: Ding Jiaxiong
     * @Data:2023/4/6 21:02
     */
    
    //用户管理DAO
    class AccountDaoImp : AccountDao {
        
    
        override fun findAll(): List<Account> {
        
            TODO("not implemented")
        }
    
        override fun findById(userid: String): Account? {
        
            var accountList: List<Account> = emptyList()
            //连接数据库
            Database.connect(URL, user = DB_USER, password = DB_PASSWORD, driver = DRIVER_CLASS)
            //操作数据库
            transaction {
        
                //添加SQL日志
                addLogger(StdOutSqlLogger)
                //按照主键查询
                accountList = Accounts.select {
         Accounts.userid.eq(userid) }.map {
        
                    val account = Account()
                    account.userid = it[Accounts.userid]
                    account.password = it[Accounts.password]
                    account.email = it[Accounts.email]
                    account.username = it[Accounts.name]
                    account.addr = it[Accounts.addr]
                    account.city = it[Accounts.city]
                    account.country = it[Accounts.country]
                    account.phone = it[Accounts.phone]
                    //Lambda表达式返回数据
                    account
                }
            }
            return if (accountList.isEmpty()) null else accountList.first()
        }
    
        override fun create(account: Account) {
        
            TODO("not implemented")
        }
    
        override fun modify(account: Account) {
        
            TODO("not implemented")
        }
    
        override fun remove(account: Account) {
        
            TODO("not implemented")
        }
    
    }

AccountDao接口中定义了5个抽象函数。但这些函数，在本项目中只需要实现findById函数。

【2】商品管理DAO

商品管理ProductDao实现类ProductDaoImp代码如下：

package com.dingjiaxiong.petstore.dao.mysql
    
    import com.dingjiaxiong.petstore.dao.ProductDao
    import com.dingjiaxiong.petstore.domain.Product
    import org.jetbrains.exposed.sql.*
    import org.jetbrains.exposed.sql.transactions.transaction
    
    /**
     * @Projectname: PetStore
     * @Classname: ProductDaoImp
     * @Author: Ding Jiaxiong
     * @Data:2023/4/6 21:04
     */
    
    class ProductDaoImp : ProductDao {
        
    
        override fun findAll(): List<Product> {
        
            var productList: List<Product> = emptyList()
            //连接数据库
            Database.connect(URL, user = DB_USER, password = DB_PASSWORD, driver = DRIVER_CLASS)
            //操作数据库
            transaction {
        
                //添加SQL日志
                addLogger(StdOutSqlLogger)
                productList = Products.selectAll().map {
        
                    val product = Product()
                    product.productid = it[Products.productid]
                    product.category = it[Products.category]
                    product.cname = it[Products.cname]
                    product.ename = it[Products.ename]
                    product.image = it[Products.image]
                    product.descn = it[Products.descn]
                    product.listprice = it[Products.listprice]
                    product.unitcost = it[Products.unitcost]
                    //Lambda表达式返回数据
                    product
                }
            }
    
            return productList
        }
    
        override fun findById(productid: String): Product? {
        
            var productList: List<Product> = emptyList()
            //连接数据库
            Database.connect(URL, user = DB_USER, password = DB_PASSWORD, driver = DRIVER_CLASS)
            //操作数据库
            transaction {
        
                //添加SQL日志
                addLogger(StdOutSqlLogger)
                //按照主键查询
                productList = Products.select {
         Products.productid.eq(productid) }.map {
        
                    val product = Product()
                    product.productid = it[Products.productid]
                    product.category = it[Products.category]
                    product.cname = it[Products.cname]
                    product.ename = it[Products.ename]
                    product.image = it[Products.image]
                    product.descn = it[Products.descn]
                    product.listprice = it[Products.listprice]
                    product.unitcost = it[Products.unitcost]
                    //Lambda表达式返回数据
                    product
                }
            }
            return if (productList.isEmpty()) null else productList.first()
        }
    
        override fun findByCategory(category: String): List<Product> {
        
            var productList: List<Product> = emptyList()
            //连接数据库
            Database.connect(URL, user = DB_USER, password = DB_PASSWORD, driver = DRIVER_CLASS)
            //操作数据库
            transaction {
        
                //添加SQL日志
                addLogger(StdOutSqlLogger)
                //按照主键查询
                productList = Products.select {
         Products.category.eq(category) }.map {
        
                    val product = Product()
                    product.productid = it[Products.productid]
                    product.category = it[Products.category]
                    product.cname = it[Products.cname]
                    product.ename = it[Products.ename]
                    product.image = it[Products.image]
                    product.descn = it[Products.descn]
                    product.listprice = it[Products.listprice]
                    product.unitcost = it[Products.unitcost]
                    //Lambda表达式返回数据
                    product
                }
            }
            return productList
        }
    
        override fun create(product: Product) {
        
            TODO("not implemented")
        }
    
        override fun modify(product: Product) {
        
            TODO("not implemented")
        }
    
        override fun remove(product: Product) {
        
            TODO("not implemented")
        }
    
    }

ProductDao接口中定义了6个抽象函数。但这些函数，在本项目中只需要实现findById、findAll、findByCategory和findById函数。

【3】订单管理DAO

订单管理OrderDao实现类OrderDaoImp代码如下：

package com.dingjiaxiong.petstore.dao.mysql
    
    import com.dingjiaxiong.petstore.dao.OrderDao
    import com.dingjiaxiong.petstore.domain.Order
    import org.jetbrains.exposed.sql.*
    import org.jetbrains.exposed.sql.transactions.transaction
    import java.util.*
    
    /**
     * @Projectname: PetStore
     * @Classname: OrderDaoImp
     * @Author: Ding Jiaxiong
     * @Data:2023/4/6 21:06
     */
    
    class OrderDaoImp : OrderDao {
        
    
        override fun findAll(): List<Order> {
        
    
            var orderList: List<Order> = emptyList()
            //连接数据库
            Database.connect(URL, user = DB_USER, password = DB_PASSWORD, driver = DRIVER_CLASS)
            //操作数据库
            transaction {
        
                //添加SQL日志
                addLogger(StdOutSqlLogger)
                orderList = Orders.selectAll().map {
        
                    val order = Order()
                    order.orderid = it[Orders.orderid]
                    order.userid = it[Orders.userid]
                    order.orderdate = Date(it[Orders.orderdate])
                    order.status = it[Orders.status]
                    order.amount = it[Orders.amount]
                    //Lambda表达式返回数据
                    order
                }
            }
            return orderList
        }
    
        override fun findById(orderid: Long): Order? {
        
            TODO("not implemented")
        }
    
        override fun create(order: Order) {
        
            //连接数据库
            Database.connect(URL, user = DB_USER, password = DB_PASSWORD, driver = DRIVER_CLASS)
            //操作数据库
            transaction {
        
                //添加SQL日志
                addLogger(StdOutSqlLogger)
                Orders.insert {
        
                    it[Orders.orderid] = order.orderid
                    it[Orders.userid] = order.userid!!
                    val now = Date() // 获得当前时间
                    it[Orders.orderdate] = now.time // 用long表示的时间戳
                    it[Orders.status] = order.status
                    it[Orders.amount] = order.amount
                }
            }
        }
    
        override fun modify(order: Order) {
        
            TODO("not implemented")
        }
    
        override fun remove(order: Order) {
        
            TODO("not implemented")
        }
    }

OrderDao接口中定义了5个抽象函数。但这些函数，在本项目中只需要实现findAll和create函数。

【4】订单明细管理DAO

订单明细管理OrderDetailDao实现类OrderDetailDaoImp代码如下：

package com.dingjiaxiong.petstore.dao.mysql
    
    import com.dingjiaxiong.petstore.dao.OrderDetailDao
    import com.dingjiaxiong.petstore.domain.OrderDetail
    import org.jetbrains.exposed.sql.*
    import org.jetbrains.exposed.sql.transactions.transaction
    
    /**
     * @Projectname: PetStore
     * @Classname: OrderDetailDaoImp
     * @Author: Ding Jiaxiong
     * @Data:2023/4/6 21:07
     */
    
    class OrderDetailDaoImp : OrderDetailDao {
        
        override fun findAll(): List<OrderDetail> {
        
            TODO("not implemented")
        }
    
        override fun findByPK(orderid: Long, productid: String): OrderDetail? {
        
    
            var orderDetailList: List<OrderDetail> = emptyList()
            //连接数据库
            Database.connect(URL, user = DB_USER, password = DB_PASSWORD, driver = DRIVER_CLASS)
            //操作数据库
            transaction {
        
                //添加SQL日志
                addLogger(StdOutSqlLogger)
                //按照主键查询
                orderDetailList =
                    Orderdetails.select {
         Orderdetails.orderid.eq(orderid) and Orderdetails.productid.eq(productid) }
                        .map {
        
                            val orderDetail = OrderDetail()
                            orderDetail.productid = it[Orderdetails.productid]
                            orderDetail.orderid = it[Orderdetails.orderid]
                            orderDetail.quantity = it[Orderdetails.quantity]
                            orderDetail.unitcost = it[Orderdetails.unitcost]
                            //Lambda表达式返回数据
                            orderDetail
                        }
            }
            return if (orderDetailList.isEmpty()) null else orderDetailList.first()
        }
    
        override fun create(orderDetail: OrderDetail) {
        
            //连接数据库
            Database.connect(URL, user = DB_USER, password = DB_PASSWORD, driver = DRIVER_CLASS)
            //操作数据库
            transaction {
        
                //添加SQL日志
                addLogger(StdOutSqlLogger)
                Orderdetails.insert {
        
                    it[orderid] = orderDetail.orderid
                    it[productid] = orderDetail.productid!!
                    it[quantity] = orderDetail.quantity
                    it[unitcost] = orderDetail.unitcost
                }
            }
        }
    
        override fun modify(orderDetail: OrderDetail) {
        
            TODO("not implemented")
        }
    
        override fun remove(orderDetail: OrderDetail) {
        
            TODO("not implemented")
        }
    
    }

OrderDetailDao接口中定义了5个抽象函数。但这些函数，在本项目中只需要实现findByPK和create函数。

[c7a364c1351c4c5098ae9d70da387f04.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/23/724b4ceb08e64112abbc4883cf4a0dd8.png
[337a9180a4634b55a7cfb94f40eb14fb.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/23/df7735fb63e7483a89495f0bdf9d809e.png
[3c1c4015ef5f4a6d9e04abaae4e438ba.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/23/8de073677c374321b720aaf6b3c89c72.png
[5a29840d93994156819f0f5d9a123da5.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/23/159063ba084b4f5cb189c5b6098a640c.png