[Java实现点赞功能的缓存机制设计 ]的搜索结果

...为高级源代码形式（如Java、C等），使得开发人员能够阅读和理解原始程序员的意图。在本文中提到的jadx即是一款用于Android APK反编译的工具，可将apk文件中的Dalvik字节码反编译为易于阅读的Java源代码。 Dalvik字节码 , Dalvik字节码是Android平台使用的虚拟机——Dalvik VM执行的一种中间代码格式。每个Android应用在安装到设备上时，都会被编译成Dalvik字节码，这种格式相较于Java字节码进行了优化以适应移动设备资源有限的特点。在使用jadx进行反编译时，可以将apk中的Dalvik字节码还原为Java源代码。 Frida , Frida是一个动态代码插桩工具，主要用于对运行中的程序进行动态分析和调试。在文中提到，通过jadx可以方便地复制类名，并在Frida中使用Java.use方法加载该类，实现对目标应用的运行时监控和控制。例如，var RpcSignUtil = Java.use(com.xxxxx.xxxxx.common.transport.utils.RpcSignUtil); 这段代码就是在Frida环境中利用jadx获取的类名动态挂钩并操作目标应用的方法。通过这样的方式，安全研究人员和开发者能够在无需源代码的情况下深入研究应用程序的行为和功能实现。

.... 在所有节点上安装Java开发工具包 (JDK) 2. 下载并解压Hadoop源码 3. 配置环境变量 4. 启动Hadoop守护进程 接下来，我们将详细介绍每一步骤的具体内容。 1. 安装JDK Hadoop需要运行在Java环境中，因此你需要在所有的Hadoop节点上安装JDK。以下是Ubuntu上的安装步骤： bash sudo apt-get update sudo apt-get install default-jdk 如果你使用的是其他操作系统，可以参考官方文档进行安装。 2. 下载并解压Hadoop源码 你可以从Hadoop官网下载最新版本的Hadoop源码。以下是在Ubuntu上下载和解压Hadoop源码的命令： bash wget https://www.apache.org/dist/hadoop/common/hadoop-3.3.0/hadoop-3.3.0.tar.gz tar -xvf hadoop-3.3.0.tar.gz cd hadoop-3.3.0 3. 配置环境变量 Hadoop需要在PATH环境变量中添加bin目录，以便能够执行Hadoop脚本。另外，你还需要把JAVA_HOME这个环境变量给设置好，让它指向你安装JDK的那个路径。以下是Ubuntu上的配置命令： bash export PATH=$PATH:$PWD/bin export JAVA_HOME=/usr/lib/jvm/java-8-openjdk-amd64 4. 启动Hadoop守护进程 启动Hadoop守护进程，包括NameNode、DataNode和JobTracker等服务。以下是Ubuntu上的启动命令： bash ./sbin/start-dfs.sh ./sbin/start-yarn.sh 三、停止Hadoop集群 与启动相反，停止Hadoop集群也非常简单，只需关闭相关守护进程即可。以下是停止Hadoop守护进程的命令： bash ./sbin/stop-dfs.sh ./sbin/stop-yarn.sh 四、总结 启动和停止Hadoop集群并不复杂，但需要注意的是，这些命令需要在Hadoop安装目录下执行。另外，在实际生产环境中，你可能需要添加更多的安全性和监控功能，例如防火墙规则、SSH密钥认证、Hadoop日志监控等。希望这篇文章能对你有所帮助！

在深入理解Java Swing和JavaFX在图形界面开发中的应用后，我们可以进一步探索这两个工具包在现代软件开发领域的最新动态和实践案例。近期，OpenJFX项目持续更新，为JavaFX带来了诸多改进，如增强的高性能图形渲染引擎、对高清屏幕的支持以及与Java 17 LTS版本的紧密集成。同时，开源社区也在积极研发各种UI框架，以适应跨平台和云原生环境的需求，例如JPro和GluonHQ推出的解决方案，它们不仅支持桌面应用，还扩展到了移动设备和Web端。 对于Swing爱好者和遗留系统维护者来说，尽管Swing的主流地位已被JavaFX逐渐取代，但其在特定场景下仍有不可替代的价值。IBM Developer网站上的一篇技术文章就详细讨论了如何在现代化环境中优化Swing应用，包括性能调优、与JavaFX组件的混合使用策略以及利用最新JVM特性进行兼容性升级。 此外，随着现代IDE如IntelliJ IDEA功能的不断丰富和完善，GUI设计工具链也在持续迭代，使得开发者能够更加便捷高效地设计和实现复杂用户界面。例如，JetBrains官方博客中关于使用IntelliJ IDEA GUI Designer设计Swing和JavaFX应用程序的文章，提供了大量实用技巧和最佳实践，值得开发者深入阅读和学习。 最后，针对ScrcpyController这一具体应用场景，可以关注其背后的开源项目Scrcpy的发展动态。Scrcpy作为一款流行的Android设备无线控制工具，已通过众多开发者为其开发GUI前端来提升用户体验，这其中就涉及到了Swing和JavaFX等技术的实际运用，而这些实践经验和代码示例无疑为Java GUI开发者提供了宝贵的学习资源。

Java中常用类和方法合集：探索实践之旅 在Java编程的世界里，一些基础且常用的类与方法就像构建我们代码帝国的基石。它们不仅简化了我们的开发工作，也赋予了程序强大的功能和灵活性。在这篇文章里，咱们就手拉手，通过一些实实在在的例子，好好唠一唠Java里那些必不可少、缺了它们程序就玩不转的核心类和方法吧！ 1. String类及其方法 （1）创建和操作字符串 在Java中，String类是我们经常打交道的对象之一。比如创建一个字符串： java String str = "Hello, World!"; 然后，我们可以使用它的各种方法来操作这个字符串： java // 获取字符串长度 int length = str.length(); // 查找子串 int index = str.indexOf("World"); // 截取子串 String subStr = str.substring(index); （2）字符串拼接 注意，虽然我们不能直接改变String对象的内容（因为它不可变），但可以利用concat()或StringBuilder进行拼接： java String str1 = "Java"; String str2 = "编程"; // 使用concat()方法拼接 String result = str1.concat(str2); // 或者使用StringBuilder效率更高 StringBuilder sb = new StringBuilder(); sb.append(str1).append(str2); String result2 = sb.toString(); 2. ArrayList类及其方法 ArrayList是Java集合框架中非常重要的一个类，用于存储可变大小的数组。 java // 创建ArrayList ArrayList list = new ArrayList<>(); // 添加元素 list.add("Java"); list.add("Python"); list.add("C++"); // 访问元素 String firstElement = list.get(0); // 遍历元素 for (String lang : list) { System.out.println(lang); } // 删除元素 list.remove("C++"); 3. Date和Calendar类处理日期时间 处理日期和时间时，我们会用到Date和Calendar类： java // 创建Date对象表示当前时间 Date now = new Date(); // 使用Calendar类获取特定日期信息 Calendar cal = Calendar.getInstance(); cal.setTime(now); int year = cal.get(Calendar.YEAR); int month = cal.get(Calendar.MONTH); int day = cal.get(Calendar.DAY_OF_MONTH); System.out.printf("Current date is: %d-%d-%d", year, month + 1, day); 4. File类实现文件操作 File类提供了与文件系统交互的能力： java // 创建File对象 File file = new File("test.txt"); // 判断文件是否存在 boolean exists = file.exists(); // 创建新文件 file.createNewFile(); // 删除文件 file.delete(); 以上仅是Java众多常用类和方法的冰山一角，每个方法背后都蕴含着丰富的设计理念和技术细节。在实际敲代码的时候，咱们得根据实际情况灵活耍弄这些工具，不断动脑筋、动手尝试、一步步改进，才能真正把这些工具的精要吃透。同时，千万要记住，随着科技的日新月异，Java库可是一直在不断丰富和进化，时常有各种新鲜出炉、实用性爆棚的类和方法加入进来。这就是Java语言让人着迷的地方——它始终紧跟时代的步伐，始终保持年轻活力，为开发者们提供最高效、最省心省力的解决办法。

...ap-column-java和--map-column-hive选项来映射Java类型到Hive类型。但是，如果我们需要直接同步到MySQL，可以考虑以下几种方法： 方法一：手动同步表结构 最直接的方法是手动创建目标表。例如，假设我们的源表employees有以下结构： sql CREATE TABLE employees ( id INT, name VARCHAR(50), age INT ); 我们可以在MySQL中创建一个同名表： sql CREATE TABLE employees ( id INT, name VARCHAR(50), age INT ); 然后使用Sqoop导入数据： bash sqoop import \ --connect jdbc:mysql://localhost:3306/mydb \ --username myuser \ --password mypassword \ --table employees \ --target-dir /user/hadoop/employees 这种方法虽然简单，但不够自动化，而且每次修改源表结构后都需要手动更新目标表结构。 方法二：使用Sqoop的--map-column-java和--map-column-hive选项 我们可以使用Sqoop的--map-column-java和--map-column-hive选项来确保数据类型的一致性。例如，如果我们想将HDFS中的数据导入到MySQL中，可以这样操作： bash sqoop import \ --connect jdbc:mysql://localhost:3306/mydb \ --username myuser \ --password mypassword \ --table employees \ --target-dir /user/hadoop/employees \ --map-column-java id=Long,name=String,age=Integer 这里，我们明确指定了Java类型的映射，这样即使HDFS中的数据类型与MySQL中的不同，Sqoop也会自动进行转换。 方法三：编写脚本自动同步表结构 为了更加自动化地管理表结构同步，我们可以编写一个简单的脚本来生成SQL语句。比如说，我们可以先瞧瞧源表长啥样，然后再动手写SQL语句，创建一个和它长得差不多的目标表。以下是一个Python脚本的示例： python import subprocess 获取源表结构 source_schema = subprocess.check_output([ "sqoop", "list-columns", "--connect", "jdbc:mysql://localhost:3306/mydb", "--username", "myuser", "--password", "mypassword", "--table", "employees" ]).decode("utf-8") 解析结构信息 columns = [line.split()[0] for line in source_schema.strip().split("\n")] 生成创建表的SQL语句 create_table_sql = f"CREATE TABLE employees ({', '.join([f'{col} VARCHAR(255)' for col in columns])});" print(create_table_sql) 运行这个脚本后，它会输出如下SQL语句： sql CREATE TABLE employees (id VARCHAR(255), name VARCHAR(255), age VARCHAR(255)); 然后我们可以执行这个SQL语句来创建目标表。这种方法虽然复杂一些，但可以实现自动化管理，减少人为错误。 5. 结论 通过以上几种方法，我们可以有效地解决Sqoop导入数据时表结构同步的问题。每种方法都有其优缺点，选择哪种方法取决于具体的需求和环境。我个人倾向于使用脚本自动化处理，因为它既灵活又高效。当然，你也可以根据实际情况选择最适合自己的方法。 希望这些内容能对你有所帮助！如果你有任何问题或建议，欢迎随时留言讨论。我们一起学习，一起进步！

