福大软工1816 · 第五次作业 - 结对作业2

CVPR2018论文爬虫与数据分析
最新推荐文章于 2025-09-10 22:56:09 发布
最新推荐文章于 2025-09-10 22:56:09 发布
阅读量59 收藏
点赞数
CC 4.0 BY-SA版权
文章标签： java 爬虫 测试
原文链接：http://www.cnblogs.com/Sulumer/p/9766760.html
本文详细介绍了使用Java与JSoup库进行CVPR2018论文爬虫的设计与实现，包括爬取论文标题、摘要，统计词频与词组，以及生成作者排行榜等附加功能。

一、前言

结对队友：031602410 黄海潮

队友博客传送门
本次作业博客
Github项目传送门

二、分工细则

苏路明：

  • Python爬虫设计
  • 完善参数传入部分，词组分割部分，代码整合
  • 单元测试&代码覆盖率&性能测试
  • 附加题设计

黄海潮：

  • Python爬虫设计
  • java版词频统计，整改个人作业一成结对作业二

三、PSP表格

PSP2.1Personal Software Process Stages预估耗时（分钟）实际耗时（分钟）
Planning计划100150
· Estimate· 估计这个任务需要多少时间100150
Development开发700900
· Analysis· 需求分析 (包括学习新技术)150200
· Design Spec· 生成设计文档4060
· Design Review· 设计复审100150
· Coding Standard· 代码规范 (为目前的开发制定合适的规范)00
· Design· 具体设计100150
· Coding· 具体编码00
· Code Review· 代码复审00
· Test· 测试（自我测试，修改代码，提交修改）00
Reporting报告90160
· Test Repor· 测试报告90130
· Size Measurement· 计算工作量55
· Postmortem & Process Improvement Plan· 事后总结, 并提出过程改进计划3050
合计15052105

四、解题思路描述与设计实现说明

爬虫使用
自己使用java导入jsoup实现爬虫
1.给定网站地址

String rooturl = "http://openaccess.thecvf.com/CVPR2018.py";
        getContent(rooturl);

2.对每一篇进行爬取并所需的信息并且按照正确的格式输出到result.txt中

    try {
            File file = new File("cvpr\\result.txt");
            BufferedWriter bufferedWriter= new BufferedWriter(new FileWriter(file));
            org.jsoup.nodes.Document document = Jsoup.connect(rooturl).maxBodySize(0)
                                                .timeout(1000000)
                                                .get();
            Elements elements =  document.select("[class=ptitle]");
            Elements hrefs = elements.select("a[href]");
            int count = 0;
            for(Element element:hrefs) {
                String url = element.absUrl("href");
                org.jsoup.nodes.Document documrnt2 = Jsoup.connect(url).maxBodySize(0)
                                                    .timeout(1000000)
                                                    .get();
                Elements elements2 = (Elements) documrnt2.select("[id=papertitle]");
                String title = elements2.text();
                if(count != 0)
                    bufferedWriter.write("\r\n" + "\r\n" + "\r\n");
                bufferedWriter.write(count + "\r\n");
                bufferedWriter.write("Title: " + title + "\r\n");
                Elements elements3 = (Elements) documrnt2.select("[id=abstract]");
                String Abstract = elements3.text();
                bufferedWriter.write("Abstract: " + Abstract);
                count++;
            }
            bufferedWriter.close();
        }catch (Exception e) {
            // TODO: handle exception
            e.printStackTrace();
        }

代码组织与内部实现设计（类图）

  • 类图：
    1473263-20181010142417425-1619477545.png
    关于部分函数的结构及其函数的接口如下:
    public static String Read(String pathname) //对文件进行读取且处理 public static void FindWordArray(List<String> tempLists, int len, String wordsLine)//寻找符合题意的词组 public static void WordCount(List<String> tempLists,int weight)//统计权重 public static void SortMap(Map<String,Integer> oldmap,int wordline,int wordcount,int characterscount,int flagN)//进行排序并输出

  • 流程图：
    1473263-20181010135852642-1938576913.png

  • 说明算法的关键与关键实现：

    1.首先先对文本进行读取，且进行预处理，将文本内容转换为小写
    2.使用Pattern和Matcher对爬取出来的Title及Abstract内容进行抽取出来，此时readline（）逐行进行抽取，并且进行字符数和行数的统计
    3.根据之前的题意，对单词合法性进行判断，不合法的单词不进行处理
    4. 对词组进行分割，此时进行统计单词数
    5.根据判断w是否为1，进行单词或词组的权重统计
    6.进行排序后根据题意输出

