木林森屿城

【零散知识点总结1】

大部分知识点来源于该博主——骆昊
知识点来源于网络，知道的可以在评论区贴上来源喔

《零散知识点总结1》
该文章涉及：Dubbo、HTTP和HTTPS、Mybatis、Hibernate、 Zookeeper、Kafka、Elasticsearch、Redis

《零散知识点总结2》
该文章涉及：MySQL、Java并发编程、Java IO 和 NIO、JUnit单元测试

《零散知识点总结3》
该文章涉及：Java Web、sprig的全家桶（spring、SpringMVC、springboot、springcloud）、微服务

《零散知识点总结4》
该文章涉及：JVM和GC、Linux、Git、RabbitMQ

《零散知识点总结5》
该文章涉及：多线程、反射、对象拷贝、异常、容器

零散知识点总结1

Dubbo
- Dubbo 的整体架构设计有哪些分层?
- 服务注册与发现的流程图
- dubbo容错方案
- Dubbo 支持服务降级吗？失败重试怎么做？
- Dubbo 配置文件是如何加载到 Spring 中的？
- Dubbo 支持分布式事务吗？
- Dubbo 如何优雅停机？
- Dubbo 和 Dubbox 之间的区别？
- Dubbo 和 Spring Cloud 的区别？
- Double、decimal和float的区别？
HTTP和HTTPS
- TCP和 UDP的区别，TCP为什么是三次握手？
- OSI 的七层模型都有哪些？
- http 和RPC 的区别
- - 什么是RPC？
vue.js跟thymeleaf 的区别
Mybatis
- mybatis-config.xml和 mapper.xml
- MyBatis 框架适用场合
- #{}和${}的区别是什么？
- 当实体类中的属性名和表中的字段名不一样，怎么办？
- 模糊查询 like 语句该怎么写?
- MyBatis动态sql有什么用？执行原理？有哪些动态sql？
- Mybatis 的 Xml 映射文件中，不同的 Xml 映射文件，id 是否可以重复？
- MyBatis实现一对一和一对多分别有几种方式，具体是怎么操作的？
- Mybatis之association和collection
- Mybatis是如何进行分页的？分页插件的原理是什么？有几种分页方式？
- RowBounds 是一次性查询全部结果吗？为什么？
- Mybatis是如何将sql执行结果封装为目标对象并返回的？都有哪些映射形式？
- 如何执行批量插入?
- 如何获取自动生成的(主)键值?
- 在 mapper 中如何传递多个参数?
- Mybatis 是否支持延迟加载？如果支持，它的实现原理是什么？
- Mybatis 的一级、二级缓存以及缓存失效的情况
- 什么是 MyBatis 的接口绑定？有哪些实现方式？
- 使用 MyBatis 的 mapper 接口调用时有哪些要求？
- Mapper 编写有哪几种方式？
- 简述 Mybatis 的插件运行原理，以及如何编写一个插件。
- MyBatis 有哪些执行器（Executor）？
- MyBatis 与 Hibernate 有哪些不同？
Hibernate
- 为什么要用hibernate？
- hibernate 中如何在控制台查看打印的 SQL 语句？
- hibernate 实体类可以被定义为 final 吗？
- 在 hibernate 中使用 Integer 和 int 做映射有什么区别？
- hibernate 是如何工作的？
- - get()和 load()的区别？
- 说一下 hibernate 的缓存机制？
- 在 hibernate 中 getCurrentSession 和 openSession 的区别是什么？
- hibernate 实体类必须要有无参构造函数吗？为什么？
Kafka 和 Zookeeper
- Zookeeper
- - 什么是zookeeper ？
  - zookeeper 文件系统
  - zookeeper 都有哪些功能？
  - zookeeper 有几种部署模式？
  - zookeeper 怎么保证主从节点的状态同步？
  - 集群中为什么要有主节点？
  - 集群中有 3 台服务器，其中一个节点宕机，这个时候 zookeeper 还可以使用吗？
  - 说一下 zookeeper 的通知机制？
  - 服务器角色
  - ZAB 协议？
  - Zookeeper 下 Server 工作状态
  - 数据同步
  - zookeeper 是如何保证事务的顺序一致性的？
  - 四种类型的数据节点 Znode
  - Zookeeper Watcher 机制 -- 数据变更通知
  - ACL 权限控制机制
  - 分布式集群中为什么会有 Master？
  - zk 节点宕机如何处理？
  - zookeeper 负载均衡和 nginx 负载均衡区别
  - Zookeeper 对节点的 watch监听通知是永久的吗？为什么不是永久的?
  - 基于 Zookeeper 的实现方式
  - 负载均衡
  - - zookeeper 的命名服务
    - 分布式通知和协调
    - zk 的命名服务（文件系统）
    - zk 的配置管理（文件系统、通知机制）
    - Zookeeper 集群管理（文件系统、通知机制）
    - Zookeeper 分布式锁（文件系统、通知机制）
    - Zookeeper 队列管理（文件系统、通知机制）
  - CAP 原则和ACID原则
  - zookeeper和dubbo的关系？
  - Zookeeper 和 Eureka的区别
  - Nacos 和 Zookeeper 的区别