...radle的依赖管理机制非常强大，它允许我们以声明式的方式定义项目所需的各种库（或称依赖）。这些依赖项，你可以从本地的文件夹、Maven那个大仓库、Ivy的存储地，甚至其他远在天边的远程仓库里通通把它们捞出来。理解这一点是正确配置和打包依赖的关键。 1.1 在build.gradle文件中声明依赖 每个Gradle项目都有一个或多个build.gradle文件，这是配置项目构建过程的地方。在这里，我们可以用groovy或者kotlin DSL来声明依赖。例如： groovy dependencies { // 声明一个Java项目的编译期依赖 implementation 'com.google.guava:guava:30.1-jre' // 声明测试相关的依赖 testImplementation 'junit:junit:4.13.2' // 声明运行时需要但编译时不需要的依赖 runtimeOnly 'mysql:mysql-connector-java:8.0.26' } 上述代码中，我们在dependencies块内通过implementation、testImplementation和runtimeOnly等方式分别指定了不同类型的依赖。 2. 控制依赖范围与传递性 2.1 依赖范围 Gradle为依赖提供了多种范围，如implementation、api、compileOnly等，用于控制依赖在编译、测试及运行阶段的作用域。比方说，implementation这个家伙的作用，就好比你有一个小秘密，只告诉自己模块内部的成员，不会跑去跟依赖它的其他模块小伙伴瞎嚷嚷。但是，当你用上api的时候，那就相当于你不仅告诉了自家模块的成员，还大方地把这个接口分享给了所有下游模块的朋友。 2.2 依赖传递性 默认情况下，Gradle具有依赖传递性，即如果A模块依赖B模块，而B模块又依赖C模块，那么A模块间接依赖了C模块。有时我们需要控制这种传递性，可以通过transitive属性进行设置： groovy dependencies { implementation('org.hibernate:hibernate-core:5.6.9.Final') { transitive = false // 禁止传递依赖 } } 3. 使用定制化仓库 除了标准的Maven中央仓库，我们还可以添加自定义的仓库地址来下载依赖包： groovy repositories { mavenCentral() // 默认的Maven中央仓库 maven { url 'https://maven.example.com/repo' } // 自定义仓库 } 4. 打包时包含依赖 当执行gradle build命令时，Gradle会自动处理并包含所有已声明的依赖。对于Java应用，使用jar任务打包时，默认并不会将依赖打进生成的jar文件中。若需将依赖包含进去，可采用如下方式： groovy task fatJar(type: Jar) { archiveBaseName = 'my-fat-app' from { configurations.runtimeClasspath.collect { it.isDirectory() ? it : zipTree(it) } } with jar } 这段代码创建了一个名为fatJar的任务，它将运行时依赖一并打包进同一个jar文件中，便于部署和运行。 总结来说，掌握Gradle依赖管理的核心在于理解其声明式依赖配置以及对依赖范围、传递性的掌控。同时，咱们在打包的时候，得瞅准实际情况，灵活选择最合适的策略把依赖项一并打包进去，这样才能保证咱们的项目构建既一步到位，又快马加鞭，准确高效没商量。在整个开发过程中，Gradle就像个超级灵活、无比顺手的工具箱，让开发者能够轻轻松松解决各种乱七八糟、错综复杂的依赖关系难题，真可谓是个得力小助手。

...大了！它的注解处理器机制就像是给开发者们插上了一对翅膀，让他们能够以前所未有的方式去自由扩展和定制编译流程，简直酷毙了！今天，咱们就手牵手，一起踏入Groovy注解处理器的神奇天地吧！咱会通过一些实实在在的代码实例，让你亲身体验它那让人着迷的独特魅力。 2. Groovy注解处理器基础 Groovy注解处理器是基于Java的JSR-269标准实现的，可以在编译时扫描并处理源代码中的注解，从而生成新的类、方法或其他程序元素。这就像一个神奇的“预处理器”，在我们的代码真正执行前就对其进行加工和优化。 groovy @MyCustomAnnotation class MyClass { // ... } 在上面的例子中，@MyCustomAnnotation就是一个自定义注解，如果我们有一个对应的注解处理器，那么在编译阶段，它就能检测到这个注解，并根据注解的含义进行相应的处理。 3. 创建Groovy注解处理器 （1）定义注解 首先，我们需要定义一个注解，例如： groovy import java.lang.annotation. @Retention(RetentionPolicy.RUNTIME) @Target(ElementType.TYPE) @interface MyCustomAnnotation { String value() default "default_value" } 这里的MyCustomAnnotation是一个简单的注解，它可以被应用于类型上，并且具有一个可选的属性value。 （2）实现注解处理器 接下来，我们创建一个实现了org.codehaus.groovy.transform.ASTTransformation接口的类，作为我们的注解处理器： groovy import org.codehaus.groovy.ast.; import org.codehaus.groovy.control.CompilePhase; import org.codehaus.groovy.transform.GroovyASTTransformation; @GroovyASTTransformation(phase = CompilePhase.CANONICALIZATION) public class MyCustomAnnotationProcessor implements ASTTransformation { @Override void visit(ASTNode[] nodes, SourceUnit source) { ClassNode annotatedClass = (ClassNode) nodes[1]; AnnotationNode annotationNode = (AnnotationNode) nodes[0]; // 获取注解的值 String annotationValue = annotationNode.getMember("value").toString(); // 这里进行具体的处理逻辑，如修改类定义等 // ... } } 在这个处理器中，visit方法会在编译期间被调用，我们可以在这里读取注解的信息并对类结构进行修改。 4. 注解处理器的应用及思考 想象一下，当我们为MyCustomAnnotation编写了一个实际的处理器后，就可以对标记了该注解的类进行各种有趣的操作，比如生成日志代码、实现AOP切面编程、动态生成数据库访问层等等。这种能力让Groovy如虎添翼，灵活性和实用性蹭蹭上涨，开发者们能够更“接地气”地深入到编译的各个环节，亲手打造更高层次的抽象和自动化功能，简直爽翻天！ 当然，在享受这种强大功能的同时，我们也需要谨慎地权衡。过多的编译时处理可能会增加项目的复杂度，使得代码变得难以理解和维护。所以在实际编程干活儿的时候，咱们得瞅准具体的需求，聪明地、恰到好处地用上Groovy注解处理器这个小功能，别浪费也别滥用。 结语 总的来说，Groovy的注解处理器为我们提供了一种深度介入编译过程的方式，使我们有机会创造出更为高效、精简的代码结构。让我们怀揣着对编程艺术的满腔热爱，就像拥有了Groovy注解处理器这个强大的秘密武器，一起勇往直前去探索、去创新，一块儿携手并肩，让软件工程的世界不断向前奔跑，蓬勃发展！下次你要是碰到个编程难题，纠结得头发都快薅光了，试试看用Groovy注解处理器来对付它，没准儿能给你整出个意料之外、惊喜连连的解决方案！

在Hadoop中实现高效的数据转换和处理过程 随着大数据时代的到来，Hadoop作为一个开源的分布式计算框架，以其卓越的大数据存储与处理能力赢得了广泛的认可。本文将深入探讨如何在Hadoop环境中实现高效的数据转换和处理过程，通过实例代码揭示其背后的奥秘。 1. Hadoop生态系统简介 Hadoop的核心组件主要包括HDFS（Hadoop Distributed File System）和MapReduce。HDFS负责海量数据的分布式存储，而MapReduce则提供了并行处理大规模数据集的强大能力。在此基础上，我们可以通过编写特定的Map和Reduce函数，实现对原始数据的转换和处理。 2. 数据转换 Map阶段 让我们首先通过一个简单的示例理解Hadoop MapReduce中的数据转换过程： java import java.io.IOException; import org.apache.hadoop.io.IntWritable; import org.apache.hadoop.io.LongWritable; import org.apache.hadoop.io.Text; import org.apache.hadoop.mapreduce.Mapper; public class WordCountMapper extends Mapper { private final static IntWritable one = new IntWritable(1); private Text word = new Text(); public void map(LongWritable key, Text value, Context context) throws IOException, InterruptedException { String line = value.toString(); for (String eachWord : line.split("\\s+")) { word.set(eachWord); context.write(word, one); // 将单词作为key，计数值1作为value输出 } } } 这段代码是Hadoop实现词频统计任务的Mapper部分，它实现了数据从原始文本格式到键值对形式的转换。当Map阶段读取每行文本时，将其拆分为单个单词，并以单词为键、值为1的形式输出，实现了初步的数据转换。 3. 数据处理 Reduce阶段 接下来，我们看下Reduce阶段如何进一步处理这些键值对，完成最终的数据聚合： java import java.io.IOException; import org.apache.hadoop.io.IntWritable; import org.apache.hadoop.io.Text; import org.apache.hadoop.mapreduce.Reducer; public class WordCountReducer extends Reducer { public void reduce(Text key, Iterable values, Context context) throws IOException, InterruptedException { int sum = 0; for (IntWritable val : values) { sum += val.get(); // 对所有相同键的值进行累加 } context.write(key, new IntWritable(sum)); // 输出每个单词及其出现次数 } } 在上述Reducer类中，对于每一个输入的单词（键），我们将所有关联的计数值（值）相加，得到该单词在整个文本中的出现次数，从而完成了数据的聚合处理。 4. 思考与讨论 Hadoop的魅力在于，通过分解复杂的计算任务为一系列简单的Map和Reduce操作，我们可以轻松地应对海量数据的转换和处理。这种并行计算模型就像是给电脑装上了超级引擎，让数据处理速度嗖嗖地往上窜。而且更棒的是，它把数据分散存放在一整个集群的各个节点上，就像把鸡蛋放在不同的篮子里一样。这样一来，不仅能够轻松应对大规模运算，就算某个节点出个小差错，其他的节点也能稳稳接住，保证整个系统的稳定性和可扩展性杠杠的！ 然而，尽管Hadoop在数据处理方面表现出色，但并非所有场景都适用。比如，在那种需要迅速反馈或者频繁做大量计算的情况下，像Spark这类流处理框架或许会是个更棒的选择。这就意味着在咱们实际操作的项目里，面对不同的需求和技术特点时，咱们得像个精明的小侦探，灵活机智地挑出最对味、最适合的数据处理武器和战术方案。 总的来说，借助Hadoop，我们能够构建出高效的数据转换和处理流程，从容应对大数据挑战。不过呢，咱们也得时刻想着把它的原理摸得更透彻些，还有怎么跟其他的技术工具灵活搭配使用。这样一来，咱就能在那些乱七八糟、变来变去的业务环境里头，发挥出更大的作用，创造更大的价值啦！

...e计算两个整数之和的Java代码： java import java.io.IOException; import org.apache.hadoop.conf.Configuration; import org.apache.hadoop.fs.Path; import org.apache.hadoop.io.IntWritable; import org.apache.hadoop.io.LongWritable; import org.apache.hadoop.mapreduce.Job; import org.apache.hadoop.mapreduce.Mapper; import org.apache.hadoop.mapreduce.Reducer; import org.apache.hadoop.mapreduce.lib.input.FileInputFormat; import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat; public class WordCount { public static class TokenizerMapper extends Mapper { private final static IntWritable one = new IntWritable(1); private Text word = new Text(); public void map(LongWritable key, Text value, Context context ) throws IOException, InterruptedException { String line = value.toString(); StringTokenizer itr = new StringTokenizer(line); while (itr.hasMoreTokens()) { word.set(itr.nextToken()); context.write(word, one); } } } public static class IntSumReducer extends Reducer { private IntWritable result = new IntWritable(); public void reduce(Text key, Iterable values, Context context ) throws IOException, InterruptedException { int sum = 0; for (IntWritable val : values) { sum += val.get(); } result.set(sum); context.write(key, result); } } public static void main(String[] args) throws Exception { Configuration conf = new Configuration(); Job job = Job.getInstance(conf, "word count"); job.setJarByClass(WordCount.class); job.setMapperClass(TokenizerMapper.class); job.setCombinerClass(IntSumReducer.class); job.setReducerClass(IntSumReducer.class); job.setOutputKeyClass(Text.class); job.setOutputValueClass(IntWritable.class); FileInputFormat.addInputPath(job, new Path(args[0])); FileOutputFormat.setOutputPath(job, new Path(args[1])); System.exit(job.waitForCompletion(true) ? 0 : 1); } } 在这个例子中，我们首先定义了一个Mapper类，它负责将文本切分成单词，并将每个单词作为一个键值对输出。然后呢，我们捣鼓出了一个Reducer类，它的职责就是把所有相同的单词出现的次数统统加起来。 以上就是Hadoop的一些基本信息以及它的主要组件介绍。如果你对此还有任何疑问或者想要深入了解，欢迎留言讨论！

...ionimport java.util.Propertiesobject DataHiveToMySQL {def main(args: Array[String]): Unit = {val sparkConf = new SparkConf().setMaster("local[]").setAppName("sparkSQL")val spark = SparkSession.builder().enableHiveSupport().config(sparkConf).getOrCreate()val result=spark.sql("select from ods.nationeverymonths")val props=new Properties()props.setProperty("user","root")props.setProperty("password","123456")props.setProperty("driver","com.mysql.jdbc.Driver")result.write.mode("overwrite").jdbc("jdbc:mysql://192.168.230.132:3306/user?serverTimezone=UTC&characterEncoding=UTF-8&useSSL=false", "nationeverymonth", props)println("导入成功")spark.stop()} } 运行可见导入成功 进入MySQL中查看结果 可见数据成功导入 接下来按照要求查询: 2.请根据dwd层表计算出某年每个国家的平均消费额和所有国家平均消费额相比较结果（“高/低/相同”）,存入MySQL数据库shtd_store的nationavgcmp表（表结构如下）中，然后在Linux的MySQL命令行中根据订单总数、消费总额、国家表主键三列均逆序排序的方式，查询出前5条，将SQL语句与执行结果截图粘贴至对应报告中; 在解这道题的时候遇见一个问题,在求所有国家平均消费额的时候一直报错,由于没有数据这道题的题意还是有点没看明白,于是我就用了最简单的办法先新增一列,再单独将所有国家平均消费额求出来然后再插入,如果各位大佬有解决这个问题的办法希望能指导一下 先将每个国家的平均消费额求出来 spark.sql("select nationkey,nationname,avg(totalconsumption) as nationavgconsumption from nationeverymonths group by nationkey,nationname") 再新增一列所有国家平均消费额 spark.sql("alter table nationeverymonths add columns(avg_allstring)") 再将查询到的所有国家平均消费额导入进去 spark.sql("insert overwrite table nationeverymonths1 select nationkey,nationname,avg_totalconsumpt,1500 from nationeverymonths1") 再次查表 按照题意添加比较结果字段 spark.sql("select ,case when avg_totalconsumpt>avg_all then '高' when avg_totalconsumpt<avg_all then '低' when avg_totalconsumpt=avg_all then '相同' else 'null' end as comparison from nationeverymonths1").show 最后的排序语句和题一一样 本篇文章为转载内容。原文链接：https://blog.csdn.net/guo_0423/article/details/126352162。 该文由互联网用户投稿提供，文中观点代表作者本人意见，并不代表本站的立场。 作为信息平台，本站仅提供文章转载服务，并不拥有其所有权，也不对文章内容的真实性、准确性和合法性承担责任。 如发现本文存在侵权、违法、违规或事实不符的情况，请及时联系我们，我们将第一时间进行核实并删除相应内容。

在学习Java爬虫技术并实践于京东商品信息抓取的过程中，可能会遇到各种实际问题，如网页结构变化、登录验证机制、数据解析异常等。这些问题的解决不仅有助于提升个人编程能力，更对了解反爬机制与合法合规的数据抓取有重要启示作用。 近期，关于网络爬虫技术的法律边界和道德规范引起了广泛关注。2022年，中国最高人民法院发布了《关于审理使用人脸识别技术处理个人信息相关民事案件适用法律若干问题的规定》，其中强调了在数据抓取过程中应尊重用户隐私权和个人信息安全。这意味着，在开发爬虫项目时，除了关注技术实现外，开发者还需严格遵守相关法律法规，确保数据来源的合法性。 另外，各大电商平台针对爬虫行为不断升级反爬策略，例如采用动态加载、加密参数、验证码等方式防止非授权抓取。在这种情况下，学习和研究如何通过模拟登录、设置合适的请求头（如User-Agent）、以及运用更高级的网络代理、IP池等手段绕过反爬机制，成为爬虫开发者必须掌握的技术要点。 与此同时，对于页面数据解析环节，诸如Jsoup这样的HTML解析库虽然强大易用，但在面对复杂多变的网页结构时，可能需要结合XPath或CSS选择器等更多工具进行精细化处理。此外，随着JavaScript渲染技术在现代网页中的广泛应用，传统的HTTP请求方式已无法满足部分动态加载内容的抓取需求，因此引入Selenium、Puppeteer等无头浏览器工具进行交互式爬虫开发已成为一种趋势。 总之，在深入学习和应用Java爬虫技术的同时，我们应当紧跟技术发展潮流，并时刻保持对法律、伦理及技术挑战的关注，以确保我们的爬虫项目既高效又合规。

...rt failed:java.lang.RuntimeException:java.lang.RuntimeException:org.apache.solr.handler.dataimport.DataImportHandlerException:One of driver or jndiName must be specified。 对于这个问题，我们可以从以下几个方面进行排查： - 首先，检查solr的配置文件，确认数据源驱动类是否正确配置； - 其次，检查数据库连接参数是否正确设置； - 最后，查看日志文件，查看是否有其他异常信息。 在实践中，我们可以尝试如下代码实现： java // 创建DataImporter对象 DataImporter importer = new DataImporter(); // 设置数据库连接参数 importer.setDataSource(new JdbcDataSource()); importer.setSql("SELECT FROM table_name"); // 执行数据导入 importer.fullImport("/path/to/solr/home"); 如果以上步骤无法解决问题，建议查阅相关文档或寻求专业人士的帮助。 1.2 集群配置错误 另一位开发者在2020年7月25日反馈了一个关于Solr集群配置的错误问题。其问题描述为：“淘淘商城第60讲——搭建Solr集群时，报错：org.apache.solr.common.SolrException: Could not find collection : core1”。读了这位开发者的文章，我们发现他在搭建Solr集群的时候，实实在在地碰到了上面提到的那些问题。 对于这个问题，我们可以从以下几个方面进行排查： - 首先，检查solr的配置文件，确认核心集合是否正确配置； - 其次，检查集群状态，确认所有节点是否都已经正常启动； - 最后，查看日志文件，查看是否有其他异常信息。 在实践中，我们可以尝试如下代码实现： java // 启动集群 CoreContainer cc = CoreContainer.create(CoreContainer.DEFAULT_CONFIG); cc.load(new File("/path/to/solr/home/solr.xml")); cc.start(); // 查询集群状态 Collections cores = cc.getCores(); for (SolrCore core : cores) { System.out.println(core.getName() + " status : " + core.getStatus()); } 如果以上步骤无法解决问题，建议查阅相关文档或寻求专业人士的帮助。 三、Solr代码执行漏洞排查及解决方法 近年来，随着Apache Solr的广泛应用，安全问题日益突出。嘿，你知道吗？在2019年11月19日曝出的一条消息，Apache Solr这个家伙在默认设置下有个不小的安全隐患。如果它以cloud模式启动，并且对外开放的话，那么远程的黑客就有机会利用这个漏洞，在目标系统上随心所欲地执行任何代码呢！就像是拿到了系统的遥控器一样，想想都有点让人捏把汗呐！ 对于这个问题，我们可以从以下几个方面进行排查： - 首先，检查solr的安全配置，确保只允许受信任的IP地址访问； - 其次，关闭不必要的服务端功能，如远程管理、JMX等； - 最后，定期更新solr到最新版本，以获取最新的安全补丁。 在实践中，我们可以尝试如下代码实现： java // 关闭JMX服务 String configPath = "/path/to/solr/home/solr.xml"; File configFile = new File(configPath); DocumentBuilder db = DocumentBuilderFactory.newInstance().newDocumentBuilder(); Document doc = db.parse(configFile); Element root = doc.getDocumentElement(); if (!root.getElementsByTagName("jmx").isEmpty()) { Node jmxNode = root.getElementsByTagName("jmx").item(0); jmxNode.getParentNode().removeChild(jmxNode); } TransformerFactory tf = TransformerFactory.newInstance(); Transformer transformer = tf.newTransformer(); transformer.setOutputProperty(OutputKeys.INDENT, "yes"); transformer.setOutputProperty("{http://xml.apache.org/xslt}indent-amount", "2"); DOMSource source = new DOMSource(doc); StreamResult result = new StreamResult(new File(configPath)); transformer.transform(source, result); 如果以上步骤无法解决问题，建议查阅相关文档或寻求专业人士的帮助。 四、总结 总的来说，Apache Solr虽然强大，但在使用过程中也会遇到各种各样的问题。了解并搞定这些常见问题后，咱们就能把Solr的潜能发挥得更淋漓尽致，这样一来，工作效率蹭蹭上涨，用户体验也噌噌提升，妥妥的双赢局面！希望本文能对你有所帮助！

...tion。 java import org.apache.lucene.analysis.standard.StandardAnalyzer; import org.apache.lucene.analysis.tokenattributes.CharTermAttribute; import org.apache.lucene.analysis.tokenattributes.OffsetAttribute; import org.apache.lucene.document.Document; import org.apache.lucene.index.DirectoryReader; import org.apache.lucene.index.IndexReader; import org.apache.lucene.index.IndexWriter; import org.apache.lucene.index.IndexWriterConfig; import org.apache.lucene.search.IndexSearcher; import org.apache.lucene.store.Directory; import org.apache.lucene.store.RAMDirectory; import org.apache.lucene.util.Version; import java.io.IOException; public class TokenStreamDemo { public static void main(String[] args) throws IOException { // 创建 RAMDirectory 实例 Directory directory = new RAMDirectory(); // 初始化 IndexWriterConfig IndexWriterConfig config = new IndexWriterConfig(Version.LATEST, new StandardAnalyzer()); // 创建 IndexWriter 并初始化索引 IndexWriter writer = new IndexWriter(directory, config); // 添加文档至索引 Document doc = new Document(); doc.add(new TextField("content", "这是一个测试文档，用于演示 Lucene 的 TokenStream 功能。", Field.Store.YES, Field.Index.ANALYZED)); writer.addDocument(doc); // 关闭 IndexWriter writer.close(); // 创建 IndexReader IndexReader reader = DirectoryReader.open(directory); // 使用 IndexSearcher 查找文档 IndexSearcher searcher = new IndexSearcher(reader); // 获取 TokenStream 对象 org.apache.lucene.search.IndexSearcher.SearchContext context = searcher.createSearchContext(); org.apache.lucene.analysis.standard.StandardAnalyzer analyzer = new org.apache.lucene.analysis.standard.StandardAnalyzer(Version.LATEST); org.apache.lucene.analysis.TokenStream tokenStream = analyzer.tokenStream("content", context.reader().getTermVector(0, 0).getPayload().toString()); // 检查是否有异常抛出 while (tokenStream.incrementToken()) { System.out.println("Token: " + tokenStream.getAttribute(CharTermAttribute.class).toString()); } // 关闭 TokenStream 和 IndexReader tokenStream.end(); reader.close(); } } 在这段代码中，我们首先创建了一个 RAMDirectory，并使用它来构建一个索引。接着，我们添加了一个包含测试文本的文档到索引中。之后，我们创建了 IndexSearcher 来搜索文档，并使用 StandardAnalyzer 来创建 TokenStream。在循环中，我们逐个输出令牌，直到遇到 EOFException，这通常意味着已经到达了文本的末尾。 第二部分：深入分析 EOFException 的原因与解决策略 在实际应用中，EOFException 通常意味着 TokenStream 已经到达了文本的结尾，这可能是由于以下原因： - 文本过短：如果输入的文本长度不足以产生足够的令牌，TokenStream 可能会过早地报告结束。 - 解析问题：在复杂的文本结构下，解析器可能未能正确地分割文本，导致部分文本未被识别为有效的令牌。 为了应对这种情况，我们可以采取以下策略： - 增加文本长度：确保输入的文本足够长，以生成多个令牌。 - 优化解析器配置：根据特定的应用场景调整分析器的配置，例如使用不同的分词器（如 CJKAnalyzer）来适应不同语言的需求。 - 错误处理机制：在代码中加入适当的错误处理逻辑，以便在遇到 EOFException 时进行相应的处理，例如记录日志、提示用户重新输入更长的文本等。 结语：拥抱挑战，驾驭全文检索 面对 org.apache.lucene.analysis.TokenStream$EOFException: End of stream 这样的挑战，我们的目标不仅仅是解决问题，更是通过这样的经历深化对 Lucene 工作原理的理解。哎呀，你猜怎么着？咱们在敲代码、调参数的过程中，不仅技术越来越溜，还能在处理那些乱七八糟的数据时，感觉自己就像个数据处理的小能手，得心应手的呢！就像是在厨房里，熟练地翻炒各种食材，做出来的菜品色香味俱全，让人赞不绝口。编程也是一样，每一次的实践和调试，都是在给我们的技能加料，让我们的作品越来越美味，越来越有营养！嘿！兄弟，听好了，每次遇到难题都像是在给咱的成长加个buff，咱们得一起揭开全文检索的神秘面纱，掌控技术的大棒，让用户体验到最棒、最快的搜索服务，让每一次敲击键盘都能带来惊喜！ --- 以上内容不仅涵盖了理论解释与代码实现，还穿插了人类在面对技术难题时的思考与探讨，旨在提供一种更加贴近实际应用、充满情感与主观色彩的技术解读方式。

...真的把我惊呆了！它的功能太牛了，感觉就像发现了一个全新的世界，简直太酷了吧！简单说呢，Hadoop就是一个开源的“大数据管家”，专门负责存东西、弄数据，而且不管数据多到啥程度，它都能应付得漂漂亮亮的！它就像是一个超级仓库，可以轻松应对各种规模的数据任务。 为什么Hadoop这么受欢迎呢？因为它解决了传统数据库在处理大规模数据时的瓶颈问题。比如说啊，你在一家电商公司当数据分析师，每天的工作就是跟上亿条用户的点击、浏览、下单这些行为记录打交道，简直就像在海量的信息海洋里淘宝一样！如果用传统的数据库，可能早就崩溃了。但Hadoop不一样，它可以将这些数据分散到多个服务器上进行并行处理，效率杠杠的！ 不过，Hadoop的魅力远不止于此。嘿，大家好！今天我想跟你们分享一个关于Hadoop的超棒功能——它居然能让你在不同的访问控制协议之间轻松切换文件！是不是听着就很带感？哎呀，是不是觉得这事听着有点绕？别慌，我这就用大白话给你说道说道，保证你一听就明白！ --- 二、什么是跨访问控制协议迁移？ 首先，我们得明白什么是访问控制协议。简单说，就是规定谁可以访问你的数据以及他们能做些什么的规则。好比说啊，你有个公共文件柜，你想让一些人只能打开看看里面的东西，啥都不能动；但另外一些人呢，不仅能看，还能随便改，甚至直接把东西清空或者拿走。这就是访问控制协议的作用。 那么，“跨访问控制协议迁移”又是什么意思呢？想象一下，你有两个不同的系统，它们各自有自己的访问控制规则。比如说，一个是Linux那边的ACL（访问控制列表）系统，另一个则是Windows里的NTFS权限系统，两者各有各的玩法。现在，你要把文件从一个系统迁移到另一个系统，而且你还想保留原来的访问控制设置。这就需要用到跨访问控制协议迁移的技术了。 为什么要关心这个功能呢？因为现实世界中，企业往往会有多种操作系统和存储环境。要是你对文件的权限管理不当，那可就麻烦了，要么重要数据被泄露出去，要么一不小心就把东西给搞砸了。而Hadoop通过其强大的灵活性，完美地解决了这个问题。 --- 三、Hadoop如何实现跨访问控制协议迁移？ 接下来，让我们来看看Hadoop是如何做到这一点的。其实，这主要依赖于Hadoop的分布式文件系统（HDFS）和它的API库。为了更好地理解，我们可以一步步来分析。 3.1 HDFS的基本概念 HDFS是Hadoop的核心组件之一，它是用来存储大量数据的分布式文件系统。这就像是一个超大号的硬盘，不过它有点特别，不是集中在一个地方存东西，而是把数据切成小块，分散到不同的“小房间”里去。这样做的好处是即使某个节点坏了，也不会影响整个系统的运行。 HDFS还提供了一套丰富的接口，允许开发者自定义文件的操作行为。这就为实现跨访问控制协议迁移提供了可能性。 3.2 实现步骤 实现跨访问控制协议迁移大致分为以下几个步骤： （1）读取源系统的访问控制信息 第一步是获取源系统的访问控制信息。比如，如果你正在从Linux系统迁移到Windows系统，你需要先读取Linux上的ACL配置。 java // 示例代码：读取Linux ACL import org.apache.hadoop.fs.FileSystem; import org.apache.hadoop.fs.Path; import java.io.IOException; public class AccessControlReader { public static void main(String[] args) throws IOException { Path path = new Path("/path/to/source/file"); FileSystem fs = FileSystem.get(new Configuration()); // 获取ACL信息 String acl = fs.getAclStatus(path).toString(); System.out.println("Source ACL: " + acl); } } 这段代码展示了如何使用Hadoop API读取Linux系统的ACL信息。可以看到，Hadoop已经为我们封装好了相关的API，调用起来非常方便。 （2）转换为目标系统的格式 接下来，我们需要将读取到的访问控制信息转换为目标系统的格式。比如，将Linux的ACL转换为Windows的NTFS权限。 java // 示例代码：模拟ACL到NTFS的转换 public class AclToNtfsConverter { public static void convert(String linuxAcl) { // 这里可以编写具体的转换逻辑 System.out.println("Converting ACL to NTFS: " + linuxAcl); } } 虽然这里只是一个简单的打印函数，但实际上你可以根据实际需求编写复杂的转换算法。 （3）应用到目标系统 最后一步是将转换后的权限应用到目标系统上。这一步同样可以通过Hadoop提供的API来完成。 java // 示例代码：应用NTFS权限 public class NtfsPermissionApplier { public static void applyPermissions(Path targetPath, String ntfsPermissions) { try { // 模拟应用权限的过程 System.out.println("Applying NTFS permissions to " + targetPath.toString() + ": " + ntfsPermissions); } catch (Exception e) { e.printStackTrace(); } } } 通过这三个步骤，我们就完成了从源系统到目标系统的访问控制协议迁移。 --- 四、实战演练 一个完整的案例 为了让大家更直观地理解，我准备了一个完整的案例。好啦，想象一下，我们现在要干的事儿就是把一个文件从一台Linux服务器搬去Windows服务器，而且还得保证这个文件在新家里的“门禁权限”跟原来一模一样，不能搞错！ 4.1 准备工作 首先，确保你的开发环境中已经安装了Hadoop，并且配置好相关的依赖库。此外，还需要准备两台机器，一台装有Linux系统，另一台装有Windows系统。 4.2 编写代码 接下来，我们编写代码来实现迁移过程。首先是读取Linux系统的ACL信息。 java // 读取Linux ACL Path sourcePath = new Path("/source/file.txt"); FileSystem linuxFs = FileSystem.get(new Configuration()); String linuxAcl = linuxFs.getAclStatus(sourcePath).toString(); System.out.println("Linux ACL: " + linuxAcl); 然后，我们将这些ACL信息转换为NTFS格式。 java // 模拟ACL到NTFS的转换 AclToNtfsConverter.convert(linuxAcl); 最后，将转换后的权限应用到Windows系统上。 java // 应用NTFS权限 Path targetPath = new Path("\\\\windows-server\\file.txt"); NtfsPermissionApplier.applyPermissions(targetPath, "Full Control"); 4.3 执行结果 执行完上述代码后，你会发现文件已经被成功迁移到了Windows系统，并且保留了原有的访问控制设置。是不是很神奇？ --- 五、总结与展望 通过这篇文章，我相信你对Hadoop支持文件的跨访问控制协议迁移有了更深的理解。Hadoop不仅是一个强大的工具，更是一种思维方式的转变。它就像个聪明的老师，不仅教我们怎么用分布式的思路去搞定问题，还时不时敲打我们：嘿，别忘了数据的安全和规矩可不能丢啊！ 未来，随着技术的发展，Hadoop的功能会越来越强大。我希望你能继续探索更多有趣的话题，一起在这个充满挑战的世界里不断前行！ 加油吧，程序员们！

...看这个问题到底是怎么实现的。我们先在内核C语言部分做简单修改，把原来的cmd_hlt函数改为cmd_execute_program: nt show_pos = 179;void cmd_execute_program(char file) {io_cli();struct Buffer appBuffer = (struct Buffer)memman_alloc(memman, 16);struct TASK task = task_now();task->pTaskBuffer = appBuffer;file_loadfile(file, appBuffer);struct SEGMENT_DESCRIPTOR gdt =(struct SEGMENT_DESCRIPTOR )get_addr_gdt();//select is multiply of 8, divided by 8 get the original valueint code_seg = 21 + (task->sel - first_task_cons_selector) / 8;//change hereint mem_seg = 30 + (task->sel - first_task_cons_selector) / 8;//22;char p = intToHexStr(mem_seg);showString(shtctl, sht_back, 0, show_pos, COL8_FFFFFF, p); show_pos += 16;set_segmdesc(gdt + code_seg, 0xfffff, (int) appBuffer->pBuffer, 0x409a + 0x60);//new memory char q = (char ) memman_alloc_4k(memman, 641024);appBuffer->pDataSeg = (unsigned char)q;set_segmdesc(gdt + mem_seg, 64 1024 - 1,(int) q ,0x4092 + 0x60);task->tss.esp0 = 0;io_sti();start_app(0, code_seg8,641024, mem_seg8, &(task->tss.esp0));io_cli();memman_free_4k(memman,(unsigned int) appBuffer->pBuffer, appBuffer->length);memman_free_4k(memman, (unsigned int) q, 64 1024);memman_free(memman,(unsigned int)appBuffer, 16);task->pTaskBuffer = 0;io_sti();}void console_task(struct SHEET sheet, int memtotal) {....for(;;) { ....else if (i == KEY_RETURN) {....} else if (strcmp(cmdline, "hlt") == 1) {//change herecmd_execute_program("abc.exe");}....}...} 原来的cmd_hlt函数默认加载并执行软盘中的abc.exe程序，现在我们把cmd_hlt改名为cmd_execute_program，并且函数需要传入一个字符串，用于表明要加载执行的程序名字。在该函数的代码实现中，我们使用showString函数把被加载执行的用户进程数据段所对应的全局描述符号给显示到桌面上，上面代码执行后情况如下： 我们看到，在控制台中执行hlt命令后，内核加载了用户进程，同时在控制台下方输出了一个字符串，也就是0x1E,这个数值对应的就是当前运行用户进程其数据段对应的全局描述符号。一旦有这个信息之后，另一个进程就可以有机可乘了。 接着我们在本地目录创建一个新文件叫crack.c,其内容如下： void main() {char p = (char)0x123;p[0] = 'c';p[1] = 'r';p[2] = 'a';p[3] = 'c';p[4] = 'k';p[5] = 0;} 它的目的简单，就是针对内存地址0x123处写入字符串”crack”.接着我们修改一下makefile，使得内核编译时，能把crack.c编译成二进制文件： CFLAGS=-fno-stack-protectorckernel : ckernel_u.asm app_u.asm crack_u.asm cp ckernel_u.asm win_sheet.h win_sheet.c mem_util.h mem_util.c write_vga_desktop.c timer.c timer.h global_define.h global_define.c multi_task.c multi_task.h app_u.asm app.c crack_u.asm crack.c makefile '/media/psf/Home/Documents/操作系统/文档/19/OS-kernel-win-sheet/'ckernel_u.asm : ckernel.o....crack_u.asm : crack.o./objconv -fnasm crack.o crack_u.asmcrack.o : crack.cgcc -m32 -fno-stack-protector -fno-asynchronous-unwind-tables -s -c -o crack.o crack.c 然后我们在本地目录下，把api_call.asm拷贝一份，并命名为crack_call.asm,后者内容与前者完全相同，只不过稍微有那么一点点改变，例如： BITS 32mov AX, 30 8mov DS, axcall mainmov edx, 4 ;返回内核int 02Dh.... 这里需要注意，语句： mov AX, 30 8mov DS, ax 其中30对应的就是前面显示的0x1E，这两句汇编的作用是，把程序crack的数据段设置成下标为30的全局描述符所指向的内存段一致。这就意味着crack进程所使用的数据段就跟hlt启动的进程所使用的数据段一致了！于是在crack.c中，它对内存地址为0x123的地方写入字符串”crack”,那就意味着对hlt加载用户进程的内存空间写入对应字符串！ 完成上面代码后，我们在java项目中，增加代码，一是用来编译crack进程，而是把crack代码写入虚拟磁盘。在OperatingSystem.java中，将代码做如下添加： public void makeFllopy() {writeFileToFloppy("kernel.bat", false, 1, 1);....header = new FileHeader();header.setFileName("crack");header.setFileExt("exe");file = new File("crack.bat");in = null;try {in = new FileInputStream(file);long len = file.length();int count = 0;while (count < file.length()) {bbuf[count] = (byte) in.read();count++;}in.close();}catch(IOException e) {e.printStackTrace();return;}header.setFileContent(bbuf);fileSys.addHeader(header);....}public static void main(String[] args) {CKernelAsmPrecessor kernelPrecessor = new CKernelAsmPrecessor();kernelPrecessor.process();kernelPrecessor.createKernelBinary();CKernelAsmPrecessor appPrecessor = new CKernelAsmPrecessor("hlt.bat", "app_u.asm", "app.asm", "api_call.asm");appPrecessor.process();appPrecessor.createKernelBinary();CKernelAsmPrecessor crackPrecessor = new CKernelAsmPrecessor("crack.bat", "crack_u.asm", "crack.asm", "crack_call.asm");crackPrecessor.process();crackPrecessor.createKernelBinary();OperatingSystem op = new OperatingSystem("boot.bat");op.makeFllopy();} 在main函数中，我们把crack.c及其附属汇编文件结合在一起，编译成二进制文件crack.bat，在makeFllopy中，我们把编译后的crack.bat二进制数据读入，并把它写入到虚拟磁盘中，当系统运行起来后，可以把crack.bat二进制内容作为进程加载执行。 完成上面代码后，回到内核的C语言部分，也就是write_vga_desktop.c做一些修改，在kernel_api函数中，修改如下： int kernel_api(int edi, int esi, int ebp, int esp,int ebx, int edx, int ecx, int eax) {....else if (edx == 14) {sheet_free(shtctl, (struct SHEET)ebx);//change herecons_putstr((char)(task->pTaskBuffer->pDataSeg + 0x123));}....}void console_task(struct SHEET sheet, int memtotal) {....for(;;) {....else if (i == KEY_RETURN) {....else if (strcmp(cmdline, "crack") == 1) {cmd_execute_program("crack.exe");}....}....} 在kernel_api中，if(edx == 14)对应的api调用是api_closewin，也就是当用户进程关闭窗口时，我们把进程数据偏移0x123处的数据当做字符串打印到控制台窗口上，在console_task控制台进程主函数中，我们增加了对命令crack的响应，当用户在控制台上输入命令”crack”时，将crack代码加载到内核中运行。上面代码完成后，编译内核，然后用虚拟机将内核加载，系统启动后，我们现在一个控制台中输入hlt，先启动用户进程。然后点击”shift + w”,启动另一个控制台窗口，在其中输入crack，运行crack程序： 接着把点击tab键，把焦点恢复到窗口task_a，然后用鼠标点击运行hlt命令的窗口，把输入焦点切换到该控制台，然后再次点击tab键，把执行权限提交给运行hlt命令的控制台，此时点击回车，介绍用户进程启动的窗口，结果情况如下： 此时我们可以看到，运行hlt命令，执行用户进程的控制台窗口居然输出了字符串”crack”,而这个字符串正是crack.c在执行时，写入地址0x123的字符串。这就意味着一个恶意进程成功修改了另一个进程的内存数据，也相当于一个流氓程序把一只咸猪手伸到其他用户进程的裙底，蹂躏一番后留下了猥琐的证据。 那么如何防范恶意进程对其他程序的非法入侵呢，这就得使用CPU提供的LDT机制，也就是局部描述符表，该机制的使用，我们将在下一节详细讲解。更详细的讲解和代码演示调试，请参看视频： 更详细的讲解和代码调试演示过程，请参看视频 Linux kernel Hacker, 从零构建自己的内核 更多技术信息，包括操作系统，编译器，面试算法，机器学习，人工智能，请关照我的公众号： 本篇文章为转载内容。原文链接：https://blog.csdn.net/tyler_download/article/details/78731905。 该文由互联网用户投稿提供，文中观点代表作者本人意见，并不代表本站的立场。 作为信息平台，本站仅提供文章转载服务，并不拥有其所有权，也不对文章内容的真实性、准确性和合法性承担责任。 如发现本文存在侵权、违法、违规或事实不符的情况，请及时联系我们，我们将第一时间进行核实并删除相应内容。

Kafka设计原则：命名规范与组织结构 1. 初识Kafka 一个让我着迷的消息队列系统 大家好啊！今天咱们聊聊Kafka，这个让我又爱又恨的消息队列系统。说实话，刚接触Kafka的时候，我真是被它的复杂度吓到了。嘿，说真的，一开始也没觉得它有多特别，但用得多了才发现这家伙简直太有范儿了！特别是它的设计思路，名字起得那叫一个讲究，东西摆得也特有条理，看得我忍不住直点头，真心觉得牛！ Kafka本质上是一个分布式流处理平台，可以用来处理实时数据流。它的核心是消息队列，但又不仅仅是简单的消息队列。它不仅传输速度快、反应还超灵敏，而且特别皮实，出点小问题也不带怕的。这么能打的表现，让它在大数据圈子里简直成了明星！不过，要想用好Kafka，你得先搞清楚它的命名规范和组织结构。接下来，我会结合自己的理解和实践，给大家分享一些干货。 --- 2. 命名规范 让Kafka的世界井然有序 2.1 主题（Topic）：Kafka世界的基石 首先，我们来聊聊主题（Topic）。在Kafka里面呢，主题就好比是一个文件夹，所有的消息啊，就像文件一样，一股脑儿地塞进这个文件夹里头。每一个主题都有一个唯一的名称，这个名字就是它的标识符。比如说嘛，你可以建个叫user_events的话题分区，专门用来存用户干的事儿，点啥、买啥、逛哪儿，都往里丢，方便又清晰！ java // 创建一个Kafka主题 kafka-topics.sh --create --zookeeper localhost:2181 --replication-factor 1 --partitions 3 --topic user_events 这里的关键点在于，主题的名字要尽量简单明了，避免使用特殊字符或者空格。哎呀，这就好比你给文件夹起个特别绕口的名字，结果自己都记不住路径了，Kafka也是一样！它会根据主题的名字创建对应的文件夹结构，但要是主题名太复杂，搞不好就会在找东西的时候迷路，路径解析起来就容易出岔子啦。而且啊，主题的名字最好起得通俗易懂一点，让大伙儿一眼扫过去就明白这是干啥用的。 2.2 分区（Partition）：主题的分身术 接着说分区（Partition）。每个主题都可以被划分为多个分区，每个分区就是一个日志文件。分区的作用是什么呢？它可以提高并发性和扩展性。比如说，你有个主题叫orders（订单），你可以把它分成5个区（分区）。这样一来，不同的小伙伴就能一起开工，各自处理这些区里的数据啦！ java // 查看主题的分区信息 kafka-topics.sh --describe --zookeeper localhost:2181 --topic orders 分区的数量决定了并发的上限。所以，在设计主题时，你需要仔细权衡分区数量。太多的话，管理起来麻烦；太少的话，可能无法充分利用资源。我一般会根据预计的消息量来决定分区的数量。比如说，如果一秒能收到几千条消息，那分区设成10到20个就挺合适的。毕竟分区太多太少了都不好，得根据实际情况来调，不然可能会卡壳或者资源浪费啊！ 2.3 消费者组（Consumer Group）：团队协作的秘密武器 最后，我们来说消费者组（Consumer Group）。消费者组是一组消费者的集合，它们共同消费同一个主题的消息。每个消费者组都有一个唯一的名称，这个名字同样非常重要。 java // 创建一个消费者组 kafka-console-consumer.sh --bootstrap-server localhost:9092 --topic user_events --group my_consumer_group 消费者组的设计理念是为了实现负载均衡和故障恢复。比如说，如果有两个小伙伴在一个小组里，系统就会帮他们自动分配任务（也就是主题的分区），这样大家就不会抢来抢去，重复干同样的活儿啦！而且呢，要是有个消费者挂掉了或者出问题了，其他的消费者就会顶上来，接手它负责的那些分区，接着干活儿，完全不受影响。 --- 3. 组织结构 Kafka的大脑与四肢 3.1 集群（Cluster）：Kafka的心脏 Kafka集群是由多个Broker组成的，Broker是Kafka的核心组件，负责存储和转发消息。一个Broker就是一个节点，多个Broker协同工作，形成一个分布式的系统。 java // 启动Kafka Broker nohup kafka-server-start.sh config/server.properties & Broker的数量决定了系统的容错能力和性能。其实啊，通常咱们都会建议弄三个Broker，为啥呢？就怕万一有个家伙“罢工”了，比如突然挂掉或者出问题，别的还能顶上，整个系统就不耽误干活啦！不过，Broker的数量也不能太多，否则会增加管理和维护的成本。 3.2 Zookeeper：Kafka的大脑 Zookeeper是Kafka的协调器，它负责管理集群的状态和配置。没有Zookeeper，Kafka就无法正常运作。比如说啊，新添了个Broker（也就是那个消息中转站），Zookeeper就会赶紧告诉其他Broker：“嘿，快看看这位新伙伴，更新一下你们的状态吧！”还有呢，要是某个分区的老大换了（Leader切换了），Zookeeper也会在一旁默默记好这笔账，生怕漏掉啥重要信息似的。 java // 启动Zookeeper nohup zookeeper-server-start.sh config/zookeeper.properties & 虽然Zookeeper很重要，但它也有一定的局限性。比如，它可能会成为单点故障，影响整个系统的稳定性。因此，近年来Kafka也在尝试去掉对Zookeeper的依赖，开发了自己的内部协调机制。 3.3 日志（Log）：Kafka的四肢 日志是Kafka存储消息的地方，每个分区对应一个日志文件。嘿，这个日志设计可太聪明了！它用的是顺序写入的方法，就像一条直线往前跑，根本不用左顾右盼，写起来那叫一个快，效率直接拉满！ java // 查看日志路径 cat config/server.properties | grep log.dirs 日志的大小可以通过参数log.segment.bytes来控制。默认值是1GB，你可以根据实际情况调整。要是日志文件太大了，查个东西就像在大海捞针一样慢吞吞的；但要是弄得太小吧，又老得换新的日志文件，麻烦得很，还费劲。 --- 4. 实战演练 从零搭建一个Kafka环境 说了这么多理论，咱们来实际操作一下吧！假设我们要搭建一个简单的Kafka环境，用来收集用户的登录日志。 4.1 安装Kafka和Zookeeper 首先，我们需要安装Kafka和Zookeeper。可以从官网下载最新的二进制包，解压后按照文档配置即可。 bash 下载Kafka wget https://downloads.apache.org/kafka/3.4.0/kafka_2.13-3.4.0.tgz 解压 tar -xzf kafka_2.13-3.4.0.tgz 4.2 创建主题和消费者 接下来，我们创建一个名为login_logs的主题，并启动一个消费者来监听消息。 bash 创建主题 bin/kafka-topics.sh --create --zookeeper localhost:2181 --replication-factor 1 --partitions 3 --topic login_logs 启动消费者 bin/kafka-console-consumer.sh --bootstrap-server localhost:9092 --topic login_logs --from-beginning 4.3 生产消息 最后，我们可以编写一个简单的Java程序来生产消息。 java import org.apache.kafka.clients.producer.KafkaProducer; import org.apache.kafka.clients.producer.ProducerRecord; import java.util.Properties; public class KafkaProducerExample { public static void main(String[] args) { Properties props = new Properties(); props.put("bootstrap.servers", "localhost:9092"); props.put("key.serializer", "org.apache.kafka.common.serialization.StringSerializer"); props.put("value.serializer", "org.apache.kafka.common.serialization.StringSerializer"); KafkaProducer producer = new KafkaProducer<>(props); for (int i = 0; i < 10; i++) { producer.send(new ProducerRecord<>("login_logs", "key" + i, "value" + i)); } producer.close(); } } 这段代码会向login_logs主题发送10条消息，每条消息都有一个唯一的键和值。 --- 5. 总结 Kafka的魅力在于细节 好了，到这里咱们的Kafka之旅就告一段落了。通过这篇文章，我希望大家能更好地理解Kafka的命名规范和组织结构。Kafka为啥这么牛？因为它在设计的时候真是把每个小细节都琢磨得特别透。就像给主题起名字吧，分个区啦，还有消费者组怎么配合干活儿，这些地方都能看出人家确实是下了一番功夫的，真不是随便凑合出来的！ 当然，Kafka的学习之路还有很多内容需要探索，比如监控、调优、安全等等。其实我觉得啊，只要你把命名的规矩弄明白了，东西该怎么放也心里有数了，那你就算是走上正轨啦，成功嘛，它就已经在向你招手啦！加油吧，朋友们！ --- 希望这篇文章对你有所帮助，如果有任何疑问，欢迎随时交流哦！

...tvirt-sfc JAVA_HOME=/usr/lib/jvm/java-1.8.0-openjdk CLASSPATH=.:$JAVA_HOME/lib/tools.jar PATH=$JAVA_HOME/bin:$PATH JVM_OPTS="-Xms256m -XX:PermSize=256m -XX:MaxPermSize=512m" MAVEN_OPTS="$MAVEN_OPTS -Xms512m -Xmx1024m -XX:PermSize=256m -XX:MaxPermSize=512m" export MAVEN_OPTS JAVA_HOME CLASSPATH JVM_OPTS PATH [root@localhost ~] netstat -ntpl Active Internet connections (only servers) Proto Recv-Q Send-Q Local Address Foreign Address State PID/Program name tcp 0 0 0.0.0.0:22 0.0.0.0: LISTEN 3327/sshd tcp 0 0 127.0.0.1:25 0.0.0.0: LISTEN 3620/master tcp6 0 0 :::6633 ::: LISTEN 868/java tcp6 0 0 127.0.0.1:1099 ::: LISTEN 868/java tcp6 0 0 :::6640 ::: LISTEN 868/java tcp6 0 0 127.0.0.1:6644 ::: LISTEN 868/java tcp6 0 0 :::8181 ::: LISTEN 868/java tcp6 0 0 127.0.0.1:2550 ::: LISTEN 868/java tcp6 0 0 :::22 ::: LISTEN 3327/sshd tcp6 0 0 :::8185 ::: LISTEN 868/java tcp6 0 0 127.0.0.1:44601 ::: LISTEN 868/java tcp6 0 0 :::33273 ::: LISTEN 868/java tcp6 0 0 ::1:25 ::: LISTEN 3620/master tcp6 0 0 :::44444 ::: LISTEN 868/java tcp6 0 0 :::6653 ::: LISTEN 868/java tcp6 0 0 :::39169 ::: LISTEN 868/java tcp6 0 0 :::8101 ::: LISTEN 868/java tcp6 0 0 :::6886 ::: LISTEN 868/java openstack配置 openstack的networking-odl插件安装方式 https://docs.openstack.org/networking-odl/latest/install/installation.htmlodl-installation yum install python-networking-odl.noarch -y https://docs.openstack.org/networking-odl/latest/install/installation.htmlnetworking-odl-configuration systemctl restart neutron-server /etc/neutron/plugins/ml2 测试端口可连接性 curl -u admin:admin http://10.13.80.34:8181/controller/nb/v2/neutron/networks odl配置文件修改 etc/custom.properties ovsdb.l3.fwd.enabled=yes ovsdb.l3gateway.mac=0a:00:27:00:00:0d telnet 10.13.80.34 8181 netstat -nlp | grep 8181 telnet 127.0.0.1 8181 telnet 10.13.80.34 8181 systemctl status firewall iptables iptables -nvL iptables -F 清空iptables openstack server create --flavor tiny --image cirros --nic net-id=24449ee2-b84e-493f-8d76-139ac3e4f3cd --key-name mykey provider-instance nova service-list nova show ae5e26d1-c84d-40fa-bb27-f0b46d6a7061 查看虚机详情 ovs-vsctl set Open_vSwitch 89444614-3bf8-4d7a-b3a0-df5d20b48b7a other_config={'local_ip'='192.168.56.102'} ovs-vsctl set Open_vSwitch b084eccf-b92e-470c-8dff-8549e92c2104 other_config={'local_ip'='192.168.56.122'} ovs-vsctl list interface eth0 ovs-appctl fdb/show br-int [root@rcontroller01 ~] openstack security group rule list 2e19a748-9086-49f8-9498-01abc1a964fe 一个神奇的命令 +--------------------------------------+-------------+-----------+------------+--------------------------------------+ | ID | IP Protocol | IP Range | Port Range | Remote Security Group | +--------------------------------------+-------------+-----------+------------+--------------------------------------+ | 0184e6b3-4f7f-4fd5-8125-b80682e7ee48 | None | None | | 2e19a748-9086-49f8-9498-01abc1a964fe | | 1e0bfedc-8f25-408a-9328-708113bbbc52 | icmp | 0.0.0.0/0 | | None | | 39116d39-454b-4d82-867e-bbfd3ea63182 | None | None | | None | | 4032366f-3ac9-4862-85a7-c7411a8b7678 | None | None | | 2e19a748-9086-49f8-9498-01abc1a964fe | | dc7bc251-f0d0-456a-9102-c5b66646aa84 | tcp | 0.0.0.0/0 | 22:22 | None | | ddacf7ea-57ea-4c8a-8b68-093766284595 | None | None | | None | +--------------------------------------+-------------+-----------+------------+--------------------------------------+ dpif/dump-flows dp 想控制端打印dp中流表的所有条目。 这个命令主要来与debugOpen Vswitch.它所打印的流表不是openFlow的流条目。 它打印的是由dp模块维护的简单的流。 如果你想查看OpenFlow条目，请使用ovs-ofctl dump-flows。dpif/del-fow dp 删除指定dp上所有流表。同上所述，这些不是OpenFlow流表。 ovs-appctl dpif/dump-flows br-int 创建网络 openstack network create --share --external --provider-physical-network provider --provider-network-type flat provider $ openstack subnet create --network provider \ --allocation-pool start=192.168.56.100,end=192.168.56.200 \ --dns-nameserver 8.8.8.8 --gateway 192.168.56.1 \ --subnet-range 192.168.56.0/24 provider openstack network create selfservice $ openstack subnet create --network selfservice \ --dns-nameserver 8.8.8.8 --gateway 192.168.1.1 \ --subnet-range 192.168.1.0/24 selfservice openstack router create router openstack router add subnet router selfservice openstack router set router --external-gateway provider openstack port list --router router +--------------------------------------+------+-------------------+-------------------------------------------------------------------------------+--------+ | ID | Name | MAC Address | Fixed IP Addresses | Status | +--------------------------------------+------+-------------------+-------------------------------------------------------------------------------+--------+ | bff6605d-824c-41f9-b744-21d128fc86e1 | | fa:16:3e:2f:34:9b | ip_address='172.16.1.1', subnet_id='3482f524-8bff-4871-80d4-5774c2730728' | ACTIVE | | d6fe98db-ae01-42b0-a860-37b1661f5950 | | fa:16:3e:e8:c1:41 | ip_address='203.0.113.102', subnet_id='5cc70da8-4ee7-4565-be53-b9c011fca011' | ACTIVE | +--------------------------------------+------+-------------------+-------------------------------------------------------------------------------+--------+ $ ping -c 4 203.0.113.102 创建虚机 openstack keypair list $ ssh-keygen -q -N "" $ openstack keypair create --public-key ~/.ssh/id_rsa.pub mykey openstack flavor list openstack image list openstack network list openstack server create --flavor tiny --image cirros --nic net-id=27616098-0374-4ab4-95a8-b5bf4839dcf8 --key-name mykey provider-instance 网络配置 python /usr/lib/python2.7/site-packages/networking_odl/cmd/set_ovs_hostconfigs.py --ovs_hostconfigs='{ "ODL L2": { "allowed_network_types": [ "flat", "vlan", "vxlan" ], "bridge_mappings": { "provider": "br-int" }, "supported_vnic_types": [ { "vnic_type": "normal", "vif_type": "ovs", "vif_details": {} } ] }, "ODL L3": {} }' ovs-vsctl list open . [‎2019/‎1/‎16 19:09] 高正伟: ovs-vsctl set Open_vSwitch . other_config:local_ip=hostip ovs-vsctl set Open_vSwitch . other_config:local_ip=192.168.56.122 ovs-vsctl set Open_vSwitch . other_config:remote_ip=192.168.56.122 ovs-vsctl remove interface tunca7b782f232 options remote_ip ovs-vsctl set Open_vSwitch . other_config:provider_mappings=provider:br-ex ovs-vsctl set Open_vSwitch . external_ids:provider_mappings="{\"provider\": \"br-ex\"}" 清空 ovs-vsctl clear Open_vSwitch . external_ids ovs-vsctl set-manager tcp:10.13.80.34:6640 ovs-vsctl set-controller br-ex tcp:10.13.80.34:6640 ovs-vsctl del-controller br-ex sudo neutron-odl-ovs-hostconfig ovs-vsctl show ovs-vsctl add-port <bridge name> <port name> ovs-vsctl add-port br-ex enp0s10 ovs-vsctl del-port br-ex phy-br-ex ovs-vsctl del-port br-ex tun2ad7e9e91e4 重启odl后 systemctl restart openvswitch.service systemctl restart neutron-server.service systemctl stop neutron-server.service 创建虚机 openstack network create --share --external --provider-physical-network provider --provider-network-type flat provider openstack subnet create --network provider --allocation-pool start=192.168.56.2,end=192.168.56.100 --dns-nameserver 8.8.8.8 --gateway 192.168.56.1 --subnet-range 192.168.56.0/24 provider nova boot --image cirros --flavor tiny --nic net-id= --availability-zone nova:rcontroller01 vm-01 openstack server create --flavor tiny --image cirros --nic net-id= --key-name mykey test nova boot --image cirros --flavor tiny --nic net-id=0fe983c2-8178-403b-a00e-e8561580b210 --availability-zone nova:rcontroller01 vm-01 虚机可以学习到mac但是ping不通 抓包，先在虚机网卡上抓包， 然后在br-int上抓包 发现虚拟网卡上是发送了icmp请求报文的，但是br-int上没有 查看报文情况 [root@rcontroller01 ~] ovs-appctl dpif/dump-flows br-int recirc_id(0),tunnel(tun_id=0x0,src=192.168.56.102,dst=192.168.56.122,flags(-df-csum+key)),in_port(4),eth(),eth_type(0x0800),ipv4(proto=17,frag=no),udp(dst=3784), packets:266436, bytes:17584776, used:0.591s, actions:userspace(pid=4294962063,slow_path(bfd)) recirc_id(0xa0),in_port(5),ct_state(+new-est-rel-inv+trk),ct_mark(0/0x1),eth(),eth_type(0x0800),ipv4(frag=no), packets:148165, bytes:14520170, used:0.566s, actions:drop recirc_id(0),in_port(3),eth(),eth_type(0x0806), packets:1, bytes:60, used:5.228s, actions:drop recirc_id(0),tunnel(tun_id=0xb,src=192.168.56.102,dst=192.168.56.122,flags(-df-csum+key)),in_port(4),eth(dst=fa:16:3e:ab:ba:7e),eth_type(0x0806), packets:0, bytes:0, used:never, actions:5 recirc_id(0),in_port(5),eth(src=fa:16:3e:ab:ba:7e),eth_type(0x0800),ipv4(src=192.168.0.16,proto=1,frag=no), packets:148165, bytes:14520170, used:0.566s, actions:ct(zone=5004),recirc(0xa0) recirc_id(0),in_port(3),eth(),eth_type(0x0800),ipv4(frag=no), packets:886646, bytes:316947183, used:0.210s, flags:SFPR., actions:drop recirc_id(0),in_port(5),eth(src=fa:16:3e:ab:ba:7e,dst=fa:16:3e:7d:95:75),eth_type(0x0806),arp(sip=192.168.0.16,tip=192.168.0.5,op=1/0xff,sha=fa:16:3e:ab:ba:7e), packets:0, bytes:0, used:never, actions:userspace(pid=4294961925,controller(reason=4,dont_send=0,continuation=0,recirc_id=4618,rule_cookie=0x822002d,controller_id=0,max_len=65535)),set(tunnel(tun_id=0xb,src=192.168.56.122,dst=192.168.56.102,ttl=64,tp_dst=4789,flags(df|key))),4 安全组设置 openstack security group rule create --proto tcp 2e19a748-9086-49f8-9498-01abc1a964fe openstack security group rule create --proto tcp 6095293d-c2cd-433d-8a8f-e77ecb03609e openstack security group rule create --proto udp 2e19a748-9086-49f8-9498-01abc1a964fe openstack security group rule create --proto udp 6095293d-c2cd-433d-8a8f-e77ecb03609e ovs-vsctl add-port br-ex "ex-patch-int" ovs-vsctl set interface "ex-patch-int" type=patch ovs-vsctl set interface "ex-patch-int" options:peer=int-patch-ex ovs-vsctl add-port br-int "int-patch-ex" ovs-vsctl set interface "int-patch-ex" type=patch ovs-vsctl set interface "int-patch-ex" options:peer=ex-patch-int ovs-vsctl del-port br-ex "ex-patch-int" ovs-vsctl del-port br-int "int-patch-ex" ovs-vsctl del-port br-ex enp0s9 ovs-vsctl add-port br-int enp0s9 ovs-appctl ofproto/trace 重要命令 sudo ovs-ofctl -O OpenFlow13 show br-int sudo ovs-appctl ofproto/trace br-int "in_port=5,ip,nw_src=192.168.0.16,nw_dst=192.168.0.5" ovs-appctl dpctl/dump-conntrack 11.查看接口id等 ovs-appctl dpif/show 12.查看接口统计 ovs-ofctl dump-ports br-int 查看接口 sudo ovs-ofctl show br-int -O OpenFlow13 ovs常用命令 控制管理类 1.查看网桥和端口 ovs-vsctl show 1 2.创建一个网桥 ovs-vsctl add-br br0 ovs-vsctl set bridge br0 datapath_type=netdev 1 2 3.添加/删除一个端口 for system interfaces ovs-vsctl add-port br0 eth1 ovs-vsctl del-port br0 eth1 for DPDK ovs-vsctl add-port br0 dpdk1 -- set interface dpdk1 type=dpdk options:dpdk-devargs=0000:01:00.0 for DPDK bonds ovs-vsctl add-bond br0 dpdkbond0 dpdk1 dpdk2 \ -- set interface dpdk1 type=dpdk options:dpdk-devargs=0000:01:00.0 \ -- set interface dpdk2 type=dpdk options:dpdk-devargs=0000:02:00.0 1 2 3 4 5 6 7 8 9 4.设置/清除网桥的openflow协议版本 ovs-vsctl set bridge br0 protocols=OpenFlow13 ovs-vsctl clear bridge br0 protocols 1 2 5.查看某网桥当前流表 ovs-ofctl dump-flows br0 ovs-ofctl -O OpenFlow13 dump-flows br0 ovs-appctl bridge/dump-flows br0 1 2 3 6.设置/删除控制器 ovs-vsctl set-controller br0 tcp:1.2.3.4:6633 ovs-vsctl del-controller br0 1 2 7.查看控制器列表 ovs-vsctl list controller 1 8.设置/删除被动连接控制器 ovs-vsctl set-manager tcp:1.2.3.4:6640 ovs-vsctl get-manager ovs-vsctl del-manager 1 2 3 9.设置/移除可选选项 ovs-vsctl set Interface eth0 options:link_speed=1G ovs-vsctl remove Interface eth0 options link_speed 1 2 10.设置fail模式，支持standalone或者secure standalone(default)：清除所有控制器下发的流表，ovs自己接管 secure：按照原来流表继续转发 ovs-vsctl del-fail-mode br0 ovs-vsctl set-fail-mode br0 secure ovs-vsctl get-fail-mode br0 1 2 3 11.查看接口id等 ovs-appctl dpif/show 1 12.查看接口统计 ovs-ofctl dump-ports br0 1 流表类 流表操作 1.添加普通流表 ovs-ofctl add-flow br0 in_port=1,actions=output:2 1 2.删除所有流表 ovs-ofctl del-flows br0 1 3.按匹配项来删除流表 ovs-ofctl del-flows br0 "in_port=1" 1 匹配项 1.匹配vlan tag，范围为0-4095 ovs-ofctl add-flow br0 priority=401,in_port=1,dl_vlan=777,actions=output:2 1 2.匹配vlan pcp，范围为0-7 ovs-ofctl add-flow br0 priority=401,in_port=1,dl_vlan_pcp=7,actions=output:2 1 3.匹配源/目的MAC ovs-ofctl add-flow br0 in_port=1,dl_src=00:00:00:00:00:01/00:00:00:00:00:01,actions=output:2 ovs-ofctl add-flow br0 in_port=1,dl_dst=00:00:00:00:00:01/00:00:00:00:00:01,actions=output:2 1 2 4.匹配以太网类型，范围为0-65535 ovs-ofctl add-flow br0 in_port=1,dl_type=0x0806,actions=output:2 1 5.匹配源/目的IP 条件：指定dl_type=0x0800，或者ip/tcp ovs-ofctl add-flow br0 ip,in_port=1,nw_src=10.10.0.0/16,actions=output:2 ovs-ofctl add-flow br0 ip,in_port=1,nw_dst=10.20.0.0/16,actions=output:2 1 2 6.匹配协议号，范围为0-255 条件：指定dl_type=0x0800或者ip ICMP ovs-ofctl add-flow br0 ip,in_port=1,nw_proto=1,actions=output:2 7.匹配IP ToS/DSCP，tos范围为0-255，DSCP范围为0-63 条件：指定dl_type=0x0800/0x86dd，并且ToS低2位会被忽略(DSCP值为ToS的高6位，并且低2位为预留位) ovs-ofctl add-flow br0 ip,in_port=1,nw_tos=68,actions=output:2 ovs-ofctl add-flow br0 ip,in_port=1,ip_dscp=62,actions=output:2 8.匹配IP ecn位，范围为0-3 条件：指定dl_type=0x0800/0x86dd ovs-ofctl add-flow br0 ip,in_port=1,ip_ecn=2,actions=output:2 9.匹配IP TTL，范围为0-255 ovs-ofctl add-flow br0 ip,in_port=1,nw_ttl=128,actions=output:2 10.匹配tcp/udp，源/目的端口，范围为0-65535 匹配源tcp端口179 ovs-ofctl add-flow br0 tcp,tcp_src=179/0xfff0,actions=output:2 匹配目的tcp端口179 ovs-ofctl add-flow br0 tcp,tcp_dst=179/0xfff0,actions=output:2 匹配源udp端口1234 ovs-ofctl add-flow br0 udp,udp_src=1234/0xfff0,actions=output:2 匹配目的udp端口1234 ovs-ofctl add-flow br0 udp,udp_dst=1234/0xfff0,actions=output:2 11.匹配tcp flags tcp flags=fin，syn，rst，psh，ack，urg，ece，cwr，ns ovs-ofctl add-flow br0 tcp,tcp_flags=ack,actions=output:2 12.匹配icmp code，范围为0-255 条件：指定icmp ovs-ofctl add-flow br0 icmp,icmp_code=2,actions=output:2 13.匹配vlan TCI TCI低12位为vlan id，高3位为priority，例如tci=0xf123则vlan_id为0x123和vlan_pcp=7 ovs-ofctl add-flow br0 in_port=1,vlan_tci=0xf123,actions=output:2 14.匹配mpls label 条件：指定dl_type=0x8847/0x8848 ovs-ofctl add-flow br0 mpls,in_port=1,mpls_label=7,actions=output:2 15.匹配mpls tc，范围为0-7 条件：指定dl_type=0x8847/0x8848 ovs-ofctl add-flow br0 mpls,in_port=1,mpls_tc=7,actions=output:2 1 16.匹配tunnel id，源/目的IP 匹配tunnel id ovs-ofctl add-flow br0 in_port=1,tun_id=0x7/0xf,actions=output:2 匹配tunnel源IP ovs-ofctl add-flow br0 in_port=1,tun_src=192.168.1.0/255.255.255.0,actions=output:2 匹配tunnel目的IP ovs-ofctl add-flow br0 in_port=1,tun_dst=192.168.1.0/255.255.255.0,actions=output:2 一些匹配项的速记符 速记符 匹配项 ip dl_type=0x800 ipv6 dl_type=0x86dd icmp dl_type=0x0800,nw_proto=1 icmp6 dl_type=0x86dd,nw_proto=58 tcp dl_type=0x0800,nw_proto=6 tcp6 dl_type=0x86dd,nw_proto=6 udp dl_type=0x0800,nw_proto=17 udp6 dl_type=0x86dd,nw_proto=17 sctp dl_type=0x0800,nw_proto=132 sctp6 dl_type=0x86dd,nw_proto=132 arp dl_type=0x0806 rarp dl_type=0x8035 mpls dl_type=0x8847 mplsm dl_type=0x8848 指令动作 1.动作为出接口 从指定接口转发出去 ovs-ofctl add-flow br0 in_port=1,actions=output:2 1 2.动作为指定group group id为已创建的group table ovs-ofctl add-flow br0 in_port=1,actions=group:666 1 3.动作为normal 转为L2/L3处理流程 ovs-ofctl add-flow br0 in_port=1,actions=normal 1 4.动作为flood 从所有物理接口转发出去，除了入接口和已关闭flooding的接口 ovs-ofctl add-flow br0 in_port=1,actions=flood 1 5.动作为all 从所有物理接口转发出去，除了入接口 ovs-ofctl add-flow br0 in_port=1,actions=all 1 6.动作为local 一般是转发给本地网桥 ovs-ofctl add-flow br0 in_port=1,actions=local 1 7.动作为in_port 从入接口转发回去 ovs-ofctl add-flow br0 in_port=1,actions=in_port 1 8.动作为controller 以packet-in消息上送给控制器 ovs-ofctl add-flow br0 in_port=1,actions=controller 1 9.动作为drop 丢弃数据包操作 ovs-ofctl add-flow br0 in_port=1,actions=drop 1 10.动作为mod_vlan_vid 修改报文的vlan id，该选项会使vlan_pcp置为0 ovs-ofctl add-flow br0 in_port=1,actions=mod_vlan_vid:8,output:2 1 11.动作为mod_vlan_pcp 修改报文的vlan优先级，该选项会使vlan_id置为0 ovs-ofctl add-flow br0 in_port=1,actions=mod_vlan_pcp:7,output:2 1 12.动作为strip_vlan 剥掉报文内外层vlan tag ovs-ofctl add-flow br0 in_port=1,actions=strip_vlan,output:2 1 13.动作为push_vlan 在报文外层压入一层vlan tag，需要使用openflow1.1以上版本兼容 ovs-ofctl add-flow -O OpenFlow13 br0 in_port=1,actions=push_vlan:0x8100,set_field:4097-\>vlan_vid,output:2 1 ps: set field值为4096+vlan_id，并且vlan优先级为0，即4096-8191，对应的vlan_id为0-4095 14.动作为push_mpls 修改报文的ethertype，并且压入一个MPLS LSE ovs-ofctl add-flow br0 in_port=1,actions=push_mpls:0x8847,set_field:10-\>mpls_label,output:2 1 15.动作为pop_mpls 剥掉最外层mpls标签，并且修改ethertype为非mpls类型 ovs-ofctl add-flow br0 mpls,in_port=1,mpls_label=20,actions=pop_mpls:0x0800,output:2 1 16.动作为修改源/目的MAC，修改源/目的IP 修改源MAC ovs-ofctl add-flow br0 in_port=1,actions=mod_dl_src:00:00:00:00:00:01,output:2 修改目的MAC ovs-ofctl add-flow br0 in_port=1,actions=mod_dl_dst:00:00:00:00:00:01,output:2 修改源IP ovs-ofctl add-flow br0 in_port=1,actions=mod_nw_src:192.168.1.1,output:2 修改目的IP ovs-ofctl add-flow br0 in_port=1,actions=mod_nw_dst:192.168.1.1,output:2 17.动作为修改TCP/UDP/SCTP源目的端口 修改TCP源端口 ovs-ofctl add-flow br0 tcp,in_port=1,actions=mod_tp_src:67,output:2 修改TCP目的端口 ovs-ofctl add-flow br0 tcp,in_port=1,actions=mod_tp_dst:68,output:2 修改UDP源端口 ovs-ofctl add-flow br0 udp,in_port=1,actions=mod_tp_src:67,output:2 修改UDP目的端口 ovs-ofctl add-flow br0 udp,in_port=1,actions=mod_tp_dst:68,output:2 18.动作为mod_nw_tos 条件：指定dl_type=0x0800 修改ToS字段的高6位，范围为0-255，值必须为4的倍数，并且不会去修改ToS低2位ecn值 ovs-ofctl add-flow br0 ip,in_port=1,actions=mod_nw_tos:68,output:2 1 19.动作为mod_nw_ecn 条件：指定dl_type=0x0800，需要使用openflow1.1以上版本兼容 修改ToS字段的低2位，范围为0-3，并且不会去修改ToS高6位的DSCP值 ovs-ofctl add-flow br0 ip,in_port=1,actions=mod_nw_ecn:2,output:2 1 20.动作为mod_nw_ttl 修改IP报文ttl值，需要使用openflow1.1以上版本兼容 ovs-ofctl add-flow -O OpenFlow13 br0 in_port=1,actions=mod_nw_ttl:6,output:2 1 21.动作为dec_ttl 对IP报文进行ttl自减操作 ovs-ofctl add-flow br0 in_port=1,actions=dec_ttl,output:2 1 22.动作为set_mpls_label 对报文最外层mpls标签进行修改，范围为20bit值 ovs-ofctl add-flow br0 in_port=1,actions=set_mpls_label:666,output:2 1 23.动作为set_mpls_tc 对报文最外层mpls tc进行修改，范围为0-7 ovs-ofctl add-flow br0 in_port=1,actions=set_mpls_tc:7,output:2 1 24.动作为set_mpls_ttl 对报文最外层mpls ttl进行修改，范围为0-255 ovs-ofctl add-flow br0 in_port=1,actions=set_mpls_ttl:255,output:2 1 25.动作为dec_mpls_ttl 对报文最外层mpls ttl进行自减操作 ovs-ofctl add-flow br0 in_port=1,actions=dec_mpls_ttl,output:2 1 26.动作为move NXM字段 使用move参数对NXM字段进行操作 将报文源MAC复制到目的MAC字段，并且将源MAC改为00:00:00:00:00:01 ovs-ofctl add-flow br0 in_port=1,actions=move:NXM_OF_ETH_SRC[]-\>NXM_OF_ETH_DST[],mod_dl_src:00:00:00:00:00:01,output:2 1 2 ps: 常用NXM字段参照表 NXM字段 报文字段 NXM_OF_ETH_SRC 源MAC NXM_OF_ETH_DST 目的MAC NXM_OF_ETH_TYPE 以太网类型 NXM_OF_VLAN_TCI vid NXM_OF_IP_PROTO IP协议号 NXM_OF_IP_TOS IP ToS值 NXM_NX_IP_ECN IP ToS ECN NXM_OF_IP_SRC 源IP NXM_OF_IP_DST 目的IP NXM_OF_TCP_SRC TCP源端口 NXM_OF_TCP_DST TCP目的端口 NXM_OF_UDP_SRC UDP源端口 NXM_OF_UDP_DST UDP目的端口 NXM_OF_SCTP_SRC SCTP源端口 NXM_OF_SCTP_DST SCTP目的端口 27.动作为load NXM字段 使用load参数对NXM字段进行赋值操作 push mpls label，并且把10(0xa)赋值给mpls label ovs-ofctl add-flow br0 in_port=1,actions=push_mpls:0x8847,load:0xa-\>OXM_OF_MPLS_LABEL[],output:2 对目的MAC进行赋值 ovs-ofctl add-flow br0 in_port=1,actions=load:0x001122334455-\>OXM_OF_ETH_DST[],output:2 1 2 3 4 28.动作为pop_vlan 弹出报文最外层vlan tag ovs-ofctl add-flow br0 in_port=1,dl_type=0x8100,dl_vlan=777,actions=pop_vlan,output:2 1 meter表 常用操作 由于meter表是openflow1.3版本以后才支持，所以所有命令需要指定OpenFlow1.3版本以上 ps: 在openvswitch-v2.8之前的版本中，还不支持meter 在v2.8版本之后已经实现，要正常使用的话，需要注意的是datapath类型要指定为netdev，band type暂时只支持drop，还不支持DSCP REMARK 1.查看当前设备对meter的支持 ovs-ofctl -O OpenFlow13 meter-features br0 2.查看meter表 ovs-ofctl -O OpenFlow13 dump-meters br0 3.查看meter统计 ovs-ofctl -O OpenFlow13 meter-stats br0 4.创建meter表 限速类型以kbps(kilobits per second)计算，超过20kb/s则丢弃 ovs-ofctl -O OpenFlow13 add-meter br0 meter=1,kbps,band=type=drop,rate=20 同上，增加burst size参数 ovs-ofctl -O OpenFlow13 add-meter br0 meter=2,kbps,band=type=drop,rate=20,burst_size=256 同上，增加stats参数,对meter进行计数统计 ovs-ofctl -O OpenFlow13 add-meter br0 meter=3,kbps,stats,band=type=drop,rate=20,burst_size=256 限速类型以pktps(packets per second)计算，超过1000pkt/s则丢弃 ovs-ofctl -O OpenFlow13 add-meter br0 meter=4,pktps,band=type=drop,rate=1000 5.删除meter表 删除全部meter表 ovs-ofctl -O OpenFlow13 del-meters br0 删除meter id=1 ovs-ofctl -O OpenFlow13 del-meter br0 meter=1 6.创建流表 ovs-ofctl -O OpenFlow13 add-flow br0 in_port=1,actions=meter:1,output:2 group表 由于group表是openflow1.1版本以后才支持，所以所有命令需要指定OpenFlow1.1版本以上 常用操作 group table支持4种类型 all：所有buckets都执行一遍 select： 每次选择其中一个bucket执行，常用于负载均衡应用 ff(FAST FAILOVER)：快速故障修复，用于检测解决接口等故障 indirect：间接执行，类似于一个函数方法，被另一个group来调用 1.查看当前设备对group的支持 ovs-ofctl -O OpenFlow13 dump-group-features br0 2.查看group表 ovs-ofctl -O OpenFlow13 dump-groups br0 3.创建group表 类型为all ovs-ofctl -O OpenFlow13 add-group br0 group_id=1,type=all,bucket=output:1,bucket=output:2,bucket=output:3 类型为select ovs-ofctl -O OpenFlow13 add-group br0 group_id=2,type=select,bucket=output:1,bucket=output:2,bucket=output:3 类型为select，指定hash方法(5元组，OpenFlow1.5+) ovs-ofctl -O OpenFlow15 add-group br0 group_id=3,type=select,selection_method=hash,fields=ip_src,bucket=output:2,bucket=output:3 4.删除group表 ovs-ofctl -O OpenFlow13 del-groups br0 group_id=2 5.创建流表 ovs-ofctl -O OpenFlow13 add-flow br0 in_port=1,actions=group:2 goto table配置 数据流先从table0开始匹配，如actions有goto_table，再进行后续table的匹配，实现多级流水线，如需使用goto table，则创建流表时，指定table id，范围为0-255，不指定则默认为table0 1.在table0中添加一条流表条目 ovs-ofctl add-flow br0 table=0,in_port=1,actions=goto_table=1 2.在table1中添加一条流表条目 ovs-ofctl add-flow br0 table=1,ip,nw_dst=10.10.0.0/16,actions=output:2 tunnel配置 如需配置tunnel，必需确保当前系统对各tunnel的remote ip网络可达 gre 1.创建一个gre接口，并且指定端口id=1001 ovs-vsctl add-port br0 gre1 -- set Interface gre1 type=gre options:remote_ip=1.1.1.1 ofport_request=1001 2.可选选项 将tos或者ttl在隧道上继承，并将tunnel id设置成123 ovs-vsctl set Interface gre1 options:tos=inherit options:ttl=inherit options:key=123 3.创建关于gre流表 封装gre转发 ovs-ofctl add-flow br0 ip,in_port=1,nw_dst=10.10.0.0/16,actions=output:1001 解封gre转发 ovs-ofctl add-flow br0 in_port=1001,actions=output:1 vxlan 1.创建一个vxlan接口，并且指定端口id=2001 ovs-vsctl add-port br0 vxlan1 -- set Interface vxlan1 type=vxlan options:remote_ip=1.1.1.1 ofport_request=2001 2.可选选项 将tos或者ttl在隧道上继承，将vni设置成123，UDP目的端为设置成8472(默认为4789) ovs-vsctl set Interface vxlan1 options:tos=inherit options:ttl=inherit options:key=123 options:dst_port=8472 3.创建关于vxlan流表 封装vxlan转发 ovs-ofctl add-flow br0 ip,in_port=1,nw_dst=10.10.0.0/16,actions=output:2001 解封vxlan转发 ovs-ofctl add-flow br0 in_port=2001,actions=output:1 sflow配置 1.对网桥br0进行sflow监控 agent: 与collector通信所在的网口名，通常为管理口 target: collector监听的IP地址和端口，端口默认为6343 header: sFlow在采样时截取报文头的长度 polling: 采样时间间隔，单位为秒 ovs-vsctl -- --id=@sflow create sflow agent=eth0 target=\"10.0.0.1:6343\" header=128 sampling=64 polling=10 -- set bridge br0 sflow=@sflow 2.查看创建的sflow ovs-vsctl list sflow 3.删除对应的网桥sflow配置，参数为sFlow UUID ovs-vsctl remove bridge br0 sflow 7b9b962e-fe09-407c-b224-5d37d9c1f2b3 4.删除网桥下所有sflow配置 ovs-vsctl -- clear bridge br0 sflow 1 QoS配置 ingress policing 1.配置ingress policing，对接口eth0入流限速10Mbps ovs-vsctl set interface eth0 ingress_policing_rate=10000 ovs-vsctl set interface eth0 ingress_policing_burst=8000 2.清除相应接口的ingress policer配置 ovs-vsctl set interface eth0 ingress_policing_rate=0 ovs-vsctl set interface eth0 ingress_policing_burst=0 3.查看接口ingress policer配置 ovs-vsctl list interface eth0 4.查看网桥支持的Qos类型 ovs-appctl qos/show-types br0 端口镜像配置 1.配置eth0收到/发送的数据包镜像到eth1 ovs-vsctl -- set bridge br0 mirrors=@m \ -- --id=@eth0 get port eth0 \ -- --id=@eth1 get port eth1 \ -- --id=@m create mirror name=mymirror select-dst-port=@eth0 select-src-port=@eth0 output-port=@eth1 2.删除端口镜像配置 ovs-vsctl -- --id=@m get mirror mymirror -- remove bridge br0 mirrors @m 3.清除网桥下所有端口镜像配置 ovs-vsctl clear bridge br0 mirrors 4.查看端口镜像配置 ovs-vsctl get bridge br0 mirrors Open vSwitch中有多个命令，分别有不同的作用，大致如下： ovs-vsctl用于控制ovs db ovs-ofctl用于管理OpenFlow switch 的 flow ovs-dpctl用于管理ovs的datapath ovs-appctl用于查询和管理ovs daemon 转载于:https://www.cnblogs.com/liuhongru/p/10336849.html 本篇文章为转载内容。原文链接：https://blog.csdn.net/weixin_30876945/article/details/99916308。 该文由互联网用户投稿提供，文中观点代表作者本人意见，并不代表本站的立场。 作为信息平台，本站仅提供文章转载服务，并不拥有其所有权，也不对文章内容的真实性、准确性和合法性承担责任。 如发现本文存在侵权、违法、违规或事实不符的情况，请及时联系我们，我们将第一时间进行核实并删除相应内容。

...rRegistry.java:47)at org.apache.ibatis.session.Configuration.getMapper(Configuration.java:779)at org.apache.ibatis.session.defaults.DefaultSqlSession.getMapper(DefaultSqlSession.java:291)at com.itcase.dao.UserDaoTest.test1(UserDaoTest.java:18)at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)at java.lang.reflect.Method.invoke(Method.java:498)at org.junit.runners.model.FrameworkMethod$1.runReflectiveCall(FrameworkMethod.java:47)at org.junit.internal.runners.model.ReflectiveCallable.run(ReflectiveCallable.java:12)at org.junit.runners.model.FrameworkMethod.invokeExplosively(FrameworkMethod.java:44)at org.junit.internal.runners.statements.InvokeMethod.evaluate(InvokeMethod.java:17)at org.junit.runners.ParentRunner.runLeaf(ParentRunner.java:271)at org.junit.runners.BlockJUnit4ClassRunner.runChild(BlockJUnit4ClassRunner.java:70)at org.junit.runners.BlockJUnit4ClassRunner.runChild(BlockJUnit4ClassRunner.java:50)at org.junit.runners.ParentRunner$3.run(ParentRunner.java:238)at org.junit.runners.ParentRunner$1.schedule(ParentRunner.java:63)at org.junit.runners.ParentRunner.runChildren(ParentRunner.java:236)at org.junit.runners.ParentRunner.access$000(ParentRunner.java:53)at org.junit.runners.ParentRunner$2.evaluate(ParentRunner.java:229)at org.junit.runners.ParentRunner.run(ParentRunner.java:309)at org.junit.runner.JUnitCore.run(JUnitCore.java:160)at com.intellij.junit4.JUnit4IdeaTestRunner.startRunnerWithArgs(JUnit4IdeaTestRunner.java:68)at com.intellij.rt.execution.junit.IdeaTestRunner$Repeater.startRunnerWithArgs(IdeaTestRunner.java:47)at com.intellij.rt.execution.junit.JUnitStarter.prepareStreamsAndStart(JUnitStarter.java:242)at com.intellij.rt.execution.junit.JUnitStarter.main(JUnitStarter.java:70) 一般这总情况就是 > Mybatis的config文件忘记在<configuration></configuration>> 里加上以下代码了，下边的UserMapper.xml换成你们报错的文件 <mappers><mapper resource="com/itcase/dao/UserMapper.xml"/></mappers> 要是加了mapper依然报错，如果是以下错误的话：点我看另一篇博客 Caused by: org.apache.ibatis.exceptions.PersistenceException: Error building SqlSession. The error may exist in com/itcase/dao/UserMapper.xml Cause: org.apache.ibatis.builder.BuilderException: Error parsing SQL Mapper Configuration. Cause: java.io.IOException: Could not find resource com/itcase/dao/UserMapper.xmlat org.apache.ibatis.exceptions.ExceptionFactory.wrapException(ExceptionFactory.java:30)at org.apache.ibatis.session.SqlSessionFactoryBuilder.build(SqlSessionFactoryBuilder.java:80)at org.apache.ibatis.session.SqlSessionFactoryBuilder.build(SqlSessionFactoryBuilder.java:64)at com.itcase.util.MybatisUtil.<clinit>(MybatisUtil.java:20)... 23 moreCaused by: org.apache.ibatis.builder.BuilderException: Error parsing SQL Mapper Configuration. Cause: java.io.IOException: Could not find resource com/itcase/dao/UserMapper.xmlat org.apache.ibatis.builder.xml.XMLConfigBuilder.parseConfiguration(XMLConfigBuilder.java:121)at org.apache.ibatis.builder.xml.XMLConfigBuilder.parse(XMLConfigBuilder.java:98)at org.apache.ibatis.session.SqlSessionFactoryBuilder.build(SqlSessionFactoryBuilder.java:78)... 25 moreCaused by: java.io.IOException: Could not find resource com/itcase/dao/UserMapper.xmlat org.apache.ibatis.io.Resources.getResourceAsStream(Resources.java:114)at org.apache.ibatis.io.Resources.getResourceAsStream(Resources.java:100)at org.apache.ibatis.builder.xml.XMLConfigBuilder.mapperElement(XMLConfigBuilder.java:372)at org.apache.ibatis.builder.xml.XMLConfigBuilder.parseConfiguration(XMLConfigBuilder.java:119)... 27 more 本篇文章为转载内容。原文链接：https://blog.csdn.net/kaikai_gege/article/details/109730197。 该文由互联网用户投稿提供，文中观点代表作者本人意见，并不代表本站的立场。 作为信息平台，本站仅提供文章转载服务，并不拥有其所有权，也不对文章内容的真实性、准确性和合法性承担责任。 如发现本文存在侵权、违法、违规或事实不符的情况，请及时联系我们，我们将第一时间进行核实并删除相应内容。

...。比如说，如果你没把JAVA_HOME环境变量设置对，Dubbo就找不到Java的藏身之处（也就是安装路径），这样一来，它就没法正常启动运行啦。 解决这个问题的方法非常简单，只需要在系统环境变量中添加JAVA_HOME即可。例如，在Windows系统中，可以在"我的电脑" -> "属性" -> "高级系统设置" -> "环境变量"中添加。 三、日志配置错误 日志配置错误也是导致Dubbo无法正常运行的一个重要原因。要是你日志的配置文件，比如说logback.xml，搞错了设定，那就等于给日志输出挖了个坑。这样一来，日志就无法顺畅地“说话”了，我们也就没法通过这些日志来摸清系统的运行状况，了解它到底是怎么干活儿的了。 解决这个问题的方法也很简单，只需要检查日志配置文件中的配置是否正确即可。比如，我们可以瞅瞅日志输出的目的地是不是设定对了，还有日志的详细程度级别是否也调得恰到好处，这些小细节都值得我们关注检查一下。 四、代码示例 为了更直观地理解环境配置问题和日志配置错误，下面给出一些代码示例。 首先，来看一下不正确的环境变量设置。假设我们在没有设置JAVA_HOME的情况下尝试启动Dubbo，那么就会出现以下错误： Exception in thread "main" java.lang.UnsatisfiedLinkError: no javassist in java.library.path at java.lang.ClassLoader.loadLibrary(ClassLoader.java:1867) at java.lang.Runtime.loadLibrary0(Runtime.java:870) at java.lang.System.loadLibrary(System.java:1122) at com.alibaba.dubbo.common.logger.LoggerFactory.getLogger(LoggerFactory.java:39) at com.alibaba.dubbo.common.logger.LoggerFactory.getLogger(LoggerFactory.java:51) at com.alibaba.dubbo.config.ApplicationConfig.(ApplicationConfig.java:114) at com.example.demo.DemoApplication.main(DemoApplication.java:12) Caused by: java.lang.ClassNotFoundException: javassist at java.net.URLClassLoader.findClass(URLClassLoader.java:382) at java.lang.ClassLoader.loadClass(ClassLoader.java:424) at sun.misc.Launcher$AppClassLoader.loadClass(Launcher.java:349) at java.lang.ClassLoader.loadClass(ClassLoader.java:357) ... 6 more 可以看出，由于JAVA_HOME环境变量未设置，所以无法找到Java的安装路径，从而导致了这个错误。 接下来，来看一下不正确的日志配置。假设我们在日志配置文件中错误地指定了日志输出的目标位置，那么就会出现以下错误： 2022-03-08 15:29:54,742 ERROR [main] org.apache.log4j.ConsoleAppender - Error initializing ConsoleAppender appenders named [STDOUT] org.apache.log4j.AppenderSkeleton$InvalidAppenderException: No such appender 'STDOUT' in category [com.example.demo]. at org.apache.log4j.Category.forcedLog(Category.java:393) at org.apache.log4j.Category.access$100(Category.java:67) at org.apache.log4j.Category$AppenderAttachedObject.append(Category.java:839) at org.apache.log4j.AppenderSkeleton.doAppend(AppenderSkeleton.java:248) at org.apache.log4j.helpers.AppenderAttachableImpl.appendLoopOnAppenders(AppenderAttachableImpl.java:51) at org.apache.log4j.Category.callAppenders(Category.java:206) at org.apache.log4j.Category.debug(Category.java:267) at org.apache.log4j.Category.info(Category.java:294) at org.apache.log4j.Logger.info(Logger.java:465) at com.example.demo.DemoApplication.main(DemoApplication.java:16) 可以看出，由于日志配置文件中的配置错误，所以无法将日志输出到指定的位置，从而导致了这个错误。 五、总结 通过以上分析，我们可以看出，环境配置问题和日志配置错误都是非常严重的问题，如果不及时处理，就会导致Dubbo无法正常运行，从而影响我们的工作。所以呢，咱们得好好学习、掌握这些知识点，这样一来，在实际工作中碰到问题时，就能更有效率地避开陷阱，解决麻烦了。同时，我们也应该养成良好的编程习惯，比如定期检查环境变量和日志配置文件，确保它们的正确性。

...ng;import java.util.Date;import java.util.HashMap;import java.util.Map;import java.util.Properties;import java.util.Random;import kafka.javaapi.producer.Producer;import kafka.producer.KeyedMessage;import kafka.producer.ProducerConfig;/ 数据生成代码，Kafka Producer产生数据/public class MockAdClickedStat {/ @param args/public static void main(String[] args) {final Random random = new Random();final String[] provinces = new String[]{"Guangdong", "Zhejiang", "Jiangsu", "Fujian"};final Map<String, String[]> cities = new HashMap<String, String[]>();cities.put("Guangdong", new String[]{"Guangzhou", "Shenzhen", "Dongguan"});cities.put("Zhejiang", new String[]{"Hangzhou", "Wenzhou", "Ningbo"});cities.put("Jiangsu", new String[]{"Nanjing", "Suzhou", "Wuxi"});cities.put("Fujian", new String[]{"Fuzhou", "Xiamen", "Sanming"});final String[] ips = new String[] {"192.168.112.240","192.168.112.239","192.168.112.245","192.168.112.246","192.168.112.247","192.168.112.248","192.168.112.249","192.168.112.250","192.168.112.251","192.168.112.252","192.168.112.253","192.168.112.254",};/ Kafka相关的基本配置信息/Properties kafkaConf = new Properties();kafkaConf.put("serializer.class", "kafka.serializer.StringEncoder");kafkaConf.put("metadeta.broker.list", "Master:9092,Worker1:9092,Worker2:9092");ProducerConfig producerConfig = new ProducerConfig(kafkaConf);final Producer<Integer, String> producer = new Producer<Integer, String>(producerConfig);new Thread(new Runnable() {public void run() {while(true) {//在线处理广告点击流的基本数据格式：timestamp、ip、userID、adID、province、cityLong timestamp = new Date().getTime();String ip = ips[random.nextInt(12)]; //可以采用网络上免费提供的ip库int userID = random.nextInt(10000);int adID = random.nextInt(100);String province = provinces[random.nextInt(4)];String city = cities.get(province)[random.nextInt(3)];String clickedAd = timestamp + "\t" + ip + "\t" + userID + "\t" + adID + "\t" + province + "\t" + city;producer.send(new KeyedMessage<Integer, String>("AdClicked", clickedAd));try {Thread.sleep(50);} catch (InterruptedException e) {// TODO Auto-generated catch blocke.printStackTrace();} }} }).start();} } package com.tom.spark.SparkApps.sparkstreaming;import java.sql.Connection;import java.sql.DriverManager;import java.sql.PreparedStatement;import java.sql.ResultSet;import java.sql.SQLException;import java.util.ArrayList;import java.util.Arrays;import java.util.HashMap;import java.util.HashSet;import java.util.Iterator;import java.util.List;import java.util.Map;import java.util.Set;import java.util.concurrent.LinkedBlockingQueue;import kafka.serializer.StringDecoder;import org.apache.spark.SparkConf;import org.apache.spark.api.java.JavaPairRDD;import org.apache.spark.api.java.JavaRDD;import org.apache.spark.api.java.JavaSparkContext;import org.apache.spark.api.java.function.Function;import org.apache.spark.api.java.function.Function2;import org.apache.spark.api.java.function.PairFunction;import org.apache.spark.api.java.function.VoidFunction;import org.apache.spark.sql.DataFrame;import org.apache.spark.sql.Row;import org.apache.spark.sql.RowFactory;import org.apache.spark.sql.hive.HiveContext;import org.apache.spark.sql.types.DataTypes;import org.apache.spark.sql.types.StructType;import org.apache.spark.streaming.Durations;import org.apache.spark.streaming.api.java.JavaDStream;import org.apache.spark.streaming.api.java.JavaPairDStream;import org.apache.spark.streaming.api.java.JavaPairInputDStream;import org.apache.spark.streaming.api.java.JavaStreamingContext;import org.apache.spark.streaming.api.java.JavaStreamingContextFactory;import org.apache.spark.streaming.kafka.KafkaUtils;import com.google.common.base.Optional;import scala.Tuple2;/ 数据处理，Kafka消费者/public class AdClickedStreamingStats {/ @param args/public static void main(String[] args) {// TODO Auto-generated method stub//好处：1、checkpoint 2、工厂final SparkConf conf = new SparkConf().setAppName("SparkStreamingOnKafkaDirect").setMaster("hdfs://Master:7077/");final String checkpointDirectory = "hdfs://Master:9000/library/SparkStreaming/CheckPoint_Data";JavaStreamingContextFactory factory = new JavaStreamingContextFactory() {public JavaStreamingContext create() {// TODO Auto-generated method stubreturn createContext(checkpointDirectory, conf);} };/ 可以从失败中恢复Driver，不过还需要指定Driver这个进程运行在Cluster，并且在提交应用程序的时候制定--supervise;/JavaStreamingContext javassc = JavaStreamingContext.getOrCreate(checkpointDirectory, factory);/ 第三步：创建Spark Streaming输入数据来源input Stream: 1、数据输入来源可以基于File、HDFS、Flume、Kafka、Socket等 2、在这里我们指定数据来源于网络Socket端口，Spark Streaming连接上该端口并在运行的时候一直监听该端口的数据 (当然该端口服务首先必须存在），并且在后续会根据业务需要不断有数据产生（当然对于Spark Streaming 应用程序的运行而言，有无数据其处理流程都是一样的） 3、如果经常在每间隔5秒钟没有数据的话不断启动空的Job其实会造成调度资源的浪费，因为并没有数据需要发生计算；所以 实际的企业级生成环境的代码在具体提交Job前会判断是否有数据，如果没有的话就不再提交Job；///创建Kafka元数据来让Spark Streaming这个Kafka Consumer利用Map<String, String> kafkaParameters = new HashMap<String, String>();kafkaParameters.put("metadata.broker.list", "Master:9092,Worker1:9092,Worker2:9092");Set<String> topics = new HashSet<String>();topics.add("SparkStreamingDirected");JavaPairInputDStream<String, String> adClickedStreaming = KafkaUtils.createDirectStream(javassc, String.class, String.class, StringDecoder.class, StringDecoder.class,kafkaParameters, topics);/因为要对黑名单进行过滤，而数据是在RDD中的，所以必然使用transform这个函数； 但是在这里我们必须使用transformToPair，原因是读取进来的Kafka的数据是Pair<String,String>类型, 另一个原因是过滤后的数据要进行进一步处理，所以必须是读进的Kafka数据的原始类型 在此再次说明，每个Batch Duration中实际上讲输入的数据就是被一个且仅被一个RDD封装的，你可以有多个 InputDStream，但其实在产生job的时候，这些不同的InputDStream在Batch Duration中就相当于Spark基于HDFS 数据操作的不同文件来源而已罢了。/JavaPairDStream<String, String> filteredadClickedStreaming = adClickedStreaming.transformToPair(new Function<JavaPairRDD<String,String>, JavaPairRDD<String,String>>() {public JavaPairRDD<String, String> call(JavaPairRDD<String, String> rdd) throws Exception {/ 在线黑名单过滤思路步骤： 1、从数据库中获取黑名单转换成RDD，即新的RDD实例封装黑名单数据； 2、然后把代表黑名单的RDD的实例和Batch Duration产生的RDD进行Join操作， 准确的说是进行leftOuterJoin操作，也就是说使用Batch Duration产生的RDD和代表黑名单的RDD实例进行 leftOuterJoin操作，如果两者都有内容的话，就会是true，否则的话就是false 我们要留下的是leftOuterJoin结果为false； /final List<String> blackListNames = new ArrayList<String>();JDBCWrapper jdbcWrapper = JDBCWrapper.getJDBCInstance();jdbcWrapper.doQuery("SELECT FROM blacklisttable", null, new ExecuteCallBack() {public void resultCallBack(ResultSet result) throws Exception {while(result.next()){blackListNames.add(result.getString(1));} }});List<Tuple2<String, Boolean>> blackListTuple = new ArrayList<Tuple2<String,Boolean>>();for(String name : blackListNames) {blackListTuple.add(new Tuple2<String, Boolean>(name, true));}List<Tuple2<String, Boolean>> blacklistFromListDB = blackListTuple; //数据来自于查询的黑名单表并且映射成为<String, Boolean>JavaSparkContext jsc = new JavaSparkContext(rdd.context());/ 黑名单的表中只有userID，但是如果要进行join操作的话就必须是Key-Value，所以在这里我们需要 基于数据表中的数据产生Key-Value类型的数据集合/JavaPairRDD<String, Boolean> blackListRDD = jsc.parallelizePairs(blacklistFromListDB);/ 进行操作的时候肯定是基于userID进行join，所以必须把传入的rdd进行mapToPair操作转化成为符合格式的RDD/JavaPairRDD<String, Tuple2<String, String>> rdd2Pair = rdd.mapToPair(new PairFunction<Tuple2<String,String>, String, Tuple2<String, String>>() {public Tuple2<String, Tuple2<String, String>> call(Tuple2<String, String> t) throws Exception {// TODO Auto-generated method stubString userID = t._2.split("\t")[2];return new Tuple2<String, Tuple2<String,String>>(userID, t);} });JavaPairRDD<String, Tuple2<Tuple2<String, String>, Optional<Boolean>>> joined = rdd2Pair.leftOuterJoin(blackListRDD);JavaPairRDD<String, String> result = joined.filter(new Function<Tuple2<String,Tuple2<Tuple2<String,String>,Optional<Boolean>>>, Boolean>() {public Boolean call(Tuple2<String, Tuple2<Tuple2<String, String>, Optional<Boolean>>> tuple)throws Exception {// TODO Auto-generated method stubOptional<Boolean> optional = tuple._2._2;if(optional.isPresent() && optional.get()){return false;} else {return true;} }}).mapToPair(new PairFunction<Tuple2<String,Tuple2<Tuple2<String,String>,Optional<Boolean>>>, String, String>() {public Tuple2<String, String> call(Tuple2<String, Tuple2<Tuple2<String, String>, Optional<Boolean>>> t)throws Exception {// TODO Auto-generated method stubreturn t._2._1;} });return result;} });//广告点击的基本数据格式：timestamp、ip、userID、adID、province、cityJavaPairDStream<String, Long> pairs = filteredadClickedStreaming.mapToPair(new PairFunction<Tuple2<String,String>, String, Long>() {public Tuple2<String, Long> call(Tuple2<String, String> t) throws Exception {String[] splited=t._2.split("\t");String timestamp = splited[0]; //YYYY-MM-DDString ip = splited[1];String userID = splited[2];String adID = splited[3];String province = splited[4];String city = splited[5]; String clickedRecord = timestamp + "_" +ip + "_"+userID+"_"+adID+"_"+province +"_"+city;return new Tuple2<String, Long>(clickedRecord, 1L);} });/ 第4.3步：在单词实例计数为1基础上，统计每个单词在文件中出现的总次数/JavaPairDStream<String, Long> adClickedUsers= pairs.reduceByKey(new Function2<Long, Long, Long>() {public Long call(Long i1, Long i2) throws Exception{return i1 + i2;} });/判断有效的点击，复杂化的采用机器学习训练模型进行在线过滤 简单的根据ip判断1天不超过100次；也可以通过一个batch duration的点击次数判断是否非法广告点击，通过一个batch来判断是不完整的，还需要一天的数据也可以每一个小时来判断。/JavaPairDStream<String, Long> filterClickedBatch = adClickedUsers.filter(new Function<Tuple2<String,Long>, Boolean>() {public Boolean call(Tuple2<String, Long> v1) throws Exception {if (1 < v1._2){//更新一些黑名单的数据库表return false;} else { return true;} }});//filterClickedBatch.print();//写入数据库filterClickedBatch.foreachRDD(new Function<JavaPairRDD<String,Long>, Void>() {public Void call(JavaPairRDD<String, Long> rdd) throws Exception {rdd.foreachPartition(new VoidFunction<Iterator<Tuple2<String,Long>>>() {public void call(Iterator<Tuple2<String, Long>> partition) throws Exception {//使用数据库连接池的高效读写数据库的方式将数据写入数据库mysql//例如一次插入 1000条 records，使用insertBatch 或 updateBatch//插入的用户数据信息：userID,adID,clickedCount,time//这里面有一个问题，可能出现两条记录的key是一样的，此时需要更新累加操作List<UserAdClicked> userAdClickedList = new ArrayList<UserAdClicked>();while(partition.hasNext()) {Tuple2<String, Long> record = partition.next();String[] splited = record._1.split("\t");UserAdClicked userClicked = new UserAdClicked();userClicked.setTimestamp(splited[0]);userClicked.setIp(splited[1]);userClicked.setUserID(splited[2]);userClicked.setAdID(splited[3]);userClicked.setProvince(splited[4]);userClicked.setCity(splited[5]);userAdClickedList.add(userClicked);}final List<UserAdClicked> inserting = new ArrayList<UserAdClicked>();final List<UserAdClicked> updating = new ArrayList<UserAdClicked>();JDBCWrapper jdbcWrapper = JDBCWrapper.getJDBCInstance();//表的字段timestamp、ip、userID、adID、province、city、clickedCountfor(final UserAdClicked clicked : userAdClickedList) {jdbcWrapper.doQuery("SELECT clickedCount FROM adclicked WHERE"+ " timestamp =? AND userID = ? AND adID = ?",new Object[]{clicked.getTimestamp(), clicked.getUserID(),clicked.getAdID()}, new ExecuteCallBack() {public void resultCallBack(ResultSet result) throws Exception {// TODO Auto-generated method stubif(result.next()) {long count = result.getLong(1);clicked.setClickedCount(count);updating.add(clicked);} else {inserting.add(clicked);clicked.setClickedCount(1L);} }});}//表的字段timestamp、ip、userID、adID、province、city、clickedCountList<Object[]> insertParametersList = new ArrayList<Object[]>();for(UserAdClicked insertRecord : inserting) {insertParametersList.add(new Object[] {insertRecord.getTimestamp(),insertRecord.getIp(),insertRecord.getUserID(),insertRecord.getAdID(),insertRecord.getProvince(),insertRecord.getCity(),insertRecord.getClickedCount()});}jdbcWrapper.doBatch("INSERT INTO adclicked VALUES(?, ?, ?, ?, ?, ?, ?)", insertParametersList);//表的字段timestamp、ip、userID、adID、province、city、clickedCountList<Object[]> updateParametersList = new ArrayList<Object[]>();for(UserAdClicked updateRecord : updating) {updateParametersList.add(new Object[] {updateRecord.getTimestamp(),updateRecord.getIp(),updateRecord.getUserID(),updateRecord.getAdID(),updateRecord.getProvince(),updateRecord.getCity(),updateRecord.getClickedCount() + 1});}jdbcWrapper.doBatch("UPDATE adclicked SET clickedCount = ? WHERE"+ " timestamp =? AND ip = ? AND userID = ? AND adID = ? "+ "AND province = ? AND city = ?", updateParametersList);} });return null;} });//再次过滤，从数据库中读取数据过滤黑名单JavaPairDStream<String, Long> blackListBasedOnHistory = filterClickedBatch.filter(new Function<Tuple2<String,Long>, Boolean>() {public Boolean call(Tuple2<String, Long> v1) throws Exception {//广告点击的基本数据格式：timestamp,ip,userID,adID,province,cityString[] splited = v1._1.split("\t"); //提取key值String date =splited[0];String userID =splited[2];String adID =splited[3];//查询一下数据库同一个用户同一个广告id点击量超过50次列入黑名单//接下来 根据date、userID、adID条件去查询用户点击广告的数据表，获得总的点击次数//这个时候基于点击次数判断是否属于黑名单点击int clickedCountTotalToday = 81 ;if (clickedCountTotalToday > 50) {return true;}else {return false ;} }});//map操作，找出用户的idJavaDStream<String> blackListuserIDBasedInBatchOnhistroy =blackListBasedOnHistory.map(new Function<Tuple2<String,Long>, String>() {public String call(Tuple2<String, Long> v1) throws Exception {// TODO Auto-generated method stubreturn v1._1.split("\t")[2];} });//有一个问题，数据可能重复，在一个partition里面重复，这个好办；//但多个partition不能保证一个用户重复，需要对黑名单的整个rdd进行去重操作。//rdd去重了，partition也就去重了，一石二鸟，一箭双雕// 找出了黑名单，下一步就写入黑名单数据库表中JavaDStream<String> blackListUniqueuserBasedInBatchOnhistroy = blackListuserIDBasedInBatchOnhistroy.transform(new Function<JavaRDD<String>, JavaRDD<String>>() {public JavaRDD<String> call(JavaRDD<String> rdd) throws Exception {// TODO Auto-generated method stubreturn rdd.distinct();} });// 下一步写入到数据表中blackListUniqueuserBasedInBatchOnhistroy.foreachRDD(new Function<JavaRDD<String>, Void>() {public Void call(JavaRDD<String> rdd) throws Exception {rdd.foreachPartition(new VoidFunction<Iterator<String>>() {public void call(Iterator<String> t) throws Exception {// TODO Auto-generated method stub//插入的用户信息可以只包含：useID//此时直接插入黑名单数据表即可。//写入数据库List<Object[]> blackList = new ArrayList<Object[]>();while(t.hasNext()) {blackList.add(new Object[]{t.next()});}JDBCWrapper jdbcWrapper = JDBCWrapper.getJDBCInstance();jdbcWrapper.doBatch("INSERT INTO blacklisttable values (?)", blackList);} });return null;} });/广告点击累计动态更新,每个updateStateByKey都会在Batch Duration的时间间隔的基础上进行广告点击次数的更新， 更新之后我们一般都会持久化到外部存储设备上，在这里我们存储到MySQL数据库中/JavaPairDStream<String, Long> updateStateByKeyDSteam = filteredadClickedStreaming.mapToPair(new PairFunction<Tuple2<String,String>, String, Long>() {public Tuple2<String, Long> call(Tuple2<String, String> t)throws Exception {String[] splited=t._2.split("\t");String timestamp = splited[0]; //YYYY-MM-DDString ip = splited[1];String userID = splited[2];String adID = splited[3];String province = splited[4];String city = splited[5]; String clickedRecord = timestamp + "_" +ip + "_"+userID+"_"+adID+"_"+province +"_"+city;return new Tuple2<String, Long>(clickedRecord, 1L);} }).updateStateByKey(new Function2<List<Long>, Optional<Long>, Optional<Long>>() {public Optional<Long> call(List<Long> v1, Optional<Long> v2)throws Exception {// v1:当前的Key在当前的Batch Duration中出现的次数的集合，例如{1，1，1，。。。，1}// v2:当前的Key在以前的Batch Duration中积累下来的结果；Long clickedTotalHistory = 0L; if(v2.isPresent()){clickedTotalHistory = v2.get();}for(Long one : v1) {clickedTotalHistory += one;}return Optional.of(clickedTotalHistory);} });updateStateByKeyDSteam.foreachRDD(new Function<JavaPairRDD<String,Long>, Void>() {public Void call(JavaPairRDD<String, Long> rdd) throws Exception {rdd.foreachPartition(new VoidFunction<Iterator<Tuple2<String,Long>>>() {public void call(Iterator<Tuple2<String, Long>> partition) throws Exception {//使用数据库连接池的高效读写数据库的方式将数据写入数据库mysql//例如一次插入 1000条 records，使用insertBatch 或 updateBatch//插入的用户数据信息：timestamp、adID、province、city//这里面有一个问题，可能出现两条记录的key是一样的，此时需要更新累加操作List<AdClicked> AdClickedList = new ArrayList<AdClicked>();while(partition.hasNext()) {Tuple2<String, Long> record = partition.next();String[] splited = record._1.split("\t");AdClicked adClicked = new AdClicked();adClicked.setTimestamp(splited[0]);adClicked.setAdID(splited[1]);adClicked.setProvince(splited[2]);adClicked.setCity(splited[3]);adClicked.setClickedCount(record._2);AdClickedList.add(adClicked);}final List<AdClicked> inserting = new ArrayList<AdClicked>();final List<AdClicked> updating = new ArrayList<AdClicked>();JDBCWrapper jdbcWrapper = JDBCWrapper.getJDBCInstance();//表的字段timestamp、ip、userID、adID、province、city、clickedCountfor(final AdClicked clicked : AdClickedList) {jdbcWrapper.doQuery("SELECT clickedCount FROM adclickedcount WHERE"+ " timestamp = ? AND adID = ? AND province = ? AND city = ?",new Object[]{clicked.getTimestamp(), clicked.getAdID(),clicked.getProvince(), clicked.getCity()}, new ExecuteCallBack() {public void resultCallBack(ResultSet result) throws Exception {// TODO Auto-generated method stubif(result.next()) {long count = result.getLong(1);clicked.setClickedCount(count);updating.add(clicked);} else {inserting.add(clicked);clicked.setClickedCount(1L);} }});}//表的字段timestamp、ip、userID、adID、province、city、clickedCountList<Object[]> insertParametersList = new ArrayList<Object[]>();for(AdClicked insertRecord : inserting) {insertParametersList.add(new Object[] {insertRecord.getTimestamp(),insertRecord.getAdID(),insertRecord.getProvince(),insertRecord.getCity(),insertRecord.getClickedCount()});}jdbcWrapper.doBatch("INSERT INTO adclickedcount VALUES(?, ?, ?, ?, ?)", insertParametersList);//表的字段timestamp、ip、userID、adID、province、city、clickedCountList<Object[]> updateParametersList = new ArrayList<Object[]>();for(AdClicked updateRecord : updating) {updateParametersList.add(new Object[] {updateRecord.getClickedCount(),updateRecord.getTimestamp(),updateRecord.getAdID(),updateRecord.getProvince(),updateRecord.getCity()});}jdbcWrapper.doBatch("UPDATE adclickedcount SET clickedCount = ? WHERE"+ " timestamp =? AND adID = ? AND province = ? AND city = ?", updateParametersList);} });return null;} });/ 对广告点击进行TopN计算，计算出每天每个省份Top5排名的广告 因为我们直接对RDD进行操作，所以使用了transfomr算子；/updateStateByKeyDSteam.transform(new Function<JavaPairRDD<String,Long>, JavaRDD<Row>>() {public JavaRDD<Row> call(JavaPairRDD<String, Long> rdd) throws Exception {JavaRDD<Row> rowRDD = rdd.mapToPair(new PairFunction<Tuple2<String,Long>, String, Long>() {public Tuple2<String, Long> call(Tuple2<String, Long> t)throws Exception {// TODO Auto-generated method stubString[] splited=t._1.split("_");String timestamp = splited[0]; //YYYY-MM-DDString adID = splited[3];String province = splited[4];String clickedRecord = timestamp + "_" + adID + "_" + province;return new Tuple2<String, Long>(clickedRecord, t._2);} }).reduceByKey(new Function2<Long, Long, Long>() {public Long call(Long v1, Long v2) throws Exception {// TODO Auto-generated method stubreturn v1 + v2;} }).map(new Function<Tuple2<String,Long>, Row>() {public Row call(Tuple2<String, Long> v1) throws Exception {// TODO Auto-generated method stubString[] splited=v1._1.split("_");String timestamp = splited[0]; //YYYY-MM-DDString adID = splited[3];String province = splited[4];return RowFactory.create(timestamp, adID, province, v1._2);} });StructType structType = DataTypes.createStructType(Arrays.asList(DataTypes.createStructField("timestamp", DataTypes.StringType, true),DataTypes.createStructField("adID", DataTypes.StringType, true),DataTypes.createStructField("province", DataTypes.StringType, true),DataTypes.createStructField("clickedCount", DataTypes.LongType, true)));HiveContext hiveContext = new HiveContext(rdd.context());DataFrame df = hiveContext.createDataFrame(rowRDD, structType);df.registerTempTable("topNTableSource");DataFrame result = hiveContext.sql("SELECT timestamp, adID, province, clickedCount, FROM"+ " (SELECT timestamp, adID, province,clickedCount, "+ "ROW_NUMBER() OVER(PARTITION BY province ORDER BY clickeCount DESC) rank "+ "FROM topNTableSource) subquery "+ "WHERE rank <= 5");return result.toJavaRDD();} }).foreachRDD(new Function<JavaRDD<Row>, Void>() {public Void call(JavaRDD<Row> rdd) throws Exception {// TODO Auto-generated method stubrdd.foreachPartition(new VoidFunction<Iterator<Row>>() {public void call(Iterator<Row> t) throws Exception {// TODO Auto-generated method stubList<AdProvinceTopN> adProvinceTopN = new ArrayList<AdProvinceTopN>();while(t.hasNext()) {Row row = t.next();AdProvinceTopN item = new AdProvinceTopN();item.setTimestamp(row.getString(0));item.setAdID(row.getString(1));item.setProvince(row.getString(2));item.setClickedCount(row.getLong(3));adProvinceTopN.add(item);}// final List<AdProvinceTopN> inserting = new ArrayList<AdProvinceTopN>();// final List<AdProvinceTopN> updating = new ArrayList<AdProvinceTopN>();JDBCWrapper jdbcWrapper = JDBCWrapper.getJDBCInstance();Set<String> set = new HashSet<String>();for(AdProvinceTopN item: adProvinceTopN){set.add(item.getTimestamp() + "_" + item.getProvince());}//表的字段timestamp、adID、province、clickedCountArrayList<Object[]> deleteParametersList = new ArrayList<Object[]>();for(String deleteRecord : set) {String[] splited = deleteRecord.split("_");deleteParametersList.add(new Object[]{splited[0],splited[1]});}jdbcWrapper.doBatch("DELETE FROM adprovincetopn WHERE timestamp = ? AND province = ?", deleteParametersList);//表的字段timestamp、ip、userID、adID、province、city、clickedCountList<Object[]> insertParametersList = new ArrayList<Object[]>();for(AdProvinceTopN insertRecord : adProvinceTopN) {insertParametersList.add(new Object[] {insertRecord.getClickedCount(),insertRecord.getTimestamp(),insertRecord.getAdID(),insertRecord.getProvince()});}jdbcWrapper.doBatch("INSERT INTO adprovincetopn VALUES (?, ?, ?, ?)", insertParametersList);} });return null;} });/ 计算过去半个小时内广告点击的趋势 广告点击的基本数据格式：timestamp、ip、userID、adID、province、city/filteredadClickedStreaming.mapToPair(new PairFunction<Tuple2<String,String>, String, Long>() {public Tuple2<String, Long> call(Tuple2<String, String> t)throws Exception {String splited[] = t._2.split("\t");String adID = splited[3];String time = splited[0]; //Todo:后续需要重构代码实现时间戳和分钟的转换提取。此处需要提取出该广告的点击分钟单位return new Tuple2<String, Long>(time + "_" + adID, 1L);} }).reduceByKeyAndWindow(new Function2<Long, Long, Long>() {public Long call(Long v1, Long v2) throws Exception {// TODO Auto-generated method stubreturn v1 + v2;} }, new Function2<Long, Long, Long>() {public Long call(Long v1, Long v2) throws Exception {// TODO Auto-generated method stubreturn v1 - v2;} }, Durations.minutes(30), Durations.milliseconds(5)).foreachRDD(new Function<JavaPairRDD<String,Long>, Void>() {public Void call(JavaPairRDD<String, Long> rdd) throws Exception {// TODO Auto-generated method stubrdd.foreachPartition(new VoidFunction<Iterator<Tuple2<String,Long>>>() {public void call(Iterator<Tuple2<String, Long>> partition)throws Exception {List<AdTrendStat> adTrend = new ArrayList<AdTrendStat>();// TODO Auto-generated method stubwhile(partition.hasNext()) {Tuple2<String, Long> record = partition.next();String[] splited = record._1.split("_");String time = splited[0];String adID = splited[1];Long clickedCount = record._2;/ 在插入数据到数据库的时候具体需要哪些字段？time、adID、clickedCount; 而我们通过J2EE技术进行趋势绘图的时候肯定是需要年、月、日、时、分这个维度的，所以我们在这里需要 年月日、小时、分钟这些时间维度；/AdTrendStat adTrendStat = new AdTrendStat();adTrendStat.setAdID(adID);adTrendStat.setClickedCount(clickedCount);adTrendStat.set_date(time); //Todo:获取年月日adTrendStat.set_hour(time); //Todo:获取小时adTrendStat.set_minute(time);//Todo:获取分钟adTrend.add(adTrendStat);}final List<AdTrendStat> inserting = new ArrayList<AdTrendStat>();final List<AdTrendStat> updating = new ArrayList<AdTrendStat>();JDBCWrapper jdbcWrapper = JDBCWrapper.getJDBCInstance();//表的字段timestamp、ip、userID、adID、province、city、clickedCountfor(final AdTrendStat trend : adTrend) {final AdTrendCountHistory adTrendhistory = new AdTrendCountHistory();jdbcWrapper.doQuery("SELECT clickedCount FROM adclickedtrend WHERE"+ " date =? AND hour = ? AND minute = ? AND AdID = ?",new Object[]{trend.get_date(), trend.get_hour(), trend.get_minute(),trend.getAdID()}, new ExecuteCallBack() {public void resultCallBack(ResultSet result) throws Exception {// TODO Auto-generated method stubif(result.next()) {long count = result.getLong(1);adTrendhistory.setClickedCountHistoryLong(count);updating.add(trend);} else { inserting.add(trend);} }});}//表的字段date、hour、minute、adID、clickedCountList<Object[]> insertParametersList = new ArrayList<Object[]>();for(AdTrendStat insertRecord : inserting) {insertParametersList.add(new Object[] {insertRecord.get_date(),insertRecord.get_hour(),insertRecord.get_minute(),insertRecord.getAdID(),insertRecord.getClickedCount()});}jdbcWrapper.doBatch("INSERT INTO adclickedtrend VALUES(?, ?, ?, ?, ?)", insertParametersList);//表的字段date、hour、minute、adID、clickedCountList<Object[]> updateParametersList = new ArrayList<Object[]>();for(AdTrendStat updateRecord : updating) {updateParametersList.add(new Object[] {updateRecord.getClickedCount(),updateRecord.get_date(),updateRecord.get_hour(),updateRecord.get_minute(),updateRecord.getAdID()});}jdbcWrapper.doBatch("UPDATE adclickedtrend SET clickedCount = ? WHERE"+ " date =? AND hour = ? AND minute = ? AND AdID = ?", updateParametersList);} });return null;} });;/ Spark Streaming 执行引擎也就是Driver开始运行，Driver启动的时候是位于一条新的线程中的，当然其内部有消息循环体，用于 接收应用程序本身或者Executor中的消息，/javassc.start();javassc.awaitTermination();javassc.close();}private static JavaStreamingContext createContext(String checkpointDirectory, SparkConf conf) {// If you do not see this printed, that means the StreamingContext has been loaded// from the new checkpointSystem.out.println("Creating new context");// Create the context with a 5 second batch sizeJavaStreamingContext ssc = new JavaStreamingContext(conf, Durations.seconds(10));ssc.checkpoint(checkpointDirectory);return ssc;} }class JDBCWrapper {private static JDBCWrapper jdbcInstance = null;private static LinkedBlockingQueue<Connection> dbConnectionPool = new LinkedBlockingQueue<Connection>();static {try {Class.forName("com.mysql.jdbc.Driver");} catch (ClassNotFoundException e) {// TODO Auto-generated catch blocke.printStackTrace();} }public static JDBCWrapper getJDBCInstance() {if(jdbcInstance == null) {synchronized (JDBCWrapper.class) {if(jdbcInstance == null) {jdbcInstance = new JDBCWrapper();} }}return jdbcInstance; }private JDBCWrapper() {for(int i = 0; i < 10; i++){try {Connection conn = DriverManager.getConnection("jdbc:mysql://Master:3306/sparkstreaming","root", "root");dbConnectionPool.put(conn);} catch (Exception e) {// TODO Auto-generated catch blocke.printStackTrace();} } }public synchronized Connection getConnection() {while(0 == dbConnectionPool.size()){try {Thread.sleep(20);} catch (InterruptedException e) {// TODO Auto-generated catch blocke.printStackTrace();} }return dbConnectionPool.poll();}public int[] doBatch(String sqlText, List<Object[]> paramsList){Connection conn = getConnection();PreparedStatement preparedStatement = null;int[] result = null;try {conn.setAutoCommit(false);preparedStatement = conn.prepareStatement(sqlText);for(Object[] parameters: paramsList) {for(int i = 0; i < parameters.length; i++){preparedStatement.setObject(i + 1, parameters[i]);} preparedStatement.addBatch();}result = preparedStatement.executeBatch();conn.commit();} catch (SQLException e) {// TODO Auto-generated catch blocke.printStackTrace();} finally {if(preparedStatement != null) {try {preparedStatement.close();} catch (SQLException e) {// TODO Auto-generated catch blocke.printStackTrace();} }if(conn != null) {try {dbConnectionPool.put(conn);} catch (InterruptedException e) {// TODO Auto-generated catch blocke.printStackTrace();} }}return result; }public void doQuery(String sqlText, Object[] paramsList, ExecuteCallBack callback){Connection conn = getConnection();PreparedStatement preparedStatement = null;ResultSet result = null;try {preparedStatement = conn.prepareStatement(sqlText);for(int i = 0; i < paramsList.length; i++){preparedStatement.setObject(i + 1, paramsList[i]);} result = preparedStatement.executeQuery();try {callback.resultCallBack(result);} catch (Exception e) {// TODO Auto-generated catch blocke.printStackTrace();} } catch (SQLException e) {// TODO Auto-generated catch blocke.printStackTrace();} finally {if(preparedStatement != null) {try {preparedStatement.close();} catch (SQLException e) {// TODO Auto-generated catch blocke.printStackTrace();} }if(conn != null) {try {dbConnectionPool.put(conn);} catch (InterruptedException e) {// TODO Auto-generated catch blocke.printStackTrace();} }} }}interface ExecuteCallBack {void resultCallBack(ResultSet result) throws Exception;}class UserAdClicked {private String timestamp;private String ip;private String userID;private String adID;private String province;private String city;private Long clickedCount;public String getTimestamp() {return timestamp;}public void setTimestamp(String timestamp) {this.timestamp = timestamp;}public String getIp() {return ip;}public void setIp(String ip) {this.ip = ip;}public String getUserID() {return userID;}public void setUserID(String userID) {this.userID = userID;}public String getAdID() {return adID;}public void setAdID(String adID) {this.adID = adID;}public String getProvince() {return province;}public void setProvince(String province) {this.province = province;}public String getCity() {return city;}public void setCity(String city) {this.city = city;}public Long getClickedCount() {return clickedCount;}public void setClickedCount(Long clickedCount) {this.clickedCount = clickedCount;} }class AdClicked {private String timestamp;private String adID;private String province;private String city;private Long clickedCount;public String getTimestamp() {return timestamp;}public void setTimestamp(String timestamp) {this.timestamp = timestamp;}public String getAdID() {return adID;}public void setAdID(String adID) {this.adID = adID;}public String getProvince() {return province;}public void setProvince(String province) {this.province = province;}public String getCity() {return city;}public void setCity(String city) {this.city = city;}public Long getClickedCount() {return clickedCount;}public void setClickedCount(Long clickedCount) {this.clickedCount = clickedCount;} }class AdProvinceTopN {private String timestamp;private String adID;private String province;private Long clickedCount;public String getTimestamp() {return timestamp;}public void setTimestamp(String timestamp) {this.timestamp = timestamp;}public String getAdID() {return adID;}public void setAdID(String adID) {this.adID = adID;}public String getProvince() {return province;}public void setProvince(String province) {this.province = province;}public Long getClickedCount() {return clickedCount;}public void setClickedCount(Long clickedCount) {this.clickedCount = clickedCount;} }class AdTrendStat {private String _date;private String _hour;private String _minute;private String adID;private Long clickedCount;public String get_date() {return _date;}public void set_date(String _date) {this._date = _date;}public String get_hour() {return _hour;}public void set_hour(String _hour) {this._hour = _hour;}public String get_minute() {return _minute;}public void set_minute(String _minute) {this._minute = _minute;}public String getAdID() {return adID;}public void setAdID(String adID) {this.adID = adID;}public Long getClickedCount() {return clickedCount;}public void setClickedCount(Long clickedCount) {this.clickedCount = clickedCount;} }class AdTrendCountHistory{private Long clickedCountHistoryLong;public Long getClickedCountHistoryLong() {return clickedCountHistoryLong;}public void setClickedCountHistoryLong(Long clickedCountHistoryLong) {this.clickedCountHistoryLong = clickedCountHistoryLong;} } 本篇文章为转载内容。原文链接：https://blog.csdn.net/tom_8899_li/article/details/71194434。 该文由互联网用户投稿提供，文中观点代表作者本人意见，并不代表本站的立场。 作为信息平台，本站仅提供文章转载服务，并不拥有其所有权，也不对文章内容的真实性、准确性和合法性承担责任。 如发现本文存在侵权、违法、违规或事实不符的情况，请及时联系我们，我们将第一时间进行核实并删除相应内容。

...的HTML网页模板，设计旨在激励用户邀请更多好友加入并分享页面内容。模板以醒目的红色为主色调，内置便捷的邀请功能和分享按钮，鼓励用户邀请好友参与，同时设有奖励机制，吸引更多新用户。通过此模板，用户可以直观查看邀请进度与奖励详情，并能方便地邀请更多好友，实现社交传播与用户增长的双重效果。 点我下载 文件大小：607.44 KB 您将下载一个资源包，该资源包内部文件的目录结构如下： 本网站提供模板下载功能，旨在帮助广大用户在工作学习中提升效率、节约时间。 本网站的下载内容来自于互联网。如您发现任何侵犯您权益的内容，请立即告知我们，我们将迅速响应并删除相关内容。 免责声明：站内所有资源仅供个人学习研究及参考之用，严禁将这些资源应用于商业场景。 若擅自商用导致的一切后果，由使用者承担责任。

...一款专为汽车服务企业设计的HTML5自适应模板，适用于汽车修理、保养、配件销售及改装行业。该模板凭借其响应式设计能完美匹配多种终端设备，实现“一次构建，全设备适用”。页面布局清晰专业，凸显汽车维修保养业务特色，内含丰富模块展示汽车配件与改装服务，且已集成SEO优化机制，助力企业在搜索引擎中获得更高排名，是打造汽车行业专业级线上形象的理想之选。 点我下载 文件大小：1.67 MB 您将下载一个资源包，该资源包内部文件的目录结构如下： 本网站提供模板下载功能，旨在帮助广大用户在工作学习中提升效率、节约时间。 本网站的下载内容来自于互联网。如您发现任何侵犯您权益的内容，请立即告知我们，我们将迅速响应并删除相关内容。 免责声明：站内所有资源仅供个人学习研究及参考之用，严禁将这些资源应用于商业场景。 若擅自商用导致的一切后果，由使用者承担责任。