java面试题备份

@Service 用于标注业务层组件，
@Controller 用于标注控制层组件，
@Repository 用于标注数据访问层组件。
@Component泛指组件，当组件不好归类时，可以使用这个注解进行标注。

高并发解决：
流量优化：防盗链处理（把一些恶意的请求拒之门外）
前端优化：减少HTTP请求、添加异步请求、启用浏览器的缓存和文件压缩、CDN加速、建立独立的图片服务器；
服务端优化：页面静态化处理、并发处理、队列处理；
数据库优化：数据库的缓存、分库分表、分区操作、读写分离、负载均衡
web服务器优化：负载均衡；

先初始化静态成员，然后调用父类构造器，再初始化非静态成员，最后调用自身构造器。

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

#{}是预编译处理，KaTeX parse error: Expected 'EOF', got '#' at position 21: …串替换。 Mybatis在处理#̲{}时，会将sql中的#{}替…则不行
MyBatis排序时使用order by 动态参数时需要注意，用$而不是#
@Service 用于标注业务层组件，@Controller 用于标注控制层组件，@Repository 用于标注数据访问层组件。@Component泛指组件，当组件不好归类时，可以使用这个注解进行标注。

反射原理
java虚拟机运行时内存有个叫方法区，主要作用是存储被装载的类的类型信息。每装载一个 类的时候，java 就会创建一个该类的Class对象实例。我们就可以通过这
个实例，来访问这个类的信息

代理的作用和实现
代理模式的作用是:为其他对象提供一种代理以控制对这个对象的访问。在某些情况下，一个客户不想或者不能直接引用另一个对象，而代理对象可以在客户端和目标对象之间起到中介的作用。

Overload是重载的意思，Override是覆盖的意思
重载Overload表示同一个类中可以有多个名称相同的方法，但这些方法的参数列表各不相同

编写多线程程序有几种实现方式
继承Thread类；实现Runnable接口

Executors类-这个类是用来创建线程池的
1、newFixedThreadPool() 创建固定大小的线程池 线程池的大小一旦达到最大值就会保持不变，如果某个线程因为执行异常而结束，那么线程池会补充一个新线程

2、newCachedThreadPool() 创建一个可缓存的线程池，如果线程池的大小超过了处理任务所需要的线程，那么就会回收部分空闲(60s不执行任务)的线程，当任务数量增加时，此线程池又可以智能的添加新线程来处理任务。此线程池不会对线程池大小做限制，线程池大小完全依赖于系统（JVM）能够创建的最大线程大小

3、newSingleThreadExecutor() 创建一个单线程的线程池。这个线程池只有线程在工作，也就是相当于单线程串行执行所有任务。如果这个唯一的线程因为异常结束，那么会有一个新的线程来替代它。此线程池保证所有任务的执行顺序按照任务的提交顺序执行

4、newScheduledThreadPool() 创建一个大小无限的线程池，此线程池支持定时以及周期性执行任务的需求

5、newSingleThreadScheduledExecutor() 创建一个单线程的线程池。此线程池支持定时以及周期性执行任务的需求

单例模式有两种：懒汉式、饿汉式
懒汉式：在需要用到对象时才实例化对象
饿汉式：在类加载时已经创建好该单例对象，在获取单例对象时直接返回对象即可，不会存在并发安全和性能问题
饿汉：public class Singleton {
private Singleton(){}
private static Singleton instance = new Singleton();
public static Singleton getInstance(){
return instance;}
}
懒汉：public class Singleton {
private static Singleton instance = null;
private Singleton() {}
public static synchronized Singleton getInstance(){
if (instance == null) instance ＝ new Singleton();
return instance;
}}

Spring管理事务有几种方式？
1、编程式事务，在代码中硬编码。(不推荐使用)
①编程式事务管理使用TransactionTemplate。

2、声明式事务，在配置文件中配置（推荐使用）
②声明式事务管理建立在AOP之上的。其本质是通过AOP功能，对方法前后进行拦截，将事务处理的功能编织到拦截的方法中，也就是在目标方法开始之前加入一个事务，在执行完目标方法之后根据执行情况提交或者回滚事务。

声明式事务最大的优点就是不需要在业务逻辑代码中掺杂事务管理的代码，只需在配置文件中做相关的事务规则声明或通过@Transactional注解的方式，便可以将事务规则应用到业务逻辑中。

声明式事务管理要优于编程式事务管理，这正是spring倡导的非侵入式的开发方式，使业务代码不受污染，只要加上注解就可以获得完全的事务支持。唯一不足地方是，最细粒度只能作用到方法级别，无法做到像编程式事务那样可以作用到代码块级别。

声明式事务又分为两种：
a、基于XML的声明式事务
b、基于注解的声明式事务

原子性(Atomic)：事务中各项操作，要么全做要么全不做，任何一项操作的失败都会导致整个事务的失败
一致性(Consistent)：事务结束后系统状态是一致的
隔离性(Isolated)：并发执行的事务彼此无法看到对方的中间状态
持久性(Durable)：事务完成后所做的改动都会被持久化，即使发生灾难性的失败。通过日志和同步备份可以在故障发生后重建数据。

spring 常用注解
@Component
@Controller：对应表现层的 Bean
@Scope("prototype")：表示将 Action 的范围声明为原型
@Service：对应的是业务层 Bean
@Repository：对应数据访问层 Bean

Java中有几种类型的流？
字节流和字符流
字节流继承于InputStream、OutputStream
字符流继承于Reader、Writer

