冲冲冲冲冲

java基础

面向对象

集合

线程

异常

反射

MySQL

SpringMVC

1.SpringMVC常用的注解有哪些？

2.说说你对Spring MVC的理解

Spring

1. spring是什么？

2.Autowired和Resource关键字的区别？

3.说说你对Spring的IOC是怎么理解的？

3.谈谈你对Spring的AOP理解

4.什么是通知呢？有哪些类型呢？

5.Spring基于xml注入bean的几种方式?

6.Spring框架中都用到了哪些设计模式？

7.BeanFactory和ApplicationContext有什么区别？

8.什么是循环依赖，Spring 是怎么解决循环依赖的？

9.解释一下spring bean的生命周期

10.说说spring事务的隔离级别

11.Spring 事务实现方式

Mybatis

1.什么是MyBatis

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

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

4.mybtis的常见封装策略

5.Mybatis中的转义标签

6.如何批量处理相同的多个数据

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

8.resultType和resultMap的区别

9.MyBatis实现一对一有几种方式?具体怎么操作的？

10.说说Mybatis的缓存机制:

Redis

1.什么是 Redis？

2.redis常用五种数据类型？

3.Redis 持久化方式有哪些？以及有什么区别？

4.如何选择redis的持久化方式

5.怎么使用 Redis 实现消息队列？

6.什么是BigKey？怎么解决

7.什么是redis缓存雪崩，怎么解决？

8.什么是缓存穿透，怎么解决？

9.什么是缓存击穿，怎么解决

Nginx

1.简述一下什么是Nginx

2.反向代理

3.负载均衡

4.负载均衡中还有三大策略

5.动静分离

RabbitMQ

1.为什么要使用MQ

2.RabbitMQ的工作模式

3.如何保证消息的可靠传输？如果消息丢了怎么办

4.怎么解决当一个消费方在处理一个消息时过长时，MQ还是会采用轮询的方式对多个消费方进行发送消息

5.如何保证消息的顺序性

SpringCloud

java基础

面向对象

1.重载和重写的区别

/*重载: 发生在同一个类中,方法名必须相同。参数列表必须不同(个数不同、类型不同、参数排序不同)。
     方法的返回类型、修饰符可以相同也可以不同。但是仅仅是返回类型不同就不是重载*/
     
重写: 发生在父子类中。遵循两同、两小、一大的注意事项。
      两同:方法名、参数列表相同。
      两小: 子类返回值范围、异常抛出范围要小于等于父类
      一大: 子类的访问修饰符范围要大于等于父类。如果父类的方法修饰符是private,子类不能重写此方法

2.什么是面向对象

对比面向过程，是两种不同的处理问题的角度。
面向过程更注重事情的每一个步骤及顺序
面向对象更注重事情有哪些参与者（对象）、及各自需要做什么
面向对象的三大特性:
    封装：该藏的藏、该漏的漏。隐藏对象的属性和实现细节，仅仅对外提供公共的方法（get、set）
    继承：可以使子类具有父类的属性和方法，还可以在子类中重新定义，追加属性和方法
    多态：同一对象在不同时刻具有不同的状态。
    多态的前提：1.有继承或实现关系 2.有方法重写 3.有父类引用指向子类对象

3.==和equals比较

==对比的是栈中的值，基本数据类型是变量值，引用类型是堆中内存对象的地址
equals：Object类中默认也是采用==比较的，如果没有重写，equals与==没有什么区别。如果重写，则比较的是内容。在String底层默认是重写了euqals方法的

4.String、StringBuffer、StringBuilder

String 是不可变类，String对象一旦被创建，其值不能被改变。每次操作都会产生新的String对象
StringBuffer、StringBuilder是可变类，都是在原对象上操作的。不会产生新的对象
在线程方面：因为StringBuffer的方法都是synchronized修饰的，所以它是线程安全的，而StringBuilder是线程不安全的。
在性能方面：StringBuilder > StringBuffer > String

5.接口和抽象类的区别