- Kafka
- - 生产者和消费者的命令行是什么？
  - consumer 是推还是拉？
  - 讲讲 kafka 维护消费状态跟踪的方法
  - 讲一下主从同步
  - 为什么需要消息系统，mysql 不能满足需求吗？
  - Zookeeper 对于 Kafka 的作用是什么？
  - 数据传输的事务定义有哪三种？
  - Kafka 判断一个节点是否还活着有那两个条件？
  - Kafka 与传统 MQ 消息系统之间有三个关键区别
  - 讲一讲 kafka 的 ack 的三种机制
  - 消费者如何不自动提交偏移量，由应用提交？
  - 消费者故障，出现活锁问题如何解决？
  - 如何控制消费的位置
  - kafka 分布式（不是单机）的情况下，如何保证消息的顺序消费?
  - kafka 的高可用机制是什么？
  - kafka 如何减少数据丢失
  - kafka 如何不消费重复数据？比如扣款，我们不能重复的扣。
  - kafka 可以脱离 zookeeper 单独使用吗？为什么？
  - kafka 有几种数据保留的策略？
  - kafka 同时设置了 7 天和 10G 清除数据，到第五天的时候消息达到了 10G，这个时候 kafka 将如何处理？
  - 什么情况会导致 kafka 运行变慢？
  - 使用 kafka 集群需要注意什么？
- Elasticsearch
- - 说说ES的集群架构，索引数据大小，分片有多少，以及一些调优手段
  - elasticsearch 是如何实现master选举的
  - Elasticsearch 在部署时，对 Linux 的设置有哪些优化方法
  - Elasticsearch 中的节点（比如共 20 个），其中的 10 个选了一个 master，另外 10 个选了另一个 master，怎么办？
  - 详细描述一下 Elasticsearch 更新和删除文档的过程。
  - 详细描述一下 Elasticsearch 搜索的过程。
  - 在并发情况下，Elasticsearch 如果保证读写一致？
Redis
- 什么是redis? Redis 最适合的场景？ Redis 有哪些功能？
- 使用 Redis 有哪些好处？Redis 为什么是单线程的？ Redis 的数据类型？
- redis 与 memcached 的区别？
- Redis 的持久化机制是什么？(RDB 和 AOF )各自的优缺点是？
- redis 过期键的删除策略？
- Redis 内存、Redis 的同步机制了解么？
- Redis 集群
- Redis 支持的 Java 客户端都有哪些？官方推荐用哪个？
- Jedis 与 Redisson 对比有什么优缺点？
- Redis 如何设置密码及验证密码？
- 说说 Redis 哈希槽的概念？
- Redis 集群的主从复制模型是怎样的？
- Redis 集群会有写操作丢失吗？为什么？
- Redis 集群之间是如何复制的？集群最大节点数是？
- Redis 集群如何选择数据库？
- 怎么保证缓存和数据库数据的一致性？
- 怎么测试 Redis 的连通性？
- 怎么理解 Redis 事务？
- Redis 事务相关的命令有哪几个？
- Redis key 的过期时间和永久有效分别怎么设置？
- Redis 回收进程如何工作的？
- MySQL 里有 2000w 数据，redis 中只存 20w 的数据，如何保证 redis 中的数据都是热点数据？
- 假如 Redis 里面有 1 亿个 key，其中有 10w 个 key 是以某个固定的已知的前缀开头的，如何将它们全部找出来？
- 使用过 Redis 分布式锁么，它是什么回事？
- Redis 怎么实现分布式锁？
- Redis 分布式锁有什么缺陷？
- 什么是缓存穿透？怎么解决？
- Redis 常见的性能问题有哪些？该如何解决？
- redis和MQ如何平滑的扩容与缩容？
- Redis 中的常用命令哪些？

Dubbo

Dobbo:阿里巴巴公司开源的一个高性能优秀的(分布式)服务框架，使得应用可通过高性能的 RPC 实现服务的输出和输入功能，可以和 [1] Spring框架无缝集成。
三大核心能力：
面向接口的远程方法调用，（RPC：远程过程调用）
智能容错和负载均衡，
以及服务自动注册和发现。

Dubbo提供的注册中心有如下几种类型可供选择：
    Multicast注册中心
    Zookeeper注册中心（推荐）
    Redis注册中心（缓存推荐）
    Simple注册中心

Dubbo优缺点
优点：
1.透明化的远程方法调用- 像调用本地方法一样调用远程方法；只需简单配置，没有任何API侵入。
2.软负载均衡及容错机制-可在内网替代nginx lvs等硬件负载均衡器。
3.服务注册中心自动注册 & 配置管理-不需要写死服务提供者地址，注册中心基于接口名自动查询提供者ip。
使用类似zookeeper等分布式协调服务作为服务注册中心，可以将绝大部分项目配置移入zookeeper集群。
4.服务接口监控与治理-Dubbo-admin与Dubbo-monitor提供了完善的服务接口管理与监控功能，针对不同应用的不同接口，可以进行多版本，多协议，多注册中心管理。