ArrayList和LinkedList的区别
ArrayList是实现了基于动态数组的数据结构，LinkedList是基于链表结构。
ArrayList要优于LinkedList，因为LinkedList要移动指针。
对于新增和删除操作add和remove，LinkedList比较占优势，因为ArrayList要移动数据
LinkedList也是线程不安全的，LinkedList提供了一些方法，使得LinkedList可以被当作堆栈和队列来使用。

List、Map、Set三个接口存取元素时，各有什么特点？
它们有一个功共同的父接口，叫Collection
Set里面不允许有重复的元素（用对象的equals()方法来区分元素是否重复）
List表示有先后顺序的集合，以特定索引来存取元素，可以有重复元素
Map与List和Set不同，它是双列的集合，其中有put方法
保存键值对（key-value pair）映射，映射关系可以是一对一或多对一。

HashTable跟HashMap区别
HashTable的方法是同步的，HashMap不能同步
HashTable是继承自Dictionary类，而HashMap是继承自AbstractMap类
HashTable不允许null值（key和value都不可以），HashMap允许使用null值
HashTable使用Enumeration遍历，HashMap使用Iterator进行遍历
HashTable中hash数组初始化大小及扩容方式不同

treeset和hashset的区别
1.HashSet是采用hash表来实现的。其中的元素没有按顺序排列
2.TreeSet是采用树结构实现(红黑树算法)。元素是按顺序进行排列

&和&&的区别：
&(1)按位与；(2)逻辑与。&&短路与运算
如果&&左边的表达式的值是false，右边的表达式会被直接短路掉，不会进行运算

==跟equals
==操作符专门用来比较两个变量的值是否相等
equals方法是用于比较两个独立对象的内容是否相同

用最有效率的方法算出2乘以8等於几?
2 << 3

数组有没有length()方法？String有没有length()方法？
答：数组没有length()方法，有length 的属性。String 有length()方法

String和StringBuilder、StringBuffer的区别
String 被final修饰。不可变类
StringBuffer和StringBuilder类都表示内容可以被修改的字符串
StringBuffer 可变字符串，线程安全
StringBuilder是线程不安全的，运行效率高，如果一个字符串变量是在方法里面定义，这种情况只可能有一个线程访问它，不存在不安全的因素了，则用StringBuilder。

接口跟抽象类
1.抽象类可以有构造方法，接口中不能有构造方法。
2.抽象类中可以有普通成员变量，接口中没有普通成员变量
3.抽象类中可以包含非抽象的普通方法，接口中的所有方法必须都是抽象的，不能有非抽象的普通方法。
4. 抽象类中的抽象方法的访问类型可以是public，protected和（默认类型,虽然
eclipse下不报错，但应该也不行），但接口中的抽象方法只能是public类型的，并且默认即为public abstract类型。
5. 抽象类中可以包含静态方法，接口中不能包含静态方法
6. 抽象类和接口中都可以包含静态成员变量，抽象类中的静态成员变量的访问类型可以任意，但接口中定义的变量只能是public static final类型，并且默认即为public static final类型。

Math.round(11.5)等於多少? Math.round(-11.5)
12 -11

Java 中的final关键字有哪些用法？
(1)修饰类：表示该类不能被继承
(2)修饰方法：表示方法不能被重写
(3)修饰变量：表示变量只能一次赋值以后值不能被修改（常量）

简述synchronized 和Lock的异同？
Lock 能完成synchronized所实现的所有功能
主要不同点：Lock有比synchronized更精确的线程语义和更好的性能，而且不强制性的要求一定要获得锁
synchronized会自动释放锁，而Lock一定要求程序员手工释放，并且最好在finally 块中释放（这是释放外部资源的最好的地方）。

Integer与int的区别
int是java提供的8种原始数据类型之一。Java为每个原始类型提供了封装类，Integer是java为int提供的封装类。int的默认值为0，而Integer的默认值为null，即Integer可以区分出未赋值和值为0的区别，int则无法表达出未赋值的情况

列出一些你常见的运行时异常？
-NullPointerException （空指针异常）

• ClassCastException （类转换异常）
• ArithmeticException（算术异常）
• IllegalArgumentException （非法参数异常）
• IndexOutOfBoundsException （下标越界异常）
• SecurityException （安全异常）

重定向跟转发区别
转发发送一次请求，重定向两次请求
转发地址栏不变，重定向地址栏发生改变
转发只能访问内部资源，重定向可访问外部资源

Cookie和Session的区别？
1、Cookie和Session都是会话技术，Cookie是运行在客户端，Session是运行在服务器端。
2、Cookie有大小限制以及浏览器在存cookie的个数也有限制，Session是没有大小限制和服务器的内存大小有关。
3、Cookie有安全隐患，通过拦截或本地文件找得到你的cookie后可以进行攻击。
4、Session是保存在服务器端上会存在一段时间才会消失，如果session过多会增加服务器的压力。

final、finally、finalize的区别
final 用于声明属性，方法和类，分别表示属性不可变，方法不可覆盖，类不可继承。 内部类要访问局部变量，局部变量必须定义成final类型

• finally：通常放在try…catch…的后面构造总是执行代码块，这就意味着程序无论正常执行还是发生异常，这里的代码只要JVM不关闭都能执行
• finalize：Object类中定义的方法，这个方法是由垃圾收集器在销毁对象时调用的，通过重写finalize()方法可以整理系统资源或者执行其他清理工作。

Collection和Collections的区别？
答：Collection是一个接口，它是Set、List等容器的父接口；Collections是个一个工具类，提供了一系列的静态方法来辅助容器操作

