使用 jdbc 技术升级水果库存系统（后端最终版本，不包含前端）

 1、配置依赖

    <dependencies>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.10</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.28</version>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.2.16</version>
        </dependency>
    </dependencies>

2、Fruit 实体类

package com.csdn.fruit.pojo;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.io.Serializable;
@Data
@NoArgsConstructor
@AllArgsConstructor
public class Fruit implements Serializable {
    private Integer fid;
    private String fname;
    private Integer price;
    private Integer fcount;
    private String remark;

    public Fruit(String fname, Integer price, Integer fcount, String remark) {
        this.fname = fname;
        this.price = price;
        this.fcount = fcount;
        this.remark = remark;
    }
    @Override
    public String toString() {
        return fname + "\t\t" + price + "\t\t" + fcount + "\t\t" + remark;
    }
}

 3、设计数据访问对象层DAO接口

package com.csdn.fruit.dao;
import com.csdn.fruit.pojo.Fruit;
import java.util.List;
//dao ：Data Access Object 数据访问对象
//接口设计
public interface FruitDao {

    void addFruit(Fruit fruit);

    void delFruit(String fname);

    void updateFruit(Fruit fruit);

    List<Fruit> getFruitList();

    Fruit getFruitByFname(String fname);
}

 4、设计DAO层的实现类

package com.csdn.fruit.dao.impl;
import com.csdn.fruit.dao.FruitDao;
import com.csdn.fruit.pojo.Fruit;
import com.csdn.mymvc.dao.BaseDao;
import java.util.List;
public class FruitDaoImpl extends BaseDao<Fruit> implements FruitDao {
    @Override
    public void addFruit(Fruit fruit) {
        String sql = "insert into t_fruit values (0,?,?,?,?)";
        super.executeUpdate(sql, fruit.getFname(), fruit.getPrice(), fruit.getFcount(), fruit.getRemark());
    }

    @Override
    public void delFruit(String fname) {
        String sql = "delete from t_fruit where fname=?";
        super.executeUpdate(sql, fname);
    }

    @Override
    public void updateFruit(Fruit fruit) {
        String sql = "update  t_fruit set fcount=? where fname = ?";
        super.executeUpdate(sql, fruit.getFcount(), fruit.getFname());
    }

    @Override
    public List<Fruit> getFruitList() {
        return super.executeQuery("select * from t_fruit");
    }

    @Override
    public Fruit getFruitByFname(String fname) {
        return load("select * from t_fruit where fname = ?", fname);
    }
}

 5、编写 jdbc 配置文件

jdbc.driver=com.mysql.cj.jdbc.Driver
jdbc.url=jdbc:mysql:///fruitdb
jdbc.user=root
jdbc.pwd=123456
jdbc.init_size=5
jdbc.max_active=20
jdbc.max_wait=3000

6、 设计数据库操作层（抽象类）

package com.csdn.mymvc.dao;
import com.alibaba.druid.pool.DruidDataSource;
import com.csdn.mymvc.util.ClassUtil;
import javax.sql.DataSource;
import java.io.IOException;
import java.io.InputStream;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.sql.*;
import java.util.ArrayList;
import java.util.List;
import java.util.Properties;
public abstract class BaseDao<T> {

    private String entityClassName;

    public BaseDao() {
        // this 是谁？ this代表的是 FruitDaoImpl 的实例对象，因为 BaseDao是抽象类，不能直接创建对象，所以 new 的是它的子类对象 FruitDaoImpl
        // this.getClass() 获取的是 FruitDaoImpl 的Class对象
        // getGenericSuperclass() 获取到的是：BaseDao<Fruit>
        // Type 是顶层接口，表示所有的类型。它有一个子接口：ParameterizedType
        ParameterizedType genericSuperclass = (ParameterizedType) this.getClass().getGenericSuperclass();
        // Actual:实际的
        // getActualTypeArguments() 获取实际的类型参数
        Type[] actualTypeArguments = genericSuperclass.getActualTypeArguments();
        Type actualTypeArgument = actualTypeArguments[0];

        // System.out.println(actualTypeArgument.getTypeName());//com.csdn.fruit.pojo.Fruit

        entityClassName = actualTypeArgument.getTypeName();

        initDataSource();
    }

