Java面试题

一、i++和++i的区别

　1、 i++ 返回原来的值，++i 返回加1后的值。

　2、 i++ 不能作为左值，而++i 可以。

    3、++i先运算，后赋值  i++先赋值，后运算

二、java中权限修饰符的四种作用域

权限修饰符

Java 中有四种权限修饰符：public、protected、default、private。
1、public

public：公共的，被 public 修饰的成员可以在任何类中被访问。

在一个 Java 源文件中，只能有一个类使用 public 修饰，而且一旦有一个类被 public 修饰，这个类的类名和其 Java 源文件的文件名必须相同。

一个类作为外部类时，只能被 public 或 default 权限修饰符修饰，但作为内部类时，则可以被四种访问权限修饰，因为一个类作为内部类时，就被当作外部类的成员了，所以可以被四种权限修饰符修饰。

public 修饰成员变量和成员方法时，通过操作该类对象，可以随意访问类中的 public 成员。

public 在继承上的体现是，被 public 修饰的成员全部被子类继承。
2、protected

protected：受保护的，受到该类所在包的保护。

被 protected 修饰的成员，只能被同一包中的类，和其子类（同一包中的子类和不同包中的子类）访问。

protected 在继承上的体现是，被 protected 修饰的成员全部被子类继承。
3、default

default：缺省的，可省略不写。

即在成员前不写任何权限修饰符的时候，默认就是缺省的。

被 default 修饰的成员，只能被同一个包中的类访问。

default 在继承上的体现是，子类必须与父类在同一个包中，才能继承 default 修饰的成员。
4、private

private：私有的，作用域最小。

被 private 修饰的成员，只能在当前类中访问。

private 在继承上的体现是，被 private 修饰的成员不能被继承。

 三、创建线程有几种方式

        1、继承Thread重写run方法

        2、实现runnable接口

        3、实现callable接口

四、hashMap和hashTable的区别

存储： HashMap 运行 key 和 value 为 null ，而 Hashtable 不允许。

线程安全： Hashtable 是线程安全的，而 HashMap 是非线程安全的。

推荐使用：在 Hashtable 的类注释可以看到， Hashtable 是保留类不建议使用，推荐在单 线 程 环 境下 使 用 HashMap 替 代 ， 如 果 需 要 多 线 程使 用 则 用ConcurrentHashMap 替代。

五、怎么解决hashMap线程不安全

1、使用Hashtable替代HashMap

       当一个线程访问HashTable的同步方法时，其他线程如果也要访问同步方法，会被阻塞住。举个例子，当一个线程使用put方法时，另一个线程不但不可以使用put方法，连get方法都不可以。效率很低，所以都不会用。

Hashtable内方法上使用了synchronized。

2、类ConcurrentHashMap定义Map

ConcurrentHashMap是JUC包中的一个类，方法内部使用了synchronized保证线程安全。

3、Collections 类的synchronizedMap(Map<K,V> m)方法可以返回一个线程安全的Map

举例：

 Map<String, Integer> crunchifySynchronizedMapObject = Collections.synchronizedMap(new HashMap<String, Integer>());

经测试，ConcurrentHashMap生成的Map性能是明显优于Hashtable和Collections 的synchronizedMap()方法。

六、SpringCloud有哪些组件，分别有什么作用。

nacos ：服务注册于发现。

Feign ：基于动态代理机制，根据注解和选择的机器，拼接请求 url 地

址，发 起请求。

Ribbon ：实现负载均衡，从一个服务的多台机器中选择一台。

Sentinel ：提供了流量控制、熔断降级、系统负载保护等多个维度来保

障服务之间的稳定性。

Gateway ：网关管理，由 gateway 网关转发请求给对应的服务。

七、项目部署在哪里？

Linux来部署目标环境，打成jar包

八、项目中出现bug如何查询？

1. 查看日志文件：在项目运行过程中，通常会生成日志文件。通过查看日志文件中的错误信息，可以找到可能导致bug的根本原因。

2. 使用调试工具：在IDE或者调试工具中打开调试模式，可以逐步执行代码并观察程序的状态变化，从而找到可能存在问题的代码段。

3. 写单元测试：编写针对特定功能的单元测试，可以快速定位和解决bug，同时也有助于提高代码质量。

4. 提交issue：如果自己无法解决bug，可以向开发团队提交issue，并提供详细的错误信息和操作步骤，以便开发人员更快地定位和修复问题。

总之，在处理bug时，需要仔细分析错误信息、重现bug、定位问题，并且尽可能提供详细的信息，以便更快地解决问题。

九、java中的String为什么不能被继承？为什么用final来修饰？

Java中的String类不能被继承是因为它被声明为final。final关键字用于限制类、方法和变量的修改，使其不能再被子类继承或者重写。这样做可以保证String对象的不可变性，使得字符串在多线程环境下能够正确地共享和操作。

String被设计为不可变类，即一旦创建了String对象，对象内部的值就不能被改变。这种设计模式有很多好处，比如：

1. 线程安全：由于String对象的值不可变，所以可以被多个线程同时访问而不需要锁定。

2. 缓存Hashcode：String对象的hashcode值可以被缓存，提高了效率。

3. 可以作为参数传递：由于String对象的值不可变，所以可以安全地将它们作为参数传递给方法。

如果String类可以被继承或者修改，那么上述优点都将无法保证，从而导致程序运行不稳定。因此，Java语言采用final关键字来保护String类的安全性和稳定性。

十、常量池放在JVM的哪一部分中？

在JVM中，常量池被分为两部分：静态常量池和运行时常量池。

静态常量池是类文件中的一部分，它包含了编译期间生成的各种字面量（如文本字符串、final常量等）和符号引用（如类和接口的全限定名、字段和方法的名称和描述符等）。这些常量在类加载时就被加载到JVM内存中，并且只存在于类的内部结构中。每个类都有自己的静态常量池。

运行时常量池则是在类加载时将静态常量池中的数据复制到JVM堆内存中，用于支持动态性质的语言特性。和静态常量池不同的是，运行时常量池可以进行动态添加、删除或修改等操作，比如使用String.intern()方法向常量池中添加字符串，或者使用java.lang.invoke.MethodHandle实现动态方法调用等。

总之，在JVM中，常量池是一个重要的内存区域，用于存储各种字面量和符号引用。静态常量池和运行时常量池的设计灵活多变，使得Java语言具有很强的动态性和扩展性。

十一、JVM有哪些数据结构？

JVM中有多个数据结构，用于管理类的加载、链接和运行等过程。以下是常见的JVM数据结构：

1. 类加载器（ClassLoader）：Java虚拟机通过类加载器来加载字节码文件，并在内存中生成对应的Class对象。ClassLoader按照一定的委派模式逐级查找并加载类。

2. 运行时常量池（Runtime Constant Pool）：运行时常量池是每个类的常量池的运行时表示形式，它包含了各种字面量和符号引用。运行时常量池可被动态修改。

3. 方法区（Method Area）：方法区是各个线程共享的内存区域，用于存储已加载的类型信息、常量、静态变量、编译器编译后的代码等。

4. Java栈（Java Stack）：Java栈为虚拟机执行Java方法服务，每个线程都有自己的Java栈。Java栈以帧（Frame）为单位，保存着方法的状态、局部变量和操作数栈等。

5. 本地方法栈（Native Method Stack）：本地方法栈与Java栈类似，但是是为本地方法服务的。

6. 堆（Heap）：堆是Java程序中最大的内存区域，用于存储对象实例和数组等。堆被所有线程共享，可以进行垃圾回收。

7. PC寄存器（Program Counter Register）：PC寄存器用于保存正在执行的Java虚拟机指令的地址。每个线程都有自己的PC寄存器。

8. 线程上下文（Thread Context）：线程上下文包含了线程的状态、基础操作系统资源和JVM运行时数据结构等。

总之，JVM中包含了诸多数据结构，这些数据结构协同工作，使得Java程序可以被加载、链接和执行等。理解并熟练掌握这些数据结构对于深入理解Java编程和JVM优化非常重要。

十二、堆和内存

堆和内存都是计算机系统中的重要概念，它们在Java编程和JVM优化等方面也有很大的作用。

内存是计算机系统中的硬件设备，用于存储数据和程序。内存被划分为多个大小相等的块，每个块都有一个唯一的地址，可以用于存储数据或程序。内存的读写速度比较快，但是容量有限，一旦超过了内存容量，就会出现严重的性能问题。

堆是Java虚拟机内存中最大的一块区域，主要用于存储Java对象实例。堆是一种动态分配的内存池，它的容量可以根据需要自动增加或减少。堆中的对象不需要手动释放，由Java虚拟机的垃圾回收器自动回收。Java程序员只需要关心如何创建对象和如何使用对象，而无需关心对象的销毁。

Java虚拟机会将堆分为新生代和老年代两部分。新生代用于存放刚刚创建的对象，老年代用于存放已经存活较长时间的对象。新生代又分为Eden区、Survivor0区和Survivor1区三部分，其中Eden区用于创建新的对象，Survivor0和Survivor1用于存放从Eden区或另一个Survivor区中幸存的对象。Java虚拟机对不同区域采用了不同的垃圾回收算法，以提高垃圾回收效率和内存利用率。

总之，堆和内存都是计算机系统中非常重要的概念。理解堆的结构和垃圾回收机制可以帮助Java程序员写出更高效、更健壮的代码；而理解内存的工作原理和性能特点可以帮助系统管理员优化系统资源使用和调整系统配置。

十三、多线程用在哪些方面？

多线程可以应用于许多场景中，以下是一些常见的使用多线程的情况：

1. 提高程序性能：在CPU密集型的应用中，使用多线程可以将计算任务分配到不同的线程中，从而提高程序的执行效率。

2. 提高用户体验：在IO密集型的应用中，例如网络传输或者图形界面等，使用多线程可以避免阻塞用户界面，使得用户体验更加流畅。

3. 并发控制：在需要同时访问共享资源的场景中，使用多线程可以实现对共享资源的并发控制，避免数据竞争和死锁等问题。

4. 优化数据结构：在数据结构设计中，有些算法和数据结构可以通过并发技术来实现优化，例如ConcurrentHashMap和ConcurrentLinkedQueue等。

5. 处理大规模数据：在处理大规模数据时，可以使用多线程来分割数据并行处理，以减少执行时间。

总之，多线程技术可以应用于各种领域，包括但不限于提高程序性能、提高用户体验、并发控制、优化数据结构和处理大规模数据等。然而，由于多线程带来的复杂性和并发控制的难度，开发人员需要仔细考虑并发风险和线程安全性等问题，以保证多线程应用的正确性和稳定性。

十四、创建线程池的核心参数如何编写？

创建线程池时，需要设置一些核心参数以实现合理的线程管理和任务调度。以下是常见的线程池参数及其编写方法：

1. corePoolSize：线程池中保持的最小线程数。当提交了任务，但运行的线程少于corePoolSize时，会创建新的线程来执行任务。

2. maximumPoolSize：线程池允许的最大线程数。如果提交的任务超过了corePoolSize并且workQueue已满，那么会根据maximumPoolSize来创建新的线程。

3. keepAliveTime：非核心线程闲置时间的最大值。如果线程池中的线程数大于corePoolSize，那么多余的空闲线程会在keepAliveTime之后被终止。

4. workQueue：存放待处理任务的阻塞队列。可以选择不同类型的阻塞队列来作为workQueue，例如ArrayBlockingQueue、LinkedBlockingQueue、SynchronousQueue等。

5. threadFactory：用于创建新线程的工厂类。可以自定义threadFactory来控制线程池中线程的属性，例如名称、优先级等。

6. handler：当线程池达到最大容量并且任务队列也已满时，采取的饱和策略。Java提供了四种饱和策略，分别是AbortPolicy（默认）、CallerRunsPolicy、DiscardOldestPolicy和DiscardPolicy。

通常情况下，线程池的参数需要根据具体的业务场景进行设置。例如，对于CPU密集型应用，可以将线程池中的线程数设置为CPU核心数的两倍，以提高性能。对于IO密集型应用，可以将队列长度设置较大，以避免线程间频繁切换和阻塞。

在编写线程池参数时，需要考虑的因素包括任务数量、任务类型、系统负载、硬件资源等。通过合理地设置线程池参数，可以最大限度地利用系统资源，提高任务处理效率和可靠性。

十五、java多态的理解？

Java多态是一种面向对象编程的特性，它能够让不同类的对象对同一个方法做出不同的响应。具体来说，Java多态包括两种形式：方法重载和方法重写。

1. 方法重载（Overloading）：在同一个类中定义多个方法，它们有相同的名称但参数列表不同，编译器会根据方法签名选择最匹配的方法进行调用。这种形式的多态称为编译时多态或静态多态。

2. 方法重写（Overriding）：子类中定义与父类中有相同名称、参数列表和返回类型的方法，并且访问权限不能小于父类中相应方法的访问权限。当父类引用指向子类对象时，调用该方法时会根据实际类型动态地选择相应的方法进行调用。这种形式的多态称为运行时多态或动态多态。

Java多态可以提高代码的可读性和重用性，使得程序结构更加灵活和易于扩展。通过使用多态，程序员可以针对抽象类或接口编程，而无需考虑具体实现细节，从而提高代码的可维护性和可扩展性。

总之，Java多态是面向对象编程中的重要概念，它通过方法重载和方法重写等机制实现了多种类型的多态性，使得程序变得更加灵活、可读性和可维护性更强。

十六、mybatis缓存有几层？(一级缓存、二级缓存)

（ 1 ）一级缓存 : 基于 PerpetualCache 的 HashMap 本地缓存，其存

储作用域为 Session ，当 Session flush 或 close 之后，该Session 中的所有 Cache 就将清空，默认打开一级缓存。

（ 2 ）二级缓存与一级缓存其机制相同，默认也是采用 PerpetualCache ， HashMap 存储，不同在于其存储作用域为 Mapper(Namespace) ，并且可 自定义存储源，如 Ehcache 。默认不打开二级缓存，要开启二级缓存，使 用二级缓存属性类需要实现 Serializable 序列化接口 ( 可用来保存对象的 状态 ), 可在它的映射文件中配置 ；

（ 3 ）对于缓存数据更新机制，当某一个作用域 ( 一级缓存 Session/ 二级缓存 Namespaces) 的进行了 C/U/D 操作后，默认该作用域下所有 select 中的缓存将被 clear 掉并重新更新，如果开启了二级缓存，则只根据配置 判断是否刷新。

十七、Spring的核心

Spring的核心是IoC（Inversion of Control）和AOP（Aspect-Oriented Programming）。

1. IOC，Inversion of Control，控制反转，指将对象的控制权转移给 Spring框架，由 Spring 来负责控制对象的生命周期（比如创建、销毁）和对象间的依赖关系。

2. AOP：一般称为面向切面，作为面向对象的一种补充，用于将那些与业务无 关，但却对多个对象产生影响的公共行为和逻辑，抽取并封装为一个可重用的模块，这个模块被命名为“切面”（Aspect），减少系统中的重复代码，降低了模块间的耦合度，提高系统的可维护性。可用于权限认证、日志、事务处理。

3. Spring MVC：基于IoC和AOP的Web框架，可以快速开发Web应用程序。

4. Spring Boot：基于Spring的轻量级Web框架，可以快速构建独立的、生产级别的应用程序。

5. Spring Data：提供了一种简单的方式来访问关系型和非关系型数据库，比如JPA、Hibernate、MongoDB等。

6. Spring Security：提供了一种强大的安全框架，可以保护Web应用程序免受各种攻击和威胁。

十八、如何查看sql的执行效率？

Explain命令在解决数据库性能上是第一推荐使用命令，大部分的性能问题可以通过此命令来简单的解决，Explain可以用来查看 SQL 语句的执行效果，可以帮助选择更好的索引和优化查询语句，写出更好的优化语句。

十九、什么情况下建立了索引但是没有生效？

• 如果条件中有 or，即使其中有部分条件是索引字段，也不会使用索引
• 复合索引，查询条件不使用索引前面的字段，后续字段也将无法使用索引
• 以 % 开头的 like 查询
• 索引列的数据类型存在隐形转换
• where 子句里对索引列有数学运算
• where 子句里对索引列使用函数
• MySQL 引擎估算使用全表扫描要比使用索引快，则不使用索引

二十、数据库的连接池？

数据库连接池负责分配、管理和释放数据库连接，它允许应用程序重复使用一个现有的数据库连接，而不是再重新建立一个；释放空闲时间超过最大空闲时间的数据库连接来避免因为没有释放数据库连接而引起的数据库连接遗漏。这项技术能明显提高对数据库操作的性能。

常用的主流开源数据库连接池有C3P0、DBCP、Tomcat Jdbc Pool、BoneCP、Druid等

C3p0: 开源的JDBC连接池，实现了数据源和JNDI绑定，支持JDBC3规范和JDBC2的标准扩展。目前使用它的开源项目有Hibernate、Spring等。单线程，性能较差，适用于小型系统，代码600KB左右。