Spring Bean 的生命周期？
①instantiate bean 对象实例化
②populate properties 封装属性
③如果 Bean 实现 BeanNameAware 执行 setBeanName
④ 如 果 Bean 实 现 BeanFactoryAware 或 者 ApplicationContextAware setBeanFactory 或者上下文对象 setApplicationContext 设 置 工 厂
⑤如果存在类实现 BeanPostProcessor 后处理Bean） ，执行 postProcessBeforeInitialization，BeanPostProcessor 接口提供钩子函数，用来动态扩展修改 Bean。(程序自动调用后处理 Bean)
⑥如果 Bean 实现 InitializingBean 执行 afterPropertiesSet
⑦调用 指定初始化方法 init
⑧如果存在类实现 BeanPostProcessor（处理 Bean） ，执行 postProcessAfterInitialization
⑨执行业务处理
⑩如果 Bean 实现 DisposableBean 执行 destroy
?调用 指定销毁方法 customerDestroy

Bean 注入属性有哪几种方式？
spring 支持构造器注入和 setter 方法注入
构造器注入，通过 元素完成注入
setter 方法注入， 通过

spring 配置 bean 实例化有哪些方式？
1）使用类构造器实例化(默认无参数)

2）使用静态工厂方法实例化(简单工厂模式)
//下面这段配置的含义：调用 Bean2Factory 的 getBean2 方法得到 bean2

3）使用实例工厂方法实例化(工厂方法模式)
//先创建工厂实例 bean3Facory，再通过工厂实例创建目标 bean 实例

IOC，DI
IOC：创建对象的控制权的转移（意味着将你设计好的对象交给容器控制）
IOC让对象的创建不用去new了，可以由spring自动生产，使用java的反射机制，根据配置文件在运行时动态的去创建对象以及管理对象，并调用对象的方法的
Spring的IOC有三种注入方式 ：构造器注入、setter方法注入、根据注解注入。
DI：Dependency Injection 依赖注入，在 Spring 框架负责创建 Bean 对象时，动态的将依赖对象注入到 Bean 组件

Spring中AOP的应用场景、Aop原理、好处？
答：AOP–Aspect Oriented Programming面向切面编程；用来封装横切关注点，具体可以在下面的场景中使用:

Authentication 权限、Caching 缓存、Context passing 内容传递、Error handling 错误处理Lazy loading懒加载、Debugging调试、logging, tracing, profiling and monitoring 记录跟踪优化　校准、Performance optimization　性能优化、Persistence 持久化、Resource pooling　资源池、Synchronization　同步、Transactions 事务

原理：AOP是面向切面编程，是通过动态代理的方式为程序添加统一功能，集中解决一些公共问题。

优点：1.各个步骤之间的良好隔离性耦合性大大降低
2.源代码无关性，再扩展功能的同时不对源码进行修改操作

高并发解决：
流量优化：防盗链处理（把一些恶意的请求拒之门外）
前端优化：减少HTTP请求、添加异步请求、启用浏览器的缓存和文件压缩、CDN加速、建立独立的图片服务器；
服务端优化：页面静态化处理、并发处理、队列处理；
数据库优化：数据库的缓存、分库分表、分区操作、读写分离、负载均衡
web服务器优化：负载均衡；

实现同步的方式
1.同步方法
即有 synchronized 关键字修饰的方法。
由于 java 的每个对象都有一个内置锁，当用此关键字修饰方法时，内置锁会保护整个方法。在调用该方法前，需要获得内置锁，否则就处于阻塞状态。
代码如：
public synchronized void save(){}
注： synchronized 关键字也可以修饰静态方法，此时如果调用该静态方法，将会锁住整个类
2.同步代码块
即有 synchronized 关键字修饰的语句块。
被该关键字修饰的语句块会自动被加上内置锁，从而实现同步代码如：
synchronized(object){
}
注：同步是一种高开销的操作，因此应该尽量减少同步的内容。通常没有必要同步整个方法，使用 synchronized 代码块同步关键代码即可。

Error和Exception有什么区别？
Error表示系统级的错误和程序不必处理的异常，是恢复不是不可能但很困难的情况下的一种严重问题；比如内存溢出，Exception表示需要捕捉或者需要程序进行处理的异常，是一种设计或实现问题

try{}里有一个return语句，那么紧跟在这个try后的finally{}里的代码会不会被执行，什么时候被执行，在return前还是后?
会执行，在方法返回调用者前执行。

Thread类的sleep()方法和对象的wait()
sleep()方法（休眠）是线程类（Thread）的静态方法，调用此方法会让当前线程暂停执行指定的时间，将执行机会（CPU）让给其他线程，
wait()是Object类的方法，调用对象的wait()方法导致当前线程放弃对象的锁（线程暂停执行），进入对象的等待池（wait pool），只有调用对象的notify()方法（或notifyAll()方法）时才能唤醒等待池中的线程进入等锁池（lock pool），如果线程重新获得对象的锁就可以进入就绪状态。

请说出与线程同步以及线程调度相关的方法
wait()：使一个线程处于等待（阻塞）状态，并且释放所持有的对象的锁；

• sleep()：使一个正在运行的线程处于睡眠状态，是一个静态方法，调用此方法要处理InterruptedException异常；
• notify()：唤醒一个处于等待状态的线程，当然在调用此方法的时候，并不能确切的唤醒某一个等待状态的线程，而是由JVM确定唤醒哪个线程，而且与优先级无关；
• notityAll()：唤醒所有处于等待状态的线程，该方法并不是将对象的锁给所有线程，而是让它们竞争，只有获得锁的线程才能进入就绪状态；