    private DataSource dataSource;

    //加载jdbc.properties文件
    private void initDataSource() {
        try {
            InputStream inputStream = getClass().getClassLoader().getResourceAsStream("jdbc.properties");
            Properties properties = new Properties();
            properties.load(inputStream);

            String driver = properties.getProperty("jdbc.driver", "com.mysql.cj.jdbc.Driver");
            String url = properties.getProperty("jdbc.url", "jdbc:mysql:///fruitdb");
            String user = properties.getProperty("jdbc.user", "root");
            String pwd = properties.getProperty("jdbc.pwd", "123456");
            Integer initSize = Integer.parseInt(properties.getProperty("jdbc.init_size", "5"));
            Integer maxActive = Integer.parseInt(properties.getProperty("jdbc.max_active", "10"));
            Integer maxWait = Integer.parseInt(properties.getProperty("jdbc.max_wait", "5000"));

            DruidDataSource druidDataSource = new DruidDataSource();

            druidDataSource.setDriverClassName(driver);
            druidDataSource.setUrl(url);
            druidDataSource.setUsername(user);
            druidDataSource.setPassword(pwd);
            druidDataSource.setInitialSize(initSize);
            druidDataSource.setMaxActive(maxActive);
            druidDataSource.setMaxWait(maxWait);

            dataSource = druidDataSource;

        } catch (IOException e) {
            throw new RuntimeException(e);
        }

    }

    private Connection getConn() throws SQLException {
            return dataSource.getConnection();
    }

    private void close(Connection conn, PreparedStatement psmt, ResultSet rs) {
        try {
            if (rs != null) {
                rs.close();
            }
            if (psmt != null) {
                psmt.close();
            }
            if (conn != null && !conn.isClosed()) {
                conn.close();
            }
        } catch (SQLException e) {
            throw new RuntimeException(e);
        }
    }

    //抽取执行更新方法
    //执行更新，返回影响行数
    //如果是执行 insert，那么可以尝试返回自增列的值
    protected int executeUpdate(String sql, Object... params) {

        boolean insertFlag = sql.trim().toUpperCase().startsWith("INSERT");

        Connection conn = null;
        PreparedStatement psmt = null;
        try {
            conn = getConn();
            psmt = insertFlag ? conn.prepareStatement(sql, Statement.RETURN_GENERATED_KEYS) : conn.prepareStatement(sql);

            setParams(psmt, params);

            int count = psmt.executeUpdate();

            if (insertFlag) {
                ResultSet rs = psmt.getGeneratedKeys();
                if (rs.next()) {
                    Long id = rs.getLong(1);
                    count = id.intValue();
                }
            }

            return count;
        } catch (SQLException e) {
            throw new RuntimeException(e);
        } finally {
            close(conn, psmt, null);
        }
    }

    //设置参数
    private void setParams(PreparedStatement psmt, Object... params) throws SQLException {
        if (params != null && params.length > 0) {
            for (int i = 0; i < params.length; i++) {
                psmt.setObject(i + 1, params[i]);
            }
        }
    }

    //执行查询，返回集合
    protected List<T> executeQuery(String sql, Object... params) {
        List<T> list = new ArrayList<>();
        Connection conn = null;
        PreparedStatement psmt = null;
        ResultSet rs = null;

        try {
            conn = getConn();
            psmt = conn.prepareStatement(sql);
            setParams(psmt, params);
            rs = psmt.executeQuery();
            ResultSetMetaData rsmd = rs.getMetaData();//元数据,结果集的结构数据
            while (rs.next()) {
                //T t = new T();  T仅仅是一个符号，所以不能 new
                T t = (T) ClassUtil.createInstance(entityClassName);
                int columnCount = rsmd.getColumnCount();//获取结果集的列的数据
                //jdbc中都是从 1 开始，所以要把 i 改成 从 1 开始
                for (int i = 1; i <= columnCount; i++) {
                    //假设循环 5 次，得到 5 个值，应该对应的是一个对象的 5 个属性的值
                    String columnName = rsmd.getColumnLabel(i);
                    Object columnValue = rs.getObject(i);
                    //给 t 这个对象的 columnName 属性赋 columnValue 值
                    ClassUtil.setProperty(t, columnName, columnValue);
                }
                list.add(t);
            }
            return list;
        } catch (SQLException e) {
            throw new RuntimeException(e);
        } finally {
            close(conn, psmt, rs);
        }
    }