缺点：只支持JAVA语言

Zookeeper是一个分布式的服务框架，是树型的目录服务的数据存储，能做到集群管理数据，这里能很好的作为Dubbo服务的注册中心。
Dubbo能与Zookeeper做到集群部署，当提供者出现断电等异常停机时，Zookeeper注册中心能自动删除提供者信息，
当提供者重启时，能自动恢复注册数据，以及订阅请求。

Dubbo 的整体架构设计有哪些分层?

接口服务层（Service）：该层与业务逻辑相关，根据 provider （服务提供者）和 consumer （服务消费者）的业务设计对应的接口和实现
配置层（Config）：对外配置接口，以 ServiceConfig 和 ReferenceConfig 为中心
服务代理层（Proxy）：服务接口透明代理，生成服务的客户端 Stub 和服务端的 Skeleton，以 ServiceProxy 为中心，扩展接口为ProxyFactory
服务注册层（Registry）：封装服务地址的注册和发现，以服务 URL 为中心，扩展接口为 RegistryFactory、Registry、RegistryService
路由层（Cluster）：封装多个提供者的路由和负载均衡，并桥接注册中心，以Invoker 为中心，扩展接口为 Cluster、Directory、Router 和 LoadBlancce
监控层（Monitor）：RPC 调用次数和调用时间监控，以 Statistics 为中心，扩展接口为 MonitorFactory、Monitor 和 MonitorService
远程调用层（Protocal）：封装 RPC 调用，以 Invocation 和 Result 为中心，扩展接口为 Protocal、Invoker 和 Exporter
信息交换层（Exchange）：封装请求响应模式，同步转异步。以 Request 和Response 为中心，扩展接口为 Exchanger、ExchangeChannel、ExchangeClient 和 ExchangeServer
网络传输层（Transport）：抽象 mina 和 netty 为统一接口，以 Message 为中心，扩展接口为 Channel、Transporter、Client、Server 和 Codec
数据序列化层（Serialize）：可复用的一些工具，扩展接口为 Serialization、ObjectInput、ObjectOutput 和 ThreadPool

默认使用的是什么通信框架，还有别的选择吗？

默认推荐使用netty 框架，还有 mina

服务调用是阻塞的吗？

默认是阻塞的，可以异步调用，没有返回值的可以这么做。Dubbo 是基于 NIO 的非阻塞实现并行调用，客户端不需要启动多线程即可完成
并行调用多个远程服务，相对多线程开销较小，异步调用会返回一个 Future 对象。

一般使用什么注册中心？还有别的选择吗？

推荐使用 Zookeeper 作为注册中心，还有 Redis、Multicast、Simple 注册中心，但不推荐。

默认使用什么序列化框架，你知道的还有哪些？

推荐使用 Hessian 序列化，还有 Duddo、FastJson、Java 自带序列化。

服务提供者能实现失效踢出是什么原理？

服务失效踢出基于 zookeeper 的临时节点原理。

服务上线怎么不影响旧版本？

采用多版本开发，不影响旧版本。

服务上线怎么兼容旧版本？

可以用版本号（version）过渡，多个不同版本的服务注册到注册中心，版本号不同的服务相互间不引用。这个和服务分组的概念有一点类似。

如何解决服务调用链过长的问题？

可以结合 zipkin 实现分布式服务追踪。

说说核心的配置有哪些？

配置	配置说明
dubbo:service	服务配置
dubbo:reference	引用配置
dubbo:protocol	协议配置
dubbo:application	应用配置
dubbo:module	模块配置
dubbo:registry	注册中心配置
dubbo:monitor	监控中心配置
dubbo:provider	提供方配置
dubbo:consumer	消费方配置
dubbo:method	方法配置
dubbo:argument	参数配置

dubbo推荐用什么协议？

dubbo://（推荐）、 rmi://、 hessian://、 http://、 webservice://、 thrift://、 memcached://、 redis://、rest://

同一个服务多个注册的情况下可以直连某一个服务吗？

可以点对点直连，修改配置即可，也可以通过 telnet 直接某个服务。

服务注册与发现的流程图

dubbo容错方案

集群容错方案	说明
Failover Cluster	失败自动切换，自动重试其它服务器（默认）
Failfast Cluster	快速失败，立即报错，只发起一次调用
Failsafe Cluster	失败安全，出现异常时，直接忽略
Failback Cluster	失败自动恢复，记录失败请求，定时重发
Forking Cluster	并行调用多个服务器，只要一个成功即返回
Broadcast Cluster	广播逐个调用所有提供者，任意一个报错则报错

Dubbo 支持服务降级吗？失败重试怎么做？