synchronized关键字的用法？
答：synchronized关键字可以将对象或者方法标记为同步，以实现对对象和方法的互斥访问，可以用synchronized(对象) { … }定义同步代码块，或者在声明方法时将synchronized作为方法的修饰符

启动一个线程是调用run()还是start()方法？
答：启动一个线程是调用start()方法，使线程所代表的虚拟处理机处于可运行状态，run()方法是线程启动后要进行回调（callback）的方法。

synchronized 和java.util.concurrent.locks.Lock的异同
Lock 能完成synchronized所实现的所有功能；主要不同点：
Lock有比synchronized更精确的线程语义和更好的性能，而且不强制性的要求一定要获得锁。synchronized会自动释放锁，而Lock一定要求程序员手工释放，并且最好在finally 块中释放

Java中有几种类型的流？
字节流和字符流。字节流继承于InputStream、OutputStream，字符流继承于Reader、Writer。在java.io 包中还有许多其他的流，主要是为了提高性能和使用方便。关于Java的I/O需要注意的有两点：一是两种对称性（输入和输出的对称性，字节和字符的对称性）；二是两种设计模式（适配器模式和装潢模式）

你在项目中哪些地方用到了XML？
答：XML的主要作用有两个方面：数据交换和信息配置。在做数据交换时

数据库通常会通过锁机制来解决数据并发访问问题，按锁定对象不同可以分为表级锁和行级锁；按并发事务锁定关系可以分为共享锁和独占锁，具体的内容大家可以自行查阅资料进行了解。直接使用锁是非常麻烦的，为此数据库为用户提供了自动锁机制，只要用户指定会话的事务隔离级别，数据库就会通过分析SQL语句然后为事务访问的资源加上合适的锁
事务隔离级别和数据访问的并发性是对立的，事务隔离级别越高并发性就越差。所以要根据具体的应用来确定合适的事务隔离级别
读已提交
读未提交
可重复读
串行化

获得一个类的类对象有哪些方式？

• 方法1：类型.class，例如：String.class
• 方法2：对象.getClass()，例如："hello".getClass()
• 方法3：Class.forName()，例如：Class.forName("java.lang.String")

简述一下你了解的设计模式
1/工厂模式：工厂类可以根据条件生成不同的子类实例，这些子类有一个公共的抽象父类并且实现了相同的方法，但是这些方法针对不同的数据进行了不同的操作（多态方法）。当得到子类的实例后，开发人员可以调用基类中的方法而不必考虑到底返回的是哪一个子类的实例。
2/代理模式：给一个对象提供一个代理对象，并由代理对象控制原对象的引用。实际开发中，按照使用目的的不同，代理可以分为：远程代理、虚拟代理、保护代理、Cache代理、防火墙代理、同步化代理、智能引用代理。
3/适配器模式：把一个类的接口变换成客户端所期待的另一种接口，从而使原本因接口不匹配而无法在一起使用的类能够一起工作。
4/观察者模式：定义对象键一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都会得到通知被制动更新，如Spring中listener的实现–

ApplicationListener
get和post请求的区别？
①get请求用来从服务器上获得资源，而post是用来向服务器提交数据；
②get将表单中数据按照name=value的形式，添加到action 所指向的URL 后面，并且两者使用"?"连接，而各个变量之间使用"&"连接；post是将表单中的数据放在HTTP协议的请求头或消息体中，传递到action所指向URL；
③get传输的数据要受到URL长度限制（1024字节）；而post可以传输大量的数据，上传文件通常要使用post方式；
④使用get时参数会显示在地址栏上，如果这些数据不是敏感数据，那么可以使用get；对于敏感数据还是应用使用post；
⑤get使用MIME类型application/x-www-form-urlencoded的URL编码（也叫百分号编码）文本的格式传递参数，保证被传送的参数由遵循规范的文本组成，例如一个空格的编码是"%20"

锁机制有什么用？简述Hibernate的悲观锁和乐观锁机制。
答：有些业务逻辑在执行过程中要求对数据进行排他性的访问，于是需要通过一些机制保证在此过程中数据被锁住不会被外界修改，这就是所谓的锁机制。
Hibernate支持悲观锁和乐观锁两种锁机制。悲观锁，顾名思义悲观的认为在数据处理过程中极有可能存在修改数据的并发事务（包括本系统的其他事务或来自外部系统的事务），于是将处理的数据设置为锁定状态。悲观锁必须依赖数据库本身的锁机制才能真正保证数据访问的排他性，关于数据库的锁机制和事务隔离级别在《Java面试题大全（上）》中已经讨论过了。乐观锁，顾名思义，对并发事务持乐观态度（认为对数据的并发操作不会经常性的发生），通过更加宽松的锁机制来解决由于悲观锁排他性的数据访问对系统性能造成的严重影响。

表达式语言（EL）支持哪些运算符？
答：除了.和[]运算符，EL还提供了：

• 算术运算符：+、-、*、/或div、%或mod
• 关系运算符：==或eq、!=或ne、>或gt、>=或ge、<或lt、<=或le
• 逻辑运算符：&&或and、||或or、!或not
• 条件运算符：${statement? A : B}（跟Java的条件运算符类似）
• empty运算符：检查一个值是否为null或者空（数组长度为0或集合中没有元素也返回true）