抽象类只能继承一个，接口可以实现多个。
抽象类中可以存在普通方法，半普半抽、全抽。接口在jdk7及以前只能存在抽象方法、jdk8之后还可以存在默认方法
抽象类中的成员变量可以是各种类型的，而接口的成员变量只能是public static final 类型的
抽象类表达的是is a的关系，主要实现代码的复用性
接口表达的是like a 的关系，主要表达的是对类的行为进行约束

6.Java 创建对象有几种方式

1.使用new关键字                                      eg:User user=new User();
2.使用反射方式创建对象,使用 newInstance()               eg:
3.使用克隆clone()方法创建对象
4.使用反序列化创建对象

集合

1.List

元素有序，按照对象存入的顺序保存对象；可重复，允许多个Null元素对象。
可以使用迭代器(Iterator)取出所有元素，再逐一遍历。
也可以使用get(int index)获取指定下标的元素

2.Set

元素无序，不可重复，最多允许有一个null元素对象，只能使用迭代器取得所有元素，再逐一遍历各个元素

3.ArrayList 、LinkedList、Vector的区别

ArrayList : 底层封装了Object类型的数组,属于连续内存存储,适合下标随机访问,故查询快，增删慢。
			因为源码中没有synchronized关键字，线程是不安全的。
			其扩容机制采用的是位运算符的形式。
			当创建ArrayList对象时，如果使用的是无参构造方法，初始容量为0,第一次扩容为10,再扩容为其1.5倍
			如果使用的是指定大小的有参构造方法，则初始容量为指定大小，再扩容依旧是其1.5倍
LinkedList: 底层维护了一个双向循环链表和双端队列，链表中的每一个元素都使用引用的方式来记住它的前一个元素和后一个元素，从而将所			有元素连接起来。当插入、删除一个元素时,只需要修改元素之间的引用关系即可，故增删快，查询慢。
			因为源码中没有synchronized关键字，线程是不安全的。
		    遍历LinkedList的时候，必须使用迭代器，不能使用for循环。因为for循环使用get()获取一个元素时,都需要给linkedList			 重新遍历一次，消耗大
Vector:
		线程是同步的，即线程安全。因为其操作方法有synchronized关键字,但是效率慢
		其底层是Object类型的数组,扩容机制采用的是三元运算符，即原数组长度+原数组长度

4.HashMap

线程不安全,key、value结构,key值不允许重复，如果重复，对应的value会被覆盖,value无序，允许key和value为null
HashMap的底层实现在jdk8之前是数组+链表实现。jdk开始链表高度到8、数组长度超过64，链表转变为红黑树。
实现流程是：
	1. 添加一个元素时，会先得到其hash值，再转换成索引值
    2. 然后存储数据表table，看这个索引值对应的位置有没有元素
    3. 没有的话，直接加入。
    4. 有的话，通过equals比较，如果相同，放弃添加。如果不相同，添加到已存放元素后面，形成链表
    5. 当链表长度>=8 并且table>=64时，会进化成红黑树
扩容机制为：第一次扩容到16，当元素到达其临界值12时，再次扩容为其2倍

5.Hashtable

线程安全;key、value不能为null;底层是数组+链表+树的结构;初始容量为11，扩容到初始容量的2倍+1

6.ConcurrentHashMap

线程

1.Java中实现多线程有几种方法

1.继承Thread类
2.实现Runable接口
3.实现Callable接口(实现Runnable接口与实现Callable接口的方式基本相同,只是Callable接口里定义的方法返回值,可以声明抛出异
常)
4.线程池的方式创建

2.如何停止一个正在运行的线程

1.使用退出标志,使线程正常退出，也就是当run方法完成后线程终止；
2.使用interrupt方法中断线程 ；
3.使用stop方法强行终止（不推荐使用该方法，目前该方法已作废）。

3.并发的三大特性

原子性：在一个操作中cpu不可以在中途暂停然后再调度，即不被中断操作，要不全部执行完成，要 不都不执行。就好比转账，从账户A向账户B转1000元，那么必然包括2个操作：从账户A减去1000元， 往账户B加上1000元。2个操作必须全部完成
关键字：synchronized

可见性：当多个线程访问同一个变量时，一个线程修改了这个变量的值，其他线程能够立即看得到修改的值。
关键字：volatile、synchronized、final

