[Java TreeSet和TreeMap...]的搜索结果

... { // 声明一个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就像个超级灵活、无比顺手的工具箱，让开发者能够轻轻松松解决各种乱七八糟、错综复杂的依赖关系难题，真可谓是个得力小助手。

在了解了如何通过Java的JACOB工具调用中控考勤机SDK进行设备连接后，我们可以进一步关注企业级考勤系统与现代技术融合的最新趋势。近日，多家知名人力资源管理软件提供商推出了基于云服务和人工智能技术的智能考勤解决方案，不仅能够实现传统考勤功能，如记录员工上下班时间、异常考勤提醒等，还能够结合大数据分析提供出勤统计报表、劳动力效能分析等增值服务。 例如，阿里云的人力资源管理系统就集成了先进的面部识别技术，将考勤机与云端数据同步，实现了无接触式的高效打卡体验，并且支持远程办公场景下的虚拟签到。此外，该系统还能与其他业务模块深度集成，为企业决策者提供全面的人力资源视图，助力优化企业运营策略。 深入探讨考勤系统的安全性问题也不容忽视，随着数据隐私保护法规日益严格，如何确保考勤数据的安全存储与传输成为业界焦点。一些厂商开始采用区块链技术，确保考勤信息不可篡改，保障员工隐私权益。 总的来说，随着信息技术的日新月异，考勤系统的开发与应用正不断突破边界，从单一的硬件接入转变为云服务+AI赋能的整体解决方案，为企业提供了更强大、安全且便捷的考勤管理方式。在实际项目开发过程中，理解并掌握类似JACOB这样的中间件工具，对于整合不同平台资源，实现多元化的企业级应用具有重要意义。

...们可以编写一段简单的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的运行机制打成一片后，咱们就能挖出真正管用的解决方案，保证咱的应用程序稳稳当当地跑起来。同时呢，咱们也得明白，在真实的开发过程里头，咱们可不能停下学习和探索的脚步。为啥呢？因为这样才能够更好地对付那些时不时冒出来的挑战和问题嘛，让咱变得更游刃有余。

...的客户端库主要支持 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实现在线协同过滤算法，实时更新用户偏好，提高推荐的准确性和时效性。 4. 数据流上的机器学习 Mahout的Flink接口支持在数据流上执行机器学习任务，如实时异常检测、预测模型更新等。 三、代码示例 构建实时推荐系统 为了更好地理解Mahout的Flink接口如何工作，下面我们将构建一个简单的实时推荐系统。哎呀，这个玩意儿啊，它能根据你过去咋用它的样子，比如你点过啥，买过啥，然后啊，它就能实时给你推东西。就像是个超级贴心的朋友，老记着你的喜好，时不时给你点惊喜！ java import org.apache.flink.api.common.functions.MapFunction; import org.apache.flink.api.java.tuple.Tuple2; import org.apache.flink.streaming.api.datastream.DataStream; import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment; public class RealtimeRecommendationSystem { public static void main(String[] args) throws Exception { // 创建流处理环境 StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment(); // 假设我们有一个实时事件流，包含用户ID和商品ID DataStream> eventStream = env.fromElements( Tuple2.of("user1", "itemA"), Tuple2.of("user2", "itemB"), Tuple2.of("user1", "itemC") ); // 使用Mahout的协同过滤算法进行实时推荐 DataStream> recommendations = eventStream.map(new MapFunction, Tuple2>() { @Override public Tuple2 map(Tuple2 value) { // 这里只是一个示例，实际应用中需要调用具体的协同过滤算法 return new Tuple2<>(value.f0, "recommendedItem"); } }); // 打印输出 recommendations.print(); // 执行任务 env.execute("Realtime Recommendation System"); } } 四、结论 开启数据驱动的未来 通过整合Mahout的机器学习能力和Flink的实时计算能力，开发者能够构建出响应迅速、高效精准的数据分析系统。无论是实时推荐、大规模聚类还是在线协同过滤，这些功能都为数据分析带来了新的可能。哎呀，随着科技这玩意儿越变越厉害，咱们能见到的新鲜事儿也是一波接一波。就像是魔法一样，数据这东西，现在能帮咱们推动业务发展，搞出不少新花样，让咱们的生意越来越红火，创意源源不断。简直就像开了挂一样！

...巴巴开源的一个高性能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与分布式追踪系统的世界里游刃有余。记住，每一次挑战都是成长的机会，勇敢地迎接它们吧！

在学习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的潜能发挥得更淋漓尽致，这样一来，工作效率蹭蹭上涨，用户体验也噌噌提升，妥妥的双赢局面！希望本文能对你有所帮助！

... JSON格式 , JavaScript Object Notation（JSON）是一种轻量级的数据交换格式，易于人阅读和编写，也易于机器解析和生成。在文中，百度返回的下拉词数据即采用JSON格式，包含键值对结构，通过抓取并解析JSON响应内容，可以提取出具体的下拉推荐词信息。 线程池 (concurrent.futures.ThreadPoolExecutor) , 在Python编程中，线程池是一种多线程编程的高效解决方案，通过预先创建一定数量的线程并进行复用，能够减少线程频繁创建销毁带来的开销。文中使用了concurrent.futures.ThreadPoolExecutor来并发处理多个关键词的下拉词数据获取任务，每个关键词的请求作为一个独立的任务提交给线程池，线程池中的空闲线程会自动执行这些任务，从而提高了数据采集效率。 抓包操作 , 在网络编程与数据分析领域中，抓包操作指的是利用网络封包分析软件（如Wireshark、Fiddler等，或浏览器开发者工具）捕获、记录网络传输过程中经过计算机网络接口的所有数据包的过程。在本文的具体情境下，作者通过浏览器开发者工具进行抓包操作，找到了包含百度下拉词数据的HTTP请求，进一步分析了该请求的相关参数和返回结果，以实现自动化数据采集的目标。

...calhost): java.lang.OutOfMemoryError: Java heap space 这段日志信息清晰地指出错误原因（OutOfMemoryError: Java heap space），并提供了关键细节，包括任务编号、所在节点以及错误类型。针对这一问题，可以通过增加Spark集群的内存资源或者优化数据处理逻辑来解决。 五、调试策略与最佳实践 1. 使用日志级别 调整日志级别（如INFO、DEBUG）可以帮助开发者在日志中获取更多详细信息。 2. 定期检查日志 通过自动化工具定期检查日志文件，可以及时发现潜在问题。 3. 利用Spark UI Spark自带的Web UI提供了详细的作业监控界面，直观显示任务状态和性能指标。 4. 错误重试机制 合理配置Spark任务的重试策略，避免因一次失败而影响整体进程。 5. 性能监控工具 集成性能监控工具（如Prometheus、Grafana）有助于实时监控系统性能，预防内存泄漏等严重问题。 六、总结与展望 日志记录是Spark应用程序开发和维护过程中的关键环节。哎呀，你知道吗？程序员们在遇到bug（小错误）的时候，那可是得使出浑身解数了！他们可不是对着电脑屏幕发呆，而是会仔细地分析问题，就像侦探破案一样。找到问题的源头后，他们就开始了他们的“调试大作战”，就像是医生给病人开药一样精准。通过这些努力，他们能优化代码，让程序跑得更顺畅，就像给汽车加了润滑剂，不仅跑得快，还稳当当的。这样，我们的应用就能更加可靠，用户用起来也更舒心啦！哎呀，你懂的，随着咱们每天产生的数据就像自来水一样哗哗流，那处理这些数据的大数据工具就得越来越厉害才行。特别是那些记录我们操作痕迹的日志管理系统，不仅要快得跟闪电一样，操作起来还得像玩手机游戏一样简单，最好还能自己动脑筋分析出点啥有价值的信息来。这样，未来日志记录这事儿就不仅仅是记录，还能帮我们找到问题、优化流程，简直就是一大神器嘛！所以，你看，这发展方向就是越来越智能、好用、高效，让科技真正服务于人，而不是让人被科技牵着鼻子走。 --- 通过本文的探讨，我们不仅学习了如何理解和利用Spark的日志信息来诊断问题，还了解了一些实用的调试技巧和最佳实践。希望这些内容能帮助你更有效地管理你的Spark应用程序，确保其在复杂的数据处理场景下稳定运行。

...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的分布式文件系统（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的功能会越来越强大。我希望你能继续探索更多有趣的话题，一起在这个充满挑战的世界里不断前行！ 加油吧，程序员们！

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

... 和 lpop 可以实现消息队列(队尾进队头出)，但是消费者需要不停地调用 lpop 查看 List 中是否有等待处理的消息(比如写一个 while 循环)。 为了减少通信的消耗，可以 sleep()一段时间再消费，但是会有两个问题: 1、如果生产者生产消息的速度远大于消费者消费消息的速度，List 会占用大量的内存。 2、消息的实时性降低。 list 还提供了一个阻塞的命令:blpop，没有任何元素可以弹出的时候，连接会被阻塞。 基于 list 实现的消息队列，不支持一对多的消息分发。 1.2 发布订阅模式 除了通过 list 实现消息队列之外，Redis 还提供了一组命令实现发布/订阅模式。 这种方式，发送者和接收者没有直接关联(实现了解耦)，接收者也不需要持续尝试获取消息。 1.2.1 订阅频道 首先，我们有很多的频道(channel)，我们也可以把这个频道理解成 queue。订阅者可以订阅一个或者多个频道。消息的发布者(生产者)可以给指定的频道发布消息。只要有消息到达了频道，所有订阅了这个频道的订阅者都会收到这条消息。 需要注意的注意是，发出去的消息不会被持久化，因为它已经从队列里面移除了，所以消费者只能收到它开始订阅这个频道之后发布的消息。 下面我们来看一下发布订阅命令的使用方法。 订阅者订阅频道：可以一次订阅多个，比如这个客户端订阅了 3 个频道。 subscribe channel-1 channel-2 channel-3 发布者可以向指定频道发布消息(并不支持一次向多个频道发送消息): publish channel-1 2673 取消订阅(不能在订阅状态下使用): unsubscribe channel-1 1.2.2 按规则(Pattern)订阅频道 支持 ?和 占位符。? 代表一个字符， 代表 0 个或者多个字符。 消费端 1，关注运动信息: psubscribe sport 消费端 2，关注所有新闻: psubscribe news 消费端 3，关注天气新闻: psubscribe news-weather 生产者，发布 3 条信息 publish news-sport yaoming publish news-music jaychou publish news-weather rain 2、Redis 事务 2.1 为什么要用事务 我们知道 Redis 的单个命令是原子性的(比如 get set mget mset)，如果涉及到多个命令的时候，需要把多个命令作为一个不可分割的处理序列，就需要用到事务。 例如我们之前说的用 setnx 实现分布式锁，我们先 set，然后设置对 key 设置 expire， 防止 del 发生异常的时候锁不会被释放，业务处理完了以后再 del，这三个动作我们就希望它们作为一组命令执行。 Redis 的事务有两个特点: 1、按进入队列的顺序执行。 2、不会受到其他客户端的请求的影响。 Redis 的事务涉及到四个命令:multi(开启事务)，exec(执行事务)，discard (取消事务)，watch(监视) 2.2 事务的用法 案例场景:tom 和 mic 各有 1000 元，tom 需要向 mic 转账 100 元。tom 的账户余额减少 100 元，mic 的账户余额增加 100 元。 通过 multi 的命令开启事务。事务不能嵌套，多个 multi 命令效果一样。 multi 执行后，客户端可以继续向服务器发送任意多条命令，这些命令不会立即被执行，而是被放到一个队列中，当 exec 命令被调用时，所有队列中的命令才会被执行。 通过 exec 的命令执行事务。如果没有执行 exec，所有的命令都不会被执行。如果中途不想执行事务了，怎么办? 可以调用 discard 可以清空事务队列，放弃执行。 2.3 watch命令 在 Redis 中还提供了一个 watch 命令。 它可以为 Redis 事务提供 CAS 乐观锁行为(Check and Set / Compare and Swap)，也就是多个线程更新变量的时候，会跟原值做比较，只有它没有被其他线程修改的情况下，才更新成新的值。 我们可以用 watch 监视一个或者多个 key，如果开启事务之后，至少有一个被监视 key 键在 exec 执行之前被修改了，那么整个事务都会被取消(key 提前过期除外)。可以用 unwatch 取消。 2.4 事务可能遇到的问题 我们把事务执行遇到的问题分成两种，一种是在执行 exec 之前发生错误，一种是在执行 exec 之后发生错误。 2.4.1 在执行 exec 之前发生错误 比如：入队的命令存在语法错误，包括参数数量，参数名等等(编译器错误)。 在这种情况下事务会被拒绝执行，也就是队列中所有的命令都不会得到执行。 2.4.2 在执行 exec 之后发生错误 比如，类型错误，比如对 String 使用了 Hash 的命令，这是一种运行时错误。 最后我们发现 set k1 1 的命令是成功的，也就是在这种发生了运行时异常的情况下， 只有错误的命令没有被执行，但是其他命令没有受到影响。 这个显然不符合我们对原子性的定义，也就是我们没办法用 Redis 的这种事务机制来实现原子性，保证数据的一致。 3、Lua脚本 Lua/ˈluə/是一种轻量级脚本语言，它是用 C 语言编写的，跟数据的存储过程有点类似。 使用 Lua 脚本来执行 Redis 命令的好处: 1、一次发送多个命令，减少网络开销。 2、Redis 会将整个脚本作为一个整体执行，不会被其他请求打断，保持原子性。 3、对于复杂的组合命令，我们可以放在文件中，可以实现程序之间的命令集复用。 3.1 在Redis中调用Lua脚本 使用 eval /ɪ’væl/ 方法，语法格式: redis> eval lua-script key-num [key1 key2 key3 ....] [value1 value2 value3 ....] eval代表执行Lua语言的命令。 lua-script代表Lua语言脚本内容。 key-num表示参数中有多少个key，需要注意的是Redis中key是从1开始的，如果没有key的参数，那么写0。 [key1key2key3…]是key作为参数传递给Lua语言，也可以不填，但是需要和key-num的个数对应起来。 [value1 value2 value3 …]这些参数传递给 Lua 语言，它们是可填可不填的。 示例，返回一个字符串，0 个参数: redis> eval "return 'Hello World'" 0 3.2 在Lua脚本中调用Redis命令 使用 redis.call(command, key [param1, param2…])进行操作。语法格式: redis> eval "redis.call('set',KEYS[1],ARGV[1])" 1 lua-key lua-value command是命令，包括set、get、del等。 key是被操作的键。 param1,param2…代表给key的参数。 注意跟 Java 不一样，定义只有形参，调用只有实参。 Lua 是在调用时用 key 表示形参，argv 表示参数值(实参)。 3.2.1 设置键值对 在 Redis 中调用 Lua 脚本执行 Redis 命令 redis> eval "return redis.call('set',KEYS[1],ARGV[1])" 1 gupao 2673 redis> get gupao 以上命令等价于 set gupao 2673。 在 redis-cli 中直接写 Lua 脚本不够方便，也不能实现编辑和复用，通常我们会把脚本放在文件里面，然后执行这个文件。 3.2.2 在 Redis 中调用 Lua 脚本文件中的命令，操作 Redis 创建 Lua 脚本文件: cd /usr/local/soft/redis5.0.5/src vim gupao.lua Lua 脚本内容，先设置，再取值: cd /usr/local/soft/redis5.0.5/src redis-cli --eval gupao.lua 0 得到返回值: root@localhost src] redis-cli --eval gupao.lua 0 "lua666" 3.2.3 案例:对 IP 进行限流 需求：在 X 秒内只能访问 Y 次。 设计思路：用 key 记录 IP，用 value 记录访问次数。 拿到 IP 以后，对 IP+1。如果是第一次访问，对 key 设置过期时间(参数 1)。否则判断次数，超过限定的次数(参数 2)，返回 0。如果没有超过次数则返回 1。超过时间， key 过期之后，可以再次访问。 KEY[1]是 IP， ARGV[1]是过期时间 X，ARGV[2]是限制访问的次数 Y。 -- ip_limit.lua-- IP 限流，对某个 IP 频率进行限制 ，6 秒钟访问 10 次 local num=redis.call('incr',KEYS[1])if tonumber(num)==1 thenredis.call('expire',KEYS[1],ARGV[1])return 1elseif tonumber(num)>tonumber(ARGV[2]) thenreturn 0 elsereturn 1 end 6 秒钟内限制访问 10 次，调用测试(连续调用 10 次): ./redis-cli --eval "ip_limit.lua" app:ip:limit:192.168.8.111 , 6 10 app:ip:limit:192.168.8.111 是 key 值 ，后面是参数值，中间要加上一个空格和一个逗号，再加上一个空格 。 即:./redis-cli –eval [lua 脚本] [key…]空格,空格[args…] 多个参数之间用一个空格分割 。 代码:LuaTest.java 3.2.4 缓存 Lua 脚本 为什么要缓存 在脚本比较长的情况下，如果每次调用脚本都需要把整个脚本传给 Redis 服务端， 会产生比较大的网络开销。为了解决这个问题，Redis 提供了 EVALSHA 命令，允许开发者通过脚本内容的 SHA1 摘要来执行脚本。 如何缓存 Redis 在执行 script load 命令时会计算脚本的 SHA1 摘要并记录在脚本缓存中，执行 EVALSHA 命令时 Redis 会根据提供的摘要从脚本缓存中查找对应的脚本内容，如果找到了则执行脚本，否则会返回错误:“NOSCRIPT No matching script. Please use EVAL.” 127.0.0.1:6379> script load "return 'Hello World'" "470877a599ac74fbfda41caa908de682c5fc7d4b"127.0.0.1:6379> evalsha "470877a599ac74fbfda41caa908de682c5fc7d4b" 0 "Hello World" 3.2.5 自乘案例 Redis 有 incrby 这样的自增命令，但是没有自乘，比如乘以 3，乘以 5。我们可以写一个自乘的运算，让它乘以后面的参数： local curVal = redis.call("get", KEYS[1]) if curVal == false thencurVal = 0 elsecurVal = tonumber(curVal)endcurVal = curVal tonumber(ARGV[1]) redis.call("set", KEYS[1], curVal) return curVal 把这个脚本变成单行，语句之间使用分号隔开 local curVal = redis.call("get", KEYS[1]); if curVal == false then curVal = 0 else curVal = tonumber(curVal) end; curVal = curVal tonumber(ARGV[1]); redis.call("set", KEYS[1], curVal); return curVal script load ‘命令’ 127.0.0.1:6379> script load 'local curVal = redis.call("get", KEYS[1]); if curVal == false then curVal = 0 else curVal = tonumber(curVal) end; curVal = curVal tonumber(ARGV[1]); redis.call("set", KEYS[1], curVal); return curVal' "be4f93d8a5379e5e5b768a74e77c8a4eb0434441" 调用: 127.0.0.1:6379> set num 2OK127.0.0.1:6379> evalsha be4f93d8a5379e5e5b768a74e77c8a4eb0434441 1 num 6 (integer) 12 3.2.6 脚本超时 Redis 的指令执行本身是单线程的，这个线程还要执行客户端的 Lua 脚本，如果 Lua 脚本执行超时或者陷入了死循环，是不是没有办法为客户端提供服务了呢? eval 'while(true) do end' 0 为了防止某个脚本执行时间过长导致 Redis 无法提供服务，Redis 提供了 lua-time-limit 参数限制脚本的最长运行时间，默认为 5 秒钟。 lua-time-limit 5000(redis.conf 配置文件中) 当脚本运行时间超过这一限制后，Redis 将开始接受其他命令但不会执行(以确保脚本的原子性，因为此时脚本并没有被终止)，而是会返回“BUSY”错误。 Redis 提供了一个 script kill 的命令来中止脚本的执行。新开一个客户端: script kill 如果当前执行的 Lua 脚本对 Redis 的数据进行了修改(SET、DEL 等)，那么通过 script kill 命令是不能终止脚本运行的。 127.0.0.1:6379> eval "redis.call('set','gupao','666') while true do end" 0 因为要保证脚本运行的原子性，如果脚本执行了一部分终止，那就违背了脚本原子性的要求。最终要保证脚本要么都执行，要么都不执行。 127.0.0.1:6379> script kill(error) UNKILLABLE Sorry the script already executed write commands against the dataset. You can either wait the scripttermination or kill the server in a hard way using the SHUTDOWN NOSAVE command. 遇到这种情况，只能通过 shutdown nosave 命令来强行终止 redis。 shutdown nosave 和 shutdown 的区别在于 shutdown nosave 不会进行持久化操作，意味着发生在上一次快照后的数据库修改都会丢失。 4、Redis 为什么这么快? 4.1 Redis到底有多快？ 根据官方的数据，Redis 的 QPS 可以达到 10 万左右(每秒请求数)。 4.2 Redis为什么这么快? 总结:1)纯内存结构、2)单线程、3)多路复用 4.2.1 内存 KV 结构的内存数据库，时间复杂度 O(1)。 第二个，要实现这么高的并发性能，是不是要创建非常多的线程? 恰恰相反，Redis 是单线程的。 4.2.2 单线程 单线程有什么好处呢? 1、没有创建线程、销毁线程带来的消耗 2、避免了上线文切换导致的 CPU 消耗 3、避免了线程之间带来的竞争问题，例如加锁释放锁死锁等等 4.2.3 异步非阻塞 异步非阻塞 I/O，多路复用处理并发连接。 4.3 Redis为什么是单线程的? 不是白白浪费了 CPU 的资源吗? 因为单线程已经够用了，CPU 不是 redis 的瓶颈。Redis 的瓶颈最有可能是机器内存或者网络带宽。既然单线程容易实现，而且 CPU 不会成为瓶颈，那就顺理成章地采用单线程的方案了。 4.4 单线程为什么这么快? 因为 Redis 是基于内存的操作，我们先从内存开始说起。 4.4.1 虚拟存储器(虚拟内存 Vitual Memory) 名词解释:主存:内存;辅存:磁盘(硬盘) 计算机主存(内存)可看作一个由 M 个连续的字节大小的单元组成的数组，每个字节有一个唯一的地址，这个地址叫做物理地址(PA)。早期的计算机中，如果 CPU 需要内存，使用物理寻址，直接访问主存储器。 这种方式有几个弊端: 1、在多用户多任务操作系统中，所有的进程共享主存，如果每个进程都独占一块物理地址空间，主存很快就会被用完。我们希望在不同的时刻，不同的进程可以共用同一块物理地址空间。 2、如果所有进程都是直接访问物理内存，那么一个进程就可以修改其他进程的内存数据，导致物理地址空间被破坏，程序运行就会出现异常。 为了解决这些问题，我们就想了一个办法，在 CPU 和主存之间增加一个中间层。CPU 不再使用物理地址访问，而是访问一个虚拟地址，由这个中间层把地址转换成物理地址，最终获得数据。这个中间层就叫做虚拟存储器(Virtual Memory)。 具体的操作如下所示: 在每一个进程开始创建的时候，都会分配一段虚拟地址，然后通过虚拟地址和物理地址的映射来获取真实数据，这样进程就不会直接接触到物理地址，甚至不知道自己调用的哪块物理地址的数据。 目前，大多数操作系统都使用了虚拟内存，如 Windows 系统的虚拟内存、Linux 系统的交换空间等等。Windows 的虚拟内存(pagefile.sys)是磁盘空间的一部分。 在 32 位的系统上，虚拟地址空间大小是 2^32bit=4G。在 64 位系统上，最大虚拟地址空间大小是多少? 是不是 2^64bit=10241014TB=1024PB=16EB?实际上没有用到 64 位，因为用不到这么大的空间，而且会造成很大的系统开销。Linux 一般用低 48 位来表示虚拟地址空间，也就是 2^48bit=256T。 cat /proc/cpuinfo address sizes : 40 bits physical, 48 bits virtual 实际的物理内存可能远远小于虚拟内存的大小。 总结：引入虚拟内存，可以提供更大的地址空间，并且地址空间是连续的，使得程序编写、链接更加简单。并且可以对物理内存进行隔离，不同的进程操作互不影响。还可以通过把同一块物理内存映射到不同的虚拟地址空间实现内存共享。 4.4.2 用户空间和内核空间 为了避免用户进程直接操作内核，保证内核安全，操作系统将虚拟内存划分为两部分，一部分是内核空间(Kernel-space)/ˈkɜːnl /，一部分是用户空间(User-space)。 内核是操作系统的核心，独立于普通的应用程序，可以访问受保护的内存空间，也有访问底层硬件设备的权限。 内核空间中存放的是内核代码和数据，而进程的用户空间中存放的是用户程序的代码和数据。不管是内核空间还是用户空间，它们都处于虚拟空间中，都是对物理地址的映射。 在 Linux 系统中, 内核进程和用户进程所占的虚拟内存比例是 1:3。 当进程运行在内核空间时就处于内核态，而进程运行在用户空间时则处于用户态。 进程在内核空间以执行任意命令，调用系统的一切资源;在用户空间只能执行简单的运算，不能直接调用系统资源，必须通过系统接口(又称 system call)，才能向内核发出指令。 top 命令: us 代表 CPU 消耗在 User space 的时间百分比; sy 代表 CPU 消耗在 Kernel space 的时间百分比。 4.4.3 进程切换(上下文切换) 多任务操作系统是怎么实现运行远大于 CPU 数量的任务个数的? 当然，这些任务实际上并不是真的在同时运行，而是因为系统通过时间片分片算法，在很短的时间内，将 CPU 轮流分配给它们，造成多任务同时运行的错觉。 为了控制进程的执行，内核必须有能力挂起正在 CPU 上运行的进程，并恢复以前挂起的某个进程的执行。这种行为被称为进程切换。 什么叫上下文? 在每个任务运行前，CPU 都需要知道任务从哪里加载、又从哪里开始运行，也就是说，需要系统事先帮它设置好 CPU 寄存器和程序计数器(ProgramCounter)，这个叫做 CPU 的上下文。 而这些保存下来的上下文，会存储在系统内核中，并在任务重新调度执行时再次加载进来。这样就能保证任务原来的状态不受影响，让任务看起来还是连续运行。 在切换上下文的时候，需要完成一系列的工作，这是一个很消耗资源的操作。 4.4.4 进程的阻塞 正在运行的进程由于提出系统服务请求(如 I/O 操作)，但因为某种原因未得到操作系统的立即响应，该进程只能把自己变成阻塞状态，等待相应的事件出现后才被唤醒。 进程在阻塞状态不占用 CPU 资源。 4.4.5 文件描述符 FD Linux 系统将所有设备都当作文件来处理，而 Linux 用文件描述符来标识每个文件对象。 文件描述符(File Descriptor)是内核为了高效管理已被打开的文件所创建的索引，用于指向被打开的文件，所有执行 I/O 操作的系统调用都通过文件描述符;文件描述符是一个简单的非负整数，用以表明每个被进程打开的文件。 Linux 系统里面有三个标准文件描述符。 0:标准输入(键盘); 1:标准输出(显示器); 2:标准错误输出(显示器)。 4.4.6 传统 I/O 数据拷贝 以读操作为例: 当应用程序执行 read 系统调用读取文件描述符(FD)的时候，如果这块数据已经存在于用户进程的页内存中，就直接从内存中读取数据。如果数据不存在，则先将数据从磁盘加载数据到内核缓冲区中，再从内核缓冲区拷贝到用户进程的页内存中。(两次拷贝，两次 user 和 kernel 的上下文切换)。 I/O 的阻塞到底阻塞在哪里? 4.4.7 Blocking I/O 当使用 read 或 write 对某个文件描述符进行过读写时，如果当前 FD 不可读，系统就不会对其他的操作做出响应。从设备复制数据到内核缓冲区是阻塞的，从内核缓冲区拷贝到用户空间，也是阻塞的，直到 copy complete，内核返回结果，用户进程才解除 block 的状态。 为了解决阻塞的问题，我们有几个思路。 1、在服务端创建多个线程或者使用线程池，但是在高并发的情况下需要的线程会很多，系统无法承受，而且创建和释放线程都需要消耗资源。 2、由请求方定期轮询，在数据准备完毕后再从内核缓存缓冲区复制数据到用户空间 (非阻塞式 I/O)，这种方式会存在一定的延迟。 能不能用一个线程处理多个客户端请求? 4.4.8 I/O 多路复用(I/O Multiplexing) I/O 指的是网络 I/O。 多路指的是多个 TCP 连接(Socket 或 Channel)。 复用指的是复用一个或多个线程。它的基本原理就是不再由应用程序自己监视连接，而是由内核替应用程序监视文件描述符。 客户端在操作的时候，会产生具有不同事件类型的 socket。在服务端，I/O 多路复用程序(I/O Multiplexing Module)会把消息放入队列中，然后通过文件事件分派器(File event Dispatcher)，转发到不同的事件处理器中。 多路复用有很多的实现，以 select 为例，当用户进程调用了多路复用器，进程会被阻塞。内核会监视多路复用器负责的所有 socket，当任何一个 socket 的数据准备好了，多路复用器就会返回。这时候用户进程再调用 read 操作，把数据从内核缓冲区拷贝到用户空间。 所以，I/O 多路复用的特点是通过一种机制一个进程能同时等待多个文件描述符，而这些文件描述符(套接字描述符)其中的任意一个进入读就绪(readable)状态，select() 函数就可以返回。 Redis 的多路复用， 提供了 select, epoll, evport, kqueue 几种选择，在编译的时 候来选择一种。 evport 是 Solaris 系统内核提供支持的; epoll 是 LINUX 系统内核提供支持的; kqueue 是 Mac 系统提供支持的; select 是 POSIX 提供的，一般的操作系统都有支撑(保底方案); 源码 ae_epoll.c、ae_select.c、ae_kqueue.c、ae_evport.c 5、内存回收 Reids 所有的数据都是存储在内存中的，在某些情况下需要对占用的内存空间进行回 收。内存回收主要分为两类，一类是 key 过期，一类是内存使用达到上限(max_memory) 触发内存淘汰。 5.1 过期策略 要实现 key 过期，我们有几种思路。 5.1.1 定时过期(主动淘汰) 每个设置过期时间的 key 都需要创建一个定时器，到过期时间就会立即清除。该策略可以立即清除过期的数据，对内存很友好;但是会占用大量的 CPU 资源去处理过期的 数据，从而影响缓存的响应时间和吞吐量。 5.1.2 惰性过期(被动淘汰) 只有当访问一个 key 时，才会判断该 key 是否已过期，过期则清除。该策略可以最大化地节省 CPU 资源，却对内存非常不友好。极端情况可能出现大量的过期 key 没有再次被访问，从而不会被清除，占用大量内存。 例如 String，在 getCommand 里面会调用 expireIfNeeded server.c expireIfNeeded(redisDb db, robj key) 第二种情况，每次写入 key 时，发现内存不够，调用 activeExpireCycle 释放一部分内存。 expire.c activeExpireCycle(int type) 5.1.3 定期过期 源码:server.h typedef struct redisDb { dict dict; / 所有的键值对 /dict expires; / 设置了过期时间的键值对 /dict blocking_keys; dict ready_keys; dict watched_keys; int id;long long avg_ttl;list defrag_later; } redisDb; 每隔一定的时间，会扫描一定数量的数据库的 expires 字典中一定数量的 key，并清除其中已过期的 key。该策略是前两者的一个折中方案。通过调整定时扫描的时间间隔和每次扫描的限定耗时，可以在不同情况下使得 CPU 和内存资源达到最优的平衡效果。 Redis 中同时使用了惰性过期和定期过期两种过期策略。 5.2 淘汰策略 Redis 的内存淘汰策略，是指当内存使用达到最大内存极限时，需要使用淘汰算法来决定清理掉哪些数据，以保证新数据的存入。 5.2.1 最大内存设置 redis.conf 参数配置: maxmemory <bytes> 如果不设置 maxmemory 或者设置为 0，64 位系统不限制内存，32 位系统最多使用 3GB 内存。 动态修改: redis> config set maxmemory 2GB 到达最大内存以后怎么办? 5.2.2 淘汰策略 https://redis.io/topics/lru-cache redis.conf maxmemory-policy noeviction 先从算法来看: LRU，Least Recently Used:最近最少使用。判断最近被使用的时间，目前最远的数据优先被淘汰。 LFU，Least Frequently Used，最不常用，4.0 版本新增。 random，随机删除。 如果没有符合前提条件的 key 被淘汰，那么 volatile-lru、volatile-random、 volatile-ttl 相当于 noeviction(不做内存回收)。 动态修改淘汰策略: redis> config set maxmemory-policy volatile-lru 建议使用 volatile-lru，在保证正常服务的情况下，优先删除最近最少使用的 key。 5.2.3 LRU 淘汰原理 问题：如果基于传统 LRU 算法实现 Redis LRU 会有什么问题? 需要额外的数据结构存储，消耗内存。 Redis LRU 对传统的 LRU 算法进行了改良，通过随机采样来调整算法的精度。如果淘汰策略是 LRU，则根据配置的采样值 maxmemory_samples(默认是 5 个), 随机从数据库中选择 m 个 key, 淘汰其中热度最低的 key 对应的缓存数据。所以采样参数m配置的数值越大, 就越能精确的查找到待淘汰的缓存数据,但是也消耗更多的CPU计算,执行效率降低。 问题：如何找出热度最低的数据? Redis 中所有对象结构都有一个 lru 字段, 且使用了 unsigned 的低 24 位，这个字段用来记录对象的热度。对象被创建时会记录 lru 值。在被访问的时候也会更新 lru 的值。 但是不是获取系统当前的时间戳，而是设置为全局变量 server.lruclock 的值。 源码：server.h typedef struct redisObject {unsigned type:4;unsigned encoding:4;unsigned lru:LRU_BITS;int refcount;void ptr; } robj; server.lruclock 的值怎么来的? Redis 中有个定时处理的函数 serverCron，默认每 100 毫秒调用函数 updateCachedTime 更新一次全局变量的 server.lruclock 的值，它记录的是当前 unix 时间戳。 源码:server.c void updateCachedTime(void) { time_t unixtime = time(NULL); atomicSet(server.unixtime,unixtime); server.mstime = mstime();​struct tm tm; localtime_r(&server.unixtime,&tm);server.daylight_active = tm.tm_isdst; } 问题:为什么不获取精确的时间而是放在全局变量中?不会有延迟的问题吗? 这样函数 lookupKey 中更新数据的 lru 热度值时,就不用每次调用系统函数 time，可以提高执行效率。 OK，当对象里面已经有了 LRU 字段的值，就可以评估对象的热度了。 函数 estimateObjectIdleTime 评估指定对象的 lru 热度，思想就是对象的 lru 值和全局的 server.lruclock 的差值越大(越久没有得到更新)，该对象热度越低。 源码 evict.c / Given an object returns the min number of milliseconds the object was never requested, using an approximated LRU algorithm. /unsigned long long estimateObjectIdleTime(robj o) {unsigned long long lruclock = LRU_CLOCK(); if (lruclock >= o->lru) {return (lruclock - o->lru) LRU_CLOCK_RESOLUTION; } else {return (lruclock + (LRU_CLOCK_MAX - o->lru)) LRU_CLOCK_RESOLUTION;} } server.lruclock 只有 24 位，按秒为单位来表示才能存储 194 天。当超过 24bit 能表 示的最大时间的时候，它会从头开始计算。 server.h define LRU_CLOCK_MAX ((1<<LRU_BITS)-1) / Max value of obj->lru / 在这种情况下，可能会出现对象的 lru 大于 server.lruclock 的情况，如果这种情况 出现那么就两个相加而不是相减来求最久的 key。 为什么不用常规的哈希表+双向链表的方式实现?需要额外的数据结构，消耗资源。而 Redis LRU 算法在 sample 为 10 的情况下，已经能接近传统 LRU 算法了。 问题:除了消耗资源之外，传统 LRU 还有什么问题? 如图，假设 A 在 10 秒内被访问了 5 次，而 B 在 10 秒内被访问了 3 次。因为 B 最后一次被访问的时间比 A 要晚，在同等的情况下，A 反而先被回收。 问题:要实现基于访问频率的淘汰机制，怎么做? 5.2.4 LFU server.h typedef struct redisObject {unsigned type:4;unsigned encoding:4;unsigned lru:LRU_BITS;int refcount;void ptr; } robj; 当这 24 bits 用作 LFU 时，其被分为两部分: 高 16 位用来记录访问时间(单位为分钟，ldt，last decrement time) 低 8 位用来记录访问频率，简称 counter(logc，logistic counter) counter 是用基于概率的对数计数器实现的，8 位可以表示百万次的访问频率。 对象被读写的时候，lfu 的值会被更新。 db.c——lookupKey void updateLFU(robj val) {unsigned long counter = LFUDecrAndReturn(val); counter = LFULogIncr(counter);val->lru = (LFUGetTimeInMinutes()<<8) | counter;} 增长的速率由，lfu-log-factor 越大，counter 增长的越慢 redis.conf 配置文件。 lfu-log-factor 10 如果计数器只会递增不会递减，也不能体现对象的热度。没有被访问的时候，计数器怎么递减呢? 减少的值由衰减因子 lfu-decay-time(分钟)来控制，如果值是 1 的话，N 分钟没有访问就要减少 N。 redis.conf 配置文件 lfu-decay-time 1 6、持久化机制 https://redis.io/topics/persistence Redis 速度快，很大一部分原因是因为它所有的数据都存储在内存中。如果断电或者宕机，都会导致内存中的数据丢失。为了实现重启后数据不丢失，Redis 提供了两种持久化的方案，一种是 RDB 快照(Redis DataBase)，一种是 AOF(Append Only File)。 6.1 RDB RDB 是 Redis 默认的持久化方案。当满足一定条件的时候，会把当前内存中的数据写入磁盘，生成一个快照文件 dump.rdb。Redis 重启会通过加载 dump.rdb 文件恢复数据。 什么时候写入 rdb 文件? 6.1.1 RDB 触发 1、自动触发 a)配置规则触发。 redis.conf， SNAPSHOTTING，其中定义了触发把数据保存到磁盘的触发频率。 如果不需要 RDB 方案，注释 save 或者配置成空字符串""。 save 900 1 900 秒内至少有一个 key 被修改(包括添加) save 300 10 400 秒内至少有 10 个 key 被修改save 60 10000 60 秒内至少有 10000 个 key 被修改 注意上面的配置是不冲突的，只要满足任意一个都会触发。 RDB 文件位置和目录: 文件路径，dir ./ 文件名称dbfilename dump.rdb 是否是LZF压缩rdb文件 rdbcompression yes 开启数据校验 rdbchecksum yes 问题：为什么停止 Redis 服务的时候没有 save，重启数据还在? RDB 还有两种触发方式: b)shutdown 触发，保证服务器正常关闭。 c)flushall，RDB 文件是空的，没什么意义(删掉 dump.rdb 演示一下)。 2、手动触发 如果我们需要重启服务或者迁移数据，这个时候就需要手动触 RDB 快照保存。Redis 提供了两条命令: a)save save 在生成快照的时候会阻塞当前 Redis 服务器， Redis 不能处理其他命令。如果内存中的数据比较多，会造成 Redis 长时间的阻塞。生产环境不建议使用这个命令。 为了解决这个问题，Redis 提供了第二种方式。 执行 bgsave 时，Redis 会在后台异步进行快照操作，快照同时还可以响应客户端请求。 具体操作是 Redis 进程执行 fork 操作创建子进程(copy-on-write)，RDB 持久化过程由子进程负责，完成后自动结束。它不会记录 fork 之后后续的命令。阻塞只发生在 fork 阶段，一般时间很短。 用 lastsave 命令可以查看最近一次成功生成快照的时间。 6.1.2 RDB 数据的恢复(演示) 1、shutdown 持久化添加键值 添加键值 redis> set k1 1 redis> set k2 2 redis> set k3 3 redis> set k4 4 redis> set k5 5 停服务器，触发 save redis> shutdown 备份 dump.rdb 文件 cp dump.rdb dump.rdb.bak 启动服务器 /usr/local/soft/redis-5.0.5/src/redis-server /usr/local/soft/redis-5.0.5/redis.conf 啥都没有: redis> keys 3、通过备份文件恢复数据停服务器 redis> shutdown 重命名备份文件 mv dump.rdb.bak dump.rdb 启动服务器 /usr/local/soft/redis-5.0.5/src/redis-server /usr/local/soft/redis-5.0.5/redis.conf 查看数据 redis> keys 6.1.3 RDB 文件的优势和劣势 一、优势 1.RDB 是一个非常紧凑(compact)的文件，它保存了 redis 在某个时间点上的数据集。这种文件非常适合用于进行备份和灾难恢复。 2.生成 RDB 文件的时候，redis 主进程会 fork()一个子进程来处理所有保存工作，主进程不需要进行任何磁盘 IO 操作。 3.RDB 在恢复大数据集时的速度比 AOF 的恢复速度要快。 二、劣势 1、RDB 方式数据没办法做到实时持久化/秒级持久化。因为 bgsave 每次运行都要执行 fork 操作创建子进程，频繁执行成本过高。 2、在一定间隔时间做一次备份，所以如果 redis 意外 down 掉的话，就会丢失最后一次快照之后的所有修改(数据有丢失)。 如果数据相对来说比较重要，希望将损失降到最小，则可以使用 AOF 方式进行持久化。 6.2 AOF Append Only File AOF:Redis 默认不开启。AOF 采用日志的形式来记录每个写操作，并追加到文件中。开启后，执行更改 Redis 数据的命令时，就会把命令写入到 AOF 文件中。 Redis 重启时会根据日志文件的内容把写指令从前到后执行一次以完成数据的恢复工作。 6.2.1 AOF 配置 配置文件 redis.conf 开关appendonly no 文件名appendfilename "appendonly.aof" AOF 文件的内容(vim 查看): 问题：数据都是实时持久化到磁盘吗? 由于操作系统的缓存机制，AOF 数据并没有真正地写入硬盘，而是进入了系统的硬盘缓存。什么时候把缓冲区的内容写入到 AOF 文件? 问题:文件越来越大，怎么办? 由于 AOF 持久化是 Redis 不断将写命令记录到 AOF 文件中，随着 Redis 不断的进行，AOF 的文件会越来越大，文件越大，占用服务器内存越大以及 AOF 恢复要求时间越长。 例如 set xxx 666，执行 1000 次，结果都是 xxx=666。 为了解决这个问题，Redis 新增了重写机制，当 AOF 文件的大小超过所设定的阈值时，Redis 就会启动 AOF 文件的内容压缩，只保留可以恢复数据的最小指令集。 可以使用命令 bgrewriteaof 来重写。 AOF 文件重写并不是对原文件进行重新整理，而是直接读取服务器现有的键值对，然后用一条命令去代替之前记录这个键值对的多条命令，生成一个新的文件后去替换原来的 AOF 文件。 重写触发机制 auto-aof-rewrite-percentage 100 auto-aof-rewrite-min-size 64mb 问题:重写过程中，AOF 文件被更改了怎么办? 另外有两个与 AOF 相关的参数: 6.2.2 AOF 数据恢复 重启 Redis 之后就会进行 AOF 文件的恢复。 6.2.3 AOF 优势与劣势 优点: 1、AOF 持久化的方法提供了多种的同步频率，即使使用默认的同步频率每秒同步一次，Redis 最多也就丢失 1 秒的数据而已。 缺点: 1、对于具有相同数据的的 Redis，AOF 文件通常会比 RDB 文件体积更大(RDB 存的是数据快照)。 2、虽然 AOF 提供了多种同步的频率，默认情况下，每秒同步一次的频率也具有较高的性能。在高并发的情况下，RDB 比 AOF 具好更好的性能保证。 6.3 两种方案比较 那么对于 AOF 和 RDB 两种持久化方式，我们应该如何选择呢? 如果可以忍受一小段时间内数据的丢失，毫无疑问使用 RDB 是最好的，定时生成 RDB 快照(snapshot)非常便于进行数据库备份， 并且 RDB 恢复数据集的速度也要比 AOF 恢复的速度要快。 否则就使用 AOF 重写。但是一般情况下建议不要单独使用某一种持久化机制，而是应该两种一起用，在这种情况下,当 redis 重启的时候会优先载入 AOF 文件来恢复原始的数据，因为在通常情况下 AOF 文件保存的数据集要比 RDB 文件保存的数据集要完整。 本篇文章为转载内容。原文链接：https://blog.csdn.net/zhoutaochun/article/details/120075092。 该文由互联网用户投稿提供，文中观点代表作者本人意见，并不代表本站的立场。 作为信息平台，本站仅提供文章转载服务，并不拥有其所有权，也不对文章内容的真实性、准确性和合法性承担责任。 如发现本文存在侵权、违法、违规或事实不符的情况，请及时联系我们，我们将第一时间进行核实并删除相应内容。