MySQL和Oracle的区别？
1.mysql是开源的项目。orcal是闭源收费的，安装空间大，3点多个G。
2.mysql轻量型数据库；orcal 重量型数据库。
3.sql语句的扩展和灵活性：
mysql对sql语句有许多实用方便的扩展，有limit功能，insert可以一次插入多行数据，select 某些管理数据库可以不加from
orcal更传统一些。
4.对事务的提交：
mysql默认自动提交；orcal需要用户手动提交，需要在写commit指令或者点击commit按钮。
5.分页查询：
mysal直接在sql语句中写“select … from … where … limit … x,y”，有limit可以实现分页，自动增长的数据类型处理；orcal需要用到伪列rownum和嵌套查询。
6.对事务的支持：
mysql在innodb存储引擎的行级锁的情况下才支持事务；orcal完全支持事务。
7.MySQL是单进程多线程；Oracle是多进程
8.性能诊断:
mysql的诊断调优方法较少，主要有慢查询日志;
oracle有各种成熟的性能诊断调优工具，能实现很多自动分析、诊断功能。比如awr\addm\sqltrace\tkproof等。
9.管理工具：
mysql管理工具较少，在linux下的管理工具的安装有时要安装额外的包，有一定复杂性；oracle有多种成熟的命令行，图形界面，web管理工具，还有很多第三方的管理工具，管理及其方便高效。
10.保存数据的持久性：
mysql是在数据库更新或者重启，则会丢失数据；oracle把提交的sql操作线写入了在线联机日志文件中，保持到了磁盘上，可以随时恢复。
11.自动增长的数据类型处理：
mysql是一个自动增长的数据类型，插入数据的时候，不需要管理，它自己会自动增长;Oracle不支持自动增长的数据类型，通过建立一个自动增长的序列号来完成自动增长。
12.oracle支持大并发，大访问量，

Mybatis和Hibernate区别
Mybatis 优势
MyBatis 可以进行更为细致的 SQL 优化，可以减少查询字段。
MyBatis 容易掌握，而 Hibernate 门槛较高。
Hibernate 优势
Hibernate 的 DAO 层开发比 MyBatis 简单，Mybatis 需要维护 SQL 和结果映射。
Hibernate 对对象的维护和缓存要比 MyBatis 好，对增删改查的对象的维护要方便。
Hibernate 数据库移植性很好，MyBatis 的数据库移植性不好，不同的数据库需要写不同 SQL。
Hibernate 有更好的二级缓存机制，可以使用第三方缓存。MyBatis 本身提供的缓存机制不佳。

kafka消息队列
Kafka是一个分布式，可划分的，冗余备份的持久性的日志服务，它主要用于处理流式数据
缓冲和削峰：上游数据时有突发流量，下游可能扛不住，或者下游没有足够多的机器来保证冗余，kafka在中间可以起到一个缓冲的作用，把消息暂存在kafka中，下游服务就可以按照自己的节奏进行慢慢处理。
解耦和扩展性：项目开始的时候，并不能确定具体需求。消息队列可以作为一个接口层，解耦重要的业务流程。只需要遵守约定，针对数据编程即可获取扩展能力。
冗余：可以采用一对多的方式，一个生产者发布消息，可以被多个订阅topic的服务消费到，供多个毫无关联的业务使用。
健壮性：消息队列可以堆积请求，所以消费端业务即使短时间死掉，也不会影响主要业务的正常进行。
异步通信：很多时候，用户不想也不需要立即处理消息。消息队列提供了异步处理机制，允许用户把一个消息放入队列，但并不立即处理它。想向队列中放入多少消息就放多少，然后在需要的时候再去处理它们。

Kafka相对传统技术有什么优势?
快速：单一的Kafka代理可以处理成千上万的客户端，每秒处理数兆字节的读写操作。
可伸缩：在一组机器上对数据进行分区和简化，以支持更大的数据
持久：消息是持久性的，并在集群中进行复制，以防止数据丢失。
设计：它提供了容错保证和持久性

JSP有哪些内置对象？作用分别是什么？
答：JSP有9个内置对象：

• request：封装客户端的请求，其中包含来自GET或POST请求的参数；
• response：封装服务器对客户端的响应；
• pageContext：通过该对象可以获取其他对象；
• session：封装用户会话的对象；
• application：封装服务器运行环境的对象；
• out：输出服务器响应的输出流对象；
• config：Web应用的配置对象；
• page：JSP页面本身（相当于Java程序中的this）；
• exception：封装页面抛出异常的对象。

字符串反转(代码)
public static String reverse(String originStr) {
if(originStr == null || originStr.length() <= 1)
return originStr;
return reverse(originStr.substring(1)) + originStr.charAt(0);
}

顺序读写；
零拷贝；
消息压缩；
分批发送。

JAVA反射机制概念：
JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。
Java反射机制主要提供了以下功能：
1、在运行时判定任意一个对象所属的类；
2、在运行时构造任意一个类的对象；
3、在运行时判定任意一个类所具有的成员变量和方法；
4、在运行时调用任意一个对象的方法；
5、生成动态代理。

消息：Kafka 中的数据单元被称为消息，也被称为记录，可以把它看作数据库表中某一行的记录。

批次：为了提高效率， 消息会分批次写入 Kafka，批次就代指的是一组消息。

主题：消息的种类称为 主题（Topic）,可以说一个主题代表了一类消息。相当于是对消息进行分类。主题就像是数据库中的表。

分区：主题可以被分为若干个分区（partition），同一个主题中的分区可以不在一个机器上，有可能会部署在多个机器上，由此来实现 kafka 的伸缩性，单一主题中的分区有序，但是无法保证主题中所有的分区有序