可以通过 dubbo:reference 中设置 mock="return null"。mock 的值也可以修改为 true，然后再跟接口同一个路径下实现一个 Mock 类，命名规则是 “接口名称+Mock” 后缀。然后在 Mock 类里实现自己的降级逻辑

Dubbo 使用过程中都遇到了些什么问题？

在注册中心找不到对应的服务,检查 service 实现类是否添加了@service 注解无法连接到注册中心,检查配置文件中的对应的测试 ip 是否正确

Dubbo 配置文件是如何加载到 Spring 中的？

Spring 容器在启动的时候，会读取到 Spring 默认的一些 schema 以及 Dubbo 自定义的 schema，每个 schema 都会对应一个自己的 NamespaceHandler，NamespaceHandler 里面通过 BeanDefinitionParser 来解析配置信息并转化为需要加载的 bean 对象！

Dubbo 支持分布式事务吗？

目前暂时不支持，可与通过 tcc-transaction 框架实现，介绍：tcc-transaction 是开源的 TCC 补偿性分布式事务框架
Git 地址
TCC-Transaction 通过 Dubbo 隐式传参的功能，避免自己对业务代码的入侵。

Dubbo 可以对结果进行缓存吗？

可以（声明式缓存，提高数据访问速度，减少用户加缓存的工作量）

其实比普通的配置文件就多了一个标签 cache="true

Dubbo 必须依赖的包有哪些？

Dubbo 必须依赖 JDK，其他为可选。

Dubbo telnet 命令能做什么？

dubbo 服务发布之后，我们可以利用 telnet 命令进行调试、管理。Dubbo2.0.5 以上版本服务提供端口支持 telnet 命令

连接服务：telnet localhost 20880 //键入回车进入 Dubbo 命令模式。

查看服务列表

dubbo>ls
com.test.TestService
dubbo>ls com.test.TestService
create
delete
query

ls (list services and methods)
ls : 显示服务列表。
ls -l : 显示服务详细信息列表。
ls XxxService：显示服务的方法列表。
ls -l XxxService：显示服务的方法详细信息列表

Dubbo 如何优雅停机？

Dubbo 是通过 JDK 的 ShutdownHook 来完成优雅停机的，所以如果使用kill -9 PID 等强制关闭指令，是不会执行优雅停机的，只有通过 kill PID 时，才会执行。

Dubbo 和 Dubbox 之间的区别？

Dubbox 是继 Dubbo 停止维护后，当当网基于 Dubbo 做的一个扩展项目，如加了服务可 Restful 调用，更新了开源组件等。

两者之间本质上没什么区别，因为dubbox是dubbo扩展出来的，扩展以下的功能：

支持REST风格远程调用（HTTP + JSON/XML)；
支持基于Kryo和FST的Java高效序列化实现；
支持基于Jackson的JSON序列化；
支持基于嵌入式Tomcat的HTTP remoting体系；
升级Spring至3.x；
升级ZooKeeper客户端；
支持完全基于Java代码的Dubbo配置；

Dubbo 和 Spring Cloud 的区别？

根据微服务架构在各方面的要素，看看 Spring Cloud 和 Dubbo 都提供了哪些支持。

	Dubbo	Spring Cloud
服务注册中心	Zookeeper	Spring Cloud Netflix Eureka
服务调用方式	RPC	REST API
服务网关	无	Spring Cloud Netflix Zuul
断路器	不完善	Spring Cloud Netflix Hystrix
分布式配置	无	Spring Cloud Config
服务跟踪	无	Spring Cloud Sleuth
消息总线	无	Spring Cloud Bus
数据流	无	Spring Cloud Stream
批量任务	无	Spring Cloud Task
……	……	……

使用 Dubbo 构建的微服务架构就像组装电脑，各环节我们的选择自由度很高，但是最终结果很有可能因为一条内存质量不行就点不亮了，总是让人不怎么放心，但是如果你是一名高手，那这些都不是问题；

而 Spring Cloud 就像品牌机，在Spring Source 的整合下，做了大量的兼容性测试，保证了机器拥有更高的稳定性，但是如果要在使用非原装组件外的东西，就需要对其基础有足够的了解

你还了解别的分布式框架吗？
别的还有 spring 的 spring cloud，facebook 的 thrift，twitter 的 finagle 等

Double、decimal和float的区别？

Double、decimal和float都可以表示小数，float是单精度，double是双精度，decimal是数字型，它们所占的内存空间不一样，表示的位数也不一样。

在精度上，double比float精确，但是依然会存在精度损失的问题，且不会报任何错误和异常；在占内存和处理速度上，float要快得多，因此如果涉及到小数计算的话，我们会建议用decimal型

总而言之，自己看情况来使用吧

HTTP和HTTPS

跨域：协议、域名（子/主）端口号任意一个不同，相互请求资源都可以称为跨域。
域名地址组成----例如： http://www.abc.com:8080/scripts/jquery.js

http://(协议);
www(子域名);
abc.com(主域名);
8080(端口号);
scripts/jquery.js(请求资源地址);