...司网站，帮助用户快速实现企业官网的构建，无需任何编程基础，让您的公司在网络世界中脱颖而出。 点我下载 文件大小：18.36 MB 您将下载一个资源包，该资源包内部文件的目录结构如下： 本网站提供模板下载功能，旨在帮助广大用户在工作学习中提升效率、节约时间。 本网站的下载内容来自于互联网。如您发现任何侵犯您权益的内容，请立即告知我们，我们将迅速响应并删除相关内容。 免责声明：站内所有资源仅供个人学习研究及参考之用，严禁将这些资源应用于商业场景。 若擅自商用导致的一切后果，由使用者承担责任。

...公司介绍、产品展示等基础板块，还特别优化了移动端浏览体验，实现全平台自适应布局。用户可便捷下载并快速搭建出兼具美观与实用性的企业网站，满足多元化的企业数字化展示需求。 点我下载 文件大小：5.17 MB 您将下载一个资源包，该资源包内部文件的目录结构如下： 本网站提供模板下载功能，旨在帮助广大用户在工作学习中提升效率、节约时间。 本网站的下载内容来自于互联网。如您发现任何侵犯您权益的内容，请立即告知我们，我们将迅速响应并删除相关内容。 免责声明：站内所有资源仅供个人学习研究及参考之用，严禁将这些资源应用于商业场景。 若擅自商用导致的一切后果，由使用者承担责任。

