面试题总结
你是计算机专业，学过哪些编程语言？解释下c中的指针指针是一个变量，其值为另一个变量的地址，即，内存位置的直接地址。就像其他变量或常量一样，您必须在使用指针存储其他变量地址之前，对其进行声明。指针变量声明的一般形式为：容器包含哪些？list，map的子类有哪些？区别，底层实现jvm了解多少堆聊一下，新声代老年代永久带。。。出一道sql分组查询平均数，外加排序li..................
前比较常用的构建线程安全的List有三种方法：
- 使用Vector容器
- 使用Collections的静态方法synchronizedList(List< T> list)
- 采用CopyOnWriteArrayList容器
- 获取线程安全的List我们可以通过Vector、Collections.synchronizedList()方法和CopyOnWriteArrayList三种方式
读多写少的情况下，推荐使用CopyOnWriteArrayList方式
读少写多的情况下，推荐使用Collections.synchronizedList()的方式
三种线程安全的List_橙不甜橘不酸的博客-CSDN博客_线程安全的list
mysql事务隔离级别与读写锁
mysql事物隔离级别，底层实现
redis sds实现
b+树
非聚集和聚集b+树区别
mysql，innodb
synchronized ,以及升级过程
AQS
JVM
hashmap底层实现 1.6和1.7区别
mq 交换机
spring事务传播特性
redis 数据一致性
JVM内存模型
哨兵模式
Mq防止消息丢失
Java线程池七个核心参数
路由规则
锁
cas
eruka同步策略
线程池
ActiveMQ死信产生的原因及使用方案
数据库事物
线程多线程 实际的应用情况剧烈
大量数据 用线程池处理 怎么处理
内存泄漏和内存溢出
jvm的几种回收机制以及优点
类加载器可以打破双亲委派吗
java的同步工具
hashmap的底层结构，什么时候会触发红黑树 1.7和1.8的改变
java锁有什么了解 自己在哪方面用到 描述一下
设计模式有哪几类 分别有哪些设计模式
讲一下用过的设计模式 代码
创建线程的方式有几种
springboot的自动加载怎么实现的
redis的穿透 雪崩 击穿
redis 数据同步
springboot 启动流程
bean 初始化
mongodb和mysql区别
es使用
neo4j多层查询
spring 循环依赖
docker命令
redis的持久化
两种：aof,rdb
方便记忆：a-append 基于日志追加
rdb是基于镜像，默认是两种都会生效，
例如，aof每秒同步一次（可以设置日志追加与否）
rdb默认是参数可参考save 参数，当然我们也可以根据自己的业务自定义
save 900 1
save 300 10
save 60 10000
appendonly no
appendfilename "appendonly.aof"
appendfsync everysec
# If unsure, use "everysec".
# appendfsync always
appendfsync everysec
# appendfsync no
dbfilename dump.rdb
databases 16
save 900 1
save 300 10
save 60 10000
springboot如何解决循环依赖问题
1.在你的配置文件中，在互相依赖的两个bean的任意一个加上lazy-init属性
2.在你注入bean时，在互相依赖的两个bean上加上@Lazy注解也可以
docker的开发部署流程
docker部署的原理很简单，基于一个jdk的基础镜像，把对应的app.jar与基础镜像制作成对应的服务镜像，发布到对应的镜像仓库，在部署到k8环境
springcloud 和 springboot是什么关系？
springboot专注于快速方便的开发单个个体微服务。
springcloud是关注全局的微服务协调治理框架，它将springboot开发的一个个单体微服务整合并管理起来
为各个微服务之间提供，配置管理，服务发现，断路器，路由，微代理，事件总线，全局锁，决策竞选，分布式会话等集成服务
springboot可以离开springcloud独立使用开发项目，但是springcloud离不开springboot，属于依赖的关系，springboot专注于快速，方便的开发单个微服务个体，spirngcloud关注全局的微服务治理框架。
springcloud config 能干嘛？
1.集中管理配置文件
2.不同环境不同配置，动态化的配置更新，分环境部署比如dev/test/prod/teta/relase
3.运行期间动态调整配置，不再需要在每个服务部署的机器上编写配置文件，服务会向配置中心统一拉取配置
4.当配置发生变动时，服务不需要重启即可感知到配置的变化并应用新的配置
5.将配置信息以REST接口的形式暴露
Sole跟es比较以及不采用Solr的原因大揭秘
两个框架底层使用的都是lucene,而es出来的比较晚，他们的更新速度都相对比较快。
es的搜索速度会更快，他的变更也更友好，es可以做到近实时的搜索，当数据量大的时候，当有大量的新增数据，搜索服务都需要先做分词，然后在存入搜索库，在
性能比较上，es表现地非常好。
Solr完全免费，而es高级功能部分收费（权限）
MongoDB
它是最像关系型数据库的非关系型数据库软件
对于我们采集来的数据，其实有部分不一定要哦存到mysql中，而且采集到的数据没有太复杂的逻辑关系，可以把采集来的数据放到非关系型数据库中，
非常推荐大家使用mongodb，在跟springboot整合后，很难发现他的操作方式跟mysql有什么区别
mongodb的安装配置略微有些复杂，现在建议大家安装的版本是3.7，要注意的是安装完毕后需要配置数据库的存储路径，还要注意磁盘的占用问题。
在安装过程中肯定会遇到各种各样的问题，大家遇到的问题较多，你能学到的也就越多。
素具采集表，设备表，设备阀值
物联网项目中为什么用es
大量传感器数据采集，数据如果继续放在mysql,是承受不了的。需要能实时检索，并作大量的统计。
数据采集LogStash&数据可视化-Kibana的友好展示
es做搜索非常厉害，但是数据哪里来，这是需要使用LogStash进行采集的，可以从日志，消息队列，数据库进行数据的采集。
官方也提供了开箱即用的安装包，我们只需要下载安装包，然后配置数据源，将数据保存到es中即可。
数据的展示就需要使用Kibana,Kibana也可以做es的管理。
需要注意的是，大家在安装配置elk的时候，要统一他们三者之间的版本。
ELK运行是依赖于java运行时环境的，由于ELK消耗的服务器资源相对较多，需要服务器的配置相对较多，也需要配置多台服务器，建议搭建一个高可用的集群。
权限框架
Shiro和SpringSecurity他们的使用场景
在开发中Shiro用的稍微多一点，其实这两个权限框架的原理都是类似的。
有两种权限控制的方式：
粗粒度：我只判断是否登陆，在访问页面之前判断用户是否有权限，权限只判断一次
细粒度：细粒度指的是在访问每个方法之前，都会进行权限校验，控制的非常精细
权限的具体实现：
写代码做逻辑判断：用的很少
把规则写在配置文件中：对于页面的访问，大部分情况下用于粗粒度
规则定义在表中：用户表，角色表，权限表，菜单表，他们之间都是多对多的关系
爬虫程序
1.模拟用户行为
用户的行为就是一个http请求，可以采用httpclient发送请求，得到相应页面的数据
2.对页面进行解析
jsoup webmagic
3.保存数据jdbc
测试原理
任何继承自 junit.framework.TestCase或groovy.util.GroovyTestCase的类
任何被@RunWith注解的类
任何至少包含一个被@Test注解的类
消息队列的重试机制
项目中使用了mq，mq发送消息可能会失败，失败了之后会进行重试操作，尽量避免消息的丢失。这里以activemq为例，会首先发送一次，如果失败，重试六次，
如果六次后依然失败，就认为消息发不出去了，会把消息放到死信队列，等待用户手动处理
Mq持久化
RabbitMQ之消息持久化_朱小厮的博客-CSDN博客_rabbitmq消息持久化
RabbitMQ的消息确认ACK机制 - 别先生 - 博客园
zset 跳表
关于redis中zset底层跳表的理解 - Code2020 - 博客园
多线程 生命周期
1.新建状态 2.就绪状态 3.运行状态 4.阻塞状态 5.死亡状态
https://www.cnblogs.com/sunddenly/p/4106562.html
你是计算机专业，学过哪些编程语言？
解释下c中的指针
指针是一个变量，其值为另一个变量的地址，即，内存位置的直接地址。就像其他变量或常量一样，您必须在使用指针存储其他变量地址之前，对其进行声明。指针变量声明的一般形式为：
容器包含哪些？
list，map的子类有哪些？区别，底层实现
jvm了解多少
堆聊一下，新声代老年代永久带。。。
出一道sql分组查询平均数，外加排序
linux常用命令（查看线程，查看目录，授权，，
redis，使用场景，为什么不用mysql直接查
工作中有木有涉及线程安全的场景（回答了conrrenthamap，又问到了分段线程锁）面试官鄙视了conrrenthashmap这种，说效率太低，没红黑树效率高。。。
Java 8和7内存分配区别
Redis主从
Do bbo协议
Bobbo支持的文件传输协议
手写二分查找，list排序
事务隔离级别
Redis支持的存储类型
Mysql锁
Sql优化
Git命令
Pom结构
springcloud的组件及调用流程
dubbo实现服务的指定调用，或者绕过注册中心直接去服务提供者调用，如何配置
mybatis如何实现sql预编译
编写sql的时候注意哪些？
索引创建的注意事项？
class.format反射
IOC使用到了哪些设计模式
CAS
springboot事务
如何保证消息被送达
为什么redis效率很高
什么是长连接，短连接
什么是有状态，什么时候是无状态
springcloud中升降级机制
spring事务的传播特性
阿里巴巴Java开发手册建议：循环体内，字符串的连接方式，使用 StringBuilder 的 append 方法进行扩展。而不要使用+
性能对比：
StringBuilder < StringBuffer < concat < + < StringUtils.join
简单说一下servlet的生命周期?
servlet有良好的生存期的定义，包括加载和实例化、初始化、处理请求以及服务结束。这个生存期由javax.servlet.Servlet接口的init,service和destroy方法表达。
加载Servlet的class---->实例化Servlet----->调用Servlet的init完成初始化---->响应请求（Servlet的service方法）----->Servlet容器关闭时(Servlet的destory方法)
Servlet启动时，开始加载servlet生命周期开始。Servlet被服务器实例化后，容器运行其init方法，请求到达时运行其service方法，service方法自动派遣运行与请求对应的doXXX方法（doGet，doPost）等，当服务器决定将实例销毁的时候(服务器关闭)调用其destroy方法。
Servlet API中forward() 与redirect()的区别？
1、forward是服务器端的转向而redirect是客户端的跳转。
2、使用forward浏览器的地址不会发生改变。而redirect会发生改变。
3、Forward是一次请求中完成。而redirect是重新发起请求。
4、Forward是在服务器端完成，而不用客户端重新发起请求，效率较高。
SQL 之聚合函数
聚合函数是对一组值进行计算并返回单一的值的函数，它经常与select语句中的 group by子句一同使用。
group by()：对数据进行分组，对执行完 group by 之后的组进行聚合函数的运算，计算每一组的值。
最后用having去掉不符合条件的组，having子句中的每一个元素必须出现在select列表中（只针对于mysql）
数组是一种类型（引用），存储相同类型的元素（类型唯一），list(类型不唯一)
数据初始化后，大小固定不变，list可以自动进行扩容
list支持泛型
三者都用来处理一组数据，继承了IEnumerable接口，可用于for循环处理。都可以通过索引下标进行获取和设置元素。
数组在内存中是连续的，长度固定，无法删除和增加新的元素。而ArrayList或List的容量可根据需要自动插入和删除元素。
数组可以具有多个维度，而 ArrayList或 List< T> 始终只具有一个维度。但是，您可以轻松创建数组列表或列表的列表。
特定类型（Object 除外）的数组 的性能优于 ArrayList的性能。 这是因为 ArrayList的元素属于 Object 类型；所以在存储或检索值类型时通常发生装箱和取消装箱操作。不过，在不需要重新分配时（即最初的容量十分接近列表的最大容量），List< T> 的性能与同类型的数组十分相近。
在决定使用 List 还是使用ArrayList 类（两者具有类似的功能）时，记住List 类在大多数情况下执行得更好并且是类型安全的。如果对List< T> 类的类型T 使用引用类型，则两个类的行为是完全相同的。但是，如果对类型T使用值类型，则需要考虑实现和装箱问题。
深入理解 Java 中的 final 关键字
final 关键字可以用于成员变量、本地变量、方法以及类
•final 成员变量必须在声明的时候初始化或者在构造器中初始化，否则就汇报编译错误
•不能够对 final 变量再次赋值
•本地变量必须在声明时赋值•在匿名类中所有变量都必须是 final 变量
•final 方法不能被重写
•final 类不能被继承
•接口中声明的所有变量本身是 final 的
•final 和 abstract 这两个关键字是反相关的，final 类就不可能是 abstract 的
•没有在声明时初始化 final 变量的称为空白 final 变量(blank final variable)，它们必须在构造器中初始化，或者调用 this() 初始化，不这么做的话，编译器会报错final变量(变量名)需要进行初始化
•按照 Java 代码惯例，final 变量就是常量，而且通常常量名要大写
•对于集合对象声明为 final 指的是引用不能被更改
ArrayList集合删除用什么方式？
使用迭代器Iterator删除元素，
Iterator<String> iterator = arrayList2.iterator();
while(iterator.hasNext()){
String item = iterator.next();
if("1".equals(item)){
iterator.remove();
}
}
如果存在并发操作，还需要对Iterator进行加锁操作。
数组和list区别
数组是一种类型（引用），存储相同类型的元素（类型唯一），list(类型不唯一)
数据初始化后，大小固定不变，list可以自动进行扩容
list支持泛型
三者都用来处理一组数据，继承了IEnumerable接口，可用于for循环处理。都可以通过索引下标进行获取和设置元素。
数组在内存中是连续的，长度固定，无法删除和增加新的元素。而ArrayList或List的容量可根据需要自动插入和删除元素。
数组可以具有多个维度，而 ArrayList或 List< T> 始终只具有一个维度。但是，您可以轻松创建数组列表或列表的列表。
特定类型（Object 除外）的数组 的性能优于 ArrayList的性能。 这是因为 ArrayList的元素属于 Object 类型；所以在存储或检索值类型时通常发生装箱和取消装箱操作。不过，在不需要重新分配时（即最初的容量十分接近列表的最大容量），List< T> 的性能与同类型的数组十分相近。
在决定使用 List 还是使用ArrayList 类（两者具有类似的功能）时，记住List 类在大多数情况下执行得更好并且是类型安全的。如果对List< T> 类的类型T 使用引用类型，则两个类的行为是完全相同的。但是，如果对类型T使用值类型，则需要考虑实现和装箱问题。
SpringMVC 的工作原理
a. 用户向服务器发送请求，请求被 springMVC 前端控制器 DispatchServlet 捕获；
b. DispatcherServle 对请求 URL 进行解析，得到请求资源标识符（URL），然后根据该 URL 调用 HandlerMapping
将请求映射到处理器 HandlerExcutionChain；
c. DispatchServlet 根据获得 Handler 选择一个合适的 HandlerAdapter 适配器处理；
d. Handler 对数据处理完成以后将返回一个 ModelAndView（）对象给 DisPatchServlet;
e. Handler 返回的 ModelAndView()只是一个逻辑视图并不是一个正式的视图， DispatcherSevlet 通过
ViewResolver 试图解析器将逻辑视图转化为真正的视图 View;
h. DispatcherServle 通过 model 解析出 ModelAndView()中的参数进行解析最终展现出完整的 view 并返回给
客户端;
简单介绍一下 Spring bean 的生命周期
bean 定义：在配置文件里面用<bean></bean>来进行定义。
bean 初始化：有两种方式初始化:
1.在配置文件中通过指定 init-method 属性来完成
2.实现 org.springframwork.beans.factory.InitializingBean 接口
bean 调用：有三种方式可以得到 bean 实例，并进行调用
bean 销毁：销毁有两种方式
1.使用配置文件指定的 destroy-method 属性
2.实现 org.springframwork.bean.factory.DisposeableBean 接口
索引总结
好的索引设计：兰博基尼
没有索引： 人力三轮车
索引分单列索引和组合索引
单列索引，即一个索引只包含单个列，一个表可以有多个单列索引，但这不是组合索引。
组合索引，即一个索引包含多个列。
创建索引列：一般作为 WHERE 子句的条件
实际上，索引也是一张表，该表保存了主键与索引字段，并指向实体表的记录。
缺点：虽然索引大大提高了查询速度，同时却会降低更新表的速度，如对表进行INSERT、UPDATE和DELETE。因为更新表时，MySQL不仅要保存数据，还要保存一下索引文件。
建立索引会占用磁盘空间的索引文件。
唯一索引
它与前面的普通索引类似，不同的就是：索引列的值必须唯一，但允许有空值。如果是组合索引，则列值的组合必须唯一。它有以下几种创建方式：
SHOW INDEX FROM person;
Mysql 性能优化
1、 当只要一行数据时使用 limit 1
Mysql 中有两个引擎 MyISAM 和 InnoDB，每个引擎有利有弊。
MyISAM 适用于一些大量查询的应用，但对于有大量写功能的应用不是很好。甚至你只需要
update 一个字段整个表都会被锁起来。而别的进程就算是读操作也不行要等到当前 update 操作完成之后才能继续进行。另外， MyISAM 对于 select count(*)这类操作是超级快的。
InnoDB 的趋势会是一个非常复杂的存储引擎，对于一些小的应用会比 MyISAM 还慢，但是支持“行锁”，所以在写操作比较多的时候会比较优秀。并且，它支持很多的高级应用，例如：事物。
3. 用 not exists 代替 not in
Not exists 用到了连接能够发挥已经建立好的索引的作用， not in 不能使用索引。 Not in 是最慢的方式要同每条记录比较，在数据量比较大的操作红不建议使用这种方式。
4. 对操作符的优化，尽量不采用不利于索引的操作符
如： in not in is null is not null <> 等
某个字段总要拿来搜索，为其建立索引：
Mysql 中可以利用 alter table 语句来为表中的字段添加索引，语法为： alter table 表明
add index (字段名)；
在同一数据库不同表之间mysql引擎是否可以混用
mysql可以实现，同一个数据库中，不同的表应用不同的存储引擎，
mysql主从数据库里同一张表，数据引擎也可以不一样
在建表的时候，设定引擎就好了
事务的四大特征是什么？
数据库事务 transanction 正确执行的四个基本要素。 ACID,原子性(Atomicity)、一致性(Correspondence)、隔离
性(Isolation)、持久性(Durability)。
（1）原子性：整个事务中的所有操作，要么全部完成，要么全部不完成，不可能停滞在中间某个环节。事务在执
行过程中发生错误，会被回滚（Rollback）到事务开始前的状态，就像这个事务从来没有执行过一样。
（2）一致性：在事务开始之前和事务结束以后，数据库的完整性约束没有被破坏。
（3）隔离性：隔离状态执行事务，使它们好像是系统在给定时间内执行的唯一操作。如果有两个事务，运行在相
同的时间内，执行 相同的功能，事务的隔离性将确保每一事务在系统中认为只有该事务在使用系统。这种属性有时称
为串行化，为了防止事务操作间的混淆， 必须串行化或序列化请 求，使得在同一时间仅有一个请求用于同一数据。
（4）持久性：在事务完成以后，该事务所对数据库所作的更改便持久的保存在数据库之中，并不会被回滚。
SQL多表查询优化
--0.15s
select * from (select * from t_crm_project where LENGTH(project_code)>8) t1 left JOIN t_app_little_user tu on t1.project_code=tu.project_code
--0.154
select * from t_crm_project t1 left join t_app_little_user tu on t1.project_code=tu.project_code where LENGTH(t1.project_code)>8SQL 之聚合函数
聚合函数是对一组值进行计算并返回单一的值的函数，它经常与select语句中的 group by子句一同使用。
group by()：对数据进行分组，对执行完 group by 之后的组进行聚合函数的运算，计算每一组的值。
最后用having去掉不符合条件的组，having子句中的每一个元素必须出现在select列表中（只针对于mysql）
Redis 的持久化
RDB 持久化：该机制可以在指定的时间间隔内生成数据集的时间点快照（point-in-time snapshot）。
AOF 持久化：记录服务器执行的所有写操作命令，并在服务器启动时，通过重新执行这些命令来还原数据集。 AOF
文件中的命令全部以 Redis 协议的格式来保存，新命令会被追加到文件的末尾。 Redis 还可以在后台对 AOF 文件进行重写（rewrite），使得 AOF 文件的体积不会超出保存数据集状态所需的实际大小
无持久化：让数据只在服务器运行时存在。
同时应用 AOF 和 RDB：当 Redis 重启时， 它会优先使用 AOF 文件来还原数据集， 因为 AOF 文件保存的
数据集通常比 RDB 文件所保存的数据集更完整。
RDB 的优缺点：
优点： RDB 是一个非常紧凑（compact）的文件，它保存了 Redis 在某个时间点上的数据集。 这种文件非
常适合用于进行备份： 比如说，你可以在最近的 24 小时内，每小时备份一次 RDB 文件，并且在每个月的每一
天，也备份一个 RDB 文件。 这样的话，即使遇上问题，也可以随时将数据集还原到不同的版本。 RDB 非常适
用于灾难恢复（disaster recovery）：它只有一个文件，并且内容都非常紧凑，可以（在加密后）将它传送到别的
数据中心，或者亚马逊 S3 中。 RDB 可以最大化 Redis 的性能：父进程在保存 RDB 文件时唯一要做的就是 fork
出一个子进程，然后这个子进程就会处理接下来的所有保存工作，父进程无须执行任何磁盘 I/O 操作。
RDB 恢复大数据集时的速度比 AOF 的恢复速度要快。
缺点：如果你需要尽量避免在服务器故障时丢失数据，那么 RDB 不适合你。 虽然 Redis 允许你设置不同
的保存点（save point）来控制保存 RDB 文件的频率， 但是， 因为 RDB 文件需要保存整个数据集的状态， 所
以它并不是一个轻松的操作。 因此你可能会至少 5 分钟才保存一次 RDB 文件。 在这种情况下， 一旦发生故
障停机， 你就可能会丢失好几分钟的数据。每次保存 RDB 的时候， Redis 都要 fork() 出一个子进程，并由子
进程来进行实际的持久化工作。 在数据集比较庞大时， fork() 可能会非常耗时，造成服务器在某某毫秒内停止
处理客户端； 如果数据集非常巨大，并且 CPU 时间非常紧张的话，那么这种停止时间甚至可能会长达整整一秒。
AOF 的优缺点。
优点：
1、使用 AOF 持久化会让 Redis 变得非常耐久（much more durable）：你可以设置不同的 fsync 策略，比如
无 fsync ，每秒钟一次 fsync ，或者每次执行写入命令时 fsync 。 AOF 的默认策略为每秒钟 fsync 一次，在这种
配置下， Redis 仍然可以保持良好的性能，并且就算发生故障停机，也最多只会丢失一秒钟的数据（fsync 会在后台
线程执行，所以主线程可以继续努力地处理命令请求）。 AOF 文件是一个只进行追加操作的日志文件（append only
log）， 因此对 AOF 文件的写入不需要进行 seek ， 即使日志因为某些原因而包含了未写入完整的命令（比如写入
时磁盘已满，写入中途停机，等等）， redis-check-aof 工具也可以轻易地修复这种问题。
2、 Redis 可以在 AOF 文件体积变得过大时，自动地在后台对 AOF 进行重写： 重写后的新 AOF 文件包含了
恢复当前数据集所需的最小命令集合。 整个重写操作是绝对安全的，因为 Redis 在创建新 AOF 文件的过程中，会
继续将命令追加到现有的 AOF 文件里面，即使重写过程中发生停机，现有的 AOF 文件也不会丢失。 而一旦新 AOF
文件创建完毕， Redis 就会从旧 AOF 文件切换到新 AOF 文件，并开始对新 AOF 文件进行追加操作。
缺点：
对于相同的数据集来说， AOF 文件的体积通常要大于 RDB 文件的体积。根据所使用的 fsync 策略， AOF 的速度可能会慢于 RDB 。
在一般情况下， 每秒 fsync 的性能依然非常高， 而关闭 fsync 可以让 AOF 的速度和 RDB一样快， 即使在高负荷之下也是如此。 不过在处理巨大的写入载入时， RDB 可以提供更有保证的最大延迟时间（latency）。
AOF 在过去曾经发生过这样的 bug ： 因为个别命令的原因，导致 AOF 文件在重新载入时，无法将数据集恢复
成保存时的原样。 （举个例子，阻塞命令 BRPOPLPUSH 就曾经引起过这样的 bug 。） 测试套件里为这种情况添
加了测试： 它们会自动生成随机的、复杂的数据集， 并通过重新载入这些数据来确保一切正常。 虽然这种 bug 在
AOF 文件中并不常见， 但是对比来说， RDB 几乎是不可能出现这种 bug 的。
MyBatis 在 insert 插入操作时返回主键 ID
数据库为 MySql 时：
1. <insert id="insert" parameterType="com.test.User" keyProperty="userId"
useGeneratedKeys="true" >
“keyProperty”表示返回的 id 要保存到对象的那个属性中，“useGeneratedKeys”表示主键 id 为自增长模式。
MySQL 中做以上配置就 OK 了
数据库为 Oracle 时：
1. <insert id="insert" parameterType="com.test.User">
2. <selectKey resultType="INTEGER" order="BEFORE" keyProperty="userId">
3. SELECT SEQ_USER.NEXTVAL as userId from DUAL
4. </selectKey>
5. insert into user (user_id, user_name, modified, state)
6. values (#{userId,jdbcType=INTEGER}, #{userName,jdbcType=VARCHAR},
#{modified,jdbcType=TIMESTAMP}, #{state,jdbcType=INTEGER})
7. </insert>
由于 Oracle 没有自增长一说法，只有序列这种模仿自增的形式，所以不能再使用“useGeneratedKeys”属性。
而是使用<selectKey>将 ID 获取并赋值到对象的属性中， insert 插入操作时正常插入 id
简单说一下servlet的生命周期?
servlet有良好的生存期的定义，包括加载和实例化、初始化、处理请求以及服务结束。这个生存期由javax.servlet.Servlet接口的init,service和destroy方法表达。
加载Servlet的class---->实例化Servlet----->调用Servlet的init完成初始化---->响应请求（Servlet的service方法）----->Servlet容器关闭时(Servlet的destory方法)
Servlet启动时，开始加载servlet生命周期开始。Servlet被服务器实例化后，容器运行其init方法，请求到达时运行其service方法，service方法自动派遣运行与请求对应的doXXX方法（doGet，doPost）等，当服务器决定将实例销毁的时候(服务器关闭)调用其destroy方法。
Servlet API中forward() 与redirect()的区别？
1、forward是服务器端的转向而redirect是客户端的跳转。
2、使用forward浏览器的地址不会发生改变。而redirect会发生改变。
3、Forward是一次请求中完成。而redirect是重新发起请求。
4、Forward是在服务器端完成，而不用客户端重新发起请求，效率较高。
JSP和Servlet有哪些相同点和不同点?
JSP是Servlet技术的扩展，所有的jsp文件都会被翻译为一个继承HttpServlet的类。也就是jsp最终也是一个Servlet.这个Servlet对外提供服务。
Servlet和JSP最主要的不同点在于JSP侧重于视图，Servlet主要用于控制逻辑。
Servlet如果要实现html的功能，必须使用Writer输出对应的html,比较麻烦。而JSP的情况是Java和HTML可以组合成一个扩展名为.jsp的文件,做界面展示比较方便而嵌入逻辑比较复
jsp有哪些内置对象?作用分别是什么?
9个内置的对象：
request 用户端请求，此请求会包含来自GET/POST请求的参数
response 网页传回用户端的回应
pageContext 网页的属性是在这里管理
session 与请求有关的会话期
application servlet正在执行的内容
out 用来传送回应的输出
config servlet的构架部件
page JSP网页本身
exception 针对错误网页，未捕捉的例外
四大作用域：pageContext request session application 可以通过jstl从四大作用域中取值.
Jsp传递值request session application cookie也能传值
说一下session和cookie的区别？你在项目中都有哪些地方使用了？
Session和cookie都是会话(Seesion)跟踪技术。Cookie通过在客户端记录信息确定用户身份，Session通过在服务器端记录信息确定用户身份。但是Session的实现依赖于Cookie,sessionId(session的唯一标识需要存放在客户端).
cookie 和session 的区别：
1、cookie数据存放在客户的浏览器上，session数据放在服务器上。
2、cookie不是很安全，别人可以分析存放在本地的COOKIE并进行COOKIE欺骗
考虑到安全应当使用session。
3、session会在一定时间内保存在服务器上。当访问增多，会比较占用你服务器的性能,考虑到减轻服务器性能方面，应当使用COOKIE。
4、单个cookie保存的数据不能超过4K，很多浏览器都限制一个站点最多保存20个cookie。
5、所以个人建议：
将登陆信息等重要信息存放为SESSION
其他信息如果需要保留，可以放在COOKIE中，比如购物车最好使用cookie，但是cookie是可以在客户端禁用的，这时候我们要使用cookie+数据库的方式实现，当从cookie中不能取出数据时，就从数据库获取。
说一下你对servlet的理解？或者servlet是什么？
Servlet（Server Applet），全称Java Servlet， 是用Java编写的服务器端程序。而这些Sevlet都要实现Servlet这个借口。其主要功能在于交互式地浏览和修改数据，生成动态Web内容。Servlet运行于支持Java的应用服务器中。
HttpServlet 重写doGet和doPost方法或者你也可以重写service方法完成对get和post请求的响应
多态总结
靠的是父类或接口定义的引用变量可以指向子类或具体实现类的实例对象，而程序调用的方法在运行期才动态绑定，就是引用变量所指向的具体实例对象的方法，也就是内存里正在运行的那个对象的方法，而不是引用变量的类型中定义的方法。
有没有使用过线程并发库?
简单了解过？JDK5中增加了Doug Lea的并发库，这一引进给Java线程的管理和使用提供了强大的便利性。 java.util.current包中提供了对线程优化、管理的各项操作，使得线程的使用变得的心应手。
该包提供了线程的运行，线程池的创建，线程生命周期的控制.
Java通过Executors提供四个静态方法创建四种线程池，分别为：
newCachedThreadPool创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。
newFixedThreadPool 创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。
newScheduledThreadPool 创建一个定长线程池，支持定时及周期性任务执行。
newSingleThreadExecutor 创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行
字符串拼接性能对比？
阿里巴巴Java开发手册建议：循环体内，字符串的连接方式，使用 StringBuilder 的 append 方法进行扩展。而不要使用+
性能对比：
StringBuilder < StringBuffer < concat < + < StringUtils.join
讲一下String和StringBuilder的区别(final)？StringBuffer和StringBuilder的区别?
1.在java中提供三个类String StringBuillder StringBuffer来表示和操作字符串。字符串就是多个字符的集合。
String是内容不可变的字符串。String底层使用了一个不可变的字符数组(final char[])
String str =new String(“bbbb”);
而StringBuillder StringBuffer,是内容可以改变的字符串。StringBuillder StringBuffer底层使用的可变的字符数组（没有使用final来修饰）
2.最经典就是拼接字符串。
- String进行拼接.String c = “a”+”b”;
- StringBuilder或者StringBuffer
StringBuilder sb = new StringBuilder(); sb.apend(“a”).apend(“b”)
拼接字符串不能使用String进行拼接，要使用StringBuilder或者StringBuffer
3.StringBuilder是线程不安全的，效率较高.而StringBuffer是线程安全的，效率较低。
什么要使用 PreparedStatement？
1、 PreparedStatement 接口继承 Statement， PreparedStatement 实例包含已编译的 SQL 语句，所以其执行
速度要快于 Statement 对象。
2 、 作 为 Statement 的 子 类 ， PreparedStatement 继 承 了 Statement 的 所 有 功 能 。 三 种 方
法 execute、 executeQuery 和 executeUpdate 已被更改以使之不再需要参数
3、在 JDBC 应用中,在任何时候都不要使用 Statement，原因如下：
一、代码的可读性和可维护性.Statement 需要不断地拼接，而 PreparedStatement 不会。
二、 PreparedStatement 尽最大可能提高性能.DB 有缓存机制，相同的预编译语句再次被调用不会再次需要
编译。
三、最重要的一点是极大地提高了安全性.Statement 容易被 SQL 注入，而 PreparedStatementc 传入的内容不会和 sql 语句发生任何匹配关系。
谈下ArrayList、LinkedList
总结
对于LinkedList来说，头部插入和尾部插入时间复杂度都是O(1)
但是对于ArrayList来说，头部的每一次插入都需要移动size-1个元素，效率可想而知
但是如果都是在最中间的位置插入的话，ArrayList速度比LinkedList的速度快将近10倍
ArrayList、LinkedList查找
这就没啥好说的了，对于ArrayList，无论什么位置，都是直接通过索引定位到元素，时间复杂度O(1)
而对于LinkedList查找，其核心方法就是上面所说的node()方法，所以头尾查找速度极快，越往中间靠拢效率越低
Java switch 支持的类型有哪些？
char, byte, short, int, Character, Byte, Short, Integer, String, or an enum
什么情况下用“+” 运算符进行字符串连接比调用 StringBuffer/StringBuilder对象的 append 方法连接字符串性能更好？
1.+的底层用的还是StringBuilder,所以，能用StringBuilder就不要用+
finalize了解多少？
1.父类的方法
2.当对象由可达变成不可达，如果被回收就会调用finalize，如果还可以再变成可恢复，就不会被回收，否则，就会被回收掉
抽象的（abstract）方法是否可同时是静态的（static）,是否可同时是本地方法（native）,是否可同时被synchronized?
都不能。抽象方法需要子类重写，而静态的方法是无法被重写的，因此二者是矛盾的。本地方法是由本地代码（如C代码）实现的方法，而抽象方法是没有实现的，也是矛盾的。synchronized和方法的实现细节有关，抽象方法不涉及实现细节，因此也是相互矛盾的。
为什么要使用接口和抽象类
1.接口和抽象类都是抽象模型，经常用来定义模版
2.主要区别：
接口：
1.是多实现
2.方法全部都是抽象方法
3.抽象类中的成员可以是private,默认，protected,public
4.接口中定义的成员变量实际上都是常量
5.接口中不能有静态方法
抽象类：
1.是单继承，
2.可以有抽象方法和具体方法
3.成员变量都是public的
4.抽象类中可以定义构造器
5.有抽象方法的类必须被声明为抽象类，而抽象类未必有抽象方法
6.抽象类中可以包含静态方法
3.主流： 将接口放在顶层，抽象类实现该接口，具体类去继承该抽象类
4.说了这么多，貌似还是没说为什么要使用接口和抽象类，但123不已经具备接口和抽象类所有的优势了？
重载（overload）和重写（override）的区别？ 重载的方法能否根据返回类型进行区分？
方法的重载和重写都是实现多态的方式，区别在于前者实现的是编译时的多态性，而后者实现的是运行时的多态
性。重载发生在一个类中，同名的方法如果有不同的参数列表（参数类型不同、参数个数不同或者二者都不同）则视为
重载；重写发生在子类与父类之间，重写要求子类被重写方法与父类被重写方法有相同的返回类型，比父类被重写方
法更好访问，不能比父类被重写方法声明更多的异常（里氏代换原则）。重载对返回类型没有特殊的要求。
方法重载的规则：
1.方法名一致，参数列表中参数的顺序，类型，个数不同。
2.重载与方法的返回值无关，存在于父类和子类， 同类中。
3.可以抛出不同的异常，可以有不同修饰符。
方法重写的规则：
1.参数列表必须完全与被重写方法的一致，返回类型必须完全与被重写方法的返回类型一致。
2.构造方法不能被重写，声明为 final 的方法不能被重写，声明为 static 的方法不能被重写，但是能够被再次声明。
3.访问权限不能比父类中被重写的方法的访问权限更低。
4.重写的方法能够抛出任何非强制异常（UncheckedException，也叫非运行时异常），无论被重写的方法是否抛出异常。但是，重写的方法不能抛出新的强制性异常，或者比被重写方法声明的更广泛的强制性异常，反之则可以。
为什么函数不能根据返回类型来区分重载？
该道题来自华为面试题。
因为调用时不能指定类型信息，编译器不知道你要调用哪个函数。
例如：
1． float max(int a, int b);
2． int max(int a, int b);
当调用 max(1, 2);时无法确定调用的是哪个，单从这一点上来说，仅返回值类型不同的重载是不应该允许的。
再比如对下面这两个方法来说，虽然它们有同样的名字和自变量，但其实是很容易区分的：
1． void f() {}
2． int f() {}
若编译器可根据上下文（语境）明确判断出含义，比如在 int x=f()中，那么这样做完全没有问题。然而，我们也可能调用一个方法，同时忽略返回值；我们通常把这称为“为它的副作用去调用一个方法” ，因为我们关心的不是返回值，而是方法调用的其他效果。所以假如我们像下面这样调用方法： f(); Java 怎样判断 f()的具体调用方式呢？而且别人如何识别并理解代码呢？由于存在这一类的问题，所以不能。
函数的返回值只是作为函数运行之后的一个“状态”，他是保持方法的调用者与被调用者进行通信的关键。并不能作为某个方法的“标识”。
两个对象值相同 (x.equals(y) == true) ， 但却可有不同的 hashCode， 这句话对不对？
不对，如果两个对象 x 和 y 满足 x.equals(y) == true，它们的哈希码（hashCode）应当相同。
Java 对于 eqauls 方法和 hashCode 方法是这样规定的： (1)如果两个对象相同（equals 方法返回 true），那么它们的 hashCode 值一定要相同； (2)如果两个对象的 hashCode 相同，它们并不一定相同。当然，你未必要按照要求去做，但是如果你违背了上述原则就会发现在使用容器时，相同的对象可以出现在 Set 集合中，同时增加新元素的效率会大大下降（对于使用哈希存储的系统，如果哈希码频繁的冲突将会造成存取性能急剧下降）。
关于 equals 和 hashCode 方法，很多 Java 程序员都知道，但很多人也就是仅仅知道而已，在 Joshua Bloch的大作《Effective Java》（很多软件公司，《Effective Java》、《Java 编程思想》以及《重构：改善既有代码质量》是 Java 程序员必看书籍，如果你还没看过，那就赶紧去买一本吧）中是这样介绍 equals 方法的。
首先 equals 方法必须满足自反性（x.equals(x)必须返回 true）、对称性（x.equals(y)返回 true 时， y.equals(x)也必须返回 true）、传递性（x.equals(y)和 y.equals(z)都返回 true 时， x.equals(z)也必须返回 true）和一致性（当x 和 y 引用的对象信息没有被修改时，多次调用 x.equals(y)应该得到同样的返回值），而且对于任何非 null 值的引用 x， x.equals(null)必须返回 false。实现高质量的 equals 方法的诀窍包括： 1. 使用==操作符检查"参数是否为这个对象的引用"； 2. 使用 instanceof 操作符检查"参数是否为正确的类型"； 3. 对于类中的关键属性，检查参数传入对象的属性是否与之相匹配； 4. 编写完 equals 方法后，问自己它是否满足对称性、传递性、一致性； 5. 重写 equals 时总是要重写 hashCode； 6. 不要将 equals 方法参数中的 Object 对象替换为其他的类型，在重写时不要忘掉@Override 注解。
Java 中实现多态的机制是什么？
靠的是父类或接口定义的引用变量可以指向子类或具体实现类的实例对象，而程序调用的方法在运行期才动态绑定，就是引用变量所指向的具体实例对象的方法，也就是内存里正在运行的那个对象的方法，而不是引用变量的类型中定义的方法。
Redis 内存满了怎么办？
1、通过配置文件配置
//设置Redis最大占用内存大小为100M
maxmemory 100mb
2、通过命令修改
Redis支持运行时通过命令动态修改内存大小
//设置Redis最大占用内存大小为100M
127.0.0.1:6379> config set maxmemory 100mb
//获取设置的Redis能使用的最大内存大小
127.0.0.1:6379> config get maxmemory
3.Redis的内存淘汰(LRU算法)
dubbo是什么
dubbo是一个分布式框架，远程服务调用的分布式框架，其核心部分包含：集群容错：提供基于接口方法的透明远程过程调用，包括多协议支持，以及软负载均衡，失败容错，地址路由，动态配置等集群支持。远程通讯：提供对多种基于长连接的NIO框架抽象封装，包括多种线程模型，序列化，以及“请求-响应”模式的信息交换方式。自动发现：基于注册中心目录服务，使服务消费方能动态的查找服务提供方，使地址透明，使服务提供方可以平滑增加或减少机器。
dubbo能做什么
透明化的远程方法调用，就像调用本地方法一样调用远程方法，只需简单配置，没有任何API侵入。软负载均衡及容错机制，可在内网替代F5等硬件负载均衡器，降低成本，减少单点。服务自动注册与发现，不再需要写死服务提供方地址，注册中心基于接口名查询服务提供者的IP地址，并且能够平滑添加或删除服务提供者。
1、默认使用的是什么通信框架，还有别的选择吗?
答：默认也推荐使用 netty 框架，还有 mina。
2、服务调用是阻塞的吗？
答：默认是阻塞的，可以异步调用，没有返回值的可以这么做。
3、一般使用什么注册中心？还有别的选择吗？
答：推荐使用 zookeeper 注册中心，还有 Multicast注册中心, Redis注册中心, Simple注册中心.
ZooKeeper的节点是通过像树一样的结构来进行维护的，并且每一个节点通过路径来标示以及访问。除此之外，每一个节点还拥有自身的一些信息，包括：数据、数据长度、创建时间、修改时间等等。
4、默认使用什么序列化框架，你知道的还有哪些？
答：默认使用 Hessian 序列化，还有 Duddo、FastJson、Java 自带序列化。hessian是一个采用二进制格式传输的服务框架，相对传统soap web service，更轻量，更快速。
Hessian原理与协议简析：
http的协议约定了数据传输的方式，hessian也无法改变太多：
1) hessian中client与server的交互，基于http-post方式。
2) hessian将辅助信息，封装在http header中，比如“授权token”等，我们可以基于http-header来封装关于“安全校验”“meta数据”等。hessian提供了简单的”校验”机制。
3) 对于hessian的交互核心数据，比如“调用的方法”和参数列表信息，将通过post请求的body体直接发送，格式为字节流。
4) 对于hessian的server端响应数据，将在response中通过字节流的方式直接输出。
hessian的协议本身并不复杂，在此不再赘言；所谓协议(protocol)就是约束数据的格式，client按照协议将请求信息序列化成字节序列发送给server端，server端根据协议，将数据反序列化成“对象”，然后执行指定的方法，并将方法的返回值再次按照协议序列化成字节流，响应给client，client按照协议将字节流反序列话成”对象”。
5、服务提供者能实现失效踢出是什么原理？
答：服务失效踢出基于 zookeeper 的临时节点原理。
6、服务上线怎么不影响旧版本？
答：采用多版本开发，不影响旧版本。在配置中添加version来作为版本区分
7、如何解决服务调用链过长的问题？
答：可以结合 zipkin 实现分布式服务追踪。
8、说说核心的配置有哪些？
核心配置有：
1) dubbo:service/
2) dubbo:reference/
3) dubbo:protocol/
4) dubbo:registry/
5) dubbo:application/
6) dubbo:provider/
7) dubbo:consumer/
8) dubbo:method/
9、dubbo 推荐用什么协议？
答：默认使用 dubbo 协议。
10、同一个服务多个注册的情况下可以直连某一个服务吗？
答：可以直连，修改配置即可，也可以通过 telnet 直接某个服务。
11、dubbo 在安全机制方面如何解决的？
dubbo 通过 token 令牌防止用户绕过注册中心直连，然后在注册中心管理授权，dubbo 提供了黑白名单，控制服务所允许的调用方。
12、集群容错怎么做？
答：读操作建议使用 Failover 失败自动切换，默认重试两次其他服务器。写操作建议使用 Failfast 快速失败，发一次调用失败就立即报错。
13、在使用过程中都遇到了些什么问题？如何解决的？
1) 同时配置了 XML 和 properties 文件，则 properties 中的配置无效
只有 XML 没有配置时，properties 才生效。
2) dubbo 缺省会在启动时检查依赖是否可用，不可用就抛出异常，阻止 spring 初始化完成，check 属性默认为 true。
测试时有些服务不关心或者出现了循环依赖，将 check 设置为 false
3) 为了方便开发测试，线下有一个所有服务可用的注册中心，这时，如果有一个正在开发中的服务提供者注册，可能会影响消费者不能正常运行。
解决：让服务提供者开发方，只订阅服务，而不注册正在开发的服务，通过直连测试正在开发的服务。设置 dubbo:registry 标签的 register 属性为 false。
4) spring 2.x 初始化死锁问题。
在 spring 解析到 dubbo:service 时，就已经向外暴露了服务，而 spring 还在接着初始化其他 bean，如果这时有请求进来，并且服务的实现类里有调用 applicationContext.getBean() 的用法。getBean 线程和 spring 初始化线程的锁的顺序不一样，导致了线程死锁，不能提供服务，启动不了。
解决：不要在服务的实现类中使用 applicationContext.getBean(); 如果不想依赖配置顺序，可以将 dubbo:provider 的 deplay 属性设置为 - 1，使 dubbo 在容器初始化完成后再暴露服务。
5) 服务注册不上
检查 dubbo 的 jar 包有没有在 classpath 中，以及有没有重复的 jar 包
检查暴露服务的 spring 配置有没有加载
在服务提供者机器上测试与注册中心的网络是否通
6) 出现 RpcException: No provider available for remote service 异常
表示没有可用的服务提供者，
a. 检查连接的注册中心是否正确
b. 到注册中心查看相应的服务提供者是否存在
c. 检查服务提供者是否正常运行
7) 出现” 消息发送失败” 异常
通常是接口方法的传入传出参数未实现 Serializable 接口。
14、dubbo 和 dubbox 之间的区别？
答：dubbox 是当当网基于 dubbo 上做了一些扩展，如加了服务可 restful 调用，更新了开源组件等。
15、你还了解别的分布式框架吗？
答：别的还有 spring 的 spring cloud，facebook 的 thrift，twitter 的 finagle 等。
16、Dubbo 支持哪些协议，每种协议的应用场景，优缺点？
dubbo：单一长连接和 NIO 异步通讯，适合大并发小数据量的服务调用，以及消费者远大于提供者。传输协议 TCP，异步，Hessian 序列化；
rmi：采用 JDK 标准的 rmi 协议实现，传输参数和返回参数对象需要实现 Serializable 接口，使用 java 标准序列化机制，使用阻塞式短连接，传输数据包大小混合，消费者和提供者个数差不多，可传文件，传输协议 TCP。多个短连接，TCP 协议传输，同步传输，适用常规的远程服务调用和 rmi 互操作。在依赖低版本的 Common-Collections 包，java 序列化存在安全漏洞；
webservice:基于 WebService 的远程调用协议，集成 CXF 实现，提供和原生 WebService 的互操作。多个短连接，基于 HTTP 传输，同步传输，适用系统集成和跨语言调用；http：基于 Http 表单提交的远程调用协议，使用 Spring 的 HttpInvoke 实现。多个短连接，传输协议 HTTP，传入参数大小混合，提供者个数多于消费者，需要给应用程序和浏览器 JS 调用；hessian：集成 Hessian 服务，基于 HTTP 通讯，采用 Servlet 暴露服务，Dubbo 内嵌 Jetty 作为服务器时默认实现，提供与 Hession 服务互操作。多个短连接，同步 HTTP 传输，Hessian 序列化，传入参数较大，提供者大于消费者，提供者压力较大，可传文件；
memcache：基于 memcached 实现的 RPC 协议 redis：基于 redis 实现的 RPC 协议
17、Dubbo 集群的负载均衡有哪些策略
Dubbo 提供了常见的集群策略实现，并预扩展点予以自行实现。
Random LoadBalance: 随机选取提供者策略，有利于动态调整提供者权重。截面碰撞率高，调用次数越多，分布越均匀；
RoundRobin LoadBalance: 轮循选取提供者策略，平均分布，但是存在请求累积的问题；
LeastActive LoadBalance: 最少活跃调用策略，解决慢提供者接收更少的请求；ConstantHash LoadBalance: 一致性 Hash 策略，使相同参数请求总是发到同一提供者，一台机器宕机，可以基于虚拟节点，分摊至其他提供者，避免引起提供者的剧烈变动；
18、服务调用超时问题怎么解决
dubbo在调用服务不成功时，默认是会重试两次的。这样在服务端的处理时间超过了设定的超时时间时，就会有重复请求，比如在发邮件时，可能就会发出多份重复邮件，执行注册请求时，就会插入多条重复的注册数据，那么怎么解决超时问题呢？如下
对于核心的服务中心，去除dubbo超时重试机制，并重新评估设置超时时间。业务处理代码必须放在服务端，客户端只做参数验证和服务调用，不涉及业务流程处理 全局配置实例
当然Dubbo的重试机制其实是非常好的QOS保证，它的路由机制，是会帮你把超时的请求路由到其他机器上，而不是本机尝试，所以 dubbo的重试机器也能一定程度的保证服务的质量。但是请一定要综合线上的访问情况，给出综合的评估。
Dubbo 的容错机制有哪些
Dubbo 官网提出总共有六种容错策略
1） Failover Cluster 模式
失败自动切换，当出现失败，重试其它服务器。 (默认)
2） Failfast Cluster
快速失败，只发起一次调用，失败立即报错。 通常用于非幂等性的写操作，比如新增记录。
3） Failsafe Cluster
失败安全，出现异常时，直接忽略。 通常用于写入审计日志等操作。
4） Failback Cluster
失败自动恢复，后台记录失败请求，定时重发。 通常用于消息通知操作。
5） Forking Cluster
并行调用多个服务器，只要一个成功即返回。 通常用于实时性要求较高的读操作，但需要浪费更多服务资源。
可通过 forks=” 2”来设置最大并行数
6） Broadcast Cluster
广播调用所有提供者，逐个调用，任意一台报错则报错。 (2.1.0 开始支持) 通常用于通知所有提供者更新缓存
或日志等本地资源信息。
总结： 在实际应用中查询语句容错策略建议使用默认 Failover Cluster ，而增删改建议使用 Failfast Cluster 或
者 使用 Failover Cluster（retries=” 0”） 策略 防止出现数据 重复添加等等其它问题！建议在设计接口时候把查询
接口方法单独做一个接口提供查询
使用 dubbo 遇到过哪些问题？
1. 增加提供服务版本号和消费服务版本号
这个具体来说不算是一个问题,而是一种问题的解决方案,在我们的实际工作中会面临各种环境资源短缺的问题,也
是很实际的问题,刚开始我们还可以提供一个服务进行相关的开发和测试,但是当有多个环境多个版本,多个任务的时候
就不满足我们的需求,这时候我们可以通过给提供方增加版本的方式来区分.这样能够剩下很多的物理资源,同时为今后
更换接口定义发布在线时，可不停机发布，使用版本号.
引用只会找相应版本的服务,例如：
<dubbo:serviceinterface=“com.xxx.XxxService” ref=“xxxService” version=“1.0” />
<dubbo:referenceid=“xxxService” interface=“com.xxx.XxxService” version=“1.0” />
2. dubbo reference 注解问题
@Reference 只能在 springbean 实例对应的当前类中使用，暂时无法在父类使用；如果确实要在父类声明一个
引用，可通过配置文件配置 dubbo:reference，然后在需要引用的地方跟引用 springbean 一样就可以了.
3.出现 RpcException: No provider available for remote service 异常，表示没有可用的服务提供者
1). 检查连接的注册中心是否正确
2). 到注册中心查看相应的服务提供者是否存在
3). 检查服务提供者是否正常运行
4. 服务提供者没挂，但在注册中心里看不到
首先，确认服务提供者是否连接了正确的注册中心，不只是检查配置中的注册中心地址，而且要检查实际的网络
连接。
其次，看服务提供者是否非常繁忙，比如压力测试，以至于没有 CPU 片段向注册中心发送心跳，这种情况，减小
压力，将自动恢复。
Dubbo 的连接方式有哪些？
Dubbo 的客户端和服务端有三种连接方式，分别是：广播，直连和使用 zookeeper 注册中心
Dubbo 广播
这种方式是 dubbo 官方入门程序所使用的连接方式，但是这种方式有很多问题。在企业开发中，不使用广播的方
式。
taotao-manager 服务端配置：
<!-- applicationContext-service.xml 文件中 -->
<!-- 提供方应用信息，用于计算机依赖关系 -->
<dubbo:application name=”taotao-manager-service” />
<!-- 使用 multicast 广播暴露服务地址 -->
<dubbo:registry address=”multicast://224.5.6.7:1234” />
<!-- 使用 dubbo 协议在 20880 协议暴露服务 -->
<dubbo:protocol name=”dubbo” port=”20880” />
<!-- 声明需要暴露的服务接口 -->
<dubbo:service interface=”com.taotao.manager.service.TestService” ref=”testServiceImpl” />
</bean>
客户端配置 taotao-manager-web 的配置如下：
<!--springMVC.xml 文件中 -->
<!-- 配置 dubbo 服务 -->
<dubbp:application name=”taotao-manager-web” />
<!-- 使用 multicast 广播暴露服务地址 -->
<dubbo:registry address=”multicast://224.5.6.7:1234” />
<!-- 声明要调用的服务 timeout 是设置连接超时最长时间，如果不设置，默认超时时间为 3 秒 -->
<dubbo:service interface=”com.taotao.manager.service.TestService” id=”testService”
timeout=”10000000” />
</bean>
Dubbo 直连
这种方式在企业中一般在开发中环境中使用，但是生产环境很少使用，因为服务是直接调用，没有使用注册中心，
很难对服务进行管理。 Dubbo 直连，首先要取消广播，然后客户端直接到指定需要的服务的 url 获取服务即可。
服务端配置： taotao-manager 的修改如下，取消广播，注册中心地址为 N/A
<!-- applicationContext-service.xml 文件中 -->
<!-- 提供方应用信息，用于计算机依赖关系 -->
<dubbo:application name=”taotao-manager-service” />
<!-- <dubbo:registry address=”multicast://224.5.6.7:1234” /> -->
<!-- 使用 multicast 广播暴露服务地址 -->
<dubbo:registry address=”N/A” />
<!-- 使用 dubbo 协议在 20880 协议暴露服务 -->
<dubbo:protocol name=”dubbo” port=”20880” />
<!-- 声明需要暴露的服务接口 -->
<dubbo:service interface=”com.taotao.manager.service.TestService” ref=”testServiceImpl” />
</bean>
客户端配置： taotao-manager-web 配置如下，取消广播，从指定的 url 中获取服务
<!--springMVC.xml 文件中 -->
<!-- 配置 dubbo 服务 -->
<dubbp:application name=”taotao-manager-web” />
<!-- 使用 multicast 广播暴露服务地址 -->
<!-- <dubbo:registry address=”multicast://224.5.6.7:1234” /> -->
<!-- 声明要调用的服务 timeout 是设置连接超时最长时间，如果不设置，默认超时时间为 3 秒 -->
<dubbo:service interface=”com.taotao.manager.service.TestService” id=”testService”
timeout=”10000000” />
</bean>
public class A {
public void m() {
if(this instanceof A){
System.out.println("a");
}
if(this instanceof B){
System.out.println("B");
}
}
class B extends A {
public void m() {
super.m();
}
}
public static void main(String[] args) {
A a = new B();
a.m();
}
}
Error:(20, 15) java: 无法从静态上下文中引用非静态 变量 this
权威｜前沿｜技术｜干货｜国内首个API全生命周期开发者社区
更多推荐
1
0- 0
已为社区贡献1条内容
所有评论(0)