DBCP (Database Connection Pool):由Apache开发的一个Java数据库连接池项目， Jakarta commons-pool对象池机制，Tomcat使用的连接池组件就是DBCP。单独使用dbcp需要3个包：common-dbcp.jar,common-pool.jar,common-collections.jar，预先将数据库连接放在内存中，应用程序需要建立数据库连接时直接到连接池中申请一个就行，用完再放回。单线程，并发量低，性能不好，适用于小型系统。

Tomcat Jdbc Pool：Tomcat在7.0以前都是使用common-dbcp做为连接池组件，但是dbcp是单线程，为保证线程安全会锁整个连接池，性能较差，dbcp有超过60个类，也相对复杂。Tomcat从7.0开始引入了新增连接池模块叫做Tomcat jdbc pool，基于Tomcat JULI，使用Tomcat日志框架，完全兼容dbcp，通过异步方式获取连接，支持高并发应用环境，超级简单核心文件只有8个，支持JMX，支持XA Connection。

BoneCP：官方说法BoneCP是一个高效、免费、开源的Java数据库连接池实现库。设计初衷就是为了提高数据库连接池性能，根据某些测试数据显示，BoneCP的速度是最快的，要比当时第二快速的连接池快25倍左右，完美集成到一些持久化产品如Hibernate和DataNucleus中。BoneCP特色：高度可扩展，快速；连接状态切换的回调机制；允许直接访问连接；自动化重置能力；JMX支持；懒加载能力；支持XML和属性文件配置方式；较好的Java代码组织，100%单元测试分支代码覆盖率；代码40KB左右。

Druid：Druid是Java语言中最好的数据库连接池，Druid能够提供强大的监控和扩展功能，是一个可用于大数据实时查询和分析的高容错、高性能的开源分布式系统，尤其是当发生代码部署、机器故障以及其他产品系统遇到宕机等情况时，Druid仍能够保持100%正常运行。主要特色：为分析监控设计；快速的交互式查询；高可用；可扩展；Druid是一个开源项目，源码托管在github上。

 二十一、如何实现跨域？

实现跨域有多种方法，下面列举其中几种：

1. JSONP：利用script标签不受同源策略的限制，可以通过动态创建script标签，将数据以回调函数的形式返回到当前页面中。但是，JSONP只能用于GET请求，而且只能接收JSON格式的数据。

2. CORS：跨域资源共享，是一种标准化的跨域解决方案，需要服务器设置响应头Access-Control-Allow-Origin，允许指定的源（Origin）访问当前资源。CORS支持所有HTTP方法，可以发送复杂请求，比如PUT、DELETE等。

3. 代理：在服务器端设置代理，将请求转发到目标服务器，然后再将响应返回给客户端。客户端只需要访问自己的服务器，不需要直接访问目标服务器，从而实现跨域。

4. WebSocket：WebSocket是HTML5中新增的协议，可以在浏览器和服务器之间建立双向通信通道，避免了跨域问题。但是，WebSocket需要服务器端支持，且只能用于支WebSocket协议的浏览器。 以上是常用的几种跨域解决方案，选择合适的方法取决于具体的业务需求和实现难度。

二十二、为什么使用openfeign？

OpenFeign是一种声明式的HTTP客户端，它基于Ribbon和Spring Cloud LoadBalancer实现了负载均衡，并提供了多种编码器和解码器，支持多种传输协议和数据格式，比如HTTP、JSON、XML等。在微服务架构中，服务之间经常需要相互调用，使用OpenFeign可以使得服务之间的调用更加简单、灵活和可维护，具有以下几个优点：

1. 简化代码：OpenFeign采用注解方式定义接口，无需手动编写HTTP请求的代码，从而减少了代码量，提高了开发效率。

2. 易于维护：OpenFeign集成了Ribbon和Spring Cloud LoadBalancer，可以自动进行负载均衡和故障转移，从而提高了服务的可用性和稳定性。

3. 支持多种传输协议和数据格式：OpenFeign支持多种传输协议和数据格式，可以根据具体的业务需求选择合适的编码器和解码器。

4. 可扩展性强：OpenFeign基于接口和注解方式定义HTTP请求，可以灵活扩展和定制HTTP请求的处理逻辑，满足不同的业务需求。 总之，使用OpenFeign进行服务之间的调用可以大大简化代码，提高开发效率和可维护性，同时还具有良好的可扩展性和稳定性。

二十三、用户登陆的时候token是什么方式来存储？token存在哪里？用什么算法来存的？

什么时候放在缓存中，什么时候取出来用（网关、nacos这个过程）

Token是一种用于标识用户身份的字符串，通常用于用户登录认证。

在存储Token时，一般使用数据库或缓存两种方式。

1. 存储在数据库中

当用户登录成功后，服务器生成一个Token字符串，并将该Token存储在数据库中的用户表中，一般是作为用户表的一个字段，例如token字段。当用户需要验证身份时，服务器会从数据库中查询Token，判断Token的有效性和所属用户信息。

2. 存储在缓存中

当用户登录成功后，服务器生成一个Token字符串，并将该Token存储在缓存中，例如Redis等。这样可以避免频繁访问数据库，提高访问效率。当用户需要验证身份时，服务器会从缓存中查询Token，判断Token的有效性和所属用户信息。

在网关和Nacos中

一般会将Token存储在缓存中，例如Redis中。当用户请求到达网关时，网关会从请求头中获取Token，并从缓存中查询Token，判断Token的有效性和所属用户信息。如果Token有效，则将用户信息存储在请求上下文中，方便后续的服务调用。如果Token无效，则网关会返回错误信息或重定向到登录页面。

在服务调用过程中，服务会从请求上下文中获取用户信息，以便对用户进行权限验证和操作。

二十四、项目中RabbitMQ在什么情况下用？

在分布式系统中，应用服务之间需要进行异步通信，以达到解耦和提高系统的可伸缩性、可用性等目的。RabbitMQ 是一款流行的消息中间件，它实现了 AMQP 协议，并提供了可靠性消息传递、消息持久化、消息分发等强大的功能，可以在服务之间进行异步通信。下面是 RabbitMQ 的一些使用场景：

1. 异步处理：在应用中，某些处理可能需要一些时间才能完成，例如发送邮件、短信等。如果同步执行这些操作，会导致用户体验差，甚至让应用崩溃。使用 RabbitMQ 可以将这些任务放到消息队列中，让应用快速响应请求，同时异步处理这些任务。

2. 解耦：应用系统由多个服务组成，服务之间需要进行通信。使用 RabbitMQ 可以让服务之间解耦，每个服务只需要关注自己需要处理的消息，不需要关心消息的来源和去向。这样可以增强系统的可维护性和可扩展性。

3. 广播：某些场景下，需要将消息广播给所有订阅者，例如实时消息、通知等。使用 RabbitMQ 可以实现发布-订阅模式，将消息发布到一个交换机，由多个队列接收消息，从而实现消息广播。

4. 负载均衡：在应用中，某些任务需要同时在多个服务上执行。使用 RabbitMQ 可以将任务放到消息队列中，多个服务可以消费队列中的消息，从而实现任务的负载均衡。 总之，RabbitMQ 在应用系统中的应用场景非常多，它能够实现异步处理、解耦、广播、负载均衡等功能，从而提高应用系统的可维护性、可扩展性和可用性。

二十五、minIo是什么？

MinIO是一款高性能、可扩展、分布式的对象存储服务器，它是一款兼容Amazon S3 API的云存储解决方案。它可以用于存储大量的非结构化数据，例如图片、音视频、日志等数据。MinIO提供了容错、数据保护、安全、高可用等功能，可以将数据存储在多个节点上，从而实现数据备份和数据恢复。 MinIO的主要特点如下：

1. 高性能：MinIO采用Go语言编写，使用了多线程和异步I/O等技术，可以实现高并发、低延迟的数据访问。

2. 可扩展：MinIO支持水平扩展，可以将数据存储在多个节点上，从而提高存储容量和吞吐量。

3. 兼容S3 API：MinIO是兼容Amazon S3 API的，可以使用AWS SDK、S3 API和S3 CLI等工具访问和管理数据。

4. 容错性好：MinIO采用Erasure Code算法实现数据的容错和数据保护，可以在节点故障时自动恢复数据。

5. 安全可靠：MinIO支持数据加密、身份认证、访问控制等安全特性，可以保障数据的安全性和可靠性。

总之，MinIO是一款高性能、可扩展、兼容S3 API的对象存储服务器，可以满足不同场景下的数据存储需求，例如大数据、机器学习、容器存储等场景。

二十六、怎么去查索引？通过什么能看到走没走索引？怎么看出来有没有满足索引、有没有索引？

在 MySQL 中，可以通过 `EXPLAIN` 命令来查看 SQL 语句的执行计划。执行该命令后，MySQL 会解析 SQL 语句并生成一个执行计划，包括了该语句将如何被执行，使用哪些索引等信息。 下面是一些常用的 `EXPLAIN` 命令：

1. `EXPLAIN SELECT ...`：查看 SELECT 语句的执行计划。

2. `EXPLAIN EXTENDED SELECT ...`：查看 SELECT 语句的执行计划，同时输出更多的信息，例如使用的索引、扫描的行数等。

3. `EXPLAIN UPDATE ...`：查看 UPDATE 语句的执行计划。

4. `EXPLAIN DELETE ...`：查看 DELETE 语句的执行计划。 在执行 `EXPLAIN` 命令后，会得到一个类似下面的输出：

``` id select_type table partitions type possible_keys key key_len ref rows filtered Extra 1 SIMPLE users NULL range idx_username idx_name 193 NULL 10 100.00 Using index condition;

Using where ```

其中，最重要的是 `type` 和 `key` 字段：

- `type` 字段表示查询使用的访问类型，包括了 `ALL`、`index`、`range`、`ref`、`eq_ref` 等类型，其中 `index` 表示使用索引扫描，`range` 表示使用索引的范围查询。

- `key` 字段表示查询使用的索引名称，如果该字段为 `NULL`，则表示没有使用索引。

另外，如果使用了 `EXPLAIN EXTENDED` 命令，则还会输出更多的信息，例如使用的索引、扫描的行数、访问类型、过滤条件等。

通过查看 `type` 和 `key` 字段，可以判断是否使用了索引，如果 `type` 为 `index` 或 `range`，则表示使用了索引；如果 `key` 不为 `NULL`，则表示使用了索引。如果查询没有使用索引，则需要优化 SQL 语句或者增加适当的索引。 总之，通过 `EXPLAIN` 命令可以查看 SQL 语句的执行计划，判断是否使用了索引，从而优化 SQL 查询。

 二十七、Eureka和Nacos的区别是什么？

Eureka和Nacos都是服务发现和注册中心，它们的主要区别如下：

1. 技术架构不同：Eureka是Netflix开源的一个项目，采用Java编写，基于AP原则设计，使用了传统的基于HTTP的RESTful API进行通信；Nacos是阿里巴巴开源的一个项目，采用Java编写，基于CP原则设计，使用了基于HTTP和DNS协议的双协议栈通信。

2. 功能差异：Eureka的功能比较简单，主要提供服务注册和发现功能，而Nacos提供了更多的功能，包括服务注册和发现、配置管理、流量管理和服务治理等。

3. 技术生态不同：Eureka是Netflix的一个项目，主要被Spring Cloud等一系列项目所采用，而Nacos则是阿里巴巴开源的项目，主要被阿里巴巴的各个业务部门所使用。

4. 社区活跃度不同：Eureka的社区相对较小，更新迭代相对较慢，而Nacos社区活跃度很高，更新迭代速度较快，功能也在不断扩展和完善。

综上所述，Eureka和Nacos在技术架构、功能、技术生态和社区活跃度等方面存在一些差异，需要根据自身的需求进行选择。如果只是需要简单的服务注册和发现功能，Eureka是一个不错的选择；如果需要更多的功能，如配置管理、流量管理和服务治理等，可以考虑使用Nacos。

二十八、cloud模块之间的调用用的什么？

在Spring Cloud中，不同的微服务之间的调用一般使用RESTful API进行通信。

Spring Cloud提供了多种方式来简化RESTful API的调用，如使用Feign、Ribbon等组件来实现负载均衡和服务发现等功能。

Feign是一个声明式的HTTP客户端，使用Feign可以更加方便地定义和调用RESTful API，而无需手动编写HTTP请求的代码。Feign还支持负载均衡和服务发现等功能，可以自动将请求分发到不同的微服务实例中，从而提高系统的可用性和性能。

Ribbon是一个负载均衡器，可以将请求分发到多个微服务实例中，从而实现高可用和高性能的服务调用。Ribbon支持多种负载均衡算法和服务发现方式，可以根据不同的场景进行配置和使用。

除了RESTful API之外，Spring Cloud还提供了基于消息中间件的方式来实现微服务之间的通信，如使用Spring Cloud Stream和Apache Kafka等组件。这种方式可以实现异步通信和解耦，适用于复杂的业务场景。

二十九、Rabbit有几种模型？

RabbitMQ支持多种消息模型，其中常见的有以下几种：

1. 简单模型（Simple Model）：简单模型包含一个生产者、一个消费者和一个队列。生产者发送消息到队列，消费者从队列中获取消息并处理。这是最基本的模型。

2. 工作队列模型（Work Queues Model）：工作队列模型包含多个消费者和一个队列。生产者发送消息到队列，多个消费者并发地从队列中获取消息并处理。这种模型能够提高消息的处理速度和吞吐量。

3. 发布/订阅模型（Publish/Subscribe Model）：发布/订阅模型包含一个生产者、多个消费者和多个队列。生产者发送消息到交换机（Exchange），交换机将消息路由到多个队列中，多个消费者从队列中获取消息并处理。这种模型可以实现一对多的消息传递。

4. 路由模型（Routing Model）：路由模型包含一个生产者、多个消费者、多个队列和一个交换机。生产者发送消息到交换机，交换机将消息根据路由规则路由到指定的队列中，多个消费者从队列中获取消息并处理。这种模型可以实现灵活的消息路由。

5. 主题模型（Topics Model）：主题模型包含一个生产者、多个消费者、多个队列和一个交换机。生产者发送消息到交换机，交换机将消息根据主题（Topic）进行匹配并路由到指定的队列中，多个消费者从队列中获取消息并处理。这种模型可以实现更加灵活的消息路由。 总的来说，RabbitMQ的消息模型丰富多样，可以根据实际的业务需求选择合适的模型。

三十、我的前端页面有一些重要的接口，如何记录这些接口的操作日志？

记录接口操作日志通常需要在后端进行，以下是一些常见的实现方式：

1. 在接口请求的参数和返回结果中记录相关信息，并将其存储在数据库中。

2. 使用日志框架，如Log4j、Logback等，在后端代码中添加日志记录功能。可以在代码中自定义日志格式，记录接口请求的参数、返回结果、请求时间等信息。

3. 在后端使用AOP（面向切面编程）技术，将接口请求和响应过程中的关键信息拦截并记录到日志中。可以使用Spring AOP等框架实现。

4. 集成第三方日志监控系统，如ELK、Splunk等。这些系统可以实时地对日志进行分析和展示，方便开发人员进行问题排查和性能优化。 需要注意的是，在记录接口操作日志时，需要考虑隐私和安全性等方面的问题，避免敏感信息泄露。同时，日志记录的量也需要进行适当的限制，避免对服务器性能造成负担。

三十一、String类里面有一个startwith方法，如何通过反射调用？

可以使用Java反射机制中的Method类来调用String类的startsWith(String prefix)方法。以下是一个示例代码：

这个示例代码首先获取了字符串对象的Class对象，然后使用getMethod方法获取到名为startsWith的方法对象，并指定该方法的参数类型为String。最后通过invoke方法调用这个方法并传递相关参数。需要注意的是，如果目标方法有返回值，则需要进行强制类型转换。

import java.lang.reflect.Method;

public class Example {
    public static void main(String[] args) throws Exception {
        String str = "Hello World";
        Class<?> stringClass = str.getClass();
        Method startsWithMethod = stringClass.getMethod("startsWith", String.class);
        boolean result = (boolean)startsWithMethod.invoke(str, "Hello");
        System.out.println(result); // output: true
    }
}

三十二、在事务操作中，怎么管理事务，比如一个接口中的事务如何来做？接口中的事务如何来回滚和提交？

在Java中，我们可以使用@Transactional注解来管理事务。
当一个方法被@Transactional注解修饰时，如果发生了异常，则事务会回滚。
如果没有异常，则事务会提交。当然，我们也可以手动管理事务，例如：

```java
@Service
public class UserServiceImpl implements UserService {
    
    @Autowired
    private UserDao userDao;
    
    @Override
    @Transactional
    public void transferMoney(int fromId, int toId, double money) {
        userDao.withdraw(fromId, money);
        userDao.deposit(toId, money);
    }
}
```

在上述代码中，我们使用@Transactional注解修饰了transferMoney()方法。
这意味着这个方法是一个事务。当这个方法被调用时，
会开启一个事务，执行withdraw()和deposit()方法，
如果这两个方法都执行成功，则事务会提交。
如果有一个方法抛出了异常，则事务会回滚。

