[Java集合框架中的迭代器模式实现]的搜索结果

Font类 , 在Java的图形用户界面编程中，Font类是用于描述字体信息的核心类，它封装了字体的名称、样式（如正常、加粗、斜体等）和大小等属性。在文章的上下文中，通过创建一个Font对象，并设置其属性，可以实现对窗口标题字体样式的自定义。 JFrame , JFrame是javax.swing包中的一个类，它是Java Swing GUI框架中构建窗口的主要容器组件。程序员通常会继承或实例化JFrame以创建具有特定功能的应用程序窗口，其中包括设置窗口标题、大小、位置、关闭操作等属性。在本文中，JFrame对象被用来设置其标题栏的字体样式。 setVisible(true) , 这是Java Swing API中用于控制组件可见性的一个方法，应用于JFrame或其他任何组件时，调用setVisible(true)会使该组件在屏幕上显示出来。在文章示例代码中，当窗口标题字体设置完毕后，通过frame.setVisible(true)，确保设置了新字体的窗口会被正确地显示给用户。

在Java多线程编程中，p和v操作作为信号量机制的核心组成部分，为开发者提供了有效的同步手段。然而，随着并发编程复杂度的提升以及对性能要求的日益严格，现代Java库引入了更高级的并发工具类，如java.util.concurrent Semaphore类。该类是对传统信号量概念的增强实现，不仅支持计数信号量，还提供公平性选项，确保线程按照等待时间顺序获取许可。 近期，一篇发布于InfoQ的技术文章《深入剖析Java并发之Semaphore源码与实战》（链接需替换为实际链接）就对此进行了详细的解读。文中作者不仅深入剖析了JDK中Semaphore类的设计原理与源码实现，还结合实例探讨了如何在生产者消费者、数据库连接池等常见场景中合理运用Semaphore进行线程同步控制，从而避免死锁并优化系统性能。 此外，对于更复杂的同步问题，读者还可以进一步了解和研究其他Java并发工具类，例如ReentrantLock、CountDownLatch、CyclicBarrier等。这些工具通过灵活的设计和API，能够更好地适应不同场景下的同步需求，并帮助开发者编写出更加健壮、高效的多线程程序。 同时，值得注意的是，虽然诸如Semaphore这样的工具能有效解决同步问题，但过度依赖或不恰当使用也可能导致新的问题产生。因此，在实际开发过程中，理解并发编程的本质，遵循“最小权限原则”来设计线程间的交互，始终是提高程序并发能力的关键所在。在最新的Java版本更新中，也不断有针对并发特性的改进和完善，持续关注并跟进学习最新技术动态，将有助于开发者更好地应对高并发环境下的挑战。

在深入理解Java中使用wait和notify实现线程同步的银行账户模型后，我们可以进一步探讨现代并发编程中的其他高级同步机制及其在实际场景中的应用。例如，Java 5引入了java.util.concurrent包，其中提供了多种高效的并发工具类，如Semaphore（信号量）、ReentrantLock（可重入锁）以及BlockingQueue（阻塞队列），它们为复杂多线程环境下的资源控制提供了更强大的支持。 具体来说，在银行账户模型中，如果考虑更多的并发操作，如转账交易，那么显式锁（如ReentrantLock）可以提供更细粒度的控制，允许公平锁、非公平锁的选择，并且具备tryLock等灵活方法，以增强系统的响应能力和处理能力。另外，通过结合使用BlockingQueue，可以构建出生产者消费者模式，有效解决线程间数据交换的问题，确保存款请求与取款请求按照先进先出（FIFO）或其他策略有序进行处理。 同时，随着JDK版本的更新，Java内存模型（JMM）的完善以及对原子变量类（AtomicInteger、AtomicLong等）的支持，使得我们能够更好地理解和利用这些底层机制优化并行计算性能，降低死锁概率，提高系统整体并发效率。 此外，对于分布式系统中的银行账户模型，还可以研究分布式锁服务（如Redis或ZooKeeper提供的分布式锁机制），以应对集群环境下多个节点间的并发控制挑战，确保全局一致性。 综上所述，尽管基于wait和notify的经典线程同步方式在特定场合下依然适用，但不断发展的Java并发库为我们提供了更多与时俱进、更为高效且功能丰富的工具，帮助开发者构建更为稳健且高性能的并发程序。

...源的分布式计算和存储框架，由 Apache 基金会开发和维护。Hadoop这哥们儿，可厉害了！它就像是个超级管家，专门为那些超大规模的计算机团队打造了一个既靠谱又灵活的分布式文件系统——HDFS。不仅如此，它还拥有强大的并行运算能力，能轻松处理海量数据，就像一台高效的超级计算机引擎，让数据处理变得so easy！这篇文章将为你介绍如何启动和停止Hadoop集群。 二、启动Hadoop集群 启动Hadoop集群需要以下几步： 1. 在所有节点上安装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日志监控等。希望这篇文章能对你有所帮助！

...B , JACOB（Java COM Bridge）是一个开源的Java-COM桥接库，允许Java程序调用COM组件和DLL文件。在本文的上下文中，开发者使用JACOB来实现Java应用程序与中控考勤机SDK（基于COM接口）之间的交互，从而实现在Java环境下操作和控制考勤机设备。 ActiveXComponent , ActiveX是Microsoft为Internet和Windows平台开发的一种软件技术标准，而ActiveXComponent则是Java通过JACOB访问ActiveX控件或COM对象的类。在本文中，通过实例化ActiveXComponent并指定“zkemkeeper.ZKEM.1”，开发者能够创建一个与中控考勤机SDK交互的Java对象，进而执行诸如连接、断开考勤机等操作。 SDK（Software Development Kit） , SDK是一套软件开发工具包，通常包含了开发某一特定软件产品所需的所有文档、示例代码、库文件、API接口说明以及其他辅助工具。在本文语境下，中控考勤机SDK是指由中控公司提供的用于开发与中控考勤机硬件设备进行通信和数据交互的应用程序所需的工具集合，它提供了如连接考勤机、读取考勤记录等功能的接口。 DLL（Dynamic Link Library） , 动态链接库是一种微软Windows操作系统中的文件类型，包含可以被多个程序同时使用的函数和资源。在文章中提到的jacob-1.19-x64.dll和zkemkeeper.dll都是DLL文件，其中jacob-1.19-x64.dll是JACOB为了支持64位JDK环境下的COM调用所必需的，而zkemkeeper.dll则是中控考勤机SDK的核心文件，通过注册这个DLL，Java应用才能成功调用到考勤机的接口功能。

...vy注解处理器是基于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注解处理器来对付它，没准儿能给你整出个意料之外、惊喜连连的解决方案！