有序性：虚拟机在进行代码编译时，对于那些改变顺序之后不会对最终结果造成影响的代码，虚拟机不一定会按 照我们写的代码的顺序来执行，有可能将他们重排序。实际上，对于有些代码进行重排序之后，虽然对 变量的值没有造成影响，但有可能会出现线程安全问题
关键字：volatile、synchronized

4.为什么调用是start方法，而不是run方法

因为调用start方法是启动线程，再去调用start0方法，再由start0方法调用线程类的run方法。
而直接调用run方法的话，run方法其实就是一个普通的方法，没有真正的启动线程，会把run方法执行完，才会先下执行

5.线程的生命周期、线程有几种状态

线程通常有七种状态，创建，就绪，运行、阻塞、等待状态、超时等待状态和死亡状态。
1.新建状态（New）：新创建了一个线程对象。 
2.就绪状态（Runnable）：线程对象创建后，其他线程调用了该对象的start方法。该状态的线程位于 可运行线程池中，变得可运行，等待获取CPU的使用权。 
3.运行状态（Running）：就绪状态的线程获取了CPU，执行程序代码。 
4.阻塞状态（Blocked）：也叫同步阻塞，运行的线程在获取对象的同步锁时，若该同步锁被别的线程占用，则JVM会把该线程放 入“锁池”中，等待获得锁，再次进入就绪状态。
5. 等待状态：运行的线程执行wait方法，该线程会释放占用的所有资源，JVM会把该线程放入“等待 池”中。进入这个状态后，是不能自动唤醒的，必须依靠其他线程调用notify或notifyAll方法才能被唤醒，唤醒后再次进入就绪状态
6. 超时等待状态：运行的线程执行sleep或join方法或者发出了I/O请求时，JVM会把该线程设置为超时等待状态，当sleep状态超时、join等待线程终止或者超时、或者I/O处理完毕时，线程重新转入就绪状态
7.死亡状态（Dead）：线程执行完了或者因异常退出了run方法，该线程结束生命周期。

6.请说出与线程同步以及线程调度相关的方法

1.wait():使一个线程处于等待状态，并且释放所持有的对象的锁
2.sleep(): 是一个正在运行的线程处于超时等待状态
3.notify():唤醒一个处于等待状态的线程
4.notifyAll():唤醒所有处于等待状态的线程

7.sleep()和wait()有什么区别？

两者都可以暂停线程的执行
	sleep()方法，是属于Thread类中的。wait()方法，属于Object类中的
	sleep()不释放锁,wait()释放锁
	wait()方法被调用后，线程不会自动苏醒，需要别的线程调用同一个对象上notify()或者notifyAll()
	sleep()方法执行完成后，线程会自动苏醒

8.如何保证多线程的运行安全

1.使用自动锁synchronized
2.使用安全类.eg:原子类：AtomicInteger
3.使用手动锁Lock

9.自己是怎么使用synchronized关键字

1. 修饰实例方法: 作用于当前对象实例加锁，进入同步代码前要获得当前对象实例的锁
2. 修饰静态方法: 也就是给当前类加锁，会作用于类的所有对象实例
3.修饰代码块: 指定加锁对象，对给定对象加锁，进入同步代码库前要获得给定对象的锁

异常

1.平时是怎么处理 Java 异常的

try-catch-finally
try 块负责监控可能出现异常的代码
catch 块负责捕获可能出现的异常，并进行处理
finally 块负责清理各种资源，不管是否出现异常都会执行
其中 try 块是必须的，catch 和 finally 至少存在一个标准异常处理流

2.throws和throw的区别

throws关键字通常被应用在声明方法时，用来指定可能抛出的异常。多个异常可以使用逗号隔开。
throw关键字通常用在方法体中，并且抛出一个异常对象。

3.try-catch-finally中，如果catch中return了，finally还会执行嘛

会,因为不管有没有异常,finally中的代码都会执行。

4.常见的异常类有哪些？

1.空指针异常
2.SQLException
3.数据下标越界异常
4.IO异常

IO

反射