java基础
1、equals 和== 区别
equals比较的是值,==比较是地址对象
2、java集合有哪些 有什么区别?优点 原理、底层数据结构、数据扩展时数据结构变化模型
例如:arrayList 、linkedList
1.ArrayList是实现了基于动态数组的数据结构,LinkedList是基于链表结构。
2.对于随机访问的get和set方法,ArrayList要优于LinkedList,因为LinkedList要移动指针。
3.对于新增和删除操作add和remove,LinkedList比较占优势,因为ArrayList要移动数据
详解:
1.对ArrayList和LinkedList而言,在列表末尾增加一个元素所花的开销都是固定的。对 ArrayList而言,主要是在内部数组中增加一项,指向所添加的元素,偶尔可能会导致对数组重新进行分配;而对LinkedList而言,这个开销是 统一的,分配一个内部Entry对象。
2.在ArrayList集合中添加或者删除一个元素时,当前的列表所所有的元素都会被移动。而LinkedList集合中添加或者删除一个元素的开销是固定的。
3.LinkedList集合不支持 高效的随机随机访问(RandomAccess),因为可能产生二次项的行为。
4.ArrayList的空间浪费主要体现在在list列表的结尾预留一定的容量空间,而LinkedList的空间花费则体现在它的每一个元素都需要消耗相当的空间
总结:arrayList 在数据读取性能较好,linkedList在add 和remove 性能较好
hashMap、hashTable、currenthashMap
HashTable 线程安全
底层数组+链表实现,无论key还是value都不能为null,线程安全,实现线程安全的方式是在修改数据时锁住整个HashTable,效率低,ConcurrentHashMap做了相关优化
初始size为11,扩容:newsize = olesize2+1
计算index的方法:index = (hash & 0x7FFFFFFF) % tab.length
HashMap 线程不安全 key 和value 可以空
底层数组+链表实现,可以存储null键和null值,线程不安全
初始size为16,扩容:newsize = oldsize2,size一定为2的n次幂
扩容针对整个Map,每次扩容时,原来数组中的元素依次重新计算存放位置,并重新插入
插入元素后才判断该不该扩容,有可能无效扩容(插入后如果扩容,如果没有再次插入,就会产生无效扩容)
当Map中元素总数超过Entry数组的75%,触发扩容操作,为了减少链表长度,元素分配更均匀
计算index方法:index = hash & (tab.length – 1)
ConcurrentHashMap是线程安全且高效的HashMap
1 为什么要使用ConcurrentHashMap
线程不安全的HashMap
HashMap是Java中最常用的一个Map类,00000性能好、速度快,但不能保证线程安全,它可用null作为key/value
在多线程环境下,使用HashMap进行put操作会引起死循环,所以在并发情况下不能使用HashMap.例如,执行以下代码会引起死循环.
在JDK1.7版本中,ConcurrentHashMap的数据结构是由一个Segment数组和多个HashEntry组成,如下图所示:
图片: https://images2018.cnblogs.com/blog/981978/201803/981978-20180326222203010-1538132747.png
JDK1.8的实现
JDK1.8的实现已经摒弃了Segment的概念,而是直接用Node数组+链表+红黑树的数据结构来实现,并发控制使用Synchronized和CAS来操作,整个看起来就像是优化过且线程安全的HashMap,虽然在JDK1.8中还能看到Segment的数据结构,但是已经简化了属性,只是为了兼容旧版本。
图片: https://images2018.cnblogs.com/blog/981978/201803/981978-20180326222301021-637978199.png
ConcurrentHashMap
底层采用分段的数组+链表实现,线程安全
通过把整个Map分为N个Segment,可以提供相同的线程安全,但是效率提升N倍,默认提升16倍。(读操作不加锁,由于HashEntry的value变量是 volatile的,也能保证读取到最新的值。)
Hashtable的synchronized是针对整张Hash表的,即每次锁住整张表让线程独占,ConcurrentHashMap允许多个修改操作并发进行,其关键在于使用了锁分离技术
有些方法需要跨段,比如size()和containsValue(),它们可能需要锁定整个表而而不仅仅是某个段,这需要按顺序锁定所有段,操作完毕后,又按顺序释放所有段的锁
扩容:段内扩容(段内元素超过该段对应Entry数组长度的75%触发扩容,不会对整个Map进行扩容),插入前检测需不需要扩容,有效避免无效扩容
在多线程并发访问一个共享变量时,为了保证逻辑的正确,可以采用以下方法:
加锁,性能最低,能保证原子性、可见性,防止指令重排;
volatile修饰,性能中等,能保证可见性,防止指令重排;
使用getObjectVolatile,性能最好,可防止指令重排;
因此ConcurrentHashMap选择了使用Unsafe的getObjectVol
3、session 和cookie 区别?
session数据放在服务器上,cookie则放在客户浏览器上。cookie不太安全,因为可以分析出本地cookie,并进行cookie欺骗,考虑安全应使用session。session会在一定时间内保存在服务器上,当访问增多时,会比较占用服务器的性能,考虑减轻服务器压力则应该使用cookie。单个cookie保持的数据不超过4k,很多浏览器都限制要给站点最多保存20个cookie。
4、get、post、put 区别?
get是从服务器上获取数据,post是向服务器发送数据。
get是把参数数据队列加到提交表单的action属性所指的URL中,值和表单内各个字段一一对应,在url中可以看到。post是通过HTTPpost机制,将表单内各个字段与其内容放置在html header内一起传送到action属性所指的url地址。
对于get方式,服务区端用request.QueryString获取变量值,对于post方式,服务器端用request.Form获取提交的数据。get传送的数据量较小,post较大,一般不受限制。get安全性比post要低,但执行效率较高
put 相当于update 数据库操作,修改类型的接口
5、jvm 模型 垃圾回收
JVM的堆空间中主要分为年轻代、年老代和永久代。年轻代和年老代是存储动态产生的对象。永久代主要是存储java类信息,包括解析得到的方法属性、字段等等。永久代基本不参与垃圾回收。年轻代分为一个eden区和两个相同的survior区。刚开始创建的对象都放置在eden区。这样主要是为了将生命周期短的对象尽量留在年轻代中。当eden区申请不到空间时,进行minorGC,把存活的对象拷贝到survior。年老代主要存放生命周期比较长的对象,如缓存对象。具体JVM垃圾回收过程如下:
1、对象在Eden区完成内存分配。2、当Eden区满了,在创建对象就会申请不到空间,则触发minorGC,进行young(eden区和1survivor区的垃圾回收)。3、在minorGC时,Eden不能被回收的对象呗放入到空的survior(即Eden肯定被清空),另一个survivor里不能被GC回收的地想也会被放入到这个survivor,始终保证一个survivor是空的。4、当完成第三步的时候、如果发现survivor满了,则这些对象呗copy到old区,或者survivor并没有满,但有些对象已经足够old了,也被放入到old区。当old区北放满之后,进行fullGC。
6、接口与抽象类的区别?
1:抽象类可以通过子类间接实例化,接口不能实例化,所以接口不占用堆空间,抽象类占用堆空间。
2:抽象类可以拥有私有属性、方法,接口不能拥有。
3:抽象类方法不能使用default关键字 修饰,接口方法可以。
3:抽象类只能被extends不能被implements,接口可以被implements和extends
5:接口没有构造方法,抽象方法有。接口调用newInstance()抛出java.lang.NoSuchMethodException: Test2.(),抽象类抛出java.lang.InstantiationException
7:接口所有变量都是public static final 不可变, 抽象类可以使用任意权限修饰符修饰变量。
8:抽象类不能多extends,接口可以多extends
9:抽象类抽象方法可以被public, protected修饰,接口抽象类只能被public 修饰
10:private 可以修饰内部类,private 不能修饰内部接口
11:接口支持lambda表达式@FunctionInterface,抽象类不支持
总结:接口优于抽象类,在编写代码代码的时候优先考虑使用接口
7、Java中的异常有哪几类?分别怎么使用?
Throwable包含了错误(Error)和异常(Excetion两类)
Exception又包含了运行时异常(RuntimeException, 又叫非检查异常)和非运行时异常(又叫检查异常)
(1) Error是程序无法处理了, 如果OutOfMemoryError、OutOfMemoryError等等, 这些异常发生时, java虚拟机一般会终止线程 .
(2) 运行时异常都是RuntimeException类及其子类,如 NullPointerException、IndexOutOfBoundsException等, 这些异常是不检查的异常, 是在程序运行的时候可能会发生的, 所以程序可以捕捉, 也可以不捕捉. 这些错误一般是由程序的逻辑错误引起的, 程序应该从逻辑角度去尽量避免.
(3) 检查异常是运行时异常以外的异常, 也是Exception及其子类, 这些异常从程序的角度来说是必须经过捕捉检查处理的, 否则不能通过编译.
8、final/finally/finalize的区别?
final用于声明属性,方法和类,分别表示属性不可交变,方法不可覆盖,类不可继承。
finally是异常处理语句结构的一部分,表示总是执行。
finalize是Object类的一个方法,在垃圾收集器执行的时候会调用被回收对象的此方法,供垃圾收集时的其他资源回收,例如关闭文件等。
9、String/StringBuffer/StringBuilder的区别,扩展再问他们的实现?
可以在源码中看到,String类是被定义为final的,而StringBuffer和StringBulider不是
举个例子
String a=“asd”;//假设a指向了0x00001的地址
假如再 a=“saf”;//假设saf的地址是0x00002
此时,a是指向0x00002地址,而不是0x00001地址
a="saf"相当于新产生了一个String对象,而0x00001的“asd”对象还存在
而如果是用 StringBuilder或者StringBuffer进行上述操作,a还是指向0x00001地址,只是将其上的内容改了,并没有产生新的对象
其次String和StringBuffer是线程安全的,而StringBuilder是非线程安全的
String因为是定义为final的,所以是线程安全的,而StringBuffer加了同步锁,所以也是线程安全的。
最后String是java.lang.String而StringBuffer和StringBuilder都是继承自AbstractStringBuilder(是一个抽象类)所以StringBuffer和StringBulider拥有共同的方法,比如append
10、String s = new String(“abc”);创建了几个 String Object?
2个
算法
1、排序都有哪几种方法?
冒泡法排序
- 比较相邻的元素。如果第一个比第二个小,就交换他们两个。
- 对每一对相邻元素作同样的工作,从开始第一对到结尾的最后一对。在这一点,最后的元素应该会是最小的数。
- 针对所有的元素重复以上的步骤,除了最后一个。
- 持续每次对越来越少的元素重复上面的步骤,直到没有任何一对数字需要比较。
快速排序
- 从数列中挑出一个元素,称为“基准”
- 重新排序数列,所有元素比基准值小的摆放在基准前面,所有元素比基准值大的摆在基准的后面(相同的数可以到任一边)。在这个分割之后,
- 该基准是它的最后位置。这个称为分割(partition)操作。
- 递归地把小于基准值元素的子数列和大于基准值元素的子数列排序。
public static void quickSort(int[] numbers, int start, int end) {
if (start < end) {
int base = numbers[start]; // 选定的基准值(第一个数值作为基准值)
int temp; // 记录临时中间值
int i = start, j = end;
do {
while ((numbers[i] < base) && (i < end))
i++;
while ((numbers[j] > base) && (j > start))
j–;
if (i <= j) {
temp = numbers[i];
numbers[i] = numbers[j];
numbers[j] = temp;
i++;
j–;
}
} while (i <= j);
if (start < j)
quickSort(numbers, start, j);
if (end > i)
quickSort(numbers, i, end);
}
}
选择排序
- 在未排序序列中找到最小元素,存放到排序序列的起始位置
- 再从剩余未排序元素中继续寻找最小元素,然后放到排序序列起始位置。
- 以此类推,直到所有元素均排序完毕。
/**
- 插入排序
- 从第一个元素开始,该元素可以认为已经被排序
- 取出下一个元素,在已经排序的元素序列中从后向前扫描
- 如果该元素(已排序)大于新元素,将该元素移到下一位置
- 重复步骤3,直到找到已排序的元素小于或者等于新元素的位置
- 将新元素插入到该位置中
- 重复步骤2
- @param numbers
*/
public static void insertSort(int[] numbers) {
int size = numbers.length, temp, j;
for(int i=1; i<size; i++) {
temp = numbers[i];
for(j = i; j > 0 && temp < numbers[j-1]; j–)
numbers[j] = numbers[j-1];
numbers[j] = temp;
/**
- 归并排序
- 申请空间,使其大小为两个已经排序序列之和,该空间用来存放合并后的序列
- 设定两个指针,最初位置分别为两个已经排序序列的起始位置
- 比较两个指针所指向的元素,选择相对小的元素放入到合并空间,并移动指针到下一位置
- 重复步骤3直到某一指针达到序列尾
- 将另一序列剩下的所有元素直接复制到合并序列尾
- @param numbers
*/
public static void mergeSort(int[] numbers, int left, int right) {
int t = 1;// 每组元素个数
int size = right - left + 1;
while (t < size) {
int s = t;// 本次循环每组元素个数
t = 2 * s;
int i = left;
while (i + (t - 1) < size) {
merge(numbers, i, i + (s - 1), i + (t - 1));
i += t;
}
if (i + (s - 1) < right)
merge(numbers, i, i + (s - 1), right);
}
}
4、linux 查看端口命令:
(1)lsof -i:8000
(2)netstat -tunlp |grep 端口号
5、linux 监控cpu 工具
mpstat: mpstat 不但能查看所有CPU的平均信息,还能查看指定CPU的信息。
vmstat:只能查看所有CPU的平均信息;查看cpu队列信息;
iostat: 只能查看所有CPU的平均信息。
sar: 与mpstat 一样,不但能查看CPU的平均信息,还能查看指定CPU的信息。
top:显示的信息同ps接近,但是top可以了解到CPU消耗,可以根据用户指定的时间来更新显示。
5、常见Hash算法,哈希的原理和代价
- 加法Hash;
- 位运算Hash;
- 乘法Hash;
- 除法Hash;
- 查表Hash;
- 混合Hash;
数据库
1、sql注入,防止注入
sql 注入就是通过表单形式向程序填写sql段,会给程序带来灾难性毁灭,
防止注入可以用:
1.简单方式PreparedStatement
2.使用正则表达式过滤传入的参数
3.字符串过滤
4.jsp中调用该函数检查是否包函非法字符
5.jsp 页面正则过滤
2、数据库事务隔离级别
ACID特性
四中隔离级别:
① Serializable (串行化):可避免脏读、不可重复读、幻读的发生。
② Repeatable read (可重复读):可避免脏读、不可重复读的发生。
③ Read committed (读已提交):可避免脏读的发生。
④ Read uncommitted (读未提交):最低级别,任何情况都无法保证。
脏读:是指在一个事务处理过程里读取了另一个未提交的事务中的数据。
不可重复读:是指在对于数据库中的某个数据,一个事务范围内多次查询却返回了不同的数据值,这是由于在查询间隔,被另一个事务修改并提交了。
例如事务T1在读取某一数据,而事务T2立马修改了这个数据并且提交事务给数据库,事务T1再次读取该数据就得到了不同的结果,发送了不可重复读。
不可重复读和脏读的区别是,脏读是某一事务读取了另一个事务未提交的脏数据,而不可重复读则是读取了前一事务提交的数据
幻读是事务非独立执行时发生的一种现象。例如事务T1对一个表中所有的行的某个数据项做了从“1”修改为“2”的操作,这时事务T2又对这个表中插入了一行数据项,而这个数据项的数值还是为“1”并且提交给数据库。而操作事务T1的用户如果再查看刚刚修改的数据,会发现还有一行没有修改,其实这行是从事务T2中添加的,就好像产生幻觉一样,这就是发生了幻读。
幻读和不可重复读都是读取了另一条已经提交的事务(这点就脏读不同),所不同的是不可重复读查询的都是同一个数据项,而幻读针对的是一批数据整体(比如数据的个数)。
3、为什么需要锁,锁定分类,锁粒度
数据库锁主要为了控制并发,
锁包括行级锁、表级锁、悲观锁、乐观锁
锁的粒度也就是锁的范围,分为行锁和表锁。锁的范围和多个因素有关,包括事务隔离级别、是否使用索引。
4、乐观锁,悲观锁的概念及实现方式
悲观锁
总是假设最坏的情况,每次去拿数据的时候都认为别人会修改,所以每次在拿数据的时候都会上锁,这样别人想拿这个数据就会阻塞直到它拿到锁(共享资源每次只给一个线程使用,其它线程阻塞,用完后再把资源转让给其它线程)。传统的关系型数据库里边就用到了很多这种锁机制,比如行锁,表锁等,读锁,写锁等,都是在做操作之前先上锁。Java中synchronized和ReentrantLock等独占锁就是悲观锁思想的实现。
乐观锁
总是假设最好的情况,每次去拿数据的时候都认为别人不会修改,所以不会上锁,但是在更新的时候会判断一下在此期间别人有没有去更新这个数据,可以使用版本号机制和CAS算法实现。乐观锁适用于多读的应用类型,这样可以提高吞吐量,像数据库提供的类似于write_condition机制,其实都是提供的乐观锁。在Java中java.util.concurrent.atomic包下面的原子变量类就是使用了乐观锁的一种实现方式CAS实现的。
5、分页如何实现(Oracle,MySql)
6、Mysql引擎
7、MYSQL语句优化
8、从一张大表读取数据,如何解决性能问题
9、内连接,左连接,右连接作用及区别
10、索引以及索引的实现(B+树介绍、和B树、R树区别
多线程
1、进程和线程的区别
根本区别:进程是操作系统资源分配的基本单位,而线程是任务调度和执行的基本单位
在开销方面:每个进程都有独立的代码和数据空间(程序上下文),程序之间的切换会有较大的开销;线程可以看做轻量级的进程,同一类线程共享代码和数据空间,每个线程都有自己独立的运行栈和程序计数器(PC),线程之间切换的开销小。
所处环境:在操作系统中能同时运行多个进程(程序);而在同一个进程(程序)中有多个线程同时执行(通过CPU调度,在每个时间片中只有一个线程执行)
内存分配方面:系统在运行的时候会为每个进程分配不同的内存空间;而对线程而言,除了CPU外,系统不会为线程分配内存(线程所使用的资源来自其所属进程的资源),线程组之间只能共享资源。
包含关系:没有线程的进程可以看做是单线程的,如果一个进程内有多个线程,则执行过程不是一条线的,而是多条线(线程)共同完成的;线程是进程的一部分,所以线程也被称为轻权进程或者轻量级进程。
2、并行和并发的区别和联系
1.并行是在同一时刻执行多个事件,并发是在同一事件段内执行多个事件
2.并行发生在不同的实体上,并发发生在同一个实体上。
并发编程可以充分的利用cpu的,达到最高的处理性能
那为什么并发就能充分利用cpu的执行能力
首先执行多个任务如果是串行执行那么cpu一定会存在等待一个任务执行完去执行下一个任务
但是如果是并发开启多个线程去分别执行不同的任务的时候,这个时候便可以充分的利用cpu,多个线程进行切换去抢占cpu,cpu的空闲时间就会减少。
3、同步与异步
同步交互:指发送一个请求,需要等待返回,然后才能够发送下一个请求,有个等待过程;
异步交互:指发送一个请求,不需要等待返回,随时可以再发送下一个请求,即不需要等待。 区别:一个需要等待,一个不需要等待,在部分情况下,我们的项目开发中都会优先选择不需要等待的异步交互方式。
5、什么叫守护线程
守护线程又被称为“服务进程”“精灵线程”“后台线程”,是指在程序运行是在后台提供一种通用的线程,这种线程并不属于程序不可或缺的部分。 通俗点讲,任何一个守护线程都是整个JVM中所有非守护线程的“保姆”。
用户线程和守护线程几乎一样,唯一的不同之处就在于如果用户线程已经全部退出运行,只剩下守护线程存在了,JVM也就退出了。 因为当所有非守护线程结束时,没有了被守护者,守护线程也就没有工作可做了,也就没有继续运行程序的必要了,程序也就终止了,同时会“杀死”所有守护线程。 也就是说,只要有任何非守护线程还在运行,程序就不会终止。
在Java语言中,守护线程一般具有较低的优先级,它并非只由JVM内部提供,用户在编写程序时也可以自己设置守护线程,例如将一个用户线程设置为守护线程的方法就是在调用start()方法启动线程之前调用对象的setDaemon(true)方法,若将以上括号里的参数设置为false,则表示的是用户进程模式。
6、如何停止一个线程?
-
抛异常法;
-
使用stop方法强行终止线程
-
使用interrupt方法中断线程
-
抛异常法;
-
使用stop方法强行终止线程
-
使用interrupt方法中断线程
7、什么是线程安全?synchronized和 lock的区别synchronized
1.首先synchronized是java内置关键字,在jvm层面,Lock是个java类;
2.synchronized无法判断是否获取锁的状态,Lock可以判断是否获取到锁;
3.synchronized会自动释放锁(a 线程执行完同步代码会释放锁 ;b 线程执行过程中发生异常会释放锁),Lock需在finally中手工释放锁(unlock()方法释放锁),否则容易造成线程死锁;
4.用synchronized关键字的两个线程1和线程2,如果当前线程1获得锁,线程2线程等待。如果线程1阻塞,线程2则会一直等待下去,而Lock锁就不一定会等待下去,如果尝试获取不到锁,线程可以不用一直等待就结束了;
5.synchronized的锁可重入、不可中断、非公平,而Lock锁可重入、可判断、可公平(两者皆可)
6.Lock锁适合大量同步的代码的同步问题,synchronized锁适合代码少量的同步问题。
8、启动一个线程是用run还是start?
9、wait和sleep的区别
10、notify和notifyAll的区别
11、线程池的作用
12、Java中线程池相关的类
WEB安全
1、什么是SQL注入 ,如何避免。
SQL注入:就是通过将sql命令插入到web表单递交或输入域名或页面请求的查询字符串,最终达到欺骗服务器执行恶意SQL命令。如sql命令:select id from test where name=‘1’ or 1=1; drop table test,但用PreparedStatement就可以避免这种问题。
2、什么是XSS攻击,如何避免
XSS 存在的根本原因是,对URL中的参数,对用户输入提交给web server的内容,没有进行充分的过滤。如果我们能够在web程序中,对用户提交的URL中的参数,和提交的所有内容,进行充分的过滤,将所有的不合法的参数和输入内容过滤掉,那么就不会导致“在用户的浏览器中执行攻击者自己定制的脚本”。
XSS防御的总体思路是:对输入(和URL参数)进行过滤,对输出进行编码黑白名单结合。
3、什么是CSRF攻击,如何避免
我们首先来认识一下CSRF。CSRF(Cross-site request forgery)也被称为 one-click attack或者 session riding,中文全称是叫跨站请求伪造。一般来说,攻击者通过伪造用户的浏览器的请求,向访问一个用户自己曾经认证访问过的网站发送出去,使目标网站接收并误以为是用户的真实操作而去执行命令。常用于盗取账号、转账、发送虚假消息等。攻击者利用网站对请求的验证漏洞而实现这样的攻击行为,网站能够确认请求来源于用户的浏览器,却不能验证请求是否源于用户的真实意愿下的操作行为。
2.如何防范?
1.验证 HTTP Referer 字段
2.使用验证码
3.在请求地址中添加token并验证
4.在HTTP 头中自定义属性并验证
编码问题
1、常用的字符编码
2、如何解决中文乱码问题
response.setCharacterEncoding(“UTF-8”);
解决不了,后来又搜到一条解决方法是:
response.setContentType(“text/html;charset=utf-8”);或者 response.setHeader(“content-type”,“text/html;charset=UTF-8”);告诉浏览器用utf-8解析
程序问题:
1、如何防止黑洞狂刷api
拦截器、动态口令校验、token 等
2、如果写个工具类,将对象生成HashMap,如何实现
import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
/**
*
-
类名称:ListToMapUtil
-
类描述: ListToMap
-
创建人:panpan
-
创建时间:2018年1月18日 上午10:29:12
-
@version
*/
public class ListToMapUtil {public static <K, V> Map<K, V> listToMap(List list, String keyMethodName,Class c) {
Map<K, V> map = new HashMap<K, V>();
if (list != null) {
try {
Method methodGetKey = c.getMethod(keyMethodName);
for (int i = 0; i < list.size(); i++) {
V value = list.get(i);
@SuppressWarnings(“unchecked”)
K key = (K) methodGetKey.invoke(list.get(i));
map.put(key, value);
}
} catch (Exception e) {
throw new IllegalArgumentException(“field can’t match the key!”);
}
}return map; }
}
2、ClassLoader如果自己实现?
因为Java中提供的默认ClassLoader,只加载指定目录下的jar和class,如果我们想加载其它位置的类或jar时,比如:我要加载网络上的一个class文件,通过动态加载到内存之后,要调用这个类中的方法实现我的业务逻辑。在这样的情况下,默认的ClassLoader就不能满足我们的需求了,所以需要定义自己的ClassLoader。
定义自已的类加载器分为两步:
1、继承java.lang.ClassLoader
2、重写父类的findClass方法
读者可能在这里有疑问,父类有那么多方法,为什么偏偏只重写findClass方法?
因为JDK已经在loadClass方法中帮我们实现了ClassLoader搜索类的算法,当在loadClass方法中搜索不到类时,loadClass方法就会调用findClass方法来搜索类,所以我们只需重写该方法即可。如没有特殊的要求,一般不建议重写loadClass搜索类的算法。
3、spring和springmvc如何集成
Spring是IOC和AOP的容器框架,SpringMVC是基于Spring功能之上添加的Web框架,想用SpringMVC必须先依赖Spring。
简单点的话可以将SpringMVC类比于Struts。
Spring是IOC和AOP的容器框架,SpringMVC是基于Spring功能之上添加的Web框架,想用SpringMVC必须先依赖Spring。
Spring可以说是一个管理bean的容器,也可以说是包括很多开源项目的总称,spring mvc是其中一个开源项目,所以简单走个流程的话,http请求一到,由容器(如:tomact)解析http搞成一个request,通过映射关系(路径,方法,参数啊)被spring mvc一个分发器去找到可以处理这个请求的bean,那tomcat里面就由spring管理bean的一个池子(bean容器)里面找到,处理完了就把响应返回回去。
SpringMVC是一个MVC模式的WEB开发框架;
Spring是一个通用解决方案, 最大的用处就是通过Ioc/AOP解耦, 降低软件复杂性, 所以Spring可以结合SpringMVC等很多其他解决方案一起使用, 不仅仅只适用于WEB开发
4、为什么要用Redis,Redis有哪些优缺点?Redis如何实现扩容?
redis优势和使用场景
(1) 速度快,因为数据存在内存中,类似于HashMap,HashMap的优势就是查找和操作的时间复杂度都是O(1)
(2) 支持丰富数据类型,支持string,list,set,sorted set,hash
(3) 支持事务,操作都是原子性,所谓的原子性就是对数据的更改要么全部执行,要么全部不执行
(4) 丰富的特性:可用于缓存,消息,按key设置过期时间,过期后将会自动删除
redis和memcatche区别
(1)memcached所有的值均是简单的字符串,redis作为其替代者,支持更为丰富的数据类型
(2) redis的速度比memcached快很多
(3) redis可以持久化其数据
redis 持久化
(1) Master最好不要做任何持久化工作,如RDB内存快照和AOF日志文件
(2) 如果数据比较重要,某个Slave开启AOF备份数据,策略设置为每秒同步一次
(3) 为了主从复制的速度和连接的稳定性,Master和Slave最好在同一个局域网内
(4) 尽量避免在压力很大的主库上增加从库
(5) 主从复制不要用图状结构,用单向链表结构更为稳定,即:Master <- Slave1 <- Slave2 <- Slave3…
这样的结构方便解决单点故障问题,实现Slave对Master的替换。如果Master挂了,可以立刻启用Slave1做Master,其他不变
redis 提供 6种数据淘汰策略:
voltile-lru:从已设置过期时间的数据集(server.db[i].expires)中挑选最近最少使用的数据淘汰
volatile-ttl:从已设置过期时间的数据集(server.db[i].expires)中挑选将要过期的数据淘汰
volatile-random:从已设置过期时间的数据集(server.db[i].expires)中任意选择数据淘汰
allkeys-lru:从数据集(server.db[i].dict)中挑选最近最少使用的数据淘汰
allkeys-random:从数据集(server.db[i].dict)中任意选择数据淘汰
no-enviction(驱逐):禁止驱逐数据
请说明Kafka相对传统技术有什么优势?
Apache Kafka与传统的消息传递技术相比优势之处在于:
快速:单一的Kafka代理可以处理成千上万的客户端,每秒处理数兆字节的读写操作。
可伸缩:在一组机器上对数据进行分区和简化,以支持更大的数据
持久:消息是持久性的,并在集群中进行复制,以防止数据丢失。
设计:它提供了容错保证和持久性
扩容:
存储容量水平扩展,新节点加入或下线的问题解决
主从读写分离
Netty是如何使用线程池的,为什么这么使用
为什么要使用Spring,Spring的优缺点有哪些
消息中间件是如何实现的,技术难点有哪些
Tomcat,apache,jboss的区别
Tomcat是servlet容器,用于解析jsp,servlet。是一个轻量级的高效的容器;缺点是不支持EJB,只能用于Java应用。
Apache是http服务器(web服务器),类似于IIS可以用来建立虚拟站点,编译处理静态页面。支持SSL技术,支持多个虚拟主机等功能。
Jboss是应用服务器,运行EJB的javaee应用服务器,遵循javaee规范,能够提供更多平台的支持和更多集成功能,如数据库连接,JCA等。其对servlet的支持是通过集成其他servlet容器来实现的。如tomcat。
Servlet的生命周期
主要分三个阶段:初始化——调用init()方法,响应客户请求阶段——调用service()方法,终止阶段——调用destroy方法。工作原理:客户发送一个请求,servlet调用service方法对请求进行响应,即对请求方式进行匹配,选择调用doGet、doPost方法等,然后进入对于的方法中调用逻辑层的方法,实现对客户的响应。自定义的servlet必须首先servlet接口。
具体生命周期包括:装载Servlet、服务器创建Servlet实例、服务器调用Servlet的init()方法、客户请求到达服务器、服务器创建请求对象、服务创建相应对象、服务器激活Servlet的service方法,请求对象和响应对象作为service()方法的参数、service()方法获得关于请求对象的信息,处理请求,访问其他资源,获得需要的信息、service()方法可能激活其他方法以处理请求,如doGet(),doPost()
HTTP 报文包含内容
请求方法包括GET,POST,HEAD,PUT,TRACE,OPTIONS,DELETE。请求头如:Host、User-Agent、Connection、Accept-Charset等。请求头部的最后会有一个空行,表示请求头部结束,接下来为请求正文,这一行非常重要,必不可少。请求正文为可选部分,如get就没有。
Statement与PreparedStatement的区别,什么是SQL注入,如何防止SQL注入
使用PreparedStatement可以提升代码的可读性和可维护性,可以尽最大可能提高性能。因为Statement每次执行一个SQL命令都会对其编译,但PreparedStatement则只编译一次。PreparedStatement就类似于流水线生产。另一方面PreparedStatement可以极大提高安全性:它对传递过来的参数进行了强制参数类型转换,确保插入或查询数据时,与底层数据库格式匹配。
SQL注入:就是通过将sql命令插入到web表单递交或输入域名或页面请求的查询字符串,最终达到欺骗服务器执行恶意SQL命令。如sql命令:select id from test where name=‘1’ or 1=1; drop table test,但用PreparedStatement就可以避免这种问题。
redirect, forward区别
redirect:服务器根据逻辑,发送一个状态码,告诉浏览器重新去请求那个地址。所以地址栏显示是新的url。forward是指服务器请求资源,直接访问目标地址url,把响应的内容读取过来并再发送给浏览器,浏览器并不知道资源从哪里来,所以地址栏不变。
redirect不能共享数据,forward转发页面和转发到页面可以贡献request中的数据。redirect用于注销,forward用于登陆。forward效率高于redirect
谈谈Hibernate的理解,一级和二级缓存的作用,在项目中Hibernate都是怎么使用缓存的
一级缓存为session基本的缓存,是内置的不能卸载。一个Session做了一个查询操作,它会把这个结果放在一级缓存中,如果短时间内这个session又做了同一个操作,那么hibernate就直接从一级缓存中获取数据。
!
二级缓存是SessionFactory的缓存,分为内置缓存和外置缓存两类。即查询结果放在二级缓存中,如果同一个sessionFactory创建的某个session执行了相同的操作,hibernate就会从二级缓存中获取结果。适合放在二级缓存中的数据包括:很少被修改的数据,不是很重要的数据,允许出现偶偶并发的数据,不会被并发访问的数据,参考数据。不适合放在二级缓存中的数据:经常被修改的数据,财务数据,绝对不允许出现并发,与其他应用共享的数据。
反射讲一讲,主要是概念,都在哪需要反射机制,反射的性能,如何优化
能够分析类能力的程序称为反射。反射机制可以用来:在运行中分析类的能力,在运行中查看对象,如编写一个toString方法供所有类使用。实现通用的数据操作代码。利用Method对象,这个对象很像C++的指针。
反射性能优化方法主要为设置不用做安全检查。
谈谈Hibernate与Ibatis的区别,哪个性能会更高一些
Ibatis相当较为简单,容易上手,Hibernate比较复杂,门槛较高。如果系统需要处理数据量很大,性能要求很高,需要执行高度优化的sql语句才能达到性能要求,则此时Ibatis会比较好。
对不同数据库支持方面Hibernate较好,因为Ibatis需要修改的字段较多。另外Hibernate现已成为主流的o/r Mapping框架,开发效率高。
Mysql中DDL, DML, DCL, 和TCL是什么?
DDL(Data Definition Languages)语句:数据定义语言,这些语句定义了不同的数据段、数据库、表、列、索引等数据库对象的定义。常用的语句关键字主要包括 create、drop、alter等。
DML(Data Manipulation Language)语句:数据操纵语句,用于添加、删除、更新和查询数据库记录,并检查数据完整性,常用的语句关键字主要包括 insert、delete、udpate 和select 等。(增添改查)
DCL(Data Control Language)语句:数据控制语句,用于控制不同数据段直接的许可和访问级别的语句。这些语句定义了数据库、表、字段、用户的访问权限和安全级别。主要的语句关键字包括 grant、revoke 等。
DDL 语句:
DDL 是数据定义语言的缩写,简单来说,就是对数据库内部的对象进行创建、删除、修改的操作语言。它和 DML 语言的最大区别是 DML 只是对表内部数据的操作,而不涉及到表的定义、结构的修改,更不会涉及到其他对象。DDL 语句更多的被数据库管理员
(DBA)所使用
tcl 链接数据库脚本
· Servlet的生命周期?
实例化,初始init,接收请求service,销毁destroy
关于Cache redis (Ehcache,Memcached)
redis优势和使用场景
(1) 速度快,因为数据存在内存中,类似于HashMap,HashMap的优势就是查找和操作的时间复杂度都是O(1)
(2) 支持丰富数据类型,支持string,list,set,sorted set,hash
(3) 支持事务,操作都是原子性,所谓的原子性就是对数据的更改要么全部执行,要么全部不执行
(4) 丰富的特性:可用于缓存,消息,按key设置过期时间,过期后将会自动删除
redis和memcatche区别
(1)memcached所有的值均是简单的字符串,redis作为其替代者,支持更为丰富的数据类型
(2) redis的速度比memcached快很多
(3) redis可以持久化其数据
redis 持久化
(1) Master最好不要做任何持久化工作,如RDB内存快照和AOF日志文件
(2) 如果数据比较重要,某个Slave开启AOF备份数据,策略设置为每秒同步一次
(3) 为了主从复制的速度和连接的稳定性,Master和Slave最好在同一个局域网内
(4) 尽量避免在压力很大的主库上增加从库
(5) 主从复制不要用图状结构,用单向链表结构更为稳定,即:Master <- Slave1 <- Slave2 <- Slave3…
这样的结构方便解决单点故障问题,实现Slave对Master的替换。如果Master挂了,可以立刻启用Slave1做Master,其他不变
redis 提供 6种数据淘汰策略:
voltile-lru:从已设置过期时间的数据集(server.db[i].expires)中挑选最近最少使用的数据淘汰
volatile-ttl:从已设置过期时间的数据集(server.db[i].expires)中挑选将要过期的数据淘汰
volatile-random:从已设置过期时间的数据集(server.db[i].expires)中任意选择数据淘汰
allkeys-lru:从数据集(server.db[i].dict)中挑选最近最少使用的数据淘汰
allkeys-random:从数据集(server.db[i].dict)中任意选择数据淘汰
no-enviction(驱逐):禁止驱逐数据
请说明Kafka相对传统技术有什么优势?
Apache Kafka与传统的消息传递技术相比优势之处在于:
快速:单一的Kafka代理可以处理成千上万的客户端,每秒处理数兆字节的读写操作。
可伸缩:在一组机器上对数据进行分区和简化,以支持更大的数据
持久:消息是持久性的,并在集群中进行复制,以防止数据丢失。
设计:它提供了容错保证和持久性
Memcache:分布式内存对象缓存系统,占用其他机子的内存。很多互联网,负载均衡三台(以三台为例)web服务器可以共享一台Memcache的资源。传递的信息以键值对的形式存储。传递的数据要实现序列化。
Oscache:页面级缓存(网上强调最多的东西),占用本机的内存资源。可 以选择缓存到硬盘,如存取到硬盘重启服务也可重新获得上次持久化的资源,而如果缓存到内存就不行。一般没必要缓存到硬盘,因为I/O操作也是比较耗资源,和从数据库取往往优势很小。Oscache存取数据的作用域分为application和session两种。
EhCache:Hibernate缓存,DAO缓存,安全性凭证缓存(Acegi),Web缓存,应用持久化和分布式缓存。EhCache在默认情况下,即在用户未提供自身配置文件ehcache.xml或ehcache-failsafe.xml时,EhCache会依据其自身Jar存档包含的ehcache-failsafe.xml文件所定制的策略来管理缓存。如果用户在classpath下提供了ehcache.xml或ehcache-failsafe.xml文件,那么EhCache将会应用这个文件。如果两个文件同时提供,那么EhCache会使用ehcache.xml文件的配置。
sql的优化相关问题
-
对查询优化,避免全表扫描
-
尽量避免where子句中对段进行null值判断,否则将导致引擎放弃使用索引而进行全表扫描。
-
尽量避免where子句中出现!=或<>,否则将导致引擎放弃使用索引而进行全表扫描。
-
尽量避免where子句中出现or来连接条件。
-
慎用in和not in,否则导致全表扫描
-
where中不要用函数操作。
-
Update 语句,如果只更改1、2个字段,不要Update全部字段,否则频繁调用会引起明显的性能消耗,同时带来大量日志。
-
对于多张大数据量(这里几百条就算大了)的表JOIN,要先分页再JOIN,否则逻辑读会很高,性能很差。
-
尽可能的使用 varchar/nvarchar 代替 char/nchar,节省空间,提高查询效率
-
select count(*) from table;这样不带任何条件的count会引起全表扫描,并且没有任何业务意义,是一定要杜绝的
DB中索引原理,种类,使用索引的好处和问题是什么?
原理:因为检索磁盘比对数据,需要大量的时间和IO,所以就需要构造某列的数据的btree、hash值、位图索引。一般的索引能快速的查找比对,而索引的值记录了磁盘的位置,直接读取数据库字段对应位置的内容。
索引好处:加快数据检索速度、加速表与表之间的连接特别是实现数据的参考完整性方面有特别的意义、减少查询中分组和排序的时间,使用优化隐藏器,提高系统性能。
缺点:创建和维护索引需要时间,索引需要占用物理空间,当对表中的数据惊醒增删改时所有也需要动态维护。
框架:
描述一下Hibernate的三个状态?
图片: https://uploader.shimo.im/f/weXyUmHww2sIVRRQ
瞬时 (Transient )/临时状态/自由状态
持久 (Persistent)
脱管 (Detached)
瞬时对象:
如何直接获得 — new 出来
转换到持久态 ---- save、saveOrUpdate 保存操作
转换到脱管态 ---- setId 设置OID持久化标识(这个id是数据库中存在的)
持久对象:
如何直接获得 ---- 通过session查询方法获得 get、load、createQuery、createCriteria
转换到瞬时态 ---- delete 删除操作 (数据表不存在对应记录 )(其实还有id,只是不叫OID)
转换到脱管态 ---- close 关闭Session, evict、clear 从Session清除对象
脱管对象:
如何直接获得 ----- 无法直接获得 ,必须通过瞬时对象、持久对象转换获得
转换到瞬时态 ---- 将id设置为 null,或者手动将数据库的对应的数据删掉
转换到持久态 ---- update、saveOrUpdate、lock (对象重新放入Session ,重新与session关联)
Spring中Bean的生命周期。
生命周期:实例化,初始init,接收请求service,销毁destroy;
Spring上下文中的Bean也类似,如下
1、实例化一个Bean--也就是我们常说的new;
2、按照Spring上下文对实例化的Bean进行配置--也就是IOC注入;
3、如果这个Bean已经实现了BeanNameAware接口,会调用它实现的setBeanName(String)方法,此处传递的就是Spring配置文件中Bean的id值
4、如果这个Bean已经实现了BeanFactoryAware接口,会调用它实现的setBeanFactory(setBeanFactory(BeanFactory)传递的是Spring工厂自身(可以用这个方式来获取其它Bean,只需在Spring配置文件中配置一个普通的Bean就可以);
5、如果这个Bean已经实现了ApplicationContextAware接口,会调用setApplicationContext(ApplicationContext)方法,传入Spring上下文(同样这个方式也可以实现步骤4的内容,但比4更好,因为ApplicationContext是BeanFactory的子接口,有更多的实现方法);
6、如果这个Bean关联了BeanPostProcessor接口,将会调用postProcessBeforeInitialization(Object obj, String s)方法,BeanPostProcessor经常被用作是Bean内容的更改,并且由于这个是在Bean初始化结束时调用那个的方法,也可以被应用于内存或缓存技术;
7、如果Bean在Spring配置文件中配置了init-method属性会自动调用其配置的初始化方法。
8、如果这个Bean关联了BeanPostProcessor接口,将会调用postProcessAfterInitialization(Object obj, String s)方法、;
注:以上工作完成以后就可以应用这个Bean了,那这个Bean是一个Singleton的,所以一般情况下我们调用同一个id的Bean会是在内容地址相同的实例,当然在Spring配置文件中也可以配置非Singleton,这里我们不做赘述。
9、当Bean不再需要时,会经过清理阶段,如果Bean实现了DisposableBean这个接口,会调用那个其实现的destroy()方法;
10、最后,如果这个Bean的Spring配置中配置了destroy-method属性,会自动调用其配置的销毁方法。
· SpringMVC或Struts处理请求的流程。
springMVC 工作流程与介绍
图片: https://images2017.cnblogs.com/blog/1135193/201710/1135193-20171005165210099-1015669941.png
(1)客户端通过url发送请求
(2-3)核心控制器Dispatcher Servlet接收到请求,通过系统或自定义的映射器配置找到对应的handler,并将url映射的控制器controller返回给核心控制器。
(4)通过核心控制器找到系统或默认的适配器
(5-7)由找到的适配器,调用实现对应接口的处理器,并将结果返回给适配器,结果中包含数据模型和视图对象,再由适配器返回给核心控制器
(8-9)核心控制器将获取的数据和视图结合的对象传递给视图解析器,获取解析得到的结果,并由视图解析器响应给核心控制器
(10)核心控制器将结果返回给客户端
struts 工作流程
1)浏览器发出请求
2)控制层中的核心控制器FilterDispatcher根据请求调用相应的Action.
3)Struts2的拦截链(即一系列拦截器)自动对请求调用一些通用的控制逻辑,如数据校验,对数据的封装和文件上传等功能。
4)回调Action中的execute()方法(Action对象的默认方法),并在方法体内调用业务逻辑组件,即自定义的Javabean 等来处理请求,如数据的查询处理等。
5)Execute()方法返回后会产生一个输出。
6)该输出经过拦截器链自动处理,这和开始的拦截器链处理是相反的过程。
7)控制层最后将数据返还并更新视图层。
Spring AOP解决了什么问题?怎么实现的?
1.问题:
代码混乱:越来越多的非业务需求(日志和验证等)加入后, 原有的业务方法急剧膨胀.
每个方法在处理核心逻辑的同时还必须兼顾其他多个关注点.
代码分散: 以日志需求为例, 只是为了满足这个单一需求, 就不得不在多个模块(方法)里多次重复相同的日志代码.
如果日志需求发生变化, 必须修改所有模块.
解决: AOP
AOP(Aspect Oriented Programming),即面向切面编程,
可以说是OOP(Object Oriented Programming,面向对象编程)的补充和完善。
OOP引入封装、继承、多态等概念来建立一种对象层次结构,用于模拟公共行为的一个集合。
不过OOP允许开发者定义纵向的关系,但并不适合定义横向的关系,例如日志功能。
日志代码往往横向地散布在所有对象层次中,而与它对应的对象的核心功能毫无关系对于其他类型的代码,
如安全性、异常处理和透明的持续性也都是如此,这种散布在各处的无关的代码被称为横切(cross cutting),
在OOP设计中,它导致了大量代码的重复,而不利于各个模块的重用。
AOP技术恰恰相反,它利用一种称为"横切"的技术,剖解开封装的对象内部,
并将那些影响了多个类的公共行为封装到一个可重用模块,并将其命名为"Aspect",即切面。
所谓"切面",简单说就是那些与业务无关,却为业务模块所共同调用的逻辑或责任封装起来,
便于减少系统的重复代码,降低模块之间的耦合度,并有利于未来的可操作性和可维护性。
Spring事务的传播属性是怎么回事?它会影响什么?
Require:支持当前事务,如果没有事务,就建一个新的,这是最常见的;
Supports:支持当前事务,如果当前没有事务,就以非事务方式执行;
Mandatory:支持当前事务,如果当前没有事务,就抛出异常;
RequiresNew:新建事务,如果当前存在事务,把当前事务挂起;
NotSupported:以非事务方式执行操作,如果当前存在事务,就把事务挂起;
Never:以非事务方式执行,如果当前存在事务,则抛出异常。
Nested:新建事务,如果当前存在事务,把当前事务挂起。与RequireNew的区别是与父事务相关,且有一个savepoint
影响保证多线程时数据的一致性
Spring中BeanFactory和FactoryBean有什么区别
在Spring中,BeanFactory是IOC容器的核心接口,它的职责包括:实例化、定位、配置应用程序中的对象及建立这些对象间的依赖。
FactoryBean以Bean结尾,表示它是一个Bean,不同于普通Bean的是:它是实现了FactoryBean接口的Bean,根据该Bean的ID从BeanFactory中获取的实际上是FactoryBean的getObject()返回的对象,而不是FactoryBean本身,如果要获取FactoryBean对象,请在id前面加一个&符号来获取。
例如自己实现一个FactoryBean,功能:用来代理一个对象,对该对象的所有方法做一个拦截,在调用前后都输出一行LOG,模仿ProxyFactoryBean的功能。
Spring框架中IOC的原理是什么?
IoC容器启动的三个基本过程
1)Resource资源信息定位
2)BeanDefinition的载入(将资源中的信息初始化为BeanDefinition对象)
3)向IoC容器注册生成的BeanDefinition对象
依赖注入
spring的依赖注入有哪几种方式
ioc new bean 对象
配置文件写bean 对象
构造器set 方式构造bean
bean工厂方式注入
注解方式@ Autowired
· struts工作流程
如当我们在浏览器的地址栏中输入:http://localhost:8080/Struts/TestMvc/add.action,浏览器就会把这个请求发送给tomcat,tomcat接收到这个请求后,会检查一下应该交给哪个web程序处理,现在是交给Struts去处理,然后Struts会去参考此程序下的配置文件web.xml,在web.xml中找到过滤器(Filter),如(ActionContextCleanUp、其他过滤器(SiteMesh等)、 FilterDispatcher),注意这里是有顺序的,先ActionContextCleanUp,再其他过滤器(SiteMesh等)、最后到FilterDispatcher;
FilterDispatcher是控制器的核心,就是mvc中c控制层的核心,FilterDispatcher进行初始化并启用核心 doFilter。FilterDispatcher询问ActionMapper来决定这个请是否需要调用某个Action, 如果 ActionMapper决定需要调用某个Action,FilterDispatcher把请求的处理交给 ActionProxy ,ActionProxy通过struts.xml询问框架的配置文件,找到需要调用的Action类和方法来处理这请求;
Action执行完毕,根据struts.xml中的配置找到对应的返回结果result,并跳转到相应页面,最后返回HTTP响应到客户端浏览器
其实用最简单的七个步骤:
1:客户端在浏览器中输入一个url地址;
2:这个url请求通过http协议发送给tomcat;
3:tomcat根据url找到对应项目里面的web.xml文件;
4:在web.xml里面会发现有struts2的配置;
5:然后会找到struts2对应的struts.xml配置文件;
6:根据url解析struts.xml配置文件就会找到对应的class;
7:调用完class返回一个结果result,根据struts.xml返回到对应的jsp
· 用Spring如何实现一个切面?
1.经典的基于代理的AOP
2.@AspectJ注解驱动的切面
3.纯POJO切面
4.注入式AspectJ切面
· Spring 如何实现数据库事务?
特性:事务具备ACID四种特性,ACID是Atomic(原子性)、Consistency(一致性)、Isolation(隔离性)和Durability(持久性)的英文缩写
Spring事务管理机制的实现原理。由于Spring内置AOP默认使用动态代理模式实现,我们就先来分析一下动态代理模式的实现方 法。动态代理模式的核心就在于代码中不出现与具体应用层相关联的接口或者类引用,如上所说,这个代理类适用于任何接口的实现。
Spring的事务管理机制实现的原理,就是通过这样一个动态代理对所有需要事务管理的Bean进行加载,并根据配置在invoke方法中对当前调用的 方法名进行判定,并在method.invoke方法前后为其加上合适的事务管理代码,这样就实现了Spring式的事务管理。Spring中的AOP实 现更为复杂和灵活
事务实现方式3种:
方式一:通过事务代理工厂bean进行配置[XML方式]
方式二:注解。测试类getBean获取的id是原始对象service
方式三:Aspectj AOP配置事务 。同理 测试类getBean方法id获取的是原始对象
事务:声明方式和代码方式;目前一般都是声明式事务
事务隔离级别4种和传播机制七种
隔离:
1、Serializable :最严格的级别,事务串行执行,资源消耗最大;
2、REPEATABLE READ :保证了一个事务不会修改已经由另一个事务读取但未提交(回滚)的数据。避免了“脏读取”和“不可重复读取”的情况,但是带来了更多的性能损失。
3、READ COMMITTED :大多数主流数据库的默认事务等级,保证了一个事务不会读到另一个并行事务已修改但未提交的数据,避免了“脏读取”。该级别适用于大多数系统。
4、Read Uncommitted :保证了读取过程中不会读取到非法数据
传播:
PROPAGATION_REQUIRED 如果存在一个事务,则支持当前事务。如果没有事务则开启一个新的事务。
PROPAGATION_SUPPORTS 如果存在一个事务,支持当前事务。如果没有事务,则非事务的执行。但是对于事务同步的事务管理器,PROPAGATION_SUPPORTS与不使用事务有少许不同。
PROPAGATION_MANDATORY 如果已经存在一个事务,支持当前事务。如果没有一个活动的事务,则抛出异常。
PROPAGATION_REQUIRES_NEW 总是开启一个新的事务。如果一个事务已经存在,则将这个存在的事务挂起。
PROPAGATION_NOT_SUPPORTED 总是非事务地执行,并挂起任何存在的事务。
PROPAGATION_NEVER 总是非事务地执行,如果存在一个活动事务,则抛出异常
PROPAGATION_NESTED如果一个活动的事务存在,则运行在一个嵌套的事务中. 如果没有活动事务, 则按TransactionDefinition.PROPAGATION_REQUIRED 属性执行
· Hibernate对一二级缓存的使用,Lazy-Load的理解;
一级缓存为session基本的缓存,是内置的不能卸载。一个Session做了一个查询操作,它会把这个结果放在一级缓存中,如果短时间内这个session又做了同一个操作,那么hibernate就直接从一级缓存中获取数据。
二级缓存是SessionFactory的缓存,分为内置缓存和外置缓存两类。即查询结果放在二级缓存中,如果同一个sessionFactory创建的某个session执行了相同的操作,hibernate就会从二级缓存中获取结果。适合放在二级缓存中的数据包括:很少被修改的数据,不是很重要的数据,允许出现偶偶并发的数据,不会被并发访问的数据,参考数据。不适合放在二级缓存中的数据:经常被修改的数据,财务数据,绝对不允许出现并发,与其他应用共享的数据。
· mybatis如何实现批量提交?
以map 方式批量更新
foreach 循环map