...imate.css库基础上。通过这款插件，开发者能够便捷地将Animate.css中预设的丰富、跨浏览器的CSS3动画应用到网页中的DOM元素上。jQueryAnimator.js不仅简化了对Animate.css动画效果的选择与调用过程，还特别提供了额外的功能，即当指定的DOM元素进入浏览器视口时自动触发相应的动画效果，极大地增强了用户体验和动态网页设计的灵活性。只需简单的jQuery语法调用，开发者就能够轻松实现复杂的动画交互，让网页元素以更为生动和吸引人的方式展示出来。 点我下载 文件大小：62.61 KB 您将下载一个JQuery插件资源包，该资源包内部文件的目录结构如下： 本网站提供JQuery插件下载功能，旨在帮助广大用户在工作学习中提升效率、节约时间。 本网站的下载内容来自于互联网。如您发现任何侵犯您权益的内容，请立即告知我们，我们将迅速响应并删除相关内容。 免责声明：站内所有资源仅供个人学习研究及参考之用，严禁将这些资源应用于商业场景。 若擅自商用导致的一切后果，由使用者承担责任。

...otstrap提供的基础导航组件，并对其进行了深度扩展。当用户的鼠标滑过导航菜单项时，它能够实现诸如遮罩层滑动等动态且吸引人的动画特效，从而增强了页面的互动性和沉浸式体验。通过集成这款插件，开发者无需从零开始编写复杂的CSS3或JavaScript动画代码，即可轻松打造出专业而炫酷的导航菜单效果，不仅提高了开发效率，也保证了网站的现代感和用户体验的一致性。 点我下载 文件大小：41.86 KB 您将下载一个JQuery插件资源包，该资源包内部文件的目录结构如下： 本网站提供JQuery插件下载功能，旨在帮助广大用户在工作学习中提升效率、节约时间。 本网站的下载内容来自于互联网。如您发现任何侵犯您权益的内容，请立即告知我们，我们将迅速响应并删除相关内容。 免责声明：站内所有资源仅供个人学习研究及参考之用，严禁将这些资源应用于商业场景。 若擅自商用导致的一切后果，由使用者承担责任。