    protected T load(String sql, Object... params) {

        Connection conn = null;
        PreparedStatement psmt = null;
        ResultSet rs = null;

        try {
            conn = getConn();
            psmt = conn.prepareStatement(sql);
            setParams(psmt, params);
            rs = psmt.executeQuery();
            ResultSetMetaData rsmd = rs.getMetaData();//元数据,结果集的结构数据
            if (rs.next()) {
                //T t = new T();  T仅仅是一个符号，所以不能 new
                T t = (T) ClassUtil.createInstance(entityClassName);
                int columnCount = rsmd.getColumnCount();//获取结果集的列的数据
                //jdbc中都是从 1 开始，所以要把 i 改成 从 1 开始
                for (int i = 1; i <= columnCount; i++) {
                    //假设循环 5 次，得到 5 个值，应该对应的是一个对象的 5 个属性的值
                    String columnName = rsmd.getColumnLabel(i);
                    Object columnValue = rs.getObject(i);
                    //给 t 这个对象的 columnName 属性赋 columnValue 值
                    ClassUtil.setProperty(t, columnName, columnValue);
                }
                return t;
            }
        } catch (SQLException e) {
            throw new RuntimeException(e);
        } finally {
            close(conn, psmt, rs);
        }
        return null;
    }

    //select max(age) as max_age ,  avg(age)  as avg_age from t_user
    // 28               24.5

    //select deptNo,avg(sal)  as avg_sal  from emp  group by deptNo

    /**
     * d001       3500
     * d002       3650
     * d003       2998
     */
    protected List<Object[]> executeComplexQuery(String sql, Object... params) {
        List<Object[]> list = new ArrayList<>();
        Connection conn = null;
        PreparedStatement psmt = null;
        ResultSet rs = null;

        try {
            conn = getConn();
            psmt = conn.prepareStatement(sql);
            setParams(psmt, params);
            rs = psmt.executeQuery();
            ResultSetMetaData rsmd = rs.getMetaData();//元数据,结果集的结构数据
            while (rs.next()) {
                int columnCount = rsmd.getColumnCount();//获取结果集的列的数据
                Object[] arr = new Object[columnCount];
                //jdbc中都是从 1 开始，所以要把 i 改成 从 1 开始
                for (int i = 1; i <= columnCount; i++) {
                    Object columnValue = rs.getObject(i);
                    //数组从 0 开始，所以要减 1
                    arr[i - 1] = columnValue;
                }
                list.add(arr);
            }
            return list;
        } catch (SQLException e) {
            throw new RuntimeException(e);
        } finally {
            close(conn, psmt, rs);
        }
    }
}

7、 设计Class工具类

package com.csdn.mymvc.util;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
public class ClassUtil {

    public static Object createInstance(String entityClassName) {
        try {
            return Class.forName(entityClassName).getDeclaredConstructor().newInstance();
        } catch (InstantiationException | IllegalAccessException | InvocationTargetException | NoSuchMethodException |
                 ClassNotFoundException e) {
            throw new RuntimeException(e);
        }
    }

    public static void setProperty(Object instance, String propertyName, Object propertyValue) {
        Class<?> aClass = instance.getClass();
        try {
            Field field = aClass.getDeclaredField(propertyName);
            field.setAccessible(true);
            field.set(instance, propertyValue);
        } catch (NoSuchFieldException | IllegalAccessException e) {
            throw new RuntimeException(e);
        }
    }
}

 8、测试DAO层实现类