需要注意的是，如果我们在方法内部手动抛出异常，事务仍然会回滚。例如：

```java
@Service
public class UserServiceImpl implements UserService {
    
    @Autowired
    private UserDao userDao;
    
    @Override
    @Transactional
    public void transferMoney(int fromId, int toId, double money) {
        userDao.withdraw(fromId, money);
        if (true) {
            throw new RuntimeException("故意抛出异常");
        }
        userDao.deposit(toId, money);
    }
}
```

在上述代码中，我们故意抛出了一个RuntimeException异常，这会导致事务回滚。
因此，即使我们手动抛出了异常，事务仍然会自动回滚。

总的来说，使用@Transactional注解来管理事务可以让我们更加方便地进行事务管理，
不必手动处理事务提交和回滚。但如果有特殊需求，我们也可以手动管理事务。

三十三、如何控制事务中的某些异常不进行回滚

在Java中，我们可以使用@Transactional注解来控制事务的提交和回滚。当一个方法被@Transactional注解修饰时，如果发生了异常，则事务会回滚。但是，有时候我们希望在某些特定的异常情况下，不进行回滚，这时我们可以使用noRollbackFor属性来实现。 noRollbackFor属性接受一个Class数组，指定在遇到这些异常时，不进行回滚。例如：

```java

@Service @Transactional

public class UserServiceImpl implements UserService {

@Autowired

private UserDao userDao;

@Override

public void transferMoney(int fromId, int toId, double money) {

try {

userDao.withdraw(fromId, money);

userDao.deposit(toId, money);

} catch (InsufficientBalanceException e) {

// 如果是余额不足的异常，不进行回滚

TransactionAspectSupport.currentTransactionStatus().setRollbackOnly();

} catch (Exception e) {

// 如果是其他异常，回滚事务

throw e;

}

}

}

在上述代码中，我们使用了try-catch块来捕获InsufficientBalanceException异常。如果发生了这个异常，我们手动将当前事务标记为只读，不进行回滚。如果是其他异常，则抛出异常，让事务回滚。

三十四、MySQl中的having在什么时候会用到？

HAVING子句是MySQL中一个非常有用的语句，用于在执行聚合函数后对结果集进行筛选过滤。

HAVING子句只能与GROUP BY子句一起使用，通常出现在GROUP BY子句之后，WHERE子句之前，

语法如下： ``` SELECT column1, column2,

... FROM table_name WHERE condition GROUP BY column1,

column2, ... HAVING condition

```

HAVING子句的作用是对GROUP BY子句分组后的结果进行筛选，

可以使用聚合函数进行条件过滤，如SUM、AVG、COUNT等。HAVING子句的作用和WHERE子句类似，不同之处在于WHERE子句用于筛选原始数据，而HAVING子句用于筛选聚合后的结果。 HAVING子句通常用于需要对分组后的数据进行统计和分析的查询中，如查询每个部门的平均薪资超过5000的员工信息，

可以使用如下语句：

```

SELECT department, AVG(salary) as avg_salary FROM employee GROUP BY department HAVING avg_salary > 5000;

```

在这个查询中，先按部门分组，然后使用AVG函数计算每个部门的平均薪资，最后使用HAVING子句筛选出平均薪资超过5000的部门。

三十五、创建线程的几种方式？

在Java中，创建线程有以下几种方式：

1. 继承Thread类并重写run()方法：

创建一个类继承Thread类，重写run()方法，在run()方法中编写线程执行的代码，最后创建该类的对象并调用start()方法启动线程。

```java

public class MyThread extends Thread {

public void run() {

// 线程执行的代码

}

}

MyThread thread = new MyThread();

thread.start();

```

2. 实现Runnable接口：创建一个类实现Runnable接口，重写run()方法，在run()方法中编写线程执行的代码，最后创建该类的对象，并将其传入Thread类的构造方法中，最后调用start()方法启动线程。

```java

public class MyRunnable implements Runnable {

public void run() {

// 线程执行的代码

}

}

MyRunnable runnable = new MyRunnable();

Thread thread = new Thread(runnable);

thread.start();

```

3. 实现Callable接口：创建一个类实现Callable接口，重写call()方法，在call()方法中编写线程执行的代码，最后创建该类的对象，并将其传入FutureTask类的构造方法中，最后调用start()方法启动线程。

```java

public class MyCallable implements Callable<Integer> {

public Integer call() throws Exception {

// 线程执行的代码

}

        }

MyCallable callable = new MyCallable();

FutureTask<Integer> futureTask = new FutureTask<>(callable);

Thread thread = new Thread(futureTask);

thread.start();

```

4. 使用线程池：创建一个线程池对象，将任务提交给线程池执行，线程池会自动管理线程的创建和销毁，可以有效地提高程序的性能和稳定性。

```java

ExecutorService executorService = Executors.newFixedThreadPool(10); executorService.execute(new Runnable() {

public void run() { // 线程执行的代码

}

});

executorService.shutdown();

```

以上是Java中创建线程的几种方式，不同的方式适用于不同的场景，根据实际情况选择合适的方式可以提高程序的性能和可维护性。

三十六、线程池的几大核心参数？如何使用？

线程池的几大核心参数如下：

1. corePoolSize：线程池的核心线程数，即在没有任务需要执行时线程池维护的线程数。

2. maximumPoolSize：线程池的最大线程数，即当队列已满且所有的核心线程都在执行任务时，线程池会创建新的线程来处理任务，但是最多不会超过最大线程数。

3. keepAliveTime：非核心线程空闲时的存活时间，即当线程池中的线程数量超过corePoolSize时，多余的空闲线程会在指定的时间内被销毁，以保持线程池的大小不超过maximumPoolSize。

4. workQueue：用于保存等待执行的任务的阻塞队列，当所有的核心线程都在处理任务时，新的任务会被放入队列中等待执行。

线程池的使用步骤如下：

1. 创建ThreadPoolExecutor对象，并指定其核心线程数、最大线程数、空闲线程存活时间和阻塞队列等参数。

```java

ThreadPoolExecutor executor = new ThreadPoolExecutor( corePoolSize, maximumPoolSize, keepAliveTime, TimeUnit.SECONDS, new LinkedBlockingQueue<Runnable>());

```

2. 创建任务，将任务提交给线程池处理。

```java

executor.execute(new Runnable() { public void run() {

// 任务执行的代码

}

});

```

3. 关闭线程池。

```java

executor.shutdown();

```

其中，execute()方法会将任务提交给线程池处理，并立即返回，而shutdown()方法会等待所有任务执行完毕后再关闭线程池。 使用线程池的好处在于可以避免频繁创建和销毁线程的开销，提高程序的性能和稳定性。同时，通过调整线程池的参数，可以灵活地控制线程池的大小和任务的执行方式，从而更好地满足不同场景下的需求。

三十七、多任务在同时异步处理的时候其中一个线程还没跑完，但是我想终止，如何做到？

在Java中，我们可以使用线程的interrupt()方法来中断正在执行的线程。当一个线程调用了interrupt()方法时，线程会收到一个中断信号，并抛出InterruptedException异常，如果线程正在执行sleep、wait、join等方法，会立即抛出InterruptedException异常。如果线程没有在这些方法中，则需要在线程中使用Thread.interrupted()方法检查中断标志位，来决定是否终止线程。

以下是一个简单的示例代码，演示了如何中断一个正在执行的线程：

```java

public class MyThread extends Thread { @Override public void run() { while (!Thread.currentThread().isInterrupted()) {

// 线程执行的代码

// 如果想终止线程，可以在此处添加判断语句

}

}

}

// 中断线程

MyThread thread = new MyThread(); thread.start();

/ 启动线程 thread.interrupt();

// 中断线程

```

在上述代码中，MyThread类继承自Thread类，重写了run()方法。在run()方法中，使用了一个循环来模拟线程的执行过程。在循环中，通过Thread.currentThread().isInterrupted()方法来检查中断标志位，如果为true，则退出循环，终止线程。 在主线程中，我们可以通过调用线程的interrupt()方法来中断线程。当线程被中断后，会抛出InterruptedException异常，此时线程会退出循环，终止执行。

三十八、synchronized 和 Lock 有什么区别？

synchronized 和 Lock 都是 Java 中用于实现线程同步的机制，它们的主要区别如下：

1. 性质不同：synchronized 是 Java 语言内置的关键字，是 JVM 实现的一种锁机制，而 Lock 是一个 Java 类，是由 Java API 提供的一种显式锁机制。

2. 锁的释放方式不同：synchronized 在代码执行完或者抛出异常时会自动释放锁，而 Lock 必须通过代码显式地调用 unlock() 方法来释放锁。

3. 等待可中断性：synchronized 不可中断，除非线程抛出异常或者正常运行完成，而 Lock 可以通过 lockInterruptibly() 方法响应中断请求。

4. 锁的获取方式不同：synchronized 在获取锁时是非公平的，即无法保证等待时间最长的线程最先获取到锁，而 Lock 可以通过构造方法中的参数指定是公平锁还是非公平锁。

5. 条件变量的使用：Lock 支持多个条件变量，可以通过 Condition 接口实现精准的线程通信，而 synchronized 不支持。

综上所述，synchronized 是一种隐式锁机制，适用于大部分的同步场景，使用起来比较简单；而 Lock 是一种显式锁机制，适用于复杂的同步场景，需要手动管理锁的获取和释放，但可以更加精细地控制同步过程。

 三十九、union / union all

在 SQL 中，
UNION 和 UNION ALL 
都是用于合并两个或多个 SELECT 语句的结果集的操作符。

它们的区别在于：

1. UNION 会合并两个或多个 SELECT 语句的结果集，
并去除重复的行。
即 UNION 会对结果集进行去重处理。
而 UNION ALL 不会去除重复的行，
即它返回所有的行，包括重复的行。

2. UNION ALL 的执行速度通常比 UNION 快，
因为 UNION 需要对结果集进行去重处理，
而 UNION ALL 不需要。

使用 UNION 时，需要注意以下几点：

1. 要求 SELECT 语句的列数和数据类型必须相同，否则会报错。

2. UNION 操作符会默认按照第一个 SELECT 语句中的列名进行列名的命名和列的顺序，
如果需要修改列名或调整列的顺序，需要使用别名或者重新编写 SELECT 语句。


3. UNION 操作符会默认按照第一个 SELECT 语句中的列的数据类型进行数据类型的匹配，
如果不匹配可能会导致错误。

举个例子：

假设有两个表 A 和 B，它们有相同的列结构，现在需要将这两个表的数据合并起来：

- 使用 UNION：

```
SELECT column1, column2 FROM A
UNION
SELECT column1, column2 FROM B;
```

该语句会返回去除重复行后的 A 和 B 表的数据合并结果。

- 使用 UNION ALL：

```
SELECT column1, column2 FROM A
UNION ALL
SELECT column1, column2 FROM B;
```

该语句会返回 A 和 B 表的数据合并结果，包括重复的行。

中科软面试题

四十、cloud常用的组件有哪些？

四十一、nacos怎么接入到spring里面去？

要将Nacos接入到Spring中，需要在Spring项目中添加Nacos的依赖包，
并在Spring配置文件中配置相关信息。

下面是具体的步骤：

1. 在Spring项目中添加Nacos的依赖包，可以通过Maven或Gradle进行添加。Maven依赖如下：

```xml
<dependency>
    <groupId>com.alibaba.cloud</groupId>
    <artifactId>spring-cloud-starter-alibaba-nacos-config</artifactId>
    <version>${nacos.version}</version>
</dependency>
```

其中，`${nacos.version}`是Nacos的版本号，可以根据实际情况进行替换。

2. 在Spring配置文件中添加Nacos相关配置。比如，在application.yml中添加如下配置：

```yaml
spring:
  cloud:
    nacos:
      config:
        server-addr: ${nacos.server-addr}
        namespace: ${nacos.namespace}
```

其中，`${nacos.server-addr}`是Nacos服务器地址，
`${nacos.namespace}`是Nacos的命名空间，可以根据实际情况进行替换。

3. 在Java代码中使用Nacos的配置。比如，可以使用`@Value`注解来获取Nacos中的配置项，
如下所示：

```java
@Value("${myconfig.value}")
private String myconfigValue;
```

其中，`myconfig.value`是Nacos中的配置项名称，可以根据实际情况进行替换。

通过以上步骤，就可以将Nacos接入到Spring中，并在Java代码中使用Nacos的配置了。

四十二、springBoot自动配置过程？

里面有一个 main 方法运行了一个 run() 方法，在 run 方法中必须要传入一个被 @SpringBootApplication 注解的类。

@SpringBootApplication 包含 @EnableAutoConfiguration 该注 解， @EnableAutoConfiguration 开启自动配置功能，在 @EnableAutoConfiguration 中包含

@Import({AutoConfigurationImportSelector.class}) 注解，

该注解需要导入 AutoConfigurationImportSelector 自动配置选择器 类，该类会自动装载一些自动配置类。而这些配置类会完成相应的自动装 配。

 四十三、代码中写的业务逻辑的Bean产生冲突如何解决？

在业务中，可能会出现多个Bean的名称相同，或者多个Bean的类型相同，导致产生冲突的情况。解决这种问题的方法有以下几种：

1. 指定Bean的名称：在使用 @Component、@Service、@Repository、@Controller、@Configuration 等注解时，可以通过 value 或 name 属性指定Bean的名称，保证Bean名称的唯一性。

2. 使用 @Qualifier 注解：当存在多个相同类型的Bean时，可以使用 @Qualifier 注解指定需要注入的Bean名称，保证注入的Bean的唯一性。

3. 使用 @Primary 注解：当存在多个相同类型的Bean时，可以在其中一个Bean上使用 @Primary 注解，表示这个Bean是首选Bean，在注入时，会优先选择这个Bean。

4. 自定义配置类：当出现Bean冲突时，可以使用自定义配置类，通过 @Configuration 和 @Bean 注解来定义Bean，避免与其他Bean产生冲突。

5. 使用 @Conditional 注解：当存在多个相同类型的Bean时，可以在使用 @Autowired 注解时，结合 @Conditional 注解来指定注入的Bean，保证注入的Bean的唯一性。

总的来说，解决Bean产生冲突的方法有很多种，开发者可以根据具体情况选择合适的方法。

四十四、写sql的时候有什么注意事项？

1.防止 SQL 注入攻击：应该使用参数化查询，避免将用户输入的内容直接拼接到 SQL 语句中。

2.避免使用 SELECT *：应该只查询需要的列，避免不必要的数据传输和内存开销。

3.避免多重嵌套查询：应该尽量避免多重嵌套查询，使用 JOIN 或子查询等方式进行优化。

4.注意索引的使用：应该根据查询条件和表结构合理地创建索引，避免全表扫描。

5.避免使用 COUNT(*)：应该使用 COUNT(1) 或 COUNT(column) 等方式进行优化。

6.使用 EXISTS 替代 IN：如果 IN 中的元素较多，应该使用 EXISTS 进行优化。

7.注意分页查询：应该使用 LIMIT 和 OFFSET 进行分页查询，避免全表扫描。

8.注意事务：对于需要保证原子性的操作，应该使用事务来保证数据的一致性。

9.注意性能问题：应该避免多余的 JOIN 操作、不必要的排序和分组等操作，同时注意 SQL 语句的格式和书写规范。

总之，写 SQL 语句时应该注重代码的可读性、可维护性和性能优化，避免常见的错误和安全问题。

 四十五、在做一个数据量很大的查询时如何进行优化

1.使用索引：可以根据查询条件和表结构来选择合适的索引，以避免全表扫描。

2.分区查询：如果表中的数据可以按照某个范围进行分区，可以采用分区查询的方式，以避免查询整个表。

3.限制返回的数据量：可以使用 LIMIT 关键字限制查询返回的数据量，避免一次返回过多的数据。

4.使用缓存：可以使用缓存技术将查询结果缓存到内存中，避免重复查询。

5.避免使用子查询：尽可能地使用 JOIN 操作替代子查询，以提高查询效率。

6.优化查询语句：可以使用 EXPLAIN 关键字分析查询语句，找到执行计划中的瓶颈，并进行优化。

7.升级硬件：如果以上方法仍无法满足需求，可以考虑升级硬件，例如增加 CPU、内存或者使用 SSD 硬盘等。

总之，优化查询需要针对具体的场景进行分析和优化，综合考虑查询的效率和数据的准确性。

Linux中shell脚本

四十六、把一个用户添加另一个用户的组里 shell

可以使用 `usermod` 命令来将一个用户添加到另一个用户的组中，具体命令如下：

```
sudo usermod -a -G <组名> <用户名>
```

其中，`-a` 表示添加用户到组中，`-G` 表示指定组名，`<组名>` 和 `<用户名>` 
分别是待添加到的组名和用户名。

例如，将用户 `user1` 添加到组 `user2` 中，可以使用以下命令：

```
sudo usermod -a -G user2 user1
```

添加完成后，可以使用以下命令来查看用户所属的组：

```
groups <用户名>
```

例如，查看用户 `user1` 所属的组，可以使用以下命令：

```
groups user1