...们可以编写一段简单的Java代码进行测试： java import org.apache.activemq.ActiveMQConnectionFactory; import javax.jms.Connection; import javax.jms.Destination; import javax.jms.JMSException; import javax.jms.MessageProducer; import javax.jms.Session; import java.util.concurrent.CountDownLatch; public class UnsubscribeTest { private static final String QUEUE_NAME = "queue1"; public static void main(String[] args) throws JMSException, InterruptedException { ActiveMQConnectionFactory connectionFactory = new ActiveMQConnectionFactory("tcp://localhost:61616"); Connection connection = connectionFactory.createConnection(); connection.start(); Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE); Destination destination = session.createQueue(QUEUE_NAME); MessageProducer producer = session.createProducer(destination); CountDownLatch latch = new CountDownLatch(1); Thread thread = new Thread(() -> { try { latch.await(); producer.send(session.createTextMessage("Hello World")); } catch (JMSException e) { e.printStackTrace(); } }); thread.start(); // Wait for the message to be produced and sent latch.countDown(); // Now unsubscribe the queue session.unsubscribe(QUEUE_NAME); // Try to send a message to the queue again producer.send(session.createTextMessage("Hello World")); // Close the resources session.close(); connection.close(); } } 在这个例子中，我们首先创建了一个到ActiveMQ服务器的连接，并创建了一个到名为"queue1"的消息队列的Session。然后，我们创建了一个消息生产者，并发送了一条消息到该队列。然后呢，我们就在另一个小线程里头耐心等待，等到第一条消息妥妥地送出去了，立马就取消了对那个叫“queue1”的消息队列的关注。接下来，咱们又试着给它发了一条新消息。最后，我们关闭了所有的资源。 四、解决办法 那么，如何避免这种"UnsubscribedException"呢？主要有以下几种方法： 1. 使用事务 我们可以将发送消息和取消订阅操作放在一个事务中，这样如果在执行过程中发生任何错误，都可以回滚事务，从而保证数据的一致性。 2. 重试机制 如果我们知道应用程序会在一段时间后重新启动，那么我们可以使用一个简单的重试机制来发送消息。例如，我们可以设置一个计数器，在每次发送失败后递增，直到达到某个阈值（如3次）为止。 五、结论 总的来说，"UnsubscribedException"是一个我们在使用ActiveMQ时可能遇到的问题。了解透彻并跟ActiveMQ的运行机制打成一片后，咱们就能挖出真正管用的解决方案，保证咱的应用程序稳稳当当地跑起来。同时呢，咱们也得明白，在真实的开发过程里头，咱们可不能停下学习和探索的脚步。为啥呢？因为这样才能够更好地对付那些时不时冒出来的挑战和问题嘛，让咱变得更游刃有余。

...性能、通用的并行计算框架，凭借其对大规模数据处理的强大支持和优异性能赢得了广泛的赞誉。在实际操作Spark的过程中，咱们可能会碰上个让人头疼的问题。啥问题呢？就是由于关键的依赖库缺失了，导致Spark这个家伙没法正常启动或者执行任务，这确实挺让人挠头的。本文将深入探讨这一问题，并通过实例代码揭示它的重要性。 1. Spark与依赖库的关系 (1) 依赖库的重要性 在Spark的工作机制中，它自身提供了一系列核心功能库，如spark-core负责基本的分布式任务调度，spark-sql实现SQL查询等。为了应对各种业务需求，Spark往往需要和其他好伙伴——第三方库一起携手工作。比如，如果你想和数据库打交道，就可能得请出JDBC驱动这位“翻译官”。再比如，当你需要进行机器学习这类高大上的任务时，MLlib或者其他的深度学习库就成了你必不可少的得力助手啦。这些“依赖库”，你就想象成是Spark引擎运行必需的“小帮手”或者说是“关键零部件”。没有它们，就好比一辆汽车缺了心脏般的重要零件，哪怕引擎再猛如虎，也只能干瞪眼没法跑起来。 (2) 依赖传递性 在构建Spark应用时，我们需要通过构建工具（如Maven、Sbt）明确指定项目的依赖关系。这里说的依赖，可不是仅仅局限在Spark自己的核心组件里，还包括咱们应用“嗷嗷待哺”的其他第三方库。这些库之间，就好比是一群互相帮忙的朋友，关系错综复杂。如果其中任何一个朋友缺席了，那整个团队的工作可能就要乱套，咱们的应用也就没法正常运转啦。 2. 缺少依赖库引发的问题实例 假设我们要用Spark读取MySQL数据库中的数据，首先需要引入JDBC驱动依赖： scala // 在build.sbt文件中添加依赖 libraryDependencies += "mysql" % "mysql-connector-java" % "8.0.23" // 或在pom.xml文件中添加依赖 mysql mysql-connector-java 8.0.23 然后在代码中尝试连接MySQL： scala import org.apache.spark.sql.SparkSession val spark = SparkSession.builder.appName("mysqlExample").getOrCreate() val jdbcDF = spark.read.format("jdbc") .option("url", "jdbc:mysql://localhost:3306/mydatabase") .option("driver", "com.mysql.jdbc.Driver") .option("dbtable", "mytable") .load() jdbcDF.show() 如果此时没有正确引入并配置MySQL JDBC驱动，上述代码在运行时就会抛出类似于NoClassDefFoundError: com/mysql/jdbc/Driver的异常，表明Spark找不到相应的类定义，这就是典型的因缺少依赖库而导致的运行错误。 3. 如何避免和解决依赖库缺失问题 (1) 全面且精确地声明依赖 在项目初始化阶段，务必详细列出所有必需的依赖库及其版本信息，确保它们能在构建过程中被正确下载和打包。 (2) 利用构建工具管理依赖 利用Maven、Gradle或Sbt等构建工具，可以自动解析和管理项目依赖关系，减少手动管理带来的疏漏。 (3) 检查和更新依赖 定期检查和更新项目依赖库，以适应新版本API的变化以及修复潜在的安全漏洞。 (4) 理解依赖传递性 深入理解各个库之间的依赖关系，防止因间接依赖导致的问题。当遇到问题时，可通过查看构建日志或使用mvn dependency:tree命令来排查依赖树结构。 总结来说，依赖库对于Spark这类复杂的应用框架而言至关重要。只有妥善管理和维护好这些“零部件”，才能保证Spark引擎稳定高效地运转。所以，开发者们在尽情享受Spark带来的各种便捷时，也千万不能忽视对依赖库的管理和配置这项重要任务。只有这样，咱们的大数据探索之路才能走得更顺溜，一路绿灯，畅通无阻。

...的客户端库主要支持 Java 和 Go 两种语言。这是因为，在企业级应用开发和系统编程这两大领域里，这两种语言各自扮演着无可替代的主力角色。就像是在各自的舞台上，它们是领衔主演，扛起了大旗。 1.1 Java 客户端库 Java 是一种广泛应用在企业级应用开发中的语言，其丰富的类库和强大的跨平台能力使其成为了 Consul 客户端库的重要选择。现在，官方推出了一个 Consul 客户端库，这家伙可是专门为 Java 7 或更新版本量身打造的。你要是用 Java 写程序，不管是做服务发现还是配置管理，只要有了这个库，一切都变得轻松加愉快，就像给你的应用程序装上了一对顺风耳和千里眼一样方便。 下面是一个简单的示例，展示了如何使用 Java 客户端库来获取 Consul 中的服务列表： java import com.ecwid.consul.v1.ConsulClient; import com.ecwid.consul.v1.kv.model.GetValue; import java.util.List; public class ConsulServiceDiscovery { public static void main(String[] args) { // 初始化 Consul 客户端 ConsulClient consulClient = new ConsulClient("localhost", 8500); // 获取所有可用的服务 List services = consulClient.getKVValue("/services"); for (GetValue service : services) { System.out.println(service.getKey() + ": " + service.getValue()); } } } 1.2 Go 客户端库 Go 是一种新兴的系统编程语言，因其简洁高效的特性受到了广大开发者的喜爱。你知道吗，Consul 的那个 Go 客户端库啊，就是专门用 Go 语言精心设计出来的。这样一来，我们开发者们就能轻轻松松地在自个儿的 Go 程序里头，借用 Consul 这个神器来进行服务发现和配置管理啦，简直就像开挂一样方便！ 下面是一个简单的示例，展示了如何使用 Go 客户端库来获取 Consul 中的服务列表： go package main import ( "fmt" "github.com/hashicorp/consul/api" ) func main() { // 初始化 Consul 客户端 client, err := api.NewClient(api.DefaultConfig()) if err != nil { panic(err) } // 获取所有可用的服务 services, _, err := client.KV().Get("/services", nil) if err != nil { panic(err) } for _, service := range services { fmt.Printf("%s: %s\n", service.Key, service.Value) } } 2. 其他语言的支持情况 除了 Java 和 Go 之外，Consul 还支持其他一些语言的客户端库。例如，Python、Ruby、Node.js 等语言都有对应的 Consul 客户端库。 然而，需要注意的是，虽然这些客户端库都是由社区维护的，但并不保证所有的特性和功能都得到了完全的支持。所以呢，当你准备挑选拿个 Consul 客户端库来用的时候，千万记得要根据实际情况，好好掂量掂量、比对比对，再做决定。 3. 总结 综上所述，Consul 主要支持 Java 和 Go 两种语言的客户端库。虽然市面上还有其他语言版本的客户端库可以选择，不过呢，由于各个语言得到官方和社区支持的程度参差不齐，我建议你在实际用起来的时候，最好优先考虑一下Java和Go这两种语言的库。就像是选餐厅一样，不仅要看菜品丰富，还得看看人气和服务，对吧？这两个家伙就像是“官方认证、群众口碑好”的那两家店，值得你优先考虑。另外，说到挑选哪个语言的客户端库，咱们得结合自己手头的需求和技术装备来一番深思熟虑，做决定的时候可不能含糊。

...些基本的软件支持，如Java、Hadoop、HBase等。我刚开始的时候就因为没有正确安装这些软件而走了不少弯路。比如我以前试过用Java 8跑Kylin，结果发现好多功能都用不了。后来才知道是因为Java版本太低了，怪自己当初没注意。所以在启动之前，记得检查一下你的电脑上是不是已经装了Java 11或者更新的版本，最好是长期支持版（LTS），这样Kylin才能乖乖地跑起来。 java 检查Java版本 java -version 接下来是Hadoop和HBase的安装。如果你用的是Cloudera CDH或者Hortonworks HDP，那安装起来就会轻松不少。但如果你是从源码编译安装，那么可能会遇到更多问题。比如说，我之前碰到过Hadoop配置文件里的一些参数不匹配，结果Kylin就启动不了。要搞定这个问题，关键就是得仔仔细细地检查一下配置文件，确保所有的参数都跟官方文档上说的一模一样。 xml 在hadoop-env.sh中设置JAVA_HOME export JAVA_HOME=/usr/lib/jvm/java-11-openjdk-amd64 3. Kylin配置详解 在完成环境搭建后，我们需要对Kylin进行配置。Kylin的配置主要集中在kylin.properties文件中。这个文件包含了Kylin运行所需的几乎所有参数。我头一回设置的时候，因为对那些参数不太熟悉，结果Kylin愣是没启动起来。后来经过多次尝试和查阅官方文档，我才找到了正确的配置方法。 一个常见的问题是，如何设置Kylin的存储位置。默认情况下，Kylin会将元数据存储在HBase中。不过，如果你想把元数据存在本地的文件系统里，只需要调整一下kylin.metadata.storage这个参数就行啦。这可以显著提高开发阶段的效率，但在生产环境中并不推荐这样做。 properties 设置Kylin元数据存储为本地文件系统 kylin.metadata.storage=fs:/path/to/local/directory 另一个重要的配置是Kylin的Cube构建策略。Cube是Kylin的核心概念之一，它用于加速查询响应时间。不同的Cube构建策略会影响查询性能和存储空间的占用。我曾经因为选择了错误的构建策略而导致Cube构建速度极慢。后来，通过调整kylin.cube.algorithm参数，我成功地优化了Cube构建过程。 properties 设置Cube构建策略为INMEM kylin.cube.algorithm=INMEM 4. Kylin部署与监控 最后，我们来谈谈Kylin的部署与监控。Kylin提供了多种部署方式，包括单节点部署、集群部署等。对于初学者来说，单节点部署可能更易于理解和操作。但是，随着数据量的增长，单节点部署很快就会达到瓶颈。这时，就需要考虑集群部署方案。 在部署过程中，我遇到的一个主要问题是服务之间的依赖关系。Kylin依赖于Hadoop和HBase，如果这些服务没有正确配置，Kylin将无法启动。要搞定这个问题，就得细细排查每个服务的状况，确保它们都乖乖地在运转着。 bash 检查Hadoop服务状态 sudo systemctl status hadoop-hdfs-namenode 部署完成后，监控Kylin的运行状态变得非常重要。Kylin提供了Web界面和日志文件两种方式来进行监控。你可以直接在网页上看到Kylin的各种数据指标，就像看仪表盘一样。至于Kylin的操作记录嘛，就都记在日志文件里头了。我经常使用日志文件来排查问题，因为它能提供更多的上下文信息。 bash 查看Kylin日志文件 tail -f /opt/kylin/logs/kylin.log 结语 通过这次分享，我希望能让大家对Kylin的配置与部署有一个更全面的理解。尽管在过程中会碰到各种难题，但只要咱们保持耐心，不断学习和探索，肯定能找到解决的办法。Kylin 的厉害之处就在于它超级灵活，还能随意扩展，这正是我们在大数据分析里头求之不得的呢。希望你们在使用Kylin的过程中也能感受到这份乐趣！ --- 希望这篇技术文章对你有所帮助！如果你有任何疑问或需要进一步的帮助，请随时联系我。

...还贼简单的分布式计算框架。现如今，越来越多的数据科学家和工程师们发现这家伙好使，都把它当成了心头好，处理数据时的首选法宝。当这两个家伙碰头，那肯定能碰撞出炫酷的火花来。不过，在我们实际做项目整合的时候，Mahout和Spark版本之间的兼容性问题却像个小捣蛋鬼，时不时地就给我们带来些小麻烦。本文将深入探讨这一主题，通过实例代码及详细分析，揭示可能遇到的问题以及应对策略。 2. Mahout与Spark的结合 优势与挑战 2.1 优势 集成Mahout与Spark后，我们可以利用Spark的并行处理能力来大幅提升Mahout算法的执行效率。例如，以下是一段使用Mahout-on-Spark实现协同过滤推荐算法的基础代码示例： scala import org.apache.mahout.sparkbindings._ import org.apache.mahout.math.drm._ val data: RDD[Rating] = ... // 初始化用户-物品评分数据 val drmData = DistributedRowMatrix(data.map(r => (r.user, r.product, r.rating)).map { case (u, i, r) => ((u.toLong, i.toLong), r.toDouble) }, numCols = numProducts) val model = ALS.train(drmData, rank = 10, iterations = 10) 2.2 挑战 然而，看似美好的融合背后，版本兼容性问题如同暗礁般潜藏。你知道吗，Mahout和Spark这两个家伙一直在不停地更新升级自己，就像手机系统一样，隔段时间就蹦出个新版本。这样一来呢，新版的接口或者内部构造可能就会变变样，这就意味着不是所有版本都能无缝衔接、愉快合作的，有时候也得头疼一下兼容性问题。如若不慎选择不匹配的版本组合，可能会出现运行错误、性能低下甚至完全无法运行的情况。 3. 版本冲突实例及其解决之道 3.1 实际案例 假设我们在一个项目中尝试将Mahout 0.13.x与Spark 2.4.x进行集成，可能会遇到如下错误提示（这里仅为示例，并非真实错误信息）： Exception in thread "main" java.lang.NoSuchMethodError: org.apache.spark.rdd.RDD.org$apache$spark$rdd$RDD$$sc()Lorg/apache/spark/SparkContext; 这是因为Mahout 0.13.x对Spark的支持仅到2.3.x版本，对于Spark 2.4.x的部分接口进行了更改，导致调用失败。 3.2 解决策略 面对这类问题，我们需要遵循以下步骤来解决： - 确认兼容性：查阅Mahout官方文档或相关社区资源，明确当前Mahout版本所支持的Spark版本范围。 - 降级或升级：根据兼容性范围，决定是回退Spark版本还是升级Mahout版本以达到兼容。 - 依赖管理：在构建工具如Maven或SBT中，精确指定对应的依赖版本，确保项目中所有组件版本一致。 - 测试验证：完成上述操作后，务必进行全面的功能与性能测试，确保系统在新的版本环境中稳定运行。 4. 结论与思考 尽管Mahout与Spark集成过程中的版本冲突可能会带来一些困扰，但只要我们理解其背后的原理，掌握正确的排查方法，这些问题都是可预见且可控的。所以，在我们实际动手开发的时候，千万要像追星一样紧盯着Mahout和Spark这些技术栈的版本更新，毕竟它们一有动静，可能就会影响到兼容性。要想让Mahout和Spark这对好搭档火力全开，就得提前把这些因素琢磨透彻了。 以上内容仅是一个简要的探讨，实际开发过程中可能还会遇到更多具体问题。记住啊，当咱们碰上那些棘手的技术问题时，千万要稳住心态，有耐心去慢慢摸索，而且得乐在其中，把解决问题的过程当成一场冒险探索。这正是编写代码、开发软件让人欲罢不能的魅力所在！

...巴巴开源的一个高性能Java RPC框架，一直备受青睐。不过嘛，在实际用起来的时候，服务一多啊，咱们就难免要跟分布式追踪系统打交道，各种问题接踵而至。这篇文章主要是想聊聊Dubbo怎么和Zipkin、Jaeger这些分布式追踪系统打交道，以及怎么优化它们的合作。我们会用一些真实的例子来说明，怎样才能更好地应对分布式追踪中遇到的各种问题。 1. 分布式追踪系统的重要性 首先，让我们来谈谈为什么需要分布式追踪系统。想想看，当你得照顾一大堆微服务组成的复杂系统时，每个请求都像是个大冒险，得穿梭在好几个服务之间打交道。在这种情况下，要准确地定位问题所在变得极其困难。而分布式追踪系统就像一双眼睛，能够帮助我们清晰地看到每一次请求的完整路径，包括它经过了哪些服务、耗时多少、是否有错误发生等关键信息。这对于提升系统性能、快速定位故障以及优化用户体验都至关重要。 2. Dubbo集成分布式追踪系统的初步探索 Dubbo本身并不直接支持分布式追踪功能，但可以通过集成第三方工具来实现这一目标。比如说Zipkin吧，这是Twitter推出的一个开源工具，专门用来追踪应用程序在分布式环境中的各种请求路径和数据流动情况。用它就像是给你的系统搭建了一个超级详细的导航地图，让你能一眼看清楚每个请求走过了哪些地方。接下来，我们将通过几个步骤来演示如何在Dubbo项目中集成Zipkin。 2.1 添加依赖 首先，我们需要向项目的pom.xml文件中添加Zipkin客户端的依赖。这步超级重要，因为得靠它让我们的Dubbo服务乖乖地把追踪信息发给Zipkin服务器，不然出了问题我们可找不到北啊。 xml io.zipkin.java zipkin-reporter-brave 2.7.5 2.2 配置Dubbo服务端 然后，在Dubbo服务端配置文件（如application.properties）中加入必要的配置项，让其知道如何连接到Zipkin服务器。 properties dubbo.application.qos-enable=false dubbo.registry.address=multicast://224.5.6.7:1234 指定Zipkin服务器地址 spring.zipkin.base-url=http://localhost:9411/ 使用Brave作为追踪库 brave.sampler.probability=1.0 这里，spring.zipkin.base-url指定了Zipkin服务器的URL，而brave.sampler.probability=1.0则表示所有请求都会被追踪。 2.3 编写服务接口与实现 假设我们有一个简单的服务接口，用于处理用户订单： java public interface OrderService { String placeOrder(String userId); } 服务实现类如下： java @Service("orderService") public class OrderServiceImpl implements OrderService { @Override public String placeOrder(String userId) { // 模拟业务逻辑 System.out.println("Order placed for user: " + userId); return "Your order has been successfully placed!"; } } 2.4 启动服务并测试 完成上述配置后，启动Dubbo服务端。你可以试试调用placeOrder这个方法，然后看看在Zipkin的界面上有没有出现相应的追踪记录。 3. 深入探讨 从Dubbo到Jaeger的转变 虽然Zipkin是一个优秀的解决方案，但在某些场景下，你可能会发现它无法满足你的需求。例如，如果你需要更高级别的数据采样策略或是对追踪数据有更高的控制权。这时，Jaeger就成为一个不错的选择。Jaeger是Uber开源的分布式追踪系统，它提供了更多的定制选项和更好的性能表现。 将Dubbo与Jaeger集成的过程与Zipkin类似，主要区别在于依赖库的选择和一些配置细节。这里就不详细展开，但你可以按照类似的思路去尝试。 4. 结语 持续优化与未来展望 集成分布式追踪系统无疑为我们的Dubbo服务增添了一双“慧眼”，使我们能够在复杂多变的分布式环境中更加从容不迫。然而，这只是一个开始。随着技术日新月异，咱们得不停地充电，学些新工具新技能，才能跟上这变化的脚步嘛。别忘了时不时地检查和调整你的追踪方法，确保它们跟得上你生意的发展步伐。 希望这篇文章能为你提供一些有价值的启示，让你在Dubbo与分布式追踪系统的世界里游刃有余。记住，每一次挑战都是成长的机会，勇敢地迎接它们吧！

...处理大规模数据的开源框架。它的主要目标是解决海量数据存储和处理的问题。Hadoop这家伙，处理大数据的能力贼溜，现在早就是业界公认的大数据处理“扛把子”了！ 3. Hadoop的主要组件有哪些？ Hadoop的主要组件包括以下几个部分： 3.1 Hadoop Distributed File System (HDFS) HDFS是Hadoop的核心组件之一，它是基于Google的GFS文件系统的分布式文件系统。HDFS这小家伙可机灵了，它知道大文件是个难啃的骨头，所以就耍了个聪明的办法，把大文件切成一块块的小份儿，然后把这些小块分散存到不同的服务器上，这样一来，不仅能储存得妥妥当当，还能同时在多台服务器上进行处理，效率杠杠滴！这种方式可以大大提高数据的读取速度和写入速度。 3.2 MapReduce MapReduce是Hadoop的另一个核心组件，它是用于处理大量数据的一种编程模型。MapReduce的运作方式就像这么回事儿：它先把一个超大的数据集给剁成一小块一小块，然后把这些小块分发给一群计算节点，大家一起手拉手并肩作战，同时处理各自的数据块。最后，将所有结果汇总起来得到最终的结果。 下面是一段使用MapReduce计算两个整数之和的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的一些基本信息以及它的主要组件介绍。如果你对此还有任何疑问或者想要深入了解，欢迎留言讨论！

Java爬虫技术 , Java爬虫技术是一种利用Java编程语言实现的网络数据抓取工具，通过模拟用户浏览器行为发送HTTP请求，获取网页HTML内容，并进一步解析、抽取和处理所需信息的技术手段。在本文中，作者学习并实践了Java爬虫技术，用于从京东商城抓取手机类商品的数据。 SpringBoot框架 , SpringBoot是由Pivotal团队开发的一款开源Java应用程序框架，它简化了Spring应用的初始搭建以及开发过程，提供了一种快速构建独立、生产级别的基于Spring框架的应用程序的方式。在文中，项目采用SpringBoot框架进行搭建，结合JPA（Java Persistence API）实现对爬取数据的持久化存储管理。 JPA（Java Persistence API） , JPA是Java平台上的一个规范，为Java开发者提供了对象关系映射（ORM）的功能，使开发者可以使用面向对象的方式来操作数据库。在文章的场景下，JPA被应用于SpringBoot项目中，用以简化数据库操作，将爬取的商品数据自动映射到实体类，并通过ORM方式方便地与数据库进行交互和数据持久化。 HttpClient , Apache HttpClient是一个强大的Java库，用于执行HTTP协议相关的客户端功能，如GET、POST等请求，获取HTTP响应结果。在本文的爬虫项目中，HttpClient被用来发起对京东页面的HTTP请求，获取商品列表页面的HTML源码。 Jsoup , Jsoup是一个基于Java的HTML解析器，它可以非常方便地提取和操作HTML文档中的数据，支持CSS选择器来查找元素。在该篇文章的爬虫实践中，Jsoup用于解析从京东页面获取的HTML内容，从中提取出商品SPU、SKU、价格、标题、图片链接等具体信息。

... 打开浏览器的开发者模式（快捷键F12）并点击这个搜索按钮 打开这个搜索按钮以后，进行粘贴操作 并且按下回车！ 由图可知，只搜索到一个包，在查看这个包内容之前，应该就有90%的把握就是这个包了 点开查看（没错 就是这个包了） 小细节：Preview是渲染之后的结果 Response是写代码请求的结果 接下来我们就上代码 -- coding: UTF-8 --import jsonimport requestsfrom faker import Fakerdef get_aim(file_name):"""从文件里获取想要的关键词"""with open(file_name, mode='r', encoding='utf-8') as file:keys = file.read()return keysdef aim_letter(aim):"""获取到网页的json数据并保存到txt文件"""url = f'https://m.baidu.com/sugrec?pre=1&p=3&ie=utf-8&json=1&prod=wise&from=wise_web&sugsid=128699,138809,114177,135846,141002,138945,140853,141677,138878,137978,141200,140173,131246,132552,137743,138165,107315,138883,140259,141754,140201,138585,141650,138253,140114,136196,140325,140579,133847,140793,140066,134046,131423,137703,110085,127969,140957,141581,140593,140865,139886,138426,138941,141190,140596&net=&os=&sp=null&rm_brand=0&callback=jsonp1&wd{aim}&sugmode=2&lid=12389568409845924354&sugid=1990018821100998871&preqy=java&_=1580993331416'headers = {'User-Agent': Faker().user_agent(),'Host': 'm.baidu.com','Referer': 'https://m.baidu.com/ssid=4348023d/s?word={aim}&ts=3254538&t_kt=0&ie=utf-8&rsv_iqid=2845402975&rsv_t=daabpEKSG2wGueEO%252FnXSVz2dj3oGTk5cF1suYK9xduVIBAnyA5yo&sa=ib&rsv_pq=2845402975&rsv_sug4=5130&tj=1&inputT=2405&sugid=1990018821100998871&ss=100'}res = requests.get(url, headers=headers) 由于获取到的数据不是标准的json数据要进行字符串的删减result = json.loads(res.text.replace('jsonp1', '').strip('()')) 保存到txt文件with open(f'百度下拉词.txt', mode='a', encoding='utf-8') as file:for key in result['g']:file.write(key + '\n')def main():"""进行整合，并捕捉错误"""name = input('请输入文件的名字：')start_time = time.time()try:letter = get_aim(name).split('\n') 利用线程池加快爬取速度with concurrent.futures.ThreadPoolExecutor(max_workers=100) as executor:for l in letter:executor.submit(get_data, l)except:print('请检查文件名是否存在或者文件名是否错误！！')else: 提示用户完成并打印运行时间时间print('' 30 + f'<{name}> 百度相关词 已完成' + '' 30)finally:print(time.time() - start_time)if __name__ == '__main__':main() 在此 要感谢我的晨哥!!!哈哈 本篇文章为转载内容。原文链接：https://blog.csdn.net/Result_Sea/article/details/104201970。 该文由互联网用户投稿提供，文中观点代表作者本人意见，并不代表本站的立场。 作为信息平台，本站仅提供文章转载服务，并不拥有其所有权，也不对文章内容的真实性、准确性和合法性承担责任。 如发现本文存在侵权、违法、违规或事实不符的情况，请及时联系我们，我们将第一时间进行核实并删除相应内容。

...ecylerview实现的，这里就来讲下如何使用监听recylerview的滚动事件来实现子view的曝光量统计，我们这里说的view都是列表中的子item条目（子view） 先来看下统计结果图 左边是我们的列表，右边是我们统计到每个条目的曝光量。下面就来讲讲具体实现步骤。 一，activity中使用recylerview并显示数据 这里我不再啰嗦，recylerview最基础的使用。 二，监听recylerview的滚动事件OnScrollListener onScrollStateChanged：监听滚动状态 onScrolled：监听滚动 我们接下来的统计工作，就是拿这两个方法做文章。 //检测recylerview的滚动事件recyclerView.addOnScrollListener(new RecyclerView.OnScrollListener() {@Overridepublic void onScrollStateChanged(RecyclerView recyclerView, int newState) {/我这里通过的是停止滚动后屏幕上可见view。如果滚动过程中的可见view也要统计，你可以根据newState去做区分SCROLL_STATE_IDLE:停止滚动SCROLL_STATE_DRAGGING: 用户慢慢拖动SCROLL_STATE_SETTLING：惯性滚动/if (newState == RecyclerView.SCROLL_STATE_IDLE) {.....} }@Overridepublic void onScrolled(RecyclerView recyclerView, int dx, int dy) {super.onScrolled(recyclerView, dx, dy);........} });复制代码 首先再次明确下，我们要统计的是用户停止滑动时，显示在屏幕的上控件。所以我们要监测到onScrollStateChanged 方法中 newState == RecyclerView.SCROLL_STATE_IDLE 时，也就是用户停止滚动。然后在这里做文章。 三，获取屏幕内可见条目的起始位置 这里的起始位置就是指我们屏幕当中最上面和最下面条目的位置。比如下图的0就是最上面的可见条目，3就是最下面的可见条目。我们次数的曝光view就是0，1，2，3 这个时候这四个条目显示在屏幕中。我们这时就要对这4个view的曝光量进行加1 那么接下来的重点就是要去获取屏幕内可见条目的起始位置。获取到起始位置后，当前屏幕里的可见条目就都能拿到了。 而recylerview的manager正好给我们提供的有对应的方法。 findFirstVisibleItemPosition()和findLastVisibleItemPosition() 看字面意思就能知道这时干嘛用的。 但是我们的manager不止LinearLayoutManager一种，所以我们要做下区分， //这里我们用一个数组来记录起始位置int[] range = new int[2];RecyclerView.LayoutManager manager = reView.getLayoutManager();if (manager instanceof LinearLayoutManager) {range = findRangeLinear((LinearLayoutManager) manager);} else if (manager instanceof GridLayoutManager) {range = findRangeGrid((GridLayoutManager) manager);} else if (manager instanceof StaggeredGridLayoutManager) {range = findRangeStaggeredGrid((StaggeredGridLayoutManager) manager);}复制代码 LinearLayoutManager和GridLayoutManager获取起始位置方法如下 private int[] findRangeLinear(LinearLayoutManager manager) {int[] range = new int[2];range[0] = manager.findFirstVisibleItemPosition();range[1] = manager.findLastVisibleItemPosition();return range;}private int[] findRangeGrid(GridLayoutManager manager) {int[] range = new int[2];range[0] = manager.findFirstVisibleItemPosition();range[1] = manager.findLastVisibleItemPosition();return range;}复制代码 StaggeredGridLayoutManager获取起始位置有点复杂，如下 private int[] findRangeStaggeredGrid(StaggeredGridLayoutManager manager) {int[] startPos = new int[manager.getSpanCount()];int[] endPos = new int[manager.getSpanCount()];manager.findFirstVisibleItemPositions(startPos);manager.findLastVisibleItemPositions(endPos);int[] range = findRange(startPos, endPos);return range;}private int[] findRange(int[] startPos, int[] endPos) {int start = startPos[0];int end = endPos[0];for (int i = 1; i < startPos.length; i++) {if (start > startPos[i]) {start = startPos[i];} }for (int i = 1; i < endPos.length; i++) {if (end < endPos[i]) {end = endPos[i];} }int[] res = new int[]{start, end};return res;}复制代码 四，获取到起始位置以后，我们就根据位置获取到view及view中的数据 上面第三步拿到屏幕内可见条目的起始位置以后，我们就用一个for循环，获取当前屏幕内可见的所有子view for (int i = range[0]; i <= range[1]; i++) {View view = manager.findViewByPosition(i);recordViewCount(view);}复制代码 recordViewCount是我自己写的用于获取子view内绑定数据的方法 //获取view绑定的数据private void recordViewCount(View view) {if (view == null || view.getVisibility() != View.VISIBLE ||!view.isShown() || !view.getGlobalVisibleRect(new Rect())) {return;}int top = view.getTop();int halfHeight = view.getHeight() / 2;int screenHeight = UiUtils.getScreenHeight((Activity) view.getContext());int statusBarHeight = UiUtils.getStatusBarHeight(view.getContext());if (top < 0 && Math.abs(top) > halfHeight) {return;}if (top > screenHeight - halfHeight - statusBarHeight) {return;}//这里获取的是我们view绑定的数据，相应的你要去在你的view里setTag，只有set了，才能getItemData tag = (ItemData) view.getTag();String key = tag.toString();if (TextUtils.isEmpty(key)) {return;}hashMap.put(key, !hashMap.containsKey(key) ? 1 : (hashMap.get(key) + 1));Log.i("qcl0402", key + "----出现次数：" + hashMap.get(key));}复制代码 这里有几点需要注意 1，这这里起始位置的view显示区域如果不超过50%，就不算这个view可见，进而也就不统计曝光。 2，我们通过view.getTag();获取view里的数据，必须在此之前setTag()数据，我这里setTag是在viewholder中把数据set进去的 到这里我们就实现了recylerview列表中view控件曝光量的统计了。下面贴出来完整的代码给大家 package com.example.qcl.demo.xuexi.baoguang;import android.app.Activity;import android.graphics.Rect;import android.support.v7.widget.GridLayoutManager;import android.support.v7.widget.LinearLayoutManager;import android.support.v7.widget.RecyclerView;import android.support.v7.widget.StaggeredGridLayoutManager;import android.text.TextUtils;import android.util.Log;import android.view.View;import com.example.qcl.demo.utils.UiUtils;import java.util.concurrent.ConcurrentHashMap;/ 2019/4/2 13:31 author: qcl desc: 安卓曝光量统计工具类 wechat:2501902696/public class ViewShowCountUtils {//刚进入列表时统计当前屏幕可见viewsprivate boolean isFirstVisible = true;//用于统计曝光量的mapprivate ConcurrentHashMap<String, Integer> hashMap = new ConcurrentHashMap<String, Integer>();/ 统计RecyclerView里当前屏幕可见子view的曝光量 /void recordViewShowCount(RecyclerView recyclerView) {hashMap.clear();if (recyclerView == null || recyclerView.getVisibility() != View.VISIBLE) {return;}//检测recylerview的滚动事件recyclerView.addOnScrollListener(new RecyclerView.OnScrollListener() {@Overridepublic void onScrollStateChanged(RecyclerView recyclerView, int newState) {/我这里通过的是停止滚动后屏幕上可见view。如果滚动过程中的可见view也要统计，你可以根据newState去做区分SCROLL_STATE_IDLE:停止滚动SCROLL_STATE_DRAGGING: 用户慢慢拖动SCROLL_STATE_SETTLING：惯性滚动/if (newState == RecyclerView.SCROLL_STATE_IDLE) {getVisibleViews(recyclerView);} }@Overridepublic void onScrolled(RecyclerView recyclerView, int dx, int dy) {super.onScrolled(recyclerView, dx, dy);//刚进入列表时统计当前屏幕可见viewsif (isFirstVisible) {getVisibleViews(recyclerView);isFirstVisible = false;} }});}/ 获取当前屏幕上可见的view /private void getVisibleViews(RecyclerView reView) {if (reView == null || reView.getVisibility() != View.VISIBLE ||!reView.isShown() || !reView.getGlobalVisibleRect(new Rect())) {return;}//保险起见，为了不让统计影响正常业务，这里做下try-catchtry {int[] range = new int[2];RecyclerView.LayoutManager manager = reView.getLayoutManager();if (manager instanceof LinearLayoutManager) {range = findRangeLinear((LinearLayoutManager) manager);} else if (manager instanceof GridLayoutManager) {range = findRangeGrid((GridLayoutManager) manager);} else if (manager instanceof StaggeredGridLayoutManager) {range = findRangeStaggeredGrid((StaggeredGridLayoutManager) manager);}if (range == null || range.length < 2) {return;}Log.i("qcl0402", "屏幕内可见条目的起始位置：" + range[0] + "---" + range[1]);for (int i = range[0]; i <= range[1]; i++) {View view = manager.findViewByPosition(i);recordViewCount(view);} } catch (Exception e) {e.printStackTrace();} }//获取view绑定的数据private void recordViewCount(View view) {if (view == null || view.getVisibility() != View.VISIBLE ||!view.isShown() || !view.getGlobalVisibleRect(new Rect())) {return;}int top = view.getTop();int halfHeight = view.getHeight() / 2;int screenHeight = UiUtils.getScreenHeight((Activity) view.getContext());int statusBarHeight = UiUtils.getStatusBarHeight(view.getContext());if (top < 0 && Math.abs(top) > halfHeight) {return;}if (top > screenHeight - halfHeight - statusBarHeight) {return;}//这里获取的是我们view绑定的数据，相应的你要去在你的view里setTag，只有set了，才能getItemData tag = (ItemData) view.getTag();String key = tag.toString();if (TextUtils.isEmpty(key)) {return;}hashMap.put(key, !hashMap.containsKey(key) ? 1 : (hashMap.get(key) + 1));Log.i("qcl0402", key + "----出现次数：" + hashMap.get(key));}private int[] findRangeLinear(LinearLayoutManager manager) {int[] range = new int[2];range[0] = manager.findFirstVisibleItemPosition();range[1] = manager.findLastVisibleItemPosition();return range;}private int[] findRangeGrid(GridLayoutManager manager) {int[] range = new int[2];range[0] = manager.findFirstVisibleItemPosition();range[1] = manager.findLastVisibleItemPosition();return range;}private int[] findRangeStaggeredGrid(StaggeredGridLayoutManager manager) {int[] startPos = new int[manager.getSpanCount()];int[] endPos = new int[manager.getSpanCount()];manager.findFirstVisibleItemPositions(startPos);manager.findLastVisibleItemPositions(endPos);int[] range = findRange(startPos, endPos);return range;}private int[] findRange(int[] startPos, int[] endPos) {int start = startPos[0];int end = endPos[0];for (int i = 1; i < startPos.length; i++) {if (start > startPos[i]) {start = startPos[i];} }for (int i = 1; i < endPos.length; i++) {if (end < endPos[i]) {end = endPos[i];} }int[] res = new int[]{start, end};return res;} }复制代码 使用就是在我们的recylerview设置完数据以后，把recylerview传递进去就可以了。如下图： 我们统计到曝光量，拿到曝光view绑定的数据，就可以结合后面的view点击，来看下那些商品view的曝光量高，那些商品的转化率高。当然，这都是运营小伙伴的事了，我们只需要负责把曝光量统计到即可。 如果你有任何编程方面的问题，可以加我微信交流 2501902696（备注编程） by:年糕妈妈qcl 转载于:https://juejin.im/post/5ca30ad1e51d4514c01634f1 本篇文章为转载内容。原文链接：https://blog.csdn.net/weixin_34150503/article/details/91475198。 该文由互联网用户投稿提供，文中观点代表作者本人意见，并不代表本站的立场。 作为信息平台，本站仅提供文章转载服务，并不拥有其所有权，也不对文章内容的真实性、准确性和合法性承担责任。 如发现本文存在侵权、违法、违规或事实不符的情况，请及时联系我们，我们将第一时间进行核实并删除相应内容。

...三、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。 该文由互联网用户投稿提供，文中观点代表作者本人意见，并不代表本站的立场。 作为信息平台，本站仅提供文章转载服务，并不拥有其所有权，也不对文章内容的真实性、准确性和合法性承担责任。 如发现本文存在侵权、违法、违规或事实不符的情况，请及时联系我们，我们将第一时间进行核实并删除相应内容。

...方便又清晰！ 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的学习之路还有很多内容需要探索，比如监控、调优、安全等等。其实我觉得啊，只要你把命名的规矩弄明白了，东西该怎么放也心里有数了，那你就算是走上正轨啦，成功嘛，它就已经在向你招手啦！加油吧，朋友们！ --- 希望这篇文章对你有所帮助，如果有任何疑问，欢迎随时交流哦！

...对象的作用 类似于 Java 中使用类访问静态成员的语法。因为 Kotlin 取消了 static 关键字，所以 Kotlin 引入伴生对象来弥补没有静态成员的不足。可见，伴生对象的主要作用就是为其所在的外部类模拟静态成员。 在 Java 代码中调用伴生对象 如何在 Java 代码中调用 Kotlin 的伴生对象呢？ public static void main(String[] args) { 如果声明伴生对象有名称，则使用： 类名.伴生对象名.方法名() 类名.半生对象名.属性的setter,getter方法 如果声明伴生对象无名称，则采用 Companion 关键字调用： .Companion.方法名() @JvmField 和 @JvmStatic 的使用 在上面的例子中，我们知道了可以在 Java 代码中调用 Kotlin 中伴生对象的成员，类似于 Java 类中的静态成员。但是看上去和 Java 中的还是略有区别，因为类名和方法名/属性setter,getter方法名之间多了个伴生对象的名称或者 Companion 关键字。如何使其在调用的时候与 Java 中的调用看上去一样呢？ Kotlin 为我们提供了 @JvmField 和 @JvmStatic 两个注解。@JvmField 使用在属性上，@JvmStatic 使用在方法上。如： class Test { 这样我们在 Java 代码中调用的时候就和 Java 类调用静态成员的形式一致了，Kotlin 代码调用方式不变： System.out.println(Test.flag); System.out.println(Test.add(1, 2)); const 关键字 在伴生对象中，我们可能需要声明一个常量，目的是等同于 Java 中的静态常量。有两种方式，一种是上面所提到的使用 @JvmField 注解，另一种则是使用 const 关键字修饰。这两种声明方式都等同于 Java 中 static final 所修饰的变量。如下代码： companion  扩展属性和扩展方法 扩展函数 Kotlin的扩展函数可以让你作为一个类成员进行调用的函数，但是是定义在这个类的外部。这样可以很方便的扩展一个已经存在的类，为它添加额外的方法 下面我们为String添加一个toInt的方法 package com.binzi.kotlin 在这个扩展函数中，你可以直接访问你扩展的类的函数和属性，就像定义在这个类中的方法一样，但是扩展函数并不允许你打破封装。跟定义在类中方法不同，它不能访问那些私有的、受保护的方法和属性。 扩展函数的导入 我们直接在包里定义扩展函数。这样我们就可以在整个包里面使用这些扩展，如果我们要使用其他包的扩展，我们就需要导入它。导入扩展函数跟导入类是一样的方式。 import  有时候，可能你引入的第三方包都对同一个类型进行了相同函数名扩展，为了解决冲突问题，你可以使用下面的方式对扩展函数进行改名 import com.binzi.kotlin.toInt as toInteger 扩展函数不可覆盖 扩展方法的原理 Kotlin 中类的扩展方法并不是在原类的内部进行拓展，通过反编译为Java代码，可以发现，其原理是使用装饰模式，对源类实例的操作和包装，其实际相当于我们在 Java中定义的工具类方法，并且该工具类方法是使用调用者为第一个参数的，然后在工具方法中操作该调用者 如： fun String?.toInt():  反编译为对应的Java代码： public  扩展属性 类的扩展属性原理其实与扩展方法是一样的，只是定义的形式不同，扩展属性必须定义get和set方法 为MutableList扩展一个firstElement属性: var  反编译后的java代码如下： public static final Object getFirstElement(@NotNull List $this$firstElement) { 内部类 kotlin的内部类与java的内部类有点不同java的内部类可以直接访问外部类的成员，kotlin的内部类不能直接访问外部类的成员，必须用inner标记之后才能访问外部类的成员 没有使用inner标记的内部类 class A{ 反编译后的java代码 public  用inner标记的内部类 class A{ 反编译后的java代码 public  从上面可以看出，没有使用inner标记的内部类最后生成的是静态内部类，而使用inner标记的生成的是非静态内部类 匿名内部类 匿名内部类主要是针对那些获取抽象类或者接口对象而来的。最常见的匿名内部类View点击事件： //java,匿名内部类的写法 上面这个是java匿名内部类的写法，kotlin没有new关键字，那么kotlin的匿名内部类该怎么写呢？ object : View.OnClickListener{ 方法的参数是一个匿名内部类，先写object:，然后写你的参数类型View.OnClickListener{} kotlin还有一个写法lambda 表达式，非常之方便： print( 数据类 在Java中没有专门的数据类，常常是通过JavaBean来作为数据类，但在Kotlin中提供了专门的数据类。 Java public  从上面的例子中可以看到，如果要使用数据类，需要手动写相应的setter/getter方法(尽管IDE也可以批量生成)，但是从代码阅读的角度来说，在属性较多的情况下，诸多的seeter/getter方法还是不利于代码的阅读和维护。 Kotlin 在Kotlin中，可以通过关键字data来生成数据类： data  即在class关键字之前添加data关键字即可。编译器会根据主构造函数中的参数生成相应的数据类。自动生成setter/getter、toString、hashCode等方法 要声明一个数据类，需要满足： 主构造函数中至少有一个参数 主构造函数中所有参数需要标记为val或var 数据类不能是抽象、开发、密封和内部的 枚举类 枚举类是一种特殊的类，kotlin可以通过enum class关键字定义枚举类。 枚举类可以实现0~N个接口； 枚举类默认继承于kotlin.Enum类(其他类最终父类都是Any)，因此kotlin枚举类不能继承类； 非抽象枚举类不能用open修饰符修饰，因此非抽象枚举类不能派生子类； 抽象枚举类不能使用abstract关键字修饰enum class，抽象方法和抽象属性需要使用； 枚举类构造器只能使用private修饰符修饰，若不指定，则默认为private； 枚举类所有实例在第一行显式列出，每个实例之间用逗号隔开，整个声明以分号结尾； 枚举类是特殊的类，也可以定义属性、方法、构造器； 枚举类应该设置成不可变类，即属性值不允许改变，这样更安全； 枚举属性设置成只读属性后，最好在构造器中为枚举类指定初始值，如果在声明时为枚举指定初始值，会导致所有枚举值(或者说枚举对象)的该属性都一样。 定义枚举类 /   定义一个枚举类  / 枚举类实现接口 枚举值分别实现接口的抽象成员 enum  枚举类统一实现接口的抽象成员 enum  分别实现抽象枚举类抽象成员 enum  委托 委托模式 是软件设计模式中的一项基本技巧。在委托模式中，有两个对象参与处理同一个请求，接受请求的对象将请求委托给另一个对象来处理。委托模式是一项基本技巧，许多其他的模式，如状态模式、策略模式、访问者模式本质上是在更特殊的场合采用了委托模式。委托模式使得我们可以用聚合来替代继承。 Java中委托： interface Printer { Kotlin： interface Printer { by表示 p 将会在 PrintImpl 中内部存储， 并且编译器将自动生成转发给 p 的所有 Printer 的方法。 委托属性 有一些常见的属性类型，虽然我们可以在每次需要的时候手动实现它们， 但是如果能够为大家把他们只实现一次并放入一个库会更好。例如包括： 延迟属性(lazy properties): 其值只在首次访问时计算； 可观察属性(observable properties): 监听器会收到有关此属性变更的通知； 把多个属性储存在一个映射(map)中，而不是每个存在单独的字段中。 为了涵盖这些(以及其他)情况，Kotlin 支持 委托属性 。 委托属性的语法是： var :  在 by 后面的表达式是该 委托， 因为属性对应的 get()(和 set())会被委托给它的 getValue() 和 setValue() 方法。 标准委托： Kotlin 标准库为几种有用的委托提供了工厂方法。 延迟属性 Lazy lazy() 接受一个 lambda 并返回一个 Lazy 实例的函数，返回的实例可以作为实现延迟属性的委托：第一次调用 get() 会执行已传递给 lazy() 的 lambda 表达式并记录结果， 后续调用 get() 只是返回记录的结果。例如： val lazyValue: String  可观察属性 Observable Delegates.observable() 接受两个参数：初始值和修改时处理程序(handler)。每当我们给属性赋值时会调用该处理程序(在赋值后执行)。它有三个参数：被赋值的属性、旧值和新值： class User { 如果想拦截赋的新值，并根据你是不是想要这个值来决定是否给属性赋新值，可以使用 vetoable() 取代 observable()，接收的参数和 observable 一样，不过处理程序 返回值是 Boolean 来决定是否采用新值，即在属性被赋新值生效之前 会调用传递给 vetoable 的处理程序。例如： class User { 把属性存在map 中 一个常见的用例是在一个映射(map)里存储属性的值。这经常出现在像解析 JSON 或者做其他“动态”事情的应用中。在这种情况下，你可以使用映射实例自身作为委托来实现委托属性。 例如： class User(map: Map 在上例中，委托属性会从构造函数传入的map中取值(通过字符串键——属性的名称)，如果遇到声明的属性名在map 中找不到对应的key 名，或者key 对应的value 值的类型与声明的属性的类型不一致，会抛出异常。 内联函数 当一个函数被声明为inline时，它的函数体是内联的，也就是说，函数体会被直接替换到函数被调用地方 inline函数(内联函数)从概念上讲是编译器使用函数实现的真实代码来替换每一次的函数调用，带来的最直接的好处就是节省了函数调用的开销，而缺点就是增加了所生成字节码的尺寸。基于此，在代码量不是很大的情况下，我们是否有必要将所有的函数定义为内联？让我们分两种情况进行说明： 将普通函数定义为内联：众所周知，JVM内部已经实现了内联优化，它会在任何可以通过内联来提升性能的地方将函数调用内联化，并且相对于手动将普通函数定义为内联，通过JVM内联优化所生成的字节码，每个函数的实现只会出现一次，这样在保证减少运行时开销的同时，也没有增加字节码的尺寸；所以我们可以得出结论，对于普通函数，我们没有必要将其声明为内联函数，而是交给JVM自行优化。 将带有lambda参数的函数定义为内联：是的，这种情况下确实可以提高性能；但在使用的过程中，我们会发现它是有诸多限制的，让我们从下面的例子开始展开说明： inline  假如我们这样调用doSomething: fun main(args: Array<String>) { 上面的调用会被编译成： fun main(args: Array<String>) { 从上面编译的结果可以看出，无论doSomething函数还是action参数都被内联了，很棒，那让我们换一种调用方式： fun main(args: Array<String>) { 上面的调用会被编译成： fun main(args: Array<String>) { doSomething函数被内联，而action参数没有被内联，这是因为以函数型变量的形式传递给doSomething的lambda在函数的调用点是不可用的，只有等到doSomething被内联后，该lambda才可以正常使用。 通过上面的例子，我们对lambda表达式何时被内联做一下简单的总结： 当lambda表达式以参数的形式直接传递给内联函数，那么lambda表达式的代码会被直接替换到最终生成的代码中。 当lambda表达式在某个地方被保存起来，然后以变量形式传递给内联函数，那么此时的lambda表达式的代码将不会被内联。 上面对lambda的内联时机进行了讨论，消化片刻后让我们再看最后一个例子： inline  上面的例子是否有问题？是的，编译器会抛出“Illegal usage of inline-parameter”的错误，这是因为Kotlin规定内联函数中的lambda参数只能被直接调用或者传递给另外一个内联函数，除此之外不能作为他用；那我们如果确实想要将某一个lambda传递给一个非内联函数怎么办？我们只需将上述代码这样改造即可： inline  很简单，在不需要内联的lambda参数前加上noinline修饰符就可以了。 以上便是我对内联函数的全部理解，通过掌握该特性的运行机制，相信大家可以做到在正确的时机使用该特性，而非滥用或因恐惧弃而不用。 Kotlin下单例模式 饿汉式实现 //Java实现 懒汉式 //Java实现 上述代码中，我们可以发现在Kotlin实现中，我们让其主构造函数私有化并自定义了其属性访问器，其余内容大同小异。 如果有小伙伴不清楚Kotlin构造函数的使用方式。请点击 - - - 构造函数 不清楚Kotlin的属性与访问器，请点击 - - -属性和字段 线程安全的懒汉式 //Java实现 大家都知道在使用懒汉式会出现线程安全的问题，需要使用使用同步锁，在Kotlin中，如果你需要将方法声明为同步，需要添加@Synchronized注解。 双重校验锁式 //Java实现 哇！小伙伴们惊喜不，感不感动啊。我们居然几行代码就实现了多行的Java代码。其中我们运用到了Kotlin的延迟属性 Lazy。 Lazy内部实现 public  观察上述代码，因为我们传入的mode = LazyThreadSafetyMode.SYNCHRONIZED， 那么会直接走 SynchronizedLazyImpl，我们继续观察SynchronizedLazyImpl。 Lazy接口 SynchronizedLazyImpl实现了Lazy接口，Lazy具体接口如下： public  继续查看SynchronizedLazyImpl，具体实现如下： SynchronizedLazyImpl内部实现 private  通过上述代码，我们发现 SynchronizedLazyImpl 覆盖了Lazy接口的value属性，并且重新了其属性访问器。其具体逻辑与Java的双重检验是类似的。 到里这里其实大家还是肯定有疑问，我这里只是实例化了SynchronizedLazyImpl对象，并没有进行值的获取，它是怎么拿到高阶函数的返回值呢？。这里又涉及到了委托属性。 委托属性语法是：val/var : by 。在 by 后面的表达式是该 委托， 因为属性对应的 get()(和 set())会被委托给它的 getValue() 和 setValue() 方法。属性的委托不必实现任何的接口，但是需要提供一个 getValue() 函数(和 setValue()——对于 var 属性)。 而Lazy.kt文件中，声明了Lazy接口的getValue扩展函数。故在最终赋值的时候会调用该方法。 internal.InlineOnly 静态内部类式 //Java实现 静态内部类的实现方式，也没有什么好说的。Kotlin与Java实现基本雷同。 补充 在该篇文章结束后，有很多小伙伴咨询，如何在Kotlin版的Double Check，给单例添加一个属性，这里我给大家提供了一个实现的方式。(不好意思，最近才抽出时间来解决这个问题) class SingletonDemo private constructor( 其中关于?:操作符，如果 ?: 左侧表达式非空，就返回其左侧表达式，否则返回右侧表达式。请注意，当且仅当左侧为空时，才会对右侧表达式求值。 Kotlin 智能类型转换 对于子父类之间的类型转换 先看这样一段 Java 代码 public  尽管在 main 函数中，对 person 这个对象进行了类型判断，但是在使用的时候还是需要强制转换成 Student 类型，这样是不是很不智能？ 同样的情况在 Kotlin 中就变得简单多了 fun main(args: Array<String>) { 在 Kotlin 中，只要对类型进行了判断，就可以直接通过父类的对象去调用子类的函数了 安全的类型转换 还是上面的那个例子，如果我们没有进行类型判断，并且直接进行强转，会怎么样呢？ public static void main(String[] args) { 结果就只能是 Exception in thread "main" java.lang.ClassCastException 那么在 Kotlin 中是不是会有更好的解决方法呢？ val person: Person = Person() 在转换操作符后面添加一个 ?，就不会把程序 crash 掉了，当转化失败的时候，就会返回一个 null 在空类型中的智能转换 需要提前了解 Kotlin 类型安全的相关知识(Kotlin 中的类型安全(对空指针的优化处理)) String? =  aString 在定义的时候定义成了有可能为 null，按照之前的写法，我们需要这样写 String? =  但是已经进行了是否为 String 类型的判断，所以就一定 不是 空类型了，也就可以直接输出它的长度了 T.()->Unit 、 ()->Unit 在做kotlin开发中，经常看到一些系统函数里，用函数作为参数 public  .()-Unit与()->Unit的区别是我们调用时，在代码块里面写this，的时候，两个this代表的含义不一样，T.()->Unit里的this代表的是自身实例，而()->Unit里，this代表的是外部类的实例。 推荐阅读 对 Kotlin 与 Java 编程语言的思考 使用 Kotlin 做开发一个月后的感想 扫一扫 关注我的公众号如果你想要跟大家分享你的文章，欢迎投稿~ 本篇文章为转载内容。原文链接：https://blog.csdn.net/weixin_39611037/article/details/109984124。 该文由互联网用户投稿提供，文中观点代表作者本人意见，并不代表本站的立场。 作为信息平台，本站仅提供文章转载服务，并不拥有其所有权，也不对文章内容的真实性、准确性和合法性承担责任。 如发现本文存在侵权、违法、违规或事实不符的情况，请及时联系我们，我们将第一时间进行核实并删除相应内容。

...te 类型是在早期 Java 中 java.util.Date 类基础上构建的。为此，Date 类型使用 UTC（Coordinated Universal Time，国际协调时间[又称世界统一时间]）1970 年 1 月 1 日午夜（零时）开始经过的毫秒来保存日期。在使用这种数据存储格式的条件下，Date 类型保存的日期能够精确到 1970 年 1 月 1 日之前或之后的 285616 年。 创建一个日期对象，使用 new 运算符和 Date 构造方法（构造函数）即可。 var box = new Date(); // 创建一个日期对象 在调用 Date 构造方法而不传递参数的情况下，新建的对象自动获取当前的时间和日期。 alert(box); // 不同浏览器显示不同 ECMAScript 提供了两个方法，Date.parse()和 Date.UTC()。Date.parse()方法接收一个表示日期的字符串参数，然后尝试根据这个字符串返回相应的毫秒数。ECMA-262 没有定义 Date.parse()应该支持哪种日期格式，因此方法的行为因实现而异，因地区而异。默认通常接收的日期格式如下： ‘月/日/年’，如 6/13/2011; ‘英文月名 日, 年’，如 May 25, 2004; ‘英文星期几 英文月名 日 年 时:分:秒 时区’，如 Tue May 25 2004 00:00:00 GMT-070 alert(Date.parse('6/13/2011')); // 1307894400000 如果 Date.parse()没有传入或者不是标准的日期格式，那么就会返回 NaN。 alert(Date.parse()); // NaN 如果想输出指定的日期，那么把 Date.parse()传入 Date 构造方法里。 var box = new Date(Date.parse('6/13/2011')); // Mon Jun 13 2011 00:00:00 GMT+0800var box = new Date('6/13/2011'); // 直接传入，Date.parse()后台被调用 Date 对象及其在不同浏览器中的实现有许多奇怪的行为。其中有一种倾向是将超出的范围的值替换成当前的值，以便生成输出。例如，在解析“January 32, 2007”时，有的浏览器会将其解释为“February 1, 2007”。而 Opera 则倾向与插入当前月份的当前日期。 Date.UTC()方法同样也返回表示日期的毫秒数，但它与 Date.parse()在构建值时使用不同的信息。（年份，基于 0 的月份[0 表示 1 月，1 表示 2 月]，月中的哪一天[1-31]，小时数[0-23] ，分钟，秒以及毫秒)。只有前两个参数是必须的。如果没有提供月数，则天数为 1；如果省略其他参数，则统统为 0。 alert(Date.UTC(2011,11)); // 1322697600000 如果 Date.UTC()参数传递错误，那么就会出现负值或者 NaN 等非法信息。 alert(Date.UTC()); // 负值或者 NaN 如果要输出指定日期，那么直接把 Date.UTC()传入 Date 构造方法里即可。 var box = new Date(Date.UTC(2011,11, 5, 15, 13, 16)); 通用的方法 与其他类型一样，Date 类型也重写了 toLocaleString()、toString()和 valueOf()方法；但这些方法返回值与其他类型中的方法不同。 var box = new Date(Date.UTC(2011,11, 5, 15, 13, 16));alert('toString:' + box.toString());alert('toLocaleString:' + box.toLocaleString()); // 按本地格式输出 这两个方法在不同浏览器显示的效果又不一样，但不用担心，这两个方法只是在调试比较有用，在显示时间和日期上，没什么价值。valueOf()方法显示毫秒数。 日期格式化方法 Date 类型还有一些专门用于将日期格式化为字符串的方法。 var box = new Date();alert(box.toDateString()); // 以特定的格式显示星期几、月、日和年alert(box.toTimeString()); // 以特定的格式显示时、分、秒和时区alert(box.toLocaleDateString()); // 以特定地区格式显示星期几、月、日和年alert(box.toLocaleTimeString()); // 以特定地区格式显示时、分、秒和时区alert(box.toUTCString()); // 以特定的格式显示完整的 UTC 日期 组件方法 组件方法，是为我们单独获取你想要的各种时间/日期而提供的方法。需要注意的时候 ，这些方法中，有带 UTC 的，有不带 UTC 的。UTC 日期指的是在没有时区偏差的情况下的日期值。 alert(box.getTime()); // 获取日期的毫秒数，和 valueOf()返回一致alert(box.setTime(100)); // 以毫秒数设置日期，会改变整个日期alert(box.getFullYear()); // 获取四位年份alert(box.setFullYear(2012)); // 设置四位年份，返回的是毫秒数alert(box.getMonth()); // 获取月份，没指定月份，从 0 开始算起alert(box.setMonth(11)); // 设置月份alert(box.getDate()); // 获取日期alert(box.setDate(8)); // 设置日期，返回毫秒数alert(box.getDay()); // 返回星期几，0 表示星期日，6 表示星期六alert(box.setDay(2)); // 设置星期几alert(box.getHours()); // 返回时alert(box.setHours(12)); // 设置时alert(box.getMinutes()); // 返回分钟alert(box.setMinutes(22)); // 设置分钟alert(box.getSeconds()); // 返回秒数alert(box.setSeconds(44)); // 设置秒数alert(box.getMilliseconds()); // 返回毫秒数alert(box.setMilliseconds()); // 设置毫秒数alert(box.getTimezoneOffset()); // 返回本地时间和 UTC 时间相差的分钟数 以上方法除了 getTimezoneOffset()，其他都具有 UTC 功能，例如 setDate()及 getDate()获取星期几，那么就会有 setUTCDate()及getUTCDate()，表示世界协调时间。 2、正则表达式 假设用户需要在 HTML 表单中填写姓名、地址、出生日期等。那么在将表单提交到服务器进一步处理前，JavaScript 程序会检查表单以确认用户确实输入了信息并且这些信息是符合要求的。 什么是正则表达式 正则表达式（regular expression）是一个描述字符模式的对象。ECMAScript 的 RegExp 类表示正则表达式，而 String 和 RegExp 都定义了使用正则表达式进行强大的模式匹配和文本检索与替换的函数。 正则表达式主要用来验证客户端的输入数据。用户填写完表单单击按钮之后，表单就会被发送到服务器，在服务器端通常会用 PHP、ASP.NET 等服务器脚本对其进行进一步处理 。因为客户端验证，可以节约大量的服务器端的系统资源，并且提供更好的用户体验。 创建正则表达式 创建正则表达式和创建字符串类似，创建正则表达式提供了两种方法，一种是采用 new 运算符，另一个是采用字面量方式。 两种创建方式 var box = new RegExp('box'); // 第一个参数字符串var box = new RegExp('box', 'ig'); // 第二个参数可选模式修饰符 模式修饰符的可选参数 参数 含义 i 忽略大小写 g 全局匹配 m 多行匹配 var box = /box/; // 直接用两个反斜杠var box = /box/ig; // 在第二个斜杠后面加上模式修饰符 测试正则表达式 RegExp 对象包含两个方法：test()和 exec()，功能基本相似，用于测试字符串匹配。test()方法在字符串中查找是否存在指定的正则表达式并返回布尔值，如果存在则返回 true，不存在则返回 false。exec()方法也用于在字符串中查找指定正则表达式，如果 exec()方法执行成功，则返回包含该查找字符串的相关信息数组。如果执行失败，则返回 null。 RegExp 对象的方法 方法 功能 test 在字符串中测试模式匹配，返回 true 或 false exec 在字符串中执行匹配搜索，返回结果数组 // 使用 new 运算符的 test 方法示例var pattern = new RegExp('box', 'i'); // 创建正则模式，不区分大小写var str = 'This is a Box!'; // 创建要比对的字符串alert(pattern.test(str)); // 通过 test()方法验证是否匹配// 使用字面量方式的 test 方法示例var pattern = /box/i; // 创建正则模式，不区分大小写var str = 'This is a Box!';alert(pattern.test(str));// 使用一条语句实现正则匹配alert(/box/i.test('This is a Box!')); // 模式和字符串替换掉了两个变量// 使用 exec 返回匹配数组var pattern = /box/i;var str = 'This is a Box!';alert(pattern.exec(str)); // 匹配了返回数组，否则返回 null 使用字符串的正则表达式方法 除了 test()和 exec()方法，String 对象也提供了 4 个使用正则表达式的方法。 String 对象中的正则表达式方法 方法 含义 match(pattern) 返回 pattern 中的子串或 null replace(pattern, replacement) 用 replacement 替换 pattern search(pattern) 返回字符串中 pattern 开始位置 split(pattern) 返回字符串按指定 pattern 拆分的数组 // 使用 match 方法获取获取匹配数组var pattern = /box/ig; // 全局搜索var str = 'This is a Box!，That is a Box too';alert(str.match(pattern)); // 匹配到两个 Box,Boxalert(str.match(pattern).length); // 获取数组的长度// 使用 search 来查找匹配数据var pattern = /box/ig;var str = 'This is a Box!，That is a Box too';alert(str.search(pattern)); // 查找到返回位置，否则返回-1 因为 search 方法查找到即返回，也就是说无需 g 全局。 // 使用 replace 替换匹配到的数据var pattern = /box/ig;var str = 'This is a Box!，That is a Box too';alert(str.replace(pattern, 'Tom')); // 将 Box 替换成了 Tom// 使用 split 拆分成字符串数组var pattern = / /ig;var str = 'This is a Box!，That is a Box too';alert(str.split(pattern)); // 将空格拆开分组成数组 RegExp 对象的静态属性 属性 短名 含义 input $_ 当前被匹配的字符串 lastMatch $& 最后一个匹配字符串 lastParen $+ 最后一对圆括号内的匹配子串 leftContext $ 最后一次匹配前的子串 multiline $ 用于指定是否所有的表达式都用于多行的布尔值 rightContext $’ 在上次匹配之后的子串 // 使用静态属性var pattern = /(g)oogle/;var str = 'This is google！';pattern.test(str); // 执行一下alert(RegExp.input); // This is google！alert(RegExp.leftContext); // This isalert(RegExp.rightContext); // ！alert(RegExp.lastMatch); // googlealert(RegExp.lastParen); // galert(RegExp.multiline); // false Opera 不支持 input、lastMatch、lastParen 和 multiline 属性。IE 不支持 multiline 属性。所有的属性可以使用短名来操作。RegExp.input 可以改写成 RegExp['$_']，依次类推。但 RegExp.input 比较特殊，它还可以写成 RegExp.$_。 RegExp 对象的实例属性 属性 含义 global Boolean 值，表示 g 是否已设置 ignoreCase Boolean 值，表示 i 是否已设置 lastIndex 整数，代表下次匹配将从哪里字符位置开始 multiline Boolean 值，表示 m 是否已设置 Source 正则表达式的源字符串形式 // 使用实例属性var pattern = /google/ig;alert(pattern.global); // true，是否全局了alert(pattern.ignoreCase); // true，是否忽略大小写alert(pattern.multiline); // false，是否支持换行alert(pattern.lastIndex); // 0，下次的匹配位置alert(pattern.source); // google，正则表达式的源字符串var pattern = /google/g;var str = 'google google google';pattern.test(str); // google，匹配第一次alert(pattern.lastIndex); // 6，第二次匹配的位 以上基本没什么用。并且 lastIndex 在获取下次匹配位置上 IE 和其他浏览器有偏差 ，主要表现在非全局匹配上。lastIndex 还支持手动设置，直接赋值操作。 获取控制 正则表达式元字符是包含特殊含义的字符。它们有一些特殊功能，可以控制匹配模式的方式。反斜杠后的元字符将失去其特殊含义。 字符类：单个字符和数字 元字符/元符号 匹配情况 . 匹配除换行符外的任意字符 [a-z0-9] 匹配括号中的字符集中的任意字符 [^a-z0-9] 匹配任意不在括号中的字符集中的字符 \d 匹配数字 \D 匹配非数字，同[^0-9]相同 \w 匹配字母和数字及_ \W 匹配非字母和数字及_ 字符类：空白字符 元字符/元符号 匹配情况 \0 匹配 null 字符 \b 匹配空格字符 \f 匹配进纸字符 \n 匹配换行符 \r 匹配回车字符 \t 匹配制表符 \s 匹配空白字符、空格、制表符和换行符 \S 匹配非空白字符 字符类：锚字符 元字符/元符号 匹配情况 ^ 行首匹配 $ 行尾匹配 \A 只有匹配字符串开始处 \b 匹配单词边界，词在[]内时无效 \B 匹配非单词边界 \G 匹配当前搜索的开始位置 \Z 匹配字符串结束处或行尾 \z 只匹配字符串结束处 字符类：重复字符 元字符/元符号 匹配情况 x? 匹配 0 个或 1 个 x x 匹配 0 个或任意多个 x x+ 匹配至少一个 x (xyz)+ 匹配至少一个(xyz) x{m,n} 匹配最少 m 个、最多 n 个 x 字符类：替代字符 元字符/元符号 匹配情况 this where 字符类：记录字符 元字符/元符号 匹配情况 (string) 用于反向引用的分组 \1 或$1 匹配第一个分组中的内容 \2 或$2 匹配第二个分组中的内容 \3 或$3 匹配第三个分组中的内容 // 使用点元字符var pattern = /g..gle/; // .匹配一个任意字符var str = 'google';alert(pattern.test(str));// 重复匹配var pattern = /g.gle/; // .匹配 0 个一个或多个var str = 'google'; //,?,+,{n,m}alert(pattern.test(str));// 使用字符类匹配var pattern = /g[a-zA-Z_]gle/; // [a-z]表示任意个 a-z 中的字符var str = 'google';alert(pattern.test(str));var pattern = /g[^0-9]gle/; // [^0-9]表示任意个非 0-9 的字符var str = 'google';alert(pattern.test(str));var pattern = /[a-z][A-Z]+/; // [A-Z]+表示 A-Z 一次或多次var str = 'gOOGLE';alert(pattern.test(str));// 使用元符号匹配var pattern = /g\wgle/; // \w匹配任意多个所有字母数字_var str = 'google';alert(pattern.test(str));var pattern = /google\d/; // \d匹配任意多个数字var str = 'google444';alert(pattern.test(str));var pattern = /\D{7,}/; // \D{7,}匹配至少 7 个非数字var str = 'google8';alert(pattern.test(str));// 使用锚元字符匹配var pattern = /^google$/; // ^从开头匹配，$从结尾开始匹配var str = 'google';alert(pattern.test(str));var pattern = /goo\sgle/; // \s 可以匹配到空格var str = 'goo gle';alert(pattern.test(str));var pattern = /google\b/; // \b 可以匹配是否到了边界var str = 'google';alert(pattern.test(str));// 使用或模式匹配var pattern = /google|baidu|bing/; // 匹配三种其中一种字符串var str = 'google';alert(pattern.test(str));// 使用分组模式匹配var pattern = /(google){4,8}/; // 匹配分组里的字符串 4-8 次var str = 'googlegoogle';alert(pattern.test(str));var pattern = /8(.)8/; // 获取 8..8 之间的任意字符var str = 'This is 8google8';str.match(pattern);alert(RegExp.$1); // 得到第一个分组里的字符串内容var pattern = /8(.)8/;var str = 'This is 8google8';var result = str.replace(pattern,'<strong>$1</strong>'); // 得到替换的字符串输出document.write(result);var pattern = /(.)\s(.)/;var str = 'google baidu';var result = str.replace(pattern, '$2 $1'); // 将两个分组的值替换输出document.write(result); 贪婪 惰性 + +? ? ?? ? {n} {n}? {n,} {n,}? {n,m} {n,m}? // 关于贪婪和惰性var pattern = /[a-z]+?/; // ?号关闭了贪婪匹配，只替换了第一个var str = 'abcdefjhijklmnopqrstuvwxyz';var result = str.replace(pattern, 'xxx');alert(result);var pattern = /8(.+?)8/g; // 禁止了贪婪，开启的全局var str = 'This is 8google8, That is 8google8, There is 8google8';var result = str.replace(pattern,'<strong>$1</strong>');document.write(result);var pattern = /8([^8])8/g; // 另一种禁止贪婪var str = 'This is 8google8, That is 8google8, There is 8google8';var result = str.replace(pattern,'<strong>$1</strong>');document.write(result);// 使用 exec 返回数组var pattern = /^[a-z]+\s[0-9]{4}$/i;var str = 'google 2012';alert(pattern.exec(str)); // 返回整个字符串var pattern = /^[a-z]+/i; // 只匹配字母var str = 'google 2012';alert(pattern.exec(str)); // 返回 googlevar pattern = /^([a-z]+)\s([0-9]{4})$/i; // 使用分组var str = 'google 2012';alert(pattern.exec(str)[0]); // google 2012alert(pattern.exec(str)[1]); // googlealert(pattern.exec(str)[2]); // 2012// 捕获性分组和非捕获性分组var pattern = /(\d+)([a-z])/; // 捕获性分组var str = '123abc';alert(pattern.exec(str));var pattern = /(\d+)(?:[a-z])/; // 非捕获性分组var str = '123abc';alert(pattern.exec(str));// 使用分组嵌套var pattern = /(A?(B?(C?)))/; // 从外往内获取var str = 'ABC';alert(pattern.exec(str));// 使用前瞻捕获var pattern = /(goo(?=gle))/; // goo 后面必须跟着 gle 才能捕获var str = 'google';alert(pattern.exec(str));// 使用特殊字符匹配var pattern = /\.\[\/b\]/; // 特殊字符，用\符号转义即可var str = '.[/b]';alert(pattern.test(str));// 使用换行模式var pattern = /^\d+/mg; // 启用了换行模式var str = '1.baidu\n2.google\n3.bing';var result = str.replace(pattern, '');alert(result); 常用的正则 检查邮政编码 var pattern = /[1-9][0-9]{5}/; // 共 6 位数字，第一位不能为 0var str = '224000';alert(pattern.test(str)); 检查文件压缩包 var pattern = /[\w]+\.zip|rar|gz/; // \w 表示所有数字和字母加下划线var str = '123.zip'; // \.表示匹配.，后面是一个选择alert(pattern.test(str)); 删除多余空格 var pattern = /\s/g; // g 必须全局，才能全部匹配var str = '111 222 333';var result = str.replace(pattern,''); // 把空格匹配成无空格alert(result); 删除首尾空格 var pattern = /^\s+/; // 强制首var str = ' goo gle ';var result = str.replace(pattern, '');pattern = /\s+$/; // 强制尾result = result.replace(pattern, '');alert('|' + result + '|');var pattern = /^\s(.+?)\s$/; // 使用了非贪婪捕获var str = ' google ';alert('|' + pattern.exec(str)[1] + '|');var pattern = /^\s(.+?)\s$/;var str = ' google ';alert('|' + str.replace(pattern, '$1') + '|'); // 使用了分组获取 简单的电子邮件验证 var pattern = /^([a-zA-Z0-9_\.\-]+)@([a-zA-Z0-9_\.\-]+)\.([a-zA-Z]{2,4})$/;var str = 'yc60.com@gmail.com';alert(pattern.test(str));var pattern = /^([\w\.\-]+)@([\w\.\-]+)\.([\w]{2,4})$/;var str = 'yc60.com@gmail.com';alert(pattern.test(str)); 3、Function类型 在 ECMAScript 中，Function（函数）类型实际上是对象。每个函数都是 Function 类型的实例，而且都与其他引用类型一样具有属性和方法。由于函数是对象，因此函数名实际上也是一个指向函数对象的指针。 函数的声明方式 普通的函数声明 function box(num1, num2) {return num1+ num2;} 使用变量初始化函数 var box= function(num1, num2) {return num1 + num2;}; 使用 Function 构造函数 var box= new Function('num1', 'num2' ,'return num1 + num2'); 第三种方式我们不推荐，因为这种语法会导致解析两次代码（第一次解析常规 ECMAScript 代码，第二次是解析传入构造函数中的字符串），从而影响性能。但我们可以通过这种语法来理解"函数是对象，函数名是指针"的概念。 作为值的函数 ECMAScript 中的函数名本身就是变量，所以函数也可以作为值来使用。也就是说，不仅可以像传递参数一样把一个函数传递给另一个函数，而且可以将一个函数作为另一个函数的结果返回。 function box(sumFunction, num) {return sumFunction(num); // someFunction}function sum(num) {return num + 10;}var result = box(sum, 10); // 传递函数到另一个函数里 函数内部属性 在函数内部，有两个特殊的对象：arguments 和 this。arguments 是一个类数组对象，包含着传入函数中的所有参数，主要用途是保存函数参数。但这个对象还有一个名叫 callee 的属性，该属性是一个指针，指向拥有这个 arguments 对象的函数。 function box(num) {if (num <= 1) {return 1;} else {return num box(num-1); // 一个简单的的递归} } 对于阶乘函数一般要用到递归算法，所以函数内部一定会调用自身；如果函数名不改变是没有问题的，但一旦改变函数名，内部的自身调用需要逐一修改。为了解决这个问题，我们可以使用 arguments.callee 来代替。 function box(num) {if (num <= 1) {return 1;} else {return num arguments.callee(num-1); // 使用 callee 来执行自身} } 函数内部另一个特殊对象是 this，其行为与 Java 和 C中的 this 大致相似。换句话说 ，this 引用的是函数据以执行操作的对象，或者说函数调用语句所处的那个作用域。当在全局作用域中调用函数时，this 对象引用的就是 window。 // 便于理解的改写例子window.color = '红色的'; // 全局的，或者 var color = '红色的';也行alert(this.color); // 打印全局的 colorvar box = {color : '蓝色的', // 局部的 colorsayColor : function () {alert(this.color); // 此时的 this 只能 box 里的 color} };box.sayColor(); // 打印局部的 coloralert(this.color); // 还是全局的// 引用教材的原版例子window.color = '红色的'; // 或者 var color = '红色的';也行var box = {color : '蓝色的'};function sayColor() {alert(this.color); // 这里第一次在外面，第二次在 box 里面}getColor();box.sayColor = sayColor; // 把函数复制到 box 对象里，成为了方法box.sayColor(); 函数属性和方法 ECMAScript 中的函数是对象，因此函数也有属性和方法。每个函数都包含两个属性 ：length 和 prototype。其中，length 属性表示函数希望接收的命名参数的个数。 function box(name, age) {alert(name + age);}alert(box.length); // 2 对于 prototype 属性，它是保存所有实例方法的真正所在，也就是原型。这个属性 ，我们将在面向对象一章详细介绍。而 prototype 下有两个方法：apply()和 call()，每个函数都包含这两个非继承而来的方法。这两个方法的用途都在特定的作用域中调用函数，实际上等于设置函数体内 this 对象的值。 function box(num1, num2) {return num1 + num2; // 原函数}function sayBox(num1, num2) {return box.apply(this, [num1, num2]); // this 表示作用域，这里是 window} // []表示 box 所需要的参数function sayBox2(num1, num2) {return box.apply(this, arguments); // arguments 对象表示 box 所需要的参数}alert(sayBox(10,10)); // 20alert(sayBox2(10,10)); // 20 call()方法于 apply()方法相同，他们的区别仅仅在于接收参数的方式不同。对于 call()方法而言，第一个参数是作用域，没有变化，变化只是其余的参数都是直接传递给函数的。 function box(num1, num2) {return num1 + num2;}function callBox(num1, num2) {return box.call(this, num1, num2); // 和 apply 区别在于后面的传参}alert(callBox(10,10)); 事实上，传递参数并不是 apply()和 call()方法真正的用武之地；它们经常使用的地方是能够扩展函数赖以运行的作用域。 var color = '红色的'; // 或者 window.color = '红色的';也行var box = {color : '蓝色的'};function sayColor() {alert(this.color);}sayColor(); // 作用域在 windowsayColor.call(this); // 作用域在 windowsayColor.call(window); // 作用域在 windowsayColor.call(box); // 作用域在 box，对象冒充 这个例子是之前作用域理解的例子修改而成，我们可以发现当我们使用 call(box)方法的时候，sayColor()方法的运行环境已经变成了 box 对象里了。 使用 call()或者 apply()来扩充作用域的最大好处，就是对象不需要与方法发生任何耦合关系（耦合，就是互相关联的意思，扩展和维护会发生连锁反应）。也就是说，box 对象和 sayColor()方法之间不会有多余的关联操作，比如 box.sayColor = sayColor;。 本篇文章为转载内容。原文链接：https://blog.csdn.net/gongxifacai_believe/article/details/108286196。 该文由互联网用户投稿提供，文中观点代表作者本人意见，并不代表本站的立场。 作为信息平台，本站仅提供文章转载服务，并不拥有其所有权，也不对文章内容的真实性、准确性和合法性承担责任。 如发现本文存在侵权、违法、违规或事实不符的情况，请及时联系我们，我们将第一时间进行核实并删除相应内容。

...t/luoyang_java/article/details/84953241。 该文由互联网用户投稿提供，文中观点代表作者本人意见，并不代表本站的立场。 作为信息平台，本站仅提供文章转载服务，并不拥有其所有权，也不对文章内容的真实性、准确性和合法性承担责任。 如发现本文存在侵权、违法、违规或事实不符的情况，请及时联系我们，我们将第一时间进行核实并删除相应内容。 1、分布式事务出现场景 场景描述：支付宝转账余额宝 分布式事务必须满足的条件： 1、远程RPC调用，支付宝和余额宝存在接口调用 2、支付宝和余额宝使用不同的数据库 如图： 2、分布式事务解决方案 1、基于数据库XA协议的两段提交 XA协议是数据库支持的一种协议，其核心是一个事务管理器用来统一管理两个分布式数据库，如图 事务管理器负责跟支付宝数据库和余额宝数据库打交道，一旦有一个数据库连接失败，另一个数据库的操作就不会进行，一个数据库操作失败就会导致另一个数据库回滚，只有他们全部成功两个数据库的事务才会提交。 基于XA协议的两段和三段提交是一种严格的安全确认机制，其安全性是非常高的，但是保证安全性的前提是牺牲了性能，这个就是分布式系统里面的CAP理论，做任何架构的前提需要有取舍。所以基于XA协议的分布式事务并发性不高，不适合高并发场景。 2、基于activemq的解决方案 如图： 1、支付宝扣款成功时往message表插入消息 2、message表有message_id(流水id，标识夸系统的一次转账操作),status（confirm，unconfirm） 3、timer扫描message表的unconfirm状态记录往activemq插入消息 4、余额宝收到消息消费消息时先查询message表如果有记录就不处理如果没记录就进行数据库增款操作 5、如果余额宝数据库操作成功往余额宝message表插入消息，表字段跟支付宝message一致 6、如果5操作成功，回调支付宝接口修改message表状态，把unconfirm状态转换成confirm状态 问题描述： 1、支付宝设计message表的目的 如果支付宝往activemq插入消息而余额宝消费消息异常，有可能是消费消息成功而事务操作异常，有可能是网络异常等等不确定因素。如果出现异常而activemq收到了确认消息的信号，这时候activemq中的消息是删除了的，消息丢失了。设置message表就是有一个消息存根，activemq中消息丢失了message表中的消息还在。解决了activemq消息丢失问题 2、余额宝设计message表的目的 当余额宝消费成功并且数据库操作成功时，回调支付宝的消息确认接口，如果回调接口时出现异常导致支付宝状态修改失败还是unconfirm状态，这时候还会被timer扫描到，又会往activemq插入消息，又会被余额宝消费一边，但是这条消息已经消费成功了的只是回调失败而已，所以就需要有一个这样的message表，当余额宝消费时先插入message表，如果message根据message_id能查询到记录就说明之前这条消息被消费过就不再消费只需要回调成功即可，如果查询不到消息就消费这条消息继续数据库操作，数据库操作成功就往message表插入消息。 这样就解决了消息重复消费问题，这也是消费端的幂等操作。 基于消息中间件的分布式事务是最理想的分布式事务解决方案，兼顾了安全性和并发性！ 接下来贴代码： 支付宝代码： @Controller@RequestMapping("/order")public class OrderController {/ @Description TODO @param @return 参数 @return String 返回类型 @throws userID：转账的用户ID amount：转多少钱/@Autowired@Qualifier("activemq")OrderService orderService;@RequestMapping("/transfer")public @ResponseBody String transferAmount(String userId,String messageId, int amount) {try {orderService.updateAmount(amount,messageId, userId);}catch (Exception e) {e.printStackTrace();return "===============================transferAmount failed===================";}return "===============================transferAmount successfull===================";}@RequestMapping("/callback")public String callback(String param) {JSONObject parse = JSONObject.parseObject(param);String respCode = parse.getString("respCode");if(!"OK".equalsIgnoreCase(respCode)) {return null;}try {orderService.updateMessage(param);}catch (Exception e) {e.printStackTrace();return "fail";}return "ok";} } public interface OrderService {public void updateAmount(int amount, String userId,String messageId);public void updateMessage(String param);} @Service("activemq")@Transactional(rollbackFor = Exception.class)public class OrderServiceActivemqImpl implements OrderService {Logger logger = LoggerFactory.getLogger(getClass());@AutowiredJdbcTemplate jdbcTemplate;@AutowiredJmsTemplate jmsTemplate;@Overridepublic void updateAmount(final int amount, final String messageId, final String userId) {String sql = "update account set amount = amount - ?,update_time=now() where user_id = ?";int count = jdbcTemplate.update(sql, new Object[]{amount, userId});if (count == 1) {//插入到消息记录表sql = "insert into message(user_id,message_id,amount,status) values (?,?,?,?)";int row = jdbcTemplate.update(sql,new Object[]{userId,messageId,amount,"unconfirm"});if(row == 1) {//往activemq中插入消息jmsTemplate.send("zg.jack.queue", new MessageCreator() {@Overridepublic Message createMessage(Session session) throws JMSException {com.zhuguang.jack.bean.Message message = new com.zhuguang.jack.bean.Message();message.setAmount(Integer.valueOf(amount));message.setStatus("unconfirm");message.setUserId(userId);message.setMessageId(messageId);return session.createObjectMessage(message);} });} }}@Overridepublic void updateMessage(String param) {JSONObject parse = JSONObject.parseObject(param);String messageId = parse.getString("messageId");String sql = "update message set status = ? where message_id = ?";int count = jdbcTemplate.update(sql,new Object[]{"confirm",messageId});if(count == 1) {logger.info(messageId + " callback successfull");} }} activemq.xml <?xml version="1.0" encoding="UTF-8"?><beans xmlns="http://www.springframework.org/schema/beans"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xmlns:amq="http://activemq.apache.org/schema/core"xmlns:jms="http://www.springframework.org/schema/jms"xmlns:context="http://www.springframework.org/schema/context"xmlns:mvc="http://www.springframework.org/schema/mvc"xsi:schemaLocation="http://www.springframework.org/schema/beanshttp://www.springframework.org/schema/beans/spring-beans-4.1.xsdhttp://www.springframework.org/schema/contexthttp://www.springframework.org/schema/context/spring-context-4.1.xsdhttp://www.springframework.org/schema/mvchttp://www.springframework.org/schema/mvc/spring-mvc-4.1.xsdhttp://www.springframework.org/schema/jmshttp://www.springframework.org/schema/jms/spring-jms-4.1.xsdhttp://activemq.apache.org/schema/corehttp://activemq.apache.org/schema/core/activemq-core-5.12.1.xsd"><context:component-scan base-package="com.zhuguang.jack" /><mvc:annotation-driven /><amq:connectionFactory id="amqConnectionFactory"brokerURL="tcp://192.168.88.131:61616"userName="system"password="manager" /><!-- 配置JMS连接工长 --><bean id="connectionFactory"class="org.springframework.jms.connection.CachingConnectionFactory"><constructor-arg ref="amqConnectionFactory" /><property name="sessionCacheSize" value="100" /></bean><!-- 定义消息队列（Queue） --><bean id="demoQueueDestination" class="org.apache.activemq.command.ActiveMQQueue"><!-- 设置消息队列的名字 --><constructor-arg><value>zg.jack.queue</value></constructor-arg></bean><!-- 配置JMS模板（Queue），Spring提供的JMS工具类，它发送、接收消息。 --><bean id="jmsTemplate" class="org.springframework.jms.core.JmsTemplate"><property name="connectionFactory" ref="connectionFactory" /><property name="defaultDestination" ref="demoQueueDestination" /><property name="receiveTimeout" value="10000" /><!-- true是topic，false是queue，默认是false，此处显示写出false --><property name="pubSubDomain" value="false" /></bean></beans> spring-dispatcher.xml <beans xmlns="http://www.springframework.org/schema/beans"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p"xmlns:context="http://www.springframework.org/schema/context"xmlns:task="http://www.springframework.org/schema/task" xmlns:aop="http://www.springframework.org/schema/aop"xmlns:tx="http://www.springframework.org/schema/tx"xmlns:util="http://www.springframework.org/schema/util" xmlns:mvc="http://www.springframework.org/schema/mvc"xsi:schemaLocation="http://www.springframework.org/schema/utilhttp://www.springframework.org/schema/util/spring-util-3.2.xsdhttp://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.2.xsdhttp://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.2.xsdhttp://www.springframework.org/schema/mvchttp://www.springframework.org/schema/mvc/spring-mvc-3.2.xsdhttp://www.springframework.org/schema/task http://www.springframework.org/schema/task/spring-task-3.0.xsdhttp://www.springframework.org/schema/txhttp://www.springframework.org/schema/tx/spring-tx-3.0.xsdhttp://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.0.xsd"><!-- 引入同文件夹下的redis属性配置文件 --><!-- 解决springMVC响应数据乱码 text/plain就是响应的时候原样返回数据--><import resource="../activemq/activemq.xml"/><!--<context:property-placeholder ignore-unresolvable="true" location="classpath:config/core/core.properties,classpath:config/redis/redis-config.properties" />--><bean id="propertyConfigurerForProject1" class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer"><property name="order" value="1" /><property name="ignoreUnresolvablePlaceholders" value="true" /><property name="location"><value>classpath:config/core/core.properties</value></property></bean><mvc:annotation-driven><mvc:message-converters register-defaults="true"><bean class="org.springframework.http.converter.StringHttpMessageConverter"><property name="supportedMediaTypes" value = "text/plain;charset=UTF-8" /></bean></mvc:message-converters></mvc:annotation-driven><!-- 避免IE执行AJAX时,返回JSON出现下载文件 --><bean id="mappingJacksonHttpMessageConverter" class="org.springframework.http.converter.json.MappingJacksonHttpMessageConverter"><property name="supportedMediaTypes"><list><value>text/html;charset=UTF-8</value></list></property></bean><!-- 开启controller注解支持 --><!-- 注：如果base-package=com.avicit 则注解事务不起作用 TODO 读源码 --><context:component-scan base-package="com.zhuguang"></context:component-scan><mvc:view-controller path="/" view-name="redirect:/index" /><beanclass="org.springframework.web.servlet.mvc.annotation.DefaultAnnotationHandlerMapping" /><bean id="handlerAdapter"class="org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerAdapter"></bean><beanclass="org.springframework.web.servlet.view.ContentNegotiatingViewResolver"><property name="mediaTypes"><map><entry key="json" value="application/json" /><entry key="xml" value="application/xml" /><entry key="html" value="text/html" /></map></property><property name="viewResolvers"><list><bean class="org.springframework.web.servlet.view.BeanNameViewResolver" /><bean class="org.springframework.web.servlet.view.UrlBasedViewResolver"><property name="viewClass" value="org.springframework.web.servlet.view.JstlView" /><property name="prefix" value="/" /><property name="suffix" value=".jsp" /></bean></list></property></bean><!-- 支持上传文件 --> <!-- 控制器异常处理 --><bean id="exceptionResolver"class="org.springframework.web.servlet.handler.SimpleMappingExceptionResolver"><property name="exceptionMappings"><props><prop key="java.lang.Exception">error</prop></props></property></bean><bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource" destroy-method="close"><property name="driverClass"><value>${jdbc.driverClassName}</value></property><property name="jdbcUrl"><value>${jdbc.url}</value></property><property name="user"><value>${jdbc.username}</value></property><property name="password"><value>${jdbc.password}</value></property><property name="minPoolSize" value="10" /><property name="maxPoolSize" value="100" /><property name="maxIdleTime" value="1800" /><property name="acquireIncrement" value="3" /><property name="maxStatements" value="1000" /><property name="initialPoolSize" value="10" /><property name="idleConnectionTestPeriod" value="60" /><property name="acquireRetryAttempts" value="30" /><property name="breakAfterAcquireFailure" value="false" /><property name="testConnectionOnCheckout" value="false" /><property name="acquireRetryDelay"><value>100</value></property></bean><bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate"><property name="dataSource" ref="dataSource"></property></bean><bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager"><property name="dataSource" ref="dataSource"/></bean><tx:annotation-driven transaction-manager="transactionManager" proxy-target-class="true" /><aop:aspectj-autoproxy expose-proxy="true"/></beans> logback.xml <?xml version="1.0" encoding="UTF-8"?><!--scan：当此属性设置为true时，配置文件如果发生改变，将会被重新加载，默认值为true。scanPeriod：设置监测配置文件是否有修改的时间间隔，如果没有给出时间单位，默认单位是毫秒当scan为true时，此属性生效。默认的时间间隔为1分钟。debug：当此属性设置为true时，将打印出logback内部日志信息，实时查看logback运行状态。默认值为false。--><configuration scan="false" scanPeriod="60 seconds" debug="false"><!-- 定义日志的根目录 --><!-- <property name="LOG_HOME" value="/app/log" /> --><!-- 定义日志文件名称 --><property name="appName" value="netty"></property><!-- ch.qos.logback.core.ConsoleAppender 表示控制台输出 --><appender name="stdout" class="ch.qos.logback.core.ConsoleAppender"><Encoding>UTF-8</Encoding><!--日志输出格式：%d表示日期时间，%thread表示线程名，%-5level：级别从左显示5个字符宽度%logger{50} 表示logger名字最长50个字符，否则按照句点分割。 %msg：日志消息，%n是换行符--><encoder><pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger{50} - %msg%n</pattern></encoder></appender><!-- 滚动记录文件，先将日志记录到指定文件，当符合某个条件时，将日志记录到其他文件 --> <appender name="appLogAppender" class="ch.qos.logback.core.rolling.RollingFileAppender"><Encoding>UTF-8</Encoding><!-- 指定日志文件的名称 --> <file>${appName}.log</file><!--当发生滚动时，决定 RollingFileAppender 的行为，涉及文件移动和重命名TimeBasedRollingPolicy： 最常用的滚动策略，它根据时间来制定滚动策略，既负责滚动也负责出发滚动。--><rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy"><!--滚动时产生的文件的存放位置及文件名称 %d{yyyy-MM-dd}：按天进行日志滚动 %i：当文件大小超过maxFileSize时，按照i进行文件滚动--><fileNamePattern>${appName}-%d{yyyy-MM-dd}-%i.log</fileNamePattern><!-- 可选节点，控制保留的归档文件的最大数量，超出数量就删除旧文件。假设设置每天滚动，且maxHistory是365，则只保存最近365天的文件，删除之前的旧文件。注意，删除旧文件是，那些为了归档而创建的目录也会被删除。--><MaxHistory>365</MaxHistory><!-- 当日志文件超过maxFileSize指定的大小是，根据上面提到的%i进行日志文件滚动 注意此处配置SizeBasedTriggeringPolicy是无法实现按文件大小进行滚动的，必须配置timeBasedFileNamingAndTriggeringPolicy--><timeBasedFileNamingAndTriggeringPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedFNATP"><maxFileSize>100MB</maxFileSize></timeBasedFileNamingAndTriggeringPolicy></rollingPolicy><!--日志输出格式：%d表示日期时间，%thread表示线程名，%-5level：级别从左显示5个字符宽度 %logger{50} 表示logger名字最长50个字符，否则按照句点分割。 %msg：日志消息，%n是换行符--> <encoder><pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [ %thread ] - [ %-5level ] [ %logger{50} : %line ] - %msg%n</pattern></encoder></appender><!-- logger主要用于存放日志对象，也可以定义日志类型、级别name：表示匹配的logger类型前缀，也就是包的前半部分level：要记录的日志级别，包括 TRACE < DEBUG < INFO < WARN < ERRORadditivity：作用在于children-logger是否使用 rootLogger配置的appender进行输出，false：表示只用当前logger的appender-ref，true：表示当前logger的appender-ref和rootLogger的appender-ref都有效--><!-- <logger name="edu.hyh" level="info" additivity="true"><appender-ref ref="appLogAppender" /></logger> --><!-- root与logger是父子关系，没有特别定义则默认为root，任何一个类只会和一个logger对应，要么是定义的logger，要么是root，判断的关键在于找到这个logger，然后判断这个logger的appender和level。 --><root level="debug"><appender-ref ref="stdout" /><appender-ref ref="appLogAppender" /></root></configuration> 2、余额宝代码 package com.zhuguang.jack.controller;import com.alibaba.fastjson.JSONObject;import com.zhuguang.jack.service.OrderService;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.stereotype.Controller;import org.springframework.web.bind.annotation.RequestMapping;import org.springframework.web.bind.annotation.ResponseBody;@Controller@RequestMapping("/order")public class OrderController {/ @Description TODO @param @return 参数 @return String 返回类型 @throws 模拟银行转账 userID：转账的用户ID amount：转多少钱/@AutowiredOrderService orderService;@RequestMapping("/transfer")public @ResponseBody String transferAmount(String userId, String amount) {try {orderService.updateAmount(Integer.valueOf(amount), userId);}catch (Exception e) {e.printStackTrace();return "===============================transferAmount failed===================";}return "===============================transferAmount successfull===================";} } 消息监听器 package com.zhuguang.jack.listener;import com.alibaba.fastjson.JSONObject;import com.zhuguang.jack.service.OrderService;import org.slf4j.Logger;import org.slf4j.LoggerFactory;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.http.client.SimpleClientHttpRequestFactory;import org.springframework.stereotype.Service;import org.springframework.transaction.annotation.Transactional;import org.springframework.web.client.RestTemplate;import javax.jms.JMSException;import javax.jms.Message;import javax.jms.MessageListener;import javax.jms.ObjectMessage;@Service("queueMessageListener")public class QueueMessageListener implements MessageListener {private Logger logger = LoggerFactory.getLogger(getClass());@AutowiredOrderService orderService;@Transactional(rollbackFor = Exception.class)@Overridepublic void onMessage(Message message) {if (message instanceof ObjectMessage) {ObjectMessage objectMessage = (ObjectMessage) message;try {com.zhuguang.jack.bean.Message message1 = (com.zhuguang.jack.bean.Message) objectMessage.getObject();String userId = message1.getUserId();int count = orderService.queryMessageCountByUserId(userId);if (count == 0) {orderService.updateAmount(message1.getAmount(), message1.getUserId());orderService.insertMessage(message1.getUserId(), message1.getMessageId(), message1.getAmount(), "ok");} else {logger.info("异常转账");}RestTemplate restTemplate = createRestTemplate();JSONObject jo = new JSONObject();jo.put("messageId", message1.getMessageId());jo.put("respCode", "OK");String url = "http://jack.bank_a.com:8080/alipay/order/callback?param="+ jo.toJSONString();restTemplate.getForObject(url,null);} catch (JMSException e) {e.printStackTrace();throw new RuntimeException("异常");} }}public RestTemplate createRestTemplate() {SimpleClientHttpRequestFactory simpleClientHttpRequestFactory = new SimpleClientHttpRequestFactory();simpleClientHttpRequestFactory.setConnectTimeout(3000);simpleClientHttpRequestFactory.setReadTimeout(2000);return new RestTemplate(simpleClientHttpRequestFactory);} } package com.zhuguang.jack.service;public interface OrderService {public void updateAmount(int amount, String userId);public int queryMessageCountByUserId(String userId);public int insertMessage(String userId,String messageId,int amount,String status);} package com.zhuguang.jack.service;import org.slf4j.Logger;import org.slf4j.LoggerFactory;import org.springframework.beans.factory.annotation.Autowired;import org.springframework.http.client.SimpleClientHttpRequestFactory;import org.springframework.jdbc.core.JdbcTemplate;import org.springframework.stereotype.Service;import org.springframework.transaction.annotation.Transactional;import org.springframework.web.client.RestTemplate;@Service@Transactional(rollbackFor = Exception.class)public class OrderServiceImpl implements OrderService {private Logger logger = LoggerFactory.getLogger(getClass());@AutowiredJdbcTemplate jdbcTemplate;/ 更新数据库表，把账户余额减去amountd/@Overridepublic void updateAmount(int amount, String userId) {//1、农业银行转账3000，也就说农业银行jack账户要减3000String sql = "update account set amount = amount + ?,update_time=now() where user_id = ?";int count = jdbcTemplate.update(sql, new Object[] {amount, userId});if (count != 1) {throw new RuntimeException("订单创建失败，农业银行转账失败！");} }public RestTemplate createRestTemplate() {SimpleClientHttpRequestFactory simpleClientHttpRequestFactory = new SimpleClientHttpRequestFactory();simpleClientHttpRequestFactory.setConnectTimeout(3000);simpleClientHttpRequestFactory.setReadTimeout(2000);return new RestTemplate(simpleClientHttpRequestFactory);}@Overridepublic int queryMessageCountByUserId(String messageId) {String sql = "select count() from message where message_id = ?";int count = jdbcTemplate.queryForInt(sql, new Object[]{messageId});return count;}@Overridepublic int insertMessage(String userId, String message_id,int amount, String status) {String sql = "insert into message(user_id,message_id,amount,status) values(?,?,?)";int count = jdbcTemplate.update(sql, new Object[]{userId, message_id,amount, status});if(count == 1) {logger.info("Ok");}return count;} } activemq.xml <?xml version="1.0" encoding="UTF-8"?><beans xmlns="http://www.springframework.org/schema/beans"xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"xmlns:amq="http://activemq.apache.org/schema/core"xmlns:jms="http://www.springframework.org/schema/jms"xmlns:context="http://www.springframework.org/schema/context"xmlns:mvc="http://www.springframework.org/schema/mvc"xsi:schemaLocation="http://www.springframework.org/schema/beanshttp://www.springframework.org/schema/beans/spring-beans-4.1.xsdhttp://www.springframework.org/schema/contexthttp://www.springframework.org/schema/context/spring-context-4.1.xsdhttp://www.springframework.org/schema/mvchttp://www.springframework.org/schema/mvc/spring-mvc-4.1.xsdhttp://www.springframework.org/schema/jmshttp://www.springframework.org/schema/jms/spring-jms-4.1.xsdhttp://activemq.apache.org/schema/corehttp://activemq.apache.org/schema/core/activemq-core-5.12.1.xsd"><context:component-scan base-package="com.zhuguang.jack" /><mvc:annotation-driven /><amq:connectionFactory id="amqConnectionFactory"brokerURL="tcp://192.168.88.131:61616"userName="system"password="manager" /><!-- 配置JMS连接工长 --><bean id="connectionFactory"class="org.springframework.jms.connection.CachingConnectionFactory"><constructor-arg ref="amqConnectionFactory" /><property name="sessionCacheSize" value="100" /></bean><!-- 定义消息队列（Queue） --><bean id="demoQueueDestination" class="org.apache.activemq.command.ActiveMQQueue"><!-- 设置消息队列的名字 --><constructor-arg><value>zg.jack.queue</value></constructor-arg></bean><!-- 显示注入消息监听容器（Queue），配置连接工厂，监听的目标是demoQueueDestination，监听器是上面定义的监听器 --><bean id="queueListenerContainer"class="org.springframework.jms.listener.DefaultMessageListenerContainer"><property name="connectionFactory" ref="connectionFactory" /><property name="destination" ref="demoQueueDestination" /><property name="messageListener" ref="queueMessageListener" /></bean><!-- 配置JMS模板（Queue），Spring提供的JMS工具类，它发送、接收消息。 --><bean id="jmsTemplate" class="org.springframework.jms.core.JmsTemplate"><property name="connectionFactory" ref="connectionFactory" /><property name="defaultDestination" ref="demoQueueDestination" /><property name="receiveTimeout" value="10000" /><!-- true是topic，false是queue，默认是false，此处显示写出false --><property name="pubSubDomain" value="false" /></bean></beans> OK~~~~~~~~~~~~大功告成！！！， 如果大家觉得满意并且对技术感兴趣请加群：171239762， 纯技术交流群，非诚勿扰。 本篇文章为转载内容。原文链接：https://blog.csdn.net/luoyang_java/article/details/84953241。 该文由互联网用户投稿提供，文中观点代表作者本人意见，并不代表本站的立场。 作为信息平台，本站仅提供文章转载服务，并不拥有其所有权，也不对文章内容的真实性、准确性和合法性承担责任。 如发现本文存在侵权、违法、违规或事实不符的情况，请及时联系我们，我们将第一时间进行核实并删除相应内容。