package com.csdn.dao.impl;
import com.csdn.fruit.dao.FruitDao;
import com.csdn.fruit.dao.impl.FruitDaoImpl;
import com.csdn.fruit.pojo.Fruit;
import org.junit.Test;
import java.util.List;
public class FruitDaoImplTest {

    private FruitDao fruitDao = new FruitDaoImpl();

    @Test
    public void testAddFruit() {
        Fruit fruit = new Fruit("香蕉", 7, 77, "波罗蜜是一种神奇的水果！");
        fruitDao.addFruit(fruit);
    }

    @Test
    public void testDelFruit() {
        fruitDao.delFruit("哈密瓜");
    }

    @Test
    public void testUpdateFruit() {
        Fruit fruit = new Fruit("波罗蜜", 5, 1000, "好吃");
        fruitDao.updateFruit(fruit);
    }

    @Test
    public void testGetFruitList() {
        List<Fruit> fruitList = fruitDao.getFruitList();
        fruitList.stream().forEach(System.out::println);
    }

    @Test
    public void testGetFruitByFname() {

        Fruit fruit = fruitDao.getFruitByFname("波罗蜜");
        System.out.println(fruit);
    }

/*
    // this 是谁？ this代表的是 FruitDaoImpl 的实例对象，因为 BaseDao是抽象类，不能直接创建对象，所以 new 的是它的子类对象 FruitDaoImpl
    // this.getClass() 获取的是 FruitDaoImpl 的Class对象
    // getGenericSuperclass() 获取到的是：BaseDao<Fruit>
    // Type 是顶层接口，表示所有的类型。它有一个子接口：ParameterizedType
    ParameterizedType genericSuperclass = (ParameterizedType) this.getClass().getGenericSuperclass();
    // Actual:实际的
    // getActualTypeArguments() 获取实际的类型参数
    Type[] actualTypeArguments = genericSuperclass.getActualTypeArguments();
    Type actualTypeArgument = actualTypeArguments[0];

    // System.out.println(actualTypeArgument.getTypeName());//com.csdn.fruit.pojo.Fruit

    entityClassName = actualTypeArgument.getTypeName();

    loadJdbcProperties();
*/
    @Test
    public void testActualTypeArgument() {
            //这个方法是用来测试  actualTypeArgument 实际返回的参数
    }
}

 9、设计控制台操作菜单

