----------------------- Page 1-----------------------
目录
面试题目考点.............................................................................................................................................................................................................................................................1
一、 基础问题...........................................................................................................................................................................................................................................................1
....................................................................................................................................................................................................................
(i)合理利用内存，有的数据要缓存 21
一.用于装配Bean 的注解...................................................................................................................................................................................................................................... 27
二.用于属性注入的注解........................................................................................................................................................................................................................................ 28
三.作用域................................................................................................................................................................................................................................................................ 28
四.生命周期相关的................................................................................................................................................................................................................................................ 28
五.其他配置类相关的............................................................................................................................................................................................................................................ 28
六.Junit相关的..................................................................................................................................................................................................................................................... 29
一、MyBatis框架的优点：................................................................................................................................................................................................................................... 37
二.缺点.................................................................................................................................................................................................................................................................... 38
面试题目考点
一、基础问题
1. Hashmap 的工作原理?
HashMap底层是数组+链表（以数组存储元素，如有hash相同的元素，在数组结构中，创建链表结构，再把hash相同的元素放到链表的下一个节点），
基于hashing (散列法（Hashing）或哈希法是一种将字符组成的字符串转换为固定长度（一般是更短长度）的数值或索引值的方法) 原理,通过put()
和get()方法来储存和获取对象。当我们将键值对传递给put()方法的时候,调用键对象的hashCode()方法来计算哈希值,然后找到
bucket(桶)位置来储存值对象。当我们要获取对象的时候，通过键对象的equal()方法找到正确的键值对,然后返回值对象。HashMap
----------------------- Page 2-----------------------
使用链表来解决碰撞的问题,当发生碰撞了,对象就会储存在链表的下一个节点中。HashMap在每个链表节点中储存键值对对象。
2．HashMap和HashTable 的区别?
主要区别有:线程安全性,同步(synchronization),以及速度
1 HashMap是非同步的,而HashTable是同步的,意味着HashTable是线程安全的,多个线程可以共享一个HashTable,没有正确同步的
话,多个线程不能共享HashMap.
2 HashMap可以接收null 的键值对(key和value都可以为null),HashTable则不行.
3 HashMap 的迭代器(Iterator)是fail-fast迭代器.当有其他线程改变了HashMap 的结构(例如增加或者移除元素),将会抛出异常.
集合中的一种错误机制。当多个线程对同一个集合的内容进行操作时，就可能会产生fail-fast事件
4 HashTable是线程安全的,同时也是同步的,所以在单线程下比HashMap要慢。另外HashMap不能保证随着时间的推移Map 中的元素
次序是不变的。要保持元素顺序不变，除非是LinkedHashMap。
3．能否让HashMap 同步？
HashMap可以通过下面的语句进行同步：
Map m = Collections.synchronizeMap(hashMap);
3.1 HashMap 的扩容
----------------------- Page 3-----------------------
默认的负载因子大小为0.75，也就是说，当一个map填满了75%的bucket时候，和其它集合类(如ArrayList等)一样，将会创建原来
HashMap大小的两倍的bucket数组，来重新调整map 的大小，并将原来的对象放入新的bucket数组中。这个过程叫作rehashing，因
为它调用hash方法找到新的bucket位置。当多线程的情况下，可能产生条件竞争(race condition)。
3.2 hashMap在1.7和1.8 中有什么变化?
JDK1.7中:使用一个Entry数组来存储数据，用key的hashcode取模来决定key会被放到数组里的位置，通常hashMap查询的时间复
杂度是O(N).
JDK1.8 中:使用一个Node数组来存储数据，但这个Node可能是链表结构，也可能是红黑树结构,链表的长度如果>8,就会变成红黑树,
即数组+链表+红黑树.
1.7里是每次扩容都去计算元素的hash值，从而改变该元素在数组中的位置容量,容量变了，位置自然就要改变。1.8 中使用的是2次
幂的扩展(指长度扩为原来2倍)，所以，元素的位置要么是在原位置，要么是在原位置再移动2次幂的位置。
4．什么是HashSet?
HashSet实现了Set接口,他不允许集合中有重复的值,当我们将对象存储在HashSet之前,要先确保对象重写equals()方法和
hashCode()方法,这样才能比较对象的值是否相等,以确保set中没有储存相等的对象。
----------------------- Page 4-----------------------
5．HashSet和HashMap 的区别
*HashMap* *HashSet*
HashMap实现了Map接口 HashSet实现了Set接口
HashMap储存键值对 HashSet仅仅存储对象
使用put()方法将元素放入map
使用add()方法将元素放入set中
中
HashMap 中使用键对象来计算 HashSet使用成员对象来计算hashcode值，对于两个对象来说hashcode可能相同，所以equals()
hashcode值 方法用来判断对象的相等性，如果两个对象不同的话，那么返回false
HashMap 比较快，因为是使用唯
HashSet较HashMap来说比较慢
一的键来获取对象
6. 抽象类(abstract class)和接口(interface)有什么异同?
①成员区别:抽象类成员可以是变量或常量,拥有构造方法,可以有抽象方法和非抽象方法,接口的成员变量只能是常量,没有构造方法,
都是抽象方法
②关系区别:抽象类子类使用extends关键字来继承,只能单继承或者多重继承;接口子类使用implements来实现,可以多实现.
----------------------- Page 5-----------------------
③设计理念:抽象类的方法可以有public,protected和defalut修饰符,接口默认修饰符只有public。抽象类体现的是 “is a”的关
系,体现在共性功能方面,接口体现的是 “like a”的关系,体现在扩展功能.
7. final、finally、finalize的区别？
final：用于声明属性，方法和类，分别表示属性不可变，方法不可覆盖，被其修饰的类不可继承。
finally：异常处理语句结构的一部分，表示总是执行。
finalize：Object 类的一个方法，在垃圾收集器执行的时候会调用被回收对象的此方法，可以覆盖此方法提供垃圾收集时的其他资源
回收，例如关闭文件等。
8．现在有T1、T2、T3三个线程，你怎样保证T2在T1执行完后执行，T3在T2执行完后执行？
Thread.join把指定的线程加入到当前线程,可以将两个交替执行的线程合并为顺序执行的线程,比如说在线程T2中调用了线程T1的
join方法,直到线程T1执行完毕后,才会继续执行线程T2.
t.join(); //调用join方法，等待线程t执行完毕
t.join(1000); //等待 t 线程，等待时间是1000毫秒。
----------------------- Page 6-----------------------
8.1多线程的创建方式
①继承 Thread类：但Thread本质上也是实现了Runnable 接口的一个实例，它代表一个线程的实例，并且，启动线程的唯一方法就
是通过 Thread 类的 start()实例方法。
②实现Runnable接口的方式实现多线程，并且实例化Thread，传入自己的Thread实例，调用run()方法
③实现Callable接口, 可返回值的任务必须实现Callable接口。执Callable任务后，可以获取一个 Future 的对象，在该对象上调
用 get 就可以获取到 Callable 任务返回的 Object 了，再结合线程池接ExecutorService就可以实现传说中有返回结果的多线程了
8.2
9. 在java 中wait和sleep方法的不同？
最大的不同是在等待时wait会释放锁，而sleep一直持有锁。wait通常被用于线程间交互，sleep通常被用于暂停执行。
Java的多线程锁是挂在对象上的，并不是在方法上的。即每个对象都有一个锁.Java 中获取锁的单位是线程。当线程A获取了对象B
的锁，也就是对象B 的持有标记上写的是线程A 的唯一标识，在需要同步的情况下的话，只有线程A能访问对象B。
9.1 synchronized和volatile关键字的作用?
一旦一个共享变量 （类的成员变量、类的静态成员变量）被volatile修饰之后，那么就具备了两层语义：
①保证了不同线程对这个变量进行操作时的可见性，即一个线程修改了某个变量的值，这新值对其他线程来说也是立即可见的。
----------------------- Page 7-----------------------
②禁止进行指令重排序
synchronized则是锁定当前变量，只有当前线程可以访问该变量，其他线程被阻塞住。
1 volatile仅能使用在变量级别;synchronized则可以使用在变量、方法、和类级别的
②volatile仅能实现变量的修改可见性，并不能保证原子性;synchronized则可以保证变量的修改可见性和原子性
2 volatile不会造成线程的阻塞;synchronized可能会造成线程的阻塞。
④volatile标记的变量不会被编译器优化;synchronized标记的变量可以被编译器优化
10. 请叙述一下您对线程池的理解.
① 降低资源消耗。通过重复利用已创建的线程降低线程创建和销毁造成的消耗。
3 提高响应速度。当任务到达时，任务可以不需要等到线程创建就能立即执行。
4 提高线程的可管理性。线程是稀缺资源，如果无限制的创建，不仅会消耗系统资源，还会降低系统的稳定性，使用线程池可以进行
统一的分配，调优和监控。
10.1 常用的线程池有哪些,特点以及方法
①newSingleThreadExecutor：创建一个单线程的线程池，此线程池保证所有任务的执行顺序按照任务的提交顺序执行。
②newFixedThreadPool：创建固定大小的线程池，每次提交一个任务就创建一个线程，直到线程达到线程池的最大大小。
③newCachedThreadPool：创建一个可缓存的线程池，此线程池不会对线程池大小做限制，线程池大小完全依赖于操作系统 （或者说
----------------------- Page 8-----------------------
JVM）能够创建的最大线程大小。
④newScheduledThreadPool：创建一个大小无限的线程池，此线程池支持定时以及周期性执行任务的需求。
10.2 线程的可用状态及生命周期
①就绪(Runnable):线程准备运行，不一定立马就能开始执行。
②运行中(Running)：进程正在执行线程的代码。
③等待中(Waiting):线程处于阻塞的状态，等待外部的处理结束。
④睡眠中(Sleeping)：线程被强制睡眠。
⑤I/O阻塞(BlockedonI/O)：等待I/O操作完成。
⑥同步阻塞(BlockedonSynchronization)：等待获取锁。
⑦死亡(Dead)：线程完成了执行。
11.什么是锁?锁的作用是什么?
锁就是对象.锁的作用是保证线程同步，解决线程安全问题。
持有锁的线程可以在同步中执行，没有锁的线程即使获得cpu执行权，也进不去。
----------------------- Page 9-----------------------
11.1什么情况下导致线程死锁，遇到线程死锁该怎么解决？
指多个线程因竞争资源而造成的一种僵局 （互相等待），若无外力作用，这些进程都将无法向前推进。
产生条件：
①互斥条件：线程要求对所分配的资源 （如打印机）进行排他性控制，即在一段时间内某 资源仅为一个线程所占有。
②不剥夺条件：线程所获得的资源在未使用完毕之前，不能被其他线程夺走，只能由该线程主动释放
③请求和保持条件：线程已经保持了至少一个资源，但又提出了新的资源请求，而该资源已被其他线程占有，此时请求进程被阻塞，
但对自己已获得的资源保持不放。
循环等待条件：存在一种线程资源的循环等待链，链中每一个线程已获得的资源同时被链中下一个线程所请求。
如何避免死锁：
加锁顺序 （线程按照一定的顺序加锁）
加锁时限 （线程尝试获取锁的时候加上一定的时限，超过时限则放弃对该锁的请求，并释放自己占有的锁）
12．说说你对Java 中反射的理解
Java反射机制是运行状态中，对于任意一个类，能够知道这个类的所有属性和方法，对于任意一个对象，都能调用它的任意一个方法，
这种动态获取的信息以及动态调用对象方法的功能称为反射。
反射机制的优点就是可以实现动态创建对象和编译，体现出很大的灵活性. 缺点是对性能有影响, 使用反射基本上是一种解释操作，我们可以告诉JVM，
----------------------- Page 10-----------------------
我们希望做什么并且它 满足我们的要求。这类操作总是慢于只直接执行相同的操作。
获取字节码有三种方法: 1. 根据类名：类名.class ,2. 根据对象：对象.getClass() , 3. 根据全限定类名：Class.forName(全限
定类名)
12.1JVM 内存区域划分?
(1）类加载器子系统
①加载:启动类加载, 负责从启动类路径中加载类; 扩展类加载:负责加载ext 目录(jre\lib)内的类;应用程序类加载器:负责加载
应用程序级别类路径
②链接:校验, 校验生成的字节码是否正确, 准备, 分配内存并初始化默认值给所有的静态变量, 解析,所有符号内存引用被方法区
(Method Area)的原始引用所替代
③初始化:静态代码块被执行
(2）运行时数据区
①本地方法栈:执行虚拟机所使用到的本地方法服务
②java堆:存放对象实例和数组的区域
③方法区:存储已被虚拟机加载的类信息、常量、静态变量等区域
(3）执行引擎
①编译器, 利用解释器转换字节码
②垃圾回收机制:VM 的垃圾回收只收集哪些由new关键字创建的对象。所以，如果不是用new创建的对象，你可以使用finalize函数
----------------------- Page 11-----------------------
来执行清理.
12.2垃圾回收机制?
①标记／清除算法: 内存中的对象构成一棵树，当有效的内存被耗尽的时候，程序就会停止，做两件事，第一：标记，标记从树根可
达的对象 （途中水红色），第二：清除 （清楚不可达的对象）
缺点：递归效率低性能低；释放空间不连续容易导致内存碎片；会停止整个程序运行；
②复制算法:把内存分成两块区域：空闲区域和活动区域，第一还是标记 （标记谁是可达的对象），标记之后把可达的对象复制到空闲
区，将空闲区变成活动区，同时把以前活动区对象1，4清除掉，变成空闲区。
缺点:速度快但是耗费空间
③标记整理算法:标记谁是活跃对象，整理，会把内存对象整理成一课树一个连续的空间，
12.3对象的创建过程?
----------------------- Page 12-----------------------
13. 动静态代理的区别，什么场景使用?
静态代理通常只代理一个类，动态代理是代理一个接口下的多个实现类。
静态代理事先知道要代理的是什么，而动态代理不知道要代理什么东西，只有在运行时才知道.
JDK动态代理是实现JDK里的 InvocationHandler接口的 invoke方法，但注意的是代理的是接口，也就是你的业务类必须要实现接
口，通过Proxy里的newProxyInstance得到代理对象。
还有一种动态代理 CGLIB，代理的是类，不需要业务类继承接口，通过派生的子类来实现代理。通过在运行时，动态修改字节码达到
修改类的目的。
----------------------- Page 13-----------------------
14. JDK1.8 十大新特性详解
① 允许给接口添加一个非抽象的方法实现，只需要使用default关键字即可，这个特征又叫做扩展方法.
② Lambda 表达式:Collections.sort(names,(a,b) ->b.compareTo(a));
③ 函数式接口:指仅仅只包含一个抽象方法的接口，每一个该类型的lambda表达式都会被匹配到这个抽象方法
④方法与构造函数引用:允许你使用 :: 关键字来传递方法或者构造函数引用
⑤Lambda 作用域:可以直接访问标记了final的外层局部变量，或者实例的字段以及静态变量。
⑥访问局部变量, 访问对象字段与静态变量
⑦访问接口的默认方法: 如Stream 接口表示能应用在一组元素上一次执行的操作序列.
⑧Date API:Clock类提供了访问当前日期和时间的方法，Clock是时区敏感的，可以用来取代 System.currentTimeMillis() 来获取
当前的微秒数。
⑨Annotation 注解:支持多重注解, 只需要给该注解标注一下@Repeatable即可。
⑩Java8引入了一个新的Optional类:这是一个可以为 null 的容器对象。如果值存在则 isPresent() 方法会返回 true ，调用 get()
方法会返回该对象。
14.Java 中的设计模式和回收机制?
①创建型模式:工厂方法模式,抽象工厂模式,单例模式,建造者模式
----------------------- Page 14-----------------------
②结构型模式:适配器模式,代理模式,装饰者模式
③行为型模式:策略模式,观察者模式
工厂方法模式分为三种：普通工厂模式，就是建立一个工厂类，对实现了同一接口的一些类进行实例的创建。
多个工厂方法模式，是对普通工厂方法模式的改进，在普通工厂方法模式中，如果传递的字符串出错，则不能正确创建对象，而多个
工厂方法模式是提供多个工厂方法，分别创建对象。
静态工厂方法模式，将上面的多个工厂方法模式里的方法置为静态的，不需要创建实例，直接调用即可。
抽象工厂模式:工厂方法模式有一个问题就是，类的创建依赖工厂类，也就是说，如果想要拓展程序，必须对工厂类进行修改,此时就
需要用到工厂模式,创建多个工厂类, ，这样一旦需要增加新的功能，直接增加新的工厂类就可以了，不需要修改之前的代码。
建造者模式:而建造者模式则是将各种产品集中起来进行管理，用来创建复合对象，所谓复合对象就是指某个类具有不同的属性，其
实建造者模式就是前面抽象工厂模式和最后的 Test 结合起来得到的。
适配器模式:适配器模式将某个类的接口转换成客户端期望的另一个接口表示, 主要分为三类：类的适配器模式、对象的适配器模式、
接口的适配器模式。
装饰者模式:装饰模式就是给一个对象增加一些新的功能，而且是动态的，要求装饰对象和被装饰对象实现同一个接口，装饰对象持
有被装饰对象的实例。
15. Java的基本数据类型
8种基本数据类型:byte 1
----------------------- Page 15-----------------------
char 2
short 2
int 4
float 4
double 8
long 8
boolean 1,
String是引用类型，底层用char数组实现的。
16. jvm为什么设计成一个进程?
JVM是一份本地化的程序，本质上是可执行的文件，是静态的概念。程序运行起来成为进程，是动态的概念。实际上，多个进程可以
并发执行同一个程序,java程序是跑在JVM上的，严格来讲，是跑在JVM实例上的，一个JVM实例其实就是JVM跑起来的进程，二者
合起来称之为一个JAVA进程。
17. 既然有GC机制，为什么还会有内存泄露的情况?
理论上 Java 因为有垃圾回收机制 （GC）不会存在内存泄露问题 （这也是 Java 被广泛使用于服务器端编程的一个重要原因）。然而在
实际开发中，可能会存在无用但可达的对象，这些对象不能被 GC 回收，因此也会导致内存泄露的发生。例如 hibernate 的 Session
----------------------- Page 16-----------------------
（一级缓存）中的对象属于持久态，垃圾回收器是不会回收这些对象的，然而这些对象中可能存在无用的垃圾对象，如果不及时关闭
（close）或清空 （flush）一级缓存就可能导致内存泄露。
18. 说下原生jdbc操作数据库流程？
第一步：Class.forName()加载数据库连接驱动；
第二步：DriverManager.getConnection()获取数据连接对象;
第三步：根据SQL获取sql会话对象，有2种方式 Statement、PreparedStatement ;
第四步：执行SQL处理结果集，执行SQL前如果有参数值就设置参数值setXXX();
第五步：关闭结果集、关闭会话、关闭连接
19. GET和POST 的区别?
① GET请求的数据会附在URL之后 （就是把数据放置在HTTP协议头中），以?分割URL和传输数据，参数之间以&相连.
② GET方式提交的数据最多只能是1024字节，理论上POST没有限制，可传较大量的数据。
③POST 的安全性要比GET 的安全性高。通过GET提交数据，用户名和密码将明文出现在 URL 上，因为(1)登录页面有可能被浏览器缓
存，(2)其他人查看浏览器的历史纪录，那么别人就可以拿到你的账号和密码了.
----------------------- Page 17-----------------------
20. session共享怎么做的 （分布式如何实现session共享）？
利用 redis 做session共享,方案是重写服务器中的HttpSession和HttpServletRequest，首先实现HttpSession接口，重写session
的所有方法，将session 以hash值的方式存在redis中，一个session 的key就是sessionID，setAtrribute重写之后就是更新 redis
中的数据，getAttribute 重写之后就是获取 redis 中的数据，等等需要将 HttpSession 的接口一一实现。
21. 什么是jsp，什么是Servlet？jsp和Servlet有什么区别？
①jsp本质上就是一个Servlet, 每个jsp页面都是一个servlet实例。
1 Servlet是由 Java提供用于开发 web服务器应用程序的一个组件, 用来生
成动态内容
区别:
2 jsp是html页面中内嵌的Java代码，侧重页面显示；
②②Servlet是html代码和Java代码分离，侧重逻辑控制，mvc设计思想中jsp位于视图层，servlet位于控制层
22. jsp有哪些域对象?
（1）pageContext,在当前jsp页面有效，跳到其它页面失效
（2）request,指一次请求范围内有效，从http请求到服务器处理结束，返回响应的整个过程。在这个过程中使用forward （请求转
----------------------- Page 18-----------------------
发）方式跳转多个jsp，在这些页面里你都可以使用这个变量
（3）session,指当前会话有效范围，浏览器从打开到关闭过程中，转发、重定向均可以使用
（4）application context域-指只能在同一个web 中使用，服务器未关闭或者重启，数据就有效
23. 谈谈你对ajax 的认识？
Ajax是一种创建交互式网页应用的的网页开发技术, 通过异步模式，提升了用户体验。 优化了浏览器和服务器之间的传输，减少不
必要的数据往返，减少了带宽占用。最大特点是可以实现局部刷新，在不更新整个页面的前提下维护数据.
24. 常用的Linux命令?
列出文件列表：ls 【参数 -a -l】
创建目录和移除目录：mkdir rmdir
创建文件:touch 文件名称
打包并压缩：tar -zcvf
解压压缩包:tar -xvf
查找字符串：grep
显示当前所在目录：pwd
创建空文件：touch
----------------------- Page 19-----------------------
编辑器：vim vi
删除:rm -rf
修改:mv 目录名称 新目录名称
动态打印日志信息：tail –f 日志文件
25. Mysql性能优化?
①当只要一行数据时使用limit 1
②选择正确的数据库引擎,MyISAM 适用于一些大量查询的应用,InnoDB 的写操作比较优秀
3 用not exists代替not in
4 充分使用索引,B-TREE 仍然是最高效的索引之中的一个
5 用 NOSQL 的方式使用 MYSQL
25.1 内连接与外连接的区别?
内连接，也被称为自然连接，只有两个表相匹配的行才能在结果集中出现。
外连接不仅包含符合连接条件的行，（1）左外连接(左边的表不加限制) （2）右外连接(右边的表不加限制) （3）全外连接(左右两表都
不加限制
----------------------- Page 20-----------------------
25.2 mysql行转列?
mysql中行转列是通过group_concat()函数来实现的。默认是使用逗号隔开.
26. 事务的四大特性是什么？
①原子性(A)：整个事务中的所有操作，要么全部完成，要么全部不完成，不可能停滞在中间某个环节, 事务在执行过程中发生错误，
会被回滚 （Rollback）到开始前的状态.
②一致性(C)：在事务开始之前和事务结束以后，数据库的完整性约束没有被破坏。就拿转账为例，A有500元，B有300元，如果在
一个事务里A成功转给B50元，那么不管并发多少，不管发生什么，只要事务执行成功了，那么最后A账户一定是450元，B账户一
定是350元。
③隔离性(I)：一个事务的成功或者失败对于其他的事务是没有影响。2个事务应该相互独立
④持久性(D)：在事务完成以后，该事务所对数据库所作的更改便持久的保存在数据库之中，并不会被回滚。
27.四种隔离级别?
①读未提交 （read uncommitted）：也就是脏读, 事务可以读取其它事务未提交的数据。(避免)
②读已提交 （read committed）：一个事务读到另一个事务已经提交的数据。解决了脏读问题.oracle默认
③可重复读(repeatable read）：在一个事务中读到的数据始终保持一致，无论另一个事务是否提交。解决脏读、不可重复读,mysql
----------------------- Page 21-----------------------
默认
④可串行化 （SERIALIZABLE）: 同时只能执行一个事务，相当于事务中的单线程。
28. 在千万级的数据库查询中，如何提高效率？
(1) 数据库设计方面
a.对查询进行优化，应尽量避免全表扫描
b.应尽量避免在 where 子句中对字段进行 null 值判断
c.索引并不是越多越好，索引固然可以提高相应的 select 的效率，但同时也降低了 insert 及 update 的效率
d.尽量使用数字型字段, 是因为引擎在处理查询和连接时会逐个比较字符串中每一个字符，而对于数字型而言只需要比较一次就够了。
e.避免频繁创建和删除临时表，以减少系统表资源的消耗。
(2)语句方面
f.应尽量避免在 where 子句中使用!=或<>操作符,或者是or来连接条件，否则将引擎放弃使用索引而进行全表扫描。
g.任何地方都不要使用 select * from t ，用具体的字段列表代替 “*”，不要返回用不到的任何字段
h.用not exists代替not in
(3)java方面
(i)合理利用内存，有的数据要缓存
----------------------- Page 22-----------------------
29. SpringMVC 的工作原理
①用户向服务器发送请求,请求被springMVC前端控制器DispatchServlet捕获.
②DispatcherServle对请求URL进行解析，得到请求资源标识符 （URL），然后根据该URL调用HandlerMapping将请求映射到处理器
HandlerExcutionChain
③DispatchServlet根据获得Handler选择一个合适的HandlerAdapter适配器处理；
④Handler对数据处理完成以后将返回一个ModelAndView （）对象给DisPatchServlet;
⑤Handler 返回的 ModelAndView()只是一个逻辑视图并不是一个正式的视图，DispatcherSevlet 通过ViewResolver试图解析器将逻
辑视图转化为真正的视图View;
6 DispatcherServle 通过 model 解析出 ModelAndView()中的参数进行解析最终展现出完整的 view 并返回给客户端;
----------------------- Page 23-----------------------
----------------------- Page 24-----------------------
29.1. SpringMVC常用注解都有哪些?’’
@requestMapping 用于请求 url 映射。
@RequestBody 注解实现接收 http 请求的 json 数据，将 json 数据转换为 java 对象。
@ResponseBody 注解实现将 controller 方法返回对象转化为 json 响应给客户。
29.2 springMvc的优化?
①controller能使用单例的话尽量使用单例,可以减少创建对象和回收对象的开销.
②处理request的方法形参务必加上@RequestParam注解,可以避免springmvc使用asm框架读取class文件获取方法参数名的过程.
30. 如何解决get和post乱码问题?
解决 post 请求乱码:我们可以在web.xml 里边配置一个 CharacterEncodingFilter 过滤器。 设置为 utf-8.
解决 get 请求的乱码:有两种方法。对于 get 请求中文参数出现乱码解决方法有两个:
①修改 tomcat 配置文件添加编码与工程编码一致。
②另 外 一 种 方 法 对 参 数 进 行 重 新 编 码 String userName = New
String(Request.getParameter(“userName”).getBytes(“ISO8859-1”), “utf-8”);
----------------------- Page 25-----------------------
31.谈谈你对Spring的理解
Spring容器的主要核心是：控制反转 （IOC）, 依赖注入 （DI）和面向切面(AOP)
①控制反转: 传统的java开发模式中，当需要一个对象时，我们会自己使用new或者getInstance等直接或者间接调用构造方法创建
一个对象, 。而在spring开发模式中，spring容器使用了工厂模式为我们创建了所需要的对象，直接调用就可以了.
②依赖注入: spring使用javaBean对象的set方法或者带参的构造方法为我们在创建所需对象时将其属性自动设置所需要的值的过
程，就是依赖注入的思想。
③面向切面编程: 将一个个的对象某些类似的方面横向抽成一个切面，对这个切面进行一些如权限控制、事物管理，记录日志等,底层
是动态代理.
31.1spring的启动过程?
①创建全局的上下文环境，这个上下文就是ServletContext
②在web容器启动时，会触发容器初始化事件, 其contextInitialized方法会被调用，在这个方法中，spring会初始 化一个启动上
下文，这个上下文被称为根上下文，即WebApplicationContext
③监听器初始化完毕后，开始初始化web.xml中配置的Servlet
----------------------- Page 26-----------------------
32. Spring 中的几种设计模式?
①单例模式:spring的配置文件中设置bean默认为单例模式,spring 中有两种代理方式，若目标对象实现了若干接口，spring使用
jdk 的类代理, 没有实现任何接口，spring使用CGLIB库生成目标类的子类。
②模板方式模式——用来解决代码重复的问题。比如：RestTemplate, 当我们从服务消费端去调用服务提供者的服务的时候，使用了
RestTemplate.
③前端控制器模式——spring提供了前端控制器DispatherServlet来对请求进行分发。
④试图帮助 （view helper）——spring提供了一系列的JSP标签,高效宏来帮助将分散的代码整合在试图中
⑤依赖注入——贯穿于BeanFactory/ApplacationContext 接口的核心理念。
⑥工厂模式——在工厂模式中, 通过使用同一个接口来指向新创建的对象。Spring中使用beanFactory来创建对象的实例。
33. bean 的生命周期?
单例对象：scope="singleton",一个应用只有一个对象的实例。它的作用范围就是整个应用。
生命周期：
对象出生：当应用加载，创建容器时，对象就被创建了。
对象活着：只要容器在，对象一直活着。
对象死亡：当应用卸载，销毁容器时，对象就被销毁了。
----------------------- Page 27-----------------------
多例对象：scope="prototype",每次访问对象时，都会重新创建对象实例。
生命周期：
对象出生：当使用对象时，创建新的对象实例 （getBean）。
对象活着：只要对象在使用中，就一直活着。
对象死亡：当对象长时间不用时，被java的垃圾回收器回收了.
33.1 BeanFactory和FactoryBean 的区别?
BeanFactory是IOC最基本的容器，负责生产和管理bean，它为其他具体的IOC容器提供了最基本的规范,
FactoryBean是一个接口, 当在IOC容器中的Bean实现了FactoryBean后, 通过getBean(StringBeanName)获取到的Bean对象.(并
不是FactoryBean 的实现类对象，而是这个实现类中的getObject()方法返回的对象。)
34. Spring的常用注解
注解装配在 spring 中默认是关闭的。必须在 Spring 配置文件中配置 <context:annotation-config/>元素,开启注解装配.
一.用于装配Bean 的注解
@Component(value=”xxx”):把资源让spring 来管理。相当于在xml 中配置一个bean。value可以省略，value的属性值作为bean 的id
@Component的三个衍生注解：
@Controller(value=”xxx”):一般用于将表现层装配到容器中，使用方法和@Componet一样
----------------------- Page 28-----------------------
@Service(value=”xxx”):一般用于将业务层装配到容器中，使用方法和@Component一样
@Repository(value=”xxx”):一般用于将持久层装配到容器中，使用方法和@Component一样
二.用于属性注入的注解
@Autowired:只能按照bean类型注入,如果有多个类型匹配，默认将属性名称作为id去容器中查找。
@Qualifier:一般和@Autowired配合使用，用来注入指定id的bean,做方法的参数中可以独立使用
@Resource:用来注入指定id的bean类型，相当于@Autowired+@Qualifier
@Value:只能注入基本类型等数据，不能注入bean类型，可以使用${}在资源文件中获取数据，前提是，外部资源文件被加载。
三.作用域
@Scope:用于指定bean 的作用域，一般就是singleton和prototype
四.生命周期相关的
@PostConstruct:用于指定某一个方法为初始化方法
@PreDestroy:用于指定某一个方法为销毁方法
五.其他配置类相关的
@Configuration：声明一个类为配置类，用于替代applicationContext.xml的
----------------------- Page 29-----------------------
@ComponentScan:用于开启注解扫描的包
@Import:用于导入其他类的
@PropertySource:用于加载外部资源文件的
@Bean:用于将方法返回的bean类型的对象装配到容器中
六.Junit相关的
@RunWith:用于加载配置文件，初始化spring容器的
@ContextConfiguration:用于指定配置文件或者配置类的
35. spring的事务传播特性?
①PROPAGATION_REQUIRED: 如果存在一个事务，则支持当前事务。如果没有事务则开启
②PROPAGATION_SUPPORTS: 如果存在一个事务，支持当前事务。如果没有事务，则非事务的执行
③PROPAGATION_MANDATORY: 如果已经存在一个事务，支持当前事务。如果没有一个活动的事务，则抛出异常。
④PROPAGATION_REQUIRES_NEW: 总是开启一个新的事务。如果一个事务已经存在，则将这个存在的事务挂起。
⑤PROPAGATION_NOT_SUPPORTED: 总是非事务地执行，并挂起任何存在的事务。
----------------------- Page 30-----------------------
⑥PROPAGATION_NEVER: 总是非事务地执行，如果存在一个活动事务，则抛出异常
⑦PROPAGATION_NESTED ：如果一个活动 的事务存在 ，则运行在一个嵌套 的事务 中. 如果没有活动事务, 则按
TransactionDefinition.PROPAGATION_REQUIRED 属性执行
36. HTTP/1.1与HTTP/1.0的区别?
①可扩展性:HTTP/1.1 在消息中增加版本号和OPTIONS方法, 它用于获取当前URL所支持的方法。若请求成功，则它会在HTTP头中
包含一个名为 “Allow”的头，值是所支持的方法，如 “GET, POST”。
②缓存:HTTP/1.1 在 1.0 的基础上加入了一些 cache 的新特性
③带宽优化:HTTP/1.1中在请求消息中引入了range头域，它允许只请求资源的某个部分。
④长连接:在一个TCP连接上可以传送多个 HTTP 请求和响应，减少了建立和关闭连接的消耗和延迟
36.1 HTTP与HTTPS有什么区别？
HTTP是一个客户端和服务器端请求和应答的标准,HTTPS：是以安全为目标的HTTP通道，简单讲是HTTP 的安全版，即HTTP下加入SSL
层
区别主要如下：
①https协议需要到ca 申请证书，一般免费证书较少，因而需要一定费用。
②http是超文本传输协议，信息是明文传输，https则是具有安全性的ssl加密传输协议。
----------------------- Page 31-----------------------
③http和https使用的是完全不同的连接方式，用的端口也不一样，前者是80，后者是443。
④http 的连接很简单，是无状态的；HTTPS协议是由SSL+HTTP协议构建的可进行加密传输、身份认证的网络协议，比http协议安全。
37. http常见的状态码有哪些?
200 OK //客户端请求成功
301 Moved Permanently （永久移除)，请求的URL 已移走。Response中应该包含一个Location URL, 说明资源现在所处的位置
302 found 重定向
400 Bad Request //客户端请求有语法错误，不能被服务器所理解
401 Unauthorized //请求未经授权，这个状态代码必须和WWW-Authenticate报头域一起使用
403 Forbidden //服务器收到请求，但是拒绝提供服务
404 Not Found //请求资源不存在，eg：输入了错误的URL
500 Internal Server Error //服务器发生不可预期的错误
503 Server Unavailable //服务器当前不能处理客户端的请求，一段时间后可能恢复正常
38. Mybatis的编程步骤是什么样的?
①创建SqlSessionFactory
②通过SqlSessionFactory创建SqlSession
----------------------- Page 32-----------------------
③通过sqlsession执行数据库操作
④调用session.commit()提交事务
⑤调用session.close()关闭会话
39. Redis的持久化?
①RDB 持久化：该机制可以在指定的时间间隔内生成数据集的时间点快照, 非常适合用于进行备份, 可以最大化 Redis 的性能
②AOF 持久化：记录服务器执行的所有写操作命令，并在服务器启动时，通过重新执行这些命令来还原数据集,使用 AOF 持久化会让
Redis 变得非常耐久, 对于相同数量的数据集而言，AOF文件通常要大于RDB文件,AOF在运行效率上往往会慢于RDB
③无持久化：让数据只在服务器运行时存在
两者的区别:
RDB持久化是指在指定的时间间隔内将内存中的数据集快照写入磁盘，实际操作过程是fork一个子进程，先将数据集写入临时文件，
写入成功后，再替换之前的文件，用二进制压缩存储。
AOF持久化以日志的形式记录服务器所处理的每一个写、删除操作，查询操作不会记录，以文本的方式记录，可以打开文件看到详细
的操作记录。
39.1. Redis有哪几种数据结构?
String——字符串,hash(键值对),list(列表),set(集合),zset(有序集合)
----------------------- Page 33-----------------------
39.2 Redis常见的性能问题都有哪些？如何解决?
（1）、Master写内存快照, 会阻塞主线程的工作
（2）、Master AOF持久化，如果不重写AOF文件, ，AOF文件过大会影响Master重启的恢复速度
(3) Master调用BGREWRITEAOF重写AOF文件，AOF在重写的时候会占大量的CPU和内存资源
（4）、Redis 主从复制的性能问题，为了主从复制的速度和连接的稳定性，Slave 和 Master 最好在同一个局域
网内
39.3 redis存满之后的解决方案?
①增加内存,因为redis是基于内存的k-v键值对存储的,内存越大,可存储的数据越多.
②使用内存淘汰策略:修改redis.conf中maxmemory-policy选项，设置删除redis键的淘汰规则,redis中并不会准确的删除所有键
中最近最少使用的键，而是随机抽取3个键，删除这三个键中最近最少使用的键。
③集群:设置redis主从,避免redis单点故障,构建读写分离架构，满足读多写少的应用场景, 即使有了主从复制，每个数据库都要保
存整个集群中的所有数据，容易形成木桶效应, 这时要用到分片集群,所有的redis节点彼此互联(PING-PONG机制),内部使用二进制
协议优化传输速度和带宽. 客户端与redis节点直连,不需要中间proxy层.客户端不需要连接集群所有节点,连接集群中任何一个可用
节点即可.
----------------------- Page 34-----------------------
40.数据库的分库分表?
①当数据比较大的时候，对数据进行分表操作，首先要确定需要将数据平均分配到多少张表中，也就是：表容量。
40.1用户中心数据库切分方法|范围法
以用户中心的业务uid为划分依据，将数据水平切分到两个数据库实例上去,user_db1存储0到1千万的uid数据,user_db2存储1到
2千万的数据切分策略简单,扩容简单,数据量和请求量不均匀
40.2用户中心数据库切分方法|哈希法
以用户中心的业务uid为划分依据，将数据水平切分到两个数据库实例上去,user_db1存储uid%2=0 的数据,user_db2存储uid%2=1
的数据
切分策略简单,数据量和请求量均匀,扩容麻烦,增加一个库需要重新hash.
垂直分库就是根据业务耦合性，将关联度低的不同表存储在不同的数据库。做法与大系统拆分为多个小系统类似，按业务分类进行独
立划分。与"微服务治理"的做法相似，每个微服务使用单独的一个数据库。
41. 分库分表带来的问题?
①事务一致性问题: 当更新内容同时分布在不同库中，不可避免会带来跨库事务问题,解决方案:分布式事务能最大限度保证了数据库
----------------------- Page 35-----------------------
操作的原子性。事务补偿的方式,可以基于日志进行对比，定期同标准数据来源进行同步
②跨节点关联查询 join 问题:全局表, 可以将这类表在每个数据库中都保存一份;数据组装,分几次查询,再根据id将得到的数据进
行拼接;ER分片, 将那些存在关联关系的表记录存放在同一个分片上
全局主键避重问题:UUID是主键是最简单的方案，本地生成，性能高
支持分库分表中间件:Vitess(谷歌),mycat(基于cobar)
42. 什么是乐观锁，什么是悲观锁，两者的区别是什么？
悲观锁(PessimisticLock):每次在拿数据的时候都会上锁，这样别人想拿这个数据就会 block 直到它拿到锁。传统的关系型数据库
里边就用到了很多这种锁机制，比如行锁，表锁等，读锁，写锁等，都是在做操作之前先上锁,比如 Java里面的同步原语synchronized
关键字的实现也是悲观锁。 在整个数据处理过程中，将数据处于锁定状态。
悲观锁机制存在以下问题：
1. 在多线程竞争下，加锁、释放锁会导致比较多的上下文切换和调度延时，引起性能问题。
2. 一个线程持有锁会导致其它所有需要此锁的线程挂起。
3. 如果一个优先级高的线程等待一个优先级低的线程释放锁会导致优先级倒置，引起性能风险。
乐观锁(冲突检测和数据更新):每次去拿数据的时候都认为别人不会修改，所以不会上锁，但是在更新的时候会判断一下在此期间别人
有没有去更新这个数据，如果因为并发冲突失败就重试，直到成功为止。
CAS是乐观锁技术，当多个线程尝试使用CAS 同时更新同一个变量时，只有其中一个线程能更新变量的值，而其它线程都失败，失败
----------------------- Page 36-----------------------
的线程并不会被挂起，而是被告知这次竞争中失败，并可以再次尝试。需要读写的内存位置 （V）、进行比较的预期原值 （A）和拟写入
的新值(B)。如果内存位置V 的值与预期原值A相匹配，那么处理器会自动将该位置值更新为新值B。否则处理器不做任何操作。
CAS缺点：
(1)ABA 问题：比如说一个线程one从内存位置V 中取出A，这时候另一个线程two也从内存中取出A，并且two进行了一些操作变成
了B，然后two又将V位置的数据变成A，这时候线程one进行CAS操作发现内存中仍然是A，然后one操作成功。尽管线程one的CAS
操作成功，但可能存在潜藏的问题。如下所示：
现有一个用单向链表实现的堆栈，栈顶为 A，这时线程 T1 已经知道 A.next 为 B，然后希望用 CAS 将栈顶替换为 B：
head.compareAndSet(A,B);在T1执行上面这条指令之前，线程T2介入，将A、B 出栈，再pushD、C、A，此时堆栈结构如下图，而对
象B此时处于游离状态：
此时轮到线程T1执行CAS操作，检测发现栈顶仍为A，所以CAS成功，栈顶变为B，但实际上B.next为null，所以此时
的情况变为：
----------------------- Page 37-----------------------
其中堆栈中只有B一个元素，C和D组成的链表不再存在于堆栈中，平白无故就把C、D丢掉了。
(2)循环时间长开销大：不成功，就一直循环执行，直到成功）如果长时间不成功，会给CPU带来非常大的执行开销
(3)只能保证一个共享栈区变量的原子操作：当对一个共享变量执行操作时，我们可以使用循环CAS的方式来保证原子操作，但是对多
个共享变量操作时，循环CAS就无法保证操作的原子性，这个时候就可以用锁，或者就是把多个共享变量合并成一个共享变量来操作。
43. Mybatis框架 （优点是什么？缺点是什么？以及在企业开发中有什么好处？你在开发中是怎么使用的？有那些属性）
一、MyBatis框架的优点：
① 与JDBC相比，减少了50%以上的代码量。
② MyBatis是最简单的持久化框架，小巧并且简单易学。
③ MyBatis相当灵活，不会对应用程序或者数据库的现有设计强加任何影响，SQL写在XML里，从程序代码中彻底分离，降低耦合度，
便于统一管理和优化，并可重用。
2 提供XML标签，支持编写动态SQL语句。
----------------------- Page 38-----------------------
3 提供映射标签，支持对象与数据库的ORM字段关系映射。
二.缺点
① SQL语句的编写工作量较大，尤其是字段多、关联表多时，更是如此，对开发人员编写SQL语句的功底有一定要求。
② SQL语句依赖于数据库，导致数据库移植性差，不能随意更换数据库。
MyBatis专注于SQL本身，是一个足够灵活的DAO层解决方案，对性能的要求很高，或者需求变化较多的项目，如互联网项目，那么
MyBatis将是不错的选择。
属性
id="selectUser" //与 PersonMapper.java 接口对应的方法
parameterType="int" //传入的参数格式
resultType="hashmap" //返回的数据类型，当返回多个参数的时候，建议使用 resultMap
resultMap="userResultMap" //返回的数据类型，相当于对 resultType="hashmap" 的封装。resultType、resultMap两者只能存在
一个
flushCache="false" //是否清空缓存，默认为false
useCache="true" //是否二级缓存，默认值：对 select 元素为 true。
timeout="10000" //等待数据库返回请求结果的秒数
----------------------- Page 39-----------------------
44.Springboot的常用注解?
@SpringBootApplication：包含了@ComponentScan、@Configuration和@EnableAutoConfiguration注解。其中@ComponentScan让spring
Boot扫描到Configuration类并把它加入到程序上下文。
@Configuration 等同于spring的XML配置文件；使用Java代码可以检查类型安全。
@EnableAutoConfiguration 自动配置。
@ComponentScan 组件扫描，可自动发现和装配一些Bean。
@Component可配合CommandLineRunner使用，在程序启动后执行一些基础任务。
@RestController注解是@Controller和@ResponseBody的合集,表示这是个控制器bean,并且是将函数的返回值直 接填入HTTP响应体
中,是REST风格的控制器。
@Autowired 自动导入。
@PathVariable获取参数。
@JsonBackReference解决嵌套外链问题。
@RepositoryRestResourcepublic配合spring-boot-starter-data-rest使用。
----------------------- Page 40-----------------------
45.rabbitMQ在项目中的应用场景?
主要是完成系统之间的通信,并且将系统之间的调用进行解耦,例如在添加商品信息后,需要将商品信息同步到索引库,同步缓存中的数
据,一旦后台对商品信息进行修改后,就像activeMQ发送一条消息,然后通过activeMQ将消息发送给消息的消费端,消费端接收到消息
后可以进行相应的业务处理.
45.1 rabbitMQ 的5种消息模型?
①基本消息模型: -
P：生产者，也就是要发送消息的程序 C：消费者：消息的接受者，会一直等待消息到来。
- queue：消息队列，图中红色部分。类似一个邮箱，可以缓存消息；生产者向其中投递消息，消费者从其中取出消息
----------------------- Page 41-----------------------
②work消息模型 :：让多个消费者绑定到一个队列，共同消费队列中的消息。队列中的消息一旦消
费，就会消失，因此任务是不会被重复执行的。
③订阅模型-Fanout(广播): :
- 1） 可以有多个消费者
- 2） 每个消费者有自己的queue （队列）
- 3） 每个队列都要绑定到Exchange （交换机）
- 4） 生产者发送的消息，只能发送到交换机，交换机来决定要发给哪个队列，生产者无法决定。
----------------------- Page 42-----------------------
- 5） 交换机把消息发送给绑定过的所有队列
- 6） 队列的消费者都能拿到消息。实现一条消息被多个消费者消费
④: 订阅模型-Direct: :
- 队列与交换机的绑定，不能是任意绑定了，而是要指定至少一个RoutingKey （路由key）
- 消息的发送方在 向 Exchange发送消息时，也必须指定消息的 RoutingKey。
-Exchange不再把消息交给每一个绑定的队列，而是根据消息的RoutingKey进行判断，只有队列的Routingkey与消息的 Routingkey
完全一致，才会接收到消息
⑤:订阅模型-Topic:Topic类型的Exchange与Direct相比，都是可以根据RoutingKey把消息路由到不同的队列。只不过Topic类
型Exchange可以让队列在绑定Routing key 的时候使用通配符！
通配符规则：#：匹配一个或多个词*：匹配不多不少恰好1个词
45.2:rabbitMQ如果数据提交不成功怎么办?
rabbitMQ有两种通信方式:点到点形式和发布订阅模式,点到点模式的话,如果消息发送不成功,消息会默认保存到服务端直到有消费者
----------------------- Page 43-----------------------
将其消费掉,所以此时消息是不会丢失的.发布订阅模式的通信方式,此时就需要将配置持久化(队列持久化,交换机持久化,消息持久
化),发送消息和接收消息需要配置发送模式为持久化,此时如果客户端接收不到消息,消息就会持久化到服务端,直到客户端正常接收
为止.
45.3 rabbitMQ 的常见问题?
①RabbitMQ 队列超长导致QueueingConsumerJVM溢出
②RabbitMQ数据速率问题, 在边读边写的情况下：速率只与网络带宽正相关;在只写不读的情况下：写入速率瓶颈在于硬盘写入速度。
③RabbitMQ数据存储路径变更到D盘方法:Windows环境下，在安装前设置环境变量：RABBITMQ_BASE=D:\RabbitMQ_Data
④RabbitMQ磁盘写满重启后数据丢失问题
45.4 rabbtiMQ消息阻塞.
①消息会处于阻塞状态:解决阻塞的办法，可以在subscribe消息队列是设置autoAck=true，这种情况是worker接到消息后，就会
把消息从消息队列删除，不管消息是否被正确处理，另一种是设置autoAck=false，这样worker在接受消息后，必须给予服务端一个
ack响应，该消息才会从消息队列中删除，这样会防止消息的意外丢失.
②关于健壮的消息处理: 当rabbitmq server重启，或意外当掉的话，所用消息的订阅都会跟着坏掉 （当然也可以设置持久化的消息
队列设置），解决办法是捕获ShutdownSignalException异常.
----------------------- Page 44-----------------------
46.页面静态化?
①使用freemarker实现生成静态页面，将页面的实际存在于服务器的硬盘中，然后通过nginx反向代理服务器访问资源；
②WEB服务器的 URLRewrite的方式, 一句话来说就是把外部请求的静态地址转化为实际的动态页面地址，静态页面实际是不存在的.
47.谈谈你对elasticsearch 的理解?
是一个基于Lucene的搜索服务器。它提供了一个分布式多用户能力的全文搜索引擎
- 分布式，无需人工搭建集群 （solr就需要人为配置，使用Zookeeper作为注册中心）
- Restful风格，一切API都遵循Rest原则，容易上手
- 近实时搜索，数据更新在Elasticsearch 中几乎是完全同步的。
48.谈谈你对node.js的理解?
概念: 1. Node.js是一个基于Chrome V8引擎的javascipt的运行环境。
2. Node.js使用了一个事件驱动、非阻塞I/O 的模型，
3. Node.js轻量又高效,能够使我们在本地运行javascript
----------------------- Page 45-----------------------
作用: 1、提供数据给浏览器展示
2、保存用户提交过来的数据
3、数据统计与分析
49.谈谈对springcloud的理解?
SpringCloud是Spring为微服务架构思想做的一个一站式实现。提供了微服务开发所需的配置管理、服务发现、断路器、智能路由、
微代理、控制总线、全局锁、决策竞选、分布式会话和集群状态管理等组件。最重要的是，跟SpringBoot框架一起使用的话，会让你
开发微服务架构的云服务非常方便。组件有:
- Eureka：注册中心
- Zuul：服务网关
- Ribbon：负载均衡
- Feign：服务调用(集成了负载)
- Hystix：熔断器
- Feign：服务调用
- springCloud config它支持配置文件放在在配置服务的内存中，也支持放在远程Git仓库里。
----------------------- Page 46-----------------------
50.eureka的理解?
- Eureka：就是服务注册中心 （可以是一个集群），对外暴露自己的地址
- 提供者：启动后向Eureka注册自己信息 （地址，提供什么服务）
- 消费者：向Eureka订阅服务，Eureka会将对应服务的所有提供者地址列表发送给消费者，并且定期更新
- 心跳(续约)：提供者定期通过http方式向Eureka刷新自己的状态
51.JWT 的理解?
JWT，全称是Json Web Token， 是JSON风格轻量级的授权和身份认证规范，可实现无状态、分布式的Web应用授权,
----------------------- Page 47-----------------------
- 1、用户登录
- 2、服务的认证，通过后根据secret生成token
- 3、将生成的token返回给用户
- 4、用户每次请求携带token
- 5、服务端解读jwt签名，判断签名有效后，从Payload中获取用户信息
- 6、处理请求，返回响应结果
52.REST风格的WEB设计原则
①使用客户/服务器模型。客户和服务器之间通过一个统一的接口来互相通讯。
②层次化的系统. 在一个REST系统中，客户端并不会固定地与一个服务器打交道。
③无状态,在一个REST系统中，服务端并不会保存有关客户的任何状态。也就是说，客户端自身负责用户状态的维持，并在每次发送请求时都需要提供足
够的信息。
④可缓存,REST系统需要能够恰当地缓存请求，以尽量减少服务端和客户端之间的信息传输，以提高性能。
⑤统一的接口,一个REST 系统需要使用一个统一的接口来完成子系统之间以及服务与用户之间的交互。这使得REST 系统中的各个子系统可以独自完成演
化。
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