...p原始下拉菜单功能的基础上进行了深度定制与美化。该插件显著提升了用户体验，通过引入多级下拉菜单支持，允许用户构建复杂的导航结构，尤其适用于拥有大量分类和子类别的网站或应用。metisMenu还实现了列表树形式的展示效果，这意味着当鼠标滑过父菜单项时，其关联的子菜单会动态展开，提供直观且流畅的交互体验。此外，metisMenu不仅增强了视觉表现力，而且保持了对响应式设计的良好兼容性，确保在不同屏幕尺寸和设备上都能高效运作。开发者只需简单地调用该插件并配置相关元素，即可轻松实现高度可定制化的下拉菜单效果，大大简化了基于Bootstrap框架进行Web开发时创建高级导航菜单的工作流程。 点我下载 文件大小：127.56 KB 您将下载一个JQuery插件资源包，该资源包内部文件的目录结构如下： 本网站提供JQuery插件下载功能，旨在帮助广大用户在工作学习中提升效率、节约时间。 本网站的下载内容来自于互联网。如您发现任何侵犯您权益的内容，请立即告知我们，我们将迅速响应并删除相关内容。 免责声明：站内所有资源仅供个人学习研究及参考之用，严禁将这些资源应用于商业场景。 若擅自商用导致的一切后果，由使用者承担责任。