package com.csdn.fruit.view;
import com.csdn.fruit.dao.FruitDao;
import com.csdn.fruit.dao.impl.FruitDaoImpl;
import com.csdn.fruit.pojo.Fruit;
import java.util.List;
import java.util.Scanner;
public class Menu {
    Scanner input = new Scanner(System.in);
    private FruitDao fruitDao = new FruitDaoImpl();
    //显示主菜单
    public int showMainMenu() {
        System.out.println("================欢迎使用水果库存系统===================");
        System.out.println("1.显示库存列表");
        System.out.println("2.添加库存记录");
        System.out.println("3.查看特定库存");
        System.out.println("4.水果下架");
        System.out.println("5.退出");
        System.out.println("====================================================");
        System.out.print("请选择：");

        return input.nextInt();
    }
    //显示库存列表
    public void showFruitList() {
        List<Fruit> fruitList = fruitDao.getFruitList();
        System.out.println("----------------------------------------------------");
        System.out.println("名称\t\t单价\t\t库存\t\t备注");
        if (fruitList == null || fruitList.size() <= 0) {
            System.out.println("对不起，库存为空！");
        } else {
               /* fruitList.forEach(new Consumer<Fruit>() {
                @Override
                public void accept(Fruit fruit) {
                    System.out.println(fruit);
                }
            });*/

            //fruitList.forEach(fruit -> System.out.println(fruit));
            fruitList.forEach(System.out::println);
        }
        System.out.println("----------------------------------------------------");
    }
    //添加库存记录
    public void addFruit() {
        System.out.print("请输入水果名称：");
        String fname = input.next();

        Fruit fruit = fruitDao.getFruitByFname(fname);

        if (fruit == null) {
            System.out.print("请输入水果单价：");
            Integer price = input.nextInt();
            System.out.print("请输入水果库存：");
            Integer fcount = input.nextInt();
            System.out.print("请输入水果备注：");
            String remark = input.next();

            fruit = new Fruit(fname, price, fcount, remark);
            fruitDao.addFruit(fruit);
        } else {
            System.out.print("请输入追加的库存量：");
            Integer fcount = input.nextInt();
            fruit.setFcount(fruit.getFcount() + fcount);
            fruitDao.updateFruit(fruit);
        }
        System.out.println("添加成功！");
    }
    //查看特定库存记录
    public void showFruitInfo() {
        System.out.print("请输入水果名称：");
        String fname = input.next();
        Fruit fruit = fruitDao.getFruitByFname(fname);

        if (fruit == null) {
            System.out.println("对不起，没有找到对应的库存记录！");
        } else {
            System.out.println("----------------------------------------------------");
            System.out.println("名称\t\t单价\t\t库存\t\t备注");
            System.out.println(fruit);
            System.out.println("----------------------------------------------------");
        }
    }
    //水果下架
    public void delFruit() {
        System.out.print("请输入水果名称：");
        String fname = input.next();

        Fruit fruit = fruitDao.getFruitByFname(fname);
        if (fruit == null) {
            System.out.println("对不起，没有找到需要下架的库存记录！");
        } else {
            System.out.print("是否确认下架?（Y/N）");
            String confirm = input.next();
            if ("y".equalsIgnoreCase(confirm)) {
                fruitDao.delFruit(fname);
            }

        }
    }
    //退出
    public boolean exit() {
        System.out.print("是否确认退出？（Y/N）");
        String confirm = input.next();
        boolean flag= !"y".equalsIgnoreCase(confirm);
        return flag;
    }
}

 10、设计客户端

package com.csdn.fruit.view;
public class Client {
    public static void main(String[] args) {
        Menu m = new Menu();
        boolean flag = true;
        while (flag) {
            int slt = m.showMainMenu();
            switch (slt) {
                case 1:
                    m.showFruitList();
                    break;
                case 2:
                    m.addFruit();
                    break;
                case 3:
                    m.showFruitInfo();
                    break;
                case 4:
                    m.delFruit();
                    break;
                case 5:
                    //方法设计时是否需要返回值，依据是：是否在调用的地方需要留下一些值用于再运算
                    flag = m.exit();
                    break;
                default:
                    System.out.println("你不按套路出牌！");
                    break;
            }
        }
        System.out.println("谢谢使用！再见！");
    }
}

 

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mfbz.cn/a/109764.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

智能工厂解决方案

智能工厂解决方案

智能工厂解决方案&#xff1a;生产工单 智能工厂解决方案&#xff1a;物流中转 样品单-4.2寸 工单任务卡-4.2寸 工单流转卡-4.2寸 生产配送卡-4.2寸 工序参数卡-7.5寸 生产拣配单-7.5寸 仓库24代-参数 接收路由器发送的数据信息并解析&#xff0c;做出相应的指示&#…
阅读更多...
图片去除水印文字怎么去除？这几个方法快来收藏

图片去除水印文字怎么去除？这几个方法快来收藏

图片怎么去除水印文字&#xff1f;现在嘛&#xff0c;图片已经成了我们生活和工作里必不可少的一部分&#xff0c;可是有时候看图的时候&#xff0c;总会碰到一些带水印的图片&#xff0c;这些水印总是搞得图片看起来不那么爽&#xff0c;所以很多人都想知道图片怎么去除水印文…
阅读更多...
如何改善设备综合效率（OEE）并提高工厂的生产力

如何改善设备综合效率（OEE）并提高工厂的生产力

在现代制造业中&#xff0c;提高设备综合效率&#xff08;Overall Equipment Efficiency&#xff0c;OEE&#xff09;是企业追求高效生产和优化生产能力的重要目标之一。OEE是一个关键的绩效指标&#xff0c;可以帮助企业评估设备的利用效率、生产效率和质量水平。本文将从三个…
阅读更多...
[UDS] --- RoutineCommunicationControl 0x31