特性：
高吞吐、低延迟：kakfa 最大的特点就是收发消息非常快，kafka 每秒可以处理几十万条消息，它的最低延迟只有几毫秒；
高伸缩性：每个主题(topic) 包含多个分区(partition)，主题中的分区可以分布在不同的主机(broker)中；
持久性、可靠性：Kafka 能够允许数据的持久化存储，消息被持久化到磁盘，并支持数据备份防止数据丢失，Kafka 底层的数据存储是基于 Zookeeper 存储的，Zookeeper 我们知道它的数据能够持久存储；
容错性：允许集群中的节点失败，某个节点宕机，Kafka 集群能够正常工作；
高并发：支持数千个客户端同时读写。

使用场景
活动跟踪：Kafka 可以用来跟踪用户行为，比如我们经常回去淘宝购物，你打开淘宝的那一刻，你的登陆信息，登陆次数都会作为消息传输到 Kafka ，当你浏览购物的时候，你的浏览信息，你的搜索指数，你的购物爱好都会作为一个个消息传递给 Kafka ，这样就可以生成报告，可以做智能推荐，购买喜好等；
传递消息：Kafka 另外一个基本用途是传递消息，应用程序向用户发送通知就是通过传递消息来实现的，这些应用组件可以生成消息，而不需要关心消息的格式，也不需要关心消息是如何发送的；
度量指标：Kafka也经常用来记录运营监控数据。包括收集各种分布式应用的数据，生产各种操作的集中反馈，比如报警和报告；
日志记录：Kafka 的基本概念来源于提交日志，比如我们可以把数据库的更新发送到 Kafka 上，用来记录数据库的更新时间，通过kafka以统一接口服务的方式开放给各种consumer，例如hadoop、Hbase、Solr等；
流式处理：流式处理是有一个能够提供多种应用程序的领域；
限流削峰：Kafka 多用于互联网领域某一时刻请求特别多的情况下，可以把请求写入Kafka 中，避免直接请求后端程序导致服务崩溃。

Kafka 的消息队列
Kafka 的消息队列一般分为两种模式：点对点模式和发布订阅模式

//申请单编号 时间戳+随机数
Date date = new Date();
SimpleDateFormat sdf = new SimpleDateFormat(“yyyyMMddHHmmsss”);
String timeStamp = sdf.format(date);
String random = String.format("%05d", (int) (Math.random() * 99999));
String randomStr = String.valueOf(random);
String applicationFormNo= timeStamp + randomStr;
cmsCustomerRelationshipInsert.setApplicationFormNo(applicationFormNo);

// 1.新建完成的订单自动生成订单号，规则为S+9位数字，数字自增长展示，如S00000001，S12345678.系统默认从50000000开始
/**

• 订单号处理
• @param tmsBooking 订单对象
• @author Y.linjun
• @date 2021/3/19 15:03
  */
  private void bookingCodeHandler(TmsBooking tmsBooking) {
  // 获取最大的序列
  Long maxSeq = tmsBookingQueryDsl.findMaxSeq();
  if (maxSeq == null) {
  maxSeq = 500000000L;
  }else {
  maxSeq += 1L;
  }
  tmsBooking.setIncreasingSeq(maxSeq);
  tmsBooking.setBookingCode(“S” + maxSeq);
  }

Spring中AOP的应用场景、Aop原理、好处？
答：AOP–Aspect Oriented Programming面向切面编程；用来封装横切关注点，具体可以在下面的场景中使用:

Authentication 权限、Caching 缓存、Context passing 内容传递、Error handling 错误处理Lazy loading懒加载、Debugging调试、logging, tracing, profiling and monitoring 记录跟踪优化　校准、Performance optimization　性能优化、Persistence 持久化、Resource pooling　资源池、Synchronization　同步、Transactions 事务

原理：AOP是面向切面编程，是通过动态代理的方式为程序添加统一功能，集中解决一些公共问题。

优点：1.各个步骤之间的良好隔离性耦合性大大降低
2.源代码无关性，再扩展功能的同时不对源码进行修改操作

Spring中IOC的作用与原理？对象创建的过程。
答：IOC–Inversion of Control控制反转。当某个角色需要另外一个角色协助的时候，在传统的程序设计过程中，通常由调用者来创建被调用者的实例对象。但在spring中创建被调用者的工作不再由调用者来完成，因此称为控制反转。创建被调用者的工作由spring来完成，然后注入调用者 直接使用。

介绍spring框架
它是一个一站式（full-stack全栈式）框架，提供了从表现层-springMVC到业务层-spring再到持久层-springdata的一套完整的解决方案。我们在项目中可以只使用spring一个框架，它就可以提供表现层的mvc框架，持久层的Dao框架。它的两大核心IoC和AOP更是为我们程序解耦和代码简洁易维护提供了支持。

Spring常见创建对象的注解？
答：@Component@Controller@ Service@ Repository

Spring中用到的设计模式
答：简单工厂、工厂方法、单例模式、适配器、包装器、代理、观察者、策略、模板方法

Spring的优点？
答：1.降低了组件之间的耦合性 ，实现了软件各层之间的解耦
2.可以使用容易提供的众多服务，如事务管理，消息服务等
3.容器提供单例模式支持
4.容器提供了AOP技术，利用它很容易实现如权限拦截，运行期监控等功能
5.容器提供了众多的辅助类，能加快应用的开发
6.spring对于主流的应用框架提供了集成支持，如hibernate，JPA，Struts等
7.spring属于低侵入式设计，代码的污染极低
8.独立于各种应用服务器
9.spring的DI机制降低了业务对象替换的复杂性
10.Spring的高度开放性，并不强制应用完全依赖于Spring，开发者可以自由选择spring 的部分或全部