HTTP：是互联网上应用最为广泛的一种网络协议，是一个客户端和服务器端请求和应答的标准（TCP），用于从WWW服务器传输超文本到本地浏览器的传输协议，它可以使浏览器更加高效，使网络传输减少。(最广泛、明文传输安全性较差、端口80)
HTTPS：是以安全为目标的HTTP通道，简单讲是HTTP的安全版，即HTTP下加入SSL层，HTTPS的安全基础是SSL，因此加密的详细内容就需要SSL。（要到ca申请证书，一般免费证书较少，因而需要一定费用、是由http+SSL加密传输的，身份认证的网络协议，安全性较高、端口443）

HTTPS协议的主要作用可以分为两种：一种是建立一个信息安全通道，来保证数据传输的安全；另一种就是确认网站的真实性。

TCP和 UDP的区别，TCP为什么是三次握手？

TCP和 UDP的区别:TCP是双工协议，比UDP更可靠，效率也更高；

tcp（传输控制协议）和 udp （用户数据报协议）是 OSI（开放式系统互联参考模型）模型中的运输层中的协议。tcp 提供可靠的通信传输，而 udp 则常被用于让广播和细节控制交给应用的通信传输。

两者的区别大致如下：

tcp 面向连接，udp 面向非连接即发送数据前不需要建立链接；
tcp 提供可靠的服务（数据传输），udp 无法保证；
tcp 面向字节流，udp 面向报文；
tcp 数据传输慢，udp 数据传输快；

TCP为什么是三次握手：为了保证服务端能收接受到客户端的信息并能做出正确的应答而进行前两次握手，为了保证客户端能够接收到服务端的信息并能做出正确的应答而进行后两次握手。详细的三次握手

TCP为什么不可以两次握手?
如果采用两次握手，那么只要服务器发出确认数据包就会建立连接，但由于客户端此时并未响应服务器端的请求，那此时服务器端就会一直在等待客户端，这样服务器端就白白浪费了一定的资源。若采用三次握手，服务器端没有收到来自客户端的再此确认，则就会知道客户端并没有要求建立请求，就不会浪费服务器的资源。

说一下 tcp 粘包是怎么产生的？
tcp 粘包可能发生在发送端或者接收端，分别来看两端各种产生粘包的原因：

发送端粘包：发送端需要等缓冲区满才发送出去，造成粘包；
接收方粘包：接收方不及时接收缓冲区的包，造成多个包接收。

OSI 的七层模型都有哪些？

物理层：利用传输介质为数据链路层提供物理连接，实现比特流的透明传输。
数据链路层：负责建立和管理节点间的链路。
网络层：通过路由选择算法，为报文或分组通过通信子网选择最适当的路径。
传输层：向用户提供可靠的端到端的差错和流量控制，保证报文的正确传输。
会话层：向两个实体的表示层提供建立和使用连接的方法。
表示层：处理用户信息的表示问题，如编码、数据格式转换和加密解密等。
应用层：直接向用户提供服务，完成用户希望在网络上完成的各种工作。

http 和RPC 的区别

什么是RPC？

RPC两大核心：通讯，序列化
什么是RPC，推荐阅读 https://www.jianshu.com/p/2accc2840a1b

http 和RPC 都是很常见的服务远程调用的方式，那么它们之间有什么区别呢?
https://www.cnblogs.com/helloworldmybokeyuan/p/11626833.html

RPC：Remote Produce Call远程过程调用，类似的还有RMI（Remote Methods Invoke 远程方法调用，是JAVA中的概念，是JAVA十三大技术之一）。自定义数据格式，基于原生TCP通信，速度快，效率高。早期的webservice，现在热门的dubbo，都是RPC的典型
RPC的框架：webservie(cxf)、dubbo
RMI的框架：hessian
Http：（前面也有提到）http其实是一种网络传输协议，基于TCP，规定了数据传输的格式。现在客户端浏览器与服务端通信基本都是采用Http协议。也可以用来进行远程服务调用。缺点是消息封装臃肿。
现在热门的Rest风格，就可以通过http协议来实现。
http的实现技术：HttpClient

相同点：底层通讯都是基于socket，都可以实现远程调用，都可以实现服务调用服务

不同点：

RPC：框架有：dubbo、cxf、（RMI远程方法调用）Hessian
当使用RPC框架实现服务间调用的时候，要求服务提供方和服务消费方都必须使用统一的RPC框架，要么都dubbo，要么都cxf
跨操作系统在同一编程语言内使用
优势：调用快、处理快
http：框架有：httpClient
当使用http进行服务间调用的时候，无需关注服务提供方使用的编程语言，也无需关注服务消费方使用的编程语言，服务提供方只需要提供restful风格的接口，服务消费方，按照restful的原则，请求服务，即可
跨系统跨编程语言的远程调用框架
优势：通用性强

总结：对比RPC和http的区别