[UDS] --- RoutineCommunicationControl 0x31

1 0x31功能描述 client端使用RoutineControl服务执行定义的步骤序列并获取任何相关结果。该服务具有很大的灵活性&#xff0c;典型的用法包括擦除内存&#xff0c;复位或学习自适应数据&#xff0c;运行自检&#xff0c;覆盖正常服务器控制策略以及控制服务器值随时间变化等功…
阅读更多...
基于springboot实现校园疫情防控系统项目【项目源码+论文说明】计算机毕业设计

基于springboot实现校园疫情防控系统项目【项目源码+论文说明】计算机毕业设计

基于springboot实现校园疫情防控系统演示 摘要 随着信息技术和网络技术的飞速发展&#xff0c;人类已进入全新信息化时代&#xff0c;传统管理技术已无法高效&#xff0c;便捷地管理信息。为了迎合时代需求&#xff0c;优化管理效率&#xff0c;各种各样的管理系统应运而生&am…
阅读更多...
LabVIEW背景颜色设为和其他程序或图像中一样

LabVIEW背景颜色设为和其他程序或图像中一样

LabVIEW背景颜色设为和其他程序或图像中一样 有时候LabVIEW背景色要和其他程序或者图片的颜色保持一致&#xff0c;如果要求不高可以大致设置一下。如果要求较高&#xff0c;那可以按照如下的方式。 先用PS打开标准图像&#xff0c;之后用吸管工具选择图像上中的点&#xff0…
阅读更多...
leetcode经典面试150题---3.删除有序数组中的重复项

leetcode经典面试150题---3.删除有序数组中的重复项

目录 题目描述 前置知识 代码 方法一 双指针 思路 图解 实现 复杂度 题目描述 给你一个 非严格递增排列 的数组 nums &#xff0c;请你 原地 删除重复出现的元素&#xff0c;使每个元素 只出现一次 &#xff0c;返回删除后数组的新长度。元素的 相对顺序 应该保持 一致…
阅读更多...
用友 GRP-U8 存在sql注入漏洞复现

用友 GRP-U8 存在sql注入漏洞复现

0x01 漏洞介绍 用友 GRP-U8 license_check.jsp 存在sql注入&#xff0c;攻击者可利用该漏洞执行任意SQL语句&#xff0c;如查询数据、下载数据、写入webshell、执行系统命令以及绕过登录限制等。 fofa&#xff1a;app”用友-GRP-U8” 0x02 POC: /u8qx/license_check.jsp?kj…
阅读更多...
3.4每日一题（变量可分离方程通解）

3.4每日一题（变量可分离方程通解）

阅读更多...
网络协议--TCP：传输控制协议

网络协议--TCP：传输控制协议

17.1 引言 本章将介绍TCP为应用层提供的服务&#xff0c;以及TCP首部中的各个字段。随后的几章我们在了解TCP的工作过程中将对这些字段作详细介绍。 对TCP的介绍将由本章开始&#xff0c;并一直包括随后的7章。第18章描述如何建立和终止一个TCP连接&#xff0c;第19和第20章将…
阅读更多...
【操作系统】考研真题攻克与重点知识点剖析 - 第 1 篇：操作系统概述

【操作系统】考研真题攻克与重点知识点剖析 - 第 1 篇：操作系统概述

前言 本文基础知识部分来自于b站&#xff1a;分享笔记的好人儿的思维导图与王道考研课程&#xff0c;感谢大佬的开源精神&#xff0c;习题来自老师划的重点以及考研真题。此前我尝试了完全使用Python或是结合大语言模型对考研真题进行数据清洗与可视化分析&#xff0c;本人技术…
阅读更多...
十种排序算法(1) - 准备测试函数和工具

十种排序算法(1) - 准备测试函数和工具

1.准备工作 我们先写一堆工具&#xff0c;后续要用&#xff0c;不然这些写在代码里可读性巨差 #pragma once #include<stdio.h>//为C语言定义bool类型 typedef int bool; #define false 0 #define true 1//用于交互a和b inline void swap(int* a, int* b) {/*int c *a…
阅读更多...
微软bing大声朗读文档或网页卡顿老是中断，用离线的huihui就很流畅但没那么自然