...Bootstrap为基础，提供了增强的多级下拉菜单支持，使得开发人员能够轻松创建包含多层次子菜单的导航结构。此插件的一大特色是其对菜单样式的优化与美化，不仅保持了Bootstrap一贯的简洁与实用风格，还通过巧妙的CSS加工，提升了视觉效果和用户体验。无论是桌面端还是移动端，这款插件都能实现流畅自然的交互，并确保在不同屏幕尺寸下的自适应布局。总之，“基于bootsnav的简洁多级导航菜单”是一个适用于各类Web项目的高效工具，它简化了开发者的工作流程，同时为终端用户带来了优雅、直观且高度可定制的多级导航体验。 点我下载 文件大小：50.46 KB 您将下载一个JQuery插件资源包，该资源包内部文件的目录结构如下： 本网站提供JQuery插件下载功能，旨在帮助广大用户在工作学习中提升效率、节约时间。 本网站的下载内容来自于互联网。如您发现任何侵犯您权益的内容，请立即告知我们，我们将迅速响应并删除相关内容。 免责声明：站内所有资源仅供个人学习研究及参考之用，严禁将这些资源应用于商业场景。 若擅自商用导致的一切后果，由使用者承担责任。

...不修改原有动画代码的基础上灵活切换和整合诸如GreenSock（GSAP）、Velocity.js、anime.js等多样化的动画库资源。这款插件充当了一个中间层，使得在项目中运用多种动画效果变得轻松便捷，增强了开发过程中的兼容性和扩展性。借助Tweene，用户可以集中控制和管理各种复杂的动画序列，实现精准的时间线同步与交互效果。无论是在网站界面的动态元素过渡、UI动效设计，还是富媒体内容展示等方面，Tweene都能有效提升开发效率并丰富最终产品的视觉体验。总之，Tweene是面向jQuery用户的强大工具，简化了跨动画库工作的复杂性，让动画开发更加灵活和高效。 点我下载 文件大小：393.37 KB 您将下载一个JQuery插件资源包，该资源包内部文件的目录结构如下： 本网站提供JQuery插件下载功能，旨在帮助广大用户在工作学习中提升效率、节约时间。 本网站的下载内容来自于互联网。如您发现任何侵犯您权益的内容，请立即告知我们，我们将迅速响应并删除相关内容。 免责声明：站内所有资源仅供个人学习研究及参考之用，严禁将这些资源应用于商业场景。 若擅自商用导致的一切后果，由使用者承担责任。