四十七、查询一个进程里面的线程

可以使用 `ps` 命令配合 `H` 选项来查询一个进程里面的线程，具体命令如下：

```
ps -T -p <进程号>
```

其中，`-T` 表示显示进程的线程信息，`-p` 表示指定进程号，`<进程号>` 是待查询的进程号。

例如，查询进程号为 1234 的进程的线程信息，可以使用以下命令：

```
ps -T -p 1234
```

执行命令后，会显示该进程的线程信息，包括线程号、CPU 使用率、内存使用情况等。

另外，也可以使用 `top` 命令来实时查看进程的线程信息，具体命令如下：

```
top -Hp <进程号>
```

其中，`-H` 表示显示线程信息，`-p` 表示指定进程号，`<进程号>` 是待查询的进程号。

例如，查看进程号为 1234 的进程的线程信息，可以使用以下命令：

```
top -Hp 1234
```

执行命令后，会实时显示该进程的线程信息，包括线程号、CPU 使用率、内存使用情况等。

四十八、查找文件目录 shell

在 Linux 系统中，可以使用 `find` 命令来查找指定目录下的文件或目录，具体命令如下：

```
find <路径> -name <文件名>
```

其中，`<路径>` 表示待查找的目录路径，`-name` 表示按照文件名进行查找，
`<文件名>` 是待查找的文件名或通配符。

例如，查找 `/home` 目录下名为 `test.txt` 的文件，可以使用以下命令：

```
find /home -name test.txt
```

执行命令后，会在 `/home` 目录及其子目录中查找 `test.txt` 文件，并输出文件的路径。

另外，还可以使用 `locate` 命令来查找系统中已经建立索引的文件，具体命令如下：

```
locate <文件名>
```

例如，查找名为 `test.txt` 的文件，可以使用以下命令：

```
locate test.txt
```

执行命令后，会在系统中查找名为 `test.txt` 的文件，并输出文件的路径。
需要注意的是，
`locate` 命令默认情况下只能查找系统中已经建立索引的文件，
因此可能无法查找到最新创建的文件。
如果需要更新索引，可以使用 `updatedb` 命令更新数据库。

四十九、linux 常用命令

### 文件和目录相关命令

- `ls`：列出目录内容
- `cd`：切换当前目录
- `pwd`：显示当前所在目录的完整路径
- `mkdir`：创建新目录
- `rmdir`：删除空目录
- `touch`：创建新文件或更新已有文件的访问和修改时间
- `cp`：复制文件或目录
- `mv`：移动或重命名文件或目录
- `rm`：删除文件或目录
- `cat`：显示文件内容
- `head`：显示文件开头几行内容
- `tail`：显示文件结尾几行内容
- `grep`：在文件中查找指定文本

### 系统管理命令

- `ps`：显示当前进程列表
- `top`：动态显示系统进程活动和性能指标
- `kill`：发送信号给指定进程
- `killall`：根据进程名杀死进程
- `ifconfig`：显示和配置网络接口
- `ping`：测试网络连通性
- `netstat`：显示网络连接、路由表和网络接口统计信息
- `route`：显示和配置网络路由表
- `ssh`：远程登录其他主机
- `scp`：在本地和远程主机之间复制文件
- `chmod`：修改文件或目录的权限
- `chown`：修改文件或目录的所有者
- `su`：切换到其他用户身份
- `sudo`：以管理员权限执行命令

### 压缩和解压命令

- `tar`：打包和解包文件
- `gzip`：压缩和解压文件
- `gunzip`：解压 .gz 文件
- `bzip2`：压缩和解压文件
- `bunzip2`：解压 .bz2 文件
- `zip`：压缩和解压文件
- `unzip`：解压 .zip 文件

### 文本编辑器

- `vi`：命令行文本编辑器，常用于系统配置文件的编辑
- `nano`：简单易用的命令行文本编辑器
- `emacs`：功能强大的文本编辑器

这只是一些常用的命令，Linux 系统拥有非常丰富的命令和工具，可以根据需求选择使用。

五十、spring中的拦截器的作用

Spring 拦截器（Interceptor）是一种 AOP（面向切面编程）的技术，它可以在 Spring MVC 请求的前、后、异常、完成等阶段进行拦截，并在其中进行一些自定义的处理。 Spring 拦截器的作用主要有以下几个方面：

1. 日志记录：可以在拦截器中记录请求的 URL、参数、响应时间等信息，方便进行统计分析和排查问题。

2. 权限校验：可以在拦截器中进行用户权限的校验，判断当前用户是否有权限访问该资源。

3. 参数校验：可以在拦截器中进行参数的校验，判断请求参数是否符合要求。

4. 数据预处理：可以在拦截器中对请求数据进行预处理，例如加密、解密等。

5. 业务逻辑处理：可以在拦截器中进行一些自定义的业务逻辑处理，例如记录用户行为等。

6. 异常处理：可以在拦截器中捕获异常，并进行统一的异常处理，例如返回特定的错误信息、记录日志等。

总之，Spring 拦截器可以在请求处理的各个阶段进行拦截和处理，方便进行一些自定义的业务逻辑处理和公共功能的实现。

五十一、redis怎么实现点赞？

五十二、创建了十个线程，如何关闭第二个线程

要关闭第二个线程，可以使用以下步骤：

1. 记录第二个线程的引用。在创建线程时，将每个线程存储在一个列表或数组中，并使用索引来标识每个线程。找到第二个线程的索引并获取其引用。

2. 调用线程的 `interrupt()` 方法。这会设置线程的中断标志，通知线程它应该停止执行并退出。但是这并不能立即停止线程，它必须在适当的时候检查中断标志并自行停止执行。

3. 在第二个线程的任务中检查中断标志。在线程执行的任务中，使用 `Thread.currentThread().isInterrupted()` 检查中断标志，如果标志为 true，则停止线程的执行。

4. 在需要关闭线程的位置上，使用第一步记录的引用调用 `join()` 方法。这将等待线程终止，并使主线程等待第二个线程的终止，然后继续执行。如果线程已经停止，`join()` 方法会立即返回。

注意：线程的中断标志只是一个通知线程应该停止执行的信号，它并不会强制终止线程的执行。因此，在线程的任务中，必须使用 `isInterrupted()` 来检查中断标志并自行停止线程的执行。

五十三、jar包有安全漏洞，需要升级，如何进行处理？

如果一个 jar 包存在安全漏洞，需要进行升级处理。具体的处理步骤如下：

1. 确认受影响的版本：通过查看 CVE（Common Vulnerabilities and Exposures，公共漏洞和暴露）数据库，或者使用一些工具（例如 OWASP Dependency Check）来确定该 jar 包的哪些版本存在安全漏洞。

2. 下载最新版本的 jar 包：从官方或其他可信来源下载最新版本的 jar 包，并确保下载的 jar 包是来自官方或其他可信的源。

3. 替换旧版本的 jar 包：将新的 jar 包替换掉旧版本的 jar 包，可以通过将新的 jar 包放置在项目的 classpath 中来完成。如果使用的是 Maven 等构建工具，则需要在 pom.xml 中更新依赖项的版本。

4. 测试：升级 jar 包之后，需要对应用程序进行全面的测试，以确保新版本的 jar 包没有引入新的问题或错误，并且应用程序的功能和性能都没有受到影响。

需要注意的是，升级 jar 包可能会导致应用程序的不兼容性问题，例如 API 变化或其他行为变化。因此，在进行升级之前，需要对应用程序进行全面的测试和评估，以确保升级过程是安全和可靠的。同时，应该定期检查和更新应用程序使用的所有 jar 包，以避免因漏洞导致的安全问题。

 五十四、什么情况下链表会升级成红黑树

在 Java 中，链表在使用时会根据元素数量的不同采用不同的实现方式。

当链表的元素数量超过某个阈值时，链表会升级成红黑树来提高性能。 具体来说，Java 中的 `HashMap` 和 `HashSet` 使用链表来实现，但当链表的长度超过了阈值（默认为 8），链表会被升级成红黑树来提高查找元素的效率，从而避免链表退化成线性查找的情况。

同样的，当红黑树中的元素数量变得很少时，红黑树也会退化成链表。

在 Java 8 之前，采用了一个固定的阈值，一旦链表长度超过了这个阈值，就会升级成红黑树。而在 Java 8 中，这个阈值变为了可调的，

即根据元素数量和当前桶的大小来计算阈值。这种动态的阈值调整能够更加精确地适应不同的场景和负载，从而提高了性能。

五十五、MySQL实现索引的方式有哪些

MySQL 实现索引的方式主要有以下几种：

1. B-Tree 索引：B-Tree 索引是 MySQL 最常用的索引类型。它可以加速等值查询、范围查询和排序操作。B-Tree 索引适用于大多数类型的查询操作。

2. Hash 索引：Hash 索引适用于等值查询操作。它使用哈希函数对索引列的值进行计算，然后将计算结果作为指针指向数据所在的位置。Hash 索引不支持范围查询和排序操作。

3. Full-Text 索引：Full-Text 索引是用于全文搜索的索引类型。它可以加速对文本数据的搜索和匹配，支持自然语言查询、布尔查询和短语查询等操作。

4. R-Tree 索引：R-Tree 索引是用于空间数据的索引类型。它可以加速对空间数据的查找和匹配，例如地理位置数据。R-Tree 索引适用于经度和纬度数据等有序数据类型。

5. Bitmap 索引：Bitmap 索引适用于基数高（取值范围大）的列，它可以将列中每个值映射到一个位图上，然后通过位运算实现查询和匹配操作。Bitmap 索引适用于低基数列（取值范围小）的查询操作。

需要注意的是，每种索引类型都有其适用的场景和限制。在选择索引类型时，需要根据实际情况进行选择，以达到最优的查询性能。

 五十六、有一个sql很慢，应该从哪些方面来分析

当 SQL 查询较慢时，可以从以下几个方面来分析：

1. 查询语句本身：首先需要检查查询语句是否优化，是否能够更改为更高效的查询方式，例如使用 JOIN 等语句，避免使用子查询等语句。还需要检查是否有多余的查询条件或排序，是否有必要的索引等。

2. 硬件资源：查询的执行时间还会受到硬件资源的影响，例如 CPU、内存、磁盘等。可以通过检查系统负载、内存使用情况、磁盘 I/O 等指标来判断硬件资源是否足够。

3. 数据库表设计：查询效率还会受到数据库表设计的影响，例如表结构是否合理、表的大小、表的数据分布是否均匀等。可以通过查看表的元数据、分析表的数据分布等来进行判断。

4. 数据库服务器配置：数据库服务器的配置也会影响查询效率，例如数据库版本、缓存设置、连接池设置等。可以通过查看数据库服务器的配置文件、日志等来进行判断。

5. 网络带宽：如果是远程查询，还需要考虑网络带宽的影响，例如网络延迟、带宽限制等。

通过综合分析以上几个方面的因素，可以找出 SQL 查询慢的原因，并进行相应的优化。

五十七、高并发下，如何保证接口的幂等性

在高并发场景下，为了保证接口的幂等性，可以采取以下措施：

1. 生成唯一的请求标识：在每个请求中添加唯一的标识，可以通过 UUID 或 Snowflake 等算法来生成。在每次请求时，判断该标识是否已经存在，如果已经存在，则直接返回结果，避免重复处理。

2. 使用 Token 机制：Token 是一种身份验证机制，可以通过在请求中携带 Token 来保证接口的幂等性。每次请求时，需要检查 Token 是否已经被使用过，如果已经被使用过，则直接返回结果，避免重复处理。

3. 利用缓存：在每个请求中添加缓存，可以将请求的处理结果缓存起来，下次相同的请求直接从缓存中获取结果，避免重复处理。

4. 使用分布式锁：在多台服务器上部署同一个服务时，可以使用分布式锁来保证接口的幂等性。每次请求时，需要获取锁，如果获取成功，则进行处理，否则直接返回结果，避免重复处理。

5. 数据库操作：可以通过在数据库中添加唯一索引或使用乐观锁等方式来保证接口的幂等性。在每次请求时，需要根据请求参数在数据库中查询是否已经存在对应的记录，如果已经存在，则直接返回结果，避免重复处理。

综上所述，可以采用上述多种方式来保证接口的幂等性。不同的场景和需求可以选用不同的方案，以达到最优的效果。

中科软外包一面

五十八、医生的排班量是否用控制？如何保证不超出排班量？如果有成千上万个人同时预约如何解决？

医生的排班量一般是有控制的，医院会根据医生的工作能力、工作时间和患者的需求等因素来安排医生的排班量。这样可以保证医生的工作负荷不过重，同时也能够满足患者的就诊需求。

为了保证不超出排班量，医院通常会采用一些预约管理系统来进行控制。这些系统会限制患者的预约数量，一旦达到限制就无法继续预约，直到有空余的预约时间。另外，医院也会对医生的排班进行监管，一旦发现超出排班量，就会及时进行调整。

对于成千上万个人同时预约的情况，可以采用分时段预约的方式来解决。例如，将一天的时间分为若干个时段，每个时段可以接受一定数量的预约，预约数量超过限制的时段就无法再接受预约。这样可以避免因大量人同时预约而造成的系统瘫痪或预约过度的情况。同时，医院也可以根据患者的情况进行优先级排序，让急诊或病情严重的患者优先得到预约。

五十九、redis是用来做什么的？缓存穿透、击穿、雪崩如何处理？

Redis是一款高性能的内存数据库，它支持多种数据结构，包括字符串、哈希表、列表、集合、有序集合等。Redis的主要用途包括以下几个方面：

1. 缓存：Redis的高性能和支持丰富的数据结构，使它成为一个非常好的缓存解决方案。Redis可以将常用的数据缓存在内存中，以提高应用程序的响应速度和性能。

2. 分布式锁：Redis提供了分布式锁的功能，多个进程或线程可以通过Redis实现互斥访问共享资源，避免数据冲突和竞争。

3. 消息队列：Redis支持发布订阅模式，可以实现简单的消息队列功能。发布者可以向某个频道发布消息，订阅者可以订阅该频道，以接收发布者发送的消息。

4. 计数器和排行榜：Redis的计数器和有序集合功能，可以实现各种计数和排行榜功能。例如，可以实现文章的点赞、踩功能，统计某个商品的销量排行等。

5. 地理位置信息：Redis支持地理位置信息的存储和查询，可以实现附近的人、商家等功能。

总之，Redis是一个非常灵活和多用途的高性能数据库，可以用于多种场景的数据处理和存储，适用于需要快速读写和高并发的应用场景。

六十、redis有几种数据类型？

Redis支持以下五种数据类型：

1. 字符串（Strings）：用于存储单个键值对，可以是整数、浮点数、字符串等。

2. 列表（Lists）：链表结构，按照插入顺序排序，可以在头部或尾部插入数据，也可以通过下标访问和修改元素。

3. 哈希（Hashes）：类似于一个字典，可以存储多个键值对，其中的键和值都是字符串类型，可以通过键访问和修改值。

4. 集合（Sets）：无序集合，不允许重复的元素，可以进行集合运算（交、并、差等）。

5. 有序集合（Sorted Sets）：集合中每个元素都会关联一个分数，根据分数进行排序。和集合一样，元素不允许重复，但可以根据分数范围查找元素。

这些数据类型都是在内存中存储的，因此可以快速读写数据。Redis还提供了一些常用的操作命令，可以方便地对这些数据类型进行操作。

六十一、解释一下JWT？

JWT（JSON Web Token）是一种用于认证和授权的开放标准。它基于 JSON 格式，用于在用户和服务之间安全传递信息，例如身份验证信息。

JWT 由三部分组成：Header、Payload 和 Signature。Header 包含两个字段：token 的类型（即 JWT）和使用的算法（例如 HMAC SHA256 或 RSA）。Payload 是 token 的主体，通常包含了用户的信息和其他相关信息。Signature 用于验证 token 是否被篡改，它包含了 Header、Payload 和一个密钥，这个密钥只有服务端才知道，因此可以确保 token 的真实性。

JWT 的主要优点是简单、安全、可扩展和跨语言。它可以用于任何需要认证和授权的场景，例如 web 应用程序、移动应用程序、微服务等。

六十二、如果超过过期时间但是还在使用怎么办？(如何保证token的时效性)

为了保证 JWT token 的时效性，可以采取以下措施：

1. 设置 token 的过期时间，一旦超过这个时间，token 就会失效。可以在生成 token 时将过期时间作为 Payload 中的一个字段，或者在服务器端设置一个默认的过期时间。

2. 在每次验证 token 时，检查 token 是否过期。可以在客户端或服务器端编写一个中间件，每次请求都检查 token 的过期时间，并返回相应的响应。

3. 采用自动刷新机制，当 token 快要过期时，自动刷新 token。可以在服务端编写一个中间件，检查 token 的过期时间，并在 token 即将过期时，自动为用户生成一个新的 token。

4. 提供 token 的撤销机制，一旦用户不再需要使用 token，可以在服务器端将该 token 标记为无效，以防止被恶意利用。

这些措施可以帮助保证 JWT token 的时效性和安全性。