1 RPC要求服务提供方和服务调用方都需要使用相同的技术，要么都hessian，要么dubbo而http无需关注语言的实现，只需要遵循rest规范
2 RPC的开发要求较多，像Hessian框架还需要服务器提供完整的接口代码(包名.类名.方法名必须完全一致)，否则客户端无法运行
3 Hessian只支持POST请求
4 Hessian只支持JAVA语言

vue.js跟thymeleaf 的区别

首先说，这两种技术在本质上属于不同类型的产品。Vue.js属于前端框架，thymeleaf属于模板引擎。
虽然它们可以实现相同的功能(如列表)，但它们的工作流程是不同的:vue.Js通过异步请求数据，后端向前端返回json，
前端通过列表呈现vue指令循环。Thymeleaf是在后端实现页面的渲染，将页面直接呈现给浏览器显示。
一般来说，后台管理我们会使用前端框架，而网站前台的部分有些页面会用thymeleaf。
有两个原因:
   (1) 因为使用vuejs进行异步请求，打开页面看到的信息显示会出现延迟，而使用thymeleaf，页面的信息就会很快看到。
   (2)异步加载数据不会被搜索引擎抓取。所以当我们希望数据被搜索引擎收录，就需要使用thymeleaf这样的模板引擎。

Mybatis

Mybatis学习：
	认识mybatis：持久化
	第一个mybatis程序
	CRUD
	mybatis 配置文件XML介绍
	ResultMap：结果集映射【重点】:
		一对多
		多对一
	log4j
	分页
	注解开发
	动态SQL
	缓存【重点】：
		一级缓存（本地缓存——默认开启）一次会话有效
		二级缓存 （全局缓存）首先请求的是二级，没有二级缓存才会请求一级缓存，还没有就去数据库
		缓存失效有四种情况：
			1.请求的内容不同
			2.进行了新增、修改和删除 操作
			3.查询不同的Mapper.xml
			4. 手动清理缓存 sqlSession.clearCache();

生命周期和作用域：

生命周期，和作用域，是至关重要的，因为错误的使用会导致非常严重的并发问题。

为什么说Mybatis是半自动ORM映射工具？它与全自动的区别在哪里？

Hibernate属于全自动ORM映射工具，使用Hibernate查询关联对象或者关联集合对象时，可以根据对象关系模型直接获取，所以它是全自动的。而Mybatis在查询关联对象或关联集合对象时，需要手动编写sql来完成，所以，称之为半自动ORM映射工具

什么是 Mybatis？

Mybatis 是一个半 ORM（Object relational mapping对象关系映射）框架，它内部封装了 JDBC，开发时只需要关注 SQL 语句本身，不需要花费精力去处理加载驱动、创建连接、创建statement （声明）等繁杂的过程。程序员直接编写原生态 sql，可以严格控制 sql 执行性能，灵活度高。
MyBatis 可以使用 XML 或注解来配置和映射原生信息，将 POJO 映射成数据库中的记录，避免了几乎所有的 JDBC 代码和手动设置参数以及获取结果集。
通过 xml 文件或注解的方式将要执行的各种 statement 配置起来，并通过java 对象和 statement 中 sql 的动态参数进行映射生成最终执行的 sql 语句，最后由 mybatis 框架执行 sql 并将结果映射为 java 对象并返回。（从执行 sql 到返回 result 的过程）。

Mybaits 的优点：

详细回答：

基于 SQL 语句编程，相当灵活，不会对应用程序或者数据库的现有设计造成任何影响，SQL 写在 XML 里，解除 sql 与程序代码的耦合，便于统一管理；提供 XML标签，支持编写动态 SQL 语句，并可重用
与 JDBC 相比，减少了 50%以上的代码量，消除了 JDBC 大量冗余的代码，不需要手动开关连接
很好的与各种数据库兼容（因为 MyBatis 使用 JDBC 来连接数据库，所以只要JDBC 支持的数据库 MyBatis 都支持）
能够与 Spring 很好的集成；
提供映射标签，支持对象与数据库的 ORM 字段关系映射；提供对象关系映射标签，支持对象关系组件维护。

粗略回答：

与JDBC相比，减少了50%以上的代码量；
MyBatis是最简单的持久化框架，小巧并且简单易学；
MyBatis相当灵活，不会对应用程序或者数据库的现有设计强加任何影响，SQL写在XML里，从程序代码中彻底分离，降低耦合度，便于统一管理和优化，并可重用；
提供XML标签，支持编写动态SQL语句；
提供映射标签，支持对象与数据库的ORM字段关系映射。

MyBatis 框架的缺点：

SQL 语句的编写工作量较大，尤其当字段多、关联表多时，对开发人员编写SQL 语句的功底有一定要求。
SQL 语句依赖于数据库，导致数据库移植性差，不能随意更换数据库。

mybatis-config.xml和 mapper.xml

mybatis核心配置文件： mybatis-config.xml

注意！！！！在 configuration 里面的标签有顺序的限制排序如下：

