实战 - 不要在for循环中调用数据库_java避免for循环查询数据库

1. 改进之前

存在的问题：for循环中存在批量查询数据库的情况，需要批量查询数据库处理掉
private void saveMemberToDb(List<DepartmentMemberInput> importMemberList) {
    // 对账号的查询放到了数据库外面，避免在for循环中重复调用
    List<UserInfoVo> userInfoVos = authFeignClient.getUserList().getData();
    Map<String/*账号名称*/, String/*账号id*/> userInfoMap 
        = userInfoVos.stream()
        .collect(Collectors.toMap(UserInfoVo::getName, UserInfoVo::getId));
    List<DepartmentMember> departmentMembers 
        = importMemberList.stream().map(departmentMemberInput -> {
        DepartmentMember departmentMember = new DepartmentMember();     
        // setDeptId
        String deptNameImport = departmentMemberInput.getDepartment().getName();
        // 存在循环调用数据库问题
        Integer rootId = departmentDao.findIdByPidAndName(
            GroupConstant.BUILT_IN_ROOT_DEPARTMENT_PARENT_ID,
            GroupConstant.BUILT_IN_ROOT_DEPARTMENT_NAME
        // 存在循环调用数据库问题
        Integer defaultDeptId = departmentDao.findIdByPidAndName(rootId, GroupConstant.BUILT_IN_DEPARTMENT_NAME);
        if (StringUtils.isEmpty(deptNameImport)) {
            departmentMember.setDeptId(defaultDeptId);
        } else {
            String deptName = departmentMemberInput.getDepartment().getName();
            // 存在的问题：在获取部门id的方法中存在循环调用数据库的问题，需要继续改进
            int deptId = getDeptId(deptName);
            if (deptId == -1) {
                departmentMember.setDeptId(defaultDeptId);
            } else {
                departmentMember.setDeptId(deptId);
        // setAccountId
        departmentMember.setAccountId(userInfoMap.get(departmentMemberInput.getAccountName()));
        return departmentMember;
    }).collect(Collectors.toList());
    if (!CollectionUtils.isEmpty(departmentMembers)) {
        departmentMemberDao.insertBatch(departmentMembers);
// 根据部门层级路径获取部门id，比如根据 “部门/研发部/SIR” 获取SIR的部门id 
// 该方法存在循环调用数据库的问题
public int getDeptId(String deptName) {
    String[] deptPathNameImport = deptName.split("/");
    int index = deptPathNameImport.length - 1;
    // 根据最后一级部门名称查找部门
    List<Department> departmentList = departmentDao.findByName(deptPathNameImport[index]);
    if (CollectionUtils.isEmpty(departmentList)) {
        return -1;
    for (Department department : departmentList) {
        // 暂存deptId
        int deptId = department.getId();
        // 如果当前部门的父级部门不是-1，寻找部门的父级部门
        while (index > 0 && department != null && department.getPid() != GroupConstant.BUILT_IN_ROOT_DEPARTMENT_PARENT_ID) {
            department = departmentDao.findById(department.getPid());
            if (department != null && !department.getName().equals(deptPathNameImport[--index])) {
                // 如果父级部门不等于excel中导入的父级部门
                break;
            if (index == 0) {
                return deptId;
    return -1;
2. 第一次改进后
 
存在的问题：可以不要在for循环中组装map，而是放在for循环外组装好，在for循环中调用 
private void saveMemberToDb(List<DepartmentMemberInput> importMemberList) {
    // 对账号的查询,避免在for循环中调用
    List<UserInfoVo> userInfoVos = authFeignClient.getUserList().getData();
    Map<String/*账号名称*/, String/*账号id*/> userInfoMap 
        = userInfoVos.stream()
        .collect(Collectors.toMap(UserInfoVo::getName, UserInfoVo::getId));
    // 查询 “部门” id，避免在for循环中调用
    Integer




    
 rootId 
        = departmentDao.findIdByPidAndName(GroupConstant.BUILT_IN_ROOT_DEPARTMENT_PARENT_ID, GroupConstant.BUILT_IN_ROOT_DEPARTMENT_NAME);
    // 查询 “默认部门” id，避免在for循环中调用
    Integer defaultDeptId 
        = departmentDao.findIdByPidAndName(rootId, GroupConstant.BUILT_IN_DEPARTMENT_NAME);
    // 查询所有部门，避免在for循环中调用
    List<Department> departments = departmentDao.findAll();
    List<DepartmentMember> departmentMembers = importMemberList.stream().map(departmentMemberInput -> {
        DepartmentMember departmentMember = new DepartmentMember();
        // setDeptId
        String deptNameImport = departmentMemberInput.getDepartment().getName();
        if (StringUtils.isEmpty(deptNameImport)) {
            departmentMember.setDeptId(defaultDeptId);
        } else {
            // 改进获取部门id的方法，不在循环调用数据库，而是查询所有数据后组装数据
            int deptId = getDepartmentId(deptNameImport,departments);
            if (deptId == -1) {
                departmentMember.setDeptId(defaultDeptId);
            } else {
                departmentMember.setDeptId(deptId);
		// setAccountId
        departmentMember.setAccountId(userInfoMap.get(departmentMemberInput.getAccountName()));
        return departmentMember;
    }).collect(Collectors.toList());
    if (!CollectionUtils.isEmpty(departmentMembers)) {
        departmentMemberDao.insertBatch(departmentMembers);
private int getDepartmentId(String deptPathName, List<Department> departments) {
    Map< String/* 父级部门名称路径 */, Integer/* 部门ID */> departmentId2NamesMap = new HashMap<>();
    Map<Integer/* 部门ID */, Department/* 部门详细信息 */> id2DepartmentMap = departments.stream().collect(Collectors.toMap(Department::getId, k -> k, (k1, k2) -> k2));
    Set<Integer> deptIds = id2DepartmentMap.keySet();
    for (Integer deptId : deptIds) {
        // 获取当前deptId的所属层级部门
        departmentId2NamesMap.put(getDeptPathName(deptId, id2DepartmentMap), deptId);
    return departmentId2NamesMap.getOrDefault(deptPathName,-1);
private String getDeptPathName(Integer deptId, Map<Integer, Department> id2DepartmentMap) {
    StringBuilder stringBuilder = new StringBuilder();
    while (id2DepartmentMap.containsKey(deptId)) {
        Department department = id2DepartmentMap.get(deptId);
        if (Objects.nonNull(department)) {
            stringBuilder.insert(0,department.getName());
            stringBuilder.insert(0,"/");
            deptId = department.getPid();
        } else {
            break;
    return stringBuilder.deleteCharAt(0).toString();
3. 第二次改进后
 
private void saveMemberToDb(List<DepartmentMemberInput> importMemberList) {
    // 对账号的查询,避免在for循环中调用
    List<UserInfoVo> userInfoVos = authFeignClient.getUserList().getData();
    Map<String/*账号名称*/, String/*账号id*/> userInfoMap 
        = userInfoVos.stream()
        .collect(Collectors.toMap(UserInfoVo::getName, UserInfoVo::getId));
    // 查询 “部门” id，避免在for循环中调用
    Integer rootId 
        = departmentDao.findIdByPidAndName(GroupConstant




    
.BUILT_IN_ROOT_DEPARTMENT_PARENT_ID, GroupConstant.BUILT_IN_ROOT_DEPARTMENT_NAME);
    // 查询 “默认部门” id，避免在for循环中调用
    Integer defaultDeptId 
        = departmentDao.findIdByPidAndName(rootId, GroupConstant.BUILT_IN_DEPARTMENT_NAME);
    // 查询所有部门，避免在for循环中调用
    List<Department> departments = departmentDao.findAll();
    // 查询每个部门的层级路径，避免在for循环中调用
    Map<String, Integer> departmentPathMap = getDepartmentPathMap(departments);
    List<DepartmentMember> departmentMembers = importMemberList.stream().map(departmentMemberInput -> {
        DepartmentMember departmentMember = new DepartmentMember();
        // setDeptId
        String deptNameImport = departmentMemberInput.getDepartment().getName();
        if (StringUtils.isEmpty(deptNameImport)) {
            departmentMember.setDeptId(defaultDeptId);
        } else {
            // 直接从map中调用
            int deptId = departmentPathMap.getOrDefault(deptNameImport,-1);
            if (deptId == -1) {
                departmentMember.setDeptId(defaultDeptId);
            } else {
                departmentMember.setDeptId(deptId);
        // setAccountId
        departmentMember.setAccountId(userInfoMap.get(departmentMemberInput.getAccountName()));
        return departmentMember;
    }).collect(Collectors.toList());
    if (!CollectionUtils.isEmpty(departmentMembers)) {
        departmentMemberDao.insertBatch(departmentMembers);
private Map< String/* 父级部门名称路径 */, Integer/* 部门ID */> getDepartmentPathMap(List<Department> departments) {
    Map< String/* 父级部门名称路径 */, Integer/* 部门ID */> departmentId2NamesMap = new HashMap<>();
    Map<Integer/* 部门ID */, Department/* 部门详细信息 */> id2DepartmentMap = departments.stream().collect(Collectors.toMap(Department::getId, k -> k, (k1, k2) -> k2));
    Set<Integer> deptIds = id2DepartmentMap.keySet();
    for (Integer deptId : deptIds) {
        departmentId2NamesMap.put(getDeptPathName(deptId, id2DepartmentMap), deptId);
    return departmentId2NamesMap;
private String getDeptPathName(Integer deptId, Map<Integer, Department> id2DepartmentMap) {
    StringBuilder stringBuilder = new StringBuilder();
    while (id2DepartmentMap.containsKey(deptId)) {
        Department department = id2DepartmentMap.get(deptId);
        if (Objects.nonNull(department)) {
            stringBuilder.insert(0,department.getName());
            stringBuilder.insert(0,"/");
            deptId = department.getPid();
        } else {
            break;
    return stringBuilder.deleteCharAt(0).toString();
4. 测试根据部门层级路径获取获取部门id接口
 
比如根据 “部门/研发部/SIR” 获取SIR的部门id 
public class Main {
    public static void main(String[] args) {
        String deptPathName = "部门/研发部/SIC";
        Department department1 = new Department(1,"部门",-1);
        Department department2 = new Department(2,"默认部门",1);
        Department department3 = new Department(3,"研发部",1);
        Department department4 = new




    
 Department(4,"SID",1);
        Department department5 = new Department(5,"SIC",3);
        Department department6 = new Department(6,"SOC",4);
        List<Department> list = new ArrayList<>();
        list.add(department1);
        list.add(department2);
        list.add(department3);
        list.add(department4);
        list.add(department5);
        list.add(department6);
        System.out.println(getDepartmentId(deptPathName, list));
    private static int getDepartmentId(String deptPathName, List<Department> departments) {
        Map< String/* 父级部门名称路径 */, Integer/* 部门ID */> map = new HashMap<>();
        Map<Integer/* 部门ID */, Department/* 部门详细信息 */> departmentMap = departments.stream()
                .collect(Collectors.toMap(Department::getId, k -> k, (k1, k2) -> k2));
        Set<Integer> deptIds = departmentMap.keySet();
        for (Integer deptId : deptIds) {
            map.put(getDeptPathName(deptId, departmentMap), deptId);
        return map.getOrDefault(deptPathName,-1);
     * 获取当前部门的层级路径
     * @param deptId 部门id
     * @param departmentMap
     * @return 部门/研发部/SIR
    private static String getDeptPathName(Integer deptId, Map<Integer, Department> departmentMap) {
        StringBuilder stringBuilder = new StringBuilder();
        while (departmentMap.containsKey(deptId)) {
            Department department = departmentMap.get(deptId);
            if (Objects.nonNull(department)) {
                stringBuilder.insert(0,department.getName());
                stringBuilder.insert(0,"/");
                deptId = department.getPid();
            } else {
                break;
        return stringBuilder.deleteCharAt(0).toString();
查询出所有部门，然后组装数据获取每个部门的层级路径
  
2. 循环调用数据库案例 2
 
将原来的遍历departmentMemberInputsFilterDb集合，判断每一条数据是否符合条件的循环调用数据库思路进行优化，
 优化思路就是查询所有数据，批量判断与数据库中数据是否重复，批量排出，而不是一个一个排出 
List<DepartmentMemberInput> successMemberList = result.getList();
// 1. 过滤出List集合中姓名和手机号不重复的数据
List<DepartmentMemberInput> departmentMemberInputsFilterPhone = new ArrayList<>();
for (DepartmentMemberInput departmentMemberInput : successMemberList) {
    if (!departmentMemberInputsFilterPhone.contains(departmentMemberInput)) {
        departmentMemberInputsFilterPhone.add(departmentMemberInput);
// 2. 过滤出list集合中账号不重复的数据
List<DepartmentMemberInput> departmentMemberInputsFilterAccount = departmentMemberInputsFilterPhone
    .stream()
    .collect(
    Collectors.collectingAndThen(
        Collectors.toCollection(
            () -> new TreeSet<>(Comparator.comparing(DepartmentMemberInput::getAccountName))
        ArrayList::new
// 将原来的遍历departmentMemberInputsFilterDb集合，判断每一条数据是否符合条件，然后排出，今天优化
// 优化思路就是查询所有数据，批量判断与数据库中数据是否重复，批量排出，而不是一个一个排出
List<DepartmentMemberInput> departmentMemberInputsFilterDb = new ArrayList<>(departmentMemberInputsFilterAccount);
// 查询所有的账号
List<UserInfoVo> userInfoVos = authFeignClient.getUserList().getData();
if(CollectionUtil.isNotEmpty(userInfoVos)){
    List<String




    
> allAccountNames = userInfoVos.stream().map(UserInfoVo::getName).collect(Collectors.toList());
    // 1. 排除数据库中账号不存在的数据
    List<DepartmentMemberInput> accountsRepeatWithDb= departmentMemberInputsFilterAccount.stream()
        .filter(departmentMemberInput -> !allAccountNames.contains(departmentMemberInput.getAccountName())).collect(Collectors.toList());
    departmentMemberInputsFilterDb.removeAll(accountsRepeatWithDb);
    // 2. 排除与数据库中人员账号重复的数据
    List<String> accountNames = departmentMemberInputsFilterAccount.stream()
        .map(DepartmentMemberInput::getAccountName).collect(Collectors.toList());
    Map<String/*账号名称*/, String/*账号ID*/> map = userInfoVos.stream().collect(Collectors.toMap(UserInfoVo::getName,UserInfoVo::getId));
    List<String> accountIds = new ArrayList<>();
    for (String accountName : accountNames) {
        accountIds.add(map.get(accountName));
    List<DepartmentMember> departmentMembers = departmentMemberDao.findByAccountIds(accountIds);
    departmentMembers.stream().map(departmentMember -> {
        DepartmentMemberInput departmentMemberInput = new DepartmentMemberInput();
        BeanUtils.copyProperties(departmentMember, departmentMemberInput);
        departmentMemberInputsFilterDb.remove(departmentMemberInput);
        return departmentMemberInput;
    }).collect(Collectors.toList());
    // 3. 排除与数据库中手机号和姓名重复的人员
    departmentMembers = departmentMemberDao.findAll();
    departmentMembers.stream().map(departmentMember -> {
        DepartmentMemberInput departmentMemberInput = new DepartmentMemberInput();
        BeanUtils.copyProperties(departmentMember, departmentMemberInput);
        departmentMemberInputsFilterDb.remove(departmentMemberInput);
        return departmentMemberInput;
    }).collect(Collectors.toList());
3. 循环调用数据库改进案例 3
 
1. 改进之前
 
@Override
public GroupTreeVo getList() {
    // 获取所有的工作组分类
    List<GroupCategory> groupCategoryList = groupCategoryDao.findAll();
    if (CollectionUtils.isEmpty(groupCategoryList)) {
        return null;
    // 设置工作组分类
    List<GroupCategoryVo> groupCategoryVos = new ArrayList<>();
    for (GroupCategory groupCategory : groupCategoryList) {
        GroupCategoryVo groupCategoryVo = new GroupCategoryVo();
        BeanUtils.copyProperties(groupCategory, groupCategoryVo);
        // 存在循环查数据库问题
        List<GroupVo> groupVos = getGroupVos(groupCategory);
        groupCategoryVo.setChildren(groupVos);
        groupCategoryVos.add(groupCategoryVo);
    // 添加顶级节点“全部”
    return setGroupTree(groupCategoryVos);
private List<GroupVo> getGroupVos(GroupCategory groupCategory) {
    // 工作组
    List<Group> groupList = groupDao.findByCategoryId(groupCategory.getId());
    List<GroupVo> groupVos = new ArrayList<>();
    if (!CollectionUtils.isEmpty(groupList)) {
        for (Group group : groupList) {
            GroupVo groupVo = new GroupVo();
            BeanUtils.copyProperties(group, groupVo);
            groupVos.add(groupVo);
    return groupVos;
private GroupTreeVo setGroupTree(List<GroupCategoryVo> groupCategoryVos) {
    GroupTreeVo groupTreeVo = new GroupTreeVo();
    groupTreeVo.setId(-1);
    groupTreeVo.setName("全部");
    groupTreeVo.setChildren(groupCategoryVos);
    return groupTreeVo;
2. 改进之后
 
@Override
public List<GroupCategoryTree> getGroupCategoryTree() {
    List<GroupCategoryTree> categoryTrees = new ArrayList<>();
    // 获取所有的工作组分类
    List<GroupCategory> categories = groupCategoryDao.findAll();
    if (!CollectionUtils.isEmpty(categories)) {
        // 所有工作组分类的ids
        List<Integer> categoryIds 
            = categories.stream().map(GroupCategory::getId).collect(Collectors.toList());
        // 所有工作组分类
        Map<Integer, GroupCategoryTree> map = new HashMap<>(categories.size());
        for (GroupCategory category : categories) {
            GroupCategoryTree groupCategoryTree = new GroupCategoryTree(category);
            map.put(category.getId(), groupCategoryTree);
        // 根据ids查出所有的工作组
        List<Group> groups = groupDao.findByCategoryIds(categoryIds);
        if (!CollectionUtils.isEmpty(groups)) {
            for (Group group : groups) {
                GroupCategoryTree groupCategoryTree = new GroupCategoryTree(group);
                GroupCategoryTree categoryTree = map.get(group.getCategoryId());
                categoryTree.getChildren().add(groupCategoryTree);
        for (Integer categoryId : map.keySet()) {
            categoryTrees.add(map.get(categoryId));
    return categoryTrees;
                    循环调用数据库会导致性能很差，所以千万不要循环调用数据库，对循环调用数据库的改进方法，就是把数据全部查出来，然后组装或者批量查询。存在的问题：for循环中存在批量查询数据库的情况，需要批量查询数据库处理掉2. 第一次改进后存在的问题：可以不要在for循环中组装map，而是放在for循环外组装好，在for循环中调用3. 第二次改进后4. 测试根据部门层级路径获取获取部门id接口比如根据 “部门/研发部/SIR” 获取SIR的部门id........................
实例086 在richtextbox控件中替换文本文字
实例087 利用richtextbox控件实现文字定位与标示
实例088 将数据表中的字段添加到combobox控件中
实例089 对listbox控件中的数据进行排序
实例090 listbox控件拒绝添加重复信息
实例091 限制用户名称长度及设置密码文本
实例092 带查询功能的combobox控件
实例093 利用选择控件实现权限设置
实例094 利用richtextbox控件显示图文数据
实例095 在listbox控件间交换数据
第10章 windows应用程序高级控件
实例096 使用imagelist组件制作动画图片
实例097 在combobox下拉列表中显示图片
实例098 在listview控件中实现修改功能
实例099 将数据库数据添加到listview控件
实例100 在listview控件中绘制底纹
实例101 在treeview控件节点中显示图片
实例102 使用树型列表动态显示菜单
实例103 使用treeview控件遍历磁盘目录
实例104 使用errorprovider组件验证文本框输入
实例105 使用helpprovider组件调用帮助文件
实例106 使listview控件中的选择项高亮显示
实例107 在列表视图中拖动视图项
实例108 实现带复选框的treeview控件
实例109 将xml文件节点绑定到treeview控件中
实例110 修改treeview控件的节点文本
第11章 c#面向对象高级技术
实例111 利用接口实现选择不同的语言
实例112 使用接口作为方法参数进行编程
实例113 自定义抽象类计算圆形的面积
实例114 重写抽象方法实现多态性
实例115 使用密封类密封登录用户信息
实例116 使用密封类封装个人身份证信息
实例117 使用迭代器显示公交车站点
实例118 通过迭代器实现文字的动态效果
实例119 使用分部类制作一个计算器
实例120 使用分部类显示员工信息
实例121 使用泛型存储不同类型的数据列表
实例122 使用泛型去掉数组中的重复数字
实例123 通过重写虚方法实现加法运算
实例124 使用迭代器实现倒序遍历
实例125 通过泛型查找数组中的元素
第12章 ado.net数据访问技术
实例126 连接加密的access数据库
实例127 使用odbc dsn连接sql server数据库
实例128 使用ado.net对象录入数据
实例129 利用存储过程录入数据
实例130 使用oledbdatareader读取文本文件的内容
实例131 使用sqldatareader读取用户登录信息
实例132 使用断开式连接的方式录入数据
实例133 使用断开式连接批量更新数据库中的数据
实例134 使datagridview控件中被选定单元格的所在行变色
实例135 在datagridview控件中隔行换色
实例136 连接excel文件
实例137 读取和保存用户头像
实例138 判断是否重复输入数据
实例139 删除datagridview控件中的指定行
实例140 将access数据库导入excel文件中
第13章 水晶报表与打印
实例141 设计带有背景图的水晶报表
实例142 设置水晶报表的打印日期与时间
实例143 设置水晶报表中节的背景图片
实例144 打印窗体中的数据
实例145 打印商品入库单据
实例146 使用打印控件实现分页打印
实例147 动态绑定水晶报表
实例148 在水晶报表中使用公式字段
实例149 设计分组统计报表
实例150 打印一个空学生证
实例151 自定义横向或纵向打印
实例152 自定义打印页码范围
第14章 文件及数据流技术
实例153 根据日期动态建立文件
实例154 将长文件名转换成短文件名
实例155 获取所有逻辑磁盘目录
实例156 使用递归法删除文件夹中的所有文件
实例157 按行读取文本文件中的数据
实例158 使用缓冲流复制文件
实例159 文件批量更名
实例160 复制文件时显示复制进度
实例161 对指定文件夹中的文件进行分类存储
实例162 将文本文件转换成网页文件
实例163 伪装文件夹
实例164 word目录提取工具
第15章 gdi+绘图
实例165 在图像中实现自定义标记
实例166 辉光效果的文字
实例167 渐变效果的文字
实例168 绘制多边形
实例169 简单画图程序
实例170 仿qq截图功能
实例171 模拟石英钟
实例172 绘制贝塞尔曲线
实例173 绘制图形验证码
实例174 以椭圆形显示图像
实例175 使用双缓冲技术绘图
实例176 批量添加图片水印
第16章 线程的使用
实例177 使用线程读取数据库中的数据
实例178 使用线程制作qq农场小游戏
实例179 使用线程实现大容量数据的计算
实例180 使用多线程制作端口扫描工具
实例181 使用线程扫描局域网ip地址
实例182 使用线程休眠控制图片以百叶窗效果显示
实例183 使用线程控制向窗体中拖放图片并显示
实例184 使用线程制作动画效果的状态栏
实例185 使用线程遍历文件夹
实例186 使用线程实现从左向右以拉伸的方式显示图像
第17章 网络编程技术
实例187 通过ip地址获取主机名称
实例188 创建web页面浏览器
实例189 获取网络信息及流量
实例190 远程关闭与重启计算机
实例191 设计点对点聊天程序
实例192 电子邮件的发送与接收
实例193 获取网络中所有工作组名称
实例194 列出指定工作组中的所有计算机名
实例195 监测当前网络连接状态
实例196 使用udp协议设计聊天室
第18章 注册表技术
实例197 禁止运行注册表
实例198 使应用程序开机自动运行
实例199 获取本机安装的软件清单
实例200 禁止使用windows任务管理器
实例201 清除ie地址栏中的历史网址
实例202 将磁盘驱动器隐藏
实例203 禁止使用命令提示符
实例204 禁止修改ie浏览器主页
实例205 设置ie浏览器的默认主页
实例206 设置ie浏览器的默认下载路径
第19章 c#语言新技术
实例207 使用隐式类型局部变量实现字母的大小写转换
实例208 使用扩展方法显示员工信息
实例209 使用lambda表达式查找指定字符串
实例210 检查序列中是否包含指定元素
实例211 使用linq在一个循环中遍历多个数组
实例212 过滤文章中包含指定单词的句子
实例213 使用linq生成随机序列
实例214 筛选指定类型的元素
实例215 使用linq技术对对象进行筛选操作
实例216 使用linq技术对对象进行排序操作
实例217 使用linq技术对对象进行聚合操作
实例218 使用linq技术对对象进行联接操作
第20章 windows应用程序打包部署
实例219 打包程序时设置桌面图标
实例220 打包.net framework 4.0框架
这里有两张表，表关系一对多，开发中常见的需求：
先分页查询出user表下的n条数据，再关联查询出note表中与之关联的表
比如：分页查询 每页10条用户（user）数据，返回结果需要携带每个用户发表的笔记（note）
2.菜鸟（我）的写法
这段代码只需要关注中间的查询过程
1.先进行分页查询，拿到全部的10条（user）数据。
2.使用循环查询每一条User下的全部note数据
1. 导入数据库模型：在过滤器所在的文件中导入需要使用的数据库模型。
2. 编写过滤器函数：根据需求编写过滤器函数，函数中可以调用数据库模型并执行相应的操作。
3. 注册过滤器：在应用程序中注册过滤器，将过滤器与相应的路由或视图函数进行绑定。
以下是一个示例代码：
```python
from flask import Flask, g
from models import User
app = Flask(__name__)
@app.before_request
def before_request():
    g.db = User.connect_db()
@app.after_request
def after_request(response):
    g.db.close()
    return response
@app.route('/users')
def get_users():
    users = g.db.query(User).all()
    return render_template('users.html', users=users)
在此示例中，我们在 before_request() 函数中连接数据库，并将连接对象保存在 Flask 的全局变量 g 中，以便在后续的请求中可以重用该连接。在 after_request() 函数中则关闭数据库连接。
在 get_users() 视图函数中，我们通过 g.db.query(User).all() 查询数据库中所有的用户，并将它们传递给模板进行渲染。
需要注意的是，为了避免在每个视图函数中都重复编写相同的代码，我们使用了 Flask 的过滤器机制，将数据库连接和关闭的操作封装在 before_request() 和 after_request() 函数中，并在应用程序中注册了这两个过滤器。
            报错：There is no supertype for types Int32, String because some of them are String/FixedString and som
            实战 - Restful APi 格式规范
            Kubernetes 工作中常见命令总结