六十三、数据量查询很多，应该从哪些角度考虑？

在面对数据量查询很多的情况时，我们可以从以下几个角度考虑：

1. 数据库索引的使用：索引是数据库中常用的优化方式，可以加速查询操作。如果数据表中的某些字段被频繁用于查询，那么就可以为这些字段建立索引，以提高查询效率。但是，过多的索引会降低写操作的效率，因此需要根据实际情况进行权衡和选择。

2. 数据库分表和分区：当数据量很大时，单张表可能无法承载，此时可以考虑将数据表分成多个表，或者使用分区表来处理大量数据。这样可以减轻单张表的负担，提高查询效率。

3. 数据库查询语句的优化：查询语句的优化可以从多个方面入手，例如，使用合适的查询语句，避免全表扫描，减少不必要的字段查询，使用合适的关键字等等。这些优化可以减少数据库的压力，提高查询效率。

4. 数据库缓存的使用：缓存是一种高效的查询优化方式，可以将查询结果存储在缓存中，当下次查询相同的数据时，直接从缓存中读取，避免重复查询数据库。使用缓存可以大大降低数据库的压力，提高查询效率。

5. 数据库服务器的优化：数据库服务器的优化可以从硬件和软件两个方面入手。例如，提高服务器的配置，增加内存和硬盘容量，调整数据库服务器参数等等。这些优化可以提高数据库服务器的性能和效率，缓解大量数据查询的压力。

综上所述，我们可以从索引、分表分区、查询语句优化、缓存使用和服务器优化等方面考虑，以提高数据库查询的效率和性能。

六十四、如何判定索引有没有失效？

可以通过以下几种方式来判断索引是否失效：

1. 查询执行计划：使用EXPLAIN或者DESCRIBE命令可以获取查询语句的执行计划，通过执行计划可以查看MySQL是否使用了索引。如果查询语句没有使用索引，可能是因为索引已经失效或者没有合适的索引，可以通过优化查询语句或者创建新的索引来解决。

2. 查看索引状态：可以使用SHOW INDEX命令来查看表的索引状态，包括索引名、索引类型、索引字段、唯一性等信息。如果索引状态异常，例如索引不存在、索引字段不正确或者唯一性冲突等，就需要检查索引是否失效。

3. 监控数据库性能：可以通过监控数据库的性能指标，例如查询响应时间、CPU使用率、IO读写速度等指标来判断索引是否失效。如果查询响应时间增加、CPU使用率升高或者IO读写速度变慢，可能是因为索引失效导致了查询效率降低。

4. 使用索引分析工具：有些工具可以对索引进行分析，例如pt-index-usage和mysql-index-stat等，可以查看索引的使用情况、访问频率、覆盖度等指标，从而判断索引是否失效。

综上所述，可以通过多种方式来判断索引是否失效，需要根据具体情况选择合适的方法来进行判断和优化。

六十五、支付的流程？

支付的流程一般包括以下几个步骤：

1. 用户发起支付请求，如在电商平台购买商品时，用户会在购物车页面点击结算按钮，发起支付请求。

2. 系统生成订单，计算订单金额和优惠券等信息，向用户展示支付页面。

3. 用户选择支付方式，如支付宝、微信支付、银行卡支付等，并输入相应的支付信息。

4. 系统根据用户选择的支付方式，调用相应的支付接口向支付平台发起支付请求，并将用户支付信息传递给支付平台。

5. 支付平台接收到支付请求后，进行身份验证、交易授权、支付处理等流程，并将支付结果返回给系统。

6. 系统接收到支付结果后，进行订单状态更新，如将订单状态更新为已支付，并向用户发送支付成功的通知。

7. 支付完成后，系统将订单信息、支付信息等记录到数据库中，以备日后查询和统计分析。

需要注意的是，不同的支付方式和支付平台可能会有不同的流程和接口，具体的支付流程需要根据实际情况进行设计和实现。同时，支付过程中需要考虑安全性和可靠性等因素，如防止支付信息泄露、支付超时等问题。

六十六、spring框架有哪些了解？

Spring 是一个开源的轻量级企业应用开发框架，它是为了解决企业级应用开发复杂性而创建的。Spring 框架的核心是控制反转（IoC）和面向切面编程（AOP），它为开发注于业务逻辑而不是底层的框架配置。

Spring 的主要特点包括：

1. 松耦合：Spring 通过依赖注入和控制反转技术实现了组件之间的松耦合，降低了组件之间的依赖关系，提高了系统的灵活性和可维护性。

2. AOP 支持：Spring 提供了 AOP（面向切面编程）支持，可以通过配置的方式实现横切关注点的统一处理，如事务管理、日志记录等。

3. 容器管理：Spring 提供了一个容器（Application Context）来管理应用程序中的对象，如 Bean 的创建、依赖关系管理、对象的生命周期管理等，使得开发者可以更加专注于业务逻辑的实现。

4. 事务管理：Spring 提供了统一的事务管理接口，支持编程式和声明式事务管理，可以与各种不同的事务管理实现（如 JTA、Hibernate Transaction 等）集成。

5. MVC 框架支持：Spring 提供了一个轻量级的 MVC 框架，可以用于开发 Web 应用程序，它提供了模型-视图-控制器（MVC）架构的实现，支持多种视图技术（如 JSP、Velocity、Thymeleaf 等）。

6. 集成其他框架：Spring 可以集成各种其他框架，如 Hibernate、MyBatis、Struts2、JSF 等，使得开发者可以更加灵活地选择最适合自己的技术栈。

总的来说，Spring 是一个功能丰富、易于使用和扩展的框架，已经成为 Java 企业级应用开发的事实标准之一。

六十七、Aop有哪几种通知类型？

AOP（面向切面编程）定义了五种通知类型，分别是：

1. 前置通知（Before）：在目标方法执行之前执行，可以在前置通知中进行一些预处理操作。

2. 后置通知（After）：在目标方法执行之后执行，无论目标方法是否抛出异常都会执行。

3. 返回通知（AfterReturning）：在目标方法执行之后执行，只有在目标方法成功返回时才会执行。

4. 异常通知（AfterThrowing）：在目标方法抛出异常时执行，可以在异常通知中处理异常或者记录日志等操作。

5. 环绕通知（Around）：在目标方法执行之前和之后执行，可以在环绕通知中控制目标方法的执行流程，可以替换或者修改目标方法的参数和返回值。

以上五种通知类型可以根据实际需求选择使用，一般情况下，前置通知和后置通知用的较多，异常通知用于处理异常，返回通知用于记录日志等操作，环绕通知则可以灵活控制目标方法的执行。

六十八、动态代理和静态代理有什么区别？

动态代理和静态代理都是代理模式的实现方式，区别在于代理类是在编译时还是运行时生成的。

静态代理是在编译时就已经确定代理关系，代理类是由程序员手动编写或者通过工具自动生成的。代理类和目标类实现同一个接口或者继承同一个父类，代理类在调用目标方法前或者后可以添加一些额外的逻辑。

动态代理是在运行时生成的，代理类是动态生成的。代理类不需要手动编写，而是在运行时通过反射等机制动态生成。Java 中的动态代理主要是通过 java.lang.reflect.Proxy 类和 java.lang.reflect.InvocationHandler 接口实现的。在动态代理中，代理类和目标类实现同一个接口或者继承同一个父类，代理类在调用目标方法前或者后可以添加一些额外的逻辑。

因为动态代理是在运行时生成的，所以相比静态代理更加灵活。但是，动态代理的性能一般会比静态代理略差。

六十九、动态代理有哪些实现方式？

Java 中动态代理的实现主要有两种方式：基于 JDK 的动态代理和基于 CGLIB 的动态代理。

1. 基于 JDK 的动态代理

基于 JDK 的动态代理主要是通过 
Java 提供的 java.lang.reflect.Proxy 类
和 java.lang.reflect.InvocationHandler 接口实现的。
具体实现方式如下：

- 定义一个实现 InvocationHandler 接口的代理类，
并实现 invoke 方法，在 invoke 方法中实现代理逻辑。
- 使用 Proxy 类的 newProxyInstance 静态方法动态生成代理对象，
该方法接受三个参数：ClassLoader、Class[] 和 InvocationHandler，
其中 ClassLoader 用于指定代理对象的类加载器，
Class[] 用于指定代理对象实现的接口列表，
InvocationHandler 用于指定代理对象方法调用的处理器。

示例代码：

```java
public interface Subject {
    void request();
}

public class RealSubject implements Subject {
    public void request() {
        System.out.println("RealSubject execute request.");
    }
}

public class ProxyHandler implements InvocationHandler {
    private Object target;

    public ProxyHandler(Object target) {
        this.target = target;
    }

    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("Before invoke " + method.getName());
        Object result = method.invoke(target, args);
        System.out.println("After invoke " + method.getName());
        return result;
    }
}

public class Client {
    public static void main(String[] args) {
        RealSubject realSubject = new RealSubject();
        ProxyHandler proxyHandler = new ProxyHandler(realSubject);
        Subject proxySubject = (Subject) Proxy.newProxyInstance(realSubject.getClass().getClassLoader(),
                                                               realSubject.getClass().getInterfaces(),
                                            proxyHandler);
        proxySubject.request();
    }
}
```

2. 基于 CGLIB 的动态代理

CGLIB（Code Generation Library）是一个高性能的字节码生成库，
可以在运行时动态生成指定类的子类。
基于 CGLIB 的动态代理可以代理没有实现接口的类，其实现方式如下：

- 定义一个实现 MethodInterceptor 接口的代理类，
并实现 intercept 方法，在 intercept 方法中实现代理逻辑。
- 使用 Enhancer 类的 create 静态方法动态生成代理对象，
该方法接受一个 Class 参数，用于指定被代理对象的类。

示例代码：

```java
public class RealSubject {
    public void request() {
        System.out.println("RealSubject execute request.");
    }
}

public class ProxyHandler implements MethodInterceptor {
    public Object intercept(Object object, Method method, Object[] args, MethodProxy proxy) throws Throwable {
        System.out.println("Before invoke " + method.getName());
        Object result = proxy.invokeSuper(object, args);
        System.out.println("After invoke " + method.getName());
        return result;
    }
}

public class Client {
    public static void main(String[] args) {
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(RealSubject.class);
        enhancer.setCallback(new ProxyHandler());
        RealSubject proxySubject = (RealSubject) enhancer.create();
        proxySubject.request();
    }
}
```

七十、动态代理的底层如何实现？

动态代理的底层主要是利用了Java反射机制。

对于基于 JDK 的动态代理，JDK 动态代理会在运行时动态生成一个代理类，该代理类继承了 Proxy 类，并实现了指定的接口。

在代理类中，每个被代理的方法都会被重写，并调用 InvocationHandler 接口的 invoke 方法，将代理逻辑交给 InvocationHandler 处理。

对于基于 CGLIB 的动态代理，CGLIB 会在运行时动态生成一个被代理类的子类，并覆盖其中的方法，将代理逻辑加入其中。

同时，CGLIB 还使用了 Enhancer 类，实现了 MethodInterceptor 接口，并将其作为参数传入生成的子类中，以实现代理逻辑的调用。

无论是基于 JDK 的动态代理还是基于 CGLIB 的动态代理，都是在运行时动态生成代理类，并将代理逻辑交给指定的处理器处理，从而实现对被代理对象的增强。

七十一、如何创建线程？线程池要接受哪些参数？

Java 中线程池的参数主要包括以下几个：

1. corePoolSize：线程池的核心线程数，即线程池维护的线程数。
当提交一个新任务时，如果当前运行的线程数小于 corePoolSize，
那么线程池会创建一个新的线程来执行该任务，即使有其他空闲的线程。

2. maximumPoolSize：线程池的最大线程数。如果队列中的任务已满，
并且正在运行的线程数已达到 maximumPoolSize，
那么线程池会根据指定的拒绝策略来拒绝该任务。

3. keepAliveTime：非核心线程闲置时的超时时间，
即如果当前线程池中的线程数超过 corePoolSize，
并且有线程处于空闲状态超过了 keepAliveTime 时间，
那么这些空闲线程将会被终止，直到线程池中的线程数不大于 corePoolSize。

4. unit：keepAliveTime 的时间单位。

5. workQueue：任务队列，用于存放等待执行的任务。
线程池的实现中提供了不同的队列实现，
如 SynchronousQueue、LinkedBlockingQueue、ArrayBlockingQueue 等。

6. threadFactory：线程工厂，用于创建新的线程。
可以通过实现 ThreadFactory 接口来自定义线程创建的过程。

7. handler：拒绝策略，用于指定当队列中的任务已满，
并且线程池中的线程数已达到 maximumPoolSize 时，
如何处理新提交的任务。线程池提供了四种预定义的拒绝策略：
AbortPolicy（抛出 RejectedExecutionException）、
CallerRunsPolicy（在调用者线程中执行）、
DiscardPolicy（直接丢弃任务）
和 DiscardOldestPolicy（丢弃队列中最老的任务）。

示例代码：

```java
ThreadPoolExecutor executor = new ThreadPoolExecutor(5, 10, 60, TimeUnit.SECONDS,
        new LinkedBlockingQueue<>(), Executors.defaultThreadFactory(), new ThreadPoolExecutor.AbortPolicy());
``` 

以上代码创建了一个线程池，其核心线程数为 5，最大线程数为 10，
非核心线程闲置时的超时时间为 60 秒，
任务队列为 LinkedBlockingQueue，
线程工厂为默认的工厂，拒绝策略为 AbortPolicy。

七十二、线程有哪些状态？

Java 中的线程有 6 种状态：

1. NEW：线程被创建但尚未启动。

2. RUNNABLE：线程正在执行中，但可能正在等待 CPU 时间片。

3. BLOCKED：线程正在等待获取一个同步锁，如果锁已被其他线程持有，则该线程将被阻塞。

4. WAITING：线程正在等待某个条件的出现，
例如调用了 Object.wait() 方法或 LockSupport.park() 方法。

5. TIMED_WAITING：线程正在等待某个条件的出现，
并且设置了等待的超时时间，
例如调用了 Thread.sleep() 方法或 wait(long) 方法。

6. TERMINATED：线程已经执行完成或因异常而中断。

示例代码：

```java
public class ThreadStateDemo {
    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(() -> {
            System.out.println("线程正在执行中");
        });
        System.out.println("线程状态：" + thread.getState()); // NEW
        thread.start();
        System.out.println("线程状态：" + thread.getState()); // RUNNABLE
        Thread.sleep(1000);
        System.out.println("线程状态：" + thread.getState()); // TERMINATED
    }
}
``` 

以上代码创建了一个新线程，启动后进入 RUNNABLE 状态，
并在 1 秒后执行完成进入 TERMINATED 状态。
通过 getState() 方法可以获取线程的当前状态。

七十三、Mybatis如何防止sql注入？

\#{} 是预编译处理， ${} 是字符替换。 在使用 #{} 时， MyBatis 会将SQL 中的 #{} 替换成 “?” ，配合 PreparedStatement 的 set 方法 赋值，这样可以有效的防止 SQL 注入， 保证程序的运行安全。

MyBatis 提供了一些防止 SQL 注入攻击的机制，以下是一些常见的做法：

1. 使用参数占位符

MyBatis 推荐使用参数占位符来构建 SQL 语句，例如：

```xml
<select id="getUserById" resultType="User">
  SELECT * FROM user WHERE id = #{id}
</select>
```

在这个例子中，`#{id}` 就是一个参数占位符，MyBatis 会自动将其替换为实际传入的参数值，而不是将参数直接拼接到 SQL 语句中。

使用参数占位符可以有效避免 SQL 注入攻击，因为参数值不会被直接拼接到 SQL 语句中，而是由 MyBatis 框架进行参数值的转义和拼接。

2. 参数校验

在接收参数时，我们可以对参数进行校验，例如：

```java
public User getUserById(Integer id) {
    if (id == null || id <= 0) {
        throw new IllegalArgumentException("Invalid parameter: id");
    }
    return userDao.getUserById(id);
}
```

这样可以避免一些非法参数的传入，例如负数、0、空值等。

3. 关闭动态 SQL

MyBatis 支持动态 SQL，例如使用 `<if>`、`<where>`、`<choose>` 等标签来动态构建 SQL 语句，这样可以根据不同的条件生成不同的 SQL 语句。

但是，如果不谨慎使用，也可能会导致 SQL 注入攻击。因此，建议在配置文件中关闭动态 SQL 功能：