properties、settings、typeAliases、typeHandlers、objectFactory、objectWrapperFactory、
reflectorFactory、plugins、environments、databaseIdProvider、mappers

properties：属性（引入外部配置文件）
写法1：
写法2：

<properties resource="db.properties">
	<!--这里面的等同于 db.properties里面的 username=root  pwd=123456 优先级1-->
    <property name="username" value="root"/>
    <property name="pwd" value="123456"/>  优先级1
</properties>

settings：全局配置参数（日志格式、动驼峰命名规则、开启二级缓存）

 <settings>
     <!-- 配置日志格式 （标准日志格式：STDOUT_LOGGING） -->
     <setting name="logImpl" value="STDOUT_LOGGING"/>
     <!--是否开启自动驼峰命名规则 camel case 映射   -->
     <setting name="mapUnderscoreToCamelCase" value="true"/>
     <!-- 二级缓存第一步：   显示的开启全局缓存-->
     <setting name="cacheEnabled" value="true"/>
 </settings>

typeAliases：给实体类起别名，一般默认别名为类名的小写：也就是 user

<typeAliases>
    <typeAlias type="com.hh.pojo.User" alias="User"/> <!-- 实体类比较少的时候，使用。 （可以DIY别名）-->
   <!-- <package name="com.hh.pojo"/>-->  <!--直接扫描整个实体类包，实体类十分多的时候使用，如果想要DIY别名可以在实体上增加注解 @Alias("hello")-->
</typeAliases>

typeHandlers：类型处理器：作用就是承担jdbcType和javaType之间的相互转换

 <!--普通注册方式 -->
<typeHandlers>
 	<typeHandler javaType="String" jdbcType="NVARCHAR" handler="priv.dengjl.ns.handler.MyStringHandler" />
 </typeHandlers>
 
 <!--包方式   包方式需要显示在java类注类型：@MappedJdbcTypes(JdbcType.NVARCHAR)  @MappedTypes(String.class)-->
 <typeHandlers>
   <package name="org.mybatis.example"/>
 </typeHandlers>

objectFactory：对象工厂
objectWrapperFactory：对象加工工厂
reflectorFactory：反射工厂

plugins：插件

<plugins>
 	<plugin interceptor="org.mybatis.example.ExamplePlugin">
     <property name="someProperty" value="100"/>
   </plugin>
 </plugins>

environments：环境集合属性对象
（ MyBatis 可以配置成适应多种环境,不过要记住：尽管可以配置多个环境，但每个 SqlSessionFactory 实例只能选择一种环境。 default=“development” 可以决定使用哪一个环境）

<environments default="development"><!--development：开发环境 -->
  <!--environment：环境子属性对象 -->
   <environment id="development">
       <!--事务管理器:transactionManager -->
       <transactionManager type="JDBC"/>
       <!-- 数据源:dataSource -->
       <dataSource type="POOLED">
           <property name="driver" value="${driver}"/>
           <property name="url" value="${url}"/>
           <property name="username" value="${username}"/>
           <property name="password" value="${password}"/>  <!-- ${pwd}-->
       </dataSource>
   </environment>

   <environment id="test"><!--test：测试环境 -->
       <transactionManager type="JDBC"/>
       <dataSource type="POOLED">
           <property name="driver" value="com.mysql.jdbc.Driver"/>
           <property name="url"
                     value="jdbc:mysql://localhost:3306/hhmybatis?useSSL=true&useUnicode=true&characterEncoding=UTF-8"/>
           <property name="username" value="root"/>
           <property name="password" value="123456"/>
       </dataSource>
   </environment>
</environments>

databaseIdProvider：多数据库支持（数据库厂商标识）

<databaseIdProvider type="DB_VENDOR">
 	<property name="SQL Server" value="sqlserver" />
    <property name="MySQL" value="mysql" />
    <property name="DB2" value="db2" />
    <property name="Oracle" value="oracle" />
</databaseIdProvider>

mappers：映射器（注册mapper.xml文件）

<mappers>
    <mapper resource="com/hh/dao/UserMapper.xml"/>
    <mapper class="com.hh.dao.BlogMapper"/>
</mappers>

mapper.xml

parameterType：参数数据类型
UserDao:

public User getById(int id);//基本数据类型   通过id查找User
public User getByName(String name);//string类型  通过name查询User
public User getById2(Integer id);//包装类  通过id查找User
public User getByNameAge(int id,String name);//多个参数   通过name和age查询User
public User getByUser(User user);//POJO   根据Usesr封装对象查询User

UserMapper.xml：