Spring管理事务有几种方式？
答：有两种方式：
1、编程式事务，在代码中硬编码。(不推荐使用)
2、声明式事务，在配置文件中配置（推荐使用）
声明式事务又分为两种：
a、基于XML的声明式事务
b、基于注解的声明式事务

spring中自动装配的方式有哪些？
答：1、 No：即不启用自动装配。
2、 byName：通过属性的名字的方式查找JavaBean依赖的对象并为其注入。比如说类Computer有个属性printer，指定其autowire属性为byName后，Spring IoC容器会在配置文件中查找id/name属性为printer的bean，然后使用Seter方法为其注入。
3、 byType：通过属性的类型查找JavaBean依赖的对象并为其注入。比如类Computer有个属性printer，类型为Printer，那么，指定其autowire属性为byType后，Spring IoC容器会查找Class属性为Printer的bean，使用Seter方法为其注入。
4、 constructor：通byType一样，也是通过类型查找依赖对象。与byType的区别在于它不是使用Seter方法注入，而是使用构造子注入。
5、 autodetect：在byType和constructor之间自动的选择注入方式。
6、 default：由上级标签的default-autowire属性确定。

spring中的核心类有那些，各有什么作用？
答：BeanFactory：产生一个新的实例，可以实现单例模式
BeanWrapper：提供统一的get及set方法
ApplicationContext:提供框架的实现，包括BeanFactory的所有功能

什么是IOC，什么又是DI，他们有什么区别？

答：依赖注入DI是一个程序设计模式和架构模型， 一些时候也称作控制反转，尽管在技术上来讲，依赖注入是一个IOC的特殊实现，依赖注入是指一个对象应用另外一个对象来提供一个特殊的能力，例如：把一个 数据库连接已参数的形式传到一个对象的结构方法里面而不是在那个对象内部自行创建一个连接。控制反转和依赖注入的基本思想就是把类的依赖从类内部转化到外 部以减少依赖

应用控制反转，对象在被创建的时候，由一个调控系统内所有对象的外界实体，将其所依赖的对象的引用，传递给它。也可以说，依赖被注入到对象中。所 以，控制反转是，关于一个对象如何获取他所依赖的对象的引用，这个责任的反转。

Springmvc的优点

答：1.它是基于组件技术的.全部的应用对象,无论控制器和视图,还是业务对象之类的都是 java组件.并且和Spring提供的其他基础结构紧密集成.

2.不依赖于Servlet API(目标虽是如此,但是在实现的时候确实是依赖于Servlet的)

3. 可以任意使用各种视图技术,而不仅仅局限于JSP

4 . 支持各种请求资源的映射策略

5 .它应是易于扩展的

请描述Spring MVC的工作流程？描述一下 DispatcherServlet 的工作流程？
（1）用户发送请求至前端控制器DispatcherServlet；
（2） DispatcherServlet收到请求后，调用HandlerMapping处理器映射器，请求获取Handle；
（3）处理器映射器根据请求url找到具体的处理器，生成处理器对象及处理器拦截器(如果有则生成)一并返回给DispatcherServlet；
（4）DispatcherServlet 调用 HandlerAdapter处理器适配器；
（5）HandlerAdapter 经过适配调用 具体处理器(Handler，也叫后端控制器)；
（6）Handler执行完成返回ModelAndView；
（7）HandlerAdapter将Handler执行结果ModelAndView返回给DispatcherServlet；
（8）DispatcherServlet将ModelAndView传给ViewResolver视图解析器进行解析；
（9）ViewResolver解析后返回具体View；
（10）DispatcherServlet对View进行渲染视图（即将模型数据填充至视图中）
（11）DispatcherServlet响应用户。

springCloud
5大组件
Eureka：服务治理组件，包括服务端的注册中心和客户端的服务发现机制；
Ribbon：负载均衡的服务调用组件，具有多种负载均衡调用策略；
Hystrix：服务容错组件，实现了断路器模式，为依赖服务的出错和延迟提供了容错能力；
Feign：基于Ribbon和Hystrix的声明式服务调用组件；
Zuul：API网关组件，对请求提供路由及过滤功能。
什么是springCloud
Spring Cloud是一系列框架的有序集合。它利用Spring Boot的开发便利性巧妙地简化了分布式系统基础设施的开发，如服务发现注册、配置中心、智能路由、消息总线、负载均衡、断路器、数据监控等，都可以用Spring Boot的开发风格做到一键启动和部署。Spring Cloud并没有重复制造轮子，它只是将各家公司开发的比较成熟、经得起实际考验的服务框架组合起来，通过Spring Boot风格进行再封装屏蔽掉了复杂的配置和实现原理，最终给开发者留出了一套简单易懂、易部署和易维护的分布式系统开发工具包。

优缺点
优点
组件丰富，功能齐全。Spring Cloud 为微服务架构提供了非常完整的支持。例如、配置管理、服务发现、断路器、微服务网关等；
Spring Cloud 社区活跃度很高，教程很丰富，遇到问题很容易找到解决方案
服务拆分粒度更细，耦合度比较低，有利于资源重复利用，有利于提高开发效率
可以更精准的制定优化服务方案，提高系统的可维护性
减轻团队的成本，可以并行开发，不用关注其他人怎么开发，先关注自己的开发
微服务可以是跨平台的，可以用任何一种语言开发
适于互联网时代，产品迭代周期更短