```xml
<configuration>
  <settings>
    <setting name="defaultScriptingLanguage" value="org.apache.ibatis.scripting.xmltags.XMLLanguageDriver"/>
    <setting name="safeRowBoundsEnabled" value="true"/>
    <setting name="aggressiveLazyLoading" value="false"/>
    <setting name="multipleResultSetsEnabled" value="true"/>
    <setting name="useColumnLabel" value="true"/>
    <setting name="cacheEnabled" value="true"/>
    <setting name="defaultExecutorType" value="SIMPLE"/>
    <setting name="mapUnderscoreToCamelCase" value="false"/>
    <setting name="localCacheScope" value="SESSION"/>
    <setting name="jdbcTypeForNull" value="OTHER"/>
    <setting name="lazyLoadTriggerMethods" value="equals,clone,hashCode,toString"/>
    <setting name="defaultStatementTimeout" value="25000"/>
    <setting name="safeResultHandlerEnabled" value="false"/>
    <setting name="safeRowBoundsEnabled" value="false"/>
    <setting name="callSettersOnNulls" value="false"/>
    <setting name="logPrefix" value=""/> 
    <setting name="logImpl" value="LOG4J2"/>
    <setting name="configurationFactory" value=""/> 
    <setting name="defaultScriptingLanguage" value="org.apache.ibatis.scripting.defaults.RawLanguageDriver"/> <!-- 关闭动态 SQL 功能 -->
  </settings>
</configuration>
```

在这个例子中，设置了 `defaultScriptingLanguage` 为 `org.apache.ibatis.scripting.defaults.RawLanguageDriver`，即关闭了动态 SQL 功能。

总之，在使用 MyBatis 进行 SQL 查询时，要注意防止 SQL 注入攻击，尽量使用参数占位符，并对参数进行校验。

七十四、SpringBoot的核心注解？

Spring Boot 中的核心注解包括：

1. @SpringBootApplication：标注主类，表示这是一个 Spring Boot 应用，包含了 @Configuration、@EnableAutoConfiguration 和 @ComponentScan 注解，可以自动配置 Spring 和 Spring MVC 环境。

2. @Configuration：标注配置类，相当于一个 Spring 配置文件，里面可以定义一些 Bean。

3. @Bean：标注方法，表示将方法返回的对象作为一个 Bean 注入到 Spring 容器中。

4. @ComponentScan：标注扫描组件，会自动扫描指定包及其子包下的所有组件，包括 @Component、@Service、@Repository、@Controller 等。

5. @RestController：标注 RESTful 风格的控制器，可以将请求映射到指定的方法上，方法返回的数据会自动转为 JSON 格式并返回给客户端。

6. @RequestMapping：标注请求映射，用来映射请求 URL 到控制器的方法，可以指定请求方法、请求参数、请求头等信息。

7. @Autowired：标注自动注入，自动从 Spring 容器中查找对应类型的 Bean 并注入到当前属性或方法中。

8. @Value：标注属性注入，可以从配置文件中读取指定的属性值并注入到当前属性中。

9. @EnableAutoConfiguration：标注自动配置，会根据 classpath 中的依赖自动配置 Spring 和 Spring MVC 环境。

10. @ConfigurationProperties：标注配置属性，可以将 application.properties 或 application.yml 中的属性值注入到指定的属性中。

11. @Conditional：标注条件注解，可以根据特定条件决定是否创建 Bean，常用于根据不同环境创建不同的 Bean。

12. @Profile：标注环境配置，可以为不同的环境配置不同的 Bean，例如开发环境和生产环境配置不同的数据源。

13. @Transactional：标注事务注解，表示该方法需要在事务中执行，如果发生异常，则自动回滚。

除了上述注解，Spring Boot 还提供了很多其他的注解，如 @Cacheable、@Scheduled、@ExceptionHandler 等，可以根据需要选择使用。

七十五、Spring、SpringBoot、SpringMVC之间的区别？

Spring、SpringMVC 和 Spring Boot 是三个不同的框架，具有以下不同点：

1. Spring 是一个全栈的企业级应用开发框架，提供了基础设施、数据访问、Web 开发、消息处理等功能，可以集成多种技术框架。

2. SpringMVC 是 Spring 框架中的一个模块，主要用于 Web 开发，提供了基于控制器的 MVC 模式，可以处理 HTTP 请求和响应，并支持多种视图解析器。

3. Spring Boot 是一个快速开发框架，基于 Spring 框架，可以自动配置 Spring 环境，减少了繁琐的配置过程，提高了开发效率。

可以理解为：Spring 是一个基础的框架，提供了 IoC、AOP、事务管理等核心功能，SpringMVC 则是在 Spring 的基础上扩展出来的一个 Web 开发框架，而 Spring Boot 则是在 Spring 的基础上进行了封装，提供了自动配置、快速开发等功能。 简单来说，Spring 是基础，SpringMVC 是 Web，Spring Boot 是快速开发。

七十六、SpringMVC如何开启注解？

要开启 Spring MVC 的注解功能，可以在 Spring MVC 的配置文件中添加以下配置：

```
<mvc:annotation-driven/>
```

这个配置告诉 Spring MVC 开启注解驱动，
它会自动扫描所有标注了@Controller、@RequestMapping、
@RequestParam等注解的类和方法，
并将它们注册为 Spring MVC 的控制器。

此外，如果需要支持其他常用的注解，
比如@PathVariable、@RequestBody等，
可以在<mvc:annotation-driven/>标签中添加相应的配置：

```
<mvc:annotation-driven>
    <mvc:argument-resolvers>
        <bean class="org.springframework.web.method.support.HandlerMethodArgumentResolverComposite">
            <list>
                <bean class="org.springframework.web.method.annotation.RequestParamMethodArgumentResolver"/>
                <bean class="org.springframework.web.method.annotation.PathVariableMethodArgumentResolver"/>
                <bean class="org.springframework.web.method.annotation.ModelAttributeMethodProcessor"/>
                <bean class="org.springframework.web.servlet.mvc.method.annotation.RequestBodyMethodProcessor"/>
            </list>
        </bean>
    </mvc:argument-resolvers>
</mvc:annotation-driven>
```

这里配置了四个常用的参数解析器，
它们分别是@RequestParam、@PathVariable、
@ModelAttribute和@RequestBody对应的解析器。
这样，在使用这些注解时就不需要再手动解析参数了。

七十七、Git中如何回退到提交之前的某一个版本？

在 Git 中，可以使用以下命令回退版本：

1. 查看当前仓库的提交历史

```
git log
```

2. 找到要回退到的目标版本的 commit ID

3. 执行回退命令，有两种方式：

- 回退到指定版本

```
git reset --hard <commit ID>
```

其中，`<commit ID>` 是要回退到的目标版本的 commit ID。

- 回退到上一个版本

```
git reset --hard HEAD^
```

其中，`HEAD^` 表示上一个版本，也可以使用 `HEAD~n` 表示回退到上 n 个版本。

4. 强制推送到远程仓库

```
git push -f
```

由于回退版本会改变历史记录，因此需要强制推送到远程仓库。
注意，强制推送可能会覆盖其他人的修改，所以需要谨慎使用。

康复医院面试题

七十八、单点登录的原理是什么？

单点登录（Single Sign-On，简称 SSO）是一种用户认证机制，允许用户只需登录一次，即可访问多个应用系统。

单点登录的原理是通过一个统一认证中心来管理用户的登录状态和凭证，当用户第一次登录一个应用系统时，该应用系统会将用户的登录信息发送到认证中心进行验证，并获取一个认证令牌（通常是一个加密的字符串）。

当用户访问其他应用系统时，该系统会向认证中心发送用户的认证令牌进行验证，如果认证通过，则用户无需再次登录即可访问该系统。

实现单点登录的关键在于认证中心和各个应用系统之间的通信协议。常见的单点登录实现方式包括：

1. 基于 Cookie 的实现方式：认证中心将用户认证令牌存储在 Cookie 中，各个应用系统在用户访问时，通过 Cookie 获取用户认证令牌，从而实现单点登录。

2. 基于 Token 的实现方式：认证中心将用户认证令牌生成为 Token，各个应用系统在用户访问时，通过 Token 获取用户认证令牌，从而实现单点登录。

3. 基于 SAML 的实现方式：认证中心和各个应用系统之间通过 SAML 协议进行通信，通过 SAML 断言（Assertion）来实现用户认证和单点登录。

单点登录可以提高用户的使用体验，减少用户的登录次数，同时也可以提高系统的安全性，避免用户重复输入用户名和密码，减少了密码泄露的风险。

服务器的部署、docker

七十九、git中如何合并代码

在 Git 中合并代码主要有两种方式：合并（Merge）和衍合（Rebase）。

1. 合并（Merge） 合并是将两个或多个分支合并为一个分支的过程，它是 Git 中最常用的合并代码的方式。合并代码的步骤如下：

- 切换到目标分支：

`git checkout <target-branch>`

- 合并源分支：`git merge <source-branch>`

其中，目标分支是需要将代码合并到哪个分支中，源分支是需要被合并的分支。

在执行合并操作之前，建议先将目标分支更新到最新状态：`git pull origin <target-branch>`

2. 衍合（Rebase）

衍合是将一个分支的修改历史应用到另一个分支的过程，它能够使提交历史更加干净和易于理解。衍合代码的步骤如下：

- 切换到目标分支：`git checkout <target-branch>`

- 执行衍合操作：`git rebase <source-branch>`

其中，目标分支是需要将代码合并到哪个分支中，源分支是需要被衍合的分支。

在执行衍合操作之前，建议先将目标分支更新到最新状态：`git pull origin <target-branch>`

需要注意的是，衍合操作会改变提交历史，因此需要谨慎使用，尤其是在多人协作开发的场景下。 无论是合并还是衍合，如果在合并代码时出现冲突，Git 会提示用户手动解决冲突后再提交代码。

 上海亿侗乐智能科技

八十、写登录的时候有哪些需要注意的地方？

在写登录的时候，需要注意以下几个方面：

1. 用户输入校验：对于用户输入的用户名和密码，需要进行校验，防止用户输入恶意代码或者非法字符，从而导致安全问题。可以使用正则表达式或者其他校验方法对用户输入进行检查。

2. 密码加密存储：在数据库中保存用户密码时，需要对密码进行加密存储，避免因为数据库泄露而导致用户密码泄露。可以使用常见的加密算法，例如MD5、SHA等，或者使用更加安全的哈希算法，例如BCrypt等。

3. 防止暴力破解：为了防止恶意用户通过暴力破解密码来登录系统，可以对登录失败的次数进行限制，例如多次登录失败后锁定账号或者需要进行验证码验证。另外，可以对登录请求进行限速，防止暴力破解攻击。

4. CSRF防护：为了防止跨站请求伪造攻击（CSRF），需要在登录表单中添加CSRF token，并在服务器端验证该token是否正确。

5. SSL/TLS加密：为了保护用户的登录信息，在传输过程中需要使用SSL/TLS协议进行加密传输，避免信息被中间人窃取或者篡改。

6. 日志记录：在登录系统时，需要记录登录的时间、IP地址等信息，方便后续的安全审计和问题排查。

7. 账号安全：需要对账号进行管理，例如设置密码复杂度要求、定期修改密码、限制登录IP范围等措施，避免账号被恶意攻击。

综上所述，登录功能是系统中非常关键和重要的功能之一，需要在设计和实现时考虑多方面的安全问题，保证用户的信息和系统的安全。

 八十一、UUID的作用

UUID（Universally Unique Identifier，通用唯一识别码）是一种用于标识信息的32位十六进制数字，其作用主要有以下几个方面：

1. 唯一性：UUID是由计算机生成的，基本上可以保证每个UUID都是唯一的。因此，UUID可以作为数据表的主键或者唯一标识符，避免了数据冲突的风险。

2. 匿名性：UUID可以不涉及用户信息，保护用户隐私。例如，在网站中生成UUID作为会话ID，避免了使用用户真实姓名或者其他敏感信息作为会话ID的风险。

3. 分布式：UUID的生成不需要中心化的服务器，可以在分布式系统中保证数据的唯一性。例如，在微服务架构中，可以使用UUID作为请求ID，在各个服务之间进行追踪和调试。

4. 随机性：UUID的生成过程是随机的，因此可以用于生成随机的密码、密钥等。例如，在用户注册时，可以使用UUID作为默认密码，保证用户密码的随机性和安全性。

综上所述，UUID具有唯一性、匿名性、分布式和随机性等特点，可以在不同场景中用于唯一标识信息、保护用户隐私、分布式系统等方面，是一个非常有用的标识符。

八十二、Spring security有哪些安全性？

Spring Security是一个用于保护Spring应用程序的框架，提供了一系列的安全性措施，包括但不限于以下几个方面：

1. 认证：Spring Security提供了多种认证机制，包括基于表单的认证、基于HTTP Basic的认证、基于HTTP Digest的认证、基于LDAP的认证、基于OAuth2的认证等。这些认证机制能够有效地保护应用程序的用户身份安全。

2. 授权：Spring Security提供了一系列授权机制，包括基于角色的授权、基于资源的授权、基于注解的授权等。这些授权机制可以根据用户的身份和权限控制用户对应用程序资源的访问。

3. CSRF防护：Spring Security提供了内置的CSRF（跨站请求伪造）防护机制，可以有效地保护应用程序免受恶意攻击。

4. XSS防护：Spring Security提供了一系列XSS（跨站脚本攻击）防护机制，可以有效地保护应用程序免受恶意攻击。

5. Session管理：Spring Security提供了内置的Session管理机制，可以控制用户会话的过期时间、并发登录控制等，保护用户会话的安全性。

综上所述，Spring Security提供了多种安全性措施，可以保护应用程序的用户身份、资源访问、CSRF、XSS等安全问题，是一个非常有用的安全框架。

 八十三、跨域网站攻击？

跨域网站攻击（Cross-site scripting，简称XSS）是一种常见的网络攻击方式，攻击者通过注入恶意脚本代码，使得被攻击者在浏览器上执行这些脚本代码，从而实现对被攻击者的信息窃取、篡改等攻击目的。

具体来说，跨域网站攻击通常包括以下步骤：

1. 攻击者在一个网站上注入恶意脚本代码，例如在评论区或者搜索框中输入恶意代码。

2. 被攻击者访问该网站，并在浏览器中执行了攻击者注入的恶意代码。

3. 恶意代码在被攻击者的浏览器中执行，可以获取被攻击者的Cookie、密码等敏感信息，或者进行其他恶意操作，例如篡改网页内容、发起恶意请求等。 为了防止跨域网站攻击，可以采取以下几个措施：

1. 输入检查：在后端对用户的输入进行检查和过滤，避免输入中包含恶意代码。

2. 输出转义：在前端对用户输入的输出进行转义，避免恶意代码被执行。

3. 使用CSP：Content Security Policy（内容安全策略）可以限制页面中可以执行的代码，从而减少跨域网站攻击的风险。

4. 使用HttpOnly Cookie：HttpOnly Cookie只能在HTTP请求中传输，不能通过JavaScript获取，从而减少Cookie被窃取的风险。

综上所述，跨域网站攻击是一种常见的网络攻击方式，可以通过输入检查、输出转义、CSP、HttpOnly Cookie等方式进行防范。

八十四、在redis中什么时候用set？

在Redis中，set命令可以用来设置一个key的值，
常用于存储字符串或者整数值。

具体来说，set命令有以下用途：

1. 设置字符串值：可以使用set命令设置一个key的字符串值。

例如：

```
set mykey "hello world"
```

这样就会将"hello world"字符串存储到mykey这个key中。

2. 设置整数值：可以使用set命令设置一个key的整数值。

例如：

```
set mycounter 100
```

这样就会将整数值100存储到mycounter这个key中。

3. 设置带过期时间的值：可以使用set命令设置一个key的值，
并且指定这个值的过期时间。

例如：

```
set mykey "hello world" EX 10
```

这样就会将"hello world"字符串存储到mykey这个key中，
并且指定这个值的过期时间为10秒。

总的来说，set命令用于设置key的值，
可以存储字符串、整数等类型的值，并且可以指定过期时间。

八十五、BitMap

在Redis中，BitMap是一种特殊的数据结构，它可以用来存储二进制数据。
在BitMap中，每个位只能是0或1，
因此可以用来表示某个事件是否发生过，或者某个元素是否在集合中等。

在Redis中，BitMap可以使用setbit、getbit、bitcount、bitop等命令来进行操作。

1. setbit命令：用于设置某个位的值。它的语法如下：

   ```
   setbit key offset value
   ```

   其中，key表示要操作的BitMap的key，
offset表示要设置的位的偏移量，value表示要设置的值（0或1）。

   例如，下面的命令可以将mybitmap这个key中偏移量为10的位设置为1：

   ```
   setbit mybitmap 10 1
   ```

2. getbit命令：用于获取某个位的值。它的语法如下：

   ```
   getbit key offset
   ```

   其中，key表示要操作的BitMap的key，offset表示要获取的位的偏移量。

   例如，下面的命令可以获取mybitmap这个key中偏移量为10的位的值：

   ```
   getbit mybitmap 10
   ```

3. bitcount命令：用于获取BitMap中值为1的位的数量。它的语法如下：

   ```
   bitcount key [start end]
   ```

   其中，key表示要操作的BitMap的key，start和end表示要统计的范围（可以省略）。

   例如，下面的命令可以获取mybitmap这个key中值为1的位的数量：

   ```
   bitcount mybitmap
   ```

4. bitop命令：用于对多个BitMap进行逻辑运算。它的语法如下：

   ```
   bitop operation destkey key [key ...]
   ```

   其中，operation表示要进行的逻辑运算（AND/OR/XOR/NOT），