<mapper>
    <select id="getById" parameterType="int" resultType="com.hh.pojo.User">
         SELECT * FROM t_user WHERE id=#{id}
     </select>

     <select id="getByName" parameterType="java.lang.String" resultType="com.hh.pojo.User">
            select * from t_user where name = #{name}
     </select>

     <select id="getById2" parameterType="java.lang.Integer" resultType="com.hh.pojo.User">
            select * from t_user where id=#{id}
     </select>

     <!--两个参数分别是String类型和int类型，类型不一致，所以此时parameterType可以省略，通过参数下标取出参数值-->
     <select id="getByNameAge" resultType="com.hh.pojo.User">
            select * from t_user where name = #{0} and age = #{1}
     </select>

     <!--很显然，当有多个参数时，一个一个写太麻烦了，这时候我们可以将参数列表进行封装，将封装对象作为parameterType的值-->
     <select id="getByUser" parameterType="com.hh.pojo.User" resultType="com.hh.pojo.User">
            select * from t_user where name = #{name} and age = #{age}
     </select>
</mapper>

resultType：结果类型
UserDao:

public int getCount();// 基本数据类型，统计User总数。
public Integer getCount2();// 包装类，统计User总数。
public String getNameById(int id);//String类型，根据id查询User的name值。

UserMapper.xml：

<mapper>
   <select id="getCount" resultType="int">
          select count(*) from t_user
   </select>

   <select id="getCount2" resultType="java.lang.Integer">
          select count(*) from t_user
   </select>

   <select id="getNameById" parameterType="int" resultType="java.lang.String">
          select name from user where id = #{name}
   </select>
   
</mapper>

MyBatis 框架适用场合

MyBatis 专注于 SQL 本身，是一个足够灵活的 DAO 层解决方案。对性能的要求很高，或者需求变化较多的项目，如互联网项目，MyBatis 将是不错的选择。

#{}和${}的区别是什么？

#{}是预编译处理，$ {}是字符串替换。
Mybatis 在处理#{}时，会将 sql 中的#{}替换为?号，调用 PreparedStatement(预声明) 的set 方法来赋值；
Mybatis 在处理$ {}时，就是把${}替换成变量的值。使用#{}可以有效的防止 SQL 注入，提高系统安全性。

当实体类中的属性名和表中的字段名不一样，怎么办？

1.通过在xml里面的sql 查询语句中定义字段的别名，别名跟实体类的属性名一致
config.xml文件【typeAliases：给实体类起别名，一般默认别名为类名的小写：也就是 user】

<typeAliases>
  <typeAlias type="com.hh.pojo.User" alias="User"/> 
</typeAliases>

mapper.xml

<mapper>
    <select id="getById" parameterType="int" resultType="com.hh.pojo.User">
        SELECT * FROM t_user WHERE id=#{id}
    </select>
</mapper>

2.通过来映射字段名和实体类属性名的一一对应的关系

<resultMap id="TeacherStudent" type="Teacher">
	<!--
	 property：实体类字段；column：对应数据库的字段
	 用id 属性来映射主键字段；用 result 属性来映射非主键字段
	  
	 复杂的属性，我们需要单独处理 【对象：association ；集合：collection】
	   javaType="" 指定属性的类型！    集合中的泛型信息，我们使用ofType获取
	-->
   <id property="id" column="tid"/>
   <result property="name" column="tname"/>
   <collection property="students" ofType="Student">
       <result property="id" column="sid"/>
       <result property="name" column="sname"/>
       <result property="tid" column="tid"/>
   </collection>
</resultMap>

模糊查询 like 语句该怎么写?

1.在 Java 代码中添加 sql 通配符。

string wildcardname = “%smi%”;
list<name> names = mapper.selectlike(wildcardname);

<select id=”selectlike”>
	select * from foo where bar like #{value}
</select>

2.在 sql 语句中拼接通配符，会引起 sql 注入

string wildcardname = “smi”;
list<name> names = mapper.selectlike(wildcardname);

<select id=”selectlike”>
	select * from foo where bar like "%"#{value}"%"
</select>

MyBatis动态sql有什么用？执行原理？有哪些动态sql？

Mybatis动态sql可以在Xml映射文件内，以标签的形式编写动态sql，执行原理是根据表达式的值完成逻辑判断并动态拼接sql的功能。
动态SQL的9个标签：if、choose、when、otherwise、trim、where、set、foreach（collection/open/close/item/sperator/index）、bind

Xml映射文件中，除了常见的select|insert|updae|delete标签之外，还有哪些标签？

、、、、，加上动态sql的9个标签，其中为sql片段标签，通过标签引入sql片段，为不支持自增的主键生成策略标签。

通常一个 Xml 映射文件，都会写一个 Dao 接口与之对应，请问，这个 Dao 接口的工作原理是什么？Dao接口里的方法，参数不同时，方法能重载吗？

Dao 接口即 Mapper 接口。比如有些人喜欢写UserDao ，有些人喜欢写UserMapper，不管是怎么写，它对应的XML映射文件一般就是写成UserMapper.xml

接口的全限名，就是映射文件中的 namespace 的值；
接口的方法名，就是映射文件中 Mapper 的 Statement 的 id 值；
接口方法内的参数，就是传递给 sql 的参数。

Mapper 接口是没有实现类的，当调用接口方法时，接口全限名+方法名拼接字符串作为 key 值，可唯一定位一个 MapperStatement。在 Mybatis 中，每一个