缺点
微服务过多，治理成本高，不利于维护系统
分布式系统开发的成本高（容错，分布式事务等）对团队挑战大

Spring Cloud Config
集中配置管理工具，分布式系统中统一的外部配置管理，默认使用Git来存储配置，可以支持客户端配置的刷新及加密、解密操作。
使用：
（1）添加pom依赖
（2）配置文件添加相关配置
（3）启动类添加注解@EnableConfigServer

SpringBoot和SpringCloud的区别？
1，SpringBoot专注于快速方便的开发单个个体微服务。
2，SpringCloud是关注全局的微服务协调整理治理框架，它将SpringBoot开发的一个个单体微服务整合并管理起来，
3，为各个微服务之间提供，配置管理、服务发现、断路器、路由、微代理、事件总线、全局锁、决策竞选、分布式会话等等集成服务
4，SpringBoot可以离开SpringCloud独立使用开发项目， 但是SpringCloud离不开SpringBoot ，属于依赖的关系
5，SpringBoot专注于快速、方便的开发单个微服务个体，SpringCloud关注全局的服务治理框架。

spring Cloud和 Dubbo有哪些区別?
dubbo 是 基于 RPC 远程 过程调用
cloud 是基于 http rest api 调用

Spring Boot和 Spring Cloud区别
spring boot 是一个快速整合第三方框架 关注的是 微观 具体关注快速方便的开发单个个体的 服务
spring cloud 关注的是 宏观 具体关注全局的微服务协调整理治理框架 将spring boot 开发的一个个单体服务整合 并管理起来

什么是服务熔断?
服务熔断 是指 由于某些原因使得服务出现了过载现象，为防止造成整个系统故障，从而采用的一种保护措施，所以很多地方把熔断亦称为过载保护。

说下你在项目开发中碰到的坑你所知道的微服务技术栈有哪些?
1 服务开发 ：spring boot spring mvc spring
2 服务的配置与管理 ： netfix 公司 archaius 阿里的diamond等
3 服务的注册于发现 ：spriing cloud 所采用的 eureka ，consul,zookeeper 等
4 服务的调用:rest GRPC RPC
5 服务的熔断器 ：hystrix envoy等
6 负载均衡 ：ribbon .nginx
7 服务接口调用(客户端调用服务的简化工具) Feign等消息队列Kafka、 Rabbitmq、 Activemq等
8 服务配置中心管理Spring Cloud Config、Chef等服务路由(API网关)Zuu等
9 服务监控Zabbix、 Nagios、 Metrics、 Spectator等
10 全链路追踪Zipkin, Brave、 Dapper等
11 服务部罟Docker、 Open Stack、 Kubernetes等
12 数据流操作开发包Spring Cloud Stream(封装与 Redis, Rabbit

ribbon和feign区别
Ribbon添加maven依赖 spring-starter-ribbon 使用@RibbonClient(value=“服务名称”) 使用RestTemplate调用远程服务对应的方法
feign添加maven依赖 spring-starter-feign 服务提供方提供对外接口 调用方使用 在接口上使用@FeignClient(“指定服务名”)

Ribbon和Feign的区别：
Ribbon和Feign都是用于调用其他服务的，不过方式不同。
1.启动类使用的注解不同，Ribbon用的是@RibbonClient，Feign用的是@EnableFeignClients。
2.服务的指定位置不同，Ribbon是在@RibbonClient注解上声明，Feign则是在定义抽象方法的接口中使用@FeignClient声明。
3.调用方式不同，Ribbon需要自己构建http请求，模拟http请求然后使用RestTemplate发送给其他服务，步骤相当繁琐。
Feign则是在Ribbon的基础上进行了一次改进，采用接口的方式，将需要调用的其他服务的方法定义成抽象方法即可，
不需要自己构建http请求。不过要注意的是抽象方法的注解、方法签名要和提供服务的方法完全一致。

断路由
当一个服务调用另一个服务由于网络原因或自 原因出现问题，调用者就会等 调用者的响应 当更多的服务请求到这些资源导致更多的请求等待，发生连锁效应（雪崩效应）
断路器有完全打开状态:一段时间内 到一定的次数无法调用 并且多次监 没有恢复的迹象 断路器完全打开 那么下次请求就不会请求到该服务
半开:短时间内 有恢复迹象 断路器会将部分请求发给该服务，正常调用时 断路器关闭
关闭：当服务一直处于正常状 能正常调用

springcloud如何实现服务的注册和发现
服务在发布时 指定对应的服务名（服务名包括了IP地址和端口） 将服务注册到注册中心（eureka或者zookeeper）
这一过程是springcloud自动实现 只需要在main方法添加@EnableDisscoveryClient 同一个服务修改端口就可以启动多个实例
调用方法：传递服务名称通过注册中心获取所有的可用实例 通过负载均衡策略调用（ribbon和feign）对应的服务

服务注册和发现是什么意思
当我们开始一个项目时，我们通常在属性文件中进行所有的配置。随着越来越多的服务开发和部署，添加和修改这些属性变得更加复杂。有些服务可能会下降，而某些位置可能会发生变化。手动更改属性可能会产生问题。 Eureka 服务注册和发现可以在这种情况下提供帮助。由于所有服务都在 Eureka 服务器上注册并通过调用 Eureka 服务器完成查找，因此无需处理服务地点的任何更改和处理。