destkey表示运算结果的存储位置，key表示要参与运算的BitMap的key。

   例如，下面的命令可以将mybitmap1和mybitmap2两个BitMap进行OR运算，
并将结果存储到mybitmap3这个key中：

   ```
   bitop OR mybitmap3 mybitmap1 mybitmap2
   ```

总的来说，BitMap是一种非常高效的数据结构，
可以用来存储大量的二进制数据，而且在Redis中的操作也非常方便。
在实际开发中，可以使用BitMap来实现各种功能，
比如统计用户在线时间、过滤垃圾邮件、判断某个元素是否在集合中等。

八十六、redis中的序列化和反序列化？

在Redis中，序列化和反序列化是非常重要的概念，
它们是将数据转换成可传输和存储的格式，
以便在不同的应用程序和环境中使用。

Redis支持多种数据类型，包括字符串、列表、哈希表、集合和有序集合等。
当将这些数据类型存储在Redis中时，需要将它们转换为二进制格式，
以便于存储和传输。这个过程就是序列化。

Redis使用的是一种称为Redis序列化协议（Redis Serialization Protocol）的二进制协议。
该协议可以将Redis数据类型序列化为二进制数据，
并且可以通过反序列化将其还原为原始数据类型。

在Redis中，序列化和反序列化是自动进行的，
用户不需要显式地调用这些操作。当用户通过命令将数据存储在Redis中时，
Redis会自动将其序列化为二进制格式。当用户从Redis中检索数据时，
Redis会自动将其反序列化为原始数据类型。

例如，当用户使用以下命令将字符串“Hello, Redis!”存储在Redis中时：

```
SET mykey "Hello, Redis!"
```

Redis会将其序列化为以下二进制格式：

```
"\x00\x0eHello, Redis!"
```

当用户使用以下命令检索这个字符串时：

```
GET mykey
```

Redis会自动将其反序列化为原始字符串类型：“Hello, Redis!”

总的来说，在Redis中，序列化和反序列化是非常重要的概念，
它们可以让用户将各种数据类型存储在Redis中，
并且可以在不同的应用程序和环境中使用。
Redis序列化协议是一种高效、灵活和可扩展的协议，
可以满足各种数据序列化和反序列化的需求。

八十七、什么是java序列化？什么情况下需要序列化？

Java 序列化是为了保存各种对象在内存中的状态，并且可以把保存的对象状态再读出来。

以下情况需要使用 Java 序列化：

1. 想把的内存中的对象状态保存到一个文件中或者数据库中时候；
2. 想用套接字在网络上传送对象的时候；
3. 想通过 RMI（远程方法调用）传输对象的时候。

八十八、医生进行排班的时候需要考虑表结构的哪些方面？

医生进行排班时，需要考虑以下表结构方面：

1. 医生信息表：记录医生的基本信息，如姓名、性别、年龄、专业、工作经验等。

2. 排班表：记录医生的排班信息，如日期、时间、科室、门诊类型等。

3. 科室表：记录医院的科室信息，如科室名称、科室编号、科室地址等。

4. 门诊类型表：记录医院的门诊类型信息，如专家门诊、普通门诊、急诊等。

5. 排班类型表：记录排班的类型信息，如早班、晚班、全天班等。

6. 预约表：记录患者的预约信息，如预约时间、预约医生、患者姓名、电话等。

在设计表结构时，需要考虑以下方面：

1. 数据的一致性和完整性：确保医生的信息和排班信息的一致性和完整性，如确保医生不存在重复信息、排班信息不存在时间冲突等。

2. 数据的查询效率：优化排班表的查询效率，以便医生和患者能够快速地查询排班信息。

3. 数据的扩展性：确保表结构具有可扩展性，以便能够满足未来的需求，如新增科室、门诊类型等。

4. 安全性：确保表结构具有合理的权限控制和数据备份策略，以便保护医院的数据安全。

八十九、设计数据表结构的时候需要考虑哪些问题？

设计数据表结构时需要考虑以下几个方面：

1. 数据表的目的和功能：首先需要确定数据表的目的和功能，确定表中需要存储哪些数据。

2. 数据的一致性：数据表中的数据应该保证一致性，即相同的数据不应该出现重复记录，也不应该有冲突或矛盾的数据。

3. 数据的完整性：数据表中的数据应该保证完整性，即每条记录都应该包含必要的信息，没有缺失和不必要的数据。

4. 数据的可扩展性：考虑到后续数据的新增、删除和修改，需要确保数据表结构具有可扩展性，能够满足未来的需求。

5. 数据的查询效率：数据表结构应该优化查询效率，尽量减少查询时间，提高数据查询的效率。

6. 数据表的规范化：数据表结构应该符合规范化原则，即将数据拆分为多个表，避免数据冗余，提高数据的存储效率和查询效率。

7. 数据表的安全性：考虑到数据的安全性，需要设置合适的数据表访问权限和数据备份策略，确保数据的安全性和完整性。

总的来说，设计数据表结构需要考虑多方面的因素，需要在保证数据完整性、一致性和可扩展性的基础上，优化查询效率和提高数据的安全性。

九十、主键索引和普通索引有什么区别？

主键索引和普通索引的区别如下：

1. 主键索引是一种特殊的索引，用于唯一标识表中的每一行记录。而普通索引则是一种通用的索引，可以用于加速表中任意列的查询。

2. 主键索引必须是唯一的，且不能为空，而普通索引可以包含重复的值和空值。

3. 主键索引可以用来保证数据完整性和一致性，因为它可以防止插入重复的行和更新或删除不存在的行。而普通索引则只是用来提高查询效率。

4. 主键索引在创建表的时候就需要定义，而普通索引可以在表创建之后再添加。

5. 主键索引是一种聚集索引，它将表按照主键值的顺序存储。而普通索引是一种非聚集索引，它将索引值和行指针存储在一起。

6. 查询主键索引时，可以直接通过主键值进行查询。而查询普通索引时，需要先使用索引值查找行指针，再根据行指针查询数据。

因此，如果需要对表中的每一行记录进行唯一标识，或者需要保证数据完整性和一致性，就需要使用主键索引。而如果只需要加速某些列的查询，就可以使用普通索引。

九十一、索引的类型

在数据库中，索引是一种数据结构，用于提高数据的查询效率。索引可以根据其不同的数据结构和使用场景，分为以下几种类型：

1. B-Tree索引：B-Tree是一种树形结构，它可以在对数级别的时间复杂度内实现数据的查找、插入和删除操作。在数据库中，常用的B-Tree索引包括普通索引、唯一索引和主键索引等。

2. 哈希索引：哈希索引通过哈希算法来构建索引，可以快速地查找特定的数据，但对于模糊查询和范围查询效果不佳。

3. 全文索引：全文索引是用于文本数据的索引，可以在文本数据中快速查找特定的关键字或短语。

4. 聚集索引：聚集索引是按照数据的物理存储顺序构建的索引，可以有效地提高范围查询的效率。

5. 非聚集索引：非聚集索引是按照数据的逻辑顺序构建的索引，可以在数据的物理存储顺序发生变化时保持索引的完整性。

6. 空间索引：空间索引是用于存储空间数据的索引，可以快速地查找指定区域内的空间数据。

不同的索引类型适用于不同的场景和需求，需要根据具体的数据结构和查询需求来选择合适的索引类型。

 九十二、回表是什么意思？

回表（或者称为二次查询）是指在使用非聚集索引（如普通索引）进行查询时，需要访问数据表的物理行来获取完整的结果集，因为非聚集索引只包含索引列的值和指向数据行的指针，而不包含其他列的数据。这个过程需要进行第二次查询，因为第一次查询只能得到部分结果集。

例如，假设有一个包含id、name和age列的表，其中id列上创建了一个普通索引。当使用以下查询时，就会出现回表的情况：

```

SELECT name FROM table WHERE id=1;

```

这个查询使用id列上的普通索引进行查找，找到了id为1的行，但是需要访问数据表的物理行来获取name列的值。因为普通索引只包含索引列的值和指向数据行的指针，而不包含其他列的数据。

回表的操作会增加额外的访问成本和时间，特别是当需要返回的列很多时，因为需要访问的物理行数量也会增加。因此，尽可能地避免回表操作是优化查询性能的一个重要策略。

九十三、 什么情况下会出现回表

回表是指在使用索引查询时，MySQL 需要通过索引定位到行，然后再根据行的主键值去表中查找数据。这种情况通常出现在使用覆盖索引的查询中，即查询语句只使用了索引列，而没有使用 SELECT * 或者其他的列，也就是查询语句只需要从索引中获取数据，而不需要从表中读取数据。此时，MySQL 会使用索引覆盖查询来避免回表的操作，从而提高查询效率。

然而，如果查询语句需要读取表中的其他列，MySQL 就无法使用索引覆盖查询，只能先通过索引查找到行的主键值，然后再通过主键值去表中查找对应的数据，这个过程就需要回到表中进行查找，因此称为回表。

通常，出现回表的情况有以下几种：

1. SELECT 查询语句需要读取表中的所有列，而不是仅使用索引列。

2. 索引中未包含查询语句所需的全部列，需要回到表中查找。

3. 查询结果集中包含的行数较多，需要回到表中查找。 回表操作会增加查询的 IO 操作和 CPU 消耗，降低查询效率。

因此，在设计索引时，应该尽量避免回表操作，优化查询语句，或者适当添加适合的索引。

九十四、如何查看索引是否失效？

可以通过使用 Explain 或者 Show Index 命令来查看索引是否失效。

1. Explain 命令

Explain 命令用于查看 MySQL 数据库执行查询时的详细信息，其中包括使用的索引、扫描的行数、查询的类型等。如果索引失效，就会看到 extra 列中出现 Using where 或者 Using filesort，这意味着查询需要进行全表扫描或者排序操作，而不是使用索引。例如：

```

EXPLAIN SELECT * FROM table WHERE id = 1;

```

2. Show Index 命令

Show Index 命令用于查看指定表的索引信息，包括索引的名称、类型、包含的列等。如果索引失效，就会看到 Cardinality 列中的值非常小，这意味着索引不够稠密，不能很好地过滤数据。例如：

```

SHOW INDEX FROM table;

```

通过检查 Explain 和 Show Index 的结果，可以判断索引是否失效，进而进行优化索引的操作，提高查询性能。

九十五、SpringBoot中事务为什么会失效？

SpringBoot中事务失效的原因可能有多种，以下是一些常见的情况：

1. 事务传播机制不当

在 Spring 中，事务传播机制（Propagation）定义了事务方法如何在另一个事务方法中执行时进行交互。如果事务方法在一个没有事务的上下文中调用另一个事务方法，则调用的事务方法的事务将独立于调用方法的事务。如果事务方法在有事务的上下文中调用另一个事务方法，则调用的事务方法将加入到调用方法的事务中。因此，在使用事务时，需要根据业务需求选择适当的传播机制。如果传播机制不当，就会导致事务失效。

2. 数据库引擎不支持事务

在使用 MySQL 数据库时，如果使用的是 MyISAM 引擎，则无法支持事务。在这种情况下，使用 SpringBoot 的事务管理器也无法实现事务的功能。

3. 事务方法内部抛出异常被捕获

在 SpringBoot 中，事务默认只会在事务方法中发生未被捕获的异常时才会回滚事务。如果事务方法内部的异常被捕获，并在捕获后继续执行事务方法，事务就会失效。

4. 多线程环境下事务失效

在多线程环境下，每个线程都有自己的事务上下文，如果在一个线程中开启事务，然后在另一个线程中执行事务操作，就会导致事务失效。

5. 事务注解使用不正确

在使用 SpringBoot 中的事务注解时，需要根据业务需求选择正确的注解。例如，@Transactional 注解应该放在 public 方法上，否则它将不起作用，还可能导致事务失效。

综上所述，事务失效的原因可能有多种，需要根据具体情况进行排查和解决。在使用 SpringBoot 的事务时，需要选择适当的传播机制，保证数据库引擎支持事务，正确处理事务方法内部的异常，避免多线程环境下的事务问题，并且正确使用事务注解。

 九十六、事务在private上会不会失效？

在 Spring 中，事务是通过 AOP 实现的，只有 public 方法才能被 Spring AOP 拦截并添加事务，因此在 private 方法上添加 @Transactional 注解是无效的，事务也无法生效。

如果需要在 private 方法中使用事务，可以通过 AOP 的方式实现，手动创建事务管理器，并在方法中使用该事务管理器控制事务的提交和回滚。具体实现方式可以参考 Spring 的编程式事务管理。但是，建议在设计业务时避免在 private 方法中使用事务，应该将事务控制放在 public 方法中，以便更好地维护和管理事务。

九十七、同一个类上有两个方法A1和A2，A2有注解，A1去调用A2，事务是否会失效？

在 Spring 中，同一个类中的方法调用是不会触发事务的开启的，因为 Spring 的事务是基于 AOP 实现的，只有通过代理对象调用被代理的方法才会触发事务的开启。如果在同一个类中的方法之间进行直接调用，那么事务是不会生效的，因为没有经过代理对象的包装。

对于这种情况，可以考虑将需要进行事务控制的方法放在不同的类中，并通过依赖注入的方式来调用。或者可以通过编程式事务管理的方式，在方法中手动开启事务并控制事务的提交和回滚。具体实现方式可以参考 Spring 的编程式事务管理。

九十八、 为什么要使用RabbitMQ？

RabbitMQ 是一个可靠、高效、可扩展的消息中间件，它为分布式应用程序提供了一种传递消息的方式。以下是使用 RabbitMQ 的一些优点：

1. 可靠性：RabbitMQ 通过持久化、传输确认和高可用性等机制，确保消息能够可靠地被传递和处理。

2. 异步通信：通过 RabbitMQ，应用程序之间可以异步通信，从而提高了系统的吞吐量和性能。

3. 解耦合：通过将应用程序解耦合，可以更容易地对系统进行维护、升级和扩展。

4. 灵活性：RabbitMQ 支持各种消息传递模式，包括点对点、发布/订阅、路由和主题等，可以满足各种场景下的需求。

5. 可扩展性：RabbitMQ 支持集群部署和负载均衡，可以通过增加节点和分布式部署来提高系统的可扩展性和容错性。

综上所述，RabbitMQ 是一种非常优秀的消息中间件，可以帮助开发人员快速构建分布式系统，并提供可靠、高效、可扩展的消息传递服务。

九十九、编写接口应该考虑哪些方面？

编写接口时应该考虑以下方面：

1. 接口设计：接口应该设计清晰、简单易用，并且符合 RESTful API 的规范，包括 URI 命名规范、HTTP 动词的使用等。

2. 接口安全：接口应该考虑安全性，包括身份认证、授权、防止 CSRF 攻击等。

3. 接口参数验证：接口参数应该进行验证，避免不合法的参数传递进来，导致系统异常或数据被篡改。

4. 接口响应：接口应该返回清晰的响应信息，包括状态码、错误信息等。

5. 接口文档：接口应该提供文档，包括接口使用说明、参数说明、返回值说明等，方便开发人员使用和维护。

6. 接口性能：接口应该具有良好的性能，包括响应时间、并发量等。

7. 接口版本：接口应该考虑版本控制，确保接口的兼容性和可维护性。

综上所述，编写接口需要考虑多个方面，从接口设计、安全性、参数验证、响应信息、文档、性能和版本控制等方面进行全面考虑，以保证接口的质量和可用性。

宇佑船舶

一百、Mybatis往MySQl插入一条数据，如何获得自增ID？

在 MyBatis 中，可以通过配置自动生成的键来获取插入数据的自增 ID。具体步骤如下：

1. 在插入数据的 SQL 语句中，添加 `useGeneratedKeys="true"` 
和 `keyProperty="id"` 属性，如下所示：

   ```xml
   <insert id="insertUser" parameterType="User" useGeneratedKeys="true" keyProperty="id">
     insert into user (name, age, gender) values (#{name}, #{age}, #{gender})
   </insert>
   ```

   其中，`useGeneratedKeys="true"` 表示使用自动生成的键，
`keyProperty="id"` 表示将自动生成的键赋值给 `User` 对象的 `id` 属性。

2. 在插入数据的方法中，使用 `SqlSession` 的 `insert` 方法执行 SQL 语句，
并获取自增 ID，如下所示：

   ```java
   public void insertUser(User user) {
       try (SqlSession session = sqlSessionFactory.openSession()) {
           session.insert("insertUser", user);
           System.out.println("插入数据成功，自增 ID 为：" + user.getId());
           session.commit();
       }
   }
   ```

   其中，`SqlSession` 是 MyBatis 中用于执行 SQL 语句的核心类，
`session.insert("insertUser", user)` 
表示执行名为 `insertUser` 的 SQL 语句，
并将 `user` 对象作为参数传入。
在执行 SQL 语句后，`user` 对象的 `id` 属性将被赋值为自增 ID。

综上所述，通过配置自动生成的键，可以在 MyBatis 中获取插入数据的自增 ID。

一百零一、如何向布隆过滤器插入数据？插入单个数据和多个数据的命令是什么？