微软bing大声朗读文档或网页卡顿老是中断，用离线的huihui就很流畅但没那么自然

默认的xiaoxiao_online好听&#xff0c;但卡顿&#xff0c;朗读功能确实受到了网络状态的影响。 大概率是网络问题。
阅读更多...
Android Glide判断图像资源是否缓存onlyRetrieveFromCache，使用缓存数据，Kotlin

Android Glide判断图像资源是否缓存onlyRetrieveFromCache，使用缓存数据，Kotlin

Android Glide判断图像资源是否缓存onlyRetrieveFromCache&#xff0c;使用缓存数据&#xff0c;Kotlin import android.graphics.Bitmap import android.os.Bundle import android.util.Log import android.widget.ImageView import androidx.appcompat.app.AppCompatActivity…
阅读更多...
目标检测算法发展史

目标检测算法发展史

前言 比起图像识别&#xff0c;现在图片生成技术要更加具有吸引力&#xff0c;但是要步入AIGC技术领域&#xff0c;首先不推荐一上来就接触那些已经成熟闭源的包装好了再提供给你的接口网站&#xff0c;会使用别人的模型生成一些图片就能叫自己会AIGC了吗&#xff1f;那样真正…
阅读更多...
0001net程序设计-net大学校园二手交易平台

0001net程序设计-net大学校园二手交易平台

文章目录 摘 要目 录系统设计开发环境 摘 要 随着信息技术和网络技术的飞速发展&#xff0c;人类已进入全新信息化时代&#xff0c;传统管理技术已无法高效&#xff0c;便捷地管理信息。为了迎合时代需求&#xff0c;优化管理效率&#xff0c;各种各样的管理系统应运而生&…
阅读更多...
数据结构───链表

数据结构───链表

花费一个周时间学完了链表&#xff08;的一部分&#xff09;&#xff0c;简单总结一下。 链表的学习离不开画图&#xff0c;将其抽象成一种逻辑模型&#xff0c;可以减少思考时间&#xff0c;方便理解。 链表大致分为8种结构&#xff0c;自己学习并实现了两种结构&#xff0c;也…
阅读更多...
UE5 日记（人物连招：蒙太奇动画通知（含视频链接））

UE5 日记（人物连招：蒙太奇动画通知（含视频链接））

教程https://www.youtube.com/watch?vsWpENaVGj2M&listPLiSlOaRBfgkcPAhYpGps16PT_9f28amXi&index10&ppiAQB 相关蓝图 连招逻辑 动画通知类 逻辑分析 1.用户输入 已搭载战斗系统模块,可以收到输入指令 2.连击 第一次攻击&#xff1a; 第一次攻击&#xff0c;…
阅读更多...
初探802.11协议(6)——Wi-Fi 6新特性简介

初探802.11协议(6)——Wi-Fi 6新特性简介

目录 前言 场景需求 Trigger Frames 一. BSS Color 1.1 机制 1.1.1 Color Collision 1.2 Frame Format 1.2.1 BSS Color Information 二. TWT 2.1 节能 2.1.1 PSM 2.1.2 从PSM到TWT 2.1.2.1 TWT模式 2.2 Frame Format REF 前言 802.11ax以前强调"高吞吐量…
阅读更多...
基于 Appium 的 Android UI 自动化测试！

基于 Appium 的 Android UI 自动化测试！

自动化测试是研发人员进行质量保障的重要一环&#xff0c;良好的自动化测试机制能够让开发者及早发现编码中的逻辑缺陷&#xff0c;将风险前置。日常研发中&#xff0c;由于快速迭代的原因&#xff0c;我们经常需要在各个业务线上进行主流程回归测试&#xff0c;目前这种测试大…
阅读更多...
最新文章

Copyright @ 2022~2023

友情链接： 我的编程经验分享 一条长河网 尧图网站开发 尧图建网站