五、附加题设计与展示

1.爬取作者信息，生成CVPR2018最强作者排行榜(将作者按关联论文数排序输出)
作者关联论文数排行榜
1474721-20181012150622356-219586908.png

2.爬取2014-2018年份的CVPR论文，按年份输出并分析论文数量趋势(部分链接404导致丢失部分论文）
2014-2018论文
趋势图（待）

3.五年汇总大牛词云(部分链接404导致丢失部分词汇）
1474721-20181012150310180-1317256387.png

4.近五年论文的热门词汇词云
1474721-20181012150323933-1818306734.png

六、关键代码解释

  • 部分代码展示如下：
    public static String Read(String pathname) throws Exception {
//      Scanner scanner=new Scanner(System.in);
//      String pathname=scanner.nextLine();


        Reader myReader = new FileReader(pathname);
        Reader myBufferedReader = new BufferedReader(myReader);
        

        //先对文本处理
        
        CharArrayWriter  tempStream = new CharArrayWriter();
        int i = -1;
        do {
            if(i!=-1)
                tempStream.write(i);
            i = myBufferedReader.read();
            if(i >= 65 && i <= 90){
                    i += 32;
            }
        }while(i != -1);
        myBufferedReader.close();
        Writer myWriter = new FileWriter(pathname);
        tempStream.writeTo(myWriter);
        tempStream.flush();
        tempStream.close();
        myWriter.close();
        return pathname;
    }
String readLine = null;
        Pattern pattern1 = Pattern.compile("(title): (.*)");
        Pattern pattern2 = Pattern.compile("(abstract): (.*)");
        while((readLine = bufferedReader.readLine()) != null)
        {  
            Matcher matcher1=pattern1.matcher(readLine);
            Matcher matcher2=pattern2.matcher(readLine);
            if(matcher1.find())
            {  
                characterscount+=matcher1.group(2).length();
                wordline++;
//              System.out.println(matcher1.group(2));
                String[] wordsArr1 = matcher1.group(2).split("[^a-zA-Z0-9]");  //过滤
                for (String newword : wordsArr1) {
                    if(newword.length() != 0){  
                        if((newword.length()>=4)&&(Character.isLetter(newword.charAt(0))&&Character.isLetter(newword.charAt(1))&&Character.isLetter(newword.charAt(2))&&Character.isLetter(newword.charAt(3)))) 
                        {
                            wordcount++;
                            if(len == 1)
                                lib.titleLists.add(newword);
                        }
                     }
                }
                
                //new
                String wordsLine = matcher1.group(2);
//              System.out.println("wordsLine " + wordsLine);
                if(len != 1 || wordsLine.length() < 4) {
                    lib.FindWordArray(lib.titleLists, len, wordsLine);
                }
             }
             if(matcher2.find())
             {
                 characterscount+=matcher2.group(2).length();
                 wordline++;
                 //System.out.println(matcher1.group(2));
                 String[] wordsArr2 = matcher2.group(2).split("[^a-zA-Z0-9]");  //过滤
                 for (String newword : wordsArr2) {  
                    if(newword.length() != 0){
                        if((newword.length()>=4)&&(Character.isLetter(newword.charAt(0))&&Character.isLetter(newword.charAt(1))&&Character.isLetter(newword.charAt(2))&&Character.isLetter(newword.charAt(3)))) 
                        {
                            wordcount++;
                            if(len == 1)
                                lib.abstractLists.add(newword);  
                        }
                    }  
                }
                 
                 String AbsLine = matcher2.group(2);
                 if(len != 1 || AbsLine.length() < 4) {
                    lib.FindWordArray(lib.abstractLists, len, AbsLine);
                 }
             }
        }
public static void FindWordArray(List<String> tempLists, int len, String wordsLine) {
        
        int tempi = 0;
        int cnti = 0;
        int cntt = 0;
        String temp = "";
        String[] words = new String[len];
        String[] separators = new String[len];
        for(int i = 0; i < wordsLine.length(); i++) {
            //The four words in front of a new word
            if (tempi < 4 && Character.isLetter(wordsLine.charAt(i)))
            {
                tempi ++;
//              System.out.println("<4 " + i + " " + wordsLine.charAt(i));
                temp = temp + wordsLine.charAt(i);
                
                //A new word appear.
                if (i == wordsLine.length() - 1) {
                    words[cnti%len] = temp;
                    cnti ++;
                    cntt ++;
//                  System.out.println("word " + temp);
                    
                    //A new wordarray appear.
                    if(cntt == len) {
                        String wordArray = "";
                        for(int j = 0; j < len; j++) {
                            wordArray = wordArray + words[(cnti + j)%len];
                            if(j != len-1)  wordArray = wordArray + separators[(cnti + j)%len];
                        }
                        tempLists.add(wordArray);
//                      System.out.println("wordArray " + wordArray);
                        cntt --;
                    }
                }
            }
            else if (tempi >= 4) {
                tempi ++;
                if(Character.isLetter(wordsLine.charAt(i)) || Character.isDigit(wordsLine.charAt(i))) {
//                  System.out.println("1 >=4 " + i + " " + wordsLine.charAt(i));
                    temp = temp + wordsLine.charAt(i);
                    
                    //A new word appear.
                    if (i == wordsLine.length() - 1) {
                        words[cnti%len] = temp;
                        cnti ++;
                        cntt ++;
//                      System.out.println("word " + temp);
                        
                        //A new wordArray appear.
                        if(cntt == len) {
                            String wordArray = "";
                            for(int j = 0; j < len; j++) {
                                wordArray = wordArray + words[(cnti + j)%len];
                                if(j != len-1)  wordArray = wordArray + separators[(cnti + j)%len];
                            }
                            
//                          add wordArray to list
                            tempLists.add(wordArray);
//                          System.out.println("wordArray " + wordArray);
                            cntt --;
                        }
                    }
                }
                else {
//                  System.out.println("2 >=4 " + i + " " + wordsLine.charAt(i));
                    
                    //A new word appear.And a separator appear.
                    words[cnti%len] = temp;
                    cnti ++;
                    cntt ++;
//                  System.out.println("word 123 " + temp);
                    if(cntt == len) {
                        String wordArray = "";
                        for(int j = 0; j < len; j++) {
                            wordArray = wordArray + words[(cnti + j)%len];
                            if(j != len-1)  wordArray = wordArray + separators[(cnti + j)%len];
                        }
//                      add wordArray to list
                        tempLists.add(wordArray);
//                      System.out.println("wordArray " + wordArray);
                        cntt --;
                    }
                    if (i + 4 >= wordsLine.length())
                        break;
                    tempi = 0;
                    temp = "";
                    
                    //draw a separator
                    String tempSeparator = "" + wordsLine.charAt(i);
//                  System.out.println("Separator" + tempSeparator + "123");
                    for(int j = 1; j < wordsLine.length() - i; j++) {
                        if( Character.isDigit(wordsLine.charAt(i+j)) || Character.isLetter(wordsLine.charAt(i+j)) ) {
//                          System.out.println("123");
                            temp = "";
                            separators[(cnti-1)%len] = tempSeparator;
                            break;
                        }
                        else    tempSeparator = tempSeparator + wordsLine.charAt(i+j);
                    }
                }
            }
            
            //A invalid word appear
            else {
//              System.out.println("invalid " + i + "" + wordsLine.charAt(i));
                if (i + 4 >= (int)wordsLine.length()) 
                    break;
                tempi = 0;
                temp = "";
                cnti = 0;
                cntt = 0;
            }
        }
    }
public static void WordCount(List<String> tempLists,int weight) {
        for (String li : tempLists) {  
            if(wordsCount.get(li) != null){ 
                wordsCount.put(li,wordsCount.get(li) + weight);  
            }else{  
                wordsCount.put(li,weight);  
            }  
  
        } 
    }
public static void SortMap(Map<String,Integer> oldmap,int wordline,int wordcount,int characterscount,int flagN) throws IOException{  
        
        ArrayList<Map.Entry<String,Integer>> list = new ArrayList<Map.Entry<String,Integer>>(oldmap.entrySet());  
          
        Collections.sort(list,new Comparator<Map.Entry<String,Integer>>(){  
            @Override  
            public int compare(Entry<String, Integer> o1, Entry<String, Integer> o2) {  
                return o2.getValue() - o1.getValue();  //降序  
            }  
        });  
        File file = new File("result.txt");
        BufferedWriter bi = new BufferedWriter(new FileWriter(file));
        bi.write("characters: "+characterscount+"\r\n");
        bi.write("words: "+wordcount+"\r\n");
        bi.write("lines: "+wordline+"\r\n");
        int flag = 0;
        for(int i = 0; i<list.size(); i++){  
            if(flag>=flagN) break;
            if(list.get(i).getKey().length()>=4)
                bi.write("<"+list.get(i).getKey()+">"+ ": " +list.get(i).getValue()+"\r\n"); 
            flag++;
        }
        bi.close();
    }

七、性能分析与改进

  • 改进思路
    1.统计单词和统计词组是分离的，导致程序性能有所下降，可改善整合统计单词和统计词组部分。
    2.在分割词组时，采用逐字符读取，使用循环数组保存单词和分隔符，如改善使用正则匹配，性能应该会有所提升。
    3.在统计长文件时，字符数会和他人有所不同(貌似一人一个答案)，寻求了解决方案后发现好像是由于存在非ASCII码的原因，改善问题不在此次作业范围内。
    4.其余部分在个人作业时，所表现的性能还是比较好的，暂时没有改善的思路。

  • 代码覆盖率
    1474721-20181011012221999-434837612.png

  • 性能测试
    1474721-20181011012338814-438969164.png

八、单元测试

以下为我进行的单元测试，包含大概的描述和输出的信息
1473263-20181012184137577-1083130898.png

九、Github的代码签入记录

1474721-20181011012156540-1796481234.png

十、遇到的代码模块异常或结对困难及解决方法

  • 问题描述：
    1.使用python进行爬虫时有时候缺少部分内容
    2.使用正则分割去出单词时，无法保留最后需输出的分隔符
  • 做过哪些尝试：
    1.对代码进行查错，上网查询类似问题及解决方法，对代码进行改进。
    2.对正则进行更多学习了解，使用其他方法进行分割保留分隔符
  • 是否解决：
    通过重新学习写一个java的爬虫解决问题.
  • 有何收获：
    解决一个问题的时候，如果一种方式怎么样都做不到，解决不了，可以尝试换一种方法来解决

十一、我的队友

  • java基础不错，一点点java基础的我，决定在这次软工实践中多多锻炼加强学习，好在队友java比我好多了，着实抱到大腿了，希望他可以继续带飞我。
  • 遇到问题都会寻求解决方法而不是退缩，赞！
  • 态度积极，值得学习。

十二、学习进度条

第N周新增代码(行)累计代码(行)本周学习耗时(小时)累计学习耗时(小时)重要成长
130030088入门Visual studio的使用(包括单元测试)
20300614了解正则表达式的使用
303001024加深掌握了Axure的使用，学会了使用NABCD模型进行需求分析
45008003660加强了python/java爬虫基础,在java代码方面有很大的提升，解除了数据分析和可视化设计

转载于:https://www.cnblogs.com/Sulumer/p/9766760.html

2022秋软工实践 第二次结对编程作业
dongy_u的博客
10-11 502
因此，针对逃课的两种类型：理性逃课和惰性逃课，我们的算法中设计了不同的点名策略，以提高有效点名率。我们通过Java实现数据集的生成和点名端策略算法，并通过Mysql展示每次的学生出勤情况和点名情况。我们先按序产生学生的学号和姓名，之后按照正态分布，产生所有学生的绩点（2.0,0.5）。由于考虑到补考通过时，该学生绩点至少为1，因此，我们的绩点生成范围为1-4之间，不考虑绩点小于1的情况。又由于遵循了3σ原则，我们产生的绩点在1-4范围内的概率有0.9544，几乎可以看做是必然事件（但我们还是做了限制，对于产
软件工程第一次结对作业 -原型设计
qdwfq3的博客
03-08 1221
最后，我们在解决这些困难的过程中也获得了不小的收获。其次，我们也意识到了团队协作和沟通的重要性，只有建立了高效的工作流程和良好的沟通机制，才能确保项目的顺利进行。在未来的工作中，我们将继续发扬这种不畏困难、勇于尝试的精神，不断提升自己的专业素养和团队协作能力，为公司的发展贡献更多的力量。在实现原型设计的过程中，我们遇到了多方面的困难，这些困难既有技术层面的，也有流程和组织层面的。下面，我将详细描述我们遇到的困难、为解决这些困难所做的尝试、以及最终的解决情况，并谈谈这些经历给我们带来的收获。
2021秋软工实践第二次结对编程作业
secretmem的博客
10-09 340
2021秋软工实践第二次结对编程作业 这个作业属于哪个课程 构建之法-2021秋-福州大学软件工程 这个作业要求在哪里 2021秋软工实践第二次结对编程作业 个人学号 031902130 结对成员学号 031902101 结对成员博客链接 GitHub 仓库地址 GitHub - yddtcsn/bobing 视频演示链接 重点难点分析 本次实验在初次拿到题目，经过简单商讨后，我们最后打算用JavaScrip...
2021秋软工实践第一次结对编程作业
qq_48659670的博客
09-29 312
第一次结对编程作业 这个作业属于哪个课程 构建之法-2021秋-福州大学软件工程 https://bbs.youkuaiyun.com/forums/fzuSoftwareEngineering2021 这个作业要求在哪里 2021秋软工实践第一次结对编程作业 https://bbs.youkuaiyun.com/topics/600868519 这个作业的目标 结对完成任务并学会原型设计 学号 031902140 队友学号 031802125 队友博客地址 需求..
软件工程实践结对作业二
半疯的博客
03-26 1661
这个作业属于哪个课程 <2022年福大-软件工程、实践-W班> 这个作业要求在哪里 <软件工程实践结对作业一> 这个作业的目标 <结对合作，NABCD模型，需求分析，原型设计> 结对学号 <221900112、221900104> 其他参考文献 见文章末尾 文章目录1、原型设计地址2、NABCD模型分析2.1 N（Need，需求）2.2 A（Approach，做法）2.3 B（Benefit，好处）2.4 C（Competit...
二叉树的前中后序遍历(迭代法)
mrjieke6的博客
09-07 1280
本文系统介绍了二叉树前序、中序和后序遍历的迭代实现方法。前序遍历采用栈结构，按;根→右→左 ;顺序入栈；中序遍历先全部左子树入栈再访问节点；后序遍历则通过修改前序遍历顺序为"根→右→左 ;后反转结果。三种遍历时间复杂度均为O(n)，空间复杂度最坏O(n)。与递归实现相比，迭代方法避免了栈溢出风险，处理大型树更稳定。每种遍历方式都配有详细代码解析、执行示例和复杂度分析，并讨论了实际应用场景，为掌握树结构操作提供了系统指导。
基于SpringBoot和uni-app开发的陪诊陪护软件系统源码
程序员创业中
09-06 1480
中国60岁以上人口已突破3.1亿，独居老人超1.3亿，而一线城市三甲医院日均门诊量超万人次。在这组数据背后，是无数家庭面临的困境：子女异地工作无法陪同父母就医，独居老人因不会操作智能设备在挂号机前徘徊，异地患者因不熟悉流程在医院迷路……当“就医”从个人事务演变为社会难题，陪诊陪护系统正以“专业服务+技术赋能”的双重模式，成为破解这一困局的关键。
大数据毕业设计选题推荐-基于大数据的贵州茅台股票数据分析系统-Spark-Hadoop-Bigdata
IT研究室的博客
09-07 993
本文介绍了基于Hadoop+Spark的贵州茅台股票数据分析系统，采用Python/Java语言开发，集成Django/Spring Boot后端与Vue前端，实现多维金融数据分析。系统核心功能包括价格趋势分析、成交量跟踪、波动性评估及技术指标验证，通过Spark SQL和Pandas处理海量交易数据，支持日均价格走势、价量相关性、MACD/RSI指标等深度挖掘。界面展示包含Echarts动态可视化图表，代码示例演示了Spark计算日均均价、20日均线及价格区间统计逻辑。
从Java全栈开发到微服务架构的实战经验分享
CatchLight的博客
09-09 760
应聘者：我认为最重要的是能够理解业务需求，并将其转化为技术方案。同时，持续学习新技术，保持对行业趋势的关注也很关键。毕竟，技术更新很快，只有不断学习才能跟上节奏。通过这次面试，我们可以看到一位资深Java全栈开发者的专业能力和实践经验。他不仅掌握了多种技术栈，还能在实际业务场景中灵活运用，解决实际问题。同时，他也展现了良好的沟通能力和学习能力，这些都是成为一名优秀工程师的关键素质。
Java内存区域与内存溢出
DKPT的博客
09-07 624
Java内存溢出的核心在于内存分配与回收失衡，需结合区域特性针对性解决。堆溢出最常见，需重点排查泄漏；方法区溢出多因动态类加载失控；直接内存溢出则需关注NIO使用。通过工具分析+代码优化+参数调优的组合策略，可显著降低OOM风险。二、内存溢出（OOM）类型与触发场景。三、内存溢出诊断与解决策略。一、Java内存区域划分。
从Java全栈到前端框架的实战之路
CatchLight的博客
09-10 767
面试官我们会在几天内通知你面试结果。应聘者面试官：加油！期待你加入我们团队。Java版本：Java 11和Java 17，注重性能优化和新特性支持。JVM内存模型：理解堆、栈、方法区等组成部分。前端技术栈：Vue3和TypeScript，使用Element Plus进行UI开发。微服务架构：使用Spring Cloud和OpenFeign进行服务治理。数据库与ORM：MyBatis和JPA，根据项目需求选择合适框架。测试与调试。
【lucene】bitsetiterator
risc123456的博客
09-09 375
某些自定义 `FieldCache` 或 `DocValues` 去重逻辑，会先把出现过的 docID 记到 `BitSet`，再用 `BitSetIterator` 一次性吐出。`BitSet` 本身只有 `get()/set()/nextSetBit(int)`，没有标准的迭代器语义，于是就有了 `BitSetIterator` 做适配。- `cost()` 直接返回 `cardinality()`，方便上层 `ConjunctionDISI/DisjunctionDISI` 做排序、选 lead。
计算机毕设 java 高校饭堂点餐系统 基于微信小程序 + SSM 的高校餐饮服务平台 Java+MySQL 的点餐与运营系统
毕设源码伍学长
09-10 696
在高校饭堂就餐需求增长的背景下，传统点餐依赖窗口排队、效率低，存在高峰期拥堵、菜品信息不透明等问题，难以满足师生便捷就餐需求。采用 Java 技术、SSM 框架、Uni-weixin 技术及 MySQL 数据库，开发高校饭堂点餐系统（微信小程序端 + 服务端），整合菜品展示、在线点餐、订单跟踪等功能，支持管理员、商家、用户三类角色协同，打造专业化餐饮服务平台。该系统既能帮助管理员监管平台内容，商家高效管理菜品与订单，又能让用户便捷查询菜品、完成点餐，提升高校饭堂服务效率与用户体验。
Java编程规范（2025最新版）
TFHoney的博客
09-08 1030
本文介绍了Java编程规范的重要性及核心细则。规范能提高代码可读性、减少Bug、提升开发效率和团队协作能力。主要内容包括：1.命名规范（包名、类名、方法名等）；2.代码格式（缩进、行宽、空格等）；3.OOP规约（方法覆写、基本类型使用）；4.集合处理（判空、遍历）；5.并发控制（线程池使用）；6.控制语句要求；7.注释规范。文章推荐使用IDE格式化工具和Alibaba插件辅助检查，强调规范是提高代码质量的重要手段而非束缚。
java LHashSet源码分析/Hashtable/Properties
2301_81088399的博客
09-07 316
数组是HashMap$Node[],存放的元素或者数据是LinkedHashMap$Entry,实际上是一种多态现象。Entry是静态内部类，而这个内部类继承了HashMap.Node。1.底层有数组Hashtable$Entry[]，初始化大小为11。有图可得，底层确实用的是LinkedHashMap。2.临界值threshold 8=11*0.75。如果扩容到了最大的大小，会直接return。进行put时，底层实际还是map那一套。3.扩容：超过临界值时，容量*2+1。Hashtable的底层。
【postMan / apifox 文件上传】
最新发布
weixin_48937140的博客
09-10 122
postman 文件上传
JAVA基本文件操作
2501_90864902的博客
09-06 457
本文介绍了Java文件操作的基本方法。首先讲解了三种创建文件的方式：直接路径创建、父目录+子路径创建和组合路径创建，并指出createNewFile()才是实际创建文件的方法。其次列举了常用文件操作方法，包括获取文件名、路径、大小、判断文件类型等。最后演示了单级目录和多级目录的创建方法，使用mkdir()和mkdirs()分别实现。文章强调在Java中文件和目录的调用形式相同，需要注意区分。
结合Spring Security 框架+ JWT，Java实现短信验证码、账号密码Token认证登录
Mai_Jun_Hao的博客
09-09 763
本文介绍了基于Spring Security实现双因素认证（账号密码+短信验证码）的技术方案。系统采用JWT令牌进行无状态认证，关键实现包括：1）自定义安全配置类整合多种认证方式；2）SM3国密算法加密存储密码；3）SM2非对称加密保障传输安全；4）JWT过滤器实现Token校验与续期；5）异常处理机制精细化权限管控。方案通过组合AuthenticationProvider、自定义UserDetailsService和密码编码器等核心组件，构建了支持多种登录方式的安全认证体系，同时确保密码在传输和存储过程中
龙芯架构powerjob-server镜像构建
noscallion的博客
09-08 196
powerjob-server 在 dockerhub 官方镜像中不支持龙芯架构，并且提供的 Dockerfile 中的基础i镜像也不支持。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值