面试题汇总（中级）

爱被打了一巴掌 2023-10-10 16:15 18阅读 0赞

1.  ### **面向对象三大基本特征** ###

封装：程序模块化、对象化，把具体事物的特性属性和通过这些属性来实现一些动作的具 体方法放到一个类里面；

继承：父类被子类重复使用；

多态：重载：在同一类中1.方法名相同； 2.参数列表不同；

重写：在父子类中两同：方法名相同，参数列表相同；

两小：返回值类型，抛出的异常，小于等于父类中的方法；

一大：访问修饰词大于等于父类方法的修饰词；

1.  ### **==和equals区别**  ###

\`==\`: 两方为基本类型则比较数值是否相等；

引用类型,则比较地址是否相等；

equals:比较两个独立对象的内容是否相同；

1.  ### **八大基本类型** ###

1)byte:字节型，用于存储整数的，占用1个字节，范围-128到127；

2)short:短整型，用于存储整数的，占用2个字节，范围-32768到32767；

3)int:整型，用于存储整数的，占用4个字节，范围-2^31到2^31-1；

4)long:长整型，用于存储较大的整数的，占用8个字节，范围-2^63到2^63-1；

5)float:单精度浮点数，用于存储小数的，占用4个字节，不能表示精确的值；

6)double:双精度浮点数，用于存储小数的，占用8个字节，不能表示精确的值；

7)boolean:布尔型，用于存储true或false，占用1个字节，00000001/00000000；

8)char:字符型，采用Unicode字符集编码，用于存储单个字符，占用2个字节；

1.  ### **String、StringBuilder和StringBuffer区别,哪个效率高, 为什么?** ###

String对象不可变,stringbuffier和stringbuilder对象是可变的；

1.  执行速度：StringBuilder > StringBuffer > String；

1.  线程安全：StringBuilder是线程不安全的，而StringBuffer是线程安全的；

String：适用于少量的字符串操作的情况；

StringBuilder：适用于单线程下在字符缓冲区进行大量操作的情况；

StringBuffer：适用多线程下在字符缓冲区进行大量操作的情况；

1.  ### **Spring框架两个核心** ###

1.  IOC（Inversion of control）控制反转，将对象object 的创建的权利及对象的生命周期的管理过程交由spring框架来处理。开发过程中不需要关注对象的创建和生命周期的管理，而是在需要的时候由spring框架提供；

1.  DI（Dependency Injection）依赖注入，在创建对象的过程中spring可以依据对象的关系，自动把其他对象注入（无需创建对象，直接拿着使用）；

备注：IOC种思想DI是实现这种思想的手段；

1.  ### **Spring依赖注入的三种方式**  ###

Spring容器中支持的依赖注入方式主要有属性注入、构造函数注入、工厂方法注入；

1.  属性注入：默认的构造函数，该属性的set方法；

1.  构造函数注入：带参的构造函数；

1.  Spring工厂注入的方法可以分为静态和非静态两种；

⑴有些工厂方法是非静态的，必须实例化工厂类之后才能调用工厂方法。

⑵很多工厂类方法都是静态的，这意味着无需创建工厂类实例的情况下就可以调用工厂类方法。因此静态工程方法比非静态工厂方法的调用更加方便简洁。

1.  ### **介绍一下AOP** ###

AOP:面向切面编程，将一个系统中共同的业务逻辑提取出来,进行单独的封装成一个组件(切面),然后以配置的方式作用于系统中,实现程序的可插拔性,提高代码的复用性,提升系统的灵活性和性能；

底层实现:JDK动态代理,只支持接口注入CGLIB（动态代理）:可以支持普通类的注入；

那些地方会用到:事物开启,日志记录,安全验证,权限验证；

切面:系统中共同的业务提取出来,在某个时刻或者某个阶段共同调用；

切入点:找到目标方法,给它追加共通的业务逻辑；

通知:什么时候调用这个共通的业务逻辑,用于指定切面方法作用到系统中的时机.前置通知,后置通知,环绕通知,异常通知,最终通知；

类上定义：@Aspect @Component

方法上定义：@Before前置通知，相当于BeforeAdvice

@AfterReturning 后置通知，相当于AfterReturningAdvice

@Around环绕通知，相当于MethodInterceptor

@AfterThrowing抛出通知，相当于ThrowAdvice

@After最终final通知，不管是否异常，该通知都会执行

1.  ### **说一下Spring和Springboot常用注解** ###

核心注解：@SpringBootConfiguration、@EnableAutoConfiguration、@ComponentScan

控制层：@Controller、@RequestBody、@ResponBody、@RestController、 @RequestMapping、@PathVariable、@Validated、@RequestParam、@GetMapping、 @PostMapping

业务层：@service、@Transactional 窗咱克受、@Autowired、@Resource

持久层：@Respoestory

配置层：@configuration

Aop: @component

1.  ### **简单介绍一下mysql数据库字段类型** ###

数值类型：tinyint、smallint、mediumint、int、bigint、float、double、decimal

字符串类型：char、varchar、tinytext、text

日期时间类型：date、time、datetime

1.  ### **String是否可以被继承** ###

不能被继承，因为string是被final

1.  ### **sql优化** ###

1.  查询时，能不用\* 就不用，尽量写全字段名；

1.  索引不是越多越好，每个表控制在6个索引以内。where条件的情况下，索引不起作用；

1.  大部分情况连接效率远大于子查询；

1.  多用explain 和 profile分析查询语句 explain模拟优化器执行sql查询；

1.  有时候可以1条大的SQL可以分成几个小SQL顺序执行，分了吧，速度会快很多；

1.  每隔一段时间用alter table table\_name engine=innodb;优化表；

1.  连接时注意:小表jion 大表的原则；

1.  学会用explain 和 profile判断是什么原因使你的SQL慢；

1.  查看慢查询日志，找出执行时间长的SQL进行优化；

1.  尽量避免使用order by；

11. where子句后面执行顺序是从右到左，尽量把能过滤掉大部分数据的条件放在最后；

1.  ### **redis在哪些场景下使用** ###

（1）热点数据的缓存 （2）消息队列 （3）秒杀时的预热缓存 （4）秒杀时的库存管理

1.  ### **如果给你三个同公司的系统，你如何实现三者的单点登录** ###

1.客户端发送请求，响应单点登录服务器；

2.第一次进入单点登录服务器，进入JWT解析的过滤器，判断JWT无效进入白名单直接放行；

3.进入控制层，找到对应的方法进行业务层调用；

4.获取用户名和密码通过Authentication进行认证，生成JWT设置算法、将ID、用户名和权限存入JWT、设置生效时间、设置盐；

5.将生成的jwt返回，存入前端的cookea中当下次登录时会进入过滤器；

6.进入过滤器进行jwt解析：清空Security上下文，从请求头中获取到jwt，校验jwt是否有效，jwt无效放行进入白名单，设置响应结果类型和编码格式，进行JWT解析，解析完成将用户名、ID、权限封装到Authentication对象中，存入Secutrity上下文中；

1.  ### **列出几条阿里巴巴代码规范**  ###

1.  【强制】代码中的命名均不能以下划线或美元符号开始和结尾

1.  类名大驼峰，包名小驼峰，名字要见名之意

1.  【强制】不允许任何魔法值（即未经定义的常量）直接出现在代码中。

1.  【强制】long 或者 Long 初始赋值时，使用大写的 L，不能是小写的l

1.  【强制】大括号的使用约定。如果是大括号内为空，则简洁地写成\{\}即可，不需要换行；如果 是非空代码块则： 1） 左大括号前不换行。 2） 左大括号后换行。 3） 右大括号前换行。 4） 右大括号后还有 else 等代码则不换行；表示终止的右大括号后必须换行。

1.  【强制】if/for/while/switch/do 等保留字与括号之间都必须加空格。

1.  【强制】注释的双斜线与注释内容之间有且仅有一个空格。

1.  【强制】避免通过一个类的对象引用访问此类的静态变量或静态方法，无谓增加编译器解析成本，直接用类名来访问即可。

1.  ### **mysql存储引擎** ###

不同的存储引擎提供不同的存储机制、索引技巧、锁定水平等功能，使用不同的存储引擎，还可以获得特定的功能。现在许多不同的数据库管理系统都支持多种不同的数据引擎。

InnoDB是默认事务型引擎，是目前最重要、使用最广泛的存储引擎。支持事务安全表（ACID），行锁定和外键。

底层结构：将数据保存到磁盘中，内存中也会保存一份数据，当用户进行查询时会先从内存中查找，内存中没有就会去磁盘中找，进行写操作会先修改内存中的数据，内存通过缓冲将数据写入磁盘中，读写效率快

1.  ### **什么是mysql的锁** ###

Mysql有全局锁、表级锁、行锁

**全局锁：**让一个数据库只读或只写

**表级锁**：多线程进行增删改操作时排队进行，也可以设置只读或只写，读取时不需要排队

**行锁**：多线程进行增删改操作时排队进行，并记录日志

1.  ### **乐观锁和悲观锁的区别** ###

悲观锁：当访问数据库的时候会认为你会修改，所以会上锁，共享资源时会进行排队，一个线程执行完下一个线程才可以进行访问

乐观锁：当访问数据库的时候会认为你不会修改，所以不会上锁，但是更新时会判断是否被修改，适用于多读场景，提高了数据库的吞吐量

1.  ### **说一下spring cloud 组件** ###

spring cloud是一个标准型的微服务解决方案，面对各个环节的问题都可以找到相应的组件进行处理

常用的组件：Spring Cloud Netflix 、Spring Cloud Alibaba

Netflix（奈飞）：

Eureka（注册中心）、Zuul（网关）、Ribbon（负载均衡）、Feign（远程调用）、Hystrix（监控和断路器）Config（配置中心）

Alibaba：

Nacos（注册和配置中心）、sentinel（限流）、dubbo（封装调用）、RocketMQ（分布式消息）、OSS（商业化储存服务）、schedulerX（定时作业调度服务）、SMS（全球短信服务）、seata（分布式事务）

1.  ### **介绍这些组件的作用** ###

Sentinel：把流量作为切入点，从流量控制、熔断降级、系统负载保护等多个维度保护服务的稳定性。

Nacos：一个更易于构建云原生应用的动态服务发现、配置管理和服务管理平台。

RocketMQ：一款开源的分布式消息系统，基于高可用分布式集群技术，提供低延时的、高可靠的消息发布与订阅服务。

Dubbo：Apache Dubbo 是一款高性能 Java RPC 框架。Rpc是远程调用内部是utf-8 传输的对象必须要序列化

Seata：阿里巴巴开源产品，一个易于使用的高性能微服务分布式事务解决方案。

Alibaba Cloud OSS : 阿里云对象存储服务（Object Storage Service，简称 OSS），是阿里云提供的海量、安全、低成本、高可靠的云存储服务。您可以在任何应用、任何时间、任何地点存储和访问任意类型的数据。

Alibaba Cloud SchedulerX: 阿里中间件团队开发的一款分布式任务调度产品，提供秒级、精准、高可靠、高可用的定时（基于 Cron 表达式）任务调度服务。

Alibaba Cloud SMS：覆盖全球的短信服务，友好、高效、智能的互联化通讯能力，帮助企业迅速搭建客户触达通道。

Eureka：服务注册和发现，它提供了一个服务注册中心、服务发现的客户端，还有一个方便的查看所有注册的服务的界面。 所有的服务使用Eureka的服务发现客户端来将自己注册到Eureka的服务器上。

Zuul：网关，所有的客户端请求通过这个网关访问后台的服务。他可以使用一定的路由配置来判断某一个URL由哪个服务来处理。并从Eureka获取注册的服务来转发请求。

Ribbon：即负载均衡，Zuul网关将一个请求发送给某一个服务的应用的时候，如果一个服务启动了多个实例，就会通过Ribbon来通过一定的负载均衡策略来发送给某一个服务实例。

Feign：服务客户端，服务之间如果需要相互访问，可以使用RestTemplate，也可以使用Feign客户端访问。它默认会使用Ribbon来实现负载均衡。

Hystrix：监控和熔断器。我们只需要在服务接口上添加Hystrix标签，就可以实现对这个接口的监控和断路器功能。

Hystrix Dashboard：监控面板，他提供了一个界面，可以监控各个服务上的服务调用所消耗的时间等。

Turbine：监控聚合，使用Hystrix监控，我们需要打开每一个服务实例的监控信息来查看。而Turbine可以帮助我们把所有的服务实例的监控信息聚合到一个地方统一查看。这样就不需要挨个打开一个个的页面一个个查看。

1.  ### **介绍redis功能作用** ###

缓存数据，内部是存的键值对，保存在内存中，所以读的效率非常高，容量非常大

在不同的领域访问数据时提高了速度，可以进行预加载，在高并发时提高了效率

消息队列、高并发的数据预热、操作库存、缓存数据

（1）热点数据的缓存 （2）消息队列 （3）秒杀时的预热缓存 （4）秒杀时的库存管理

1.  ### **数据库原理是什么** ###

1.  客户端请求连接服务器，开启线程响应用户

1.  用户发起sql语句查询数据库

1.  查询缓存：记录用户的sql查询语句。如果查询相同内容，就返回缓存

1.  如果缓存中没有对应结果，则进入分析器：解析语法是否正确，获得用户要查询的表，内容，权限等

1.  优化：执行路径的选择，生成执行树，每一个sql有很多的执行路径，优化的目的就是在这些路径中，选择最优的执行路径

1.  存储引擎：用于管理的数据管理系统。它上层应用提供了不同的管理，有支持事务的，也有不支持事务的

1.  ### **mysql三大范式** ###

第一范式（确保每列保持原子性）最基本范式。数据库表中所有字段值都是不可分解的原子值，就满足了第一范式。

第二范式（确保表中的每列都和主键相关）在第一范式上更近一层。确保数据库表中的每一列都和主键相关，而不能只与主键的某一部分相关，也就是说一个表中只能保存一种数据，不可以吧多种数据保存在一张表中。

第三范式：确保每列都和主键列直接相关，不是间接相关。

1.  ### **nacos怎么判断这个功能是否可用** ###

在网页访问nacos网页 进入8848端口号测试是否可以登录成功

[http://localhost:8848/nacos/index.html][http_localhost_8848_nacos_index.html] 访问此网址可以登录即可账号都为：nacos

1.  ### **nacos怎么实现负载** ###

Nacos支持权重负载，可以将硬件好的服务器的权重提高

1.  ### **rides常用类型** ###

Redis中key对应的常用类型：

String、LIst列表、Set集合、Hash（存的对象）、Zset（sorted set）无重复有序的集合

1.  ### **数据库进行1000万的数据传输应该怎样去快速完成** ###

分库（只读库和只写库）分表（设置多个表）

在查询时可以添加索引以便快速查询

1.  ### **hashcolde和equals 关系** ###

首先要明确，equals的优先级比hashcode高。我们需要确保当两个对象equals相等时，那么他们的hashcode一定相等。如果两个对象equals不相等，那么两个对象的hashCode 方法不一定会生成不同的整数结果。但是，程序员应该知道，为不相等的对象生成不同整数结果可以提高哈希表的性能。

什么时候需要重写equals和hashCode。一般来说涉及到对象之间的比较大小就需要重写equals方法，但是为什么说重写了equals就需要重写hashCode呢？实际上这只是一条规范，如果不重写做程序也可以执行，只不过会隐藏bug。一般一个类的对象如果会存储在Hash等散列存储结构中，那么重写equals后最好也重写hashCode。若不然，想象这种情况，两个对象equals和hashcode都不相等，此时重写了equals方法而没有重写hashcode方法，那么两个对象hashcode还是不同，可以存储在hash散列结构中，但是这时两个对象equals相等了，那么就代表你在一个hash结构中存储了两个相同的对象。而如果确定不会存储在这些散列结构中，则可以不重写hashCode。但是还是重写比较好一点，谁能保证后期不会存储在这些结构中呢。

1.  ### **maven 作用** ###

个人理解：

maven是一个构建项目和管理的工具。

maven的作用包括：1、构建标准的项目

2、添加依赖关系

3、管理二进制库

maven的好处：可以将项目过程规范化、自动化、高效化以及强大的扩展性，还可以在不同的maven模块之间共享jar包，每个maven模块都有自己的pom文件。

1.  ### **git是什么** ###

GIT，全称是分布式版本控制系统，git通常在编程中会用到，并且git支持[分布式][Link 1]部署，可以有效、高速的处理从很小到非常大的项目版本管理。分布式相比于集中式的最大区别在于开发者可以提交到本地，每个开发者通过克隆（git clone），在本地机器上拷贝一个完整的Git仓库。

1.  ### **git的命令** ###

1.  git init新项目执行Git初始化，并进行第一次提交

1.  git clone对gitlab远程仓库，已有项目进行克隆

1.  git fetch会将数据拉取到本地仓库，它并不会自动合并或修改当前的工作。

1.  git pull是从远程获取最新版本→本地，会自动合并或修改当前的工作。

1.  git add 添加→暂存区

1.  git commit 暂存区→本地仓库

1.  git push 本地→推送到远程服务器上去

1.  git reset 回退所有内容到上一个版本

1.  ### **怎么进行参数校验,一般的常用校验有什么** ###

在控制器处理请求的方法中，对需要验证的请求参数添加\`@Valid\`或\`@Validated\`注解，表示此参数是需要通过Spring Boot Validation进行检查的

\#\# 关于检查参数格式的注解

\- \`@NotNull\`：不允许为\`null\`，即必须提交此名称对应的参数

\- \`@NotEmpty\`：不允许为空字符串（长度为0的字符串）

\- 注意：只能应用于字符串格式的参数

\- \`@NotBlank\`：不允许为空白（字符串长度可能大于0，却是由空格、TAB等空白输入的）

\- 注意：只能应用于字符串格式的参数

\- \`@Min\`：设置数值类型的最小值

\- 仅用于数值类型的请求参数

\- 可被\`@Range\`取代

\- \`@Max\`：设置数值类型的最大值

\- 仅用于数值类型的请求参数

\- 可被\`@Range\`取代

\- \`@Range\`：设置数据类型的取值区间，可设置最小值和最大值

\- 此注解的\`min\`属性默认为\`0\`，\`max\`属性默认为\`long\`类型的最大值

\- 仅用于数值类型的请求参数

\- \`@Pattern\`：配置正则表达式

\- 不能取代\`@NotNull\`注解

1.  ### **list set map 区别**  ###

List和Set继承了Collection接口，而map不是；

List中存放元素有顺序并且可以重复；

set中存放的元素是无序并且是不可能重复的；

Map中存放是键值对。

1.  ### **IO 流分几种** ###

**（1）按流向分类：**

输入流

输出流

**（2）按处理数据不同分类：**

字节流：二进制，可以处理一切文件，包括：纯文本、doc、音频、视频等。

字符流：文本文件，只能处理纯文本。

**（3）按功能不同分类：**

节点流：包裹源头。

处理流：增强功能，提高性能。

1.  ### **常用的字节流** ###

FileInputStream/FileOutputStream，文件字节流（节点流）

ByteArrayInputStream/ByteArrayOutputStream，字节数组流（节点流）

BufferedInputStream/BufferedOutputStream，字节缓存流（处理流）

DataInputStream/DataOutputStream，数据字节流（处理流）

ObjectInputStream/ObjectOutputStream，对象流（处理流）

1.  ### **介绍一下java的反射**  ###

Reflection(反射) 是 Java 程序开发语言的特征之一，它允许运行中的Java 程序对自身进行检查。被private封装的资源只能类内部访问，外部是不行的，但反射能直接操作类私有属性。反射可以在运行时获取一个类的所有信息，（包括成员变量，成员方法，构造器等），并且可以操纵类的字段、方法、构造器等部分。

反射就是把java类中的各种成分映射成一个个的Java对象。

1.  ### **Class类** ###

Class的每一个实例用于表示JVM加载的一个类，所以我们也称Class的实例 为类的类对象。当JVM加载一个类时会同时实例化一个Class的实例与之对应，这个Class实例 中会保存该类的一切信息(类名，有哪些方法，构造器，属性，注解等等) 我们在程序运行期间通过某个类的类对象来操作这个类。因此使用反射操作某个类的第一件事就是获取该类的类对象。

1.  ### **获得类对象3种方式** ###

1:类名.class

例如: Class cls = String.class; Class cls = int.class (基本类型只能通过这种方式获取类对象)

2:Class.forName(String className)

通过Class的静态方法forName，传入对应类的完全限定名(包名.类名)的形式获取类对象 Class cls = Class.forName("java.lang.String");这种方式必须捕获异常

3:通过类加载器ClassLoader加载类对象

String str = new String;先创建一个类的实例

Calss c = str.getCalss;通过引用名.getCalss；

1.  ### **springBoot的核心组件** ###

1.  SpringBoot Starter帮我们封装好了所有需要的依赖,避免我们自己添加导致的一些Jar包冲突或者缺少包的情况；

1.  Spring Boot autoconfigure内容是配置Bean实例到Spring容器的实际代码实现包，然后提\\供给starter依赖。所以说配置Bean实例到Spring容器中实际是autoconfigure做的，因为是starter依赖它，所以也可以说是starter干的。

1.  Spring Boot CLI运行groovy脚本。

1.  Spring Boot actuator是Spring Boot的监控插件，本身提供了很多接口可以获取当前项目的各项运行状态指标。

1.  ### **命名规范的规则** ###

驼峰命名法（UpperCamelCase）

蛇形命名法（out\_of\_range）

串式命名法（background-color）

1)、名称只能由字母、数字、下划线、$符号组成

2)、不能以数字开头

3)、名称不能使用JAVA中的关键字。

4)、坚决不允许出现中文及拼音命名。

1.  ### **重载和重写** ###

重载：发生在同一类中，方法名相同，参数列表不同。

重写：发生在父子类中，方法名相同，参数列表相同。

两同：①方法名相同

②参数列表相同

两小：①子类返回值类型小于等于父类返回值类型（返回值为基本数据类型时，必须相等）

②子类抛出的异常小于等于父类抛出的异常

一大：子类访问控制修饰符大于等于父类访问控制修饰符

也称为覆盖。重写是子类对父类非静态、非private修饰，非final修饰，非构造方法等的实现过程进行重新编写, 返回值和形参都不能改变。即外壳不变，核心重写！重写的好处在于子类可以根据需要，定义特定于自己的行为。也就是说子类能够根据需要实现父类的方法。

1.  ### **并行和并发的区别** ###

一、意思不同

1、并发：并发是指两个或多个事件在同一时间间隔发生。

2、并行：并行是指两个或者多个事件在同一时刻发生。

二、侧重不同

1、并发：并发侧重于在同一实体上。

2、并行：并行侧重于在不同实体上。

三、处理不同

1、并发：并发在一台处理器上“同时”处理多个任务。

2、并行：并行在多台处理器上同时处理多个任务。

1.  ### **抽象类和接口的区别** ###

1.相同点

A. 两者都是抽象类，都不能实例化。

B. interface实现类及abstrct æbstrækt class的子类都必须要实现已经声明的 抽象方法。

2. 不同点

A. interface(接口)需要实现，要用implements，而abstract class需要继承，要用extends。

B. 一个类可以实现多个interface，但一个类只能继承一个abstract class。

C. interface强调特定功能的实现，而abstract class强调所属关系。

D. 尽管interface实现类及abstrct class的子类都必须要实现相应的抽象方法，但实现的形式不同。interface中的每一个方法都是抽象方法，都只是声明的(declaration dekləˈreɪʃ(ə)n, 没有方法体)，实现类必须要实现。而abstract class的子类可以有选择地实现。

1.  ### **一级缓存和二级缓存区别** ###

一级缓存

默认开启

SqlSession级别的缓存，实现在同一个会话中数据的共享

一级缓存的生命周期和SqlSession一致

当有多个SqlSession或者分布式环境下，数据库写操作会引起脏数据。

二级缓存

默认不开启，需手动开启

SqlSessionFactory fækt(ə)ri级别的缓存，实现不同会话中数据的共享，是一个全局变量可自定义存储源，如Ehcache an ken k

当开启缓存后，数据查询的执行的流程是：二级缓存>一级缓存>数据库

不同于一级缓存，二级缓存可设置是否允许刷新和刷新频率实现实体类实现序列化，在mapper文件中开启<cache> 在配置文件中设置cacheEnabled ɪneɪbld为true

1.  ### **缓存击穿，缓存雪崩，缓存穿透** ###

缓存击穿：缓存中没有查询的数据库 可以进行判断查询的条件是否存在或者添加互斥锁。

缓存穿透：缓存中没有数据库中也没有 可以通过布隆过滤器处理但是可能会出现误判。

缓存雪崩：大量缓存同时过期或Redis非关系型数据库崩溃 在添加缓存的时候生命周期可以添加随机数。

![9a345d2018156be2fd78ee54615bc3de.png][]

1.  ### **nocas的作用** ###

1.服务发现和服务健康监测

Nacos 支持基于 DNS 和基于 RPC 的服务发现。服务提供者使用 原生SDK、OpenAPI、或一个独立的Agent TODO注册 Service 后，服务消费者可以使用DNS TODO 或HTTP&API（服务名称）查找和发现服务。

Nacos 提供对服务的实时的健康检查，阻止向不健康的主机或服务实例发送请求。Nacos 支持传输层(PING 或 TCP)和应用层 (如 HTTP、MySQL、用户自定义）的健康检查。 对于复杂的云环境和网络拓扑环境中（如 VPC、边缘网络等）服务的健康检查，Nacos 提供了 agent 上报模式和服务端主动检测2种健康检查模式。Nacos 还提供了统一的健康检查仪表盘，帮助您根据健康状态管理服务的可用性及流量。

2.动态配置服务

动态配置服务可以让您以中心化、外部化和动态化的方式管理所有环境的应用配置和服务配置。

动态配置消除了配置变更时重新部署应用和服务的需要，让配置管理变得更加高效和敏捷。

配置中心化管理让实现无状态服务变得更简单，让服务按需弹性扩展变得更容易。

Nacos 提供了一个简洁易用的UI (控制台样例 Demo) 帮助您管理所有的服务和应用的配置。Nacos 还提供包括配置版本跟踪、金丝雀发布、一键回滚配置以及客户端配置更新状态跟踪在内的一系列开箱即用的配置管理特性，帮助您更安全地在生产环境中管理配置变更和降低配置变更带来的风险。

3.动态DNS服务

动态DNS 服务支持权重路由，让您更容易地实现中间层负载均衡、更灵活的路由策略、流量控制以及数据中心内网的简单DNS解析服务。动态DNS服务还能让您更容易地实现以 DNS 协议为基础的服务发现，以帮助您消除耦合到厂商私有服务发现API 上的风险。

Nacos 提供了一些简单的 DNS APIs TODO 帮助您管理服务的关联 域名和可用的IP:PORT 列表.

4.服务及其元数据管理

Nacos 能让您从微服务平台建设的视角管理数据中心的所有服务及元数据，包括管理服务的描述、生命周期、服务的静态依赖分析、服务的健康状态、服务的流量管理、路由及安全策略、服务的SLA 以及最首要的 metrics 统计数据。

1.  ### **nocas 的心跳机制** ###

Nacos内部注册的服务都会有一个心跳机制

心跳机制的目的,是每个服务和Nacos保持沟通和交换信息的机制

默认情况下,服务启动后每隔5秒会向Nacos发送一个"心跳包",这个心跳包中包含了当前服务的基本信息

Nacos接收到这个心跳包,首先检查当前服务在不在注册列表中,如果不在按新服务的业务进行注册,如果在,表示当前这个服务是健康状态

如果一个服务连续3次心跳(默认15秒)没有和Nacos进行信息的交互,就会将当前服务标记为不健康的状态

如果一个服务连续6次心跳(默认30秒)没有和Nacos进行信息的交互,Nacos会将这个服务从注册列表中剔除

这些时间都是可以通过配置修改的

如果想标记一个服务为永久实例

cloud:
      nacos:
        discovery:
          # true(默认):临时实例 false:永久实例
          ephemeral e fan mo rou: false

当过期后也不会将nacos中服务剔除

1.  ### **Linux 常用命令** ###

ls命令：

Is-a(列出目录下的所有文件，包括以 . 开头的隐含文件)

Is-l(列出文件的详细信息)

Is-i(输出文件i节点的索引信息)

Is-t(以时间排序)

pwd指令：

Pwd(显示用户当前所在的目录)

whoami指令：

Whoami(查看用户当前身份)

clear指令（功能：清屏）

cd指令：

cd 目录名（改变工作目录。将当前工作目录改变到指定的目录下）

touch指令：

touch \[选项\]… 文件…（touch命令参数可更改文档或目录的日期时间，包括存取时间和更改时间，或者新建一个不存在的文件）

mkdir指令：

mkdir \[选项\] dirname…（在当前目录下创建一个名为 “dirname”的目录）

rmdir指令：

删除空目录（当子目录被删除后如果父目录也变成空目录的话，就连带父目录一起删除）

ls指令\[含义list表示列出目录的所有文件及文件夹名称\]

pwd\[显示当前工作目录路径\]

mkdir\[创建目录\]

touch\[创建文件\]

mv\[移动文件和重命名文件\]

1.  ### **创建索引的优缺点** ###

优点：

这是因为，创建索引可以大大提高系统的性能。

第一、通过创建唯一性索引，可以保证数据库表中每一行数据的唯一性。

第二、可以大大加快 数据的查询速度，这也是创建索引的最主要的原因。

第三、可以加速表和表之间的连接，特别是在实现数据的参考完整性方面特别有意义。

第四、在使用分组和排序子句进行数据查询时，同样可以显著减少查询中分组和排序的时间。

第五、通过使用索引，可以在查询的过程中，使用优化隐藏器，提高系统的性能。

缺点：

第一、创建索引和维护索引要耗费时间，这种时间随着数据量的增加而增加。

第二、索引需要占 物理空间，除了数据表占数据空间之外，每一个索引还要占一定的物理空间。如果要建立聚簇索引，那么需要的空间就会更大。

第三、当对表中的数据进行增加、删除和修改的时候，索引也要动态的维护，这样就降低了数据的维护速度。

1.  ### **最快的删除数据库的方法** ###

drop database 数据库名称

drop> truncate > delete

1.  ### **truncate和delete的区别** ###

Truncate：删除表中的内容，不删除表结构，释放空间与事务无关。

Delete：删除内容，不删除表结构，但不释放空间与事务有关。

区别：

1、内存空间

truncate删除数据后重新写数据会从1开始，而delete删除数据后只会从删除前的最后一行续写；内存空间上，truncate省空间。

2、处理速度

因为，truncate是直接从1开始，即全部清空开始，而delete需要先得到当前行数，从而进行续写；所以truncate删除速度比delete快。

3、语句类型

delete属于DML语句，而truncate和drop都属于DDL语句，这造成了它们在事务中的不同现象。

4、语法

delete from 表名 (where…可写可不写，写的话进行选择性删除，不选清空表中数据)

truncate 表名（删除表中的数据，无法回滚的）。

1.  ### **Java的反射** ###

JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的法的功能称为java语言的反射机制。

通过java语言中的反射机制可以操作字节码文件（可以读和修改字节码文件。）

通过反射机制可以操作代码片段。（class文件。）

![2917a7826c5a787f01c2c24d43308bee.png][]

1.  ### **怎么运行一个单独的Springboot服务** ###

1.  ### **Java的序列化，什么情况下使用序列化** ###

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

什么时候需要用到java序列化：

需要将内存的对象状态保存到文件中。

需要通过socket通信进行对象传输时。

我们将系统拆分成多个服务之后，服务之间传输对象，需要序列化。

1.  ### **深拷贝和浅拷贝** ###

浅拷贝：

浅拷贝只复制某个对象的引用，而不复制对象本身，新旧对象还是共享同一块内存

深拷贝：

深拷贝会创造一个一摸一样的对象，新对象和原对象不共享内存，修改新对象不会改变原对对象。

1.  ### **简述static和final的用法？** ###

static：修饰属性，方法，代码块

（1）静态属性：也可叫类变量 类名.属性名 来访问（共有的类变量与对象无关，只和类有关）

注意：类中的实例变量是在创建对象时被初始化的，被static修饰的属性，也就是类变量，是在类加载时被创建并进行初始化，类加载的过程是进行一次。也就是类变量只会被创建一次。

（2）静态方法：类名.方法名 直接访问

注意：静态方法不能直接访问非静态成员

非静态方法可以直接访问静态成员

（3）static可以修饰类，仅限于内部类

（4）静态块由static修饰,属于类,在类被加载时自动执行,一个类只被加载一次,所以静态块只执行一次,用于初始化静态资源.

final：修饰变量，类，方法

（1）修饰变量

被fianl修饰的成员变量就是常量（常量名大写），一旦赋值不能改变

常量一旦赋值就不可以被改变

修饰局部变量：修饰基本数据类型 -> 变量的值不能改变

修饰引用 -> 引用只能指向固定的对象

修饰实例变量：默认值不生效，可以再赋值

（2）修饰方法：不能被子类覆盖

（3）修饰类：不能被继承

注意：final，不能用来修饰构造方法。在一个final类中的所有方法，默认都是final的。

1.  ### **abstract class 和 interface 有什么区别?** ###

<table style=""> 
 <tbody> 
 <tr> 
 <td style="width:86px;vertical-align:top;height:52px;"> </td> 
 <td style="width:262px;vertical-align:top;height:52px;">abstract class</td> 
 <td style="width:289px;vertical-align:top;height:52px;">interface</td> 
 </tr> 
 <tr> 
 <td style="width:86px;vertical-align:top;height:52px;">实例化</td> 
 <td style="width:262px;vertical-align:top;height:52px;">不能</td> 
 <td style="width:289px;vertical-align:top;height:52px;">不能</td> 
 </tr> 
 <tr> 
 <td style="width:86px;vertical-align:top;height:52px;">类</td> 
 <td style="width:262px;vertical-align:top;height:52px;">一种继承关系，一个类只能使用一次继承关系。可以通过实现多个接口</td> 
 <td style="width:289px;vertical-align:top;height:52px;">一个类可以实现多个interface</td> 
 </tr> 
 <tr> 
 <td style="width:86px;vertical-align:top;height:52px;">数据成员</td> 
 <td style="width:262px;vertical-align:top;height:52px;">可有自己的</td> 
 <td style="width:289px;vertical-align:top;height:52px;">静态的不能被修改即必须是static final，一般不在此定义</td> 
 </tr> 
 <tr> 
 <td style="width:86px;vertical-align:top;height:52px;">方法</td> 
 <td style="width:262px;vertical-align:top;height:52px;">可以私有的，非abstract方法，必须实现</td> 
 <td style="width:289px;vertical-align:top;height:52px;">不能有私有的，默认是public，abstract 类型</td> 
 </tr> 
 <tr> 
 <td style="width:86px;vertical-align:top;height:52px;">变量</td> 
 <td style="width:262px;vertical-align:top;height:52px;">可有私有的，变量有默认的类型，其值可以在子类中重新定义，也可以重新赋值</td> 
 <td style="width:289px;vertical-align:top;height:52px;">不可有私有的，默认是public static final 型，且必须给其初值，实现类中不能重新定义，不能改变其值。</td> 
 </tr> 
 <tr> 
 <td style="width:86px;vertical-align:top;height:52px;">设计理念</td> 
 <td style="width:262px;vertical-align:top;height:52px;">表示的是“is-a”关系</td> 
 <td style="width:289px;vertical-align:top;height:52px;">表示的是“like-a”关系</td> 
 </tr> 
 <tr> 
 <td style="width:86px;vertical-align:top;height:52px;">实现</td> 
 <td style="width:262px;vertical-align:top;height:52px;">需要继承，要用extends</td> 
 <td style="width:289px;vertical-align:top;height:52px;">要用implements</td> 
 </tr> 
 </tbody> 
</table>

1.相同点

A. 两者都是抽象类，都不能实例化。

B. interface实现类及abstrct class的子类都必须要实现已经声明的抽象方法。

2. 不同点

A. interface需要实现，要用implements，而abstract class需要继承，要用extends。

B. 一个类可以实现多个interface，但一个类只能继承一个abstract class。

C. interface强调特定功能的实现，而abstract class强调所属关系。

D. 尽管interface实现类及abstrct class的子类都必须要实现相应的抽象方法，但实现的形式不同。interface中的每一个方法都是抽象方法，都只是声明的(declaration, 没有方法体)，实现类必须要实现。而abstract class的子类可以有选择地实现。

1.  ### **Error和Exception有什么区别? 列出你见过的Exception并简要说明** ###

error表示系统级的错误和程序不必处理的异常，是恢复不是不可能但很困难的情况下的一种严重问题；比如内存溢出，不可能指望程序能处理这样的情况；

exception表示需要捕捉或者需要程序进行处理的异常，是一种设计或实现问题；也就是说，它表示如果程序运行正常，从不会发生的情况。

常见异常有：

NullPointerException：当操作一个空引用时会出现此错误。

NumberFormatException：数据格式转换出现问题时出现此异常。

ClassCastException：强制类型转换类型不匹配时出现此异常。

ArrayIndexOutOfBoundsException：数组下标越界，当使用一个不存在的数组下标时出现此异常。

1.  ### **内存溢出** ###

内存溢出(Out Of Memory，简称OOM)是指应用系统中存在无法回收的内存或使用的内存过多，最终使得程序运行要用到的内存大于能提供的最大内存,程序终止。

1.  ### **java中会存在内存泄露吗？请简单描述。** ###

内存泄露是指系统中存在无法回收的内存，有时候会造成内存不足或系统崩溃。

Java存在内存泄露。

Java中的内存泄露当然是指：存在无用但是垃圾回收器无法回收的对象。

而且即使有内存泄露问题存在，也不一定会表现出来。这个时候需要手动调用垃圾回收器GC

自己实现堆栈的数据结构时有可能会出现内存泄露。

1.  ### **多线程有几种实现方法,都是什么?同步有几种实现方法,都是什么?**  ###

多线程有两种实现方法：继承Thread类或者实现Runnable接口。

实现同步也有两种方法：一种是同步方法，另一种是同步代码块。

同步方法是在方法返回类型前面加上synchronized关键字

同步代码块是synchronized (这里写需要同步的对象)\{...\}

被修饰的代码块或方法只会有一个线程执行，以达到保证并发安全的效果。

1.  ### **讲一下线程的几种实现方式?** ###

extends Thread

implements Runnable

implements Callable

Runnable和Callable的区别是，

（1）Callable规定的方法是call（），Runnable规定的方法是run（）。

（2）Callable的任务执行后可返回值，而Runnable的任务是不能返回值得

（3）call方法可以抛出异常，run方法不可以

（4）运行Callable任务可以拿到一个Future对象，表示异步计算的结果。

1.  ### **sleep()和wait()有什么区别？** ###

答案：

（2）不同点：

1. Thread类的方法：sleep(),yield()等 sleep暂停当前线程，yield是将CPU分给优先级同级和更高级的线程

Object的方法：wait()和notify()等 wait让线程等待，notify将等待的线程唤醒

2.每个对象都有一个锁来控制同步访问。Synchronized关键字可以和对象的锁交互，来实现线程的同步。

sleep方法没有释放锁， 设置锁让线程进行排队，线程不能同时访问锁中的程序

wait方法释放了锁，使得其他线程可以使用同步控制块或者方法。

3.wait，notify和notifyAll只能在同步控制方法或者同步控制块里面使用，而sleep可以在任何地方使用

4.sleep必须捕获异常，而wait，notify和notifyAll不需要捕获异常

1.  ### **多线程的生命周期** ###

在操作系统中线程生命周期可以分为五种状态。分别是：初始状态、可运行状态、运行状态、休眠状态和终止状态。

1.  ### **谈谈你对面向对象的理解？** ###

所谓的面向对象就是将我们的程序模块化，对象化，把具体事物的特性属性和通过这些属性来实现一些动作的具体方法放到一个类里面，这就是封装。封装是我们所说的面相对象编程的特征之一。除此之外还有继承和多态。继承有点类似与我们生物学上的遗传，就是子类的一些特征是来源于父类的，儿子遗传了父亲或母亲的一些性格，或者相貌，又或者是运动天赋。有点种瓜得瓜种豆得豆的意思。面向对象里的继承也就是父类的相关的属性，可以被子类重复使用，子类不必再在自己的类里面重新定义一回，父类里有点我们只要拿过来用就好了。而对于自己类里面需要用到的新的属性和方法，子类就可以自己来扩展了。当然，会出现一些特殊情况，就是我们在有一些方法在父类已经定义好了，但是子类我们自己再用的时候，发现，其实，我们的虽然都是计算工资的，但是普通员工的工资计算方法跟经理的计算方法是不一样的，所以这个时候，我们就不能直接调用父类的这个计算工资的方法了。这个时候我们就需要用到面向对象的另一个特性，多态。对，就是多态，我们要在子类里面把父类里面定义计算工资的方法在子类里面重新实现一遍。多态包含了重载和重写。重写很简单就是把子类从父亲类里继承下来的方法重新写一遍，这样，父类里相同的方法就被覆盖了，当然啦，你还是可以通过super.CaculSalary方法来调用父类的工资计算方法。而重载就是类里面相同方法名，不同形参的情况，可以是形参类型不同或者形参个数不同，或者形参顺序不同，但是不能使返回值类型不同。

重写：方法名，参数列表，返回值类型，修饰词大于原方法 重载：方法名相同，参数列表不同

1.  ### **有了基本数据类型，为什么还需要包装类型？** ###

我们知道Java是一个面相对象的编程语言，基本类型并不具有对象的性质，为了让基本类型也具有对象的特征，就出现了包装类型（如我们在使用集合类型Collection时就一定要使用包装类型而非基本类型），它相当于将基本类型“包装起来”，使得它具有了对象的性质，并且为其添加了属性和方法，丰富了基本类型的操作。

集合中只能存放对象所以只能将基本类型转换为包装类型

另外，当需要往ArrayList，HashMap中放东西时，像int，double这种基本类型是放不进去的，因为容器都是装object的，这是就需要这些基本类型的包装器类了

1.  ### **包装类型** ###

包括：Integer、Character、Byte、Short、Long、Float、Double、Boolean。其中Character和Boolean是直接继承Object的，而其余6个包装类继承自java.lang.Number

\- JDK1.5推出了一个新的特性：自动拆装箱，当编译器编译时若发现有基本类型与包装类型相互赋值时，将会自动补充代码来完成转换工作，这个过程称为自动拆装箱

1.  ### **讲一下java中的集合** ###

set(集）、list(列表）和map(映射)。 set集合是无序的无重复元素的集合，list是有序的可以有重复元素

区别嘛hashmap只有key和value值对应的。set是可以自动清除相同的元素

list是其对象以线性方式存储，没有特定顺序，只有一个开头和一个结尾，当然，它与根本没有顺序的集是不同的。

列表在数据结构中分别表现为：数组和向量、链表、堆栈、队列。

1.  ### **ArrayList和LinkedList的区别?** ###

1.ArrayList是实现了基于动态数组的数据结构，LinkedList基于链表的数据结构。ArrayList查询方便，linkedList添加删除方便

2.对于随机访问get和set，ArrayList觉得优于LinkedList，因为LinkedList要移动指针。内部是数组内部是对象

3.对于新增和删除操作add和remove，LinedList比较占优势，因为ArrayList要移动数据。

1.  ### **讲一下HashMap和HashTable的区别?**  ###

在Java 2以前，一般使用Hashtable来映射键值和元素。为了使用Java集合框架，Java对Hashtable进行了重新设计，但是，为了向后兼容保留了所有的方法。Hashtable实现了Map接口，除了Hashtable具有同步功能之外，它与HashMap的用法是一样的。·

在使用时一般是用ArrayList代替Vector，LinkedList代替Stack，HashMap代替HashTable，即使在多线程中需要同步，也是用同步包装类。

即使在多线程中需要同步，也是用同步包装类。

1.  ### **请说出集合类中List、Map、Set的区别** ###

List和Set继承了Collection接口，而map不是；

List中存放元素有顺序并且可以重复；

set中存放的元素是无序并且是不可能重复的；

Map中存放是键值对。

1.  ### **Collection 和 Collections的区别？** ###

Collection是java.util下的接口，它是各种集合的父接口，继承于它的接口主要有Set 和List；

Collections是个java.util下的类，Collections是一个工具类，是针对集合的帮助类，提供一系列静态方法实现对各种集合的搜索、排序、线程安全化等操作。

HashSet :内部封装了HashMap和TreeMap,数据保存在键这一列

LinkedHashMap(哈希表,存放数据以链表来连接,数组存放无序但链表连接有序,可看做一个有序的HashMap),既可快速定位,查找数据,又可以使数据存放有序

ConcurrentHashMap(分段加锁)Concurrent ken ka run t-同步

![8543de3d5253f61f375939ac85f40e69.png][]

1.  ### **try \{\}里有一个return语句，那么紧跟在这个try后的finally \{\}里的code会不会被执行，什么时候被执行，在return前还是后?** ###

会执行 try\{\}中的return执行后在没有返回数据时先去执行finally\{\}中的代码，然后再返回。所以说finally\{\}在return中间执行。

1.  ### **&和&&的区别？ &&并且 ||或者 ！取反** ###

&和&&都可以用作逻辑运算符，表示逻辑与。当运算符两边的表达式都为true时，结果才为true；否则，结果为false。

另外&&还具有短路功能，也就是说，当&&左边的表达式结果为false时，将不再运算&&右边的表达式，结果肯定为false。例如，对于

if(str!=null&&!str.equals(“”))

当str为null时，不会对&&右边的表达式进行运算，否则会出现空指针异常。

&还可以用作位运算符，当&两边的表达式不是boolean类型时，&表示按位与。

1.  ### **数组有没有length()这个方法? String有没有length()这个方法？** ###

数组中没有length()这个方法，但是数组中有length这个属性。用来表示数组的长度。

String中有length()这个方法。用来得到字符串的长度。

数组是属性，string是方法，集合是size()方法。

1.  ### **构造器Constructor 是否可被override?** ###

构造器Constructor不能被继承，因此不能重写Override，但可以被重载Overload。

Constructor不能被继承，所以Constructor也就不能被override。每一个类必须有自己的构造函数，负责构造自己这部分的构造。子类不会覆盖父类的构造函数，相反必须负责在一开始调用父类的构造函数。

1.  ### **super与this的区别？** ###

不同点：

1、super()主要是对父类构造函数的调用，this()是对重载构造函数的调用

2、super()主要是在继承了父类的子类的构造函数中使用，是在不同类中的使用；this()主要是在同一类的不同构造函数中的使用

相同点：

super()和this()都必须在构造函数的第一行进行调用，否则就是错误的

注意：this是在本类中使用调用构造，super是父子类中使用直接调用父类的构造

1.  ### **接口是否可继承接口? 抽象类是否可实现(implements)接口? 抽象类是否可继承实体类？** ###

接口可以继承接口。抽象类可以实现(implements)接口，抽象类可继承实体类，但前提是实体类必须有明确的构造函数。

1.  ### **GC是什么? 为什么要有GC?** ###

GC是垃圾收集的意思，内存处理是编程人员容易出现问题的地方，

忘记或者错误的内存回收会导致程序或系统的不稳定甚至崩溃，Java提供的GC功能可以自动监测对象是否超过作用域从而达到自动回收内存的目的，

Java语言没有提供释放已分配内存的显示操作方法。Java程序员不用担心内存管理，因为垃圾收集器会自动进行管理。要请求垃圾收集，可以调用下面的方法之一：System.gc()或Runtime.getRuntime().gc()，但JVM可以屏蔽掉显示的垃圾回收调用。

垃圾回收可以有效的防止内存泄露，有效的使用可以使用的内存。垃圾回收器通常是作为一个单独的低优先级的线程运行，不可预知的情况下对内存堆中已经死亡的或者长时间没有使用的对象进行清除和回收，程序员不能实时的调用垃圾回收器对某个对象或所有对象进行垃圾回收。

在Java诞生初期，垃圾回收是Java最大的亮点之一，因为服务器端的编程需要有效的防止内存泄露问题，然而时过境迁，如今Java的垃圾回收机制已经成为被诟病的东西。移动智能终端用户通常觉得iOS的系统比Android系统有更好的用户体验，其中一个深层次的原因就在于Android系统中垃圾回收的不可预知性。

1.  ### **解释内存中的栈(stack)、堆(heap)和静态区(static area)的用法** ###

通常我们定义一个基本数据类型的变量，一个对象的引用，还有就是函数调用的现场保存都使用内存中的栈空间；而通过new关键字和构造器创建的对象放在堆空间；程序中的字面量（literal）如直接书写的100、”hello ”和常量都是放在静态区中。栈空间操作起来最快但是栈很小，通常大量的对象都是放在堆空间，理论上整个内存没有被其他进程使用的空间甚至硬盘上的虚拟内存都可以被当成堆空间来使用。

1.  ### **Java 中的final关键字有哪些用法？** ###

(1)修饰类：表示该类不能被继承；

(2)修饰方法：表示方法不能被重写；

(3)修饰变量：表示变量只能一次赋值以后值不能被修改（常量）。

1.  ### **写出常见的5个RuntimeException** ###

(1)java.lang.NullPointerException po en t空指针异常，出现原因：调用了未经初始化的对象或者不存在的对象。

(2)ClassNoFoundException 指定类找不到，出现原因：类的名称和路径加载错误，通常是试图通过字符串来加载某个类时可能引发异常。

(3)NumberFormatException字符串转换为数字异常，出现原因：字符串数据中包含非数字型字符。

(4)ArrayIndexOutOfBoundsException数组下标越界异常

(5)IllegalArgumentException 方法传递参数错误

(6)ClassCastException数据类型转换异常

(7)NoClassDefFoundExcetion 未找到类定义错误

(8)SQLException SQL异常

(9)InstantiationException实例化异常 因私单提嗯身

(10)NoSuchMethodExceptioin 方法不存在异常

1.  ### **阐述final、finally、finalize的区别。** ###

\- final：修饰符（关键字）有三种用法：如果一个类被声明为final，意味着它不能再派生出新的子类，即不能被继承，因此它和abstract是反义词。将变量声明为final，可以保证它们在使用中不被改变，被声明为final的变量必须在声明时给定初值，而在以后的引用中只能读取不可修改。被声明为final的方法也同样只能使用，不能在子类中被重写。

\- finally：通常放在try…catch…的后面构造总是执行代码块，这就意味着程序无论正常执行还是发生异常，这里的代码只要JVM不关闭都能执行，可以将释放外部资源的代码写在finally块中。

\- finalize：Object类中定义的方法，Java中允许使用finalize()方法在垃圾收集器将对象从内存中清除出去之前做必要的清理工作。这个方法是由垃圾收集器在销毁对象时调用的，通过重写finalize()方法可以整理系统资源或者执行其他清理工作。

1.  ### **如何通过反射创建对象？** ###

\- 方法1：通过类对象调用newInstance() in s den s方法

例如：String.class.newInstance()

\- 方法2：通过类对象的**getConstructor**()或getDeclaredConstructor() d k lan d方法获得构造器（Constructor）对象并调用其newInstance()方法创建对象

例如：String.class.getConstructor(String.class).newInstance(“Hello”);

1.  ### **谈谈JVM 的内存结构和内存分配？** ###

**Java 内存模型**

Java 虚拟机将其管辖的内存大致分三个逻辑部分：方法区(Method Area)、 Java 栈和 Java 堆。

1、方法区是静态分配的，编译器将变量绑定在某个存储位置上，而且这些绑定不会在运行时改变。常数池，源代码中的命名常量、 String 常量和 static 变量保存在方法区。

2、 Java Stack 是一个逻辑概念，特点是后进先出。一个栈的空间可能是连续的，也可能是不连续的。最典型的Stack 应用是方法的调用，Java 虚拟机每调用一次方法就创建一个方法帧（frame），退出该方法则对应的方法帧被弹出(pop)。栈中存储的数据也是运行时确定的。

3、 Java 堆分配(heap allocation)意味着以随意的顺序，在运行时进行存储空间分配和收回的内存管理模型。堆中存储的数据常常是大小、数量和生命期在编译时无法确定的。Java 对象的内存总是在 heap 中分配。

**java 内存分配**

1、基础数据类型直接在栈空间分配;

2、方法的形式参数(类中的变量)，直接在栈空间分配，当方法调用完成后从栈空间回收;

3、引用数据类型，需要用new 来创建，既在栈空间分配一个地址空间，又在堆空间分配对象的类变量;

4、方法的引用参数，在栈空间分配一个地址空间，并指向堆空间的对象区，当方法调用完后从栈空间回收;

5、局部变量new 出来时，在栈空间和堆空间中分配空间，当局部变量生命周期结束后，栈空间立刻被回收，堆空间区域等待GC 回收;

6、方法调用时传入的实际参数，先在栈空间分配，在方法调用完成后从栈空间释放;

7、字符串常量在DATA 区域分配 ，this 在堆空间分配;

8、数组既在栈空间分配数组名称，又在堆空间分配数组实际的大小。

1.  ### **++i与 i++的区别？** ###

\++i 先运算后赋值，i++先赋值后运算。

1.  ### **简述Servlet生命周期？（每一次响应的程序的）** ###

（1）Servlet第一次被访问到时创建对象，创建出来后立即执行init方法执行初始化的操作。

init（）是单线程，所以不用考虑线程安全的问题

（2）从此以后该对象一直驻留在内存中为后续的对这个Servlet的请求进行服务。

（3）直到服务器关闭或web应用移除出容器时，随着web应用的销毁Servlet对象销毁掉，在销毁之前调用destroy d s zhao en方法执行善后工作。 destroy（）是销毁之前释放内存的

（4）在存活期间，每次对Servlet 的调用都会导致Service方法的执行。

1.  ### **get和post请求的区别？** ###

（1）get请求用来从服务器上获得资源，而post是用来向服务器提交数据；

（2）get将表单中数据按照name=value的形式，添加到action 所指向的URL 后面，并且两者使用"?"连接，而各个变量之间使用"&"连接；post是将表单中的数据放在HTTP协议的请求头或消息体中，传递到action所指向URL；

（3）get传输的数据要受到URL长度限制（1024字节）；而post可以传输大量的数据， POST数据是没有限制的，上传文件通常要使用post方式；

（4）使用get时参数会显示在地址栏上，如果这些数据不是敏感数据，那么可以使用get；对于敏感数据还是应用使用post；

（5）get使用MIME mai m类型application/x-www-form-urlencoded 的URL编码（也叫百分号编码）文本的格式传递参数，保证被传送的参数由遵循规范的文本组成，例如一个空格的编码是"%20"。

（6）Jsp页面中的FORM标签里的method属性为get时调用doGet()，为post时调用doPost()。

1.  ### **请求乱码产生的原因？** ###

浏览器用什么码表来打开表单页面就用什么编码来发送数据。当前我们的注册页面指定了用utf-8来打开。

这就决定了浏览器是用utf-8打开的页面，浏览器在提交表单时是用utf-8编码的。

而tomcat默认情况下会使用iso8859-1来进行解码。

我们知道全世界的码表都兼容iso8859-1，所以英文处理是没有问题的。

但是iso8859-1中并没有中文，iso8859-1对于无法处理的字节都使用?替代，所以我们看到的都是？。

1.  ### **Request生命周期** ###

request对象的生命周期是针对一个客户端(一个浏览器应用程序)的一次请求，当请求完毕之后，request里边的内容也将被释放，一个请求开始时创建，请求结束后销毁。

1.  ### **如何处理响应乱码？** ###

通过response.setHeader("Content-Type", "text/html;charset=utf-8")方法，通知服务器发送数据时的码表；通过response.setCharacterEncoding kan ter in kou ding("utf-8")方法，通知浏览器解析时使用的码表。两码相同就不会有乱码了。

response提供了setContentType("text/html;charset=UTF-8")快捷方法，在它的底层，会同时做上面两件事，所以可以一行代码解决response产生的乱码问题。

1.  ### **转发与重定向的比较？** ###

转发是服务器内部资源跳转,重定向是通过302+Location实现浏览器跳转访问。

转发一次请求一次响应,重定向两次请求两次响应。

转发地址栏不发生变化,重定向地址栏会发生变化。

转发之前和转发之后request是一个,重定向之前和之后不是一个request。

1.  ### **Session生命周期？** ###

当程序第一次调用到request.getSession()代码时,服务器明确的知道了需要用到session了,此时创建session。

如果session超过30分钟(可以在web.xml中配置的)没人使用,服务器认为这个session超时了,销毁session。

明确的调用session.invalidate(),session立即销毁。

服务器被非正常关闭或web应用被移除出容器,此时随着web应用的销毁session销毁.如果是正常关闭,session会被钝化.当下次服务器正常启动时 ,没有超时的session还会被活化回来。

1.  ### **cookie与session的区别** ###

**存放位置不同：**cookie保存在客户端，session保存在服务端

**存取方式不同：**cookie只能保管字符串，有长度限制,

session中能够存取任何类型的数据，没有大小限制

**安全性不同：**cookie存储在浏览器中，对客户端是可见的，用户可能会进行coolie欺骗。

session存储在服务器上，对客户端是透明的，不存在敏感信息泄露的风险。

1.  ### **JSP的九大隐式对象是哪九个** ###

1：request: 请求对象 在javax.servlet.ServletRequest 作用域为Req uest来自客服端的请求，如：FORM表单中填写的信息，常用的方法有getParameter，getParamterName 和getParamterValue通过表用获取请求对象中包含的参数值。

2:response表示客服端的响应。

3：pageContext对象为页面的上下文对象，代表当前运行页面的一些属性。

4：session：对象代码服务器与客服端所建立的会话，比如在写购物，客服轨迹跟踪，

session”是建立在cookie的基础之上的。常用方法有getId,getValues等。

5：application对象负责提供应用程序在服务端运行时的一些全局信息，方法有getMimeType等。

6：out：与response不同，通过out对象发送的内容是浏览器需要的显示内容，还可以直接想客服端编写一个有程序动态生成的HTML的文件。

7：page：page里的变量没法从index.jsp传递到test.jsp。只要页面跳转了，就不见了。

8： exception：他是一个列外的对象，当页面发生了列外，就会会创建该对象。

9：config：是在servlet初始化Servlet的时候，JSP引擎向他传递信息用的，此消息包括Servlet初始化时所需要的参数。

1.  ### **如何防止SQL注入攻击呢？** ###

SQL注入：就是通过把SQL命令插入到Web表单递交或输入域名或页面请求的查询字符串，最终达到欺骗服务器执行恶意的SQL命令。具体来说，它是利用现有应用程序，将（恶意）的SQL命令注入到后台数据库引擎执行的能力，它可以通过在Web表单中输入（恶意）SQL语句得到一个存在安全漏洞的网站上的数据库，而不是按照设计者意图去执行SQL语句。

防止的方法：

（1）永远不要信任用户的输入，要对用户的输入进行校验，可以通过正则表达式，或限制长度，对单引号和双"-"进行转换等。

（2）永远不要使用动态拼装SQL，可以使用参数化的SQL或者直接使用存储过程进行数据查询存取。

（3）永远不要使用管理员权限的数据库连接，为每个应用使用单独的权限有限的数据库连接。

（4）不要把机密信息明文存放，请加密或者hash掉密码和敏感的信息。

（5）应用的异常信息应该给出尽可能少的提示，最好使用自定义的错误信息对原始错误信息进行包装，把异常信息存放在独立的表中。

1.  ### **Mysql数据库优化** ###

(1)查询时，能不用\* 就不用，尽量写全字段名。

(2)索引不是越多越好，每个表控制在6个索引以内。范围where条件的情况下，索引不起作用，比如where value<100

(3)大部分情况连接效率远大于子查询，但是有例外。当你对连接查询的效率都感到不能接受的时候可以试试用子查询，虽然大部分情况下你会更失望，但总有碰到惊喜的时候不是么...

(4)多用explain 和 profile分析查询语句 explain模拟优化器执行sql查询

(5)有时候可以1条大的SQL可以分成几个小SQL顺序执行，分了吧，速度会快很多。

(6)每隔一段时间用alter table table\_name engine=innodb;优化表

(7)连接时注意:小表jion 大表的原则

(8)学会用explain 和 profile判断是什么原因使你的SQL慢

(9)查看慢查询日志，找出执行时间长的SQL进行优化

(10)尽量避免使用order by

(11)因为where子句后面的条件是执行顺序是从右到左，所以尽量把能过滤掉大部分数据的条件放在最后

1.  ### **http和https的区别？** ###

HTTP协议传输的数据都是未加密的，也就是明文的，因此使用HTTP协议传输隐私信息非常不安全，为了保证这些隐私数据能加密传输，于是网景公司设计了SSL（Secure Sockets Layer）协议用于对HTTP协议传输的数据进行加密，从而就诞生了HTTPS。简单来说，HTTPS协议是由SSL+HTTP协议构建的可进行加密传输、身份认证的网络协议，要比http协议安全。

1.  ### **"" 和 null的区别** ###

如果说str是null，那么内存根本没创建字符串对像，并由str引用。不能调用object的方法。

如果说str是空串，那么确实存在一个由str引用的字符串对像，只不过这个字符串的值是""。长度为0；在获取请求参数的时候为什么要这样判断呢？

if(null==str || "".equals(str)){
    			return "不合法参数"；
    		}

如果我们在表单中什么都不填接收到的字符串就是null;

如果我们在表单中填“”，接受到的字符串是“”，但是存入数据库后，查询出来的就是null；

1.  ### **request.getParameter()和request.getAttribute()的区别** ###

a、request.getParameter()获取的类型是String；

request.getAttribute()获取的类型是Object

b、request.getPrameter()获取的是POST/GET传递的参数值和URL中的参数；

request.getAttribute()获取的是对象容器中的数据值/对象

c、request.setAttribute()和request.getAttribute()可以发送、接收对象；

request.getParamter()只能接收字符串，官方不开放request.setParamter()（也就是没有这个方法）

setAttribute()和getAttribute()的传参原理：

setAttribute()是应用服务器把这个对象放在该页面所对应的一块内存中去，当你的页面服务器重定向到另外一个页面时，应用服务器会把这块内存拷贝到另一个页面所对应的那块内存中。这个就可以通过getAttribute()获取到相应的参数值或者对象。

1.  ### **J2EE常用的设计模式？说明工厂模式。** ###

Java中一共有23中设计模式：

Factory（工厂模式）、Builder（建造模式）、Factory Method（工厂方法模式）、ProtoType（原始模型模式）、Singleton（单例模式）、

Facade（门面模式）、Adapter（适配器模式）、Bridge（桥梁模式）、Composite（合成模式）、Decorator（装饰模式）、

FlyWeight（享元模式）、Proxy（代理模式）、Command（命令模式）、Interpreter（解释器模式）、Visitor（访问者模式）、

Iterator（迭代子模式）、Mediator（调停者模式）、Memento（备忘录模式）、Observer（观察者模式）、State（状态模式）、

Strategy（策略模式）、Template Method（模板方法模式）、Chain Of Responsibility（责任链模式）、

工厂模式：工厂模式是一种经常被使用到的模式，根据工厂模式实现的类可以根据提供的数据生成一组类中某个类的实例，通常一组类中有一个公共的抽象父类并且实现了相同的方法，但是这些方法针对不同的数据进行了不同的操作。首先需要定义一个基类，该类的子类通过不同的方法实现了基类中的方法。然后定义一个工厂类，工厂类可以根据条件生成不同的子类实例。当得到子类的实例后，开发人员可以调用基类中的方法而不必考虑到底返回的是哪一个子类的实例。

1.  ### **数据库有几种隔离级别?** ###

1、Serializable (串行化)：可避免脏读、不可重复读、幻读的发生

2、Repeatable read (可重复读)：可避免脏读、不可重复读的发生。

3、Read committed (读已提交)：可避免脏读的发生。

4、Read uncommitted (读未提交)：最低级别，任何情况都无法保证

1.  ### **SQL注入攻击** ###

SQL注入是一种将SQL代码添加到输入参数中，传递到服务器解析并执行的一种攻击手法。

SQL注入攻击是输入参数未经过滤，然后直接拼接到SQL语句当中解析，执行达到预想之外的一种行为，称之为SQL注入攻击。

1.  ### **自动刷新,定时刷新** ###

自动刷新不仅可以实现一段时间之后自动跳转到另一个页面，还可以实现一段时间之后自动刷新本页面。Servlet中通过HttpServletResponse对象设置Header属性实现自动刷新例如：

Response.setHeader("Refresh","1000;URL=http://localhost:8080/servlet/example.htm");

其中1000为时间，单位为毫秒。URL指定就是要跳转的页面（如果设置自己的路径，就会实现没过一秒自动刷新本页面一次）

1.  ### **BS和CS的区别？** ###

1.C/S用户固定，并且处于相同区域，要求拥有相同的操作系统。B/S要有操作系统和浏览器就行。与操作系统平台无关。

2.C/S客户端的计算机电脑配置要求较高。B/S客户端的计算机电脑配置要求较低。

3.C/S每一个客户端都必须安装和配置软件,客户端不必安装，使用浏览器访问，易推广。B/S最大的优点就是可以在任何地方进行操作而不用安装任何专门的软件。

4.C/S每一个客户端都要升级程序。可以采用自动升级。BS客户端不必安装及维护。

5.C/S一般面向相对固定的用户群，程序更加注重流程，它可以对权限进行多层次校验，提供了更安全的存取模式，对信息安全的控制能力很强。一般高度机密的信息系统采用C/S结构适宜。

1.  ### **事务有哪些特性** ###

事务的特性:ACID

A - 原子性 Atomic

数据操作的最小单元是事务，而不是SQL语句

C - 一致性 Consistency

转账前a+b = 100

转帐后a+b = 100

I - 隔离性 Isolation

一个事物进行中时，另一事物不能操作数据

D - 持久性 Durancy

事务没有提交之前，数据操作只保存在日志文件中

提交事务之后，数据持久生效

1.  ### **Spring 在ssm中起什么作用？** ###

Spring：轻量级框架

作用：Bean工厂，用来管理Bean的生命周期和框架集成。

两大核心：

1、IOC/DI(控制反转/依赖注入) ：把dao依赖注入到service层，service层反转给action层，Spring顶层容器为BeanFactory。反客特锐 Spring+SpringMVC+Mybatis=ssm

2、AOP：面向切面编程

1.  ### **Spring的配置文件中的内容？** ###

开启事务注解驱动

事务管理器

开启注解功能，并配置扫描包

配置数据库

配置SQL会话工厂，别名，映射文件

1.  ### **Spring主要使用了什么模式？** ###

工厂模式：每个Bean的创建通过方法

单例模式：默认的每个Bean的作用域都是单例

代理模式：关于Aop的实现通过代理模式

1.  ### **何为Spring Bean容器?Spring Bean容器与Spring IOC 容器有什么不同吗?** ###

用于创建bean对象,管理bean对象的那个容器

Spring IOC 容器本质上指的的就是Spring Bean容器,

Spring Bean容器中最核心一个机制是IOC机制(控制反转),所以有时候又将springbean容器称之为Spring IOC 容器.将创建的对象存入spring容器，和从容器中取出的过程，就叫控制反转

1.  ### **Spring IOC 如何理解?** ###

IOC 是Spring中提供一种控制反转机制,目的是将我们项目中对象的依赖管理交给Spring实现,这样可以更好实现对象关系的解耦,提高程序的可扩展性.

1.  ### **Spring DI 如何理解?** ###

DI 是Spring中的依赖注入机制,IOC的实现需要借助这种机制.我们通常会这样理解,Spring Bean容器中的IOC是一种思想,DI是实现这种思想的目标的手段.

1.  ### **Spring 中基于注解如何配置对象作用域?以及如何配置延迟加载机制?** ###

@Scope(“singleton”) 单例模式，全局有且仅有一个实例

@Scope(“prototype”) 原型模式，每次获取Bean的时候会有一个新的实例

@Lazy(value=true) 懒加载

1.  ### **描述Spring MVC处理流程及应用优势** ###

1、客户端发出一个http请求给web服务器，web服务器对http请求进行解析，如果匹配前端控制器(或分发器/DispatcherServlet 第四班车儿)的请求映射路径，web容器将请求转交给DispatcherServlet.

2、DispatcherServlet接收到这个请求之后将根据请求的信息以及处理器映射器(HandlerMapping)的配置找到处理请求的处理器（Handler）。

3、由具体的处理器适配器（HandlerAdapter）对Handler进行具体的调用。

4、Handler对数据处理完成以后将返回一个ModelAndView()对象给 DispatcherServlet。

5、DispatcherSevlet通过视图解析器（ViewResolver）将ModelAndView()转化为真正的视图View。

6、Dispatcher通过model解析出ModelAndView()中的参数进行解析最终展现出完整的view并返回给客户端。

![bfffe3ae3bacb4772051ed4b5b21594f.png][]

1.  ### **MyBatis应用动态SQL解决了什么问题** ###

有时候，固定的sql语句不能够满足我们的应用需求。这个时候需要在标准的基础上建立动态的查询语句。

Mybatis提供了多种注解，可以提供动态查询语言。

比如说在开发的时候，遇到这样的场景，界面提供了多种查询，但是都是非必填写，在选择查询条件时可以选中任意几种组合作为查询条件，如果jdbc的时候，需要判断参数为空，自己组装sql， if、for但是mybatis提供动态sql机制，依靠标签。

1.  ### **Shiro框架权限管理时的认证和授权流程描述.** ###

Shiro权限控制流程的原理：

应用代码 —- 调用Subject （shiro的Subject 就代表当前登陆用户） 控制权限 —- Subject 在shiro框架内部 调用 Shiro SecurityManager 安全管理器 —– 安全管理器调用 Realm （程序和安全数据连接器 ）。

Subject要进行任何操作，都必须要调用安全管理器（对我们来说是自动的）。

而安全管理器会调用指定的Realms对象，来连接安全数据。

Realms用来编写安全代码逻辑和访问安全数据，是连接程序和安全数据的桥梁。

1.  ### **请解释Spring Bean的生命周期？** ###

Spring Bean的生命周期简单易懂。在一个bean实例被初始化时，需要执行一系列的初始化操作以达到可用的状态。同样的，当一个bean不在被调用时需要进行相关的析构操作，并从bean容器中移除。

Spring bean factory 负责管理在spring容器中被创建的bean的生命周期。Bean的生命周期由两组回调（call back）方法组成。

初始化之后调用的回调方法。

销毁之前调用的回调方法。

Spring框架提供了以下四种方式来管理bean的生命周期事件：

InitializingBean和DisposableBean回调接口

针对特殊行为的其他Aware接口

Bean配置文件中的Custom init()方法和destroy()方法

@PostConstruct和@PreDestroy注解方式

使用customInit()和 customDestroy()方法管理bean生命周期的代码样例如下：

1.  ### **Spring 中用到了那些设计模式？** ###

·Spring框架中使用到了大量的设计模式，下面列举了比较有代表性的：

·代理模式—在AOP和remoting中被用的比较多。 瑞茂定

·单例模式—在spring配置文件中定义的bean默认为单例模式。

·模板方法—用来解决代码重复的问题。比如. RestTemplate, JmsTemplate, JpaTemplate。

·工厂模式—BeanFactory用来创建对象的实例。

·适配器–spring aop

·装饰器–spring data hashmapper 哈市

·观察者– spring 时间驱动模型

·回调–Spring ResourceLoaderAware回调接口

1.  ### **Spring支持的事务管理类型** ###

Spring支持如下两种方式的事务管理：

编程式事务管理：这意味着你可以通过编程的方式管理事务，这种方式带来了很大的灵活性，但很难维护。

声明式事务管理：这种方式意味着你可以将事务管理和业务代码分离。你只需要通过注解或者XML配置管理事务。

1.  ### **Spring MVC的主要组件？** ###

（1）前端控制器 DispatcherServlet（不需要程序员开发）

作用：接收请求、响应结果，相当于转发器，有了DispatcherServlet 就减少了其它组件之间的耦合度。

（2）处理器映射器HandlerMapping（不需要程序员开发）

作用：根据请求的URL来查找Handler

（3）处理器适配器Handle—rAdapter 额单特

注意：在编写Handler的时候要按照HandlerAdapter要求的规则去编写，这样适配器HandlerAdapter才可以正确的去执行Handler。

（4）处理器Handler（需要程序员开发） controller中传参调用方法处理请求

（5）视图解析器 ViewResolver（不需要程序员开发）

作用：进行视图的解析，根据视图逻辑名解析成真正的视图（view）

（5）视图View（需要程序员开发jsp）

JsonResult.ok将处理好的数据进行数据的类型转换返回前端

View是一个接口， 它的实现类支持不同的视图类型（jsp，freemarker 福瑞玛卡，pdf等等

### 后面还有很多，后面有空进行更新！！！！！！！ ###

[http_localhost_8848_nacos_index.html]: http://localhost:8848/nacos/index.html
[Link 1]: https://so.csdn.net/so/search?q=%E5%88%86%E5%B8%83%E5%BC%8F&spm=1001.2101.3001.7020
[9a345d2018156be2fd78ee54615bc3de.png]: https://img-blog.csdnimg.cn/img_convert/9a345d2018156be2fd78ee54615bc3de.png
[2917a7826c5a787f01c2c24d43308bee.png]: https://img-blog.csdnimg.cn/img_convert/2917a7826c5a787f01c2c24d43308bee.png
[8543de3d5253f61f375939ac85f40e69.png]: https://img-blog.csdnimg.cn/img_convert/8543de3d5253f61f375939ac85f40e69.png
[bfffe3ae3bacb4772051ed4b5b21594f.png]: https://img-blog.csdnimg.cn/img_convert/bfffe3ae3bacb4772051ed4b5b21594f.png