向布隆过滤器插入单个数据的步骤和向布隆过滤器插入多个数据的步骤是一样的。
可以先创建一个布隆过滤器对象，
然后使用 `put` 方法向其中插入单个数据，
如下所示：

```java
BloomFilter<String> bloomFilter = BloomFilter.create(Funnels.stringFunnel(Charset.defaultCharset()), 1000000, 0.001);
bloomFilter.put("apple");
```

在上面的例子中，我们创建了一个大小为 1000000，
误判率为 0.001 的布隆过滤器，
并向其中插入了一个字符串 `apple`。

注意：在使用布隆过滤器时，
需要根据实际情况选择合适的大小和误判率，
以及合适的哈希函数个数。如果哈希函数个数过少，
会导致误判率增加；如果哈希函数个数过多，
会增加计算时间和空间开销。

一百零二、java中有哪些权限验证框架？

Java中常用的权限验证框架包括：

1. Spring Security：Spring Security 是 Spring 框架的安全框架，提供了身份验证和授权功能，支持多种身份验证方式和授权策略。

2. Shiro：Apache Shiro 是一个强大且易用的 Java 安全框架，提供了认证、授权、加密、会话管理等功能，并且易于扩展和集成。

3. Apache Ranger：Apache Ranger 是一个开源的权限管理框架，提供了细粒度的访问控制和策略管理功能，支持 Hadoop、Hive、HBase、Kafka 等开源组件。

4. Apache Sentry：Apache Sentry 是另一个开源的权限管理框架，提供了细粒度的数据访问控制功能，支持 Hive、Impala、Solr、HBase 等组件。

5. Spring ACL：Spring ACL 是 Spring 框架提供的基于 ACL（Access Control List）的权限管理框架，可以对对象和资源进行细粒度的访问控制。

这些框架都提供了丰富的功能和扩展点，可以根据具体的需求选择合适的框架。

 一百零三、Spring Security验证原理?

Spring Security 的验证原理基于 Spring 框架的拦截器机制和 Filter 链。

当请求进入系统时，首先会被 Spring Security 的 Filter 链拦截，
Filter 链中包含了多个 Filter，每个 Filter 负责不同的验证逻辑，
如身份验证、授权、跨域等。

其中，最核心的是 `UsernamePasswordAuthenticationFilter`，
它负责处理用户名和密码的验证逻辑。当用户提交了登录表单后，`UsernamePasswordAuthenticationFilter` 会将用户名和密码封装成 `UsernamePasswordAuthenticationToken` 对象，
并将其传递给身份验证管理器 `AuthenticationManager` 进行验证。

身份验证管理器 `AuthenticationManager` 
是 Spring Security 的核心组件之一，
它负责管理多个身份验证器 `AuthenticationProvider`，
每个身份验证器都负责一种验证方式，如用户名密码验证、LDAP 验证、OpenID 验证等。`AuthenticationManager` 会依次调用每个身份验证器进行验证，
如果其中任意一个验证通过，则表示身份验证成功。

在身份验证成功后，`UsernamePasswordAuthenticationFilter` 
会生成一个 `Authentication` 对象，
并将其传递给 `AuthenticationSuccessHandler` 处理器，
`AuthenticationSuccessHandler` 会根据具体的业务逻辑进行处理，
如跳转到登录后的页面等。

如果身份验证失败，则 `UsernamePasswordAuthenticationFilter` 会将错误信息封装成 `AuthenticationException` 对象，
并将其传递给 `AuthenticationFailureHandler` 处理器，
`AuthenticationFailureHandler` 会根据具体的业务逻辑进行处理，
如跳转到登录页面并显示错误信息等。

需要注意的是，Spring Security 的身份验证机制是基于 Spring 框架的 AOP 机制实现的。
在使用 Spring Security 时，
需要在 Spring 配置文件中配置相应的拦截器和过滤器，
并将其关联到需要进行身份验证的 URL 或方法上。

一百零四、java开发中什么情况下会使用Aop，它的作用和意义是什么？

在 Java 开发中，AOP（面向切面编程）主要用于解决系统中的横切关注点问题。横切关注点是指分布在系统各处的功能需求，例如日志记录、安全控制、事务管理等。这些需求会跨越不同的对象和模块，导致代码分散、重复和难以维护。

AOP 的作用是将这些横切关注点从业务逻辑中分离出来，形成独立的切面，使得业务逻辑只关注自己的核心功能，而不必关注这些横切关注点。通过 AOP，可以将这些横切关注点统一管理，从而提高系统的可维护性、可扩展性和可重用性。

在 Java 开发中，AOP 可以应用于以下几种情况：

1. 日志记录：记录系统中的操作日志、异常信息等，用于系统的故障排查和优化。

2. 安全控制：控制系统中的访问权限，保护系统的安全性。

3. 缓存管理：管理系统中的缓存，提高系统的性能。

4. 事务管理：管理系统中的事务，保证系统的数据一致性。

5. 性能监控：监控系统的性能指标，进行性能优化和调优。

AOP 的主要意义是将系统中的横切关注点抽象出来，形成独立的切面，从而提高系统的可维护性、可扩展性和可重用性。同时，AOP 可以帮助开发人员更好地理解系统中的业务逻辑和横切关注点，提高开发效率和代码质量。

一百零五、 如何使用Git查看做了哪些修改？

Git 可以通过 `git diff` 命令来查看修改前后的差异，
包括修改了哪些内容以及修改的具体内容。
使用 `git diff` 命令需要指定需要比较的两个版本，
可以通过以下方式进行比较：

1. 比较工作区和暂存区的差异：

```
git diff
```

2. 比较工作区和指定版本之间的差异：

```
git diff <commit>
```

3. 比较指定两个版本之间的差异：

```
git diff <commit1> <commit2>
```

在 `git diff` 命令执行后，会显示出所有被修改的文件，
以及每个文件中被修改的具体内容。如果想要查看修改的命令，
可以通过 `--patch` 或 `-p` 选项来实现，例如：

```
git diff --patch
```

或者简写为：

```
git diff -p
```

这样会在差异显示的基础上，以 patch 的形式显示出每个修改的命令。

钛镕科技

一百零六、线程的创建有哪些方式？

一百零七、线程中sleep方法中，休眠1000毫秒，什么时候会启动？

在调用Thread.sleep方法时，会让当前线程暂停指定的时间，以便给其他线程机会来执行。具体来说，当线程执行sleep方法时，线程进入阻塞状态，暂停执行，等待指定的时间到期，然后重新进入就绪状态，等待CPU调度。

在1000毫秒的情况下，如果当前线程没有被其他线程打断，那么1000毫秒之后，该线程会重新进入就绪状态，等待CPU的调度来执行任务。如果在这1000毫秒之前，其他线程调用了该线程的interrupt()方法来打断该线程，那么该线程会立即结束sleep状态，抛出InterruptedException异常，然后重新进入就绪状态，等待CPU的调度。

一百零八、String 和 StringBuffffer、 StringBuilder 的区别是什么？

可变性

String 类中使用 final 关键字修饰字符数组来保存字符串，所以String 对象是不可变的。 而 StringBuilder 与 StringBuffer 都继承自 AbstractStringBuilder 类，在 AbstractStringBuilder 中也是 使用字符数组保存字符串 char[]value 但是没有用 final 关键字修饰，

所以这两种对象都是可变的。

线程安全性

String 中的对象是不可变的，也就可以理解为常量，线程安全。StringBuffer 对方法加了同步锁或者对调用的方法加了同步锁，所以是 线程安全的。 StringBuilder 并没有对方法进行加同步锁，所以是非线程 安全的。

性能

每次对 String 类型进行改变的时候，都会生成一个新的 String 对象， 然后将指针指向新的 String 对象。 StringBuffer 每次都会对 StringBuffer 对象本身进行操作，而不是生成新的对象并改变对象引 用。相同情况下使用 StringBuilder 相比使用 StringBuffer 仅能获 得 10%~15% 左右的性能提升，但却要冒多线程不安全的风险

 一百零九、ArrayList和LinkedList的区别？

ArrayList: 基于动态数组，连续内存存储，适合下标访问（随机访问 ) ，扩容机制 : 因为数组长度固定，超出长度存数据时需要新建数组，然后将老数组 的数据拷贝到新数组，如果不是尾部插入数据还会涉及到元素的移动 ( 往后复 制一份，插入新元素 ) ，使用尾插法并指定初始容量可以极大提升性能、甚至 超过 linkedList ( 需要创建大量的 node 对象 )

LinkedList: 基于链表，可以存储在分散的内存中，适合做数据插入及删除 操作，不适合查询 : 需要逐一遍历，遍历 LinkedList 必须使用 iterator ， 不能使用 for 循环，因为每次 for 循环体内通过 get(i) 取得某一元素时都需 要对 list 重新进行遍历，性能消耗极大。

 一百一十、MySQL优化？

MySQL 是一个非常流行的关系型数据库，使用得当可以提供高效的数据存储和查询。以下是一些常见的 MySQL 优化技巧：

1. 使用索引：索引可以提高查询效率，因此在设计表结构时应该考虑到查询的需求，并为经常用于查询条件的列添加索引。但是，过多的索引会增加写入的开销，因此应该避免过度索引。

2. 优化查询语句：避免使用 SELECT * 查询所有列，只选择必要的列。使用 LIMIT 限制返回结果的数量，避免一次性返回大量数据。在使用 JOIN 时，可以使用 INNER JOIN 或者 LEFT JOIN 等合适的连接方式。

3. 避免使用 SELECT DISTINCT：SELECT DISTINCT 会进行全表扫描，效率较低，如果需要去重可以使用 GROUP BY。

4. 合理使用缓存：使用缓存可以减少查询的次数，提高性能。MySQL 自带了查询缓存功能，但是在高并发的情况下效率不高，因此可以考虑使用其他缓存方案，例如 Memcached 或 Redis。

5. 避免使用子查询：子查询效率较低，可以使用 JOIN 代替子查询。

6. 分区表：对于数据量较大的表，可以使用分区表来提高查询效率。

7. 优化数据类型：选择合适的数据类型可以节省存储空间和提高查询效率。例如，对于一个只有 0 或 1 的布尔类型，可以使用 TINYINT(1) 来代替 BOOL。

8. 避免过度规范化：过度规范化会导致 JOIN 操作的频繁使用，降低查询效率。

9. 定期清理无用数据：无用数据会占用存储空间和影响查询效率，因此需要定期清理。

10. 升级硬件：在高并发的情况下，升级硬件可以提高 MySQL 的性能，例如增加 CPU 核心数、内存等。

综上所述，MySQL 优化需要从多个方面考虑，包括索引、查询语句、缓存、数据类型、规范化、清理数据和硬件升级等。

一百一十一、什么情况下使用Redis？

Redis 是一个高性能的键值对存储数据库，具有快速、可靠、灵活和可扩展等特点。它被广泛应用于多种场景，以下是 Redis 常见的使用场景：

1. 缓存：Redis 最常用的场景是作为缓存，可以将经常被查询的数据缓存在 Redis 中，减少数据库的查询次数，提高网站的访问速度。

2. 计数器：Redis 提供了对数字的自增、自减操作，可以用于计数器的实现，例如网站的访问次数、文章的阅读量等。

3. 分布式锁：Redis 支持分布式锁的实现，可以用于实现分布式系统中的同步控制。

4. 队列：Redis 提供了 List 类型的数据结构，可以用于实现队列，例如任务队列、消息队列等。

5. 发布订阅：Redis 支持发布订阅的模式，可以用于实现消息的发布和订阅，例如聊天室、实时推送等。

6. 地理位置应用：Redis 支持地理位置的存储和查询，可以用于实现附近的人、附近的店等应用。

7. 会话缓存：Redis 可以作为分布式系统中的会话缓存，可以实现多台服务器之间的会话共享。

8. 数据库：Redis 还可以作为数据库使用，支持多种数据结构和复杂的操作，例如 Hash、Set、Sorted Set 等。

综上所述，Redis 的使用场景非常广泛，包括缓存、计数器、分布式锁、队列、发布订阅、地理位置应用、会话缓存和数据库等。根据不同的业务需求，可以选择合适的使用场景。

一百一十二、Redis哨兵机制？

Redis 哨兵（Sentinel）是 Redis 官方提供的一种高可用性解决方案，它可以自动监控 Redis 主从节点的状态，并在主节点故障时自动切换到备用节点，从而保证 Redis 服务的高可用性。

Redis 哨兵机制的主要作用有：

1. 监控 Redis 主从节点的状态，包括节点是否在线、节点的复制状态、节点的主从关系等。

2. 当主节点失效时，自动将备用节点切换为主节点，并通知客户端修改连接地址。

3. 自动进行故障恢复，包括重新连接节点、重新同步数据等。

Redis 哨兵机制的实现原理如下：

1. 每个 Redis 哨兵进程会周期性地向 Redis 主节点和备用节点发送命令，以检测节点的状态。

2. 当 Redis 哨兵检测到 Redis 主节点失效时，它会自动选举一个备用节点作为新的主节点，并通知其他 Redis 哨兵和客户端。

3. 当 Redis 哨兵检测到主节点重新上线时，它会将备用节点切换为从节点，并重新同步数据。

4. Redis 哨兵会记录节点的状态变化和故障恢复情况，并定期将这些信息发送给其他 Redis 哨兵和客户端。

综上所述，Redis 哨兵机制可以提高 Redis 的可用性和可靠性，使 Redis 可以在主节点故障时自动切换到备用节点，从而保证 Redis 服务的高可用性。

一百一十三、 Redis做集群搭建的好处？

Redis 做集群搭建的好处有以下几点：

1. 高可用性：Redis 集群可以将数据分散存储在多个节点上，当某个节点故障时，数据仍然可以在其他节点上访问，从而提高了系统的可用性。

2. 高性能：Redis 集群可以使用多台服务器处理大量的请求，从而提高了系统的性能。

3. 数据分布均衡：Redis 集群可以将数据分布在多个节点上，从而实现数据的均衡分布，提高系统的负载能力。

4. 横向扩展：Redis 集群可以通过增加节点来扩展系统的处理能力，从而实现横向扩展。

5. 高可靠性：Redis 集群可以使用主从复制机制来保证数据的可靠性，当主节点故障时，备份节点可以自动接管主节点的工作，保证数据不会丢失。

综上所述，Redis 做集群搭建可以提高系统的可用性、性能、负载能力和可靠性，是一种非常有用的技术方案。

一百一十四、MQ的使用场景？

MQ（消息队列）是一种高效的异步通信机制，主要用于解耦和异步处理。

以下是MQ的常见使用场景：

1. 异步处理：通过MQ可以将消息发送到消息队列，然后异步地处理这些消息，从而避免了长时间等待的情况，提高了系统的性能。

2. 解耦：通过MQ可以将不同的模块之间的耦合度降低，从而使得系统更加灵活和易于维护。

3. 流量控制：通过MQ可以实现流量控制，避免系统过载和崩溃。

4. 日志处理：通过MQ可以将日志消息发送到消息队列，然后异步地处理这些消息，从而避免了对日志处理的影响。

5. 实时计算：通过MQ可以将大量的数据发送到消息队列，然后使用实时计算引擎对这些数据进行处理和分析，从而实现实时计算。

6. 任务分发：通过MQ可以将任务分发到不同的处理节点，从而实现任务的分布式处理。

综上所述，MQ在解耦、异步处理、流量控制、日志处理、实时计算和任务分发等方面都有广泛的应用场景。

一百一十五、RabittMQ如何不丢失消息？

• 生产者丢失消息：如网络传输中丢失消息、MQ 发生异常未成功接收消息等情况。  解决办法：主流的 MQ 都有确认或事务机制，可以保证生产者将消息送达到 MQ。如 RabbitMQ 就有事务模式和 confirm 模式。
• MQ 丢失消息：MQ 成功接收消息内部处理出错、宕机等情况。  解决办法：开启 MQ 的持久化配置。
• 消费者丢失消息：采用消息自动确认模式，消费者取到消息未处理挂掉了。  解决办法：改为手动确认模式，消费者成功消费消息再确认。

一百一十六、分布锁怎么实现？

实现分布式锁的一种常用方式是使用 Redis 实现。以下是一种基于 Redis 的分布式锁实现方式：

1. 客户端在获取锁时，使用 Redis 的 SETNX 命令，将锁作为一个 key 存储到 Redis 中，同时设置一个过期时间，避免锁一直占用。

2. 如果 SETNX 命令返回值为 1，表示获取锁成功，客户端执行相应的业务逻辑。

3. 如果 SETNX 命令返回值为 0，表示获取锁失败，客户端等待一段时间后重新尝试获取锁。

4. 在释放锁时，客户端使用 Redis 的 DEL 命令，删除锁对应的 key。

这种方式实现的分布式锁，存在一些问题，如锁不可重入，死锁等。为了解决这些问题，可以使用 Redlock 算法来实现分布式锁。 Redlock 算法是一个基于多个 Redis 节点的分布式锁算法，通过在多个节点上获取锁，来提高分布式锁的可靠性和稳定性。