当前位置:   article > 正文

一些重要的面试题!_吉他老师面试题

吉他老师面试题

1.

单例模式可能是代码最少的模式了,但是少不一定意味着简单,想要用好、用对单例模式,还真得费一番脑筋。本文对Java中常见的单例模式写法做了一个总结,如有错漏之处,恳请读者指正。

饿汉法

顾名思义,饿汉法就是在第一次引用该类的时候就创建对象实例,而不管实际是否需要创建。代码如下:

1
2
3
4
5
6
7
public class Singleton {  
     private static Singleton = new Singleton();
     private Singleton() {}
     public static getSignleton(){
         return singleton;
     }
}

这样做的好处是编写简单,但是无法做到延迟创建对象。但是我们很多时候都希望对象可以尽可能地延迟加载,从而减小负载,所以就需要下面的懒汉法:

单线程写法

这种写法是最简单的,由私有构造器和一个公有静态工厂方法构成,在工厂方法中对singleton进行null判断,如果是null就new一个出来,最后返回singleton对象。这种方法可以实现延时加载,但是有一个致命弱点:线程不安全。如果有两条线程同时调用getSingleton()方法,就有很大可能导致重复创建对象。

1
2
3
4
5
6
7
8
public class Singleton {
     private static Singleton singleton = null ;
     private Singleton(){}
     public static Singleton getSingleton() {
         if (singleton == null ) singleton = new Singleton();
         return singleton;
     }
}

考虑线程安全的写法

这种写法考虑了线程安全,将对singleton的null判断以及new的部分使用synchronized进行加锁。同时,对singleton对象使用volatile关键字进行限制,保证其对所有线程的可见性,并且禁止对其进行指令重排序优化。如此即可从语义上保证这种单例模式写法是线程安全的。注意,这里说的是语义上,实际使用中还是存在小坑的,会在后文写到。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class Singleton {
     private static volatile Singleton singleton = null ;
 
     private Singleton(){}
 
     public static Singleton getSingleton(){
         synchronized (Singleton. class ){
             if (singleton == null ){
                 singleton = new Singleton();
             }
         }
         return singleton;
     }   
}

兼顾线程安全和效率的写法

虽然上面这种写法是可以正确运行的,但是其效率低下,还是无法实际应用。因为每次调用getSingleton()方法,都必须在synchronized这里进行排队,而真正遇到需要new的情况是非常少的。所以,就诞生了第三种写法:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public class Singleton {
     private static volatile Singleton singleton = null ;
 
     private Singleton(){}
 
     public static Singleton getSingleton(){
         if (singleton == null ){
             synchronized (Singleton. class ){
                 if (singleton == null ){
                     singleton = new Singleton();
                 }
             }
         }
         return singleton;
     }   
}

这种写法被称为“双重检查锁”,顾名思义,就是在getSingleton()方法中,进行两次null检查。看似多此一举,但实际上却极大提升了并发度,进而提升了性能。为什么可以提高并发度呢?就像上文说的,在单例中new的情况非常少,绝大多数都是可以并行的读操作。因此在加锁前多进行一次null检查就可以减少绝大多数的加锁操作,执行效率提高的目的也就达到了。

那么,这种写法是不是绝对安全呢?前面说了,从语义角度来看,并没有什么问题。但是其实还是有坑。说这个坑之前我们要先来看看volatile这个关键字。其实这个关键字有两层语义。第一层语义相信大家都比较熟悉,就是可见性。可见性指的是在一个线程中对该变量的修改会马上由工作内存(Work Memory)写回主内存(Main Memory),所以会马上反应在其它线程的读取操作中。顺便一提,工作内存和主内存可以近似理解为实际电脑中的高速缓存和主存,工作内存是线程独享的,主存是线程共享的。volatile的第二层语义是禁止指令重排序优化。大家知道我们写的代码(尤其是多线程代码),由于编译器优化,在实际执行的时候可能与我们编写的顺序不同。编译器只保证程序执行结果与源代码相同,却不保证实际指令的顺序与源代码相同。这在单线程看起来没什么问题,然而一旦引入多线程,这种乱序就可能导致严重问题。volatile关键字就可以从语义上解决这个问题。

注意,前面反复提到“从语义上讲是没有问题的”,但是很不幸,禁止指令重排优化这条语义直到jdk1.5以后才能正确工作。此前的JDK中即使将变量声明为volatile也无法完全避免重排序所导致的问题。所以,在jdk1.5版本前,双重检查锁形式的单例模式是无法保证线程安全的。

静态内部类法

那么,有没有一种延时加载,并且能保证线程安全的简单写法呢?我们可以把Singleton实例放到一个静态内部类中,这样就避免了静态实例在Singleton类加载的时候就创建对象,并且由于静态内部类只会被加载一次,所以这种写法也是线程安全的:

1
2
3
4
5
6
7
8
9
10
11
public class Singleton {
     private static class Holder {
         private static Singleton singleton = new Singleton();
     }
 
     private Singleton(){}
 
     public static Singleton getSingleton(){
         return Holder.singleton;
     }
}

但是,上面提到的所有实现方式都有两个共同的缺点:

  • 都需要额外的工作(Serializable、transient、readResolve())来实现序列化,否则每次反序列化一个序列化的对象实例时都会创建一个新的实例。
  • 可能会有人使用反射强行调用我们的私有构造器(如果要避免这种情况,可以修改构造器,让它在创建第二个实例的时候抛异常)。

枚举写法

当然,还有一种更加优雅的方法来实现单例模式,那就是枚举写法:

1
2
3
4
5
6
7
8
9
10
public enum Singleton {
     INSTANCE;
     private String name;
     public String getName(){
         return name;
     }
     public void setName(String name){
         this .name = name;
     }
}

使用枚举除了线程安全和防止反射强行调用构造器之外,还提供了自动序列化机制,防止反序列化的时候创建新的对象。因此,Effective Java推荐尽可能地使用枚举来实现单例。

总结

这篇文章发出去以后得到许多反馈,这让我受宠若惊,觉得应该再写一点小结。代码没有一劳永逸的写法,只有在特定条件下最合适的写法。在不同的平台、不同的开发环境(尤其是jdk版本)下,自然有不同的最优解(或者说较优解)。
比如枚举,虽然Effective Java中推荐使用,但是在Android平台上却是不被推荐的。在这篇Android Training中明确指出:

Enums often require more than twice as much memory as static constants. You should strictly avoid using enums on Android.

再比如双重检查锁法,不能在jdk1.5之前使用,而在Android平台上使用就比较放心了(一般Android都是jdk1.6以上了,不仅修正了volatile的语义问题,还加入了不少锁优化,使得多线程同步的开销降低不少)。

最后,不管采取何种方案,请时刻牢记单例的三大要点:

  • 线程安全
  • 延迟加载
  • 序列化与反序列化安全

参考资料

《Effective Java(第二版)》

《深入理解Java虚拟机——JVM高级特性与最佳实践(第二版)》

2.java选择排序,冒泡排序分析,附带二分法查找

冒泡排序和选择排序是排序算法中比较简单和容易实现的算法,也是面试当中经常被考到的题目,所以是必须掌握的!

假设将数组 int[] arr = { 10, 7,11, 3, 2, 9 }; 升序排列

选择排序的思想是:从左到右依次遍历,每次遍历确定一个位置,所有遍历的元素都和这个位置上的数比较

        如上数组,首先10 和 7比较,10比7大,交换位置,这时 7是数组的第一个 ,然后用 7 和 11 比较,7 比 11小,不交换, 然后,7 和 3 比较, 7 比 3 大,交换位置,3是数组的第一个,然后 3 和 比较 ,3 比 2 大,交换位置,2是数组第一个 ,然后 2 和 9 比较 ,2 比 9 大,不交换 ,此时 外层 第一个遍历完成,2排在了数组的第一位,此时的数组是 {2,10,11,7,3,9} ,然后再从第二个元素遍历,10 和 11比较,不换位置,10和7比较 ,换位置,7和 3比较,还位置,3和9比较 换位置,此时的数组是    { 2,3,11,10,7,9}  ,这样一次类推下去,最后形成数组 {2,3,7,9,10,11} ;

[java]  view plain  copy
  1. /* 
  2.  * 选择排序 
  3.  */  
  4. @Test  
  5. public void selectSort() {  
  6.     int[] arr = { 107,11329};  
  7.     for (int i = 0; i < arr.length - 1; i++) { // 循环length-1次, 每次选择一个数放在最前面  
  8.         for (int j = i + 1; j < arr.length; j++) {// 从0循环到length-1, 遍历每一个元素  
  9.             if (arr[i] < arr[j]) { // 用每一个元素和0号元素(第一个)去比较, 如果比第一个小  
  10.                 int one = arr[i];  
  11.                 arr[i] = arr[j];  
  12.                 arr[j] = one;  
  13.             }  
  14.         }  
  15.     }  
  16.     for (int i = 0; i < arr.length; i++) {  
  17.         System.out.print(arr[i]);  
  18.     }  
  19. }  

和上面一样 假设将数组 int[] arr = { 10, 7,11, 3, 2, 9  }; 升序排列

冒泡排序的思想是:每次循环排序中,通过相邻元素的比较交换将最大值移动到右侧;意思就是 ,元素1和元素2比较,然后元素2和元素3比较,再元素3和元素4比较。。。

     如上数组,首先外层第一次循环后 内层循环 先比较 10 和 7 ,10 比 7大,交换位置,然后此时10 和 11比较,10比 11 小,不交换,然后 11 和 3比较 ,交换位置,然后 11和 2 比较,交换位置,然后 11 和 9比较 ,交换位置,外层第一次循环后,数组形式是{7,10,3,2,9,11},然后外层第二次循环,7和 10比较,7比10小,不交换,然后,10和 3 比较,交换位置,然后 10和 2比较,交换位置,然后 10和9 比较,交换位置,此时,因为最后一个元素已经确定为最大数,所以不用比较,因此第二层外层循环结束后,数组形式是:{7,3,2,9,10,11},一次类推,结果是:{2,3,7,9,10,11} ;

[java]  view plain  copy
  1. /** 
  2.  * 冒泡排序 
  3.  */  
  4. @Test  
  5. public void bubbleSort() {  
  6.     int[] arr = { 107,11329 };  
  7.     for (int i = 0; i < arr.length - 1; i++) { // 循环length-1次, 每次冒泡一个数到最后  
  8.         for (int j = 0; j < arr.length - 1 - i; j++) { // 每次从第一个开始, 向后遍历.  
  9.                                    // 第一次到倒数第二个,  
  10.                                    // 第二次到倒数第三个  
  11.             if (arr[j] > arr[j + 1]) { // 用每一个数和后面一个比较, 如果大就交换  
  12.                 int temp = arr[j];  
  13.                 arr[j] = arr[j + 1];  
  14.                 arr[j + 1] = temp;  
  15.             }  
  16.         }  
  17.     }  
  18.     for (int i = 0; i < arr.length; i++) {  
  19.         System.out.println(arr[i]);  
  20.     }  
  21. }  
[java]  view plain  copy
  1. public class Dichotomy  {  
  2.     public static void main(String[] args) {  
  3.         // 定义一个数组  
  4.         int nums[] = { 13689101218203334 };  
  5.         // 欲查询的数字  
  6.         int num = 34;  
  7.         // 输出num在nums中的索引  
  8.         System.out.println("二分法查看数组中某数的索引为:" + dichotomy(nums, num));  
  9.     }  
  10.   
  11.     /** 
  12.      * 二分法查找 
  13.      *  
  14.      * @param nums 
  15.      *            数组 
  16.      * @param num 
  17.      *            查找的数 
  18.      * @return 返回num索引,如果不存在返回-1 
  19.      */  
  20.     public static int dichotomy(int[] nums, int num) {  
  21.         // 数组长度必须大于零  
  22.         if (nums != null && nums.length > 0) {  
  23.             // 开始索引  
  24.             int start = 0;  
  25.             // 结束索引  
  26.             int end = nums.length - 1;  
  27.             // 中间索引  
  28.             int center = (start + end) / 2;  
  29.             // 开始索引不能大于结束索引  
  30.             while (start <= end) {  
  31.                 // 取中间索引值比较,如果相同,返回该索引  
  32.                 if (num == nums[center]) {  
  33.                     return center;  
  34.                 }  
  35.                 // 如果值在center右边或左边,重新定位start或end,重新计算center值  
  36.                 if (num > nums[center]) {  
  37.                     start = center + 1;  
  38.                 }  
  39.                 if (num < nums[center]) {  
  40.                     end = center - 1;  
  41.                 }  
  42.                 center = (start + end) / 2;  
  43.             }  
  44.         }  
  45.         return -1;  
  46.     }  
  47. }  

冒泡排序

思路:就是每次将最大或最小的元素放到数组的最后,so easy!时间复杂度为(O(n^2))
[java]  view plain  copy
  1. public class BubbleSort {  
  2.     public static void bubbleSort(int[] a) {  
  3.         for (int j = 1; j < a.length; j++) {  
  4.             for (int i = 0; i < a.length - j; i++) {  
  5.                 if (a[i] > a[i + 1]) {  
  6.                     int temp = a[i];  
  7.                     a[i] = a[i + 1];  
  8.                     a[i + 1] = temp;  
  9.                 }  
  10.             }  
  11.         }  
  12.     }  
  13.     public static void main(String[] args) {  
  14.         int a[] = { 524572424572424572423723043231241157,  
  15.                 3831 };  
  16.         bubbleSort(a);  
  17.         for(int i = 0; i < a.length; i++){  
  18.             System.out.print(a[i]+" ");  
  19.         }  
  20.     }  
  21. }  

选择排序

思路:类似于冒泡,每次将后面最小的元素放在前面。时间复杂度为((O(n^2)))
[java]  view plain  copy
  1. public class SelectSort {  
  2.     public static void selectSort(int[] a) {  
  3.         int min;  
  4.         for (int i = 0; i < a.length - 1; i++) {  
  5.             min = i;  
  6.             for (int j = min + 1; j < a.length; j++) {  
  7.                 if (a[min] > a[j]) {  
  8.                     int temp = a[min];  
  9.                     a[min] = a[j];  
  10.                     a[j] = temp;  
  11.                 }  
  12.             }  
  13.         }  
  14.     }  
  15.   
  16.     public static void main(String[] args) {  
  17.         int a[] = { 5245724245724245724237,  
  18.                 230432312411573831 };  
  19.         selectSort(a);  
  20.         for (int i = 0; i < a.length; i++) {  
  21.             System.out.print(a[i] + " ");  
  22.         }  
  23.     }  
  24. }  

插入排序

思路:从第二个元素开始,和之前的已排好序的字数组的元素比较,找到合适的位置,然后后面的元素向后移动一位,再将该元素插入到前面合适的位置。时间复杂度为(O(n^2))
[java]  view plain  copy
  1. public class InsertSort {  
  2.     public static void insertSort(int[] a) {  
  3.         for (int i = 1; i < a.length; i++) {  
  4.             int key = a[i];  
  5.             int j = i - 1;  
  6.             while (j >= 0 && a[j] > key) {  
  7.                 a[j+1] = a[j];  
  8.                 j--;  
  9.             }  
  10.             a[j+1] = key;  
  11.         }  
  12.     }  
  13.       
  14.     public static void main(String[] args) {  
  15.         int a[] = { 5245724245724245724237,  
  16.                 230432312411573831 };  
  17.         insertSort(a);  
  18.         for (int i = 0; i < a.length; i++) {  
  19.             System.out.print(a[i] + " ");  
  20.         }  
  21.     }  
  22. }  

二分法排序

思路:插入排序的多此一举,居然先用二分法查找插入位置(多此一举),然后再所有插入位置(二分法查出来的)后面的元素全部后移,太蛋疼了,插入法直接边找边后移多容易啊,这个事蛋疼的做法,下午想了一下做出来。(14、08、3)
[java]  view plain  copy
  1. package sort;  
  2.   
  3. public class BinarySort {  
  4.     public static int binarySerch(int[] arr, int start, int end, int value) {  
  5.         int mid = -1;  
  6.         while (start <= end) {  
  7.             mid = (start + end) / 2;  
  8.             if (arr[mid] < value)  
  9.                 start = mid + 1;  
  10.             else if (arr[mid] > value)  
  11.                 end = mid - 1;  
  12.             else  
  13.                 break;  
  14.         }  
  15.         if (arr[mid] < value)  
  16.             return mid + 1;  
  17.         else if (value < arr[mid])  
  18.             return mid;  
  19.   
  20.         return mid + 1;  
  21.   
  22.     }  
  23.   
  24.     public static void binarySort(int[] arr, int start, int end) {  
  25.         for (int i = start + 1; i <= end; i++) {  
  26.             int value = arr[i];  
  27.             int insertLoc = binarySerch(arr, start, i - 1, value) ;  
  28.             for (int j = i; j > insertLoc; j--) {  
  29.                 arr[j] = arr[j - 1];  
  30.             }  
  31.             arr[insertLoc] = value;  
  32.         }  
  33.     }  
  34.   
  35.     public static void main(String[] args) {  
  36.         int[] arr = { 3508791264 };  
  37.         binarySort(arr, 0, arr.length - 1);  
  38.         for (int i = 0; i < arr.length; i++) {  
  39.             System.out.print(arr[i] + " ");  
  40.         }  
  41.     }  
  42. }  


希尔排序

思路:类似于插入排序,只是每次所取的步长为(数组的长度 /  2 / i)。时间复杂度为(n*log n)。
[java]  view plain  copy
  1. public class ShellSort {  
  2.     public static void shellSort(int[] a) {  
  3.         for (int gap = a.length / 2; gap > 0; gap /= 2)  
  4.             for (int i = gap; i < a.length; i++) {  
  5.                 int key = a[i];  
  6.                 int j = i - gap;  
  7.                 while (j >= 0 && a[j] > key) {  
  8.                     a[j + gap] = a[j];  
  9.                     j -= gap;  
  10.                 }  
  11.                 a[j + gap] = key;  
  12.             }  
  13.   
  14.     }  
  15.   
  16.     public static void main(String[] args) {  
  17.         int a[] = { 5245724245724245724237,  
  18.                 230432312411573831 };  
  19.         shellSort(a);  
  20.         for (int i = 0; i < a.length; i++) {  
  21.             System.out.print(a[i] + " ");  
  22.         }  
  23.     }  
  24. }  

快速排序

思路:关键在于求出partition()函数。我给出了两种方法:1、从前到后。2、从前到中间,从后到中间。时间复杂度为(n * log n)最坏情况为
OK!show your my codes!
[java]  view plain  copy
  1. public class QuickSort {  
  2.       
  3.     /*public static int partition(int[] a, int p, int r) { 
  4.         int x = a[r]; 
  5.         int i = p - 1; 
  6.         for (int j = p; j < r; j++) { 
  7.             if (a[j] <= x) {//如果a[j]<x就将后面a[i]后面a[i+1](值大于x)与a[j](值<a[j])进行交换 
  8.                 i++; 
  9.                  
  10.                 int temp = a[i]; 
  11.                 a[i] = a[j]; 
  12.                 a[j] = temp; 
  13.                  
  14.             } 
  15.         } 
  16.         i++; 
  17.         int temp = a[i]; 
  18.         a[i] = a[r]; 
  19.         a[r] = temp; 
  20.         return i; 
  21.     }*/  
  22.        
  23.     public static int partition(int a[], int p, int r) {  
  24.         int x = a[p];  
  25.         int i = p;  
  26.         int j = r ;  
  27.         while (i < j) {  
  28.             while (a[j] >= x && i<j)  
  29.                 j--;  
  30.             a[i] = a[j];//把小于X的那个数拿到前面的a【i】中  
  31.             while (a[i] <= x && i<j)  
  32.                 i++;  
  33.             a[j] = a[i];//把大于X的那个数拿到后面的a【j】中  
  34.         }  
  35.         a[j] = x;//将X拿到分割处  
  36.         return j;  
  37.     }  
  38.   
  39.     public static void quickSort(int[] a, int p, int r) {  
  40.         if (p < r) {  
  41.             int q = partition(a, p, r);  
  42.             quickSort(a, p, q-1);  
  43.             quickSort(a, q + 1, r);  
  44.         }  
  45.     }  
  46.   
  47.     public static void main(String[] args) {  
  48.         int a[] = { 524572424572424572423723043231241157,  
  49.                 3831 };  
  50.         quickSort(a, 0, a.length-1);  
  51.         for (int i = 0; i < a.length; i++) {  
  52.             System.out.print(a[i] + " ");  
  53.         }  
  54.   
  55.     }  
  56. }  

合并排序

思路:用分治的思想,将数组分至最小,再合并即可,不懂自己google吧!时间复杂度为(n * log n )是一个稳定的排序算法。
[java]  view plain  copy
  1. public class MergeSort {  
  2.     public static void merge(int A[], int p, int q, int r) {  
  3.         int[] L = new int[q - p + 1];  
  4.         int[] R = new int[r - q];  
  5.         for (int i = p, j = 0; i <= q; i++, j++) {  
  6.             L[j] = A[i];  
  7.         }  
  8.         for (int i = q + 1, j = 0; i <= r; i++, j++) {  
  9.             R[j] = A[i];  
  10.         }  
  11.         int pos = p;  
  12.         int i = 0, j = 0;  
  13.         for (; i < L.length && j < R.length;) {  
  14.             if (L[i] <= R[j]) {  
  15.                 A[pos++] = L[i++];  
  16.             } else {  
  17.                 A[pos++] = R[j++];  
  18.             }  
  19.         }  
  20.         if (i < L.length) {  
  21.             for (; i < L.length;)  
  22.                 A[pos++] = L[i++];  
  23.         } else if (j < R.length) {  
  24.             for (; j < R.length;)  
  25.                 A[pos++] = R[j++];  
  26.         }  
  27.     }  
  28.   
  29.     public static void mergeSort(int[] A, int p, int r) {  
  30.         if (p < r) {  
  31.             int q = (p + r) / 2;  
  32.             mergeSort(A, p, q);  
  33.             mergeSort(A, q + 1, r);  
  34.             merge(A, p, q, r);  
  35.         }  
  36.     }  
  37.   
  38.     public static void main(String[] args) {  
  39.         int A[] = { 524572424572424572423723043231241157,  
  40.                 3831 };  
  41.         mergeSort(A, 0, A.length - 1);  
  42.         for (int i = 0; i < A.length; i++) {  
  43.             System.out.print(A[i] + " ");  
  44.         }  
  45.     }  
  46. }  

堆排序

思路:建立一个堆,大顶堆或者小顶堆都可以。每次将堆顶元素放到数组最后,然后堆的规模减小一个,再维持第一个元素的大顶堆性质。时间复杂度为(n * log n)。
[java]  view plain  copy
  1. public class HeapSort {  
  2.     //求双亲位置  
  3.     static int parent(int i) {  
  4.         return i / 2;  
  5.     }  
  6.     //求左孩子位置  
  7.     static int left(int i) {  
  8.         return 2 * i;  
  9.     }  
  10.     //求右孩子位置  
  11.     static int right(int i) {  
  12.         return 2 * i + 1;  
  13.     }  
  14.     //维持大顶堆的性质  
  15.     static void maxHelpify(int[] A, int i) {  
  16.         int l = left(i);  
  17.         int r = right(i);  
  18.         int largest = 0;  
  19.         if (l <= A[0] && A[l] > A[i])  
  20.             largest = l;  
  21.         else  
  22.             largest = i;  
  23.         if (r <= A[0] && A[r] > A[largest])  
  24.             largest = r;  
  25.         if (largest != i) {  
  26.             int temp = A[largest];  
  27.             A[largest] = A[i];  
  28.             A[i] = temp;  
  29.             maxHelpify(A, largest);  
  30.         }  
  31.     }  
  32.     //建立大顶堆  
  33.     static void buildMaxHeap(int[] A){  
  34.         for(int i=(A.length-1)/2; i>0; i--){  
  35.             maxHelpify(A, i);  
  36.         }  
  37.     }  
  38.     //堆排序  
  39.     public static void heapSort(int[] A){  
  40.         buildMaxHeap(A);//建立大顶堆  
  41.         //每次把堆顶的数放到数组最后,然后把堆的大小减1,再次维持第一个数的大顶堆性质  
  42.         for(int i = A.length - 1; i>=2; i--){  
  43.             int temp = A[1];  
  44.             A[1] = A[i];  
  45.             A[i] = temp;  
  46.             A[0]--;  
  47.             maxHelpify(A, 1);  
  48.         }  
  49.     }  
  50.     public static void main(String[] args) {  
  51.         int A[] = new int[3];  
  52.         A[0] = A.length-1;//a[0]存放堆的大小  
  53.         for(int i = 1; i < A.length; i++){  
  54.             A[i] = (int) (Math.random()*10);  
  55.         }  
  56.         heapSort(A);  
  57.         for (int i = 1; i < A.length; i++) {  
  58.             System.out.print(A[i] + " ");  
  59.         }  
  60.     }  
  61. }  


其他:还有一种计数排序。

比较简单:就是将数组下标作为元素的value,特殊情况下使用。如排序N个人的年龄就可以用计数排序。将年龄看作数组的下标,定义一个大小为100的数组,将年龄与之比较,如果年龄==下标就将,该下标的value+1.时间复杂度为(N)。


3.Java遍历Map对象的四种方式

关于java中遍历map具体哪四种方式,请看下文详解吧。

方式一 这是最常见的并且在大多数情况下也是最可取的遍历方式。在键值都需要时使用。

1
2
3
4
Map<Integer, Integer> map = new  HashMap<Integer, Integer>();
for  (Map.Entry<Integer, Integer> entry : map.entrySet()) {
   System.out.println( "Key = "  + entry.getKey() + ", Value = "  + entry.getValue());
}

方法二 在for-each循环中遍历keys或values。

如果只需要map中的键或者值,你可以通过keySet或values来实现遍历,而不是用entrySet。

1
2
3
4
5
6
7
8
9
Map<Integer, Integer> map = new  HashMap<Integer, Integer>();
//遍历map中的键
for  (Integer key : map.keySet()) {
   System.out.println( "Key = "  + key);
}
//遍历map中的值
for  (Integer value : map.values()) {
   System.out.println( "Value = "  + value);
}

该方法比entrySet遍历在性能上稍好(快了10%),而且代码更加干净。

方法三使用Iterator遍历

使用泛型

1
2
3
4
5
6
Map<Integer, Integer> map = new  HashMap<Integer, Integer>();
Iterator<Map.Entry<Integer, Integer>> entries = map.entrySet().iterator();
while  (entries.hasNext()) {
   Map.Entry<Integer, Integer> entry = entries.next();
   System.out.println( "Key = "  + entry.getKey() + ", Value = "  + entry.getValue());
}

不使用泛型:

1
2
3
4
5
6
7
8
Map map = new  HashMap();
Iterator entries = map.entrySet().iterator();
while  (entries.hasNext()) {
   Map.Entry entry = (Map.Entry) entries.next();
   Integer key = (Integer)entry.getKey();
   Integer value = (Integer)entry.getValue();
   System.out.println( "Key = "  + key + ", Value = "  + value);
}

你也可以在keySet和values上应用同样的方法。

该种方式看起来冗余却有其优点所在。首先,在老版本java中这是惟一遍历map的方式。另一个好处是,你可以在遍历时调用iterator.remove()来删除entries,另两个方法则不能。根据javadoc的说明,如果在for-each遍历中尝试使用此方法,结果是不可预测的。

从性能方面看,该方法类同于for-each遍历(即方法二)的性能。

方法四、通过键找值遍历(效率低)

1
2
3
4
Map<Integer, Integer> map = new  HashMap<Integer, Integer>();
for  (Integer key : map.keySet()) {
   Integer value = map.get(key);
   System.out.println( "Key = "  + key + ", Value = "  + value);

作为方法一的替代,这个代码看上去更加干净;但实际上它相当慢且无效率。因为从键取值是耗时的操作(与方法一相比,在不同的Map实现中该方法慢了20%~200%)。如果你安装了FindBugs,它会做出检查并警告你关于哪些是低效率的遍历。所以尽量避免使用。

总结

如果仅需要键(keys)或值(values)使用方法二。如果你使用的语言版本低于java 5,或是打算在遍历时删除entries,必须使用方法三。否则使用方法一(键值都要)。

4.查询表 A(id,name,age)中name重复的值及次数,并按重复次数从大到小排列

假设有表 tb_info:


SELECT info3,COUNT(*) AS '重复次数' FROM tb_info GROUP BY info3 ASC ;



SELECT DISTINCT info3,COUNT(info3) AS'重复次数' from tb_info GROUP BY info3;


5.SQL事务概念是什么,举个例子说明什么样的东西是事务,与程序又有何区别

事务(TRANSACTION)是作为单个逻辑工作单元执行的一系列操作 
这些操作作为一个整体一起向系统提交,要么都执行、要么都不执行
事务是一个不可分割的工作逻辑单元

转帐过程就是一个事务。
它需要两条UPDATE语句来完成,这两条语句是一个整体,如果其中任一条出现错误,则整个转帐业务也应取消,两个帐户中的余额应恢复到原来的数据,从而确保转帐前和转帐后的余额不变,

事务必须具备以下四个属性,简称ACID 属性:
原子性(Atomicity):事务是一个完整的操作。事务的各步操作是不可分的(原子的);要么都执行,要么都不执行
一致性(Consistency):当事务完成时,数据必须处于一致状态
隔离性(Isolation):对数据进行修改的所有并发事务是彼此隔离的,这表明事务必须是独立的,它不应以任何方式依赖于或影响其他事务
永久性(Durability):事务完成后,它对数据库的修改被永久保持,事务日志能够保持事务的永久性

数据库事务具有4个特性:

  1. 原子性(Atomicity):数据库事务中对数据库的所有操作,要么全做,要么全不做。

  2. 一致性(Consistency):事务执行的结果必须是使数据库从一个一致性状态变到另一个一致性状态。

  3. 隔离性(Isolation):一个事务的执行不能被其他事务干扰。

  4. 持续性/永久性(Durability):一个事务一旦提交,它对数据库中数据的改变就应该是永久性的。

比如:银行转账时,从帐号A转100元到帐号B。“帐号A余额减掉100元”、“帐号B余额增加100元”、和“明细账中增加一条转账的明细记录”,这三步操作就是一个完整的事务。

6.索引是什么?优缺点?

sql索引的优缺点

一、为什么要创建索引呢(优点)?
创建索引可以大大提高系统的性能。
第一,   通过创建唯一性索引,可以保证数据库表中每一行数据的唯一性。
第二,   可以大大加快数据的检索速度,这也是创建索引的最主要的原因。
第三,   可以加速表和表之间的连接,特别是在实现数据的参考完整性方面特别有意义。
第四,   在使用分组和排序子句进行数据检索时,同样可以显著减少查询中分组和排序的时间。
第五,   通过使用索引,可以在查询的过程中,使用优化隐藏器,提高系统的性能。
 
二、建立方向索引的不利因素(缺点)
也许会有人要问:增加索引有如此多的优点,为什么不对表中的每一个列创建一个索引呢?这种想法固然有其合理性,然而也有其片面性。虽然,索引有许多优点,但是,为表中的每一个列都增加索引,是非常不明智的。这是因为,增加索引也有许多不利的一个方面。
 
第一,   创建索引和维护索引要耗费时间,这种时间随着数据量的增加而增加。
第二,   索引需要占物理空间,除了数据表占数据空间之外,每一个索引还要占一定的物理空间,如果要建立聚簇索引,那么需要的空间就会更大。
第三,   当对表中的数据进行增加、删除和修改的时候,索引也要动态的维护,这样就降低了数据的维护速度。
 
三、创建方向索引的准则
索引是建立在数据库表中的某些列的上面。因此,在创建索引的时候,应该仔细考虑在哪些列上可以创建索引,在哪些列上不能创建索引。
一般来说,应该在这些列上创建索引。
第一,   在经常需要搜索的列上,可以加快搜索的速度;
第二,   在作为主键的列上,强制该列的唯一性和组织表中数据的排列结构;
第三,   在经常用在连接的列上,这些列主要是一些外键,可以加快连接的速度;
第四,   在经常需要根据范围进行搜索的列上创建索引,因为索引已经排序,其指定的范围是连续的;
第五,   在经常需要排序的列上创建索引,因为索引已经排序,这样查询可以利用索引的排序,加快排序查询时间;
第六,   在经常使用在WHERE子句中的列上面创建索引,加快条件的判断速度。
 
同样,对于有些列不应该创建索引。一般来说,不应该创建索引的的这些列具有下列特点:
第一,   对于那些在查询中很少使用或者参考的列不应该创建索引。这是因为,既然这些列很少使用到,因此有索引或者无索引,并不能提高查询速度。相反,由于增加了索引,反而降低了系统的维护速度和增大了空间需求。
第二,    对于那些只有很少数据值的列也不应该增加索引。这是因为,由于这些列的取值很少,例如人事表的性别列,在查询的结果中,结果集的数据行占了表中数据行的很大比例,即需要在表中搜索的数据行的比例很大。增加索引,并不能明显加快检索速度。
第三,    对于那些定义为text, image和bit数据类型的列不应该增加索引。这是因为,这些列的数据量要么相当大,要么取值很少。
第 四,    当修改性能远远大于检索性能时,不应该创建索引。这是因为,修改性能和检索性能是互相矛盾的。当增加索引时,会提高检索性能,但是会降低修改性能。当减少索引时,会提高修改性能,降低检索性能。因此,当修改性能远远大于检索性能时,不应该创建索引。
四、创建索引的方法
创建索引有多种方法,这些方法包括直接创建索引的方法和间接创建索引的方法。
第一,   直接创建索引,例如使用CREATE INDEX语句或者使用创建索引向导。
第二,   间接创建索引,例如在表中定义主键约束或者唯一性键约束时,同时也创建了索引。
虽然,这两种方法都可以创建索引,但是,它们创建索引的具体内容是有区别的。
使 用CREATE INDEX语句或者使用创建索引向导来创建索引,这是最基本的索引创建方式,并且这种方法最具有柔性,可以定制创建出符合自己需要的索引。在使用这种方式创建索引时,可以使用许多选项,例如指定数据页的充满度、进行排序、整理统计信息等,这样可以优化索引。使用这种方法,可以指定索引的类型、唯一性和复合性,也就是说,既可以创建聚簇索引,也可以创建非聚簇索引,既可以在一个列上创建索引,也可以在两个或者两个以上的列上创建索引。
通过定义主键约束或者唯一性键约束,也可以间接创建索引。主键约束是一种保持数据完整性的逻辑,它限制表中的记录有相同的主键记录。在创建主键约束时,系统自动创建了一个唯一性的聚簇索引。虽然,在逻辑上,主键约束是一种重要的结构,但是,在物理结构上,与主键约束相对应的结构是唯一性的聚簇索引。换句话说,在物理实现上,不存在主键约束,而只存在唯一性的聚簇索引。同样,在创建唯一性键约束时,也同时创建了索引,这种索引则是唯一性的非聚簇索引。因此,当使用约束创建索引时,索引的类型和特征基本上都已经确定了,由用户定制的余地比较小。
当在表上定义主键或者唯一性键约束时,如果表中已经有了使用 CREATE INDEX语句创建的标准索引时,那么主键约束或者唯一性键约束创建的索引覆盖以前创建的标准索引。也就是说,主键约束或者唯一性键约束创建的索引的优先级高于使用CREATE INDEX语句创建的索引。
五、索引的特征
    索引有两个特征,即唯一性索引和复合索引。
唯一性索引保证在索引列中的全部数据是唯一的,不会包含冗余数据。如果表中已经有一个主键约束或者唯一性键约束,那么当创建表或者修改表时,SQL Server自动创建一个唯一性索引。然而,如果必须保证唯一性,那么应该创建主键约束或者唯一性键约束,而不是创建一个唯一性索引。当创建唯一性索引时,应该认真考虑这些规则:当在表中创建主键约束或者唯一性键约束时,SQL Server自动创建一个唯一性索引;如果表中已经包含有数据,那么当创建索引时,SQL Server检查表中已有数据的冗余性;每当使用插入语句插入数据或者使用修改语句修改数据时,SQL Server检查数据的冗余性:如果有冗余值,那么SQL Server取消该语句的执行,并且返回一个错误消息;确保表中的每一行数据都有一个唯一值,这样可以确保每一个实体都可以唯一确认;只能在可以保证实体完整性的列上创建唯一性索引,例如,不能在人事表中的姓名列上创建唯一性索引,因为人们可以有相同的姓名。
复合索引就是一个索引创建在两个列或者多个列上。在搜索时,当两个或者多个列作为一个关键值时,最好在这些列上创建复合索引。当创建复合索引时,应该考虑这些规则:最多可以把16个列合并成一个单独的复合索引,构成复合索引的列的总长度不能超过900字节,也就是说复合列的长度不能太长;在复合索引中,所有的列必须来自同一个表中,不能跨表建立复合列;在复合索引中,列的排列顺序是非常重要的,因此要认真排列列的顺序,原则上,应该首先定义最唯一的列,例如在(COL1,COL2)上的索引与在(COL2,COL1)上的索引是不相同的,因为两个索引的列的顺序不同;为了使查询优化器使用复合索引,查询语句中的WHERE子句必须参考复合索引中第一个列;当表中有多个关键列时,复合索引是非常有用的;使用复合索引可以提高查询性能,减少在一个表中所创建的索引数量。
六、索引的类型
根据索引的顺序与数据表的物理顺序是否相同,可以把索引分成两种类型。一种是数据表的物理顺序与索引顺序相同的聚簇索引,另一种是数据表的物理顺序与索引顺序不相同的非聚簇索引。
七、聚簇索引的体系结构
索引的结构类似于树状结构,树的顶部称为叶级,树的其它部分称为非叶级,树的根部在非叶级中。同样,在聚簇索引中,聚簇索引的叶级和非叶级构成了一个树状结构,索引的最低级是叶级。在聚簇索引中,表中的数据所在的数据页是叶级,在叶级之上的索引页是非叶级,索引数据所在的索引页是非叶级。在聚簇索引中,数据值的顺序总是按照升序排列。
应该在表中经常搜索的列或者按照顺序访问的列上创建聚簇索引。当创建聚簇索引时,应该考虑这些因素:每一个表只能有一个聚簇索引,因为表中数据的物理顺序只能有一个;表中行的物理顺序和索引中行的物理顺序是相同的,在创建任何非聚簇索引之前创建聚簇索引,这是因为聚簇索引改变了表中行的物理顺序,数据行按照一定的顺序排列,并且自动维护这个顺序;关键值的唯一性要么使用UNIQUE关键字明确维护,要么由一个内部的唯一标识符明确维护,这些唯一性标识符是系统自己使用的,用户不能访问;聚簇索引的平均大小大约是数据表的百分之五,但是,实际的聚簇索引的大小常常根据索引列的大小变化而变化;在索引的创建过程中,SQL Server临时使用当前数据库的磁盘空间,当创建聚簇索引时,需要1.2倍的表空间的大小,因此,一定要保证有足够的空间来创建聚簇索引。
当系统访问表中的数据时,首先确定在相应的列上是否存在有索引和该索引是否对要检索的数据有意义。如果索引存在并且该索引非常有意义,那么系统使用该索引访问表中的记录。系统从索引开始浏览到数据,索引浏览则从树状索引的根部开始。从根部开始,搜索值与每一个关键值相比较,确定搜索值是否大于或者等于关键值。这一步重复进行,直到碰上一个比搜索值大的关键值,或者该搜索值大于或者等于索引页上所有的关键值为止。

系统如何访问表中的数据
一般地,系统访问数据库中的数据,可以使用两种方法:表扫描和索引查找。第一种方法是表扫描,就是指系统将指针放置在该表的表头数据所在的数据页上,然后按照数据页的排列顺序,一页一页地从前向后扫描该表数据所占有的全部数据页,直至扫描完表中的全部记录。在扫描时,如果找到符合查询条件的记录,那么就将这条记录挑选出来。最后,将全部挑选出来符合查询语句条件的记录显示出来。第二种方法是使用索引查找。索引是一种树状结构,其中存储了关键字和指向包含关键字所在记录的数据页的指针。当使用索引查找时,系统沿着索引的树状结构,根据索引中关键字和指针,找到符合查询条件的的记录。最后,将全部查找到的符合查询语句条件的记录显示出来。
    在SQL Server中,当访问数据库中的数据时,由SQL Server确定该表中是否有索引存在。如果没有索引,那么SQL Server使用表扫描的方法访问数据库中的数据。查询处理器根据分布的统计信息生成该查询语句的优化执行规划,以提高访问数据的效率为目标,确定是使用表扫描还是使用索引。

7.String,StringBuffer与StringBuilder的区别?

String 字符串常量
StringBuffer 字符串变量(线程安全)
StringBuilder 字符串变量(非线程安全)

 简要的说, String 类型和 StringBuffer 类型的主要性能区别其实在于 String 是不可变的对象, 因此在每次对 String 类型进行改变的时候其实都等同于生成了一个新的 String 对象,然后将指针指向新的 String 对象,所以经常改变内容的字符串最好不要用 String ,因为每次生成对象都会对系统性能产生影响,特别当内存中无引用对象多了以后, JVM 的 GC 就会开始工作,那速度是一定会相当慢的。
 而如果是使用 StringBuffer 类则结果就不一样了,每次结果都会对 StringBuffer 对象本身进行操作,而不是生成新的对象,再改变对象引用。所以在一般情况下我们推荐使用 StringBuffer ,特别是字符串对象经常改变的情况下。而在某些特别情况下, String 对象的字符串拼接其实是被 JVM 解释成了 StringBuffer 对象的拼接,所以这些时候 String 对象的速度并不会比 StringBuffer 对象慢,而特别是以下的字符串对象生成中, String 效率是远要比 StringBuffer 快的:
 String S1 = “This is only a” + “ simple” + “ test”;
 StringBuffer Sb = new StringBuilder(“This is only a”).append(“ simple”).append(“ test”);
 你会很惊讶的发现,生成 String S1 对象的速度简直太快了,而这个时候 StringBuffer 居然速度上根本一点都不占优势。其实这是 JVM 的一个把戏,在 JVM 眼里,这个
 String S1 = “This is only a” + “ simple” + “test”; 其实就是:
 String S1 = “This is only a simple test”; 所以当然不需要太多的时间了。但大家这里要注意的是,如果你的字符串是来自另外的 String 对象的话,速度就没那么快了,譬如:
String S2 = “This is only a”;
String S3 = “ simple”;
String S4 = “ test”;
String S1 = S2 +S3 + S4;
这时候 JVM 会规规矩矩的按照原来的方式去做
在大部分情况下 StringBuffer > String
StringBuffer
Java.lang.StringBuffer线程安全的可变字符序列。一个类似于 String 的字符串缓冲区,但不能修改。虽然在任意时间点上它都包含某种特定的字符序列,但通过某些方法调用可以改变该序列的长度和内容。
可将字符串缓冲区安全地用于多个线程。可以在必要时对这些方法进行同步,因此任意特定实例上的所有操作就好像是以串行顺序发生的,该顺序与所涉及的每个线程进行的方法调用顺序一致。
StringBuffer 上的主要操作是 append 和 insert 方法,可重载这些方法,以接受任意类型的数据。每个方法都能有效地将给定的数据转换成字符串,然后将该字符串的字符追加或插入到字符串缓冲区中。append 方法始终将这些字符添加到缓冲区的末端;而 insert 方法则在指定的点添加字符。
例如,如果 z 引用一个当前内容是“start”的字符串缓冲区对象,则此方法调用 z.append("le") 会使字符串缓冲区包含“startle”,而 z.insert(4, "le") 将更改字符串缓冲区,使之包含“starlet”。
在大部分情况下 StringBuilder > StringBuffer
java.lang.StringBuilde
java.lang.StringBuilder一个可变的字符序列是5.0新增的。此类提供一个与 StringBuffer 兼容的 API,但不保证同步。该类被设计用作 StringBuffer 的一个简易替换,用在字符串缓冲区被单个线程使用的时候(这种情况很普遍)。如果可能,建议优先采用该类,因为在大多数实现中,它比 StringBuffer 要快。两者的方法基本相同。

8.实现多线程的几种方法

JAVA多线程实现的四种方式

Java多线程实现方式主要有四种:继承Thread类、实现Runnable接口、实现Callable接口通过FutureTask包装器来创建Thread线程、使用ExecutorService、Callable、Future实现有返回结果的多线程。

其中前两种方式线程执行完后都没有返回值,后两种是带返回值的。

 

1、继承Thread类创建线程
Thread类本质上是实现了Runnable接口的一个实例,代表一个线程的实例。启动线程的唯一方法就是通过Thread类的start()实例方法。start()方法是一个native方法,它将启动一个新线程,并执行run()方法。这种方式实现多线程很简单,通过自己的类直接extend Thread,并复写run()方法,就可以启动新线程并执行自己定义的run()方法。例如:

复制代码
public class MyThread extends Thread {  
  public void run() {  
   System.out.println("MyThread.run()");  
  }  
}  
 
MyThread myThread1 = new MyThread();  
MyThread myThread2 = new MyThread();  
myThread1.start();  
myThread2.start();  
复制代码

2、实现Runnable接口创建线程
如果自己的类已经extends另一个类,就无法直接extends Thread,此时,可以实现一个Runnable接口,如下:

public class MyThread extends OtherClass implements Runnable {  
  public void run() {  
   System.out.println("MyThread.run()");  
  }  
}  

为了启动MyThread,需要首先实例化一个Thread,并传入自己的MyThread实例:

MyThread myThread = new MyThread();  
Thread thread = new Thread(myThread);  
thread.start();  

事实上,当传入一个Runnable target参数给Thread后,Thread的run()方法就会调用target.run(),参考JDK源代码:

public void run() {  
  if (target != null) {  
   target.run();  
  }  
}  

3、实现Callable接口通过FutureTask包装器来创建Thread线程

Callable接口(也只有一个方法)定义如下:   

public interface Callable<V>   { 
  V call() throws Exception;   } 
复制代码
public class SomeCallable<V> extends OtherClass implements Callable<V> {

    @Override
    public V call() throws Exception {
        // TODO Auto-generated method stub
        return null;
    }

}
复制代码
复制代码
Callable<V> oneCallable = new SomeCallable<V>();   
//由Callable<Integer>创建一个FutureTask<Integer>对象:   
FutureTask<V> oneTask = new FutureTask<V>(oneCallable);   
//注释:FutureTask<Integer>是一个包装器,它通过接受Callable<Integer>来创建,它同时实现了Future和Runnable接口。 
  //由FutureTask<Integer>创建一个Thread对象:   
Thread oneThread = new Thread(oneTask);   
oneThread.start();   
//至此,一个线程就创建完成了。
复制代码

4、使用ExecutorService、Callable、Future实现有返回结果的线程

ExecutorService、Callable、Future三个接口实际上都是属于Executor框架。返回结果的线程是在JDK1.5中引入的新特征,有了这种特征就不需要再为了得到返回值而大费周折了。而且自己实现了也可能漏洞百出。

可返回值的任务必须实现Callable接口。类似的,无返回值的任务必须实现Runnable接口。

执行Callable任务后,可以获取一个Future的对象,在该对象上调用get就可以获取到Callable任务返回的Object了。

注意:get方法是阻塞的,即:线程无返回结果,get方法会一直等待。

再结合线程池接口ExecutorService就可以实现传说中有返回结果的多线程了。

下面提供了一个完整的有返回结果的多线程测试例子,在JDK1.5下验证过没问题可以直接使用。代码如下:

复制代码
import java.util.concurrent.*;  
import java.util.Date;  
import java.util.List;  
import java.util.ArrayList;  
  
/** 
* 有返回值的线程 
*/  
@SuppressWarnings("unchecked")  
public class Test {  
public static void main(String[] args) throws ExecutionException,  
    InterruptedException {  
   System.out.println("----程序开始运行----");  
   Date date1 = new Date();  
  
   int taskSize = 5;  
   // 创建一个线程池  
   ExecutorService pool = Executors.newFixedThreadPool(taskSize);  
   // 创建多个有返回值的任务  
   List<Future> list = new ArrayList<Future>();  
   for (int i = 0; i < taskSize; i++) {  
    Callable c = new MyCallable(i + " ");  
    // 执行任务并获取Future对象  
    Future f = pool.submit(c);  
    // System.out.println(">>>" + f.get().toString());  
    list.add(f);  
   }  
   // 关闭线程池  
   pool.shutdown();  
  
   // 获取所有并发任务的运行结果  
   for (Future f : list) {  
    // 从Future对象上获取任务的返回值,并输出到控制台  
    System.out.println(">>>" + f.get().toString());  
   }  
  
   Date date2 = new Date();  
   System.out.println("----程序结束运行----,程序运行时间【"  
     + (date2.getTime() - date1.getTime()) + "毫秒】");  
}  
}  
  
class MyCallable implements Callable<Object> {  
private String taskNum;  
  
MyCallable(String taskNum) {  
   this.taskNum = taskNum;  
}  
  
public Object call() throws Exception {  
   System.out.println(">>>" + taskNum + "任务启动");  
   Date dateTmp1 = new Date();  
   Thread.sleep(1000);  
   Date dateTmp2 = new Date();  
   long time = dateTmp2.getTime() - dateTmp1.getTime();  
   System.out.println(">>>" + taskNum + "任务终止");  
   return taskNum + "任务返回运行结果,当前任务时间【" + time + "毫秒】";  
}  
}  
复制代码

 

代码说明:
上述代码中Executors类,提供了一系列工厂方法用于创建线程池,返回的线程池都实现了ExecutorService接口。
public static ExecutorService newFixedThreadPool(int nThreads) 
创建固定数目线程的线程池。
public static ExecutorService newCachedThreadPool() 
创建一个可缓存的线程池,调用execute 将重用以前构造的线程(如果线程可用)。如果现有线程没有可用的,则创建一个新线程并添加到池中。终止并从缓存中移除那些已有 60 秒钟未被使用的线程。
public static ExecutorService newSingleThreadExecutor() 
创建一个单线程化的Executor。
public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize) 
创建一个支持定时及周期性的任务执行的线程池,多数情况下可用来替代Timer类。

ExecutoreService提供了submit()方法,传递一个Callable,或Runnable,返回Future。如果Executor后台线程池还没有完成Callable的计算,这调用返回Future对象的get()方法,会阻塞直到计算完成。

软件-注重思想、逻辑

9.COOKIE和SESSION有什么区别?

1. 由于HTTP协议是无状态的协议,所以服务端需要记录用户的状态时,就需要用某种机制来识具体的用户,这个机制就是Session.典型的场景比如购物车,当你点击下单按钮时,由于HTTP协议无状态,所以并不知道是哪个用户操作的,所以服务端要为特定的用户创建了特定的Session,用用于标识这个用户,并且跟踪用户,这样才知道购物车里面有几本书。这个Session是保存在服务端的,有一个唯一标识。在服务端保存Session的方法很多,内存、数据库、文件都有。集群的时候也要考虑Session的转移,在大型的网站,一般会有专门的Session服务器集群,用来保存用户会话,这个时候 Session 信息都是放在内存的,使用一些缓存服务比如Memcached之类的来放 Session。
2. 思考一下服务端如何识别特定的客户?这个时候Cookie就登场了。每次HTTP请求的时候,客户端都会发送相应的Cookie信息到服务端。实际上大多数的应用都是用 Cookie 来实现Session跟踪的,第一次创建Session的时候,服务端会在HTTP协议中告诉客户端,需要在 Cookie 里面记录一个Session ID,以后每次请求把这个会话ID发送到服务器,我就知道你是谁了。有人问,如果客户端的浏览器禁用了 Cookie 怎么办?一般这种情况下,会使用一种叫做URL重写的技术来进行会话跟踪,即每次HTTP交互,URL后面都会被附加上一个诸如 sid=xxxxx 这样的参数,服务端据此来识别用户。
3. Cookie其实还可以用在一些方便用户的场景下,设想你某次登陆过一个网站,下次登录的时候不想再次输入账号了,怎么办?这个信息可以写到Cookie里面,访问网站的时候,网站页面的脚本可以读取这个信息,就自动帮你把用户名给填了,能够方便一下用户。这也是Cookie名称的由来,给用户的一点甜头。
所以,总结一下:
Session是在服务端保存的一个数据结构,用来跟踪用户的状态,这个数据可以保存在集群、数据库、文件中;
Cookie是客户端保存用户信息的一种机制,用来记录用户的一些信息,也是实现Session的一种方式。

类似这种面试题,实际上都属于“开放性”问题,你扯到哪里都可以。不过如果我是面试官的话,我还是希望对方能做到一点——

不要混淆 session 和 session 实现。

本来 session 是一个抽象概念,开发者为了实现中断和继续等操作,将 user agent 和 server 之间一对一的交互,抽象为“会话”,进而衍生出“会话状态”,也就是 session 的概念。

而 cookie 是一个实际存在的东西,http 协议中定义在 header 中的字段。可以认为是 session 的一种后端无状态实现。

而我们今天常说的 “session”,是为了绕开 cookie 的各种限制,通常借助 cookie 本身和后端存储实现的,一种更高级的会话状态实现。

所以 cookie 和 session,你可以认为是同一层次的概念,也可以认为是不同层次的概念。具体到实现,session 因为 session id 的存在,通常要借助 cookie 实现,但这并非必要,只能说是通用性较好的一种实现方案。

10. Java中Error与Exception的区别

在Java开发调试时,经常都会出现一些错误异常,那么对于Error类与Exception类我们了解多少呢?下面简单的介绍了Java中Error与Exception的区别。

Error类和Exception类都继承自Throwable类。

Error的继承关系:

Exception的继承关系:

二者的不同之处:

Exception:

1.可以是可被控制(checked) 或不可控制的(unchecked)。

2.表示一个由程序员导致的错误。

3.应该在应用程序级被处理。

Error:

1.总是不可控制的(unchecked)。

2.经常用来用于表示系统错误或低层资源的错误。

3.如何可能的话,应该在系统级被捕捉。

Java 中定义了两类异常:

1) Checked exception: 这类异常都是Exception的子类 。异常的向上抛出机制进行处理,假如子类可能产生A异常,那么在父类中也必须throws A异常。可能导致的问题:代码效率低,耦合度过高。

2) Unchecked exception: 这类异常都是RuntimeException的子类,虽然RuntimeException同样也是Exception的子类,但是它们是非凡的,它们不能通过client code来试图解决,所以称为Unchecked exception 。

Java 中异常类的继承关系图:

原文链接:http://mousepc.iteye.com/blog/1279559

【编辑推荐】

  1. 浅谈Java的输入输出流
  2. 高效编写Java代码的几条建议
  3. Java常见的四种引用
  4. Java程序员惯性思维的一个错误
  5. 去故就新 Java线程新同步机制

11.final,finally,finallze的区别。
final、finally、finalize的区别

1、final修饰符(关键字)。被final修饰的类,就意味着不能再派生出新的子类,不能作为父类而被子类继承。因此一个类不能既被abstract声明,又被final声明。将变量或方法声明为final,可以保证他们在使用的过程中不被修改。被声明为final的变量必须在声明时给出变量的初始值,而在以后的引用中只能读取。被final声明的方法也同样只能使用,不能重载。

【例】

public  class  finalTest{
final   int  a=6;//final成员变量不能被更改
final   int  b;//在声明final成员变量时没有赋值,称为空白final
public finalTest(){
b=8;//在构造方法中为空白final赋值
}
int   do(final x){//设置final参数,不可以修改参数x的值
return x+1;
}
void  doit(){
final int i = 7;//局部变量定义为final,不可改变i的值
}
}

2、finally是在异常处理时提供finally块来执行任何清除操作。不管有没有异常被抛出、捕获,finally块都会被执行。try块中的内容是在无异常时执行到结束。catch块中的内容,是在try块内容发生catch所声明的异常时,跳转到catch块中执行。finally块则是无论异常是否发生,都会执行finally块的内容,所以在代码逻辑中有需要无论发生什么都必须执行的代码,就可以放在finally块中。

3、finalize是方法名。java技术允许使用finalize()方法在垃圾收集器将对象从内存中清除出去之前做必要的清理工作。这个方法是由垃圾收集器在确定这个对象没有被引用时对这个对象调用的。它是在object类中定义的,因此所有的类都继承了它。子类覆盖finalize()方法以整理系统资源或者被执行其他清理工作。finalize()方法是在垃圾收集器删除对象之前对这个对象调用的。 


12.GC             

 GC是垃圾收集的意思,内存处理是编程人员容易出现问题的地方,忘记或者错误的内存回收会导致程序或系统的不稳定甚至崩溃,Java提供的GC功能可以自动监测对象是否超过作用域从而达到自动回收内存的目的,Java语言没有提供释放已分配内存的显示操作方法。Java程序员不用担心内存管理,因为垃圾收集器会自动进行管理。要请求垃圾收集,可以调用下面的方法之一:

System.gc() 或Runtime.getRuntime().gc() 。

    垃圾回收可以有效的防止内存泄露,有效的使用可以使用的内存。垃圾回收器通常是作为一个单独的低优先级的线程运行,不可预知的情况下对内存堆中已经死亡的或者长时间没有使用的对象进行清除和回收,程序员不能实时的调用垃圾回收器对某个对象或所有对象进行垃圾回收。回收机制有分代复制垃圾回收、标记垃圾回收、增量垃圾回收等方式。


   补充:标准的Java进程既有栈又有堆。栈保存了原始型局部变量,堆保存了要创建的对象。Java平台对堆内存回收和再利用的基本算法被称为标记和清除,但是Java对其进行了改进,采用“分代式垃圾收集”。这种方法会跟Java对象的生命周期将堆内存划分为不同的区域,在垃圾收集过程中,可能会将对象移动到不同区域:
 伊甸园(Eden):这是对象最初诞生的区域,并且对大多数对象来说,这里是它们唯一存在过的区域。
 幸存者乐园(Survivor):从伊甸园幸存下来的对象会被挪到这里。
 终身颐养园(Tenured):这是足够老的幸存对象的归宿。年轻代收集(Minor-GC)过程是不会触及这个地方的。当年轻代收集不能把对象放进终身颐养园时,就会触发一次完全收集(Major-GC),这里可能还会牵扯到压缩,以便为大对象腾出足够的空间。
与垃圾回收相关的JVM参数:
 -Xms / -Xmx --- 堆的初始大小 / 堆的最大大小
 -Xmn --- 堆中年轻代的大小
 -XX:-DisableExplicitGC --- 让System.gc()不产生任何作用
 -XX:+PrintGCDetail --- 打印GC的细节
-XX:+PrintGCDateStamps --- 打印GC操作的时间戳

13.Math.round(11.5)等于多少? Math.round(-11.5)等于多少?

1.先说下怎么理解

round()方法可以这样理解:

将括号内的数+0.5之后,向下取值,

比如:round(3.4)就是3.4+0.5=3.9,向下取值是3,所以round(3.4)=3; 

round(-10.5)就是-10.5+0.5=-10,向下取值就是-10,所以round(-10.5)=-10

所以,Math.round(11.5)=12;

现在再来看,Math.round(11.5),Math.round(-11.5)你应该知道等于多少了吧,掌握了方法就好解决问题了。

这个题面试了很多家就一家遇到,所以就来和大家分享下。

扩展:常用的三个

Math.ceil求最小的整数,但不小于本身.  

ceil的英文意义是天花板,该方法就表示向上取整,

例子

所以,Math.ceil(11.3)的结果为12,Math.ceil(-11.3)的结果是-11;

Java代码   收藏代码
  1. /**   
  2. * @see  求最小的整数,但不小于本身  
  3. * @param double   
  4. * @return double   
  5. */  
  6. System.out.println(Math.ceil(-1.1));  
  7. System.out.println(Math.ceil(-1.9));  
  8. System.out.println(Math.ceil(1.1));  
  9. System.out.println(Math.ceil(1.9));  

 输出结果:

Java代码   收藏代码
  1. -1.0  
  2. -1.0  
  3. 2.0  
  4. 2.0  

Math.floor求最大的整数,但不大于本身.

floor的英文意义是地板,该方法就表示向下取整,

例子:

floor的英文意义是地板,该方法就表示向下取整,

所以,Math.floor(11.6)的结果为11,Math.floor(-11.6)的结果是-12;

Java代码   收藏代码
  1. /** 
  2. * @see 求最大的整数,但不大于本身  
  3. * @param double 
  4. * @return double 
  5. */  
  6. System.out.println(Math.floor(-1.1));  
  7. System.out.println(Math.floor(-1.9));  
  8. System.out.println(Math.floor(1.1));  
  9. System.out.println(Math.floor(1.9));  

  

输出结果:

Java代码   收藏代码
  1. -2.0  
  2. -2.0  
  3. 1.0  
  4. 1.0  

  

Math.round求本身的四舍五入.  

Java代码   收藏代码
  1. /** 
  2. * @see 本身的四舍五入 
  3. * @param double 
  4. * @return long 
  5. */  
  6. System.out.println(Math.round(-1.1));  
  7. System.out.println(Math.round(-1.9));  
  8. System.out.println(Math.round(1.1));  
  9. System.out.println(Math.round(1.9));  

 

 输出结果:

Java代码   收藏代码
  1. -1  
  2. -2  
  3. 1  
  4. 2  

 

Math.abs求本身的绝对值.   

Java代码   收藏代码
  1. /** 
  2. * @see 本身的绝对值 
  3. * @param double|float|int|long 
  4. * @return double|float|int|long 
  5. */   
  6.  System.out.println(Math.abs(1.1));  
  7.  System.out.println(Math.abs(1.9));  
  8.  System.out.println(Math.abs(-1.1));  
  9.  System.out.println(Math.abs(-1.9));  

 

 输出结果:

Java代码   收藏代码
  1. 1.1  
  2. 1.9  
  3. 1.1  
  4. 1.9  

 

 Math.max与Math.min,比较两个数的最大值,最小值

Java代码   收藏代码
  1. /** 
  2.  * @see 比较两个数的最大值,最小值 
  3. * @param double|float|int|long 
  4. * @return double|float|int|long 
  5. */  
  6. System.out.println(Math.max(1.02.0));  
  7. System.out.println(Math.min(-1.0, -2.0));  

 

输出结果:

Java代码   收藏代码
  1. 2.0  
  2. -2.0  

 

返回一个与第二个参数相同的标志(正负号)的值

Java代码   收藏代码
  1. /** 
  2. * @see 返回一个与第二个参数相同的标志(正负号)的值 
  3. * @param double|float 
  4. * @return double|float 
  5. */  
  6. System.out.println(Math.copySign(-1.92.9));  
  7. System.out.println(Math.copySign(1.9, -2.9));  
  8. System.out.println(Math.copySign(0.02.9));  
  9. System.out.println(Math.copySign(0.0, -2.9));  

  

输出结果:

Java代码   收藏代码
  1. 1.9  
  2. -1.9  
  3. 0.0  
  4. -0.0  

 14.String s=new String("abc")创建了几个对象?


String str=new String("abc");   紧接着这段代码之后的往往是这个问题,那就是这行代码究竟创建了几个String对象呢?相信大家对这道题并不陌生,答案也是众所周知的,2个。接下来我们就从这道题展开,一起回顾一下与创建String对象相关的一些JAVA知识。  我们可以把上面这行代码分成String str、=、"abc"和new String()四部分来看待。String str只是定义了一个名为str的String类型的变量,因此它并没有创建对象;=是对变量str进行初始化,将某个对象的引用(或者叫句柄)赋值给它,显然也没有创建对象;现在只剩下new String("abc")了。那么,new String("abc")为什么又能被看成"abc"和new String()呢?
我们来看一下被我们调用了的String的构造器:  
public String(String original) {  //other code ...  }   大家都知道,我们常用的创建一个类的实例(对象)的方法有以下两种
一、使用new创建对象。
二、调用Class类的newInstance方法,利用反射机制创建对象。
我们正是使用new调用了String类的上面那个构造器方法创建了一个对象,并将它的引用赋值给了str变量。同时我们注意到,被调用的构造器方法接受的参数也是一个String对象,这个对象正是"abc"。由此我们又要引入另外一种创建String对象的方式的讨论——引号内包含文本。
这种方式是String特有的,并且它与new的方式存在很大区别。  
String str="abc";  

毫无疑问,这行代码创建了一个String对象。  

String a="abc";  String b="abc";   那这里呢?
答案还是一个。  
String a="ab"+"cd";   再看看这里呢?
答案是三个。
说到这里,我们就需要引入对字符串池相关知识的回顾了。  

在JAVA虚拟机(JVM)中存在着一个字符串池,其中保存着很多String对象,并且可以被共享使用,因此它提高了效率。由于String类是final的,它的值一经创建就不可改变,因此我们不用担心String对象共享而带来程序的混乱。字符串池由String类维护,我们可以调用intern()方法来访问字符串池。  

我们再回头看看String a="abc";,这行代码被执行的时候,JAVA虚拟机首先在字符串池中查找是否已经存在了值为"abc"的这么一个对象,它的判断依据是String类equals(Object obj)方法的返回值。如果有,则不再创建新的对象,直接返回已存在对象的引用;如果没有,则先创建这个对象,然后把它加入到字符串池中,再将它的引用返回。因此,我们不难理解前面三个例子中头两个例子为什么是这个答案了。

只有使用引号包含文本的方式创建的String对象之间使用“+”连接产生的新对象才会被加入字符串池中。对于所有包含new方式新建对象(包括null)的“+”连接表达式,它所产生的新对象都不会被加入字符串池中,对此我们不再赘述。因此我们提倡大家用引号包含文本的方式来创建String对象以提高效率,实际上这也是我们在编程中常采用的。

栈(stack):主要保存基本类型(或者叫内置类型)(char、byte、short、int、long、float、double、boolean)和对象的引用,数据可以共享,速度仅次于寄存器(register),快于堆。 

堆(heap):用于存储对象

15.抽象类(abstract class)和接口(Interface)的区

前言

  • 抽象类(abstract class)和接口(Interface)是Java语言中对于抽象类定义进行支持的两种机制,赋予了Java强大的面向对象能力。
  • 二者具有很大的相似性,甚至可以相互替换,因此很多开发者在进行抽象类定义时对于abstractclass和Interface的选择显得比较随意。其实,两者之间还是有很大的区别的。
  • 本文将对它们之间的区别进行剖析,并提供一个在二者之间进行选择的依据。

抽象类是什么?

本文中的抽象类表示的是一个抽象体,并非直接从abstract class翻译而来,而abstract class仅仅是Java语言中用于定义抽象类的一种方法,请读者注意区分)

  • 在面向对象的概念中,所有的对象都是通过类来描绘的,但是并不是所有的类都是用来描绘对象的,如果一个类中没有包含足够的信息来描绘一个具体的对象,这样的类就是抽象类。

  • 抽象类的定义
    是对一系列看上去不同,但是本质上相同的具体概念的抽象,往往用来表征我们在对问题进行分析、设计中得出的抽象概念

    • 比如:如果我们进行一个图形编辑软件的开发,就会发现问题领域存在着圆、三角形这样一些具体概念,它们是不同的,但是它们本质上又都属于这样一个概念:形状,形状这个概念在问题领域是不存在的,所以形状就是一个圆形、三角形的抽象类。
    • 正是因为抽象的概念在问题领域没有对应的具体概念,所以用以表征抽象概念的抽象类是不能实例化的。

为什么要有抽象类?

  • 用于类型隐藏
    在面向对象领域,抽象类主要用来进行类型隐藏。我们可以构造出一个固定的一组行为的抽象描述,但是这组行为却能够有任意个可能的具体实现方式。这个抽象描述就是抽象类。
  • 用于拓展对象的行为功能
    这一组任意个可能的具体实现则表现为所有可能的派生类(子类),模块可以操作一个抽象体。由于模块依赖于一个固定的抽象体,因此它可以是不允许修改的;同时,通过从这个抽象体派生,也可扩展此模块的行为功能。

如何进行抽象类的定义?

抽象类(abstract class)和接口(Interface)在Java语言中都是用来进行抽象类定义的两种主要方法

抽象类(abstract class)

  • 定义:包含抽象方法的的类是abstract class

    用abstract关键字修饰

  • 作用:abstractclass是为了把相同的东西提取出来,即重用

  • 使用abstractclass语法规定

语法备注
抽象类定义用abstract关键字修饰要通过子类进行实例化
抽象类是不能被实例化的要通过子类进行实例化
子类必须重写父类的所有抽象方法抽象方法:声明但却未被实现的方法,用abstract关键字修饰
含有抽象方法的类一定是抽象类,但是抽象类不一定含有抽象方法
抽象类是用来被它的子类继承的关键字extends
抽象类是在功能上的一个规定

Interface

  • 定义:比abstract class更加抽象,是一种特殊的abstract class

    用Interface关键字修饰

  • 作用:Interface是为了把程序模块进行固化的契约,是为了降低偶合

  • 使用Interface的语法规定
语法备注
接口定义用Interface关键字修饰 
接口中的所有方法都是抽象的可以用abstract修饰,也可以省略
接口中的方法必须是用public修饰,或不写但是不能被其他修饰符修饰
接口中的属性必须是全局常量publicstaticfinal修饰
抽象类是用来被它的子类实现的关键字Implements
抽象类是在结构上的一个规定
接口不能被实例化
子类实现接口时需要实现接口中的所有方法若有一个未不实现,该子类就是抽象类abstractclass

实例
下面以定义一个名为Demo的抽象类为例来说明这种不同。

  • 使用abstract class的方式定义Demo抽象类:
    1. abstract classDemo{
    2. abstract void method1();
    3. abstract avoid method2();}
  • 使用interface的方式定义Demo抽象类:
    1. interface Demo{
    2. void method1();
    3. void method2();}

二者的相同点

都不能被实例化

二者的区别

类型abstract classInterface
定义abstract class关键字Interface关键字
继承抽象类可以继承一个类和实现多个接口;子类只可以继承一个抽象类接口只可以继承接口(一个或多个);子类可以实现多个接口
访问修饰符抽象方法可以有publicprotecteddefault这些修饰符接口方法默认修饰符是public。你不可以使用其它修饰符
方法实现可定义构造方法,可以有抽象方法和具体方法接口完全是抽象的,没构造方法,且方法都是抽象的,不存在方法的实现
实现方式子类使用extends关键字来继承抽象类。如果子类不是抽象类的话,它需要提供抽象类中所有声明的方法的实现子类使用关键字implements来实现接口。它需要提供接口中所有声明的方法的实现
作用了把相同的东西提取出来,即重用为了把程序模块进行固化的契约,是为了降低偶合

16.css的盒子模型

CSS 盒子模型(Box Model)

所有HTML元素可以看作盒子,在CSS中,"box model"这一术语是用来设计和布局时使用。

CSS盒模型本质上是一个盒子,封装周围的HTML元素,它包括:边距,边框,填充,和实际内容。

盒模型允许我们在其它元素和周围元素边框之间的空间放置元素。

下面的图片说明了盒子模型(Box Model):


CSS box-model

不同部分的说明:

  • Margin(外边距) - 清除边框外的区域,外边距是透明的。
  • Border(边框) - 围绕在内边距和内容外的边框。
  • Padding(内边距) - 清除内容周围的区域,内边距是透明的。
  • Content(内容) - 盒子的内容,显示文本和图像。

为了正确设置元素在所有浏览器中的宽度和高度,你需要知道的盒模型是如何工作的。


元素的宽度和高度

Remark重要: 当您指定一个CSS元素的宽度和高度属性时,你只是设置内容区域的宽度和高度。要知道,完全大小的元素,你还必须添加填充,边框和边距。.

下面的例子中的元素的总宽度为300px:

实例

div { width: 300 px ; border: 25 px solid green ; padding: 25 px ; margin: 25 px ; }

尝试一下 »

让我们自己算算:
300px (宽)
+ 50px (左 + 右填充)
+ 50px (左 + 右边框)
+ 50px (左 + 右边距)
= 450px

试想一下,你只有250像素的空间。让我们设置总宽度为250像素的元素:

实例

div { width: 220 px ; padding: 10 px ; border: 5 px solid gray ; margin: 0 ; }

尝试一下 »

最终元素的总宽度计算公式是这样的:

总元素的宽度=宽度+左填充+右填充+左边框+右边框+左边距+右边距

元素的总高度最终计算公式是这样的:

总元素的高度=高度+顶部填充+底部填充+上边框+下边框+上边距+下边距


浏览器的兼容性问题

一旦为页面设置了恰当的 DTD,大多数浏览器都会按照上面的图示来呈现内容。然而 IE 5 和 6 的呈现却是不正确的。根据 W3C 的规范,元素内容占据的空间是由 width 属性设置的,而内容周围的 padding 和 border 值是另外计算的。不幸的是,IE5.X 和 6 在怪异模式中使用自己的非标准模型。这些浏览器的 width 属性不是内容的宽度,而是内容、内边距和边框的宽度的总和。

虽然有方法解决这个问题。但是目前最好的解决方案是回避这个问题。也就是,不要给元素添加具有指定宽度的内边距,而是尝试将内边距或外边距添加到元素的父元素和子元素。

IE8 及更早IE版本不支持设置填充的宽度和边框的宽度属性。

解决IE8及更早版本不兼容问题可以在HTML页面声明 <!DOCTYPE html>即可。


17,浏览器内核

浏览器的内核是分为两个部分的,一是渲染引擎,另一个是JS引擎。现在JS引擎比较独立,内核更加倾向于说渲染引擎。

1、Trident内核:代表作品是IE,因IE捆绑在Windows中,所以占有极高的份额,又称为IE内核或MSHTML,此内核只能用于Windows平台,且不是开源的。

    代表作品还有腾讯、Maxthon(遨游)、360浏览器等。但由于市场份额比较大,曾经出现脱离了W3C标准的时候,同时IE版本比较多,

    存在很多的兼容性问题。

2、Gecko内核:代表作品是Firefox,即火狐浏览器。因火狐是最多的用户,故常被称为firefox内核它是开源的,最大优势是跨平台,在Microsoft Windows、Linux、MacOs X等主  要操作系统中使用。

   Mozilla是网景公司在第一次浏览器大战败给微软之后创建的。有兴趣的同学可以了解一下浏览器大战

3、Webkit内核:代表作品是Safari、曾经的Chrome,是开源的项目。

4、Presto内核:代表作品是Opera,Presto是由Opera Software开发的浏览器排版引擎,它是世界公认最快的渲染速度的引擎。在13年之后,Opera宣布加入谷歌阵营,弃用了   Presto

5、Blink内核:由Google和Opera Software开发的浏览器排版引擎,2013年4月发布。现在Chrome内核是Blink。谷歌还开发了自己的JS引擎,V8,使JS运行速度极大地提高了

讲解比较粗糙,有兴趣的同学可以google搜索下,我就算是抛砖引玉了。

2013年年底的时候,我看到了网上流传的一个叫做《Java面试题大全》的东西,认真的阅读了以后发现里面的很多题目是重复且没有价值的题目,还有不少的参考答案也是错误的,于是我花了半个月时间对这个所谓的《Java面试大全》进行了全面的修订并重新发布在我的CSDN博客。在修订的过程中,参照了当时JDK最新版本(Java 7)给出了题目的答案和相关代码,去掉了EJB 2.x、JSF等无用内容或过时内容,补充了数据结构和算法、大型网站技术架构、设计模式、UML、Spring MVC等内容并对很多知识点进行了深入的剖析,例如hashCode方法的设计、垃圾收集、并发编程、数据库事务等。当时我甚至希望把面试中经常出现的操作系统、数据库、软件测试等内容也补充进去,但是由于各种原因,最终只整理出了150道面试题。让我欣慰的是,这150道题还是帮助到了很多人,而且在我CSDN博客上的总访问量超过了5万次,最终还被很多网站和个人以原创的方式转载了。最近一年内,用百度搜索"Java面试"我写的这些东西基本上都排在搜索结果的前5名,这让我觉得"亚历山大",因为我写的这些东西一旦不准确就可能误导很多人。2014年的时候我又整理了30道题,希望把之前遗漏的面试题和知识点补充上去,但是仍然感觉挂一漏万,而且Java 8问世后很多新的东西又需要去总结和整理。为此,我不止一次的修改了之前的180题,修改到自己已经感觉有些疲惫或者厌烦了。2014年至今,自己带的学生又有很多走上了Java程序员、Java工程师的工作岗位,他们的面试经验也还没来得及跟大家分享,冥冥之中似乎有一股力量在刺激我要重新写一篇《Java面试题全集》,于是这篇文章就诞生了。请不要责备我把那些出现过的内容又写了一次,因为每次写东西就算是重复的内容,我也需要对编程语言和相关技术进行重新思考,不仅字斟句酌更是力求至臻完美,所以请相信我分享的一定是更新的、更好的、更有益的东西,这些内容也诉说着一个职业程序员和培训师的思想、精神和情感。

1、面向对象的特征有哪些方面? 
答:面向对象的特征主要有以下几个方面: 
- 抽象:抽象是将一类对象的共同特征总结出来构造类的过程,包括数据抽象和行为抽象两方面。抽象只关注对象有哪些属性和行为,并不关注这些行为的细节是什么。 
- 继承:继承是从已有类得到继承信息创建新类的过程。提供继承信息的类被称为父类(超类、基类);得到继承信息的类被称为子类(派生类)。继承让变化中的软件系统有了一定的延续性,同时继承也是封装程序中可变因素的重要手段(如果不能理解请阅读阎宏博士的《Java与模式》或《设计模式精解》中关于桥梁模式的部分)。 
- 封装:通常认为封装是把数据和操作数据的方法绑定起来,对数据的访问只能通过已定义的接口。面向对象的本质就是将现实世界描绘成一系列完全自治、封闭的对象。我们在类中编写的方法就是对实现细节的一种封装;我们编写一个类就是对数据和数据操作的封装。可以说,封装就是隐藏一切可隐藏的东西,只向外界提供最简单的编程接口(可以想想普通洗衣机和全自动洗衣机的差别,明显全自动洗衣机封装更好因此操作起来更简单;我们现在使用的智能手机也是封装得足够好的,因为几个按键就搞定了所有的事情)。 
- 多态性:多态性是指允许不同子类型的对象对同一消息作出不同的响应。简单的说就是用同样的对象引用调用同样的方法但是做了不同的事情。多态性分为编译时的多态性和运行时的多态性。如果将对象的方法视为对象向外界提供的服务,那么运行时的多态性可以解释为:当A系统访问B系统提供的服务时,B系统有多种提供服务的方式,但一切对A系统来说都是透明的(就像电动剃须刀是A系统,它的供电系统是B系统,B系统可以使用电池供电或者用交流电,甚至还有可能是太阳能,A系统只会通过B类对象调用供电的方法,但并不知道供电系统的底层实现是什么,究竟通过何种方式获得了动力)。方法重载(overload)实现的是编译时的多态性(也称为前绑定),而方法重写(override)实现的是运行时的多态性(也称为后绑定)。运行时的多态是面向对象最精髓的东西,要实现多态需要做两件事:1). 方法重写(子类继承父类并重写父类中已有的或抽象的方法);2). 对象造型(用父类型引用引用子类型对象,这样同样的引用调用同样的方法就会根据子类对象的不同而表现出不同的行为)。

2、访问修饰符public,private,protected,以及不写(默认)时的区别? 
答:

修饰符当前类同 包子 类其他包
public
protected×
default××
private×××

类的成员不写访问修饰时默认为default。默认对于同一个包中的其他类相当于公开(public),对于不是同一个包中的其他类相当于私有(private)。受保护(protected)对子类相当于公开,对不是同一包中的没有父子关系的类相当于私有。Java中,外部类的修饰符只能是public或默认,类的成员(包括内部类)的修饰符可以是以上四种。

3、String 是最基本的数据类型吗? 
答:不是。Java中的基本数据类型只有8个:byte、short、int、long、float、double、char、boolean;除了基本类型(primitive type),剩下的都是引用类型(reference type),Java 5以后引入的枚举类型也算是一种比较特殊的引用类型。

4、float f=3.4;是否正确? 
答:不正确。3.4是双精度数,将双精度型(double)赋值给浮点型(float)属于下转型(down-casting,也称为窄化)会造成精度损失,因此需要强制类型转换float f =(float)3.4; 或者写成float f =3.4F;。

5、short s1 = 1; s1 = s1 + 1;有错吗?short s1 = 1; s1 += 1;有错吗? 
答:对于short s1 = 1; s1 = s1 + 1;由于1是int类型,因此s1+1运算结果也是int 型,需要强制转换类型才能赋值给short型。而short s1 = 1; s1 += 1;可以正确编译,因为s1+= 1;相当于s1 = (short)(s1 + 1);其中有隐含的强制类型转换。

6、Java有没有goto? 
答:goto 是Java中的保留字,在目前版本的Java中没有使用。(根据James Gosling(Java之父)编写的《The Java Programming Language》一书的附录中给出了一个Java关键字列表,其中有goto和const,但是这两个是目前无法使用的关键字,因此有些地方将其称之为保留字,其实保留字这个词应该有更广泛的意义,因为熟悉C语言的程序员都知道,在系统类库中使用过的有特殊意义的单词或单词的组合都被视为保留字)

7、int和Integer有什么区别? 
答:Java是一个近乎纯洁的面向对象编程语言,但是为了编程的方便还是引入了基本数据类型,但是为了能够将这些基本数据类型当成对象操作,Java为每一个基本数据类型都引入了对应的包装类型(wrapper class),int的包装类就是Integer,从Java 5开始引入了自动装箱/拆箱机制,使得二者可以相互转换。 
Java 为每个原始类型提供了包装类型: 
- 原始类型: boolean,char,byte,short,int,long,float,double 
- 包装类型:Boolean,Character,Byte,Short,Integer,Long,Float,Double

  1. class AutoUnboxingTest {
  2. public static void main(String[] args) {
  3. Integer a = new Integer(3);
  4. Integer b = 3; // 将3自动装箱成Integer类型
  5. int c = 3;
  6. System.out.println(a == b); // false 两个引用没有引用同一对象
  7. System.out.println(a == c); // true a自动拆箱成int类型再和c比较
  8. }
  9. }

最近还遇到一个面试题,也是和自动装箱和拆箱有点关系的,代码如下所示:

  1. public class Test03 {
  2. public static void main(String[] args) {
  3. Integer f1 = 100, f2 = 100, f3 = 150, f4 = 150;
  4. System.out.println(f1 == f2);
  5. System.out.println(f3 == f4);
  6. }
  7. }

如果不明就里很容易认为两个输出要么都是true要么都是false。首先需要注意的是f1、f2、f3、f4四个变量都是Integer对象引用,所以下面的==运算比较的不是值而是引用。装箱的本质是什么呢?当我们给一个Integer对象赋一个int值的时候,会调用Integer类的静态方法valueOf,如果看看valueOf的源代码就知道发生了什么。

  1. public static Integer valueOf(int i) {
  2. if (i >= IntegerCache.low && i <= IntegerCache.high)
  3. return IntegerCache.cache[i + (-IntegerCache.low)];
  4. return new Integer(i);
  5. }

IntegerCache是Integer的内部类,其代码如下所示:

  1. /**
  2. * Cache to support the object identity semantics of autoboxing for values between
  3. * -128 and 127 (inclusive) as required by JLS.
  4. *
  5. * The cache is initialized on first usage. The size of the cache
  6. * may be controlled by the {@code -XX:AutoBoxCacheMax=<size>} option.
  7. * During VM initialization, java.lang.Integer.IntegerCache.high property
  8. * may be set and saved in the private system properties in the
  9. * sun.misc.VM class.
  10. */
  11. private static class IntegerCache {
  12. static final int low = -128;
  13. static final int high;
  14. static final Integer cache[];
  15. static {
  16. // high value may be configured by property
  17. int h = 127;
  18. String integerCacheHighPropValue =
  19. sun.misc.VM.getSavedProperty("java.lang.Integer.IntegerCache.high");
  20. if (integerCacheHighPropValue != null) {
  21. try {
  22. int i = parseInt(integerCacheHighPropValue);
  23. i = Math.max(i, 127);
  24. // Maximum array size is Integer.MAX_VALUE
  25. h = Math.min(i, Integer.MAX_VALUE - (-low) -1);
  26. } catch( NumberFormatException nfe) {
  27. // If the property cannot be parsed into an int, ignore it.
  28. }
  29. }
  30. high = h;
  31. cache = new Integer[(high - low) + 1];
  32. int j = low;
  33. for(int k = 0; k < cache.length; k++)
  34. cache[k] = new Integer(j++);
  35. // range [-128, 127] must be interned (JLS7 5.1.7)
  36. assert IntegerCache.high >= 127;
  37. }
  38. private IntegerCache() {}
  39. }

简单的说,如果整型字面量的值在-128到127之间,那么不会new新的Integer对象,而是直接引用常量池中的Integer对象,所以上面的面试题中f1==f2的结果是true,而f3==f4的结果是false。

提醒:越是貌似简单的面试题其中的玄机就越多,需要面试者有相当深厚的功力。

8、&和&&的区别? 
答:&运算符有两种用法:(1)按位与;(2)逻辑与。&&运算符是短路与运算。逻辑与跟短路与的差别是非常巨大的,虽然二者都要求运算符左右两端的布尔值都是true整个表达式的值才是true。&&之所以称为短路运算是因为,如果&&左边的表达式的值是false,右边的表达式会被直接短路掉,不会进行运算。很多时候我们可能都需要用&&而不是&,例如在验证用户登录时判定用户名不是null而且不是空字符串,应当写为:username != null &&!username.equals(""),二者的顺序不能交换,更不能用&运算符,因为第一个条件如果不成立,根本不能进行字符串的equals比较,否则会产生NullPointerException异常。注意:逻辑或运算符(|)和短路或运算符(||)的差别也是如此。

补充:如果你熟悉JavaScript,那你可能更能感受到短路运算的强大,想成为JavaScript的高手就先从玩转短路运算开始吧。

9、解释内存中的栈(stack)、堆(heap)和方法区(method area)的用法。 
答:通常我们定义一个基本数据类型的变量,一个对象的引用,还有就是函数调用的现场保存都使用JVM中的栈空间;而通过new关键字和构造器创建的对象则放在堆空间,堆是垃圾收集器管理的主要区域,由于现在的垃圾收集器都采用分代收集算法,所以堆空间还可以细分为新生代和老生代,再具体一点可以分为Eden、Survivor(又可分为From Survivor和To Survivor)、Tenured;方法区和堆都是各个线程共享的内存区域,用于存储已经被JVM加载的类信息、常量、静态变量、JIT编译器编译后的代码等数据;程序中的字面量(literal)如直接书写的100、"hello"和常量都是放在常量池中,常量池是方法区的一部分,。栈空间操作起来最快但是栈很小,通常大量的对象都是放在堆空间,栈和堆的大小都可以通过JVM的启动参数来进行调整,栈空间用光了会引发StackOverflowError,而堆和常量池空间不足则会引发OutOfMemoryError。

String str = new String("hello");

上面的语句中变量str放在栈上,用new创建出来的字符串对象放在堆上,而"hello"这个字面量是放在方法区的。

补充1:较新版本的Java(从Java 6的某个更新开始)中,由于JIT编译器的发展和"逃逸分析"技术的逐渐成熟,栈上分配、标量替换等优化技术使得对象一定分配在堆上这件事情已经变得不那么绝对了。

补充2:运行时常量池相当于Class文件常量池具有动态性,Java语言并不要求常量一定只有编译期间才能产生,运行期间也可以将新的常量放入池中,String类的intern()方法就是这样的。

看看下面代码的执行结果是什么并且比较一下Java 7以前和以后的运行结果是否一致。

  1. String s1 = new StringBuilder("go")
  2. .append("od").toString();
  3. System.out.println(s1.intern() == s1);
  4. String s2 = new StringBuilder("ja")
  5. .append("va").toString();
  6. System.out.println(s2.intern() == s2);

10、Math.round(11.5) 等于多少?Math.round(-11.5)等于多少? 
答:Math.round(11.5)的返回值是12,Math.round(-11.5)的返回值是-11。四舍五入的原理是在参数上加0.5然后进行下取整。

11、switch 是否能作用在byte 上,是否能作用在long 上,是否能作用在String上? 
答:在Java 5以前,switch(expr)中,expr只能是byte、short、char、int。从Java 5开始,Java中引入了枚举类型,expr也可以是enum类型,从Java 7开始,expr还可以是字符串(String),但是长整型(long)在目前所有的版本中都是不可以的。

12、用最有效率的方法计算2乘以8? 
答: 2 << 3(左移3位相当于乘以2的3次方,右移3位相当于除以2的3次方)。

补充:我们为编写的类重写hashCode方法时,可能会看到如下所示的代码,其实我们不太理解为什么要使用这样的乘法运算来产生哈希码(散列码),而且为什么这个数是个素数,为什么通常选择31这个数?前两个问题的答案你可以自己百度一下,选择31是因为可以用移位和减法运算来代替乘法,从而得到更好的性能。说到这里你可能已经想到了:31 * num 等价于(num << 5) - num,左移5位相当于乘以2的5次方再减去自身就相当于乘以31,现在的VM都能自动完成这个优化。

  1. public class PhoneNumber {
  2. private int areaCode;
  3. private String prefix;
  4. private String lineNumber;
  5. @Override
  6. public int hashCode() {
  7. final int prime = 31;
  8. int result = 1;
  9. result = prime * result + areaCode;
  10. result = prime * result
  11. + ((lineNumber == null) ? 0 : lineNumber.hashCode());
  12. result = prime * result + ((prefix == null) ? 0 : prefix.hashCode());
  13. return result;
  14. }
  15. @Override
  16. public boolean equals(Object obj) {
  17. if (this == obj)
  18. return true;
  19. if (obj == null)
  20. return false;
  21. if (getClass() != obj.getClass())
  22. return false;
  23. PhoneNumber other = (PhoneNumber) obj;
  24. if (areaCode != other.areaCode)
  25. return false;
  26. if (lineNumber == null) {
  27. if (other.lineNumber != null)
  28. return false;
  29. } else if (!lineNumber.equals(other.lineNumber))
  30. return false;
  31. if (prefix == null) {
  32. if (other.prefix != null)
  33. return false;
  34. } else if (!prefix.equals(other.prefix))
  35. return false;
  36. return true;
  37. }
  38. }

13、数组有没有length()方法?String有没有length()方法? 
答:数组没有length()方法,有length 的属性。String 有length()方法。JavaScript中,获得字符串的长度是通过length属性得到的,这一点容易和Java混淆。

14、在Java中,如何跳出当前的多重嵌套循环? 
答:在最外层循环前加一个标记如A,然后用break A;可以跳出多重循环。(Java中支持带标签的break和continue语句,作用有点类似于C和C++中的goto语句,但是就像要避免使用goto一样,应该避免使用带标签的break和continue,因为它不会让你的程序变得更优雅,很多时候甚至有相反的作用,所以这种语法其实不知道更好)

15、构造器(constructor)是否可被重写(override)? 
答:构造器不能被继承,因此不能被重写,但可以被重载。

16、两个对象值相同(x.equals(y) == true),但却可有不同的hash code,这句话对不对? 
答:不对,如果两个对象x和y满足x.equals(y) == true,它们的哈希码(hash code)应当相同。Java对于eqauls方法和hashCode方法是这样规定的:(1)如果两个对象相同(equals方法返回true),那么它们的hashCode值一定要相同;(2)如果两个对象的hashCode相同,它们并不一定相同。当然,你未必要按照要求去做,但是如果你违背了上述原则就会发现在使用容器时,相同的对象可以出现在Set集合中,同时增加新元素的效率会大大下降(对于使用哈希存储的系统,如果哈希码频繁的冲突将会造成存取性能急剧下降)。

补充:关于equals和hashCode方法,很多Java程序都知道,但很多人也就是仅仅知道而已,在Joshua Bloch的大作《Effective Java》(很多软件公司,《Effective Java》、《Java编程思想》以及《重构:改善既有代码质量》是Java程序员必看书籍,如果你还没看过,那就赶紧去亚马逊买一本吧)中是这样介绍equals方法的:首先equals方法必须满足自反性(x.equals(x)必须返回true)、对称性(x.equals(y)返回true时,y.equals(x)也必须返回true)、传递性(x.equals(y)和y.equals(z)都返回true时,x.equals(z)也必须返回true)和一致性(当x和y引用的对象信息没有被修改时,多次调用x.equals(y)应该得到同样的返回值),而且对于任何非null值的引用x,x.equals(null)必须返回false。实现高质量的equals方法的诀窍包括:1. 使用==操作符检查"参数是否为这个对象的引用";2. 使用instanceof操作符检查"参数是否为正确的类型";3. 对于类中的关键属性,检查参数传入对象的属性是否与之相匹配;4. 编写完equals方法后,问自己它是否满足对称性、传递性、一致性;5. 重写equals时总是要重写hashCode;6. 不要将equals方法参数中的Object对象替换为其他的类型,在重写时不要忘掉@Override注解。

17、是否可以继承String类? 
答:String 类是final类,不可以被继承。

补充:继承String本身就是一个错误的行为,对String类型最好的重用方式是关联关系(Has-A)和依赖关系(Use-A)而不是继承关系(Is-A)。

18、当一个对象被当作参数传递到一个方法后,此方法可改变这个对象的属性,并可返回变化后的结果,那么这里到底是值传递还是引用传递? 
答:是值传递。Java语言的方法调用只支持参数的值传递。当一个对象实例作为一个参数被传递到方法中时,参数的值就是对该对象的引用。对象的属性可以在被调用过程中被改变,但对对象引用的改变是不会影响到调用者的。C++和C#中可以通过传引用或传输出参数来改变传入的参数的值。在C#中可以编写如下所示的代码,但是在Java中却做不到。

  1. using System;
  2. namespace CS01 {
  3. class Program {
  4. public static void swap(ref int x, ref int y) {
  5. int temp = x;
  6. x = y;
  7. y = temp;
  8. }
  9. public static void Main (string[] args) {
  10. int a = 5, b = 10;
  11. swap (ref a, ref b);
  12. // a = 10, b = 5;
  13. Console.WriteLine ("a = {0}, b = {1}", a, b);
  14. }
  15. }
  16. }

说明:Java中没有传引用实在是非常的不方便,这一点在Java 8中仍然没有得到改进,正是如此在Java编写的代码中才会出现大量的Wrapper类(将需要通过方法调用修改的引用置于一个Wrapper类中,再将Wrapper对象传入方法),这样的做法只会让代码变得臃肿,尤其是让从C和C++转型为Java程序员的开发者无法容忍。

19、String和StringBuilder、StringBuffer的区别? 
答:Java平台提供了两种类型的字符串:String和StringBuffer/StringBuilder,它们可以储存和操作字符串。其中String是只读字符串,也就意味着String引用的字符串内容是不能被改变的。而StringBuffer/StringBuilder类表示的字符串对象可以直接进行修改。StringBuilder是Java 5中引入的,它和StringBuffer的方法完全相同,区别在于它是在单线程环境下使用的,因为它的所有方面都没有被synchronized修饰,因此它的效率也比StringBuffer要高。

面试题1 - 什么情况下用+运算符进行字符串连接比调用StringBuffer/StringBuilder对象的append方法连接字符串性能更好?

面试题2 - 请说出下面程序的输出。

  1. class StringEqualTest {
  2. public static void main(String[] args) {
  3. String s1 = "Programming";
  4. String s2 = new String("Programming");
  5. String s3 = "Program";
  6. String s4 = "ming";
  7. String s5 = "Program" + "ming";
  8. String s6 = s3 + s4;
  9. System.out.println(s1 == s2);
  10. System.out.println(s1 == s5);
  11. System.out.println(s1 == s6);
  12. System.out.println(s1 == s6.intern());
  13. System.out.println(s2 == s2.intern());
  14. }
  15. }

补充:解答上面的面试题需要清除两点:1. String对象的intern方法会得到字符串对象在常量池中对应的版本的引用(如果常量池中有一个字符串与String对象的equals结果是true),如果常量池中没有对应的字符串,则该字符串将被添加到常量池中,然后返回常量池中字符串的引用;2. 字符串的+操作其本质是创建了StringBuilder对象进行append操作,然后将拼接后的StringBuilder对象用toString方法处理成String对象,这一点可以用javap -c StringEqualTest.class命令获得class文件对应的JVM字节码指令就可以看出来。

20、重载(Overload)和重写(Override)的区别。重载的方法能否根据返回类型进行区分? 
答:方法的重载和重写都是实现多态的方式,区别在于前者实现的是编译时的多态性,而后者实现的是运行时的多态性。重载发生在一个类中,同名的方法如果有不同的参数列表(参数类型不同、参数个数不同或者二者都不同)则视为重载;重写发生在子类与父类之间,重写要求子类被重写方法与父类被重写方法有相同的返回类型,比父类被重写方法更好访问,不能比父类被重写方法声明更多的异常(里氏代换原则)。重载对返回类型没有特殊的要求。

面试题:华为的面试题中曾经问过这样一个问题 - "为什么不能根据返回类型来区分重载",快说出你的答案吧!

21、描述一下JVM加载class文件的原理机制? 
答:JVM中类的装载是由类加载器(ClassLoader)和它的子类来实现的,Java中的类加载器是一个重要的Java运行时系统组件,它负责在运行时查找和装入类文件中的类。 
由于Java的跨平台性,经过编译的Java源程序并不是一个可执行程序,而是一个或多个类文件。当Java程序需要使用某个类时,JVM会确保这个类已经被加载、连接(验证、准备和解析)和初始化。类的加载是指把类的.class文件中的数据读入到内存中,通常是创建一个字节数组读入.class文件,然后产生与所加载类对应的Class对象。加载完成后,Class对象还不完整,所以此时的类还不可用。当类被加载后就进入连接阶段,这一阶段包括验证、准备(为静态变量分配内存并设置默认的初始值)和解析(将符号引用替换为直接引用)三个步骤。最后JVM对类进行初始化,包括:1)如果类存在直接的父类并且这个类还没有被初始化,那么就先初始化父类;2)如果类中存在初始化语句,就依次执行这些初始化语句。 
类的加载是由类加载器完成的,类加载器包括:根加载器(BootStrap)、扩展加载器(Extension)、系统加载器(System)和用户自定义类加载器(java.lang.ClassLoader的子类)。从Java 2(JDK 1.2)开始,类加载过程采取了父亲委托机制(PDM)。PDM更好的保证了Java平台的安全性,在该机制中,JVM自带的Bootstrap是根加载器,其他的加载器都有且仅有一个父类加载器。类的加载首先请求父类加载器加载,父类加载器无能为力时才由其子类加载器自行加载。JVM不会向Java程序提供对Bootstrap的引用。下面是关于几个类加载器的说明:

  • Bootstrap:一般用本地代码实现,负责加载JVM基础核心类库(rt.jar);
  • Extension:从java.ext.dirs系统属性所指定的目录中加载类库,它的父加载器是Bootstrap;
  • System:又叫应用类加载器,其父类是Extension。它是应用最广泛的类加载器。它从环境变量classpath或者系统属性java.class.path所指定的目录中记载类,是用户自定义加载器的默认父加载器。

22、char 型变量中能不能存贮一个中文汉字,为什么? 
答:char类型可以存储一个中文汉字,因为Java中使用的编码是Unicode(不选择任何特定的编码,直接使用字符在字符集中的编号,这是统一的唯一方法),一个char类型占2个字节(16比特),所以放一个中文是没问题的。

补充:使用Unicode意味着字符在JVM内部和外部有不同的表现形式,在JVM内部都是Unicode,当这个字符被从JVM内部转移到外部时(例如存入文件系统中),需要进行编码转换。所以Java中有字节流和字符流,以及在字符流和字节流之间进行转换的转换流,如InputStreamReader和OutputStreamReader,这两个类是字节流和字符流之间的适配器类,承担了编码转换的任务;对于C程序员来说,要完成这样的编码转换恐怕要依赖于union(联合体/共用体)共享内存的特征来实现了。

23、抽象类(abstract class)和接口(interface)有什么异同? 
答:抽象类和接口都不能够实例化,但可以定义抽象类和接口类型的引用。一个类如果继承了某个抽象类或者实现了某个接口都需要对其中的抽象方法全部进行实现,否则该类仍然需要被声明为抽象类。接口比抽象类更加抽象,因为抽象类中可以定义构造器,可以有抽象方法和具体方法,而接口中不能定义构造器而且其中的方法全部都是抽象方法。抽象类中的成员可以是private、默认、protected、public的,而接口中的成员全都是public的。抽象类中可以定义成员变量,而接口中定义的成员变量实际上都是常量。有抽象方法的类必须被声明为抽象类,而抽象类未必要有抽象方法。

24、静态嵌套类(Static Nested Class)和内部类(Inner Class)的不同? 
答:Static Nested Class是被声明为静态(static)的内部类,它可以不依赖于外部类实例被实例化。而通常的内部类需要在外部类实例化后才能实例化,其语法看起来挺诡异的,如下所示。

  1. /**
  2. * 扑克类(一副扑克)
  3. * @author 骆昊
  4. *
  5. */
  6. public class Poker {
  7. private static String[] suites = {"黑桃", "红桃", "草花", "方块"};
  8. private static int[] faces = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13};
  9. private Card[] cards;
  10. /**
  11. * 构造器
  12. *
  13. */
  14. public Poker() {
  15. cards = new Card[52];
  16. for(int i = 0; i < suites.length; i++) {
  17. for(int j = 0; j < faces.length; j++) {
  18. cards[i * 13 + j] = new Card(suites[i], faces[j]);
  19. }
  20. }
  21. }
  22. /**
  23. * 洗牌 (随机乱序)
  24. *
  25. */
  26. public void shuffle() {
  27. for(int i = 0, len = cards.length; i < len; i++) {
  28. int index = (int) (Math.random() * len);
  29. Card temp = cards[index];
  30. cards[index] = cards[i];
  31. cards[i] = temp;
  32. }
  33. }
  34. /**
  35. * 发牌
  36. * @param index 发牌的位置
  37. *
  38. */
  39. public Card deal(int index) {
  40. return cards[index];
  41. }
  42. /**
  43. * 卡片类(一张扑克)
  44. * [内部类]
  45. * @author 骆昊
  46. *
  47. */
  48. public class Card {
  49. private String suite; // 花色
  50. private int face; // 点数
  51. public Card(String suite, int face) {
  52. this.suite = suite;
  53. this.face = face;
  54. }
  55. @Override
  56. public String toString() {
  57. String faceStr = "";
  58. switch(face) {
  59. case 1: faceStr = "A"; break;
  60. case 11: faceStr = "J"; break;
  61. case 12: faceStr = "Q"; break;
  62. case 13: faceStr = "K"; break;
  63. default: faceStr = String.valueOf(face);
  64. }
  65. return suite + faceStr;
  66. }
  67. }
  68. }

测试代码:

  1. class PokerTest {
  2. public static void main(String[] args) {
  3. Poker poker = new Poker();
  4. poker.shuffle(); // 洗牌
  5. Poker.Card c1 = poker.deal(0); // 发第一张牌
  6. // 对于非静态内部类Card
  7. // 只有通过其外部类Poker对象才能创建Card对象
  8. Poker.Card c2 = poker.new Card("红心", 1); // 自己创建一张牌
  9. System.out.println(c1); // 洗牌后的第一张
  10. System.out.println(c2); // 打印: 红心A
  11. }
  12. }

面试题 - 下面的代码哪些地方会产生编译错误?

  1. class Outer {
  2. class Inner {}
  3. public static void foo() { new Inner(); }
  4. public void bar() { new Inner(); }
  5. public static void main(String[] args) {
  6. new Inner();
  7. }
  8. }

注意:Java中非静态内部类对象的创建要依赖其外部类对象,上面的面试题中foo和main方法都是静态方法,静态方法中没有this,也就是说没有所谓的外部类对象,因此无法创建内部类对象,如果要在静态方法中创建内部类对象,可以这样做:

    new Outer().new Inner();

25、Java 中会存在内存泄漏吗,请简单描述。 
答:理论上Java因为有垃圾回收机制(GC)不会存在内存泄露问题(这也是Java被广泛使用于服务器端编程的一个重要原因);然而在实际开发中,可能会存在无用但可达的对象,这些对象不能被GC回收,因此也会导致内存泄露的发生。例如Hibernate的Session(一级缓存)中的对象属于持久态,垃圾回收器是不会回收这些对象的,然而这些对象中可能存在无用的垃圾对象,如果不及时关闭(close)或清空(flush)一级缓存就可能导致内存泄露。下面例子中的代码也会导致内存泄露。

  1. import java.util.Arrays;
  2. import java.util.EmptyStackException;
  3. public class MyStack<T> {
  4. private T[] elements;
  5. private int size = 0;
  6. private static final int INIT_CAPACITY = 16;
  7. public MyStack() {
  8. elements = (T[]) new Object[INIT_CAPACITY];
  9. }
  10. public void push(T elem) {
  11. ensureCapacity();
  12. elements[size++] = elem;
  13. }
  14. public T pop() {
  15. if(size == 0)
  16. throw new EmptyStackException();
  17. return elements[--size];
  18. }
  19. private void ensureCapacity() {
  20. if(elements.length == size) {
  21. elements = Arrays.copyOf(elements, 2 * size + 1);
  22. }
  23. }
  24. }

上面的代码实现了一个栈(先进后出(FILO))结构,乍看之下似乎没有什么明显的问题,它甚至可以通过你编写的各种单元测试。然而其中的pop方法却存在内存泄露的问题,当我们用pop方法弹出栈中的对象时,该对象不会被当作垃圾回收,即使使用栈的程序不再引用这些对象,因为栈内部维护着对这些对象的过期引用(obsolete reference)。在支持垃圾回收的语言中,内存泄露是很隐蔽的,这种内存泄露其实就是无意识的对象保持。如果一个对象引用被无意识的保留起来了,那么垃圾回收器不会处理这个对象,也不会处理该对象引用的其他对象,即使这样的对象只有少数几个,也可能会导致很多的对象被排除在垃圾回收之外,从而对性能造成重大影响,极端情况下会引发Disk Paging(物理内存与硬盘的虚拟内存交换数据),甚至造成OutOfMemoryError。

26、抽象的(abstract)方法是否可同时是静态的(static),是否可同时是本地方法(native),是否可同时被synchronized修饰? 
答:都不能。抽象方法需要子类重写,而静态的方法是无法被重写的,因此二者是矛盾的。本地方法是由本地代码(如C代码)实现的方法,而抽象方法是没有实现的,也是矛盾的。synchronized和方法的实现细节有关,抽象方法不涉及实现细节,因此也是相互矛盾的。

27、阐述静态变量和实例变量的区别。 
答:静态变量是被static修饰符修饰的变量,也称为类变量,它属于类,不属于类的任何一个对象,一个类不管创建多少个对象,静态变量在内存中有且仅有一个拷贝;实例变量必须依存于某一实例,需要先创建对象然后通过对象才能访问到它。静态变量可以实现让多个对象共享内存。

补充:在Java开发中,上下文类和工具类中通常会有大量的静态成员。

28、是否可以从一个静态(static)方法内部发出对非静态(non-static)方法的调用? 
答:不可以,静态方法只能访问静态成员,因为非静态方法的调用要先创建对象,在调用静态方法时可能对象并没有被初始化。

29、如何实现对象克隆? 
答:有两种方式: 
  1). 实现Cloneable接口并重写Object类中的clone()方法; 
  2). 实现Serializable接口,通过对象的序列化和反序列化实现克隆,可以实现真正的深度克隆,代码如下。

  1. import java.io.ByteArrayInputStream;
  2. import java.io.ByteArrayOutputStream;
  3. import java.io.ObjectInputStream;
  4. import java.io.ObjectOutputStream;
  5. import java.io.Serializable;
  6. public class MyUtil {
  7. private MyUtil() {
  8. throw new AssertionError();
  9. }
  10. @SuppressWarnings("unchecked")
  11. public static <T extends Serializable> T clone(T obj) throws Exception {
  12. ByteArrayOutputStream bout = new ByteArrayOutputStream();
  13. ObjectOutputStream oos = new ObjectOutputStream(bout);
  14. oos.writeObject(obj);
  15. ByteArrayInputStream bin = new ByteArrayInputStream(bout.toByteArray());
  16. ObjectInputStream ois = new ObjectInputStream(bin);
  17. return (T) ois.readObject();
  18. // 说明:调用ByteArrayInputStream或ByteArrayOutputStream对象的close方法没有任何意义
  19. // 这两个基于内存的流只要垃圾回收器清理对象就能够释放资源,这一点不同于对外部资源(如文件流)的释放
  20. }
  21. }

下面是测试代码:

  1. import java.io.Serializable;
  2. /**
  3. * 人类
  4. * @author 骆昊
  5. *
  6. */
  7. class Person implements Serializable {
  8. private static final long serialVersionUID = -9102017020286042305L;
  9. private String name; // 姓名
  10. private int age; // 年龄
  11. private Car car; // 座驾
  12. public Person(String name, int age, Car car) {
  13. this.name = name;
  14. this.age = age;
  15. this.car = car;
  16. }
  17. public String getName() {
  18. return name;
  19. }
  20. public void setName(String name) {
  21. this.name = name;
  22. }
  23. public int getAge() {
  24. return age;
  25. }
  26. public void setAge(int age) {
  27. this.age = age;
  28. }
  29. public Car getCar() {
  30. return car;
  31. }
  32. public void setCar(Car car) {
  33. this.car = car;
  34. }
  35. @Override
  36. public String toString() {
  37. return "Person [name=" + name + ", age=" + age + ", car=" + car + "]";
  38. }
  39. }
  1. /**
  2. * 小汽车类
  3. * @author 骆昊
  4. *
  5. */
  6. class Car implements Serializable {
  7. private static final long serialVersionUID = -5713945027627603702L;
  8. private String brand; // 品牌
  9. private int maxSpeed; // 最高时速
  10. public Car(String brand, int maxSpeed) {
  11. this.brand = brand;
  12. this.maxSpeed = maxSpeed;
  13. }
  14. public String getBrand() {
  15. return brand;
  16. }
  17. public void setBrand(String brand) {
  18. this.brand = brand;
  19. }
  20. public int getMaxSpeed() {
  21. return maxSpeed;
  22. }
  23. public void setMaxSpeed(int maxSpeed) {
  24. this.maxSpeed = maxSpeed;
  25. }
  26. @Override
  27. public String toString() {
  28. return "Car [brand=" + brand + ", maxSpeed=" + maxSpeed + "]";
  29. }
  30. }
  1. class CloneTest {
  2. public static void main(String[] args) {
  3. try {
  4. Person p1 = new Person("Hao LUO", 33, new Car("Benz", 300));
  5. Person p2 = MyUtil.clone(p1); // 深度克隆
  6. p2.getCar().setBrand("BYD");
  7. // 修改克隆的Person对象p2关联的汽车对象的品牌属性
  8. // 原来的Person对象p1关联的汽车不会受到任何影响
  9. // 因为在克隆Person对象时其关联的汽车对象也被克隆了
  10. System.out.println(p1);
  11. } catch (Exception e) {
  12. e.printStackTrace();
  13. }
  14. }
  15. }

注意:基于序列化和反序列化实现的克隆不仅仅是深度克隆,更重要的是通过泛型限定,可以检查出要克隆的对象是否支持序列化,这项检查是编译器完成的,不是在运行时抛出异常,这种是方案明显优于使用Object类的clone方法克隆对象。让问题在编译的时候暴露出来总是好过把问题留到运行时。

30、GC是什么?为什么要有GC? 
答:GC是垃圾收集的意思,内存处理是编程人员容易出现问题的地方,忘记或者错误的内存回收会导致程序或系统的不稳定甚至崩溃,Java提供的GC功能可以自动监测对象是否超过作用域从而达到自动回收内存的目的,Java语言没有提供释放已分配内存的显示操作方法。Java程序员不用担心内存管理,因为垃圾收集器会自动进行管理。要请求垃圾收集,可以调用下面的方法之一:System.gc() 或Runtime.getRuntime().gc() ,但JVM可以屏蔽掉显示的垃圾回收调用。 
垃圾回收可以有效的防止内存泄露,有效的使用可以使用的内存。垃圾回收器通常是作为一个单独的低优先级的线程运行,不可预知的情况下对内存堆中已经死亡的或者长时间没有使用的对象进行清除和回收,程序员不能实时的调用垃圾回收器对某个对象或所有对象进行垃圾回收。在Java诞生初期,垃圾回收是Java最大的亮点之一,因为服务器端的编程需要有效的防止内存泄露问题,然而时过境迁,如今Java的垃圾回收机制已经成为被诟病的东西。移动智能终端用户通常觉得iOS的系统比Android系统有更好的用户体验,其中一个深层次的原因就在于Android系统中垃圾回收的不可预知性。

补充:垃圾回收机制有很多种,包括:分代复制垃圾回收、标记垃圾回收、增量垃圾回收等方式。标准的Java进程既有栈又有堆。栈保存了原始型局部变量,堆保存了要创建的对象。Java平台对堆内存回收和再利用的基本算法被称为标记和清除,但是Java对其进行了改进,采用“分代式垃圾收集”。这种方法会跟Java对象的生命周期将堆内存划分为不同的区域,在垃圾收集过程中,可能会将对象移动到不同区域: 
- 伊甸园(Eden):这是对象最初诞生的区域,并且对大多数对象来说,这里是它们唯一存在过的区域。 
- 幸存者乐园(Survivor):从伊甸园幸存下来的对象会被挪到这里。 
- 终身颐养园(Tenured):这是足够老的幸存对象的归宿。年轻代收集(Minor-GC)过程是不会触及这个地方的。当年轻代收集不能把对象放进终身颐养园时,就会触发一次完全收集(Major-GC),这里可能还会牵扯到压缩,以便为大对象腾出足够的空间。

与垃圾回收相关的JVM参数:

  • -Xms / -Xmx — 堆的初始大小 / 堆的最大大小
  • -Xmn — 堆中年轻代的大小
  • -XX:-DisableExplicitGC — 让System.gc()不产生任何作用
  • -XX:+PrintGCDetails — 打印GC的细节
  • -XX:+PrintGCDateStamps — 打印GC操作的时间戳
  • -XX:NewSize / XX:MaxNewSize — 设置新生代大小/新生代最大大小
  • -XX:NewRatio — 可以设置老生代和新生代的比例
  • -XX:PrintTenuringDistribution — 设置每次新生代GC后输出幸存者乐园中对象年龄的分布
  • -XX:InitialTenuringThreshold / -XX:MaxTenuringThreshold:设置老年代阀值的初始值和最大值
  • -XX:TargetSurvivorRatio:设置幸存区的目标使用率

31、String s = new String("xyz");创建了几个字符串对象? 
答:两个对象,一个是静态区的"xyz",一个是用new创建在堆上的对象。

32、接口是否可继承(extends)接口?抽象类是否可实现(implements)接口?抽象类是否可继承具体类(concrete class)? 
答:接口可以继承接口,而且支持多重继承。抽象类可以实现(implements)接口,抽象类可继承具体类也可以继承抽象类。

33、一个".java"源文件中是否可以包含多个类(不是内部类)?有什么限制? 
答:可以,但一个源文件中最多只能有一个公开类(public class)而且文件名必须和公开类的类名完全保持一致。

34、Anonymous Inner Class(匿名内部类)是否可以继承其它类?是否可以实现接口? 
答:可以继承其他类或实现其他接口,在Swing编程和Android开发中常用此方式来实现事件监听和回调。

35、内部类可以引用它的包含类(外部类)的成员吗?有没有什么限制? 
答:一个内部类对象可以访问创建它的外部类对象的成员,包括私有成员。

36、Java 中的final关键字有哪些用法? 
答:(1)修饰类:表示该类不能被继承;(2)修饰方法:表示方法不能被重写;(3)修饰变量:表示变量只能一次赋值以后值不能被修改(常量)。

37、指出下面程序的运行结果。

  1. class A {
  2. static {
  3. System.out.print("1");
  4. }
  5. public A() {
  6. System.out.print("2");
  7. }
  8. }
  9. class B extends A{
  10. static {
  11. System.out.print("a");
  12. }
  13. public B() {
  14. System.out.print("b");
  15. }
  16. }
  17. public class Hello {
  18. public static void main(String[] args) {
  19. A ab = new B();
  20. ab = new B();
  21. }
  22. }

答:执行结果:1a2b2b。创建对象时构造器的调用顺序是:先初始化静态成员,然后调用父类构造器,再初始化非静态成员,最后调用自身构造器。

提示:如果不能给出此题的正确答案,说明之前第21题Java类加载机制还没有完全理解,赶紧再看看吧。

38、数据类型之间的转换: 
- 如何将字符串转换为基本数据类型? 
- 如何将基本数据类型转换为字符串? 
答: 
- 调用基本数据类型对应的包装类中的方法parseXXX(String)或valueOf(String)即可返回相应基本类型; 
- 一种方法是将基本数据类型与空字符串("")连接(+)即可获得其所对应的字符串;另一种方法是调用String 类中的valueOf()方法返回相应字符串

39、如何实现字符串的反转及替换? 
答:方法很多,可以自己写实现也可以使用String或StringBuffer/StringBuilder中的方法。有一道很常见的面试题是用递归实现字符串反转,代码如下所示:

  1. public static String reverse(String originStr) {
  2. if(originStr == null || originStr.length() <= 1)
  3. return originStr;
  4. return reverse(originStr.substring(1)) + originStr.charAt(0);
  5. }

40、怎样将GB2312编码的字符串转换为ISO-8859-1编码的字符串? 
答:代码如下所示:

  1. String s1 = "你好";
  2. String s2 = new String(s1.getBytes("GB2312"), "ISO-8859-1");

41、日期和时间: 
- 如何取得年月日、小时分钟秒? 
- 如何取得从1970年1月1日0时0分0秒到现在的毫秒数? 
- 如何取得某月的最后一天? 
- 如何格式化日期? 
答: 
问题1:创建java.util.Calendar 实例,调用其get()方法传入不同的参数即可获得参数所对应的值。Java 8中可以使用java.time.LocalDateTimel来获取,代码如下所示。

  1. public class DateTimeTest {
  2. public static void main(String[] args) {
  3. Calendar cal = Calendar.getInstance();
  4. System.out.println(cal.get(Calendar.YEAR));
  5. System.out.println(cal.get(Calendar.MONTH)); // 0 - 11
  6. System.out.println(cal.get(Calendar.DATE));
  7. System.out.println(cal.get(Calendar.HOUR_OF_DAY));
  8. System.out.println(cal.get(Calendar.MINUTE));
  9. System.out.println(cal.get(Calendar.SECOND));
  10. // Java 8
  11. LocalDateTime dt = LocalDateTime.now();
  12. System.out.println(dt.getYear());
  13. System.out.println(dt.getMonthValue()); // 1 - 12
  14. System.out.println(dt.getDayOfMonth());
  15. System.out.println(dt.getHour());
  16. System.out.println(dt.getMinute());
  17. System.out.println(dt.getSecond());
  18. }
  19. }

问题2:以下方法均可获得该毫秒数。

  1. Calendar.getInstance().getTimeInMillis();
  2. System.currentTimeMillis();
  3. Clock.systemDefaultZone().millis(); // Java 8

问题3:代码如下所示。

  1. Calendar time = Calendar.getInstance();
  2. time.getActualMaximum(Calendar.DAY_OF_MONTH);

问题4:利用java.text.DataFormat 的子类(如SimpleDateFormat类)中的format(Date)方法可将日期格式化。Java 8中可以用java.time.format.DateTimeFormatter来格式化时间日期,代码如下所示。

  1. import java.text.SimpleDateFormat;
  2. import java.time.LocalDate;
  3. import java.time.format.DateTimeFormatter;
  4. import java.util.Date;
  5. class DateFormatTest {
  6. public static void main(String[] args) {
  7. SimpleDateFormat oldFormatter = new SimpleDateFormat("yyyy/MM/dd");
  8. Date date1 = new Date();
  9. System.out.println(oldFormatter.format(date1));
  10. // Java 8
  11. DateTimeFormatter newFormatter = DateTimeFormatter.ofPattern("yyyy/MM/dd");
  12. LocalDate date2 = LocalDate.now();
  13. System.out.println(date2.format(newFormatter));
  14. }
  15. }

补充:Java的时间日期API一直以来都是被诟病的东西,为了解决这一问题,Java 8中引入了新的时间日期API,其中包括LocalDate、LocalTime、LocalDateTime、Clock、Instant等类,这些的类的设计都使用了不变模式,因此是线程安全的设计。如果不理解这些内容,可以参考我的另一篇文章《关于Java并发编程的总结和思考》

42、打印昨天的当前时刻。 
答:

  1. import java.util.Calendar;
  2. class YesterdayCurrent {
  3. public static void main(String[] args){
  4. Calendar cal = Calendar.getInstance();
  5. cal.add(Calendar.DATE, -1);
  6. System.out.println(cal.getTime());
  7. }
  8. }

在Java 8中,可以用下面的代码实现相同的功能。

  1. import java.time.LocalDateTime;
  2. class YesterdayCurrent {
  3. public static void main(String[] args) {
  4. LocalDateTime today = LocalDateTime.now();
  5. LocalDateTime yesterday = today.minusDays(1);
  6. System.out.println(yesterday);
  7. }
  8. }

43、比较一下Java和JavaSciprt。 
答:JavaScript 与Java是两个公司开发的不同的两个产品。Java 是原Sun Microsystems公司推出的面向对象的程序设计语言,特别适合于互联网应用程序开发;而JavaScript是Netscape公司的产品,为了扩展Netscape浏览器的功能而开发的一种可以嵌入Web页面中运行的基于对象和事件驱动的解释性语言。JavaScript的前身是LiveScript;而Java的前身是Oak语言。 
下面对两种语言间的异同作如下比较: 
- 基于对象和面向对象:Java是一种真正的面向对象的语言,即使是开发简单的程序,必须设计对象;JavaScript是种脚本语言,它可以用来制作与网络无关的,与用户交互作用的复杂软件。它是一种基于对象(Object-Based)和事件驱动(Event-Driven)的编程语言,因而它本身提供了非常丰富的内部对象供设计人员使用。 
- 解释和编译:Java的源代码在执行之前,必须经过编译。JavaScript是一种解释性编程语言,其源代码不需经过编译,由浏览器解释执行。(目前的浏览器几乎都使用了JIT(即时编译)技术来提升JavaScript的运行效率) 
- 强类型变量和类型弱变量:Java采用强类型变量检查,即所有变量在编译之前必须作声明;JavaScript中变量是弱类型的,甚至在使用变量前可以不作声明,JavaScript的解释器在运行时检查推断其数据类型。 
- 代码格式不一样。

补充:上面列出的四点是网上流传的所谓的标准答案。其实Java和JavaScript最重要的区别是一个是静态语言,一个是动态语言。目前的编程语言的发展趋势是函数式语言和动态语言。在Java中类(class)是一等公民,而JavaScript中函数(function)是一等公民,因此JavaScript支持函数式编程,可以使用Lambda函数和闭包(closure),当然Java 8也开始支持函数式编程,提供了对Lambda表达式以及函数式接口的支持。对于这类问题,在面试的时候最好还是用自己的语言回答会更加靠谱,不要背网上所谓的标准答案。

44、什么时候用断言(assert)? 
答:断言在软件开发中是一种常用的调试方式,很多开发语言中都支持这种机制。一般来说,断言用于保证程序最基本、关键的正确性。断言检查通常在开发和测试时开启。为了保证程序的执行效率,在软件发布后断言检查通常是关闭的。断言是一个包含布尔表达式的语句,在执行这个语句时假定该表达式为true;如果表达式的值为false,那么系统会报告一个AssertionError。断言的使用如下面的代码所示:

assert(a > 0); // throws an AssertionError if a <= 0

断言可以有两种形式: 
assert Expression1; 
assert Expression1 : Expression2 ; 
Expression1 应该总是产生一个布尔值。 
Expression2 可以是得出一个值的任意表达式;这个值用于生成显示更多调试信息的字符串消息。

要在运行时启用断言,可以在启动JVM时使用-enableassertions或者-ea标记。要在运行时选择禁用断言,可以在启动JVM时使用-da或者-disableassertions标记。要在系统类中启用或禁用断言,可使用-esa或-dsa标记。还可以在包的基础上启用或者禁用断言。

注意:断言不应该以任何方式改变程序的状态。简单的说,如果希望在不满足某些条件时阻止代码的执行,就可以考虑用断言来阻止它。

45、Error和Exception有什么区别? 
答:Error表示系统级的错误和程序不必处理的异常,是恢复不是不可能但很困难的情况下的一种严重问题;比如内存溢出,不可能指望程序能处理这样的情况;Exception表示需要捕捉或者需要程序进行处理的异常,是一种设计或实现问题;也就是说,它表示如果程序运行正常,从不会发生的情况。

面试题:2005年摩托罗拉的面试中曾经问过这么一个问题“If a process reports a stack overflow run-time error, what’s the most possible cause?”,给了四个选项a. lack of memory; b. write on an invalid memory space; c. recursive function calling; d. array index out of boundary. Java程序在运行时也可能会遭遇StackOverflowError,这是一个无法恢复的错误,只能重新修改代码了,这个面试题的答案是c。如果写了不能迅速收敛的递归,则很有可能引发栈溢出的错误,如下所示:

  1. class StackOverflowErrorTest {
  2. public static void main(String[] args) {
  3. main(null);
  4. }
  5. }

提示:用递归编写程序时一定要牢记两点:1. 递归公式;2. 收敛条件(什么时候就不再继续递归)。

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

注意:在finally中改变返回值的做法是不好的,因为如果存在finally代码块,try中的return语句不会立马返回调用者,而是记录下返回值待finally代码块执行完毕之后再向调用者返回其值,然后如果在finally中修改了返回值,就会返回修改后的值。显然,在finally中返回或者修改返回值会对程序造成很大的困扰,C#中直接用编译错误的方式来阻止程序员干这种龌龊的事情,Java中也可以通过提升编译器的语法检查级别来产生警告或错误,Eclipse中可以在如图所示的地方进行设置,强烈建议将此项设置为编译错误。

这里写图片描述

47、Java语言如何进行异常处理,关键字:throws、throw、try、catch、finally分别如何使用? 
答:Java通过面向对象的方法进行异常处理,把各种不同的异常进行分类,并提供了良好的接口。在Java中,每个异常都是一个对象,它是Throwable类或其子类的实例。当一个方法出现异常后便抛出一个异常对象,该对象中包含有异常信息,调用这个对象的方法可以捕获到这个异常并可以对其进行处理。Java的异常处理是通过5个关键词来实现的:try、catch、throw、throws和finally。一般情况下是用try来执行一段程序,如果系统会抛出(throw)一个异常对象,可以通过它的类型来捕获(catch)它,或通过总是执行代码块(finally)来处理;try用来指定一块预防所有异常的程序;catch子句紧跟在try块后面,用来指定你想要捕获的异常的类型;throw语句用来明确地抛出一个异常;throws用来声明一个方法可能抛出的各种异常(当然声明异常时允许无病呻吟);finally为确保一段代码不管发生什么异常状况都要被执行;try语句可以嵌套,每当遇到一个try语句,异常的结构就会被放入异常栈中,直到所有的try语句都完成。如果下一级的try语句没有对某种异常进行处理,异常栈就会执行出栈操作,直到遇到有处理这种异常的try语句或者最终将异常抛给JVM。

48、运行时异常与受检异常有何异同? 
答:异常表示程序运行过程中可能出现的非正常状态,运行时异常表示虚拟机的通常操作中可能遇到的异常,是一种常见运行错误,只要程序设计得没有问题通常就不会发生。受检异常跟程序运行的上下文环境有关,即使程序设计无误,仍然可能因使用的问题而引发。Java编译器要求方法必须声明抛出可能发生的受检异常,但是并不要求必须声明抛出未被捕获的运行时异常。异常和继承一样,是面向对象程序设计中经常被滥用的东西,在Effective Java中对异常的使用给出了以下指导原则: 
- 不要将异常处理用于正常的控制流(设计良好的API不应该强迫它的调用者为了正常的控制流而使用异常) 
- 对可以恢复的情况使用受检异常,对编程错误使用运行时异常 
- 避免不必要的使用受检异常(可以通过一些状态检测手段来避免异常的发生) 
- 优先使用标准的异常 
- 每个方法抛出的异常都要有文档 
- 保持异常的原子性 
- 不要在catch中忽略掉捕获到的异常

49、列出一些你常见的运行时异常? 
答: 
- ArithmeticException(算术异常) 
- ClassCastException (类转换异常) 
- IllegalArgumentException (非法参数异常) 
- IndexOutOfBoundsException (下标越界异常) 
- NullPointerException (空指针异常) 
- SecurityException (安全异常)

50、阐述final、finally、finalize的区别。 
答: 
- final:修饰符(关键字)有三种用法:如果一个类被声明为final,意味着它不能再派生出新的子类,即不能被继承,因此它和abstract是反义词。将变量声明为final,可以保证它们在使用中不被改变,被声明为final的变量必须在声明时给定初值,而在以后的引用中只能读取不可修改。被声明为final的方法也同样只能使用,不能在子类中被重写。 
- finally:通常放在try…catch…的后面构造总是执行代码块,这就意味着程序无论正常执行还是发生异常,这里的代码只要JVM不关闭都能执行,可以将释放外部资源的代码写在finally块中。 
- finalize:Object类中定义的方法,Java中允许使用finalize()方法在垃圾收集器将对象从内存中清除出去之前做必要的清理工作。这个方法是由垃圾收集器在销毁对象时调用的,通过重写finalize()方法可以整理系统资源或者执行其他清理工作。

51、类ExampleA继承Exception,类ExampleB继承ExampleA。 
有如下代码片断:

  1. try {
  2. throw new ExampleB("b")
  3. } catch(ExampleA e){
  4. System.out.println("ExampleA");
  5. } catch(Exception e){
  6. System.out.println("Exception");
  7. }

请问执行此段代码的输出是什么? 
答:输出:ExampleA。(根据里氏代换原则[能使用父类型的地方一定能使用子类型],抓取ExampleA类型异常的catch块能够抓住try块中抛出的ExampleB类型的异常)

面试题 - 说出下面代码的运行结果。(此题的出处是《Java编程思想》一书)

  1. class Annoyance extends Exception {}
  2. class Sneeze extends Annoyance {}
  3. class Human {
  4. public static void main(String[] args)
  5. throws Exception {
  6. try {
  7. try {
  8. throw new Sneeze();
  9. }
  10. catch ( Annoyance a ) {
  11. System.out.println("Caught Annoyance");
  12. throw a;
  13. }
  14. }
  15. catch ( Sneeze s ) {
  16. System.out.println("Caught Sneeze");
  17. return ;
  18. }
  19. finally {
  20. System.out.println("Hello World!");
  21. }
  22. }
  23. }

52、List、Set、Map是否继承自Collection接口? 
答:List、Set 是,Map 不是。Map是键值对映射容器,与List和Set有明显的区别,而Set存储的零散的元素且不允许有重复元素(数学中的集合也是如此),List是线性结构的容器,适用于按数值索引访问元素的情形。

53、阐述ArrayList、Vector、LinkedList的存储性能和特性。 
答:ArrayList 和Vector都是使用数组方式存储数据,此数组元素数大于实际存储的数据以便增加和插入元素,它们都允许直接按序号索引元素,但是插入元素要涉及数组元素移动等内存操作,所以索引数据快而插入数据慢,Vector中的方法由于添加了synchronized修饰,因此Vector是线程安全的容器,但性能上较ArrayList差,因此已经是Java中的遗留容器。LinkedList使用双向链表实现存储(将内存中零散的内存单元通过附加的引用关联起来,形成一个可以按序号索引的线性结构,这种链式存储方式与数组的连续存储方式相比,内存的利用率更高),按序号索引数据需要进行前向或后向遍历,但是插入数据时只需要记录本项的前后项即可,所以插入速度较快。Vector属于遗留容器(Java早期的版本中提供的容器,除此之外,Hashtable、Dictionary、BitSet、Stack、Properties都是遗留容器),已经不推荐使用,但是由于ArrayList和LinkedListed都是非线程安全的,如果遇到多个线程操作同一个容器的场景,则可以通过工具类Collections中的synchronizedList方法将其转换成线程安全的容器后再使用(这是对装潢模式的应用,将已有对象传入另一个类的构造器中创建新的对象来增强实现)。

补充:遗留容器中的Properties类和Stack类在设计上有严重的问题,Properties是一个键和值都是字符串的特殊的键值对映射,在设计上应该是关联一个Hashtable并将其两个泛型参数设置为String类型,但是Java API中的Properties直接继承了Hashtable,这很明显是对继承的滥用。这里复用代码的方式应该是Has-A关系而不是Is-A关系,另一方面容器都属于工具类,继承工具类本身就是一个错误的做法,使用工具类最好的方式是Has-A关系(关联)或Use-A关系(依赖)。同理,Stack类继承Vector也是不正确的。Sun公司的工程师们也会犯这种低级错误,让人唏嘘不已。

54、Collection和Collections的区别? 
答:Collection是一个接口,它是Set、List等容器的父接口;Collections是个一个工具类,提供了一系列的静态方法来辅助容器操作,这些方法包括对容器的搜索、排序、线程安全化等等。

55、List、Map、Set三个接口存取元素时,各有什么特点? 
答:List以特定索引来存取元素,可以有重复元素。Set不能存放重复元素(用对象的equals()方法来区分元素是否重复)。Map保存键值对(key-value pair)映射,映射关系可以是一对一或多对一。Set和Map容器都有基于哈希存储和排序树的两种实现版本,基于哈希存储的版本理论存取时间复杂度为O(1),而基于排序树版本的实现在插入或删除元素时会按照元素或元素的键(key)构成排序树从而达到排序和去重的效果。

56、TreeMap和TreeSet在排序时如何比较元素?Collections工具类中的sort()方法如何比较元素? 
答:TreeSet要求存放的对象所属的类必须实现Comparable接口,该接口提供了比较元素的compareTo()方法,当插入元素时会回调该方法比较元素的大小。TreeMap要求存放的键值对映射的键必须实现Comparable接口从而根据键对元素进行排序。Collections工具类的sort方法有两种重载的形式,第一种要求传入的待排序容器中存放的对象比较实现Comparable接口以实现元素的比较;第二种不强制性的要求容器中的元素必须可比较,但是要求传入第二个参数,参数是Comparator接口的子类型(需要重写compare方法实现元素的比较),相当于一个临时定义的排序规则,其实就是通过接口注入比较元素大小的算法,也是对回调模式的应用(Java中对函数式编程的支持)。 
例子1:

  1. public class Student implements Comparable<Student> {
  2. private String name; // 姓名
  3. private int age; // 年龄
  4. public Student(String name, int age) {
  5. this.name = name;
  6. this.age = age;
  7. }
  8. @Override
  9. public String toString() {
  10. return "Student [name=" + name + ", age=" + age + "]";
  11. }
  12. @Override
  13. public int compareTo(Student o) {
  14. return this.age - o.age; // 比较年龄(年龄的升序)
  15. }
  16. }
  1. import java.util.Set;
  2. import java.util.TreeSet;
  3. class Test01 {
  4. public static void main(String[] args) {
  5. Set<Student> set = new TreeSet<>(); // Java 7的钻石语法(构造器后面的尖括号中不需要写类型)
  6. set.add(new Student("Hao LUO", 33));
  7. set.add(new Student("XJ WANG", 32));
  8. set.add(new Student("Bruce LEE", 60));
  9. set.add(new Student("Bob YANG", 22));
  10. for(Student stu : set) {
  11. System.out.println(stu);
  12. }
  13. // 输出结果:
  14. // Student [name=Bob YANG, age=22]
  15. // Student [name=XJ WANG, age=32]
  16. // Student [name=Hao LUO, age=33]
  17. // Student [name=Bruce LEE, age=60]
  18. }
  19. }

例子2:

  1. public class Student {
  2. private String name; // 姓名
  3. private int age; // 年龄
  4. public Student(String name, int age) {
  5. this.name = name;
  6. this.age = age;
  7. }
  8. /**
  9. * 获取学生姓名
  10. */
  11. public String getName() {
  12. return name;
  13. }
  14. /**
  15. * 获取学生年龄
  16. */
  17. public int getAge() {
  18. return age;
  19. }
  20. @Override
  21. public String toString() {
  22. return "Student [name=" + name + ", age=" + age + "]";
  23. }
  24. }
  1. import java.util.ArrayList;
  2. import java.util.Collections;
  3. import java.util.Comparator;
  4. import java.util.List;
  5. class Test02 {
  6. public static void main(String[] args) {
  7. List<Student> list = new ArrayList<>(); // Java 7的钻石语法(构造器后面的尖括号中不需要写类型)
  8. list.add(new Student("Hao LUO", 33));
  9. list.add(new Student("XJ WANG", 32));
  10. list.add(new Student("Bruce LEE", 60));
  11. list.add(new Student("Bob YANG", 22));
  12. // 通过sort方法的第二个参数传入一个Comparator接口对象
  13. // 相当于是传入一个比较对象大小的算法到sort方法中
  14. // 由于Java中没有函数指针、仿函数、委托这样的概念
  15. // 因此要将一个算法传入一个方法中唯一的选择就是通过接口回调
  16. Collections.sort(list, new Comparator<Student> () {
  17. @Override
  18. public int compare(Student o1, Student o2) {
  19. return o1.getName().compareTo(o2.getName()); // 比较学生姓名
  20. }
  21. });
  22. for(Student stu : list) {
  23. System.out.println(stu);
  24. }
  25. // 输出结果:
  26. // Student [name=Bob YANG, age=22]
  27. // Student [name=Bruce LEE, age=60]
  28. // Student [name=Hao LUO, age=33]
  29. // Student [name=XJ WANG, age=32]
  30. }
  31. }

57、Thread类的sleep()方法和对象的wait()方法都可以让线程暂停执行,它们有什么区别? 
答:sleep()方法(休眠)是线程类(Thread)的静态方法,调用此方法会让当前线程暂停执行指定的时间,将执行机会(CPU)让给其他线程,但是对象的锁依然保持,因此休眠时间结束后会自动恢复(线程回到就绪状态,请参考第66题中的线程状态转换图)。wait()是Object类的方法,调用对象的wait()方法导致当前线程放弃对象的锁(线程暂停执行),进入对象的等待池(wait pool),只有调用对象的notify()方法(或notifyAll()方法)时才能唤醒等待池中的线程进入等锁池(lock pool),如果线程重新获得对象的锁就可以进入就绪状态。

补充:可能不少人对什么是进程,什么是线程还比较模糊,对于为什么需要多线程编程也不是特别理解。简单的说:进程是具有一定独立功能的程序关于某个数据集合上的一次运行活动,是操作系统进行资源分配和调度的一个独立单位;线程是进程的一个实体,是CPU调度和分派的基本单位,是比进程更小的能独立运行的基本单位。线程的划分尺度小于进程,这使得多线程程序的并发性高;进程在执行时通常拥有独立的内存单元,而线程之间可以共享内存。使用多线程的编程通常能够带来更好的性能和用户体验,但是多线程的程序对于其他程序是不友好的,因为它可能占用了更多的CPU资源。当然,也不是线程越多,程序的性能就越好,因为线程之间的调度和切换也会浪费CPU时间。时下很时髦的Node.js就采用了单线程异步I/O的工作模式。

58、线程的sleep()方法和yield()方法有什么区别? 
答: 
① sleep()方法给其他线程运行机会时不考虑线程的优先级,因此会给低优先级的线程以运行的机会;yield()方法只会给相同优先级或更高优先级的线程以运行的机会; 
② 线程执行sleep()方法后转入阻塞(blocked)状态,而执行yield()方法后转入就绪(ready)状态; 
③ sleep()方法声明抛出InterruptedException,而yield()方法没有声明任何异常; 
④ sleep()方法比yield()方法(跟操作系统CPU调度相关)具有更好的可移植性。

59、当一个线程进入一个对象的synchronized方法A之后,其它线程是否可进入此对象的synchronized方法B? 
答:不能。其它线程只能访问该对象的非同步方法,同步方法则不能进入。因为非静态方法上的synchronized修饰符要求执行方法时要获得对象的锁,如果已经进入A方法说明对象锁已经被取走,那么试图进入B方法的线程就只能在等锁池(注意不是等待池哦)中等待对象的锁。

60、请说出与线程同步以及线程调度相关的方法。 
答: 
- wait():使一个线程处于等待(阻塞)状态,并且释放所持有的对象的锁; 
- sleep():使一个正在运行的线程处于睡眠状态,是一个静态方法,调用此方法要处理InterruptedException异常; 
- notify():唤醒一个处于等待状态的线程,当然在调用此方法的时候,并不能确切的唤醒某一个等待状态的线程,而是由JVM确定唤醒哪个线程,而且与优先级无关; 
- notityAll():唤醒所有处于等待状态的线程,该方法并不是将对象的锁给所有线程,而是让它们竞争,只有获得锁的线程才能进入就绪状态;

提示:关于Java多线程和并发编程的问题,建议大家看我的另一篇文章《关于Java并发编程的总结和思考》

补充:Java 5通过Lock接口提供了显式的锁机制(explicit lock),增强了灵活性以及对线程的协调。Lock接口中定义了加锁(lock())和解锁(unlock())的方法,同时还提供了newCondition()方法来产生用于线程之间通信的Condition对象;此外,Java 5还提供了信号量机制(semaphore),信号量可以用来限制对某个共享资源进行访问的线程的数量。在对资源进行访问之前,线程必须得到信号量的许可(调用Semaphore对象的acquire()方法);在完成对资源的访问后,线程必须向信号量归还许可(调用Semaphore对象的release()方法)。

下面的例子演示了100个线程同时向一个银行账户中存入1元钱,在没有使用同步机制和使用同步机制情况下的执行情况。

  • 银行账户类:
  1. /**
  2. * 银行账户
  3. * @author 骆昊
  4. *
  5. */
  6. public class Account {
  7. private double balance; // 账户余额
  8. /**
  9. * 存款
  10. * @param money 存入金额
  11. */
  12. public void deposit(double money) {
  13. double newBalance = balance + money;
  14. try {
  15. Thread.sleep(10); // 模拟此业务需要一段处理时间
  16. }
  17. catch(InterruptedException ex) {
  18. ex.printStackTrace();
  19. }
  20. balance = newBalance;
  21. }
  22. /**
  23. * 获得账户余额
  24. */
  25. public double getBalance() {
  26. return balance;
  27. }
  28. }
  • 存钱线程类:
  1. /**
  2. * 存钱线程
  3. * @author 骆昊
  4. *
  5. */
  6. public class AddMoneyThread implements Runnable {
  7. private Account account; // 存入账户
  8. private double money; // 存入金额
  9. public AddMoneyThread(Account account, double money) {
  10. this.account = account;
  11. this.money = money;
  12. }
  13. @Override
  14. public void run() {
  15. account.deposit(money);
  16. }
  17. }
  • 测试类:
  1. import java.util.concurrent.ExecutorService;
  2. import java.util.concurrent.Executors;
  3. public class Test01 {
  4. public static void main(String[] args) {
  5. Account account = new Account();
  6. ExecutorService service = Executors.newFixedThreadPool(100);
  7. for(int i = 1; i <= 100; i++) {
  8. service.execute(new AddMoneyThread(account, 1));
  9. }
  10. service.shutdown();
  11. while(!service.isTerminated()) {}
  12. System.out.println("账户余额: " + account.getBalance());
  13. }
  14. }

在没有同步的情况下,执行结果通常是显示账户余额在10元以下,出现这种状况的原因是,当一个线程A试图存入1元的时候,另外一个线程B也能够进入存款的方法中,线程B读取到的账户余额仍然是线程A存入1元钱之前的账户余额,因此也是在原来的余额0上面做了加1元的操作,同理线程C也会做类似的事情,所以最后100个线程执行结束时,本来期望账户余额为100元,但实际得到的通常在10元以下(很可能是1元哦)。解决这个问题的办法就是同步,当一个线程对银行账户存钱时,需要将此账户锁定,待其操作完成后才允许其他的线程进行操作,代码有如下几种调整方案:

  • 在银行账户的存款(deposit)方法上同步(synchronized)关键字
  1. /**
  2. * 银行账户
  3. * @author 骆昊
  4. *
  5. */
  6. public class Account {
  7. private double balance; // 账户余额
  8. /**
  9. * 存款
  10. * @param money 存入金额
  11. */
  12. public synchronized void deposit(double money) {
  13. double newBalance = balance + money;
  14. try {
  15. Thread.sleep(10); // 模拟此业务需要一段处理时间
  16. }
  17. catch(InterruptedException ex) {
  18. ex.printStackTrace();
  19. }
  20. balance = newBalance;
  21. }
  22. /**
  23. * 获得账户余额
  24. */
  25. public double getBalance() {
  26. return balance;
  27. }
  28. }
  • 在线程调用存款方法时对银行账户进行同步
  1. /**
  2. * 存钱线程
  3. * @author 骆昊
  4. *
  5. */
  6. public class AddMoneyThread implements Runnable {
  7. private Account account; // 存入账户
  8. private double money; // 存入金额
  9. public AddMoneyThread(Account account, double money) {
  10. this.account = account;
  11. this.money = money;
  12. }
  13. @Override
  14. public void run() {
  15. synchronized (account) {
  16. account.deposit(money);
  17. }
  18. }
  19. }
  • 通过Java 5显示的锁机制,为每个银行账户创建一个锁对象,在存款操作进行加锁和解锁的操作
  1. import java.util.concurrent.locks.Lock;
  2. import java.util.concurrent.locks.ReentrantLock;
  3. /**
  4. * 银行账户
  5. *
  6. * @author 骆昊
  7. *
  8. */
  9. public class Account {
  10. private Lock accountLock = new ReentrantLock();
  11. private double balance; // 账户余额
  12. /**
  13. * 存款
  14. *
  15. * @param money
  16. * 存入金额
  17. */
  18. public void deposit(double money) {
  19. accountLock.lock();
  20. try {
  21. double newBalance = balance + money;
  22. try {
  23. Thread.sleep(10); // 模拟此业务需要一段处理时间
  24. }
  25. catch (InterruptedException ex) {
  26. ex.printStackTrace();
  27. }
  28. balance = newBalance;
  29. }
  30. finally {
  31. accountLock.unlock();
  32. }
  33. }
  34. /**
  35. * 获得账户余额
  36. */
  37. public double getBalance() {
  38. return balance;
  39. }
  40. }

按照上述三种方式对代码进行修改后,重写执行测试代码Test01,将看到最终的账户余额为100元。当然也可以使用Semaphore或CountdownLatch来实现同步。

61、编写多线程程序有几种实现方式? 
答:Java 5以前实现多线程有两种实现方法:一种是继承Thread类;另一种是实现Runnable接口。两种方式都要通过重写run()方法来定义线程的行为,推荐使用后者,因为Java中的继承是单继承,一个类有一个父类,如果继承了Thread类就无法再继承其他类了,显然使用Runnable接口更为灵活。

补充:Java 5以后创建线程还有第三种方式:实现Callable接口,该接口中的call方法可以在线程执行结束时产生一个返回值,代码如下所示:

  1. import java.util.ArrayList;
  2. import java.util.List;
  3. import java.util.concurrent.Callable;
  4. import java.util.concurrent.ExecutorService;
  5. import java.util.concurrent.Executors;
  6. import java.util.concurrent.Future;
  7. class MyTask implements Callable<Integer> {
  8. private int upperBounds;
  9. public MyTask(int upperBounds) {
  10. this.upperBounds = upperBounds;
  11. }
  12. @Override
  13. public Integer call() throws Exception {
  14. int sum = 0;
  15. for(int i = 1; i <= upperBounds; i++) {
  16. sum += i;
  17. }
  18. return sum;
  19. }
  20. }
  21. class Test {
  22. public static void main(String[] args) throws Exception {
  23. List<Future<Integer>> list = new ArrayList<>();
  24. ExecutorService service = Executors.newFixedThreadPool(10);
  25. for(int i = 0; i < 10; i++) {
  26. list.add(service.submit(new MyTask((int) (Math.random() * 100))));
  27. }
  28. int sum = 0;
  29. for(Future<Integer> future : list) {
  30. // while(!future.isDone()) ;
  31. sum += future.get();
  32. }
  33. System.out.println(sum);
  34. }
  35. }

62、synchronized关键字的用法? 
答:synchronized关键字可以将对象或者方法标记为同步,以实现对对象和方法的互斥访问,可以用synchronized(对象) { … }定义同步代码块,或者在声明方法时将synchronized作为方法的修饰符。在第60题的例子中已经展示了synchronized关键字的用法。

63、举例说明同步和异步。 
答:如果系统中存在临界资源(资源数量少于竞争资源的线程数量的资源),例如正在写的数据以后可能被另一个线程读到,或者正在读的数据可能已经被另一个线程写过了,那么这些数据就必须进行同步存取(数据库操作中的排他锁就是最好的例子)。当应用程序在对象上调用了一个需要花费很长时间来执行的方法,并且不希望让程序等待方法的返回时,就应该使用异步编程,在很多情况下采用异步途径往往更有效率。事实上,所谓的同步就是指阻塞式操作,而异步就是非阻塞式操作。

64、启动一个线程是调用run()还是start()方法? 
答:启动一个线程是调用start()方法,使线程所代表的虚拟处理机处于可运行状态,这意味着它可以由JVM 调度并执行,这并不意味着线程就会立即运行。run()方法是线程启动后要进行回调(callback)的方法。

65、什么是线程池(thread pool)? 
答:在面向对象编程中,创建和销毁对象是很费时间的,因为创建一个对象要获取内存资源或者其它更多资源。在Java中更是如此,虚拟机将试图跟踪每一个对象,以便能够在对象销毁后进行垃圾回收。所以提高服务程序效率的一个手段就是尽可能减少创建和销毁对象的次数,特别是一些很耗资源的对象创建和销毁,这就是”池化资源”技术产生的原因。线程池顾名思义就是事先创建若干个可执行的线程放入一个池(容器)中,需要的时候从池中获取线程不用自行创建,使用完毕不需要销毁线程而是放回池中,从而减少创建和销毁线程对象的开销。 
Java 5+中的Executor接口定义一个执行线程的工具。它的子类型即线程池接口是ExecutorService。要配置一个线程池是比较复杂的,尤其是对于线程池的原理不是很清楚的情况下,因此在工具类Executors面提供了一些静态工厂方法,生成一些常用的线程池,如下所示: 
- newSingleThreadExecutor:创建一个单线程的线程池。这个线程池只有一个线程在工作,也就是相当于单线程串行执行所有任务。如果这个唯一的线程因为异常结束,那么会有一个新的线程来替代它。此线程池保证所有任务的执行顺序按照任务的提交顺序执行。 
- newFixedThreadPool:创建固定大小的线程池。每次提交一个任务就创建一个线程,直到线程达到线程池的最大大小。线程池的大小一旦达到最大值就会保持不变,如果某个线程因为执行异常而结束,那么线程池会补充一个新线程。 
- newCachedThreadPool:创建一个可缓存的线程池。如果线程池的大小超过了处理任务所需要的线程,那么就会回收部分空闲(60秒不执行任务)的线程,当任务数增加时,此线程池又可以智能的添加新线程来处理任务。此线程池不会对线程池大小做限制,线程池大小完全依赖于操作系统(或者说JVM)能够创建的最大线程大小。 
- newScheduledThreadPool:创建一个大小无限的线程池。此线程池支持定时以及周期性执行任务的需求。 
- newSingleThreadExecutor:创建一个单线程的线程池。此线程池支持定时以及周期性执行任务的需求。

第60题的例子中演示了通过Executors工具类创建线程池并使用线程池执行线程的代码。如果希望在服务器上使用线程池,强烈建议使用newFixedThreadPool方法来创建线程池,这样能获得更好的性能。

66、线程的基本状态以及状态之间的关系? 
答: 
这里写图片描述

说明:其中Running表示运行状态,Runnable表示就绪状态(万事俱备,只欠CPU),Blocked表示阻塞状态,阻塞状态又有多种情况,可能是因为调用wait()方法进入等待池,也可能是执行同步方法或同步代码块进入等锁池,或者是调用了sleep()方法或join()方法等待休眠或其他线程结束,或是因为发生了I/O中断。

67、简述synchronized 和java.util.concurrent.locks.Lock的异同? 
答:Lock是Java 5以后引入的新的API,和关键字synchronized相比主要相同点:Lock 能完成synchronized所实现的所有功能;主要不同点:Lock有比synchronized更精确的线程语义和更好的性能,而且不强制性的要求一定要获得锁。synchronized会自动释放锁,而Lock一定要求程序员手工释放,并且最好在finally 块中释放(这是释放外部资源的最好的地方)。

68、Java中如何实现序列化,有什么意义? 
答:序列化就是一种用来处理对象流的机制,所谓对象流也就是将对象的内容进行流化。可以对流化后的对象进行读写操作,也可将流化后的对象传输于网络之间。序列化是为了解决对象流读写操作时可能引发的问题(如果不进行序列化可能会存在数据乱序的问题)。 
要实现序列化,需要让一个类实现Serializable接口,该接口是一个标识性接口,标注该类对象是可被序列化的,然后使用一个输出流来构造一个对象输出流并通过writeObject(Object)方法就可以将实现对象写出(即保存其状态);如果需要反序列化则可以用一个输入流建立对象输入流,然后通过readObject方法从流中读取对象。序列化除了能够实现对象的持久化之外,还能够用于对象的深度克隆(可以参考第29题)。

69、Java中有几种类型的流? 
答:字节流和字符流。字节流继承于InputStream、OutputStream,字符流继承于Reader、Writer。在java.io 包中还有许多其他的流,主要是为了提高性能和使用方便。关于Java的I/O需要注意的有两点:一是两种对称性(输入和输出的对称性,字节和字符的对称性);二是两种设计模式(适配器模式和装潢模式)。另外Java中的流不同于C#的是它只有一个维度一个方向。

面试题 - 编程实现文件拷贝。(这个题目在笔试的时候经常出现,下面的代码给出了两种实现方案)

  1. import java.io.FileInputStream;
  2. import java.io.FileOutputStream;
  3. import java.io.IOException;
  4. import java.io.InputStream;
  5. import java.io.OutputStream;
  6. import java.nio.ByteBuffer;
  7. import java.nio.channels.FileChannel;
  8. public final class MyUtil {
  9. private MyUtil() {
  10. throw new AssertionError();
  11. }
  12. public static void fileCopy(String source, String target) throws IOException {
  13. try (InputStream in = new FileInputStream(source)) {
  14. try (OutputStream out = new FileOutputStream(target)) {
  15. byte[] buffer = new byte[4096];
  16. int bytesToRead;
  17. while((bytesToRead = in.read(buffer)) != -1) {
  18. out.write(buffer, 0, bytesToRead);
  19. }
  20. }
  21. }
  22. }
  23. public static void fileCopyNIO(String source, String target) throws IOException {
  24. try (FileInputStream in = new FileInputStream(source)) {
  25. try (FileOutputStream out = new FileOutputStream(target)) {
  26. FileChannel inChannel = in.getChannel();
  27. FileChannel outChannel = out.getChannel();
  28. ByteBuffer buffer = ByteBuffer.allocate(4096);
  29. while(inChannel.read(buffer) != -1) {
  30. buffer.flip();
  31. outChannel.write(buffer);
  32. buffer.clear();
  33. } }
  34. }
  35. }
  36. }

注意:上面用到Java 7的TWR,使用TWR后可以不用在finally中释放外部资源 ,从而让代码更加优雅。

70、写一个方法,输入一个文件名和一个字符串,统计这个字符串在这个文件中出现的次数。 
答:代码如下:

  1. import java.io.BufferedReader;
  2. import java.io.FileReader;
  3. public final class MyUtil {
  4. // 工具类中的方法都是静态方式访问的因此将构造器私有不允许创建对象(绝对好习惯)
  5. private MyUtil() {
  6. throw new AssertionError();
  7. }
  8. /**
  9. * 统计给定文件中给定字符串的出现次数
  10. *
  11. * @param filename 文件名
  12. * @param word 字符串
  13. * @return 字符串在文件中出现的次数
  14. */
  15. public static int countWordInFile(String filename, String word) {
  16. int counter = 0;
  17. try (FileReader fr = new FileReader(filename)) {
  18. try (BufferedReader br = new BufferedReader(fr)) {
  19. String line = null;
  20. while ((line = br.readLine()) != null) {
  21. int index = -1;
  22. while (line.length() >= word.length() && (index = line.indexOf(word)) >= 0) {
  23. counter++;
  24. line = line.substring(index + word.length());
  25. }
  26. }
  27. }
  28. } catch (Exception ex) {
  29. ex.printStackTrace();
  30. }
  31. return counter;
  32. }
  33. }

71、如何用Java代码列出一个目录下所有的文件? 
答: 
如果只要求列出当前文件夹下的文件,代码如下所示:

  1. import java.io.File;
  2. class Test12 {
  3. public static void main(String[] args) {
  4. File f = new File("/Users/Hao/Downloads");
  5. for(File temp : f.listFiles()) {
  6. if(temp.isFile()) {
  7. System.out.println(temp.getName());
  8. }
  9. }
  10. }
  11. }

如果需要对文件夹继续展开,代码如下所示:

  1. import java.io.File;
  2. class Test12 {
  3. public static void main(String[] args) {
  4. showDirectory(new File("/Users/Hao/Downloads"));
  5. }
  6. public static void showDirectory(File f) {
  7. _walkDirectory(f, 0);
  8. }
  9. private static void _walkDirectory(File f, int level) {
  10. if(f.isDirectory()) {
  11. for(File temp : f.listFiles()) {
  12. _walkDirectory(temp, level + 1);
  13. }
  14. }
  15. else {
  16. for(int i = 0; i < level - 1; i++) {
  17. System.out.print("\t");
  18. }
  19. System.out.println(f.getName());
  20. }
  21. }
  22. }

在Java 7中可以使用NIO.2的API来做同样的事情,代码如下所示:

  1. class ShowFileTest {
  2. public static void main(String[] args) throws IOException {
  3. Path initPath = Paths.get("/Users/Hao/Downloads");
  4. Files.walkFileTree(initPath, new SimpleFileVisitor<Path>() {
  5. @Override
  6. public FileVisitResult visitFile(Path file, BasicFileAttributes attrs)
  7. throws IOException {
  8. System.out.println(file.getFileName().toString());
  9. return FileVisitResult.CONTINUE;
  10. }
  11. });
  12. }
  13. }

72、用Java的套接字编程实现一个多线程的回显(echo)服务器。 
答:

  1. import java.io.BufferedReader;
  2. import java.io.IOException;
  3. import java.io.InputStreamReader;
  4. import java.io.PrintWriter;
  5. import java.net.ServerSocket;
  6. import java.net.Socket;
  7. public class EchoServer {
  8. private static final int ECHO_SERVER_PORT = 6789;
  9. public static void main(String[] args) {
  10. try(ServerSocket server = new ServerSocket(ECHO_SERVER_PORT)) {
  11. System.out.println("服务器已经启动...");
  12. while(true) {
  13. Socket client = server.accept();
  14. new Thread(new ClientHandler(client)).start();
  15. }
  16. } catch (IOException e) {
  17. e.printStackTrace();
  18. }
  19. }
  20. private static class ClientHandler implements Runnable {
  21. private Socket client;
  22. public ClientHandler(Socket client) {
  23. this.client = client;
  24. }
  25. @Override
  26. public void run() {
  27. try(BufferedReader br = new BufferedReader(new InputStreamReader(client.getInputStream()));
  28. PrintWriter pw = new PrintWriter(client.getOutputStream())) {
  29. String msg = br.readLine();
  30. System.out.println("收到" + client.getInetAddress() + "发送的: " + msg);
  31. pw.println(msg);
  32. pw.flush();
  33. } catch(Exception ex) {
  34. ex.printStackTrace();
  35. } finally {
  36. try {
  37. client.close();
  38. } catch (IOException e) {
  39. e.printStackTrace();
  40. }
  41. }
  42. }
  43. }
  44. }

注意:上面的代码使用了Java 7的TWR语法,由于很多外部资源类都间接的实现了AutoCloseable接口(单方法回调接口),因此可以利用TWR语法在try结束的时候通过回调的方式自动调用外部资源类的close()方法,避免书写冗长的finally代码块。此外,上面的代码用一个静态内部类实现线程的功能,使用多线程可以避免一个用户I/O操作所产生的中断影响其他用户对服务器的访问,简单的说就是一个用户的输入操作不会造成其他用户的阻塞。当然,上面的代码使用线程池可以获得更好的性能,因为频繁的创建和销毁线程所造成的开销也是不可忽视的。

下面是一段回显客户端测试代码:

  1. import java.io.BufferedReader;
  2. import java.io.InputStreamReader;
  3. import java.io.PrintWriter;
  4. import java.net.Socket;
  5. import java.util.Scanner;
  6. public class EchoClient {
  7. public static void main(String[] args) throws Exception {
  8. Socket client = new Socket("localhost", 6789);
  9. Scanner sc = new Scanner(System.in);
  10. System.out.print("请输入内容: ");
  11. String msg = sc.nextLine();
  12. sc.close();
  13. PrintWriter pw = new PrintWriter(client.getOutputStream());
  14. pw.println(msg);
  15. pw.flush();
  16. BufferedReader br = new BufferedReader(new InputStreamReader(client.getInputStream()));
  17. System.out.println(br.readLine());
  18. client.close();
  19. }
  20. }

如果希望用NIO的多路复用套接字实现服务器,代码如下所示。NIO的操作虽然带来了更好的性能,但是有些操作是比较底层的,对于初学者来说还是有些难于理解。

  1. import java.io.IOException;
  2. import java.net.InetSocketAddress;
  3. import java.nio.ByteBuffer;
  4. import java.nio.CharBuffer;
  5. import java.nio.channels.SelectionKey;
  6. import java.nio.channels.Selector;
  7. import java.nio.channels.ServerSocketChannel;
  8. import java.nio.channels.SocketChannel;
  9. import java.util.Iterator;
  10. public class EchoServerNIO {
  11. private static final int ECHO_SERVER_PORT = 6789;
  12. private static final int ECHO_SERVER_TIMEOUT = 5000;
  13. private static final int BUFFER_SIZE = 1024;
  14. private static ServerSocketChannel serverChannel = null;
  15. private static Selector selector = null; // 多路复用选择器
  16. private static ByteBuffer buffer = null; // 缓冲区
  17. public static void main(String[] args) {
  18. init();
  19. listen();
  20. }
  21. private static void init() {
  22. try {
  23. serverChannel = ServerSocketChannel.open();
  24. buffer = ByteBuffer.allocate(BUFFER_SIZE);
  25. serverChannel.socket().bind(new InetSocketAddress(ECHO_SERVER_PORT));
  26. serverChannel.configureBlocking(false);
  27. selector = Selector.open();
  28. serverChannel.register(selector, SelectionKey.OP_ACCEPT);
  29. } catch (Exception e) {
  30. throw new RuntimeException(e);
  31. }
  32. }
  33. private static void listen() {
  34. while (true) {
  35. try {
  36. if (selector.select(ECHO_SERVER_TIMEOUT) != 0) {
  37. Iterator<SelectionKey> it = selector.selectedKeys().iterator();
  38. while (it.hasNext()) {
  39. SelectionKey key = it.next();
  40. it.remove();
  41. handleKey(key);
  42. }
  43. }
  44. } catch (Exception e) {
  45. e.printStackTrace();
  46. }
  47. }
  48. }
  49. private static void handleKey(SelectionKey key) throws IOException {
  50. SocketChannel channel = null;
  51. try {
  52. if (key.isAcceptable()) {
  53. ServerSocketChannel serverChannel = (ServerSocketChannel) key.channel();
  54. channel = serverChannel.accept();
  55. channel.configureBlocking(false);
  56. channel.register(selector, SelectionKey.OP_READ);
  57. } else if (key.isReadable()) {
  58. channel = (SocketChannel) key.channel();
  59. buffer.clear();
  60. if (channel.read(buffer) > 0) {
  61. buffer.flip();
  62. CharBuffer charBuffer = CharsetHelper.decode(buffer);
  63. String msg = charBuffer.toString();
  64. System.out.println("收到" + channel.getRemoteAddress() + "的消息:" + msg);
  65. channel.write(CharsetHelper.encode(CharBuffer.wrap(msg)));
  66. } else {
  67. channel.close();
  68. }
  69. }
  70. } catch (Exception e) {
  71. e.printStackTrace();
  72. if (channel != null) {
  73. channel.close();
  74. }
  75. }
  76. }
  77. }
  1. import java.nio.ByteBuffer;
  2. import java.nio.CharBuffer;
  3. import java.nio.charset.CharacterCodingException;
  4. import java.nio.charset.Charset;
  5. import java.nio.charset.CharsetDecoder;
  6. import java.nio.charset.CharsetEncoder;
  7. public final class CharsetHelper {
  8. private static final String UTF_8 = "UTF-8";
  9. private static CharsetEncoder encoder = Charset.forName(UTF_8).newEncoder();
  10. private static CharsetDecoder decoder = Charset.forName(UTF_8).newDecoder();
  11. private CharsetHelper() {
  12. }
  13. public static ByteBuffer encode(CharBuffer in) throws CharacterCodingException{
  14. return encoder.encode(in);
  15. }
  16. public static CharBuffer decode(ByteBuffer in) throws CharacterCodingException{
  17. return decoder.decode(in);
  18. }
  19. }

73、XML文档定义有几种形式?它们之间有何本质区别?解析XML文档有哪几种方式? 
答:XML文档定义分为DTD和Schema两种形式,二者都是对XML语法的约束,其本质区别在于Schema本身也是一个XML文件,可以被XML解析器解析,而且可以为XML承载的数据定义类型,约束能力较之DTD更强大。对XML的解析主要有DOM(文档对象模型,Document Object Model)、SAX(Simple API for XML)和StAX(Java 6中引入的新的解析XML的方式,Streaming API for XML),其中DOM处理大型文件时其性能下降的非常厉害,这个问题是由DOM树结构占用的内存较多造成的,而且DOM解析方式必须在解析文件之前把整个文档装入内存,适合对XML的随机访问(典型的用空间换取时间的策略);SAX是事件驱动型的XML解析方式,它顺序读取XML文件,不需要一次全部装载整个文件。当遇到像文件开头,文档结束,或者标签开头与标签结束时,它会触发一个事件,用户通过事件回调代码来处理XML文件,适合对XML的顺序访问;顾名思义,StAX把重点放在流上,实际上StAX与其他解析方式的本质区别就在于应用程序能够把XML作为一个事件流来处理。将XML作为一组事件来处理的想法并不新颖(SAX就是这样做的),但不同之处在于StAX允许应用程序代码把这些事件逐个拉出来,而不用提供在解析器方便时从解析器中接收事件的处理程序。

74、你在项目中哪些地方用到了XML? 
答:XML的主要作用有两个方面:数据交换和信息配置。在做数据交换时,XML将数据用标签组装成起来,然后压缩打包加密后通过网络传送给接收者,接收解密与解压缩后再从XML文件中还原相关信息进行处理,XML曾经是异构系统间交换数据的事实标准,但此项功能几乎已经被JSON(JavaScript Object Notation)取而代之。当然,目前很多软件仍然使用XML来存储配置信息,我们在很多项目中通常也会将作为配置信息的硬代码写在XML文件中,Java的很多框架也是这么做的,而且这些框架都选择了dom4j作为处理XML的工具,因为Sun公司的官方API实在不怎么好用。

补充:现在有很多时髦的软件(如Sublime)已经开始将配置文件书写成JSON格式,我们已经强烈的感受到XML的另一项功能也将逐渐被业界抛弃。

75、阐述JDBC操作数据库的步骤。 
答:下面的代码以连接本机的Oracle数据库为例,演示JDBC操作数据库的步骤。

  • 加载驱动。
    Class.forName("oracle.jdbc.driver.OracleDriver");
  • 创建连接。
    Connection con = DriverManager.getConnection("jdbc:oracle:thin:@localhost:1521:orcl", "scott", "tiger");
  • 创建语句。
  1. PreparedStatement ps = con.prepareStatement("select * from emp where sal between ? and ?");
  2. ps.setInt(1, 1000);
  3. ps.setInt(2, 3000);
  • 执行语句。
    ResultSet rs = ps.executeQuery();
  • 处理结果。
  1. while(rs.next()) {
  2. System.out.println(rs.getInt("empno") + " - " + rs.getString("ename"));
  3. }
  • 关闭资源。
  1. finally {
  2. if(con != null) {
  3. try {
  4. con.close();
  5. } catch (SQLException e) {
  6. e.printStackTrace();
  7. }
  8. }
  9. }

提示:关闭外部资源的顺序应该和打开的顺序相反,也就是说先关闭ResultSet、再关闭Statement、在关闭Connection。上面的代码只关闭了Connection(连接),虽然通常情况下在关闭连接时,连接上创建的语句和打开的游标也会关闭,但不能保证总是如此,因此应该按照刚才说的顺序分别关闭。此外,第一步加载驱动在JDBC 4.0中是可以省略的(自动从类路径中加载驱动),但是我们建议保留。

76、Statement和PreparedStatement有什么区别?哪个性能更好? 
答:与Statement相比,①PreparedStatement接口代表预编译的语句,它主要的优势在于可以减少SQL的编译错误并增加SQL的安全性(减少SQL注射攻击的可能性);②PreparedStatement中的SQL语句是可以带参数的,避免了用字符串连接拼接SQL语句的麻烦和不安全;③当批量处理SQL或频繁执行相同的查询时,PreparedStatement有明显的性能上的优势,由于数据库可以将编译优化后的SQL语句缓存起来,下次执行相同结构的语句时就会很快(不用再次编译和生成执行计划)。

补充:为了提供对存储过程的调用,JDBC API中还提供了CallableStatement接口。存储过程(Stored Procedure)是数据库中一组为了完成特定功能的SQL语句的集合,经编译后存储在数据库中,用户通过指定存储过程的名字并给出参数(如果该存储过程带有参数)来执行它。虽然调用存储过程会在网络开销、安全性、性能上获得很多好处,但是存在如果底层数据库发生迁移时就会有很多麻烦,因为每种数据库的存储过程在书写上存在不少的差别。

77、使用JDBC操作数据库时,如何提升读取数据的性能?如何提升更新数据的性能? 
答:要提升读取数据的性能,可以指定通过结果集(ResultSet)对象的setFetchSize()方法指定每次抓取的记录数(典型的空间换时间策略);要提升更新数据的性能可以使用PreparedStatement语句构建批处理,将若干SQL语句置于一个批处理中执行。

78、在进行数据库编程时,连接池有什么作用? 
答:由于创建连接和释放连接都有很大的开销(尤其是数据库服务器不在本地时,每次建立连接都需要进行TCP的三次握手,释放连接需要进行TCP四次握手,造成的开销是不可忽视的),为了提升系统访问数据库的性能,可以事先创建若干连接置于连接池中,需要时直接从连接池获取,使用结束时归还连接池而不必关闭连接,从而避免频繁创建和释放连接所造成的开销,这是典型的用空间换取时间的策略(浪费了空间存储连接,但节省了创建和释放连接的时间)。池化技术在Java开发中是很常见的,在使用线程时创建线程池的道理与此相同。基于Java的开源数据库连接池主要有:C3P0ProxoolDBCPBoneCPDruid等。

补充:在计算机系统中时间和空间是不可调和的矛盾,理解这一点对设计满足性能要求的算法是至关重要的。大型网站性能优化的一个关键就是使用缓存,而缓存跟上面讲的连接池道理非常类似,也是使用空间换时间的策略。可以将热点数据置于缓存中,当用户查询这些数据时可以直接从缓存中得到,这无论如何也快过去数据库中查询。当然,缓存的置换策略等也会对系统性能产生重要影响,对于这个问题的讨论已经超出了这里要阐述的范围。

79、什么是DAO模式? 
答:DAO(Data Access Object)顾名思义是一个为数据库或其他持久化机制提供了抽象接口的对象,在不暴露底层持久化方案实现细节的前提下提供了各种数据访问操作。在实际的开发中,应该将所有对数据源的访问操作进行抽象化后封装在一个公共API中。用程序设计语言来说,就是建立一个接口,接口中定义了此应用程序中将会用到的所有事务方法。在这个应用程序中,当需要和数据源进行交互的时候则使用这个接口,并且编写一个单独的类来实现这个接口,在逻辑上该类对应一个特定的数据存储。DAO模式实际上包含了两个模式,一是Data Accessor(数据访问器),二是Data Object(数据对象),前者要解决如何访问数据的问题,而后者要解决的是如何用对象封装数据。

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

补充:关于事务,在面试中被问到的概率是很高的,可以问的问题也是很多的。首先需要知道的是,只有存在并发数据访问时才需要事务。当多个事务访问同一数据时,可能会存在5类问题,包括3类数据读取问题(脏读、不可重复读和幻读)和2类数据更新问题(第1类丢失更新和第2类丢失更新)。

脏读(Dirty Read):A事务读取B事务尚未提交的数据并在此基础上操作,而B事务执行回滚,那么A读取到的数据就是脏数据。

时间转账事务A取款事务B
T1 开始事务
T2开始事务 
T3 查询账户余额为1000元
T4 取出500元余额修改为500元
T5查询账户余额为500元(脏读) 
T6 撤销事务余额恢复为1000元
T7汇入100元把余额修改为600元 
T8提交事务 

不可重复读(Unrepeatable Read):事务A重新读取前面读取过的数据,发现该数据已经被另一个已提交的事务B修改过了。

时间转账事务A取款事务B
T1 开始事务
T2开始事务 
T3 查询账户余额为1000元
T4查询账户余额为1000元 
T5 取出100元修改余额为900元
T6 提交事务
T7查询账户余额为900元(不可重复读) 

幻读(Phantom Read):事务A重新执行一个查询,返回一系列符合查询条件的行,发现其中插入了被事务B提交的行。

时间统计金额事务A转账事务B
T1 开始事务
T2开始事务 
T3统计总存款为10000元 
T4 新增一个存款账户存入100元
T5 提交事务
T6再次统计总存款为10100元(幻读) 

第1类丢失更新:事务A撤销时,把已经提交的事务B的更新数据覆盖了。

时间取款事务A转账事务B
T1开始事务 
T2 开始事务
T3查询账户余额为1000元 
T4 查询账户余额为1000元
T5 汇入100元修改余额为1100元
T6 提交事务
T7取出100元将余额修改为900元 
T8撤销事务 
T9余额恢复为1000元(丢失更新) 

第2类丢失更新:事务A覆盖事务B已经提交的数据,造成事务B所做的操作丢失。

时间转账事务A取款事务B
T1 开始事务
T2开始事务 
T3 查询账户余额为1000元
T4查询账户余额为1000元 
T5 取出100元将余额修改为900元
T6 提交事务
T7汇入100元将余额修改为1100元 
T8提交事务 
T9查询账户余额为1100元(丢失更新) 

数据并发访问所产生的问题,在有些场景下可能是允许的,但是有些场景下可能就是致命的,数据库通常会通过锁机制来解决数据并发访问问题,按锁定对象不同可以分为表级锁和行级锁;按并发事务锁定关系可以分为共享锁和独占锁,具体的内容大家可以自行查阅资料进行了解。 
直接使用锁是非常麻烦的,为此数据库为用户提供了自动锁机制,只要用户指定会话的事务隔离级别,数据库就会通过分析SQL语句然后为事务访问的资源加上合适的锁,此外,数据库还会维护这些锁通过各种手段提高系统的性能,这些对用户来说都是透明的(就是说你不用理解,事实上我确实也不知道)。ANSI/ISO SQL 92标准定义了4个等级的事务隔离级别,如下表所示:

隔离级别脏读不可重复读幻读第一类丢失更新第二类丢失更新
READ UNCOMMITED允许允许允许不允许允许
READ COMMITTED不允许允许允许不允许允许
REPEATABLE READ不允许不允许允许不允许不允许
SERIALIZABLE不允许不允许不允许不允许不允许

需要说明的是,事务隔离级别和数据访问的并发性是对立的,事务隔离级别越高并发性就越差。所以要根据具体的应用来确定合适的事务隔离级别,这个地方没有万能的原则。

81、JDBC中如何进行事务处理? 
答:Connection提供了事务处理的方法,通过调用setAutoCommit(false)可以设置手动提交事务;当事务完成后用commit()显式提交事务;如果在事务处理过程中发生异常则通过rollback()进行事务回滚。除此之外,从JDBC 3.0中还引入了Savepoint(保存点)的概念,允许通过代码设置保存点并让事务回滚到指定的保存点。 
这里写图片描述

82、JDBC能否处理Blob和Clob? 
答: Blob是指二进制大对象(Binary Large Object),而Clob是指大字符对象(Character Large Objec),因此其中Blob是为存储大的二进制数据而设计的,而Clob是为存储大的文本数据而设计的。JDBC的PreparedStatement和ResultSet都提供了相应的方法来支持Blob和Clob操作。下面的代码展示了如何使用JDBC操作LOB: 
下面以MySQL数据库为例,创建一个张有三个字段的用户表,包括编号(id)、姓名(name)和照片(photo),建表语句如下:

  1. create table tb_user
  2. (
  3. id int primary key auto_increment,
  4. name varchar(20) unique not null,
  5. photo longblob
  6. );

下面的Java代码向数据库中插入一条记录:

  1. import java.io.FileInputStream;
  2. import java.io.IOException;
  3. import java.io.InputStream;
  4. import java.sql.Connection;
  5. import java.sql.DriverManager;
  6. import java.sql.PreparedStatement;
  7. import java.sql.SQLException;
  8. class JdbcLobTest {
  9. public static void main(String[] args) {
  10. Connection con = null;
  11. try {
  12. // 1. 加载驱动(Java6以上版本可以省略)
  13. Class.forName("com.mysql.jdbc.Driver");
  14. // 2. 建立连接
  15. con = DriverManager.getConnection("jdbc:mysql://localhost:3306/test", "root", "123456");
  16. // 3. 创建语句对象
  17. PreparedStatement ps = con.prepareStatement("insert into tb_user values (default, ?, ?)");
  18. ps.setString(1, "骆昊"); // 将SQL语句中第一个占位符换成字符串
  19. try (InputStream in = new FileInputStream("test.jpg")) { // Java 7的TWR
  20. ps.setBinaryStream(2, in); // 将SQL语句中第二个占位符换成二进制流
  21. // 4. 发出SQL语句获得受影响行数
  22. System.out.println(ps.executeUpdate() == 1 ? "插入成功" : "插入失败");
  23. } catch(IOException e) {
  24. System.out.println("读取照片失败!");
  25. }
  26. } catch (ClassNotFoundException | SQLException e) { // Java 7的多异常捕获
  27. e.printStackTrace();
  28. } finally { // 释放外部资源的代码都应当放在finally中保证其能够得到执行
  29. try {
  30. if(con != null && !con.isClosed()) {
  31. con.close(); // 5. 释放数据库连接
  32. con = null; // 指示垃圾回收器可以回收该对象
  33. }
  34. } catch (SQLException e) {
  35. e.printStackTrace();
  36. }
  37. }
  38. }
  39. }

83、简述正则表达式及其用途。 
答:在编写处理字符串的程序时,经常会有查找符合某些复杂规则的字符串的需要。正则表达式就是用于描述这些规则的工具。换句话说,正则表达式就是记录文本规则的代码。

说明:计算机诞生初期处理的信息几乎都是数值,但是时过境迁,今天我们使用计算机处理的信息更多的时候不是数值而是字符串,正则表达式就是在进行字符串匹配和处理的时候最为强大的工具,绝大多数语言都提供了对正则表达式的支持。

84、Java中是如何支持正则表达式操作的? 
答:Java中的String类提供了支持正则表达式操作的方法,包括:matches()、replaceAll()、replaceFirst()、split()。此外,Java中可以用Pattern类表示正则表达式对象,它提供了丰富的API进行各种正则表达式操作,请参考下面面试题的代码。

面试题: - 如果要从字符串中截取第一个英文左括号之前的字符串,例如:北京市(朝阳区)(西城区)(海淀区),截取结果为:北京市,那么正则表达式怎么写?

  1. import java.util.regex.Matcher;
  2. import java.util.regex.Pattern;
  3. class RegExpTest {
  4. public static void main(String[] args) {
  5. String str = "北京市(朝阳区)(西城区)(海淀区)";
  6. Pattern p = Pattern.compile(".*?(?=\\()");
  7. Matcher m = p.matcher(str);
  8. if(m.find()) {
  9. System.out.println(m.group());
  10. }
  11. }
  12. }

说明:上面的正则表达式中使用了懒惰匹配和前瞻,如果不清楚这些内容,推荐读一下网上很有名的《正则表达式30分钟入门教程》

85、获得一个类的类对象有哪些方式? 
答: 
- 方法1:类型.class,例如:String.class 
- 方法2:对象.getClass(),例如:"hello".getClass() 
- 方法3:Class.forName(),例如:Class.forName("java.lang.String")

86、如何通过反射创建对象? 
答: 
- 方法1:通过类对象调用newInstance()方法,例如:String.class.newInstance() 
- 方法2:通过类对象的getConstructor()或getDeclaredConstructor()方法获得构造器(Constructor)对象并调用其newInstance()方法创建对象,例如:String.class.getConstructor(String.class).newInstance("Hello");

87、如何通过反射获取和设置对象私有字段的值? 
答:可以通过类对象的getDeclaredField()方法字段(Field)对象,然后再通过字段对象的setAccessible(true)将其设置为可以访问,接下来就可以通过get/set方法来获取/设置字段的值了。下面的代码实现了一个反射的工具类,其中的两个静态方法分别用于获取和设置私有字段的值,字段可以是基本类型也可以是对象类型且支持多级对象操作,例如ReflectionUtil.get(dog, "owner.car.engine.id");可以获得dog对象的主人的汽车的引擎的ID号。

  1. import java.lang.reflect.Constructor;
  2. import java.lang.reflect.Field;
  3. import java.lang.reflect.Modifier;
  4. import java.util.ArrayList;
  5. import java.util.List;
  6. /**
  7. * 反射工具类
  8. * @author 骆昊
  9. *
  10. */
  11. public class ReflectionUtil {
  12. private ReflectionUtil() {
  13. throw new AssertionError();
  14. }
  15. /**
  16. * 通过反射取对象指定字段(属性)的值
  17. * @param target 目标对象
  18. * @param fieldName 字段的名字
  19. * @throws 如果取不到对象指定字段的值则抛出异常
  20. * @return 字段的值
  21. */
  22. public static Object getValue(Object target, String fieldName) {
  23. Class<?> clazz = target.getClass();
  24. String[] fs = fieldName.split("\\.");
  25. try {
  26. for(int i = 0; i < fs.length - 1; i++) {
  27. Field f = clazz.getDeclaredField(fs[i]);
  28. f.setAccessible(true);
  29. target = f.get(target);
  30. clazz = target.getClass();
  31. }
  32. Field f = clazz.getDeclaredField(fs[fs.length - 1]);
  33. f.setAccessible(true);
  34. return f.get(target);
  35. }
  36. catch (Exception e) {
  37. throw new RuntimeException(e);
  38. }
  39. }
  40. /**
  41. * 通过反射给对象的指定字段赋值
  42. * @param target 目标对象
  43. * @param fieldName 字段的名称
  44. * @param value 值
  45. */
  46. public static void setValue(Object target, String fieldName, Object value) {
  47. Class<?> clazz = target.getClass();
  48. String[] fs = fieldName.split("\\.");
  49. try {
  50. for(int i = 0; i < fs.length - 1; i++) {
  51. Field f = clazz.getDeclaredField(fs[i]);
  52. f.setAccessible(true);
  53. Object val = f.get(target);
  54. if(val == null) {
  55. Constructor<?> c = f.getType().getDeclaredConstructor();
  56. c.setAccessible(true);
  57. val = c.newInstance();
  58. f.set(target, val);
  59. }
  60. target = val;
  61. clazz = target.getClass();
  62. }
  63. Field f = clazz.getDeclaredField(fs[fs.length - 1]);
  64. f.setAccessible(true);
  65. f.set(target, value);
  66. }
  67. catch (Exception e) {
  68. throw new RuntimeException(e);
  69. }
  70. }
  71. }

88、如何通过反射调用对象的方法? 
答:请看下面的代码:

  1. import java.lang.reflect.Method;
  2. class MethodInvokeTest {
  3. public static void main(String[] args) throws Exception {
  4. String str = "hello";
  5. Method m = str.getClass().getMethod("toUpperCase");
  6. System.out.println(m.invoke(str)); // HELLO
  7. }
  8. }

89、简述一下面向对象的"六原则一法则"。 
答: 
- 单一职责原则:一个类只做它该做的事情。(单一职责原则想表达的就是"高内聚",写代码最终极的原则只有六个字"高内聚、低耦合",就如同葵花宝典或辟邪剑谱的中心思想就八个字"欲练此功必先自宫",所谓的高内聚就是一个代码模块只完成一项功能,在面向对象中,如果只让一个类完成它该做的事,而不涉及与它无关的领域就是践行了高内聚的原则,这个类就只有单一职责。我们都知道一句话叫"因为专注,所以专业",一个对象如果承担太多的职责,那么注定它什么都做不好。这个世界上任何好的东西都有两个特征,一个是功能单一,好的相机绝对不是电视购物里面卖的那种一个机器有一百多种功能的,它基本上只能照相;另一个是模块化,好的自行车是组装车,从减震叉、刹车到变速器,所有的部件都是可以拆卸和重新组装的,好的乒乓球拍也不是成品拍,一定是底板和胶皮可以拆分和自行组装的,一个好的软件系统,它里面的每个功能模块也应该是可以轻易的拿到其他系统中使用的,这样才能实现软件复用的目标。) 
- 开闭原则:软件实体应当对扩展开放,对修改关闭。(在理想的状态下,当我们需要为一个软件系统增加新功能时,只需要从原来的系统派生出一些新类就可以,不需要修改原来的任何一行代码。要做到开闭有两个要点:①抽象是关键,一个系统中如果没有抽象类或接口系统就没有扩展点;②封装可变性,将系统中的各种可变因素封装到一个继承结构中,如果多个可变因素混杂在一起,系统将变得复杂而换乱,如果不清楚如何封装可变性,可以参考《设计模式精解》一书中对桥梁模式的讲解的章节。) 
- 依赖倒转原则:面向接口编程。(该原则说得直白和具体一些就是声明方法的参数类型、方法的返回类型、变量的引用类型时,尽可能使用抽象类型而不用具体类型,因为抽象类型可以被它的任何一个子类型所替代,请参考下面的里氏替换原则。) 
里氏替换原则:任何时候都可以用子类型替换掉父类型。(关于里氏替换原则的描述,Barbara Liskov女士的描述比这个要复杂得多,但简单的说就是能用父类型的地方就一定能使用子类型。里氏替换原则可以检查继承关系是否合理,如果一个继承关系违背了里氏替换原则,那么这个继承关系一定是错误的,需要对代码进行重构。例如让猫继承狗,或者狗继承猫,又或者让正方形继承长方形都是错误的继承关系,因为你很容易找到违反里氏替换原则的场景。需要注意的是:子类一定是增加父类的能力而不是减少父类的能力,因为子类比父类的能力更多,把能力多的对象当成能力少的对象来用当然没有任何问题。) 
- 接口隔离原则:接口要小而专,绝不能大而全。(臃肿的接口是对接口的污染,既然接口表示能力,那么一个接口只应该描述一种能力,接口也应该是高度内聚的。例如,琴棋书画就应该分别设计为四个接口,而不应设计成一个接口中的四个方法,因为如果设计成一个接口中的四个方法,那么这个接口很难用,毕竟琴棋书画四样都精通的人还是少数,而如果设计成四个接口,会几项就实现几个接口,这样的话每个接口被复用的可能性是很高的。Java中的接口代表能力、代表约定、代表角色,能否正确的使用接口一定是编程水平高低的重要标识。) 
- 合成聚合复用原则:优先使用聚合或合成关系复用代码。(通过继承来复用代码是面向对象程序设计中被滥用得最多的东西,因为所有的教科书都无一例外的对继承进行了鼓吹从而误导了初学者,类与类之间简单的说有三种关系,Is-A关系、Has-A关系、Use-A关系,分别代表继承、关联和依赖。其中,关联关系根据其关联的强度又可以进一步划分为关联、聚合和合成,但说白了都是Has-A关系,合成聚合复用原则想表达的是优先考虑Has-A关系而不是Is-A关系复用代码,原因嘛可以自己从百度上找到一万个理由,需要说明的是,即使在Java的API中也有不少滥用继承的例子,例如Properties类继承了Hashtable类,Stack类继承了Vector类,这些继承明显就是错误的,更好的做法是在Properties类中放置一个Hashtable类型的成员并且将其键和值都设置为字符串来存储数据,而Stack类的设计也应该是在Stack类中放一个Vector对象来存储数据。记住:任何时候都不要继承工具类,工具是可以拥有并可以使用的,而不是拿来继承的。) 
- 迪米特法则:迪米特法则又叫最少知识原则,一个对象应当对其他对象有尽可能少的了解。(迪米特法则简单的说就是如何做到"低耦合",门面模式和调停者模式就是对迪米特法则的践行。对于门面模式可以举一个简单的例子,你去一家公司洽谈业务,你不需要了解这个公司内部是如何运作的,你甚至可以对这个公司一无所知,去的时候只需要找到公司入口处的前台美女,告诉她们你要做什么,她们会找到合适的人跟你接洽,前台的美女就是公司这个系统的门面。再复杂的系统都可以为用户提供一个简单的门面,Java Web开发中作为前端控制器的Servlet或Filter不就是一个门面吗,浏览器对服务器的运作方式一无所知,但是通过前端控制器就能够根据你的请求得到相应的服务。调停者模式也可以举一个简单的例子来说明,例如一台计算机,CPU、内存、硬盘、显卡、声卡各种设备需要相互配合才能很好的工作,但是如果这些东西都直接连接到一起,计算机的布线将异常复杂,在这种情况下,主板作为一个调停者的身份出现,它将各个设备连接在一起而不需要每个设备之间直接交换数据,这样就减小了系统的耦合度和复杂度,如下图所示。迪米特法则用通俗的话来将就是不要和陌生人打交道,如果真的需要,找一个自己的朋友,让他替你和陌生人打交道。)

这里写图片描述 
这里写图片描述

90、简述一下你了解的设计模式。 
答:所谓设计模式,就是一套被反复使用的代码设计经验的总结(情境中一个问题经过证实的一个解决方案)。使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性。设计模式使人们可以更加简单方便的复用成功的设计和体系结构。将已证实的技术表述成设计模式也会使新系统开发者更加容易理解其设计思路。 
在GoF的《Design Patterns: Elements of Reusable Object-Oriented Software》中给出了三类(创建型[对类的实例化过程的抽象化]、结构型[描述如何将类或对象结合在一起形成更大的结构]、行为型[对在不同的对象之间划分责任和算法的抽象化])共23种设计模式,包括:Abstract Factory(抽象工厂模式),Builder(建造者模式),Factory Method(工厂方法模式),Prototype(原始模型模式),Singleton(单例模式);Facade(门面模式),Adapter(适配器模式),Bridge(桥梁模式),Composite(合成模式),Decorator(装饰模式),Flyweight(享元模式),Proxy(代理模式);Command(命令模式),Interpreter(解释器模式),Visitor(访问者模式),Iterator(迭代子模式),Mediator(调停者模式),Memento(备忘录模式),Observer(观察者模式),State(状态模式),Strategy(策略模式),Template Method(模板方法模式), Chain Of Responsibility(责任链模式)。 
面试被问到关于设计模式的知识时,可以拣最常用的作答,例如: 
- 工厂模式:工厂类可以根据条件生成不同的子类实例,这些子类有一个公共的抽象父类并且实现了相同的方法,但是这些方法针对不同的数据进行了不同的操作(多态方法)。当得到子类的实例后,开发人员可以调用基类中的方法而不必考虑到底返回的是哪一个子类的实例。 
- 代理模式:给一个对象提供一个代理对象,并由代理对象控制原对象的引用。实际开发中,按照使用目的的不同,代理可以分为:远程代理、虚拟代理、保护代理、Cache代理、防火墙代理、同步化代理、智能引用代理。 
- 适配器模式:把一个类的接口变换成客户端所期待的另一种接口,从而使原本因接口不匹配而无法在一起使用的类能够一起工作。 
- 模板方法模式:提供一个抽象类,将部分逻辑以具体方法或构造器的形式实现,然后声明一些抽象方法来迫使子类实现剩余的逻辑。不同的子类可以以不同的方式实现这些抽象方法(多态实现),从而实现不同的业务逻辑。 
除此之外,还可以讲讲上面提到的门面模式、桥梁模式、单例模式、装潢模式(Collections工具类和I/O系统中都使用装潢模式)等,反正基本原则就是拣自己最熟悉的、用得最多的作答,以免言多必失。

91、用Java写一个单例类。 
答: 
- 饿汉式单例

  1. public class Singleton {
  2. private Singleton(){}
  3. private static Singleton instance = new Singleton();
  4. public static Singleton getInstance(){
  5. return instance;
  6. }
  7. }
  • 懒汉式单例
  1. public class Singleton {
  2. private static Singleton instance = null;
  3. private Singleton() {}
  4. public static synchronized Singleton getInstance(){
  5. if (instance == null) instance = new Singleton();
  6. return instance;
  7. }
  8. }

注意:实现一个单例有两点注意事项,①将构造器私有,不允许外界通过构造器创建对象;②通过公开的静态方法向外界返回类的唯一实例。这里有一个问题可以思考:Spring的IoC容器可以为普通的类创建单例,它是怎么做到的呢?

92、什么是UML? 
答:UML是统一建模语言(Unified Modeling Language)的缩写,它发表于1997年,综合了当时已经存在的面向对象的建模语言、方法和过程,是一个支持模型化和软件系统开发的图形化语言,为软件开发的所有阶段提供模型化和可视化支持。使用UML可以帮助沟通与交流,辅助应用设计和文档的生成,还能够阐释系统的结构和行为。

93、UML中有哪些常用的图? 
答:UML定义了多种图形化的符号来描述软件系统部分或全部的静态结构和动态结构,包括:用例图(use case diagram)、类图(class diagram)、时序图(sequence diagram)、协作图(collaboration diagram)、状态图(statechart diagram)、活动图(activity diagram)、构件图(component diagram)、部署图(deployment diagram)等。在这些图形化符号中,有三种图最为重要,分别是:用例图(用来捕获需求,描述系统的功能,通过该图可以迅速的了解系统的功能模块及其关系)、类图(描述类以及类与类之间的关系,通过该图可以快速了解系统)、时序图(描述执行特定任务时对象之间的交互关系以及执行顺序,通过该图可以了解对象能接收的消息也就是说对象能够向外界提供的服务)。 
用例图: 
这里写图片描述 
类图: 
这里写图片描述 
时序图: 
这里写图片描述

94、用Java写一个冒泡排序。 
答:冒泡排序几乎是个程序员都写得出来,但是面试的时候如何写一个逼格高的冒泡排序却不是每个人都能做到,下面提供一个参考代码:

  1. import java.util.Comparator;
  2. /**
  3. * 排序器接口(策略模式: 将算法封装到具有共同接口的独立的类中使得它们可以相互替换)
  4. * @author骆昊
  5. *
  6. */
  7. public interface Sorter {
  8. /**
  9. * 排序
  10. * @param list 待排序的数组
  11. */
  12. public <T extends Comparable<T>> void sort(T[] list);
  13. /**
  14. * 排序
  15. * @param list 待排序的数组
  16. * @param comp 比较两个对象的比较器
  17. */
  18. public <T> void sort(T[] list, Comparator<T> comp);
  19. }
  1. import java.util.Comparator;
  2. /**
  3. * 冒泡排序
  4. *
  5. * @author骆昊
  6. *
  7. */
  8. public class BubbleSorter implements Sorter {
  9. @Override
  10. public <T extends Comparable<T>> void sort(T[] list) {
  11. boolean swapped = true;
  12. for (int i = 1, len = list.length; i < len && swapped; ++i) {
  13. swapped = false;
  14. for (int j = 0; j < len - i; ++j) {
  15. if (list[j].compareTo(list[j + 1]) > 0) {
  16. T temp = list[j];
  17. list[j] = list[j + 1];
  18. list[j + 1] = temp;
  19. swapped = true;
  20. }
  21. }
  22. }
  23. }
  24. @Override
  25. public <T> void sort(T[] list, Comparator<T> comp) {
  26. boolean swapped = true;
  27. for (int i = 1, len = list.length; i < len && swapped; ++i) {
  28. swapped = false;
  29. for (int j = 0; j < len - i; ++j) {
  30. if (comp.compare(list[j], list[j + 1]) > 0) {
  31. T temp = list[j];
  32. list[j] = list[j + 1];
  33. list[j + 1] = temp;
  34. swapped = true;
  35. }
  36. }
  37. }
  38. }
  39. }

95、用Java写一个折半查找。 
答:折半查找,也称二分查找、二分搜索,是一种在有序数组中查找某一特定元素的搜索算法。搜素过程从数组的中间元素开始,如果中间元素正好是要查找的元素,则搜素过程结束;如果某一特定元素大于或者小于中间元素,则在数组大于或小于中间元素的那一半中查找,而且跟开始一样从中间元素开始比较。如果在某一步骤数组已经为空,则表示找不到指定的元素。这种搜索算法每一次比较都使搜索范围缩小一半,其时间复杂度是O(logN)。

  1. import java.util.Comparator;
  2. public class MyUtil {
  3. public static <T extends Comparable<T>> int binarySearch(T[] x, T key) {
  4. return binarySearch(x, 0, x.length- 1, key);
  5. }
  6. // 使用循环实现的二分查找
  7. public static <T> int binarySearch(T[] x, T key, Comparator<T> comp) {
  8. int low = 0;
  9. int high = x.length - 1;
  10. while (low <= high) {
  11. int mid = (low + high) >>> 1;
  12. int cmp = comp.compare(x[mid], key);
  13. if (cmp < 0) {
  14. low= mid + 1;
  15. }
  16. else if (cmp > 0) {
  17. high= mid - 1;
  18. }
  19. else {
  20. return mid;
  21. }
  22. }
  23. return -1;
  24. }
  25. // 使用递归实现的二分查找
  26. private static<T extends Comparable<T>> int binarySearch(T[] x, int low, int high, T key) {
  27. if(low <= high) {
  28. int mid = low + ((high -low) >> 1);
  29. if(key.compareTo(x[mid])== 0) {
  30. return mid;
  31. }
  32. else if(key.compareTo(x[mid])< 0) {
  33. return binarySearch(x,low, mid - 1, key);
  34. }
  35. else {
  36. return binarySearch(x,mid + 1, high, key);
  37. }
  38. }
  39. return -1;
  40. }
  41. }

说明:上面的代码中给出了折半查找的两个版本,一个用递归实现,一个用循环实现。需要注意的是计算中间位置时不应该使用(high+ low) / 2的方式,因为加法运算可能导致整数越界,这里应该使用以下三种方式之一:low + (high - low) / 2或low + (high – low) >> 1或(low + high) >>> 1(>>>是逻辑右移,是不带符号位的右移)

这部分主要是与Java Web和Web Service相关的面试题。

96、阐述Servlet和CGI的区别? 
答:Servlet与CGI的区别在于Servlet处于服务器进程中,它通过多线程方式运行其service()方法,一个实例可以服务于多个请求,并且其实例一般不会销毁,而CGI对每个请求都产生新的进程,服务完成后就销毁,所以效率上低于Servlet。

补充:Sun Microsystems公司在1996年发布Servlet技术就是为了和CGI进行竞争,Servlet是一个特殊的Java程序,一个基于Java的Web应用通常包含一个或多个Servlet类。Servlet不能够自行创建并执行,它是在Servlet容器中运行的,容器将用户的请求传递给Servlet程序,并将Servlet的响应回传给用户。通常一个Servlet会关联一个或多个JSP页面。以前CGI经常因为性能开销上的问题被诟病,然而Fast CGI早就已经解决了CGI效率上的问题,所以面试的时候大可不必信口开河的诟病CGI,事实上有很多你熟悉的网站都使用了CGI技术。

97、Servlet接口中有哪些方法? 
答:Servlet接口定义了5个方法,其中前三个方法与Servlet生命周期相关: 
- void init(ServletConfig config) throws ServletException 
- void service(ServletRequest req, ServletResponse resp) throws ServletException, java.io.IOException 
- void destory() 
- java.lang.String getServletInfo() 
- ServletConfig getServletConfig()

Web容器加载Servlet并将其实例化后,Servlet生命周期开始,容器运行其init()方法进行Servlet的初始化;请求到达时调用Servlet的service()方法,service()方法会根据需要调用与请求对应的doGet或doPost等方法;当服务器关闭或项目被卸载时服务器会将Servlet实例销毁,此时会调用Servlet的destroy()方法。

98、转发(forward)和重定向(redirect)的区别? 
答:forward是容器中控制权的转向,是服务器请求资源,服务器直接访问目标地址的URL,把那个URL 的响应内容读取过来,然后把这些内容再发给浏览器,浏览器根本不知道服务器发送的内容是从哪儿来的,所以它的地址栏中还是原来的地址。redirect就是服务器端根据逻辑,发送一个状态码,告诉浏览器重新去请求那个地址,因此从浏览器的地址栏中可以看到跳转后的链接地址,很明显redirect无法访问到服务器保护起来资源,但是可以从一个网站redirect到其他网站。forward更加高效,所以在满足需要时尽量使用forward(通过调用RequestDispatcher对象的forward()方法,该对象可以通过ServletRequest对象的getRequestDispatcher()方法获得),并且这样也有助于隐藏实际的链接;在有些情况下,比如需要访问一个其它服务器上的资源,则必须使用重定向(通过HttpServletResponse对象调用其sendRedirect()方法实现)。

99、JSP有哪些内置对象?作用分别是什么? 
答:JSP有9个内置对象: 
- request:封装客户端的请求,其中包含来自GET或POST请求的参数; 
- response:封装服务器对客户端的响应; 
- pageContext:通过该对象可以获取其他对象; 
- session:封装用户会话的对象; 
- application:封装服务器运行环境的对象; 
- out:输出服务器响应的输出流对象; 
- config:Web应用的配置对象; 
- page:JSP页面本身(相当于Java程序中的this); 
- exception:封装页面抛出异常的对象。

补充:如果用Servlet来生成网页中的动态内容无疑是非常繁琐的工作,另一方面,所有的文本和HTML标签都是硬编码,即使做出微小的修改,都需要进行重新编译。JSP解决了Servlet的这些问题,它是Servlet很好的补充,可以专门用作为用户呈现视图(View),而Servlet作为控制器(Controller)专门负责处理用户请求并转发或重定向到某个页面。基于Java的Web开发很多都同时使用了Servlet和JSP。JSP页面其实是一个Servlet,能够运行Servlet的服务器(Servlet容器)通常也是JSP容器,可以提供JSP页面的运行环境,Tomcat就是一个Servlet/JSP容器。第一次请求一个JSP页面时,Servlet/JSP容器首先将JSP页面转换成一个JSP页面的实现类,这是一个实现了JspPage接口或其子接口HttpJspPage的Java类。JspPage接口是Servlet的子接口,因此每个JSP页面都是一个Servlet。转换成功后,容器会编译Servlet类,之后容器加载和实例化Java字节码,并执行它通常对Servlet所做的生命周期操作。对同一个JSP页面的后续请求,容器会查看这个JSP页面是否被修改过,如果修改过就会重新转换并重新编译并执行。如果没有则执行内存中已经存在的Servlet实例。我们可以看一段JSP代码对应的Java程序就知道一切了,而且9个内置对象的神秘面纱也会被揭开。

JSP页面:

  1. <%@ page pageEncoding="UTF-8"%>
  2. <%
  3. String path = request.getContextPath();
  4. String basePath = request.getScheme() + "://" + request.getServerName() + ":" + request.getServerPort() + path + "/";
  5. %>
  6. <!DOCTYPE html>
  7. <html>
  8. <head>
  9. <base href="<%=basePath%>">
  10. <title>首页</title>
  11. <style type="text/css">
  12. * { font-family: "Arial"; }
  13. </style>
  14. </head>
  15. <body>
  16. <h1>Hello, World!</h1>
  17. <hr/>
  18. <h2>Current time is: <%= new java.util.Date().toString() %></h2>
  19. </body>
  20. </html>

对应的Java代码:

  1. /*
  2. * Generated by the Jasper component of Apache Tomcat
  3. * Version: Apache Tomcat/7.0.52
  4. * Generated at: 2014-10-13 13:28:38 UTC
  5. * Note: The last modified time of this file was set to
  6. * the last modified time of the source file after
  7. * generation to assist with modification tracking.
  8. */
  9. package org.apache.jsp;
  10. import javax.servlet.*;
  11. import javax.servlet.http.*;
  12. import javax.servlet.jsp.*;
  13. public final class index_jsp extends org.apache.jasper.runtime.HttpJspBase
  14. implements org.apache.jasper.runtime.JspSourceDependent {
  15. private static final javax.servlet.jsp.JspFactory _jspxFactory = javax.servlet.jsp.JspFactory
  16. .getDefaultFactory();
  17. private static java.util.Map<java.lang.String, java.lang.Long> _jspx_dependants;
  18. private javax.el.ExpressionFactory _el_expressionfactory;
  19. private org.apache.tomcat.InstanceManager _jsp_instancemanager;
  20. public java.util.Map<java.lang.String, java.lang.Long> getDependants() {
  21. return _jspx_dependants;
  22. }
  23. public void _jspInit() {
  24. _el_expressionfactory = _jspxFactory.getJspApplicationContext(
  25. getServletConfig().getServletContext()).getExpressionFactory();
  26. _jsp_instancemanager = org.apache.jasper.runtime.InstanceManagerFactory
  27. .getInstanceManager(getServletConfig());
  28. }
  29. public void _jspDestroy() {
  30. }
  31. public void _jspService(
  32. final javax.servlet.http.HttpServletRequest request,
  33. final javax.servlet.http.HttpServletResponse response)
  34. throws java.io.IOException, javax.servlet.ServletException {
  35. // 内置对象就是在这里定义的
  36. final javax.servlet.jsp.PageContext pageContext;
  37. javax.servlet.http.HttpSession session = null;
  38. final javax.servlet.ServletContext application;
  39. final javax.servlet.ServletConfig config;
  40. javax.servlet.jsp.JspWriter out = null;
  41. final java.lang.Object page = this;
  42. javax.servlet.jsp.JspWriter _jspx_out = null;
  43. javax.servlet.jsp.PageContext _jspx_page_context = null;
  44. try {
  45. response.setContentType("text/html;charset=UTF-8");
  46. pageContext = _jspxFactory.getPageContext(this, request, response,
  47. null, true, 8192, true);
  48. _jspx_page_context = pageContext;
  49. application = pageContext.getServletContext();
  50. config = pageContext.getServletConfig();
  51. session = pageContext.getSession();
  52. out = pageContext.getOut();
  53. _jspx_out = out;
  54. out.write('\r');
  55. out.write('\n');
  56. String path = request.getContextPath();
  57. String basePath = request.getScheme() + "://"
  58. + request.getServerName() + ":" + request.getServerPort()
  59. + path + "/";
  60. // 以下代码通过输出流将HTML标签输出到浏览器中
  61. out.write("\r\n");
  62. out.write("\r\n");
  63. out.write("<!DOCTYPE html>\r\n");
  64. out.write("<html>\r\n");
  65. out.write(" <head>\r\n");
  66. out.write(" <base href=\"");
  67. out.print(basePath);
  68. out.write("\">\r\n");
  69. out.write(" <title>首页</title>\r\n");
  70. out.write(" <style type=\"text/css\">\r\n");
  71. out.write(" \t* { font-family: \"Arial\"; }\r\n");
  72. out.write(" </style>\r\n");
  73. out.write(" </head>\r\n");
  74. out.write(" \r\n");
  75. out.write(" <body>\r\n");
  76. out.write(" <h1>Hello, World!</h1>\r\n");
  77. out.write(" <hr/>\r\n");
  78. out.write(" <h2>Current time is: ");
  79. out.print(new java.util.Date().toString());
  80. out.write("</h2>\r\n");
  81. out.write(" </body>\r\n");
  82. out.write("</html>\r\n");
  83. } catch (java.lang.Throwable t) {
  84. if (!(t instanceof javax.servlet.jsp.SkipPageException)) {
  85. out = _jspx_out;
  86. if (out != null && out.getBufferSize() != 0)
  87. try {
  88. out.clearBuffer();
  89. } catch (java.io.IOException e) {
  90. }
  91. if (_jspx_page_context != null)
  92. _jspx_page_context.handlePageException(t);
  93. else
  94. throw new ServletException(t);
  95. }
  96. } finally {
  97. _jspxFactory.releasePageContext(_jspx_page_context);
  98. }
  99. }
  100. }

100、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"。

101、常用的Web服务器有哪些? 
答:Unix和Linux平台下使用最广泛的免费HTTP服务器是Apache服务器,而Windows平台的服务器通常使用IIS作为Web服务器。选择Web服务器应考虑的因素有:性能、安全性、日志和统计、虚拟主机、代理服务器、缓冲服务和集成应用程序等。下面是对常见服务器的简介: 
- IIS:Microsoft的Web服务器产品,全称是Internet Information Services。IIS是允许在公共Intranet或Internet上发布信息的Web服务器。IIS是目前最流行的Web服务器产品之一,很多著名的网站都是建立在IIS的平台上。IIS提供了一个图形界面的管理工具,称为Internet服务管理器,可用于监视配置和控制Internet服务。IIS是一种Web服务组件,其中包括Web服务器、FTP服务器、NNTP服务器和SMTP服务器,分别用于网页浏览、文件传输、新闻服务和邮件发送等方面,它使得在网络(包括互联网和局域网)上发布信息成了一件很容易的事。它提供ISAPI(Intranet Server API)作为扩展Web服务器功能的编程接口;同时,它还提供一个Internet数据库连接器,可以实现对数据库的查询和更新。 
- Kangle:Kangle Web服务器是一款跨平台、功能强大、安全稳定、易操作的高性能Web服务器和反向代理服务器软件。此外,Kangle也是一款专为做虚拟主机研发的Web服务器。实现虚拟主机独立进程、独立身份运行。用户之间安全隔离,一个用户出问题不影响其他用户。支持PHP、ASP、ASP.NET、Java、Ruby等多种动态开发语言。 
- WebSphere:WebSphere Application Server是功能完善、开放的Web应用程序服务器,是IBM电子商务计划的核心部分,它是基于Java的应用环境,用于建立、部署和管理Internet和Intranet Web应用程序,适应各种Web应用程序服务器的需要。 
- WebLogic:WebLogic Server是一款多功能、基于标准的Web应用服务器,为企业构建企业应用提供了坚实的基础。针对各种应用开发、关键性任务的部署,各种系统和数据库的集成、跨Internet协作等Weblogic都提供了相应的支持。由于它具有全面的功能、对开放标准的遵从性、多层架构、支持基于组件的开发等优势,很多公司的企业级应用都选择它来作为开发和部署的环境。WebLogic Server在使应用服务器成为企业应用架构的基础方面一直处于领先地位,为构建集成化的企业级应用提供了稳固的基础。 
- Apache:目前Apache仍然是世界上用得最多的Web服务器,其市场占有率很长时间都保持在60%以上(目前的市场份额约40%左右)。世界上很多著名的网站都是Apache的产物,它的成功之处主要在于它的源代码开放、有一支强大的开发团队、支持跨平台的应用(可以运行在几乎所有的Unix、Windows、Linux系统平台上)以及它的可移植性等方面。 
- Tomcat:Tomcat是一个开放源代码、运行Servlet和JSP的容器。Tomcat实现了Servlet和JSP规范。此外,Tomcat还实现了Apache-Jakarta规范而且比绝大多数商业应用软件服务器要好,因此目前也有不少的Web服务器都选择了Tomcat。 
- Nginx:读作"engine x",是一个高性能的HTTP和反向代理服务器,也是一个IMAP/POP3/SMTP代理服务器。 Nginx是由Igor Sysoev为俄罗斯访问量第二的Rambler站点开发的,第一个公开版本0.1.0发布于2004年10月4日。其将源代码以类BSD许可证的形式发布,因它的稳定性、丰富的功能集、示例配置文件和低系统资源的消耗而闻名。在2014年下半年,Nginx的市场份额达到了14%。

102、JSP和Servlet是什么关系? 
答:其实这个问题在上面已经阐述过了,Servlet是一个特殊的Java程序,它运行于服务器的JVM中,能够依靠服务器的支持向浏览器提供显示内容。JSP本质上是Servlet的一种简易形式,JSP会被服务器处理成一个类似于Servlet的Java程序,可以简化页面内容的生成。Servlet和JSP最主要的不同点在于,Servlet的应用逻辑是在Java文件中,并且完全从表示层中的HTML分离开来。而JSP的情况是Java和HTML可以组合成一个扩展名为.jsp的文件。有人说,Servlet就是在Java中写HTML,而JSP就是在HTML中写Java代码,当然这个说法是很片面且不够准确的。JSP侧重于视图,Servlet更侧重于控制逻辑,在MVC架构模式中,JSP适合充当视图(view)而Servlet适合充当控制器(controller)。

103、讲解JSP中的四种作用域。 
答:JSP中的四种作用域包括page、request、session和application,具体来说: 
- page代表与一个页面相关的对象和属性。 
- request代表与Web客户机发出的一个请求相关的对象和属性。一个请求可能跨越多个页面,涉及多个Web组件;需要在页面显示的临时数据可以置于此作用域。 
- session代表与某个用户与服务器建立的一次会话相关的对象和属性。跟某个用户相关的数据应该放在用户自己的session中。 
- application代表与整个Web应用程序相关的对象和属性,它实质上是跨越整个Web应用程序,包括多个页面、请求和会话的一个全局作用域。

104、如何实现JSP或Servlet的单线程模式? 
答: 
对于JSP页面,可以通过page指令进行设置。

<%@page isThreadSafe=”false”%>

对于Servlet,可以让自定义的Servlet实现SingleThreadModel标识接口。

说明:如果将JSP或Servlet设置成单线程工作模式,会导致每个请求创建一个Servlet实例,这种实践将导致严重的性能问题(服务器的内存压力很大,还会导致频繁的垃圾回收),所以通常情况下并不会这么做。

105、实现会话跟踪的技术有哪些? 
答:由于HTTP协议本身是无状态的,服务器为了区分不同的用户,就需要对用户会话进行跟踪,简单的说就是为用户进行登记,为用户分配唯一的ID,下一次用户在请求中包含此ID,服务器据此判断到底是哪一个用户。 
①URL 重写:在URL中添加用户会话的信息作为请求的参数,或者将唯一的会话ID添加到URL结尾以标识一个会话。 
②设置表单隐藏域:将和会话跟踪相关的字段添加到隐式表单域中,这些信息不会在浏览器中显示但是提交表单时会提交给服务器。 
这两种方式很难处理跨越多个页面的信息传递,因为如果每次都要修改URL或在页面中添加隐式表单域来存储用户会话相关信息,事情将变得非常麻烦。 
③cookie:cookie有两种,一种是基于窗口的,浏览器窗口关闭后,cookie就没有了;另一种是将信息存储在一个临时文件中,并设置存在的时间。当用户通过浏览器和服务器建立一次会话后,会话ID就会随响应信息返回存储在基于窗口的cookie中,那就意味着只要浏览器没有关闭,会话没有超时,下一次请求时这个会话ID又会提交给服务器让服务器识别用户身份。会话中可以为用户保存信息。会话对象是在服务器内存中的,而基于窗口的cookie是在客户端内存中的。如果浏览器禁用了cookie,那么就需要通过下面两种方式进行会话跟踪。当然,在使用cookie时要注意几点:首先不要在cookie中存放敏感信息;其次cookie存储的数据量有限(4k),不能将过多的内容存储cookie中;再者浏览器通常只允许一个站点最多存放20个cookie。当然,和用户会话相关的其他信息(除了会话ID)也可以存在cookie方便进行会话跟踪。 
④HttpSession:在所有会话跟踪技术中,HttpSession对象是最强大也是功能最多的。当一个用户第一次访问某个网站时会自动创建HttpSession,每个用户可以访问他自己的HttpSession。可以通过HttpServletRequest对象的getSession方法获得HttpSession,通过HttpSession的setAttribute方法可以将一个值放在HttpSession中,通过调用HttpSession对象的getAttribute方法,同时传入属性名就可以获取保存在HttpSession中的对象。与上面三种方式不同的是,HttpSession放在服务器的内存中,因此不要将过大的对象放在里面,即使目前的Servlet容器可以在内存将满时将HttpSession中的对象移到其他存储设备中,但是这样势必影响性能。添加到HttpSession中的值可以是任意Java对象,这个对象最好实现了Serializable接口,这样Servlet容器在必要的时候可以将其序列化到文件中,否则在序列化时就会出现异常。

**补充:**HTML5中可以使用Web Storage技术通过JavaScript来保存数据,例如可以使用localStorage和sessionStorage来保存用户会话的信息,也能够实现会话跟踪。

106、过滤器有哪些作用和用法? 
答: Java Web开发中的过滤器(filter)是从Servlet 2.3规范开始增加的功能,并在Servlet 2.4规范中得到增强。对Web应用来说,过滤器是一个驻留在服务器端的Web组件,它可以截取客户端和服务器之间的请求与响应信息,并对这些信息进行过滤。当Web容器接受到一个对资源的请求时,它将判断是否有过滤器与这个资源相关联。如果有,那么容器将把请求交给过滤器进行处理。在过滤器中,你可以改变请求的内容,或者重新设置请求的报头信息,然后再将请求发送给目标资源。当目标资源对请求作出响应时候,容器同样会将响应先转发给过滤器,在过滤器中你可以对响应的内容进行转换,然后再将响应发送到客户端。

常见的过滤器用途主要包括:对用户请求进行统一认证、对用户的访问请求进行记录和审核、对用户发送的数据进行过滤或替换、转换图象格式、对响应内容进行压缩以减少传输量、对请求或响应进行加解密处理、触发资源访问事件、对XML的输出应用XSLT等。

和过滤器相关的接口主要有:Filter、FilterConfig和FilterChain。

编码过滤器的例子:

  1. import java.io.IOException;
  2. import javax.servlet.Filter;
  3. import javax.servlet.FilterChain;
  4. import javax.servlet.FilterConfig;
  5. import javax.servlet.ServletException;
  6. import javax.servlet.ServletRequest;
  7. import javax.servlet.ServletResponse;
  8. import javax.servlet.annotation.WebFilter;
  9. import javax.servlet.annotation.WebInitParam;
  10. @WebFilter(urlPatterns = { "*" },
  11. initParams = {@WebInitParam(name="encoding", value="utf-8")})
  12. public class CodingFilter implements Filter {
  13. private String defaultEncoding = "utf-8";
  14. @Override
  15. public void destroy() {
  16. }
  17. @Override
  18. public void doFilter(ServletRequest req, ServletResponse resp,
  19. FilterChain chain) throws IOException, ServletException {
  20. req.setCharacterEncoding(defaultEncoding);
  21. resp.setCharacterEncoding(defaultEncoding);
  22. chain.doFilter(req, resp);
  23. }
  24. @Override
  25. public void init(FilterConfig config) throws ServletException {
  26. String encoding = config.getInitParameter("encoding");
  27. if (encoding != null) {
  28. defaultEncoding = encoding;
  29. }
  30. }
  31. }

下载计数过滤器的例子:

  1. import java.io.File;
  2. import java.io.FileReader;
  3. import java.io.FileWriter;
  4. import java.io.IOException;
  5. import java.util.Properties;
  6. import java.util.concurrent.ExecutorService;
  7. import java.util.concurrent.Executors;
  8. import javax.servlet.Filter;
  9. import javax.servlet.FilterChain;
  10. import javax.servlet.FilterConfig;
  11. import javax.servlet.ServletException;
  12. import javax.servlet.ServletRequest;
  13. import javax.servlet.ServletResponse;
  14. import javax.servlet.annotation.WebFilter;
  15. import javax.servlet.http.HttpServletRequest;
  16. @WebFilter(urlPatterns = {"/*"})
  17. public class DownloadCounterFilter implements Filter {
  18. private ExecutorService executorService = Executors.newSingleThreadExecutor();
  19. private Properties downloadLog;
  20. private File logFile;
  21. @Override
  22. public void destroy() {
  23. executorService.shutdown();
  24. }
  25. @Override
  26. public void doFilter(ServletRequest req, ServletResponse resp,
  27. FilterChain chain) throws IOException, ServletException {
  28. HttpServletRequest request = (HttpServletRequest) req;
  29. final String uri = request.getRequestURI();
  30. executorService.execute(new Runnable() {
  31. @Override
  32. public void run() {
  33. String value = downloadLog.getProperty(uri);
  34. if(value == null) {
  35. downloadLog.setProperty(uri, "1");
  36. }
  37. else {
  38. int count = Integer.parseInt(value);
  39. downloadLog.setProperty(uri, String.valueOf(++count));
  40. }
  41. try {
  42. downloadLog.store(new FileWriter(logFile), "");
  43. }
  44. catch (IOException e) {
  45. e.printStackTrace();
  46. }
  47. }
  48. });
  49. chain.doFilter(req, resp);
  50. }
  51. @Override
  52. public void init(FilterConfig config) throws ServletException {
  53. String appPath = config.getServletContext().getRealPath("/");
  54. logFile = new File(appPath, "downloadLog.txt");
  55. if(!logFile.exists()) {
  56. try {
  57. logFile.createNewFile();
  58. }
  59. catch(IOException e) {
  60. e.printStackTrace();
  61. }
  62. }
  63. downloadLog = new Properties();
  64. try {
  65. downloadLog.load(new FileReader(logFile));
  66. } catch (IOException e) {
  67. e.printStackTrace();
  68. }
  69. }
  70. }

说明:这里使用了Servlet 3规范中的注解来部署过滤器,当然也可以在web.xml中使用<filter>和<filter-mapping>标签部署过滤器,如108题中所示。

107、监听器有哪些作用和用法? 
答:Java Web开发中的监听器(listener)就是application、session、request三个对象创建、销毁或者往其中添加修改删除属性时自动执行代码的功能组件,如下所示: 
①ServletContextListener:对Servlet上下文的创建和销毁进行监听。 
②ServletContextAttributeListener:监听Servlet上下文属性的添加、删除和替换。 
③HttpSessionListener:对Session的创建和销毁进行监听。

补充:session的销毁有两种情况:1). session超时(可以在web.xml中通过<session-config>/<session-timeout>标签配置超时时间);2). 通过调用session对象的invalidate()方法使session失效。

④HttpSessionAttributeListener:对Session对象中属性的添加、删除和替换进行监听。 
⑤ServletRequestListener:对请求对象的初始化和销毁进行监听。 
⑥ServletRequestAttributeListener:对请求对象属性的添加、删除和替换进行监听。

下面是一个统计网站最多在线人数监听器的例子。

  1. import javax.servlet.ServletContextEvent;
  2. import javax.servlet.ServletContextListener;
  3. import javax.servlet.annotation.WebListener;
  4. /**
  5. 上下文监听器,在服务器启动时初始化onLineCount和maxOnLineCount两个变量
  6. 并将其置于服务器上下文(ServletContext)中,其初始值都是0
  7. */
  8. @WebListener
  9. public class InitListener implements ServletContextListener {
  10. @Override
  11. public void contextDestroyed(ServletContextEvent evt) {
  12. }
  13. @Override
  14. public void contextInitialized(ServletContextEvent evt) {
  15. evt.getServletContext().setAttribute("onLineCount", 0);
  16. evt.getServletContext().setAttribute("maxOnLineCount", 0);
  17. }
  18. }
  1. import java.text.DateFormat;
  2. import java.text.SimpleDateFormat;
  3. import java.util.Date;
  4. import javax.servlet.ServletContext;
  5. import javax.servlet.annotation.WebListener;
  6. import javax.servlet.http.HttpSessionEvent;
  7. import javax.servlet.http.HttpSessionListener;
  8. /**
  9. 会话监听器,在用户会话创建和销毁的时候根据情况
  10. 修改onLineCount和maxOnLineCount的值
  11. */
  12. @WebListener
  13. public class MaxCountListener implements HttpSessionListener {
  14. @Override
  15. public void sessionCreated(HttpSessionEvent event) {
  16. ServletContext ctx = event.getSession().getServletContext();
  17. int count = Integer.parseInt(ctx.getAttribute("onLineCount").toString());
  18. count++;
  19. ctx.setAttribute("onLineCount", count);
  20. int maxOnLineCount = Integer.parseInt(ctx.getAttribute("maxOnLineCount").toString());
  21. if (count > maxOnLineCount) {
  22. ctx.setAttribute("maxOnLineCount", count);
  23. DateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
  24. ctx.setAttribute("date", df.format(new Date()));
  25. }
  26. }
  27. @Override
  28. public void sessionDestroyed(HttpSessionEvent event) {
  29. ServletContext app = event.getSession().getServletContext();
  30. int count = Integer.parseInt(app.getAttribute("onLineCount").toString());
  31. count--;
  32. app.setAttribute("onLineCount", count);
  33. }
  34. }

说明:这里使用了Servlet 3规范中的@WebListener注解配置监听器,当然你可以在web.xml文件中用<listener>标签配置监听器,如108题中所示。

108、web.xml文件中可以配置哪些内容? 
答:web.xml用于配置Web应用的相关信息,如:监听器(listener)、过滤器(filter)、 Servlet、相关参数、会话超时时间、安全验证方式、错误页面等,下面是一些开发中常见的配置:

①配置Spring上下文加载监听器加载Spring配置文件并创建IoC容器:

  1. <context-param>
  2. <param-name>contextConfigLocation</param-name>
  3. <param-value>classpath:applicationContext.xml</param-value>
  4. </context-param>
  5. <listener>
  6. <listener-class>
  7. org.springframework.web.context.ContextLoaderListener
  8. </listener-class>
  9. </listener>

②配置Spring的OpenSessionInView过滤器来解决延迟加载和Hibernate会话关闭的矛盾:

  1. <filter>
  2. <filter-name>openSessionInView</filter-name>
  3. <filter-class>
  4. org.springframework.orm.hibernate3.support.OpenSessionInViewFilter
  5. </filter-class>
  6. </filter>
  7. <filter-mapping>
  8. <filter-name>openSessionInView</filter-name>
  9. <url-pattern>/*</url-pattern>
  10. </filter-mapping>

③配置会话超时时间为10分钟:

  1. <session-config>
  2. <session-timeout>10</session-timeout>
  3. </session-config>

④配置404和Exception的错误页面:

  1. <error-page>
  2. <error-code>404</error-code>
  3. <location>/error.jsp</location>
  4. </error-page>
  5. <error-page>
  6. <exception-type>java.lang.Exception</exception-type>
  7. <location>/error.jsp</location>
  8. </error-page>

⑤配置安全认证方式:

  1. <security-constraint>
  2. <web-resource-collection>
  3. <web-resource-name>ProtectedArea</web-resource-name>
  4. <url-pattern>/admin/*</url-pattern>
  5. <http-method>GET</http-method>
  6. <http-method>POST</http-method>
  7. </web-resource-collection>
  8. <auth-constraint>
  9. <role-name>admin</role-name>
  10. </auth-constraint>
  11. </security-constraint>
  12. <login-config>
  13. <auth-method>BASIC</auth-method>
  14. </login-config>
  15. <security-role>
  16. <role-name>admin</role-name>
  17. </security-role>

说明:对Servlet(小服务)、Listener(监听器)和Filter(过滤器)等Web组件的配置,Servlet 3规范提供了基于注解的配置方式,可以分别使用@WebServlet、@WebListener、@WebFilter注解进行配置。 



补充:如果Web提供了有价值的商业信息或者是敏感数据,那么站点的安全性就是必须考虑的问题。安全认证是实现安全性的重要手段,认证就是要解决“Are you who you say you are?”的问题。认证的方式非常多,简单说来可以分为三类: 
A. What you know? — 口令 
B. What you have? — 数字证书(U盾、密保卡) 
C. Who you are? — 指纹识别、虹膜识别 
在Tomcat中可以通过建立安全套接字层(Secure Socket Layer, SSL)以及通过基本验证或表单验证来实现对安全性的支持。

109、你的项目中使用过哪些JSTL标签? 
答:项目中主要使用了JSTL的核心标签库,包括<c:if>、<c:choose>、<c: when>、<c: otherwise>、<c:forEach>等,主要用于构造循环和分支结构以控制显示逻辑。

说明:虽然JSTL标签库提供了core、sql、fmt、xml等标签库,但是实际开发中建议只使用核心标签库(core),而且最好只使用分支和循环标签并辅以表达式语言(EL),这样才能真正做到数据显示和业务逻辑的分离,这才是最佳实践。

110、使用标签库有什么好处?如何自定义JSP标签? 
答:使用标签库的好处包括以下几个方面: 
- 分离JSP页面的内容和逻辑,简化了Web开发; 
- 开发者可以创建自定义标签来封装业务逻辑和显示逻辑; 
- 标签具有很好的可移植性、可维护性和可重用性; 
- 避免了对Scriptlet(小脚本)的使用(很多公司的项目开发都不允许在JSP中书写小脚本)

自定义JSP标签包括以下几个步骤: 
- 编写一个Java类实现实现Tag/BodyTag/IterationTag接口(开发中通常不直接实现这些接口而是继承TagSupport/BodyTagSupport/SimpleTagSupport类,这是对缺省适配模式的应用),重写doStartTag()、doEndTag()等方法,定义标签要完成的功能 
- 编写扩展名为tld的标签描述文件对自定义标签进行部署,tld文件通常放在WEB-INF文件夹下或其子目录中 
- 在JSP页面中使用taglib指令引用该标签库

下面是一个自定义标签库的例子。

步骤1 - 标签类源代码TimeTag.java:

  1. package com.jackfrued.tags;
  2. import java.io.IOException;
  3. import java.text.SimpleDateFormat;
  4. import java.util.Date;
  5. import javax.servlet.jsp.JspException;
  6. import javax.servlet.jsp.JspWriter;
  7. import javax.servlet.jsp.tagext.TagSupport;
  8. public class TimeTag extends TagSupport {
  9. private static final long serialVersionUID = 1L;
  10. private String format = "yyyy-MM-dd hh:mm:ss";
  11. private String foreColor = "black";
  12. private String backColor = "white";
  13. public int doStartTag() throws JspException {
  14. SimpleDateFormat sdf = new SimpleDateFormat(format);
  15. JspWriter writer = pageContext.getOut();
  16. StringBuilder sb = new StringBuilder();
  17. sb.append(String.format("<span style='color:%s;background-color:%s'>%s</span>",
  18. foreColor, backColor, sdf.format(new Date())));
  19. try {
  20. writer.print(sb.toString());
  21. } catch(IOException e) {
  22. e.printStackTrace();
  23. }
  24. return SKIP_BODY;
  25. }
  26. public void setFormat(String format) {
  27. this.format = format;
  28. }
  29. public void setForeColor(String foreColor) {
  30. this.foreColor = foreColor;
  31. }
  32. public void setBackColor(String backColor) {
  33. this.backColor = backColor;
  34. }
  35. }

步骤2 - 编写标签库描述文件my.tld:

  1. <?xml version="1.0" encoding="UTF-8" ?>
  2. <taglib xmlns="http://java.sun.com/xml/ns/j2ee"
  3. xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4. xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee
  5. http://java.sun.com/xml/ns/j2ee/web-jsptaglibrary_2_0.xsd"
  6. version="2.0">
  7. <description>定义标签库</description>
  8. <tlib-version>1.0</tlib-version>
  9. <short-name>MyTag</short-name>
  10. <tag>
  11. <name>time</name>
  12. <tag-class>com.jackfrued.tags.TimeTag</tag-class>
  13. <body-content>empty</body-content>
  14. <attribute>
  15. <name>format</name>
  16. <required>false</required>
  17. </attribute>
  18. <attribute>
  19. <name>foreColor</name>
  20. </attribute>
  21. <attribute>
  22. <name>backColor</name>
  23. </attribute>
  24. </tag>
  25. </taglib>

步骤3 - 在JSP页面中使用自定义标签:

  1. <%@ page pageEncoding="UTF-8"%>
  2. <%@ taglib prefix="my" uri="/WEB-INF/tld/my.tld" %>
  3. <%
  4. String path = request.getContextPath();
  5. String basePath = request.getScheme() + "://" + request.getServerName() + ":" + request.getServerPort() + path + "/";
  6. %>
  7. <!DOCTYPE html>
  8. <html>
  9. <head>
  10. <base href="<%=basePath%>">
  11. <title>首页</title>
  12. <style type="text/css">
  13. * { font-family: "Arial"; font-size:72px; }
  14. </style>
  15. </head>
  16. <body>
  17. <my:time format="yyyy-MM-dd" backColor="blue" foreColor="yellow"/>
  18. </body>
  19. </html>

如果要将自定义的标签库发布成JAR文件,需要将标签库描述文件(tld文件)放在JAR文件的META-INF目录下,可以JDK中的jar工具完成JAR文件的生成,如果不清楚如何操作,可以请教谷老师和百老师

111、说一下表达式语言(EL)的隐式对象及其作用。 
答:EL的隐式对象包括:pageContext、initParam(访问上下文参数)、param(访问请求参数)、paramValues、header(访问请求头)、headerValues、cookie(访问cookie)、applicationScope(访问application作用域)、sessionScope(访问session作用域)、requestScope(访问request作用域)、pageScope(访问page作用域)。

用法如下所示:

  1. ${pageContext.request.method}
  2. ${pageContext["request"]["method"]}
  3. ${pageContext.request["method"]}
  4. ${pageContext["request"].method}
  5. ${initParam.defaultEncoding}
  6. ${header["accept-language"]}
  7. ${headerValues["accept-language"][0]}
  8. ${cookie.jsessionid.value}
  9. ${sessionScope.loginUser.username}

补充:表达式语言的.和[]运算作用是一致的,唯一的差别在于如果访问的属性名不符合Java标识符命名规则,例如上面的accept-language就不是一个有效的Java标识符,那么这时候就只能用[]运算符而不能使用.运算符获取它的值

112、表达式语言(EL)支持哪些运算符? 
答:除了.和[]运算符,EL还提供了: 
- 算术运算符:+、-、*、/或div、%或mod 
- 关系运算符:==或eq、!=或ne、>或gt、>=或ge、<或lt、<=或le 
- 逻辑运算符:&&或and、||或or、!或not 
- 条件运算符:${statement? A : B}(跟Java的条件运算符类似) 
- empty运算符:检查一个值是否为null或者空(数组长度为0或集合中没有元素也返回true)

113、Java Web开发的Model 1和Model 2分别指的是什么? 
答:Model 1是以页面为中心的Java Web开发,使用JSP+JavaBean技术将页面显示逻辑和业务逻辑处理分开,JSP实现页面显示,JavaBean对象用来保存数据和实现业务逻辑。Model 2是基于MVC(模型-视图-控制器,Model-View-Controller)架构模式的开发模型,实现了模型和视图的彻底分离,利于团队开发和代码复用,如下图所示。

这里写图片描述

114、Servlet 3中的异步处理指的是什么? 
答:在Servlet 3中引入了一项新的技术可以让Servlet异步处理请求。有人可能会质疑,既然都有多线程了,还需要异步处理请求吗?答案是肯定的,因为如果一个任务处理时间相当长,那么Servlet或Filter会一直占用着请求处理线程直到任务结束,随着并发用户的增加,容器将会遭遇线程超出的风险,这这种情况下很多的请求将会被堆积起来而后续的请求可能会遭遇拒绝服务,直到有资源可以处理请求为止。异步特性可以帮助应用节省容器中的线程,特别适合执行时间长而且用户需要得到结果的任务,如果用户不需要得到结果则直接将一个Runnable对象交给Executor并立即返回即可。(如果不清楚多线程和线程池的相关内容,请查看《Java面试题全集(上)》关于多线程和线程池的部分或阅读我的另一篇文章《关于Java并发编程的总结和思考》

补充:多线程在Java诞生初期无疑是一个亮点,而Servlet单实例多线程的工作方式也曾为其赢得美名,然而技术的发展往往会颠覆我们很多的认知,就如同当年爱因斯坦的相对论颠覆了牛顿的经典力学一般。事实上,异步处理绝不是Serlvet 3首创,如果你了解Node.js的话,对Servlet 3的这个重要改进就不以为奇了。

下面是一个支持异步处理请求的Servlet的例子。

  1. import java.io.IOException;
  2. import javax.servlet.AsyncContext;
  3. import javax.servlet.ServletException;
  4. import javax.servlet.annotation.WebServlet;
  5. import javax.servlet.http.HttpServlet;
  6. import javax.servlet.http.HttpServletRequest;
  7. import javax.servlet.http.HttpServletResponse;
  8. @WebServlet(urlPatterns = {"/async"}, asyncSupported = true)
  9. public class AsyncServlet extends HttpServlet {
  10. private static final long serialVersionUID = 1L;
  11. @Override
  12. public void doGet(HttpServletRequest req, HttpServletResponse resp)
  13. throws ServletException, IOException {
  14. // 开启Tomcat异步Servlet支持
  15. req.setAttribute("org.apache.catalina.ASYNC_SUPPORTED", true);
  16. final AsyncContext ctx = req.startAsync(); // 启动异步处理的上下文
  17. // ctx.setTimeout(30000);
  18. ctx.start(new Runnable() {
  19. @Override
  20. public void run() {
  21. // 在此处添加异步处理的代码
  22. ctx.complete();
  23. }
  24. });
  25. }
  26. }

115、如何在基于Java的Web项目中实现文件上传和下载? 
答:在Sevlet 3 以前,Servlet API中没有支持上传功能的API,因此要实现上传功能需要引入第三方工具从POST请求中获得上传的附件或者通过自行处理输入流来获得上传的文件,我们推荐使用Apache的commons-fileupload。 
从Servlet 3开始,文件上传变得无比简单,相信看看下面的例子一切都清楚了。

上传页面index.jsp:

  1. <%@ page pageEncoding="utf-8"%>
  2. <!DOCTYPE html>
  3. <html>
  4. <head>
  5. <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
  6. <title>Photo Upload</title>
  7. </head>
  8. <body>
  9. <h1>Select your photo and upload</h1>
  10. <hr/>
  11. <div style="color:red;font-size:14px;">${hint}</div>
  12. <form action="UploadServlet" method="post" enctype="multipart/form-data">
  13. Photo file: <input type="file" name="photo" />
  14. <input type="submit" value="Upload" />
  15. </form>
  16. </body>
  17. </html>

支持上传的Servlet:

  1. package com.jackfrued.servlet;
  2. import java.io.IOException;
  3. import javax.servlet.ServletException;
  4. import javax.servlet.annotation.MultipartConfig;
  5. import javax.servlet.annotation.WebServlet;
  6. import javax.servlet.http.HttpServlet;
  7. import javax.servlet.http.HttpServletRequest;
  8. import javax.servlet.http.HttpServletResponse;
  9. import javax.servlet.http.Part;
  10. @WebServlet("/UploadServlet")
  11. @MultipartConfig
  12. public class UploadServlet extends HttpServlet {
  13. private static final long serialVersionUID = 1L;
  14. protected void doPost(HttpServletRequest request,
  15. HttpServletResponse response) throws ServletException, IOException {
  16. // 可以用request.getPart()方法获得名为photo的上传附件
  17. // 也可以用request.getParts()获得所有上传附件(多文件上传)
  18. // 然后通过循环分别处理每一个上传的文件
  19. Part part = request.getPart("photo");
  20. if (part != null && part.getSubmittedFileName().length() > 0) {
  21. // 用ServletContext对象的getRealPath()方法获得上传文件夹的绝对路径
  22. String savePath = request.getServletContext().getRealPath("/upload");
  23. // Servlet 3.1规范中可以用Part对象的getSubmittedFileName()方法获得上传的文件名
  24. // 更好的做法是为上传的文件进行重命名(避免同名文件的相互覆盖)
  25. part.write(savePath + "/" + part.getSubmittedFileName());
  26. request.setAttribute("hint", "Upload Successfully!");
  27. } else {
  28. request.setAttribute("hint", "Upload failed!");
  29. }
  30. // 跳转回到上传页面
  31. request.getRequestDispatcher("index.jsp").forward(request, response);
  32. }
  33. }

116、服务器收到用户提交的表单数据,到底是调用Servlet的doGet()还是doPost()方法? 
答:HTML的<form>元素有一个method属性,用来指定提交表单的方式,其值可以是get或post。我们自定义的Servlet一般情况下会重写doGet()或doPost()两个方法之一或全部,如果是GET请求就调用doGet()方法,如果是POST请求就调用doPost()方法,那为什么为什么这样呢?我们自定义的Servlet通常继承自HttpServlet,HttpServlet继承自GenericServlet并重写了其中的service()方法,这个方法是Servlet接口中定义的。HttpServlet重写的service()方法会先获取用户请求的方法,然后根据请求方法调用doGet()、doPost()、doPut()、doDelete()等方法,如果在自定义Servlet中重写了这些方法,那么显然会调用重写过的(自定义的)方法,这显然是对模板方法模式的应用(如果不理解,请参考阎宏博士的《Java与模式》一书的第37章)。当然,自定义Servlet中也可以直接重写service()方法,那么不管是哪种方式的请求,都可以通过自己的代码进行处理,这对于不区分请求方法的场景比较合适。

117、JSP中的静态包含和动态包含有什么区别? 
答:静态包含是通过JSP的include指令包含页面,动态包含是通过JSP标准动作<jsp:forward>包含页面。静态包含是编译时包含,如果包含的页面不存在则会产生编译错误,而且两个页面的"contentType"属性应保持一致,因为两个页面会合二为一,只产生一个class文件,因此被包含页面发生的变动再包含它的页面更新前不会得到更新。动态包含是运行时包含,可以向被包含的页面传递参数,包含页面和被包含页面是独立的,会编译出两个class文件,如果被包含的页面不存在,不会产生编译错误,也不影响页面其他部分的执行。代码如下所示:

  1. <%-- 静态包含 --%>
  2. <%@ include file="..." %>
  3. <%-- 动态包含 --%>
  4. <jsp:include page="...">
  5. <jsp:param name="..." value="..." />
  6. </jsp:include>

118、Servlet中如何获取用户提交的查询参数或表单数据? 
答:可以通过请求对象(HttpServletRequest)的getParameter()方法通过参数名获得参数值。如果有包含多个值的参数(例如复选框),可以通过请求对象的getParameterValues()方法获得。当然也可以通过请求对象的getParameterMap()获得一个参数名和参数值的映射(Map)。

119、Servlet中如何获取用户配置的初始化参数以及服务器上下文参数? 
答:可以通过重写Servlet接口的init(ServletConfig)方法并通过ServletConfig对象的getInitParameter()方法来获取Servlet的初始化参数。可以通过ServletConfig对象的getServletContext()方法获取ServletContext对象,并通过该对象的getInitParameter()方法来获取服务器上下文参数。当然,ServletContext对象也在处理用户请求的方法(如doGet()方法)中通过请求对象的getServletContext()方法来获得。

120、如何设置请求的编码以及响应内容的类型? 
答:通过请求对象(ServletRequest)的setCharacterEncoding(String)方法可以设置请求的编码,其实要彻底解决乱码问题就应该让页面、服务器、请求和响应、Java程序都使用统一的编码,最好的选择当然是UTF-8;通过响应对象(ServletResponse)的setContentType(String)方法可以设置响应内容的类型,当然也可以通过HttpServletResponsed对象的setHeader(String, String)方法来设置。

说明:现在如果还有公司在面试的时候问JSP的声明标记、表达式标记、小脚本标记这些内容的话,这样的公司也不用去了,其实JSP内置对象、JSP指令这些东西基本上都可以忘却了,关于Java Web开发的相关知识,可以看一下我的《Servlet&JSP思维导图》,上面有完整的知识点的罗列。想了解如何实现自定义MVC框架的,可以看一下我的《Java Web自定义MVC框架详解》

121、解释一下网络应用的模式及其特点。 
答:典型的网络应用模式大致有三类:B/S、C/S、P2P。其中B代表浏览器(Browser)、C代表客户端(Client)、S代表服务器(Server),P2P是对等模式,不区分客户端和服务器。B/S应用模式中可以视为特殊的C/S应用模式,只是将C/S应用模式中的特殊的客户端换成了浏览器,因为几乎所有的系统上都有浏览器,那么只要打开浏览器就可以使用应用,没有安装、配置、升级客户端所带来的各种开销。P2P应用模式中,成千上万台彼此连接的计算机都处于对等的地位,整个网络一般来说不依赖专用的集中服务器。网络中的每一台计算机既能充当网络服务的请求者,又对其它计算机的请求作出响应,提供资源和服务。通常这些资源和服务包括:信息的共享和交换、计算资源(如CPU的共享)、存储共享(如缓存和磁盘空间的使用)等,这种应用模式最大的阻力安全性、版本等问题,目前有很多应用都混合使用了多种应用模型,最常见的网络视频应用,它几乎把三种模式都用上了。

补充:此题要跟"电子商务模式"区分开,因为有很多人被问到这个问题的时候马上想到的是B2B(如阿里巴巴)、B2C(如当当、亚马逊、京东)、C2C(如淘宝、拍拍)、C2B(如威客)、O2O(如美团、饿了么)。对于这类问题,可以去百度上面科普一下。

122、什么是Web Service(Web服务)? 
答:从表面上看,Web Service就是一个应用程序,它向外界暴露出一个能够通过Web进行调用的API。这就是说,你能够用编程的方法透明的调用这个应用程序,不需要了解它的任何细节,跟你使用的编程语言也没有关系。例如可以创建一个提供天气预报的Web Service,那么无论你用哪种编程语言开发的应用都可以通过调用它的API并传入城市信息来获得该城市的天气预报。之所以称之为Web Service,是因为它基于HTTP协议传输数据,这使得运行在不同机器上的不同应用无须借助附加的、专门的第三方软件或硬件,就可相互交换数据或集成。

补充:这里必须要提及的一个概念是SOA(Service-Oriented Architecture,面向服务的架构),SOA是一种思想,它将应用程序的不同功能单元通过中立的契约联系起来,独立于硬件平台、操作系统和编程语言,使得各种形式的功能单元能够更好的集成。显然,Web Service是SOA的一种较好的解决方案,它更多的是一种标准,而不是一种具体的技术。

123、概念解释:SOAP、WSDL、UDDI。 
答: 
- SOAP:简单对象访问协议(Simple Object Access Protocol),是Web Service中交换数据的一种协议规范。 
- WSDL:Web服务描述语言(Web Service Description Language),它描述了Web服务的公共接口。这是一个基于XML的关于如何与Web服务通讯和使用的服务描述;也就是描述与目录中列出的Web服务进行交互时需要绑定的协议和信息格式。通常采用抽象语言描述该服务支持的操作和信息,使用的时候再将实际的网络协议和信息格式绑定给该服务。 
- UDDI:统一描述、发现和集成(Universal Description, Discovery and Integration),它是一个基于XML的跨平台的描述规范,可以使世界范围内的企业在互联网上发布自己所提供的服务。简单的说,UDDI是访问各种WSDL的一个门面(可以参考设计模式中的门面模式)。

提示:关于Web Service的相关概念和知识可以在W3CSchool上找到相关的资料。

124、Java规范中和Web Service相关的规范有哪些? 
答:Java规范中和Web Service相关的有三个: 
- JAX-WS(JSR 224):这个规范是早期的基于SOAP的Web Service规范JAX-RPC的替代版本,它并不提供向下兼容性,因为RPC样式的WSDL以及相关的API已经在Java EE5中被移除了。WS-MetaData是JAX-WS的依赖规范,提供了基于注解配置Web Service和SOAP消息的相关API。 
- JAXM(JSR 67):定义了发送和接收消息所需的API,相当于Web Service的服务器端。 
- JAX-RS(JSR 311 & JSR 339 & JSR 370):是Java针对REST(Representation State Transfer)架构风格制定的一套Web Service规范。REST是一种软件架构模式,是一种风格,它不像SOAP那样本身承载着一种消息协议, (两种风格的Web Service均采用了HTTP做传输协议,因为HTTP协议能穿越防火墙,Java的远程方法调用(RMI)等是重量级协议,通常不能穿越防火墙),因此可以将REST视为基于HTTP协议的软件架构。REST中最重要的两个概念是资源定位和资源操作,而HTTP协议恰好完整的提供了这两个点。HTTP协议中的URI可以完成资源定位,而GET、POST、OPTION、DELETE方法可以完成资源操作。因此REST完全依赖HTTP协议就可以完成Web Service,而不像SOAP协议那样只利用了HTTP的传输特性,定位和操作都是由SOAP协议自身完成的,也正是由于SOAP消息的存在使得基于SOAP的Web Service显得笨重而逐渐被淘汰。

125、介绍一下你了解的Java领域的Web Service框架。 
答:Java领域的Web Service框架很多,包括Axis2(Axis的升级版本)、Jersey(RESTful的Web Service框架)、CXF(XFire的延续版本)、HessianTurmericJBoss SOA等,其中绝大多数都是开源框架。

提示:面试被问到这类问题的时候一定选择自己用过的最熟悉的作答,如果之前没有了解过就应该在面试前花一些时间了解其中的两个,并比较其优缺点,这样才能在面试时给出一个漂亮的答案。

这部分主要是开源Java EE框架方面的内容,包括Hibernate、MyBatis、Spring、Spring MVC等,由于Struts 2已经是明日黄花,在这里就不讨论Struts 2的面试题,如果需要了解相关内容,可以参考我的另一篇文章《Java面试题集(86-115)》。此外,这篇文章还对企业应用架构、大型网站架构和应用服务器优化等内容进行了简单的探讨,这些内容相信对面试会很有帮助。

126、什么是ORM? 
答:对象关系映射(Object-Relational Mapping,简称ORM)是一种为了解决程序的面向对象模型与数据库的关系模型互不匹配问题的技术;简单的说,ORM是通过使用描述对象和数据库之间映射的元数据(在Java中可以用XML或者是注解),将程序中的对象自动持久化到关系数据库中或者将关系数据库表中的行转换成Java对象,其本质上就是将数据从一种形式转换到另外一种形式。

127、持久层设计要考虑的问题有哪些?你用过的持久层框架有哪些? 
答:所谓"持久"就是将数据保存到可掉电式存储设备中以便今后使用,简单的说,就是将内存中的数据保存到关系型数据库、文件系统、消息队列等提供持久化支持的设备中。持久层就是系统中专注于实现数据持久化的相对独立的层面。

持久层设计的目标包括: 
- 数据存储逻辑的分离,提供抽象化的数据访问接口。 
- 数据访问底层实现的分离,可以在不修改代码的情况下切换底层实现。 
- 资源管理和调度的分离,在数据访问层实现统一的资源调度(如缓存机制)。 
- 数据抽象,提供更面向对象的数据操作。

持久层框架有: 
Hibernate 
MyBatis 
TopLink 
Guzz 
jOOQ 
Spring Data 
ActiveJDBC

128、Hibernate中SessionFactory是线程安全的吗?Session是线程安全的吗(两个线程能够共享同一个Session吗)?
答:SessionFactory对应Hibernate的一个数据存储的概念,它是线程安全的,可以被多个线程并发访问。SessionFactory一般只会在启动的时候构建。对于应用程序,最好将SessionFactory通过单例模式进行封装以便于访问。Session是一个轻量级非线程安全的对象(线程间不能共享session),它表示与数据库进行交互的一个工作单元。Session是由SessionFactory创建的,在任务完成之后它会被关闭。Session是持久层服务对外提供的主要接口。Session会延迟获取数据库连接(也就是在需要的时候才会获取)。为了避免创建太多的session,可以使用ThreadLocal将session和当前线程绑定在一起,这样可以让同一个线程获得的总是同一个session。Hibernate 3中SessionFactory的getCurrentSession()方法就可以做到。

129、Hibernate中Session的load和get方法的区别是什么? 
答:主要有以下三项区别: 
① 如果没有找到符合条件的记录,get方法返回null,load方法抛出异常。 
② get方法直接返回实体类对象,load方法返回实体类对象的代理。 
③ 在Hibernate 3之前,get方法只在一级缓存中进行数据查找,如果没有找到对应的数据则越过二级缓存,直接发出SQL语句完成数据读取;load方法则可以从二级缓存中获取数据;从Hibernate 3开始,get方法不再是对二级缓存只写不读,它也是可以访问二级缓存的。

说明:对于load()方法Hibernate认为该数据在数据库中一定存在可以放心的使用代理来实现延迟加载,如果没有数据就抛出异常,而通过get()方法获取的数据可以不存在。

130、Session的save()、update()、merge()、lock()、saveOrUpdate()和persist()方法分别是做什么的?有什么区别? 
答:Hibernate的对象有三种状态:瞬时态(transient)、持久态(persistent)和游离态(detached),如第135题中的图所示。瞬时态的实例可以通过调用save()、persist()或者saveOrUpdate()方法变成持久态;游离态的实例可以通过调用 update()、saveOrUpdate()、lock()或者replicate()变成持久态。save()和persist()将会引发SQL的INSERT语句,而update()或merge()会引发UPDATE语句。save()和update()的区别在于一个是将瞬时态对象变成持久态,一个是将游离态对象变为持久态。merge()方法可以完成save()和update()方法的功能,它的意图是将新的状态合并到已有的持久化对象上或创建新的持久化对象。对于persist()方法,按照官方文档的说明:① persist()方法把一个瞬时态的实例持久化,但是并不保证标识符被立刻填入到持久化实例中,标识符的填入可能被推迟到flush的时间;② persist()方法保证当它在一个事务外部被调用的时候并不触发一个INSERT语句,当需要封装一个长会话流程的时候,persist()方法是很有必要的;③ save()方法不保证第②条,它要返回标识符,所以它会立即执行INSERT语句,不管是在事务内部还是外部。至于lock()方法和update()方法的区别,update()方法是把一个已经更改过的脱管状态的对象变成持久状态;lock()方法是把一个没有更改过的脱管状态的对象变成持久状态。

131、阐述Session加载实体对象的过程。 
答:Session加载实体对象的步骤是: 
① Session在调用数据库查询功能之前,首先会在一级缓存中通过实体类型和主键进行查找,如果一级缓存查找命中且数据状态合法,则直接返回; 
② 如果一级缓存没有命中,接下来Session会在当前NonExists记录(相当于一个查询黑名单,如果出现重复的无效查询可以迅速做出判断,从而提升性能)中进行查找,如果NonExists中存在同样的查询条件,则返回null; 
③ 如果一级缓存查询失败则查询二级缓存,如果二级缓存命中则直接返回; 
④ 如果之前的查询都未命中,则发出SQL语句,如果查询未发现对应记录则将此次查询添加到Session的NonExists中加以记录,并返回null; 
⑤ 根据映射配置和SQL语句得到ResultSet,并创建对应的实体对象; 
⑥ 将对象纳入Session(一级缓存)的管理; 
⑦ 如果有对应的拦截器,则执行拦截器的onLoad方法; 
⑧ 如果开启并设置了要使用二级缓存,则将数据对象纳入二级缓存; 
⑨ 返回数据对象。

132、Query接口的list方法和iterate方法有什么区别? 
答: 
① list()方法无法利用一级缓存和二级缓存(对缓存只写不读),它只能在开启查询缓存的前提下使用查询缓存;iterate()方法可以充分利用缓存,如果目标数据只读或者读取频繁,使用iterate()方法可以减少性能开销。 
② list()方法不会引起N+1查询问题,而iterate()方法可能引起N+1查询问题

说明:关于N+1查询问题,可以参考CSDN上的一篇文章《什么是N+1查询》

133、Hibernate如何实现分页查询? 
答:通过Hibernate实现分页查询,开发人员只需要提供HQL语句(调用Session的createQuery()方法)或查询条件(调用Session的createCriteria()方法)、设置查询起始行数(调用Query或Criteria接口的setFirstResult()方法)和最大查询行数(调用Query或Criteria接口的setMaxResults()方法),并调用Query或Criteria接口的list()方法,Hibernate会自动生成分页查询的SQL语句。

134、锁机制有什么用?简述Hibernate的悲观锁和乐观锁机制。 
答:有些业务逻辑在执行过程中要求对数据进行排他性的访问,于是需要通过一些机制保证在此过程中数据被锁住不会被外界修改,这就是所谓的锁机制。 
Hibernate支持悲观锁和乐观锁两种锁机制。悲观锁,顾名思义悲观的认为在数据处理过程中极有可能存在修改数据的并发事务(包括本系统的其他事务或来自外部系统的事务),于是将处理的数据设置为锁定状态。悲观锁必须依赖数据库本身的锁机制才能真正保证数据访问的排他性,关于数据库的锁机制和事务隔离级别在《Java面试题大全(上)》中已经讨论过了。乐观锁,顾名思义,对并发事务持乐观态度(认为对数据的并发操作不会经常性的发生),通过更加宽松的锁机制来解决由于悲观锁排他性的数据访问对系统性能造成的严重影响。最常见的乐观锁是通过数据版本标识来实现的,读取数据时获得数据的版本号,更新数据时将此版本号加1,然后和数据库表对应记录的当前版本号进行比较,如果提交的数据版本号大于数据库中此记录的当前版本号则更新数据,否则认为是过期数据无法更新。Hibernate中通过Session的get()和load()方法从数据库中加载对象时可以通过参数指定使用悲观锁;而乐观锁可以通过给实体类加整型的版本字段再通过XML或@Version注解进行配置。

提示:使用乐观锁会增加了一个版本字段,很明显这需要额外的空间来存储这个版本字段,浪费了空间,但是乐观锁会让系统具有更好的并发性,这是对时间的节省。因此乐观锁也是典型的空间换时间的策略。

135、阐述实体对象的三种状态以及转换关系。 
答:最新的Hibernate文档中为Hibernate对象定义了四种状态(原来是三种状态,面试的时候基本上问的也是三种状态),分别是:瞬时态(new, or transient)、持久态(managed, or persistent)、游状态(detached)和移除态(removed,以前Hibernate文档中定义的三种状态中没有移除态),如下图所示,就以前的Hibernate文档中移除态被视为是瞬时态。

这里写图片描述

  • 瞬时态:当new一个实体对象后,这个对象处于瞬时态,即这个对象只是一个保存临时数据的内存区域,如果没有变量引用这个对象,则会被JVM的垃圾回收机制回收。这个对象所保存的数据与数据库没有任何关系,除非通过Session的save()、saveOrUpdate()、persist()、merge()方法把瞬时态对象与数据库关联,并把数据插入或者更新到数据库,这个对象才转换为持久态对象。
  • 持久态:持久态对象的实例在数据库中有对应的记录,并拥有一个持久化标识(ID)。对持久态对象进行delete操作后,数据库中对应的记录将被删除,那么持久态对象与数据库记录不再存在对应关系,持久态对象变成移除态(可以视为瞬时态)。持久态对象被修改变更后,不会马上同步到数据库,直到数据库事务提交。
  • 游离态:当Session进行了close()、clear()、evict()或flush()后,实体对象从持久态变成游离态,对象虽然拥有持久和与数据库对应记录一致的标识值,但是因为对象已经从会话中清除掉,对象不在持久化管理之内,所以处于游离态(也叫脱管态)。游离态的对象与临时状态对象是十分相似的,只是它还含有持久化标识。

提示:关于这个问题,在Hibernate的官方文档中有更为详细的解读。

136、如何理解Hibernate的延迟加载机制?在实际应用中,延迟加载与Session关闭的矛盾是如何处理的? 
答:延迟加载就是并不是在读取的时候就把数据加载进来,而是等到使用时再加载。Hibernate使用了虚拟代理机制实现延迟加载,我们使用Session的load()方法加载数据或者一对多关联映射在使用延迟加载的情况下从一的一方加载多的一方,得到的都是虚拟代理,简单的说返回给用户的并不是实体本身,而是实体对象的代理。代理对象在用户调用getter方法时才会去数据库加载数据。但加载数据就需要数据库连接。而当我们把会话关闭时,数据库连接就同时关闭了。

延迟加载与session关闭的矛盾一般可以这样处理: 
① 关闭延迟加载特性。这种方式操作起来比较简单,因为Hibernate的延迟加载特性是可以通过映射文件或者注解进行配置的,但这种解决方案存在明显的缺陷。首先,出现"no session or session was closed"通常说明系统中已经存在主外键关联,如果去掉延迟加载的话,每次查询的开销都会变得很大。 
② 在session关闭之前先获取需要查询的数据,可以使用工具方法Hibernate.isInitialized()判断对象是否被加载,如果没有被加载则可以使用Hibernate.initialize()方法加载对象。 
③ 使用拦截器或过滤器延长Session的生命周期直到视图获得数据。Spring整合Hibernate提供的OpenSessionInViewFilter和OpenSessionInViewInterceptor就是这种做法。

137、举一个多对多关联的例子,并说明如何实现多对多关联映射。 
答:例如:商品和订单、学生和课程都是典型的多对多关系。可以在实体类上通过@ManyToMany注解配置多对多关联或者通过映射文件中的和标签配置多对多关联,但是实际项目开发中,很多时候都是将多对多关联映射转换成两个多对一关联映射来实现的。

138、谈一下你对继承映射的理解。 
答:继承关系的映射策略有三种: 
① 每个继承结构一张表(table per class hierarchy),不管多少个子类都用一张表。 
② 每个子类一张表(table per subclass),公共信息放一张表,特有信息放单独的表。 
③ 每个具体类一张表(table per concrete class),有多少个子类就有多少张表。 
第一种方式属于单表策略,其优点在于查询子类对象的时候无需表连接,查询速度快,适合多态查询;缺点是可能导致表很大。后两种方式属于多表策略,其优点在于数据存储紧凑,其缺点是需要进行连接查询,不适合多态查询。

139、简述Hibernate常见优化策略。 
答:这个问题应当挑自己使用过的优化策略回答,常用的有: 
① 制定合理的缓存策略(二级缓存、查询缓存)。 
② 采用合理的Session管理机制。 
③ 尽量使用延迟加载特性。 
④ 设定合理的批处理参数。 
⑤ 如果可以,选用UUID作为主键生成器。 
⑥ 如果可以,选用基于版本号的乐观锁替代悲观锁。 
⑦ 在开发过程中, 开启hibernate.show_sql选项查看生成的SQL,从而了解底层的状况;开发完成后关闭此选项。 
⑧ 考虑数据库本身的优化,合理的索引、恰当的数据分区策略等都会对持久层的性能带来可观的提升,但这些需要专业的DBA(数据库管理员)提供支持。

140、谈一谈Hibernate的一级缓存、二级缓存和查询缓存。 
答:Hibernate的Session提供了一级缓存的功能,默认总是有效的,当应用程序保存持久化实体、修改持久化实体时,Session并不会立即把这种改变提交到数据库,而是缓存在当前的Session中,除非显示调用了Session的flush()方法或通过close()方法关闭Session。通过一级缓存,可以减少程序与数据库的交互,从而提高数据库访问性能。 
SessionFactory级别的二级缓存是全局性的,所有的Session可以共享这个二级缓存。不过二级缓存默认是关闭的,需要显示开启并指定需要使用哪种二级缓存实现类(可以使用第三方提供的实现)。一旦开启了二级缓存并设置了需要使用二级缓存的实体类,SessionFactory就会缓存访问过的该实体类的每个对象,除非缓存的数据超出了指定的缓存空间。 
一级缓存和二级缓存都是对整个实体进行缓存,不会缓存普通属性,如果希望对普通属性进行缓存,可以使用查询缓存。查询缓存是将HQL或SQL语句以及它们的查询结果作为键值对进行缓存,对于同样的查询可以直接从缓存中获取数据。查询缓存默认也是关闭的,需要显示开启。

141、Hibernate中DetachedCriteria类是做什么的? 
答:DetachedCriteria和Criteria的用法基本上是一致的,但Criteria是由Session的createCriteria()方法创建的,也就意味着离开创建它的Session,Criteria就无法使用了。DetachedCriteria不需要Session就可以创建(使用DetachedCriteria.forClass()方法创建),所以通常也称其为离线的Criteria,在需要进行查询操作的时候再和Session绑定(调用其getExecutableCriteria(Session)方法),这也就意味着一个DetachedCriteria可以在需要的时候和不同的Session进行绑定。

142、@OneToMany注解的mappedBy属性有什么作用? 
答:@OneToMany用来配置一对多关联映射,但通常情况下,一对多关联映射都由多的一方来维护关联关系,例如学生和班级,应该在学生类中添加班级属性来维持学生和班级的关联关系(在数据库中是由学生表中的外键班级编号来维护学生表和班级表的多对一关系),如果要使用双向关联,在班级类中添加一个容器属性来存放学生,并使用@OneToMany注解进行映射,此时mappedBy属性就非常重要。如果使用XML进行配置,可以用<set>标签的inverse="true"设置来达到同样的效果。

143、MyBatis中使用#$书写占位符有什么区别? 
答:#将传入的数据都当成一个字符串,会对传入的数据自动加上引号;$将传入的数据直接显示生成在SQL中。注意:使用$占位符可能会导致SQL注射攻击,能用#的地方就不要使用$,写order by子句的时候应该用$而不是#

144、解释一下MyBatis中命名空间(namespace)的作用。 
答:在大型项目中,可能存在大量的SQL语句,这时候为每个SQL语句起一个唯一的标识(ID)就变得并不容易了。为了解决这个问题,在MyBatis中,可以为每个映射文件起一个唯一的命名空间,这样定义在这个映射文件中的每个SQL语句就成了定义在这个命名空间中的一个ID。只要我们能够保证每个命名空间中这个ID是唯一的,即使在不同映射文件中的语句ID相同,也不会再产生冲突了。

145、MyBatis中的动态SQL是什么意思? 
答:对于一些复杂的查询,我们可能会指定多个查询条件,但是这些条件可能存在也可能不存在,例如在58同城上面找房子,我们可能会指定面积、楼层和所在位置来查找房源,也可能会指定面积、价格、户型和所在位置来查找房源,此时就需要根据用户指定的条件动态生成SQL语句。如果不使用持久层框架我们可能需要自己拼装SQL语句,还好MyBatis提供了动态SQL的功能来解决这个问题。MyBatis中用于实现动态SQL的元素主要有: 
- if 
- choose / when / otherwise 
- trim 
- where 
- set 
- foreach

下面是映射文件的片段。

  1. <select id="foo" parameterType="Blog" resultType="Blog">
  2. select * from t_blog where 1 = 1
  3. <if test="title != null">
  4. and title = #{title}
  5. </if>
  6. <if test="content != null">
  7. and content = #{content}
  8. </if>
  9. <if test="owner != null">
  10. and owner = #{owner}
  11. </if>
  12. </select>

当然也可以像下面这些书写。

  1. <select id="foo" parameterType="Blog" resultType="Blog">
  2. select * from t_blog where 1 = 1
  3. <choose>
  4. <when test="title != null">
  5. and title = #{title}
  6. </when>
  7. <when test="content != null">
  8. and content = #{content}
  9. </when>
  10. <otherwise>
  11. and owner = "owner1"
  12. </otherwise>
  13. </choose>
  14. </select>

再看看下面这个例子。

  1. <select id="bar" resultType="Blog">
  2. select * from t_blog where id in
  3. <foreach collection="array" index="index"
  4. item="item" open="(" separator="," close=")">
  5. #{item}
  6. </foreach>
  7. </select>

146、什么是IoC和DI?DI是如何实现的? 
答:IoC叫控制反转,是Inversion of Control的缩写,DI(Dependency Injection)叫依赖注入,是对IoC更简单的诠释。控制反转是把传统上由程序代码直接操控的对象的调用权交给容器,通过容器来实现对象组件的装配和管理。所谓的"控制反转"就是对组件对象控制权的转移,从程序代码本身转移到了外部容器,由容器来创建对象并管理对象之间的依赖关系。IoC体现了好莱坞原则 - "Don’t call me, we will call you"。依赖注入的基本原则是应用组件不应该负责查找资源或者其他依赖的协作对象。配置对象的工作应该由容器负责,查找资源的逻辑应该从应用组件的代码中抽取出来,交给容器来完成。DI是对IoC更准确的描述,即组件之间的依赖关系由容器在运行期决定,形象的来说,即由容器动态的将某种依赖关系注入到组件之中。

举个例子:一个类A需要用到接口B中的方法,那么就需要为类A和接口B建立关联或依赖关系,最原始的方法是在类A中创建一个接口B的实现类C的实例,但这种方法需要开发人员自行维护二者的依赖关系,也就是说当依赖关系发生变动的时候需要修改代码并重新构建整个系统。如果通过一个容器来管理这些对象以及对象的依赖关系,则只需要在类A中定义好用于关联接口B的方法(构造器或setter方法),将类A和接口B的实现类C放入容器中,通过对容器的配置来实现二者的关联。

依赖注入可以通过setter方法注入(设值注入)、构造器注入和接口注入三种方式来实现,Spring支持setter注入和构造器注入,通常使用构造器注入来注入必须的依赖关系,对于可选的依赖关系,则setter注入是更好的选择,setter注入需要类提供无参构造器或者无参的静态工厂方法来创建对象。

147、Spring中Bean的作用域有哪些? 
答:在Spring的早期版本中,仅有两个作用域:singleton和prototype,前者表示Bean以单例的方式存在;后者表示每次从容器中调用Bean时,都会返回一个新的实例,prototype通常翻译为原型。

补充:设计模式中的创建型模式中也有一个原型模式,原型模式也是一个常用的模式,例如做一个室内设计软件,所有的素材都在工具箱中,而每次从工具箱中取出的都是素材对象的一个原型,可以通过对象克隆来实现原型模式。

Spring 2.x中针对WebApplicationContext新增了3个作用域,分别是:request(每次HTTP请求都会创建一个新的Bean)、session(同一个HttpSession共享同一个Bean,不同的HttpSession使用不同的Bean)和globalSession(同一个全局Session共享一个Bean)。

说明:单例模式和原型模式都是重要的设计模式。一般情况下,无状态或状态不可变的类适合使用单例模式。在传统开发中,由于DAO持有Connection这个非线程安全对象因而没有使用单例模式;但在Spring环境下,所有DAO类对可以采用单例模式,因为Spring利用AOP和Java API中的ThreadLocal对非线程安全的对象进行了特殊处理。

ThreadLocal为解决多线程程序的并发问题提供了一种新的思路。ThreadLocal,顾名思义是线程的一个本地化对象,当工作于多线程中的对象使用ThreadLocal维护变量时,ThreadLocal为每个使用该变量的线程分配一个独立的变量副本,所以每一个线程都可以独立的改变自己的副本,而不影响其他线程所对应的副本。从线程的角度看,这个变量就像是线程的本地变量。

ThreadLocal类非常简单好用,只有四个方法,能用上的也就是下面三个方法: 
- void set(T value):设置当前线程的线程局部变量的值。 
- T get():获得当前线程所对应的线程局部变量的值。 
- void remove():删除当前线程中线程局部变量的值。

ThreadLocal是如何做到为每一个线程维护一份独立的变量副本的呢?在ThreadLocal类中有一个Map,键为线程对象,值是其线程对应的变量的副本,自己要模拟实现一个ThreadLocal类其实并不困难,代码如下所示:

  1. import java.util.Collections;
  2. import java.util.HashMap;
  3. import java.util.Map;
  4. public class MyThreadLocal<T> {
  5. private Map<Thread, T> map = Collections.synchronizedMap(new HashMap<Thread, T>());
  6. public void set(T newValue) {
  7. map.put(Thread.currentThread(), newValue);
  8. }
  9. public T get() {
  10. return map.get(Thread.currentThread());
  11. }
  12. public void remove() {
  13. map.remove(Thread.currentThread());
  14. }
  15. }

148、解释一下什么叫AOP(面向切面编程)? 
答:AOP(Aspect-Oriented Programming)指一种程序设计范型,该范型以一种称为切面(aspect)的语言构造为基础,切面是一种新的模块化机制,用来描述分散在对象、类或方法中的横切关注点(crosscutting concern)。

149、你是如何理解"横切关注"这个概念的? 
答:"横切关注"是会影响到整个应用程序的关注功能,它跟正常的业务逻辑是正交的,没有必然的联系,但是几乎所有的业务逻辑都会涉及到这些关注功能。通常,事务、日志、安全性等关注就是应用中的横切关注功能。

150、你如何理解AOP中的连接点(Joinpoint)、切点(Pointcut)、增强(Advice)、引介(Introduction)、织入(Weaving)、切面(Aspect)这些概念? 
答: 
a. 连接点(Joinpoint):程序执行的某个特定位置(如:某个方法调用前、调用后,方法抛出异常后)。一个类或一段程序代码拥有一些具有边界性质的特定点,这些代码中的特定点就是连接点。Spring仅支持方法的连接点。 
b. 切点(Pointcut):如果连接点相当于数据中的记录,那么切点相当于查询条件,一个切点可以匹配多个连接点。Spring AOP的规则解析引擎负责解析切点所设定的查询条件,找到对应的连接点。 
c. 增强(Advice):增强是织入到目标类连接点上的一段程序代码。Spring提供的增强接口都是带方位名的,如:BeforeAdvice、AfterReturningAdvice、ThrowsAdvice等。很多资料上将增强译为“通知”,这明显是个词不达意的翻译,让很多程序员困惑了许久。

说明: Advice在国内的很多书面资料中都被翻译成"通知",但是很显然这个翻译无法表达其本质,有少量的读物上将这个词翻译为"增强",这个翻译是对Advice较为准确的诠释,我们通过AOP将横切关注功能加到原有的业务逻辑上,这就是对原有业务逻辑的一种增强,这种增强可以是前置增强、后置增强、返回后增强、抛异常时增强和包围型增强。

d. 引介(Introduction):引介是一种特殊的增强,它为类添加一些属性和方法。这样,即使一个业务类原本没有实现某个接口,通过引介功能,可以动态的未该业务类添加接口的实现逻辑,让业务类成为这个接口的实现类。 
e. 织入(Weaving):织入是将增强添加到目标类具体连接点上的过程,AOP有三种织入方式:①编译期织入:需要特殊的Java编译期(例如AspectJ的ajc);②装载期织入:要求使用特殊的类加载器,在装载类的时候对类进行增强;③运行时织入:在运行时为目标类生成代理实现增强。Spring采用了动态代理的方式实现了运行时织入,而AspectJ采用了编译期织入和装载期织入的方式。 
f. 切面(Aspect):切面是由切点和增强(引介)组成的,它包括了对横切关注功能的定义,也包括了对连接点的定义。

补充:代理模式是GoF提出的23种设计模式中最为经典的模式之一,代理模式是对象的结构模式,它给某一个对象提供一个代理对象,并由代理对象控制对原对象的引用。简单的说,代理对象可以完成比原对象更多的职责,当需要为原对象添加横切关注功能时,就可以使用原对象的代理对象。我们在打开Office系列的Word文档时,如果文档中有插图,当文档刚加载时,文档中的插图都只是一个虚框占位符,等用户真正翻到某页要查看该图片时,才会真正加载这张图,这其实就是对代理模式的使用,代替真正图片的虚框就是一个虚拟代理;Hibernate的load方法也是返回一个虚拟代理对象,等用户真正需要访问对象的属性时,才向数据库发出SQL语句获得真实对象。

下面用一个找枪手代考的例子演示代理模式的使用:

  1. /**
  2. * 参考人员接口
  3. * @author 骆昊
  4. *
  5. */
  6. public interface Candidate {
  7. /**
  8. * 答题
  9. */
  10. public void answerTheQuestions();
  11. }
  1. /**
  2. * 懒学生
  3. * @author 骆昊
  4. *
  5. */
  6. public class LazyStudent implements Candidate {
  7. private String name; // 姓名
  8. public LazyStudent(String name) {
  9. this.name = name;
  10. }
  11. @Override
  12. public void answerTheQuestions() {
  13. // 懒学生只能写出自己的名字不会答题
  14. System.out.println("姓名: " + name);
  15. }
  16. }
  1. /**
  2. * 枪手
  3. * @author 骆昊
  4. *
  5. */
  6. public class Gunman implements Candidate {
  7. private Candidate target; // 被代理对象
  8. public Gunman(Candidate target) {
  9. this.target = target;
  10. }
  11. @Override
  12. public void answerTheQuestions() {
  13. // 枪手要写上代考的学生的姓名
  14. target.answerTheQuestions();
  15. // 枪手要帮助懒学生答题并交卷
  16. System.out.println("奋笔疾书正确答案");
  17. System.out.println("交卷");
  18. }
  19. }
  1. public class ProxyTest1 {
  2. public static void main(String[] args) {
  3. Candidate c = new Gunman(new LazyStudent("王小二"));
  4. c.answerTheQuestions();
  5. }
  6. }

说明:从JDK 1.3开始,Java提供了动态代理技术,允许开发者在运行时创建接口的代理实例,主要包括Proxy类和InvocationHandler接口。下面的例子使用动态代理为ArrayList编写一个代理,在添加和删除元素时,在控制台打印添加或删除的元素以及ArrayList的大小:

  1. import java.lang.reflect.InvocationHandler;
  2. import java.lang.reflect.Method;
  3. import java.util.List;
  4. public class ListProxy<T> implements InvocationHandler {
  5. private List<T> target;
  6. public ListProxy(List<T> target) {
  7. this.target = target;
  8. }
  9. @Override
  10. public Object invoke(Object proxy, Method method, Object[] args)
  11. throws Throwable {
  12. Object retVal = null;
  13. System.out.println("[" + method.getName() + ": " + args[0] + "]");
  14. retVal = method.invoke(target, args);
  15. System.out.println("[size=" + target.size() + "]");
  16. return retVal;
  17. }
  18. }
  1. import java.lang.reflect.Proxy;
  2. import java.util.ArrayList;
  3. import java.util.List;
  4. public class ProxyTest2 {
  5. @SuppressWarnings("unchecked")
  6. public static void main(String[] args) {
  7. List<String> list = new ArrayList<String>();
  8. Class<?> clazz = list.getClass();
  9. ListProxy<String> myProxy = new ListProxy<String>(list);
  10. List<String> newList = (List<String>)
  11. Proxy.newProxyInstance(clazz.getClassLoader(),
  12. clazz.getInterfaces(), myProxy);
  13. newList.add("apple");
  14. newList.add("banana");
  15. newList.add("orange");
  16. newList.remove("banana");
  17. }
  18. }

说明:使用Java的动态代理有一个局限性就是代理的类必须要实现接口,虽然面向接口编程是每个优秀的Java程序都知道的规则,但现实往往不尽如人意,对于没有实现接口的类如何为其生成代理呢?继承!继承是最经典的扩展已有代码能力的手段,虽然继承常常被初学者滥用,但继承也常常被进阶的程序员忽视。CGLib采用非常底层的字节码生成技术,通过为一个类创建子类来生成代理,它弥补了Java动态代理的不足,因此Spring中动态代理和CGLib都是创建代理的重要手段,对于实现了接口的类就用动态代理为其生成代理类,而没有实现接口的类就用CGLib通过继承的方式为其创建代理。

151、Spring中自动装配的方式有哪些? 
答: 
- no:不进行自动装配,手动设置Bean的依赖关系。 
- byName:根据Bean的名字进行自动装配。 
- byType:根据Bean的类型进行自动装配。 
- constructor:类似于byType,不过是应用于构造器的参数,如果正好有一个Bean与构造器的参数类型相同则可以自动装配,否则会导致错误。 
- autodetect:如果有默认的构造器,则通过constructor的方式进行自动装配,否则使用byType的方式进行自动装配。

说明:自动装配没有自定义装配方式那么精确,而且不能自动装配简单属性(基本类型、字符串等),在使用时应注意。

152、Spring中如何使用注解来配置Bean?有哪些相关的注解? 
答:首先需要在Spring配置文件中增加如下配置:

<context:component-scan base-package="org.example"/>

然后可以用@Component、@Controller、@Service、@Repository注解来标注需要由Spring IoC容器进行对象托管的类。这几个注解没有本质区别,只不过@Controller通常用于控制器,@Service通常用于业务逻辑类,@Repository通常用于仓储类(例如我们的DAO实现类),普通的类用@Component来标注。

153、Spring支持的事务管理类型有哪些?你在项目中使用哪种方式? 
答:Spring支持编程式事务管理和声明式事务管理。许多Spring框架的用户选择声明式事务管理,因为这种方式和应用程序的关联较少,因此更加符合轻量级容器的概念。声明式事务管理要优于编程式事务管理,尽管在灵活性方面它弱于编程式事务管理,因为编程式事务允许你通过代码控制业务。

事务分为全局事务和局部事务。全局事务由应用服务器管理,需要底层服务器JTA支持(如WebLogic、WildFly等)。局部事务和底层采用的持久化方案有关,例如使用JDBC进行持久化时,需要使用Connetion对象来操作事务;而采用Hibernate进行持久化时,需要使用Session对象来操作事务。

Spring提供了如下所示的事务管理器。

事务管理器实现类目标对象
DataSourceTransactionManager注入DataSource
HibernateTransactionManager注入SessionFactory
JdoTransactionManager管理JDO事务
JtaTransactionManager使用JTA管理事务
PersistenceBrokerTransactionManager管理Apache的OJB事务

这些事务的父接口都是PlatformTransactionManager。Spring的事务管理机制是一种典型的策略模式,PlatformTransactionManager代表事务管理接口,该接口定义了三个方法,该接口并不知道底层如何管理事务,但是它的实现类必须提供getTransaction()方法(开启事务)、commit()方法(提交事务)、rollback()方法(回滚事务)的多态实现,这样就可以用不同的实现类代表不同的事务管理策略。使用JTA全局事务策略时,需要底层应用服务器支持,而不同的应用服务器所提供的JTA全局事务可能存在细节上的差异,因此实际配置全局事务管理器是可能需要使用JtaTransactionManager的子类,如:WebLogicJtaTransactionManager(Oracle的WebLogic服务器提供)、UowJtaTransactionManager(IBM的WebSphere服务器提供)等。

编程式事务管理如下所示。

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <beans xmlns="http://www.springframework.org/schema/beans"
  3. xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p"
  4. xmlns:p="http://www.springframework.org/schema/context"
  5. xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
  6. http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">
  7. <context:component-scan base-package="com.jackfrued"/>
  8. <bean id="propertyConfig"
  9. class="org.springframework.beans.factory.config.
  10. PropertyPlaceholderConfigurer">
  11. <property name="location">
  12. <value>jdbc.properties</value>
  13. </property>
  14. </bean>
  15. <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource">
  16. <property name="driverClassName">
  17. <value>${db.driver}</value>
  18. </property>
  19. <property name="url">
  20. <value>${db.url}</value>
  21. </property>
  22. <property name="username">
  23. <value>${db.username}</value>
  24. </property>
  25. <property name="password">
  26. <value>${db.password}</value>
  27. </property>
  28. </bean>
  29. <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
  30. <property name="dataSource">
  31. <ref bean="dataSource" />
  32. </property>
  33. </bean>
  34. <!-- JDBC事务管理器 -->
  35. <bean id="transactionManager"
  36. class="org.springframework.jdbc.datasource.
  37. DataSourceTransactionManager" scope="singleton">
  38. <property name="dataSource">
  39. <ref bean="dataSource" />
  40. </property>
  41. </bean>
  42. <!-- 声明事务模板 -->
  43. <bean id="transactionTemplate"
  44. class="org.springframework.transaction.support.
  45. TransactionTemplate">
  46. <property name="transactionManager">
  47. <ref bean="transactionManager" />
  48. </property>
  49. </bean>
  50. </beans>
  1. package com.jackfrued.dao.impl;
  2. import org.springframework.beans.factory.annotation.Autowired;
  3. import org.springframework.jdbc.core.JdbcTemplate;
  4. import com.jackfrued.dao.EmpDao;
  5. import com.jackfrued.entity.Emp;
  6. @Repository
  7. public class EmpDaoImpl implements EmpDao {
  8. @Autowired
  9. private JdbcTemplate jdbcTemplate;
  10. @Override
  11. public boolean save(Emp emp) {
  12. String sql = "insert into emp values (?,?,?)";
  13. return jdbcTemplate.update(sql, emp.getId(), emp.getName(), emp.getBirthday()) == 1;
  14. }
  15. }
  1. package com.jackfrued.biz.impl;
  2. import org.springframework.beans.factory.annotation.Autowired;
  3. import org.springframework.stereotype.Service;
  4. import org.springframework.transaction.TransactionStatus;
  5. import org.springframework.transaction.support.TransactionCallbackWithoutResult;
  6. import org.springframework.transaction.support.TransactionTemplate;
  7. import com.jackfrued.biz.EmpService;
  8. import com.jackfrued.dao.EmpDao;
  9. import com.jackfrued.entity.Emp;
  10. @Service
  11. public class EmpServiceImpl implements EmpService {
  12. @Autowired
  13. private TransactionTemplate txTemplate;
  14. @Autowired
  15. private EmpDao empDao;
  16. @Override
  17. public void addEmp(final Emp emp) {
  18. txTemplate.execute(new TransactionCallbackWithoutResult() {
  19. @Override
  20. protected void doInTransactionWithoutResult(TransactionStatus txStatus) {
  21. empDao.save(emp);
  22. }
  23. });
  24. }
  25. }

声明式事务如下图所示,以Spring整合Hibernate 3为例,包括完整的DAO和业务逻辑代码。

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <beans xmlns="http://www.springframework.org/schema/beans"
  3. xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4. xmlns:p="http://www.springframework.org/schema/p"
  5. xmlns:context="http://www.springframework.org/schema/context"
  6. xmlns:aop="http://www.springframework.org/schema/aop"
  7. xmlns:tx="http://www.springframework.org/schema/tx"
  8. xsi:schemaLocation="http://www.springframework.org/schema/beans
  9. http://www.springframework.org/schema/beans/spring-beans-3.2.xsd
  10. http://www.springframework.org/schema/context
  11. http://www.springframework.org/schema/context/spring-context-3.2.xsd
  12. http://www.springframework.org/schema/aop
  13. http://www.springframework.org/schema/aop/spring-aop-3.2.xsd
  14. http://www.springframework.org/schema/tx
  15. http://www.springframework.org/schema/tx/spring-tx-3.2.xsd">
  16. <!-- 配置由Spring IoC容器托管的对象对应的被注解的类所在的包 -->
  17. <context:component-scan base-package="com.jackfrued" />
  18. <!-- 配置通过自动生成代理实现AOP功能 -->
  19. <aop:aspectj-autoproxy />
  20. <!-- 配置数据库连接池 (DBCP) -->
  21. <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource"
  22. destroy-method="close">
  23. <!-- 配置驱动程序类 -->
  24. <property name="driverClassName" value="com.mysql.jdbc.Driver" />
  25. <!-- 配置连接数据库的URL -->
  26. <property name="url" value="jdbc:mysql://localhost:3306/myweb" />
  27. <!-- 配置访问数据库的用户名 -->
  28. <property name="username" value="root" />
  29. <!-- 配置访问数据库的口令 -->
  30. <property name="password" value="123456" />
  31. <!-- 配置最大连接数 -->
  32. <property name="maxActive" value="150" />
  33. <!-- 配置最小空闲连接数 -->
  34. <property name="minIdle" value="5" />
  35. <!-- 配置最大空闲连接数 -->
  36. <property name="maxIdle" value="20" />
  37. <!-- 配置初始连接数 -->
  38. <property name="initialSize" value="10" />
  39. <!-- 配置连接被泄露时是否生成日志 -->
  40. <property name="logAbandoned" value="true" />
  41. <!-- 配置是否删除超时连接 -->
  42. <property name="removeAbandoned" value="true" />
  43. <!-- 配置删除超时连接的超时门限值(以秒为单位) -->
  44. <property name="removeAbandonedTimeout" value="120" />
  45. <!-- 配置超时等待时间(以毫秒为单位) -->
  46. <property name="maxWait" value="5000" />
  47. <!-- 配置空闲连接回收器线程运行的时间间隔(以毫秒为单位) -->
  48. <property name="timeBetweenEvictionRunsMillis" value="300000" />
  49. <!-- 配置连接空闲多长时间后(以毫秒为单位)被断开连接 -->
  50. <property name="minEvictableIdleTimeMillis" value="60000" />
  51. </bean>
  52. <!-- 配置Spring提供的支持注解ORM映射的Hibernate会话工厂 -->
  53. <bean id="sessionFactory"
  54. class="org.springframework.orm.hibernate3.annotation.AnnotationSessionFactoryBean">
  55. <!-- 通过setter注入数据源属性 -->
  56. <property name="dataSource" ref="dataSource" />
  57. <!-- 配置实体类所在的包 -->
  58. <property name="packagesToScan" value="com.jackfrued.entity" />
  59. <!-- 配置Hibernate的相关属性 -->
  60. <property name="hibernateProperties">
  61. <!-- 在项目调试完成后要删除show_sql和format_sql属性否则对性能有显著影响 -->
  62. <value>
  63. hibernate.dialect=org.hibernate.dialect.MySQL5Dialect
  64. </value>
  65. </property>
  66. </bean>
  67. <!-- 配置Spring提供的Hibernate事务管理器 -->
  68. <bean id="transactionManager"
  69. class="org.springframework.orm.hibernate3.HibernateTransactionManager">
  70. <!-- 通过setter注入Hibernate会话工厂 -->
  71. <property name="sessionFactory" ref="sessionFactory" />
  72. </bean>
  73. <!-- 配置基于注解配置声明式事务 -->
  74. <tx:annotation-driven />
  75. </beans>
  1. package com.jackfrued.dao;
  2. import java.io.Serializable;
  3. import java.util.List;
  4. import com.jackfrued.comm.QueryBean;
  5. import com.jackfrued.comm.QueryResult;
  6. /**
  7. * 数据访问对象接口(以对象为单位封装CRUD操作)
  8. * @author 骆昊
  9. *
  10. * @param <E> 实体类型
  11. * @param <K> 实体标识字段的类型
  12. */
  13. public interface BaseDao <E, K extends Serializable> {
  14. /**
  15. * 新增
  16. * @param entity 业务实体对象
  17. * @return 增加成功返回实体对象的标识
  18. */
  19. public K save(E entity);
  20. /**
  21. * 删除
  22. * @param entity 业务实体对象
  23. */
  24. public void delete(E entity);
  25. /**
  26. * 根据ID删除
  27. * @param id 业务实体对象的标识
  28. * @return 删除成功返回true否则返回false
  29. */
  30. public boolean deleteById(K id);
  31. /**
  32. * 修改
  33. * @param entity 业务实体对象
  34. * @return 修改成功返回true否则返回false
  35. */
  36. public void update(E entity);
  37. /**
  38. * 根据ID查找业务实体对象
  39. * @param id 业务实体对象的标识
  40. * @return 业务实体对象对象或null
  41. */
  42. public E findById(K id);
  43. /**
  44. * 根据ID查找业务实体对象
  45. * @param id 业务实体对象的标识
  46. * @param lazy 是否使用延迟加载
  47. * @return 业务实体对象对象
  48. */
  49. public E findById(K id, boolean lazy);
  50. /**
  51. * 查找所有业务实体对象
  52. * @return 装所有业务实体对象的列表容器
  53. */
  54. public List<E> findAll();
  55. /**
  56. * 分页查找业务实体对象
  57. * @param page 页码
  58. * @param size 页面大小
  59. * @return 查询结果对象
  60. */
  61. public QueryResult<E> findByPage(int page, int size);
  62. /**
  63. * 分页查找业务实体对象
  64. * @param queryBean 查询条件对象
  65. * @param page 页码
  66. * @param size 页面大小
  67. * @return 查询结果对象
  68. */
  69. public QueryResult<E> findByPage(QueryBean queryBean, int page, int size);
  70. }
  1. package com.jackfrued.dao;
  2. import java.io.Serializable;
  3. import java.util.List;
  4. import com.jackfrued.comm.QueryBean;
  5. import com.jackfrued.comm.QueryResult;
  6. /**
  7. * BaseDao的缺省适配器
  8. * @author 骆昊
  9. *
  10. * @param <E> 实体类型
  11. * @param <K> 实体标识字段的类型
  12. */
  13. public abstract class BaseDaoAdapter<E, K extends Serializable> implements
  14. BaseDao<E, K> {
  15. @Override
  16. public K save(E entity) {
  17. return null;
  18. }
  19. @Override
  20. public void delete(E entity) {
  21. }
  22. @Override
  23. public boolean deleteById(K id) {
  24. E entity = findById(id);
  25. if(entity != null) {
  26. delete(entity);
  27. return true;
  28. }
  29. return false;
  30. }
  31. @Override
  32. public void update(E entity) {
  33. }
  34. @Override
  35. public E findById(K id) {
  36. return null;
  37. }
  38. @Override
  39. public E findById(K id, boolean lazy) {
  40. return null;
  41. }
  42. @Override
  43. public List<E> findAll() {
  44. return null;
  45. }
  46. @Override
  47. public QueryResult<E> findByPage(int page, int size) {
  48. return null;
  49. }
  50. @Override
  51. public QueryResult<E> findByPage(QueryBean queryBean, int page, int size) {
  52. return null;
  53. }
  54. }
  1. package com.jackfrued.dao;
  2. import java.io.Serializable;
  3. import java.lang.reflect.ParameterizedType;
  4. import java.util.ArrayList;
  5. import java.util.Collections;
  6. import java.util.List;
  7. import org.hibernate.Query;
  8. import org.hibernate.Session;
  9. import org.hibernate.SessionFactory;
  10. import org.springframework.beans.factory.annotation.Autowired;
  11. import com.jackfrued.comm.HQLQueryBean;
  12. import com.jackfrued.comm.QueryBean;
  13. import com.jackfrued.comm.QueryResult;
  14. /**
  15. * 基于Hibernate的BaseDao实现类
  16. * @author 骆昊
  17. *
  18. * @param <E> 实体类型
  19. * @param <K> 主键类型
  20. */
  21. @SuppressWarnings(value = {"unchecked"})
  22. public abstract class BaseDaoHibernateImpl<E, K extends Serializable> extends BaseDaoAdapter<E, K> {
  23. @Autowired
  24. protected SessionFactory sessionFactory;
  25. private Class<?> entityClass; // 业务实体的类对象
  26. private String entityName; // 业务实体的名字
  27. public BaseDaoHibernateImpl() {
  28. ParameterizedType pt = (ParameterizedType) this.getClass().getGenericSuperclass();
  29. entityClass = (Class<?>) pt.getActualTypeArguments()[0];
  30. entityName = entityClass.getSimpleName();
  31. }
  32. @Override
  33. public K save(E entity) {
  34. return (K) sessionFactory.getCurrentSession().save(entity);
  35. }
  36. @Override
  37. public void delete(E entity) {
  38. sessionFactory.getCurrentSession().delete(entity);
  39. }
  40. @Override
  41. public void update(E entity) {
  42. sessionFactory.getCurrentSession().update(entity);
  43. }
  44. @Override
  45. public E findById(K id) {
  46. return findById(id, false);
  47. }
  48. @Override
  49. public E findById(K id, boolean lazy) {
  50. Session session = sessionFactory.getCurrentSession();
  51. return (E) (lazy? session.load(entityClass, id) : session.get(entityClass, id));
  52. }
  53. @Override
  54. public List<E> findAll() {
  55. return sessionFactory.getCurrentSession().createCriteria(entityClass).list();
  56. }
  57. @Override
  58. public QueryResult<E> findByPage(int page, int size) {
  59. return new QueryResult<E>(
  60. findByHQLAndPage("from " + entityName , page, size),
  61. getCountByHQL("select count(*) from " + entityName)
  62. );
  63. }
  64. @Override
  65. public QueryResult<E> findByPage(QueryBean queryBean, int page, int size) {
  66. if(queryBean instanceof HQLQueryBean) {
  67. HQLQueryBean hqlQueryBean = (HQLQueryBean) queryBean;
  68. return new QueryResult<E>(
  69. findByHQLAndPage(hqlQueryBean.getQueryString(), page, size, hqlQueryBean.getParameters()),
  70. getCountByHQL(hqlQueryBean.getCountString(), hqlQueryBean.getParameters())
  71. );
  72. }
  73. return null;
  74. }
  75. /**
  76. * 根据HQL和可变参数列表进行查询
  77. * @param hql 基于HQL的查询语句
  78. * @param params 可变参数列表
  79. * @return 持有查询结果的列表容器或空列表容器
  80. */
  81. protected List<E> findByHQL(String hql, Object... params) {
  82. return this.findByHQL(hql, getParamList(params));
  83. }
  84. /**
  85. * 根据HQL和参数列表进行查询
  86. * @param hql 基于HQL的查询语句
  87. * @param params 查询参数列表
  88. * @return 持有查询结果的列表容器或空列表容器
  89. */
  90. protected List<E> findByHQL(String hql, List<Object> params) {
  91. List<E> list = createQuery(hql, params).list();
  92. return list != null && list.size() > 0 ? list : Collections.EMPTY_LIST;
  93. }
  94. /**
  95. * 根据HQL和参数列表进行分页查询
  96. * @param hql 基于HQL的查询语句
  97. * @page 页码
  98. * @size 页面大小
  99. * @param params 可变参数列表
  100. * @return 持有查询结果的列表容器或空列表容器
  101. */
  102. protected List<E> findByHQLAndPage(String hql, int page, int size, Object... params) {
  103. return this.findByHQLAndPage(hql, page, size, getParamList(params));
  104. }
  105. /**
  106. * 根据HQL和参数列表进行分页查询
  107. * @param hql 基于HQL的查询语句
  108. * @page 页码
  109. * @size 页面大小
  110. * @param params 查询参数列表
  111. * @return 持有查询结果的列表容器或空列表容器
  112. */
  113. protected List<E> findByHQLAndPage(String hql, int page, int size, List<Object> params) {
  114. List<E> list = createQuery(hql, params)
  115. .setFirstResult((page - 1) * size)
  116. .setMaxResults(size)
  117. .list();
  118. return list != null && list.size() > 0 ? list : Collections.EMPTY_LIST;
  119. }
  120. /**
  121. * 查询满足条件的记录数
  122. * @param hql 基于HQL的查询语句
  123. * @param params 可变参数列表
  124. * @return 满足查询条件的总记录数
  125. */
  126. protected long getCountByHQL(String hql, Object... params) {
  127. return this.getCountByHQL(hql, getParamList(params));
  128. }
  129. /**
  130. * 查询满足条件的记录数
  131. * @param hql 基于HQL的查询语句
  132. * @param params 参数列表容器
  133. * @return 满足查询条件的总记录数
  134. */
  135. protected long getCountByHQL(String hql, List<Object> params) {
  136. return (Long) createQuery(hql, params).uniqueResult();
  137. }
  138. // 创建Hibernate查询对象(Query)
  139. private Query createQuery(String hql, List<Object> params) {
  140. Query query = sessionFactory.getCurrentSession().createQuery(hql);
  141. for(int i = 0; i < params.size(); i++) {
  142. query.setParameter(i, params.get(i));
  143. }
  144. return query;
  145. }
  146. // 将可变参数列表组装成列表容器
  147. private List<Object> getParamList(Object... params) {
  148. List<Object> paramList = new ArrayList<>();
  149. if(params != null) {
  150. for(int i = 0; i < params.length; i++) {
  151. paramList.add(params[i]);
  152. }
  153. }
  154. return paramList.size() == 0? Collections.EMPTY_LIST : paramList;
  155. }
  156. }
  1. package com.jackfrued.comm;
  2. import java.util.List;
  3. /**
  4. * 查询条件的接口
  5. * @author 骆昊
  6. *
  7. */
  8. public interface QueryBean {
  9. /**
  10. * 添加排序字段
  11. * @param fieldName 用于排序的字段
  12. * @param asc 升序还是降序
  13. * @return 查询条件对象自身(方便级联编程)
  14. */
  15. public QueryBean addOrder(String fieldName, boolean asc);
  16. /**
  17. * 添加排序字段
  18. * @param available 是否添加此排序字段
  19. * @param fieldName 用于排序的字段
  20. * @param asc 升序还是降序
  21. * @return 查询条件对象自身(方便级联编程)
  22. */
  23. public QueryBean addOrder(boolean available, String fieldName, boolean asc);
  24. /**
  25. * 添加查询条件
  26. * @param condition 条件
  27. * @param params 替换掉条件中参数占位符的参数
  28. * @return 查询条件对象自身(方便级联编程)
  29. */
  30. public QueryBean addCondition(String condition, Object... params);
  31. /**
  32. * 添加查询条件
  33. * @param available 是否需要添加此条件
  34. * @param condition 条件
  35. * @param params 替换掉条件中参数占位符的参数
  36. * @return 查询条件对象自身(方便级联编程)
  37. */
  38. public QueryBean addCondition(boolean available, String condition, Object... params);
  39. /**
  40. * 获得查询语句
  41. * @return 查询语句
  42. */
  43. public String getQueryString();
  44. /**
  45. * 获取查询记录数的查询语句
  46. * @return 查询记录数的查询语句
  47. */
  48. public String getCountString();
  49. /**
  50. * 获得查询参数
  51. * @return 查询参数的列表容器
  52. */
  53. public List<Object> getParameters();
  54. }
  1. package com.jackfrued.comm;
  2. import java.util.List;
  3. /**
  4. * 查询结果
  5. * @author 骆昊
  6. *
  7. * @param <T> 泛型参数
  8. */
  9. public class QueryResult<T> {
  10. private List<T> result; // 持有查询结果的列表容器
  11. private long totalRecords; // 查询到的总记录数
  12. /**
  13. * 构造器
  14. */
  15. public QueryResult() {
  16. }
  17. /**
  18. * 构造器
  19. * @param result 持有查询结果的列表容器
  20. * @param totalRecords 查询到的总记录数
  21. */
  22. public QueryResult(List<T> result, long totalRecords) {
  23. this.result = result;
  24. this.totalRecords = totalRecords;
  25. }
  26. public List<T> getResult() {
  27. return result;
  28. }
  29. public void setResult(List<T> result) {
  30. this.result = result;
  31. }
  32. public long getTotalRecords() {
  33. return totalRecords;
  34. }
  35. public void setTotalRecords(long totalRecords) {
  36. this.totalRecords = totalRecords;
  37. }
  38. }
  1. package com.jackfrued.dao;
  2. import com.jackfrued.comm.QueryResult;
  3. import com.jackfrued.entity.Dept;
  4. /**
  5. * 部门数据访问对象接口
  6. * @author 骆昊
  7. *
  8. */
  9. public interface DeptDao extends BaseDao<Dept, Integer> {
  10. /**
  11. * 分页查询顶级部门
  12. * @param page 页码
  13. * @param size 页码大小
  14. * @return 查询结果对象
  15. */
  16. public QueryResult<Dept> findTopDeptByPage(int page, int size);
  17. }
  1. package com.jackfrued.dao.impl;
  2. import java.util.List;
  3. import org.springframework.stereotype.Repository;
  4. import com.jackfrued.comm.QueryResult;
  5. import com.jackfrued.dao.BaseDaoHibernateImpl;
  6. import com.jackfrued.dao.DeptDao;
  7. import com.jackfrued.entity.Dept;
  8. @Repository
  9. public class DeptDaoImpl extends BaseDaoHibernateImpl<Dept, Integer> implements DeptDao {
  10. private static final String HQL_FIND_TOP_DEPT = " from Dept as d where d.superiorDept is null ";
  11. @Override
  12. public QueryResult<Dept> findTopDeptByPage(int page, int size) {
  13. List<Dept> list = findByHQLAndPage(HQL_FIND_TOP_DEPT, page, size);
  14. long totalRecords = getCountByHQL(" select count(*) " + HQL_FIND_TOP_DEPT);
  15. return new QueryResult<>(list, totalRecords);
  16. }
  17. }
  1. package com.jackfrued.comm;
  2. import java.util.List;
  3. /**
  4. * 分页器
  5. * @author 骆昊
  6. *
  7. * @param <T> 分页数据对象的类型
  8. */
  9. public class PageBean<T> {
  10. private static final int DEFAUL_INIT_PAGE = 1;
  11. private static final int DEFAULT_PAGE_SIZE = 10;
  12. private static final int DEFAULT_PAGE_COUNT = 5;
  13. private List<T> data; // 分页数据
  14. private PageRange pageRange; // 页码范围
  15. private int totalPage; // 总页数
  16. private int size; // 页面大小
  17. private int currentPage; // 当前页码
  18. private int pageCount; // 页码数量
  19. /**
  20. * 构造器
  21. * @param currentPage 当前页码
  22. * @param size 页码大小
  23. * @param pageCount 页码数量
  24. */
  25. public PageBean(int currentPage, int size, int pageCount) {
  26. this.currentPage = currentPage > 0 ? currentPage : 1;
  27. this.size = size > 0 ? size : DEFAULT_PAGE_SIZE;
  28. this.pageCount = pageCount > 0 ? size : DEFAULT_PAGE_COUNT;
  29. }
  30. /**
  31. * 构造器
  32. * @param currentPage 当前页码
  33. * @param size 页码大小
  34. */
  35. public PageBean(int currentPage, int size) {
  36. this(currentPage, size, DEFAULT_PAGE_COUNT);
  37. }
  38. /**
  39. * 构造器
  40. * @param currentPage 当前页码
  41. */
  42. public PageBean(int currentPage) {
  43. this(currentPage, DEFAULT_PAGE_SIZE, DEFAULT_PAGE_COUNT);
  44. }
  45. /**
  46. * 构造器
  47. */
  48. public PageBean() {
  49. this(DEFAUL_INIT_PAGE, DEFAULT_PAGE_SIZE, DEFAULT_PAGE_COUNT);
  50. }
  51. public List<T> getData() {
  52. return data;
  53. }
  54. public int getStartPage() {
  55. return pageRange != null ? pageRange.getStartPage() : 1;
  56. }
  57. public int getEndPage() {
  58. return pageRange != null ? pageRange.getEndPage() : 1;
  59. }
  60. public long getTotalPage() {
  61. return totalPage;
  62. }
  63. public int getSize() {
  64. return size;
  65. }
  66. public int getCurrentPage() {
  67. return currentPage;
  68. }
  69. /**
  70. * 将查询结果转换为分页数据
  71. * @param queryResult 查询结果对象
  72. */
  73. public void transferQueryResult(QueryResult<T> queryResult) {
  74. long totalRecords = queryResult.getTotalRecords();
  75. data = queryResult.getResult();
  76. totalPage = (int) ((totalRecords + size - 1) / size);
  77. totalPage = totalPage >= 0 ? totalPage : Integer.MAX_VALUE;
  78. this.pageRange = new PageRange(pageCount, currentPage, totalPage);
  79. }
  80. }
  1. package com.jackfrued.comm;
  2. /**
  3. * 页码范围
  4. * @author 骆昊
  5. *
  6. */
  7. public class PageRange {
  8. private int startPage; // 起始页码
  9. private int endPage; // 终止页码
  10. /**
  11. * 构造器
  12. * @param pageCount 总共显示几个页码
  13. * @param currentPage 当前页码
  14. * @param totalPage 总页数
  15. */
  16. public PageRange(int pageCount, int currentPage, int totalPage) {
  17. startPage = currentPage - (pageCount - 1) / 2;
  18. endPage = currentPage + pageCount / 2;
  19. if(startPage < 1) {
  20. startPage = 1;
  21. endPage = totalPage > pageCount ? pageCount : totalPage;
  22. }
  23. if (endPage > totalPage) {
  24. endPage = totalPage;
  25. startPage = (endPage - pageCount > 0) ? endPage - pageCount + 1 : 1;
  26. }
  27. }
  28. /**
  29. * 获得起始页页码
  30. * @return 起始页页码
  31. */
  32. public int getStartPage() {
  33. return startPage;
  34. }
  35. /**
  36. * 获得终止页页码
  37. * @return 终止页页码
  38. */
  39. public int getEndPage() {
  40. return endPage;
  41. }
  42. }
  1. package com.jackfrued.biz;
  2. import com.jackfrued.comm.PageBean;
  3. import com.jackfrued.entity.Dept;
  4. /**
  5. * 部门业务逻辑接口
  6. * @author 骆昊
  7. *
  8. */
  9. public interface DeptService {
  10. /**
  11. * 创建新的部门
  12. * @param department 部门对象
  13. * @return 创建成功返回true否则返回false
  14. */
  15. public boolean createNewDepartment(Dept department);
  16. /**
  17. * 删除指定部门
  18. * @param id 要删除的部门的编号
  19. * @return 删除成功返回true否则返回false
  20. */
  21. public boolean deleteDepartment(Integer id);
  22. /**
  23. * 分页获取顶级部门
  24. * @param page 页码
  25. * @param size 页码大小
  26. * @return 部门对象的分页器对象
  27. */
  28. public PageBean<Dept> getTopDeptByPage(int page, int size);
  29. }
  1. package com.jackfrued.biz.impl;
  2. import org.springframework.beans.factory.annotation.Autowired;
  3. import org.springframework.stereotype.Service;
  4. import org.springframework.transaction.annotation.Transactional;
  5. import com.jackfrued.biz.DeptService;
  6. import com.jackfrued.comm.PageBean;
  7. import com.jackfrued.comm.QueryResult;
  8. import com.jackfrued.dao.DeptDao;
  9. import com.jackfrued.entity.Dept;
  10. @Service
  11. @Transactional // 声明式事务的注解
  12. public class DeptServiceImpl implements DeptService {
  13. @Autowired
  14. private DeptDao deptDao;
  15. @Override
  16. public boolean createNewDepartment(Dept department) {
  17. return deptDao.save(department) != null;
  18. }
  19. @Override
  20. public boolean deleteDepartment(Integer id) {
  21. return deptDao.deleteById(id);
  22. }
  23. @Override
  24. public PageBean<Dept> getTopDeptByPage(int page, int size) {
  25. QueryResult<Dept> queryResult = deptDao.findTopDeptByPage(page, size);
  26. PageBean<Dept> pageBean = new PageBean<>(page, size);
  27. pageBean.transferQueryResult(queryResult);
  28. return pageBean;
  29. }
  30. }

154、如何在Web项目中配置Spring的IoC容器? 
答:如果需要在Web项目中使用Spring的IoC容器,可以在Web项目配置文件web.xml中做出如下配置:

  1. <context-param>
  2. <param-name>contextConfigLocation</param-name>
  3. <param-value>classpath:applicationContext.xml</param-value>
  4. </context-param>
  5. <listener>
  6. <listener-class>
  7. org.springframework.web.context.ContextLoaderListener
  8. </listener-class>
  9. </listener>

155、如何在Web项目中配置Spring MVC? 
答:要使用Spring MVC需要在Web项目配置文件中配置其前端控制器DispatcherServlet,如下所示:

  1. <web-app>
  2. <servlet>
  3. <servlet-name>example</servlet-name>
  4. <servlet-class>
  5. org.springframework.web.servlet.DispatcherServlet
  6. </servlet-class>
  7. <load-on-startup>1</load-on-startup>
  8. </servlet>
  9. <servlet-mapping>
  10. <servlet-name>example</servlet-name>
  11. <url-pattern>*.html</url-pattern>
  12. </servlet-mapping>
  13. </web-app>

说明:上面的配置中使用了*.html的后缀映射,这样做一方面不能够通过URL推断采用了何种服务器端的技术,另一方面可以欺骗搜索引擎,因为搜索引擎不会搜索动态页面,这种做法称为伪静态化。

156、Spring MVC的工作原理是怎样的? 
答:Spring MVC的工作原理如下图所示: 
这里写图片描述 
① 客户端的所有请求都交给前端控制器DispatcherServlet来处理,它会负责调用系统的其他模块来真正处理用户的请求。 
② DispatcherServlet收到请求后,将根据请求的信息(包括URL、HTTP协议方法、请求头、请求参数、Cookie等)以及HandlerMapping的配置找到处理该请求的Handler(任何一个对象都可以作为请求的Handler)。 
③在这个地方Spring会通过HandlerAdapter对该处理器进行封装。 
④ HandlerAdapter是一个适配器,它用统一的接口对各种Handler中的方法进行调用。 
⑤ Handler完成对用户请求的处理后,会返回一个ModelAndView对象给DispatcherServlet,ModelAndView顾名思义,包含了数据模型以及相应的视图的信息。 
⑥ ModelAndView的视图是逻辑视图,DispatcherServlet还要借助ViewResolver完成从逻辑视图到真实视图对象的解析工作。 
⑦ 当得到真正的视图对象后,DispatcherServlet会利用视图对象对模型数据进行渲染。 
⑧ 客户端得到响应,可能是一个普通的HTML页面,也可以是XML或JSON字符串,还可以是一张图片或者一个PDF文件。

157、如何在Spring IoC容器中配置数据源? 
答: 
DBCP配置:

  1. <bean id="dataSource"
  2. class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">
  3. <property name="driverClassName" value="${jdbc.driverClassName}"/>
  4. <property name="url" value="${jdbc.url}"/>
  5. <property name="username" value="${jdbc.username}"/>
  6. <property name="password" value="${jdbc.password}"/>
  7. </bean>
  8. <context:property-placeholder location="jdbc.properties"/>

C3P0配置:

  1. <bean id="dataSource"
  2. class="com.mchange.v2.c3p0.ComboPooledDataSource" destroy-method="close">
  3. <property name="driverClass" value="${jdbc.driverClassName}"/>
  4. <property name="jdbcUrl" value="${jdbc.url}"/>
  5. <property name="user" value="${jdbc.username}"/>
  6. <property name="password" value="${jdbc.password}"/>
  7. </bean>
  8. <context:property-placeholder location="jdbc.properties"/>

提示: DBCP的详细配置在第153题中已经完整的展示过了。

158、如何配置配置事务增强? 
答:

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <beans xmlns="http://www.springframework.org/schema/beans"
  3. xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4. xmlns:aop="http://www.springframework.org/schema/aop"
  5. xmlns:tx="http://www.springframework.org/schema/tx"
  6. xsi:schemaLocation="
  7. http://www.springframework.org/schema/beans
  8. http://www.springframework.org/schema/beans/spring-beans.xsd
  9. http://www.springframework.org/schema/tx
  10. http://www.springframework.org/schema/tx/spring-tx.xsd
  11. http://www.springframework.org/schema/aop
  12. http://www.springframework.org/schema/aop/spring-aop.xsd">
  13. <!-- this is the service object that we want to make transactional -->
  14. <bean id="fooService" class="x.y.service.DefaultFooService"/>
  15. <!-- the transactional advice -->
  16. <tx:advice id="txAdvice" transaction-manager="txManager">
  17. <!-- the transactional semantics... -->
  18. <tx:attributes>
  19. <!-- all methods starting with 'get' are read-only -->
  20. <tx:method name="get*" read-only="true"/>
  21. <!-- other methods use the default transaction settings (see below) -->
  22. <tx:method name="*"/>
  23. </tx:attributes>
  24. </tx:advice>
  25. <!-- ensure that the above transactional advice runs for any execution
  26. of an operation defined by the FooService interface -->
  27. <aop:config>
  28. <aop:pointcut id="fooServiceOperation"
  29. expression="execution(* x.y.service.FooService.*(..))"/>
  30. <aop:advisor advice-ref="txAdvice" pointcut-ref="fooServiceOperation"/>
  31. </aop:config>
  32. <!-- don't forget the DataSource -->
  33. <bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource"
  34. destroy-method="close">
  35. <property name="driverClassName" value="oracle.jdbc.driver.OracleDriver"/>
  36. <property name="url" value="jdbc:oracle:thin:@localhost:1521:orcl"/>
  37. <property name="username" value="scott"/>
  38. <property name="password" value="tiger"/>
  39. </bean>
  40. <!-- similarly, don't forget the PlatformTransactionManager -->
  41. <bean id="txManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
  42. <property name="dataSource" ref="dataSource"/>
  43. </bean>
  44. <!-- other <bean/> definitions here -->
  45. </beans>

159、选择使用Spring框架的原因(Spring框架为企业级开发带来的好处有哪些)? 
答:可以从以下几个方面作答: 
- 非侵入式:支持基于POJO的编程模式,不强制性的要求实现Spring框架中的接口或继承Spring框架中的类。 
- IoC容器:IoC容器帮助应用程序管理对象以及对象之间的依赖关系,对象之间的依赖关系如果发生了改变只需要修改配置文件而不是修改代码,因为代码的修改可能意味着项目的重新构建和完整的回归测试。有了IoC容器,程序员再也不需要自己编写工厂、单例,这一点特别符合Spring的精神"不要重复的发明轮子"。 
- AOP(面向切面编程):将所有的横切关注功能封装到切面(aspect)中,通过配置的方式将横切关注功能动态添加到目标代码上,进一步实现了业务逻辑和系统服务之间的分离。另一方面,有了AOP程序员可以省去很多自己写代理类的工作。 
- MVC:Spring的MVC框架是非常优秀的,从各个方面都可以甩Struts 2几条街,为Web表示层提供了更好的解决方案。 
- 事务管理:Spring以宽广的胸怀接纳多种持久层技术,并且为其提供了声明式的事务管理,在不需要任何一行代码的情况下就能够完成事务管理。 
- 其他:选择Spring框架的原因还远不止于此,Spring为Java企业级开发提供了一站式选择,你可以在需要的时候使用它的部分和全部,更重要的是,你甚至可以在感觉不到Spring存在的情况下,在你的项目中使用Spring提供的各种优秀的功能。

160、Spring IoC容器配置Bean的方式? 
答: 
- 基于XML文件进行配置。 
- 基于注解进行配置。 
- 基于Java程序进行配置(Spring 3+)

  1. package com.jackfrued.bean;
  2. import org.springframework.beans.factory.annotation.Autowired;
  3. import org.springframework.stereotype.Component;
  4. @Component
  5. public class Person {
  6. private String name;
  7. private int age;
  8. @Autowired
  9. private Car car;
  10. public Person(String name, int age) {
  11. this.name = name;
  12. this.age = age;
  13. }
  14. public void setCar(Car car) {
  15. this.car = car;
  16. }
  17. @Override
  18. public String toString() {
  19. return "Person [name=" + name + ", age=" + age + ", car=" + car + "]";
  20. }
  21. }
  1. package com.jackfrued.bean;
  2. import org.springframework.stereotype.Component;
  3. @Component
  4. public class Car {
  5. private String brand;
  6. private int maxSpeed;
  7. public Car(String brand, int maxSpeed) {
  8. this.brand = brand;
  9. this.maxSpeed = maxSpeed;
  10. }
  11. @Override
  12. public String toString() {
  13. return "Car [brand=" + brand + ", maxSpeed=" + maxSpeed + "]";
  14. }
  15. }
  1. package com.jackfrued.config;
  2. import org.springframework.context.annotation.Bean;
  3. import org.springframework.context.annotation.Configuration;
  4. import com.jackfrued.bean.Car;
  5. import com.jackfrued.bean.Person;
  6. @Configuration
  7. public class AppConfig {
  8. @Bean
  9. public Car car() {
  10. return new Car("Benz", 320);
  11. }
  12. @Bean
  13. public Person person() {
  14. return new Person("骆昊", 34);
  15. }
  16. }
  1. package com.jackfrued.test;
  2. import org.springframework.context.ConfigurableApplicationContext;
  3. import org.springframework.context.annotation.AnnotationConfigApplicationContext;
  4. import com.jackfrued.bean.Person;
  5. import com.jackfrued.config.AppConfig;
  6. class Test {
  7. public static void main(String[] args) {
  8. // TWR (Java 7+)
  9. try(ConfigurableApplicationContext factory = new AnnotationConfigApplicationContext(AppConfig.class)) {
  10. Person person = factory.getBean(Person.class);
  11. System.out.println(person);
  12. }
  13. }
  14. }

161、阐述Spring框架中Bean的生命周期? 
答: 
① Spring IoC容器找到关于Bean的定义并实例化该Bean。 
② Spring IoC容器对Bean进行依赖注入。 
③ 如果Bean实现了BeanNameAware接口,则将该Bean的id传给setBeanName方法。 
④ 如果Bean实现了BeanFactoryAware接口,则将BeanFactory对象传给setBeanFactory方法。 
⑤ 如果Bean实现了BeanPostProcessor接口,则调用其postProcessBeforeInitialization方法。 
⑥ 如果Bean实现了InitializingBean接口,则调用其afterPropertySet方法。 
⑦ 如果有和Bean关联的BeanPostProcessors对象,则这些对象的postProcessAfterInitialization方法被调用。 
⑧ 当销毁Bean实例时,如果Bean实现了DisposableBean接口,则调用其destroy方法。

162、依赖注入时如何注入集合属性? 
答:可以在定义Bean属性时,通过<list> / <set> / <map> / <props>分别为其注入列表、集合、映射和键值都是字符串的映射属性。

163、Spring中的自动装配有哪些限制? 
答: 
- 如果使用了构造器注入或者setter注入,那么将覆盖自动装配的依赖关系。 
- 基本数据类型的值、字符串字面量、类字面量无法使用自动装配来注入。 
- 优先考虑使用显式的装配来进行更精确的依赖注入而不是使用自动装配。

164、在Web项目中如何获得Spring的IoC容器? 
答:

  1. WebApplicationContext ctx =
  2. WebApplicationContextUtils.getWebApplicationContext(servletContext);

165. 大型网站在架构上应当考虑哪些问题? 
答: 
- 分层:分层是处理任何复杂系统最常见的手段之一,将系统横向切分成若干个层面,每个层面只承担单一的职责,然后通过下层为上层提供的基础设施和服务以及上层对下层的调用来形成一个完整的复杂的系统。计算机网络的开放系统互联参考模型(OSI/RM)和Internet的TCP/IP模型都是分层结构,大型网站的软件系统也可以使用分层的理念将其分为持久层(提供数据存储和访问服务)、业务层(处理业务逻辑,系统中最核心的部分)和表示层(系统交互、视图展示)。需要指出的是:(1)分层是逻辑上的划分,在物理上可以位于同一设备上也可以在不同的设备上部署不同的功能模块,这样可以使用更多的计算资源来应对用户的并发访问;(2)层与层之间应当有清晰的边界,这样分层才有意义,才更利于软件的开发和维护。 
- 分割:分割是对软件的纵向切分。我们可以将大型网站的不同功能和服务分割开,形成高内聚低耦合的功能模块(单元)。在设计初期可以做一个粗粒度的分割,将网站分割为若干个功能模块,后期还可以进一步对每个模块进行细粒度的分割,这样一方面有助于软件的开发和维护,另一方面有助于分布式的部署,提供网站的并发处理能力和功能的扩展。 
- 分布式:除了上面提到的内容,网站的静态资源(JavaScript、CSS、图片等)也可以采用独立分布式部署并采用独立的域名,这样可以减轻应用服务器的负载压力,也使得浏览器对资源的加载更快。数据的存取也应该是分布式的,传统的商业级关系型数据库产品基本上都支持分布式部署,而新生的NoSQL产品几乎都是分布式的。当然,网站后台的业务处理也要使用分布式技术,例如查询索引的构建、数据分析等,这些业务计算规模庞大,可以使用Hadoop以及MapReduce分布式计算框架来处理。 
- 集群:集群使得有更多的服务器提供相同的服务,可以更好的提供对并发的支持。 
- 缓存:所谓缓存就是用空间换取时间的技术,将数据尽可能放在距离计算最近的位置。使用缓存是网站优化的第一定律。我们通常说的CDN、反向代理、热点数据都是对缓存技术的使用。 
- 异步:异步是实现软件实体之间解耦合的又一重要手段。异步架构是典型的生产者消费者模式,二者之间没有直接的调用关系,只要保持数据结构不变,彼此功能实现可以随意变化而不互相影响,这对网站的扩展非常有利。使用异步处理还可以提高系统可用性,加快网站的响应速度(用Ajax加载数据就是一种异步技术),同时还可以起到削峰作用(应对瞬时高并发)。";能推迟处理的都要推迟处理"是网站优化的第二定律,而异步是践行网站优化第二定律的重要手段。 
- 冗余:各种服务器都要提供相应的冗余服务器以便在某台或某些服务器宕机时还能保证网站可以正常工作,同时也提供了灾难恢复的可能性。冗余是网站高可用性的重要保证。

166、你用过的网站前端优化的技术有哪些? 
答: 
① 浏览器访问优化: 
- 减少HTTP请求数量:合并CSS、合并JavaScript、合并图片(CSS Sprite) 
- 使用浏览器缓存:通过设置HTTP响应头中的Cache-Control和Expires属性,将CSS、JavaScript、图片等在浏览器中缓存,当这些静态资源需要更新时,可以更新HTML文件中的引用来让浏览器重新请求新的资源 
- 启用压缩 
- CSS前置,JavaScript后置 
- 减少Cookie传输 
② CDN加速:CDN(Content Distribute Network)的本质仍然是缓存,将数据缓存在离用户最近的地方,CDN通常部署在网络运营商的机房,不仅可以提升响应速度,还可以减少应用服务器的压力。当然,CDN缓存的通常都是静态资源。 
③ 反向代理:反向代理相当于应用服务器的一个门面,可以保护网站的安全性,也可以实现负载均衡的功能,当然最重要的是它缓存了用户访问的热点资源,可以直接从反向代理将某些内容返回给用户浏览器。

167、你使用过的应用服务器优化技术有哪些? 
答: 
① 分布式缓存:缓存的本质就是内存中的哈希表,如果设计一个优质的哈希函数,那么理论上哈希表读写的渐近时间复杂度为O(1)。缓存主要用来存放那些读写比很高、变化很少的数据,这样应用程序读取数据时先到缓存中读取,如果没有或者数据已经失效再去访问数据库或文件系统,并根据拟定的规则将数据写入缓存。对网站数据的访问也符合二八定律(Pareto分布,幂律分布),即80%的访问都集中在20%的数据上,如果能够将这20%的数据缓存起来,那么系统的性能将得到显著的改善。当然,使用缓存需要解决以下几个问题: 
- 频繁修改的数据; 
- 数据不一致与脏读; 
- 缓存雪崩(可以采用分布式缓存服务器集群加以解决,memcached是广泛采用的解决方案); 
- 缓存预热; 
- 缓存穿透(恶意持续请求不存在的数据)。 
② 异步操作:可以使用消息队列将调用异步化,通过异步处理将短时间高并发产生的事件消息存储在消息队列中,从而起到削峰作用。电商网站在进行促销活动时,可以将用户的订单请求存入消息队列,这样可以抵御大量的并发订单请求对系统和数据库的冲击。目前,绝大多数的电商网站即便不进行促销活动,订单系统都采用了消息队列来处理。 
③ 使用集群。 
④ 代码优化: 
- 多线程:基于Java的Web开发基本上都通过多线程的方式响应用户的并发请求,使用多线程技术在编程上要解决线程安全问题,主要可以考虑以下几个方面:A. 将对象设计为无状态对象(这和面向对象的编程观点是矛盾的,在面向对象的世界中被视为不良设计),这样就不会存在并发访问时对象状态不一致的问题。B. 在方法内部创建对象,这样对象由进入方法的线程创建,不会出现多个线程访问同一对象的问题。使用ThreadLocal将对象与线程绑定也是很好的做法,这一点在前面已经探讨过了。C. 对资源进行并发访问时应当使用合理的锁机制。 
- 非阻塞I/O: 使用单线程和非阻塞I/O是目前公认的比多线程的方式更能充分发挥服务器性能的应用模式,基于Node.js构建的服务器就采用了这样的方式。Java在JDK 1.4中就引入了NIO(Non-blocking I/O),在Servlet 3规范中又引入了异步Servlet的概念,这些都为在服务器端采用非阻塞I/O提供了必要的基础。 
- 资源复用:资源复用主要有两种方式,一是单例,二是对象池,我们使用的数据库连接池、线程池都是对象池化技术,这是典型的用空间换取时间的策略,另一方面也实现对资源的复用,从而避免了不必要的创建和释放资源所带来的开销。

168、什么是XSS攻击?什么是SQL注入攻击?什么是CSRF攻击? 
答: 
- XSS(Cross Site Script,跨站脚本攻击)是向网页中注入恶意脚本在用户浏览网页时在用户浏览器中执行恶意脚本的攻击方式。跨站脚本攻击分有两种形式:反射型攻击(诱使用户点击一个嵌入恶意脚本的链接以达到攻击的目标,目前有很多攻击者利用论坛、微博发布含有恶意脚本的URL就属于这种方式)和持久型攻击(将恶意脚本提交到被攻击网站的数据库中,用户浏览网页时,恶意脚本从数据库中被加载到页面执行,QQ邮箱的早期版本就曾经被利用作为持久型跨站脚本攻击的平台)。XSS虽然不是什么新鲜玩意,但是攻击的手法却不断翻新,防范XSS主要有两方面:消毒(对危险字符进行转义)和HttpOnly(防范XSS攻击者窃取Cookie数据)。 
- SQL注入攻击是注入攻击最常见的形式(此外还有OS注入攻击(Struts 2的高危漏洞就是通过OGNL实施OS注入攻击导致的)),当服务器使用请求参数构造SQL语句时,恶意的SQL被嵌入到SQL中交给数据库执行。SQL注入攻击需要攻击者对数据库结构有所了解才能进行,攻击者想要获得表结构有多种方式:(1)如果使用开源系统搭建网站,数据库结构也是公开的(目前有很多现成的系统可以直接搭建论坛,电商网站,虽然方便快捷但是风险是必须要认真评估的);(2)错误回显(如果将服务器的错误信息直接显示在页面上,攻击者可以通过非法参数引发页面错误从而通过错误信息了解数据库结构,Web应用应当设置友好的错误页,一方面符合最小惊讶原则,一方面屏蔽掉可能给系统带来危险的错误回显信息);(3)盲注。防范SQL注入攻击也可以采用消毒的方式,通过正则表达式对请求参数进行验证,此外,参数绑定也是很好的手段,这样恶意的SQL会被当做SQL的参数而不是命令被执行,JDBC中的PreparedStatement就是支持参数绑定的语句对象,从性能和安全性上都明显优于Statement。 
- CSRF攻击(Cross Site Request Forgery,跨站请求伪造)是攻击者通过跨站请求,以合法的用户身份进行非法操作(如转账或发帖等)。CSRF的原理是利用浏览器的Cookie或服务器的Session,盗取用户身份,其原理如下图所示。防范CSRF的主要手段是识别请求者的身份,主要有以下几种方式:(1)在表单中添加令牌(token);(2)验证码;(3)检查请求头中的Referer(前面提到防图片盗链接也是用的这种方式)。令牌和验证都具有一次消费性的特征,因此在原理上一致的,但是验证码是一种糟糕的用户体验,不是必要的情况下不要轻易使用验证码,目前很多网站的做法是如果在短时间内多次提交一个表单未获得成功后才要求提供验证码,这样会获得较好的用户体验。

这里写图片描述

补充:防火墙的架设是Web安全的重要保障,ModSecurity是开源的Web防火墙中的佼佼者。企业级防火墙的架设应当有两级防火墙,Web服务器和部分应用服务器可以架设在两级防火墙之间的DMZ,而数据和资源服务器应当架设在第二级防火墙之后。

169. 什么是领域模型(domain model)?贫血模型(anaemic domain model)和充血模型(rich domain model)有什么区别? 
答:领域模型是领域内的概念类或现实世界中对象的可视化表示,又称为概念模型或分析对象模型,它专注于分析问题领域本身,发掘重要的业务领域概念,并建立业务领域概念之间的关系。贫血模型是指使用的领域对象中只有setter和getter方法(POJO),所有的业务逻辑都不包含在领域对象中而是放在业务逻辑层。有人将我们这里说的贫血模型进一步划分成失血模型(领域对象完全没有业务逻辑)和贫血模型(领域对象有少量的业务逻辑),我们这里就不对此加以区分了。充血模型将大多数业务逻辑和持久化放在领域对象中,业务逻辑(业务门面)只是完成对业务逻辑的封装、事务和权限等的处理。下面两张图分别展示了贫血模型和充血模型的分层架构。

贫血模型 
这里写图片描述

充血模型 
这里写图片描述

贫血模型下组织领域逻辑通常使用事务脚本模式,让每个过程对应用户可能要做的一个动作,每个动作由一个过程来驱动。也就是说在设计业务逻辑接口的时候,每个方法对应着用户的一个操作,这种模式有以下几个有点: 
- 它是一个大多数开发者都能够理解的简单过程模型(适合国内的绝大多数开发者)。 
- 它能够与一个使用行数据入口或表数据入口的简单数据访问层很好的协作。 
- 事务边界的显而易见,一个事务开始于脚本的开始,终止于脚本的结束,很容易通过代理(或切面)实现声明式事务。 
然而,事务脚本模式的缺点也是很多的,随着领域逻辑复杂性的增加,系统的复杂性将迅速增加,程序结构将变得极度混乱。开源中国社区上有一篇很好的译文《贫血领域模型是如何导致糟糕的软件产生》对这个问题做了比较细致的阐述。

170. 谈一谈测试驱动开发(TDD)的好处以及你的理解。 
答:TDD是指在编写真正的功能实现代码之前先写测试代码,然后根据需要重构实现代码。在JUnit的作者Kent Beck的大作《测试驱动开发:实战与模式解析》(Test-Driven Development: by Example)一书中有这么一段内容:“消除恐惧和不确定性是编写测试驱动代码的重要原因”。因为编写代码时的恐惧会让你小心试探,让你回避沟通,让你羞于得到反馈,让你变得焦躁不安,而TDD是消除恐惧、让Java开发者更加自信更加乐于沟通的重要手段。TDD会带来的好处可能不会马上呈现,但是你在某个时候一定会发现,这些好处包括: 
- 更清晰的代码 — 只写需要的代码 
- 更好的设计 
- 更出色的灵活性 — 鼓励程序员面向接口编程 
- 更快速的反馈 — 不会到系统上线时才知道bug的存在

补充:敏捷软件开发的概念已经有很多年了,而且也部分的改变了软件开发这个行业,TDD也是敏捷开发所倡导的。

TDD可以在多个层级上应用,包括单元测试(测试一个类中的代码)、集成测试(测试类之间的交互)、系统测试(测试运行的系统)和系统集成测试(测试运行的系统包括使用的第三方组件)。TDD的实施步骤是:红(失败测试)- 绿(通过测试) - 重构。关于实施TDD的详细步骤请参考另一篇文章《测试驱动开发之初窥门径》。 
在使用TDD开发时,经常会遇到需要被测对象需要依赖其他子系统的情况,但是你希望将测试代码跟依赖项隔离,以保证测试代码仅仅针对当前被测对象或方法展开,这时候你需要的是测试替身。测试替身可以分为四类: 
- 虚设替身:只传递但是不会使用到的对象,一般用于填充方法的参数列表 
- 存根替身:总是返回相同的预设响应,其中可能包括一些虚设状态 
- 伪装替身:可以取代真实版本的可用版本(比真实版本还是会差很多) 
- 模拟替身:可以表示一系列期望值的对象,并且可以提供预设响应 
Java世界中实现模拟替身的第三方工具非常多,包括EasyMock、Mockito、jMock等。

阿里内部面试总结

标签:其他 发布于 2016-07-13 22:35:57

目录:

  1. StringBuffer和StringBuilder有什么区别?假设有一个方法,方法内部需要定义一个对象,可能是StringBuffer或StringBuilder,接下来会多次append操作,方法结束时,返回这个对象的toString()结果,并且这个线程会被多线程并发访问,请选择这个对象是被定义成StringBuffer或者StringBuilder?为什么?

  2. synchronized有什么用?如何使用?(伪代码,把所有使用方式都分别列出来)

  3. ReentranLock类有什么作用?它常用的方法有哪几个?分别有什么特点?

  4. 集群环境下多机器间进行同步操作有什么可选的解决方案?(最好用伪代码写出关键部分)

  5. 列出乐观锁的设计要点和使用方法?

  6. 何为幂等性控制?举一个例子说明你之前如何实现幂等性控制?(或在项目IDCM中如何实现幂等性控制?)

  7. spring实现aop用到的关键技术是什么?

  8. HashMap和ConcurrentHashMap有什么区别和特点?

  9. java.util.concurrent package下,你用过哪些类?分别有什么用途和特点?

  10. 如果一张表数据量较大,影响了查询性能,可以有哪些优化方案?建立索引有什么原则?

  11. 说一说数据库事务隔离级别的理解?(项目IDCM中是如何使用的?)

  12. Spring中注解@Component @Repository @Service @Controller的区别?(项目IDCM中context:component-scan注解扫描是如何配置的?)

 

 

 

1.StringBuffer和StringBuilder有什么区别?假设有一个方法,方法内部需要定义一个对象,可能是StringBuffer或StringBuilder,接下来会多次append操作,方法结束时,返回这个对象的toString()结果,并且这个线程会被多线程并发访问,请选择这个对象是被定义成StringBuffer或者StringBuilder?为什么?

  答:StringBuffer是线程安全的;StringBuilder是线程不安全的。

复制代码

1.先来看String StringBuffer StringBuilder定义。final修饰的类不能被继承,即不能拥有子类。 
    public final class StringBuffer 
    public final class StringBuilder 
    public final class String 

2.关于appdend方法的源码如下: 
    public synchronized StringBuffer append(String str) {
             toStringCache = null; 
             super.append(str); 
             return this;
    } 

    public StringBuilder append(String str) { 
        super.append(str); 
        return this; 
    } 
3.对于经常变动的字符串才会考虑使用StringBuilder和StringBuffer,使用StringBuilder效率比StringBuffer高,StringBuffer可以保证线程安全,而StringBuilder不能。

复制代码

2.synchronized有什么用?如何使用?(伪代码,把所有使用方式都分别列出来)

  答:synchronized是Java语言的关键字,同时也是一个可重入锁。当它用来修饰一个方法或者一个代码块的时候,能够保证在同一时刻最多只有一个线程执行该段代码。synchronized用于修饰方法和代码块。

复制代码

package basic;public final class TestSynchronized {    public static void main(String[] args) {        new Thread("线程A") {

            @Override            public void run() {                try {
                    print("线程A ...");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }.start();        new Thread("线程B") {

            @Override            public void run() {                try {
                    print("线程B ...");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }.start();
    }    public static synchronized void print(String str) throws InterruptedException {
        System.out.println("当前线程:" + Thread.currentThread().getName() + "执行开始");        for (int i = 0; i < 10; i++) {
            System.out.println(str);
            Thread.sleep(2000);
        }
        System.out.println("当前线程:" + Thread.currentThread().getName() + "执行完毕");
    }
} 
// 代码执行结果: 
//当前线程:线程A执行开始 
//线程A ... 
//线程A ... 
//线程A ... 
//线程A ... 
//线程A ... 
//线程A ... 
//线程A ... 
//线程A ... 
//线程A ... 
//线程A ... 
//当前线程:线程A执行完毕//当前线程:线程B执行开始 
//线程B ... 
//线程B ... 
//线程B ... 
//线程B ... 
//线程B ... 
//线程B ... 
//线程B ... 
//线程B ... 
//线程B ... 
//线程B ... 
//当前线程:线程B执行完毕

复制代码

  synchronized在修饰方法的同时,还可以修饰代码块,示例代码如下:

复制代码

package basic;public class SynchronizedExample {    public static void main(String[] args) {        new Thread("线程A") {

            @Override            public void run() {
                print("线程A");
            }
        }.start();        new Thread("线程B") {

            @Override            public void run() {
                print("线程B");
            }
        }.start();
    }    public static void print(String str) {
        System.out.println("线程: " + Thread.currentThread().getName() + "开始执行");        synchronized (SynchronizedExample.class) {            for (int i = 0; i < 10; i++) {
                System.out.println(Thread.currentThread().getName() + "打印了信息:" + i);                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                }
            }
        }
        System.out.println("线程: " + Thread.currentThread().getName() + "执行结束");
    }
}// 代码执行结果:// 线程: 线程A开始执行// 线程A打印了信息:0// 线程: 线程B开始执行// 线程A打印了信息:1// 线程A打印了信息:2// 线程A打印了信息:3// 线程A打印了信息:4// 线程A打印了信息:5// 线程A打印了信息:6// 线程A打印了信息:7// 线程A打印了信息:8// 线程A打印了信息:9// 线程: 线程A执行结束// 线程B打印了信息:0// 线程B打印了信息:1// 线程B打印了信息:2// 线程B打印了信息:3// 线程B打印了信息:4// 线程B打印了信息:5// 线程B打印了信息:6// 线程B打印了信息:7// 线程B打印了信息:8// 线程B打印了信息:9// 线程: 线程B执行结束

复制代码

  接下来详细说明synchronized在修饰方法的时候的细节。synchronized是对类的当前实例进行加锁,防止其他线程同时访问该类的该实例的所有synchronized块,注意这里是“类的当前实例”,类的两个不同实例就没有这种约束了。那么static synchronized恰好就是要控制类的所有实例的访问了,static synchronized是限制线程同时访问jvm中该类的所有实例同时访问对应的代码快。实际上,在类中某方法或某代码块中有synchronized,那么在生成一个该类实例后,该类也就有一个监视快,放置线程并发访问改实例synchronized保护快,而static synchronized则是所有该类的实例公用一个监视快了,也就是两个的区别了,也就是synchronized相当于this.synchronized,而static synchronized相当于Something.synchronized。

复制代码

package basic;public class SynchronizedExample {    public static void main(String[] args) {        final MySynchronized mySynchronized = new MySynchronized();        new Thread("线程A") {

            @Override            public void run() {
                mySynchronized.print("线程A");
            }
        }.start();        new Thread("线程B") {

            @Override            public void run() {
                mySynchronized.print("线程B");
            }
        }.start();
    }
}class MySynchronized {    public synchronized void print(String str) {
        System.out.println("线程: " + Thread.currentThread().getName() + "开始执行");        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName() + "打印了信息:" + i);            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
            }
        }
        System.out.println("线程: " + Thread.currentThread().getName() + "执行结束");
    }
} 
// 代码运行结果: 
//线程: 线程A开始执行 
//线程A打印了信息:0 
//线程A打印了信息:1 
//线程A打印了信息:2 
//线程A打印了信息:3 
//线程A打印了信息:4 
//线程A打印了信息:5 
//线程A打印了信息:6 
//线程A打印了信息:7//线程A打印了信息:8 
//线程A打印了信息:9 
//线程: 线程A执行结束 
//线程: 线程B开始执行 
//线程B打印了信息:0 
//线程B打印了信息:1 
//线程B打印了信息:2 
//线程B打印了信息:3 
//线程B打印了信息:4 
//线程B打印了信息:5//线程B打印了信息:6 
//线程B打印了信息:7 
//线程B打印了信息:8 
//线程B打印了信息:9 
//线程: 线程B执行结束 package basic;public class SynchronizedExample {    public static void main(String[] args) {        final MySynchronized mySynchronized_first = new MySynchronized();        final MySynchronized mySynchronized_second = new MySynchronized();        new Thread("线程A") {

            @Override            public void run() {
                mySynchronized_first.print("线程A");
            }
        }.start();        new Thread("线程B") {

            @Override            public void run() {
                mySynchronized_second.print("线程B");
            }
        }.start();
    }
}class MySynchronized {    public synchronized void print(String str) {
        System.out.println("线程: " + Thread.currentThread().getName() + "开始执行");        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName() + "打印了信息:" + i);            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
            }
        }
        System.out.println("线程: " + Thread.currentThread().getName() + "执行结束");
    }
}//代码运行结果: 
//线程: 线程A开始执行 
//线程A打印了信息:0 
//线程: 线程B开始执行 
//线程B打印了信息:0 
//线程A打印了信息:1 
//线程B打印了信息:1 
//线程A打印了信息:2 
//线程B打印了信息:2 
//线程A打印了信息:3//线程B打印了信息:3 
//线程A打印了信息:4 
//线程B打印了信息:4 
//线程A打印了信息:5 
//线程B打印了信息:5 
//线程A打印了信息:6 
//线程B打印了信息:6 
//线程A打印了信息:7 
//线程B打印了信息:7 
//线程A打印了信息:8//线程B打印了信息:8 
//线程A打印了信息:9 
//线程B打印了信息:9 
//线程: 线程A执行结束 
//线程: 线程B执行结束 package basic;public class SynchronizedExample {    public static void main(String[] args) {        final MySynchronized mySynchronized_first = new MySynchronized();        final MySynchronized mySynchronized_second = new MySynchronized();        new Thread("线程A") {

            @Override            public void run() {
                mySynchronized_first.print("线程A");
            }
        }.start();        new Thread("线程B") {

            @Override            public void run() {
                mySynchronized_second.print("线程B");
            }
        }.start();
    }
}class MySynchronized {    public static synchronized void print(String str) {
        System.out.println("线程: " + Thread.currentThread().getName() + "开始执行");        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName() + "打印了信息:" + i);            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
            }
        }
        System.out.println("线程: " + Thread.currentThread().getName() + "执行结束");
    }
}//代码运行结果: 
//线程: 线程A开始执行 
//线程A打印了信息:0//线程A打印了信息:1 
//线程A打印了信息:2 
//线程A打印了信息:3 
//线程A打印了信息:4 
//线程A打印了信息:5 
//线程A打印了信息:6 
//线程A打印了信息:7//线程A打印了信息:8 
//线程A打印了信息:9 
//线程: 线程A执行结束 
//线程: 线程B开始执行 
//线程B打印了信息:0 
//线程B打印了信息:1 
//线程B打印了信息:2 
//线程B打印了信息:3 
//线程B打印了信息:4 
//线程B打印了信息:5//线程B打印了信息:6 
//线程B打印了信息:7 
//线程B打印了信息:8 
//线程B打印了信息:9 
//线程: 线程B执行结束

复制代码

  上述代码完整的展示了static synchronized和synchronized的用法。synchronized针对同一个实例不能访问,针对不同的实例可以同时访问。static synchronized针对所有的实例均不能同时访问。synchronized本来就是修饰方法的,后来引申出synchronized修饰代码块,只是为了可以更精确的控制冲突限制的访问区域,使得表现更加高效率。synchronized方法只能锁定现阶段的对象,而synchronized区块可以锁定指定的对象,指定的对象直接跟在synchronized()括号之后。此外,synchronized关键字是不能继承的,也就是说,基类的方法synchronized f(){} 在继承类中并不自动是synchronized f(){},而是变成了f(){}。继承类需要你显式的指定它的某个方法为synchronized方法。还有synchronized不能被继承,继承时子类的覆盖方法必须显示定义成synchronized。

  除了方法前用synchronized关键字,synchronized关键字还可以用于方法中的某个区块中,表示只对这个区块的资源实行互斥访问。用法是: synchronized(object){/*区块*/},它的作用域是object对象。当一个线程执行时,将object对象锁住,另一个线程就不能执行对应的块。synchronized方法实际上等同于用一个synchronized块包住方法中的所有语句,然后在synchronized块的括号中传入this关键字。当然,如果是静态方法,需要锁定的则是class对象。可能一个方法中只有几行代码会涉及到线程同步问题,所以synchronized块比synchronized方法更加细粒度地控制了多个线程的访问,只有synchronized块中的内容不能同时被多个线程所访问,方法中的其他语句仍然可以同时被多个线程所访问(包括synchronized块之前的和之后的)。

复制代码

package basic;public class TestSynchronizedObject {    public static void main(String[] args) {        final MyObject myObject_first = new MyObject();        final MyObject myObject_seconde = new MyObject();        new Thread("线程A") {

            @Override            public void run() {
                myObject_first.print("线程A");
            }
        }.start();        new Thread("线程B") {

            @Override            public void run() { /* * 同一个实例,实现了互斥访问 */
                myObject_first.print("线程B"); /* * 不同的实例,并不能够实现互斥访问 */
                myObject_seconde.print("线程B");
            }
        }.start();
    }
}class MyObject {    /**
     * * synchronized(this)的用法相当于synchronized直接修饰方法<br/>
     * * 只针对一个实例的时候有效,针对多个实例的时候无效     */
    public void print(String str) {
        System.out.println("线程" + Thread.currentThread().getName() + "开始执行");        synchronized (this) {            for (int i = 0; i < 10; i++) {
                System.out.println(str + " ." + i + ". ");                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                }
            }
        }
        System.out.println("线程" + Thread.currentThread().getName() + "执行结束");
    }
}package basic;public class TestSynchronizedObject {    public static void main(String[] args) {        final MyObject myObject_first = new MyObject();        final MyObject myObject_seconde = new MyObject();        new Thread("线程A") {

            @Override            public void run() {
                myObject_first.print("线程A");
            }
        }.start();        new Thread("线程B") {

            @Override            public void run() {
                myObject_seconde.print("线程B");
            }
        }.start();
    }
}class MyObject {    /**
     * * synchronized(MyObject.class)的用法相当于static synchronized修饰方法<br/>
     * * 在针对多个实例的情况下,互斥有效,但是synchronized括号后面要指定正确的对象信息     */
    public void print(String str) {
        System.out.println("线程" + Thread.currentThread().getName() + "开始执行");        /*
         * 1、synchronized(MyObjcet.class)可以正确的实现互斥效果 ,因为调用的是MyObject的对象。         */
        synchronized (MyObject.class) {            for (int i = 0; i < 10; i++) {
                System.out.println(str + " ." + i + ". ");                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                }
            }
        }
        System.out.println("线程" + Thread.currentThread().getName() + "执行结束");
    }
}

复制代码

  总结:synchronized方法是一种粗粒度的并发控制,在某一时刻,只能有一个线程执行该synchronized方法。synchronized块则是一种细粒度的鬓发控制,只会将块中的代码同步,位于方法内,synchronized块之外的代码是可以被多个线程同时访问到的。关于synchronized修饰代码块的详细细节可以参考附录[1]和附录[2]。

3.ReentrantLock类有什么作用?它常用的方法有哪几个?分别有什么特点?(读法:Re-entrantLock)

  上面的的synchronized和ReentranLock是最经典的可重入锁,在面试中经常有问到两种锁的对比。先介绍ReentranLock的使用和代码示例,接着再分析ReentranLock和synchronized的具体区别。

4.集群环境下多机器间进行同步操作有什么可选的解决方案?(最好用伪代码写出关键部分)

  reids

5.列出乐观锁的设计要点和使用方法?

6.何为幂等性控制?举一个例子说明你之前如何实现幂等性控制?(或在项目IDCM中如何实现幂等性控制?)

7.spring实现aop用到的关键技术是什么?

8.HashMap和ConcurrentHashMap有什么区别和特点?

9.java.util.concurrent package下,你用过哪些类?分别有什么用途和特点?

10.如果一张表数据量较大,影响了查询性能,可以有哪些优化方案?建立索引有什么原则?

11.说一说数据库事务隔离级别的理解?(项目IDCM中是如何使用的?)

12.Spring中注解@Component @Repository @Service @Controller的区别?(项目IDCM中context:component-scan注解扫描是如何配置的?)

 

附录:

[1] https://segmentfault.com/q/1010000005945389?_ea=960340 

[2] https://segmentfault.com/q/1010000005944096?_ea=959633

分布式一致性算法--Paxos

标签:分布式事务,Mysql,Dubbo 发布于 2016-07-16 15:44:01

 Paxos算法是莱斯利·兰伯特(Leslie Lamport)1990年提出的一种基于消息传递的一致性算法。Paxos算法解决的问题是一个分布式系统如何就某个值(决议)达成一致。在工程实践意义上来说,就是可以通过Paxos实现多副本一致性,分布式锁,名字管理,序列号分配等。比如,在一个分布式数据库系统中,如果各节点的初始状态一致,每个节点执行相同的操作序列,那么他们最后能得到一个一致的状态。为保证每个节点执行相同的命令序列,需要在每一条指令上执行一个“一致性算法”以保证每个节点看到的指令一致。本文首先会讲原始的Paxos算法(Basic Paxos),主要描述二阶段提交过程,然后会着重讲Paxos算法的变种(Multi Paxos),它是对Basic Paxos的优化,而且更适合工程实践,最后我会通过Q&A的方式,给出我在学习Paxos算法中的疑问,以及我对这些疑问的理解。

概念与术语 
Proposer:提议发起者,处理客户端请求,将客户端的请求发送到集群中,以便决定这个值是否可以被批准。
Acceptor:提议批准者,负责处理接收到的提议,他们的回复就是一次投票,会存储一些状态来决定是否接收一个值。
replica:节点或者副本,分布式系统中的一个server,一般是一台单独的物理机或者虚拟机,同时承担paxos中的提议者和接收者角色。
ProposalId:每个提议都有一个编号,编号高的提议优先级高。
Paxos Instance:Paxos中用来在多个节点之间对同一个值达成一致的过程,比如同一个日志序列号:logIndex,不同的logIndex属于不同的Paxos Instance。
acceptedProposal:在一个Paxos Instance内,已经接收过的提议
acceptedValue:在一个Paxos Instance内,已经接收过的提议对应的值。
minProposal:在一个Paxos Instance内,当前接收的最小提议值,会不断更新

Basic-Paxos算法
     基于Paxos协议构建的系统,只需要系统中超过半数的节点在线且相互通信正常即可正常对外提供服务。它的核心实现Paxos Instance主要包括两个阶段:准备阶段(prepare phase)和提议阶段(accept phase)。如下图所示:


1.获取一个ProposalId,为了保证ProposalId递增,可以采用时间戳+serverId方式生成;
2.提议者向所有节点广播prepare(n)请求;
3.接收者比较n和minProposal,如果n>minProposal,表示有更新的提议,minProposal=n;否则将(acceptedProposal,acceptedValue)返回;
4.提议者接收到过半数请求后,如果发现有acceptedValue返回,表示有更新的提议,保存acceptedValue到本地,然后跳转1,生成一个更高的提议;
5.到这里表示在当前paxos instance内,没有优先级更高的提议,可以进入第二阶段,广播accept(n,value)到所有节点;
6.接收者比较n和minProposal,如果n>=minProposal,则acceptedProposal=minProposal=n,acceptedValue=value,本地持久化后,返回;
否则,返回minProposal
7.提议者接收到过半数请求后,如果发现有返回值>n,表示有更新的提议,跳转1;否则value达成一致。
从上述流程可知,并发情况下,可能会出现第4步或者第7步频繁重试的情况,导致性能低下,更严重者可能导致永远都无法达成一致的情况,就是所谓的“活锁”,如下图所示:

 

1.S1作为提议者,发起prepare(3.1),并在S1,S2和S3达成多数派;
2.随后S5作为提议者 ,发起了prepare(3.5),并在S3,S4和S5达成多数派;
3.S1发起accept(3.1,value1),由于S3上提议 3.5>3.1,导致accept请求无法达成多数派,S1尝试重新生成提议
4.S1发起prepare(4.1),并在S1,S2和S3达成多数派
5.S5发起accpet(3.5,value5),由于S3上提议4.1>3.5,导致accept请求无法达成多数派,S5尝试重新生成提议
6.S5发起prepare(5.5),并在S3,S4和S5达成多数派,导致后续的S1发起的accept(4.1,value1)失败

......

prepare阶段的作用
从Basic-Paxos的描述可知,需要通过两阶段来最终确定一个值,由于轮回多,导致性能低下,至少两次网络RTT。那么prepare阶段能否省去?如下图所示:


1.S1首先发起accept(1,red),并在S1,S2和S3达成多数派,red在S1,S2,S3上持久化
2.随后S5发起accept(5,blue),对于S3而言,由于接收到更新的提议,会将acceptedValue值改为blue
3.那么S3,S4和S5达成多数派,blue在S3,S4和S5持久化
4.最后的结果是,S1和S2的值是red,而S3,S4和S5的值是blue,没有达成一致。

所以两阶段必不可少,Prepare阶段的作用是阻塞旧的提议,并且返回已经接收到的acceptedProposal。同时也可以看到的是,假设只有S1提议,则不会出现问题,这就是我们下面要讲的Multi-Paxos。

Multi-paxos算法
     Paxos是对一个值达成一致,Multi-Paxos是连续多个paxos instance来对多个值达成一致,这里最核心的原因是multi-paxos协议中有一个Leader。Leader是系统中唯一的Proposal,在lease租约周期内所有提案都有相同的ProposalId,可以跳过prepare阶段,议案只有accept过程,一个ProposalId可以对应多个Value,所以称为Multi-Paxos。

选举
     首先我们需要有一个leader,其实选主的实质也是一次Paxos算法的过程,只不过这次Paxos确定的“谁是leader”这个值。由于任何一个节点都可以发起提议,在并发情况下,可能会出现多主的情况,比如A,B先后当选为leader。为了避免频繁选主,当选leader的节点要马上树立自己的leader权威(让其它节点知道它是leader),写一条特殊日志(start-working日志)确认其身份。根据多数派原则,只有一个leader的startworking日志可以达成多数派。leader确认身份后,可以通过了lease机制(租约)维持自己的leader身份,使得其它proposal不再发起提案,这样就进入了leader任期,由于没有并发冲突,因此可以跳过prepare阶段,直接进入accept阶段。通过分析可知,选出leader后,leader任期内的所有日志都只需要一个网络RTT(Round Trip Time)即可达成一致。

新主恢复流程
      由于Paxos中并没有限制,任何节点都可以参与选主并最终成为leader,这就无法保证新选出的leader包含了所有日志,可能存在空洞,因此在真正提供服务前,还存在一个获取所有已提交日志的恢复过程。新主向所有成员查询最大logId的请求,收到多数派响应后,选择最大的logId作为日志恢复结束点,这里多数派的意义在于恢复结束点包含了所有达成一致的日志,当然也可能包含了没有达成多数派的日志。拿到logId后,从头开始对每个logId逐条进行paxos协议,因为在新主获得所有日志之前,系统是无法提供服务的。为了优化,引入了confirm机制,就是将已经达成一致的logId告诉其它acceptor,acceptor写一条confirm日志到日志文件中。那么新主在重启后,扫描本地日志,对于已经拥有confirm日志的log,就不会重新发起paxos了。同样的,在响应客户端请求时,对于没有confirm日志的log,需要重新发起一轮paxos。由于没有严格要求confirm日志的位置,可以批量发送。为了确保重启时,不需要对太多已提价的log进行paxos,需要将confirm日志与最新提交的logId保持一定的距离。

性能优化
      Basic-Paxos一次日志确认,需要至少2次磁盘写操作(prepare,promise)和2次网络RTT(prepare,promise)。Multi-Paxos利用一阶段提交(省去Prepare阶段),将一次日志确认缩短为一个RTT和一次磁盘写;通过confirm机制,可以缩短新主的恢复时间。为了提高性能,我们还可以实现一批日志作为一个组提交,要么成功一批,要么都不成功,这点类似于group-commit,通过RT换取吞吐量。

安全性(异常处理)
1.Leader异常
Leader在任期内,需要定期给各个节点发送心跳,已告知它还活着(正常工作),如果一个节点在超时时间内仍然没有收到心跳,它会尝试发起选主流程。Leader异常了,则所有的节点先后都会出现超时,进入选主流程,选出新的主,然后新主进入恢复流程,最后再对外提供服务。我们通常所说的异常包括以下三类:
(1).进程crash(OS crash)
Leader进程crash和Os crash类似,只要重启时间大于心跳超时时间都会导致节点认为leader挂了,触发重新选主流程。
(2).节点网络异常(节点所在网络分区)
Leader网络异常同样会导致其它节点收不到心跳,但有可能leader是活着的,只不过发生了网络抖动,因此心跳超时不能设置的太短,否则容易因为网络抖动造成频繁选主。另外一种情况是,节点所在的IDC发生了分区,则同一个IDC的节点相互还可以通信,如果IDC中节点能构成多数派,则正常对外服务,如果不能,比如总共4个节点,两个IDC,发生分区后会发现任何一个IDC都无法达成多数派,导致无法选出主的问题。因此一般Paxos节点数都是奇数个,而且在部署节点时,IDC节点的分布也要考虑。
(3).磁盘故障
前面两种异常,磁盘都是OK的,即已接收到的日志以及对应confirm日志都在。如果磁盘故障了,节点再加入就类似于一个新节点,上面没有任何日志和Proposal信息。这种情况会导致一个问题就是,这个节点可能会promise一个比已经promise过的最大proposalID更小的proposal,这就违背了Paxos原则。因此重启后,节点不能参与Paxos Instance,它需要先追上Leader,当观察到一次完整的paxos instance时该节点结束不能promise/ack状态。
2.Follower异常(宕机,磁盘损坏等)
对于Follower异常,则处理要简单的多,因为follower本身不对外提供服务(日志可能不全),对于leader而言,只要能达成多数派,就可以对外提供服务。follower重启后,没有promise能力,直到追上leader为止。

Q&A
1.Paxos协议数据同步方式相对于基于传统1主N备的同步方式有啥区别?
      一般情况下,传统数据库的高可用都是基于主备来实现,1主1备2个副本,主库crash后,通过HA工具来进行切换,提升备库为主库。在强一致场景下,复制可以开启强同步,Oracle和Mysql都是类似的复制模式。但是如果备库网络抖动,或者crash,都会导致日志同步失败,服务不可用。为此,可以引入1主N备的多副本形式,我们对比都是3副本的情况,一个是基于传统的1主2备,另一种基于paxos的1主2备。传统的1主两备,进行日志同步时,只要有一个副本接收到日志并就持久化成功,就可以返回,在一定程度上解决了网络抖动和备库crash问题。但如果主库出问题后,还是要借助于HA工具来进行切换,那么HA切换工具的可用性如何来保证又成为一个问题。基于Paxos的多副本同步其实是在1主N备的基础上引入了一致性协议,这样整个系统的可用性完全有3个副本控制,不需要额外的HA工具。而实际上,很多系统为了保证多节点HA工具获取主备信息的一致性,采用了zookeeper等第三方接口来实现分布式锁,其实本质也是基于Paxos来实现的。

2.分布式事务与Paxos协议的关系?
     在数据库领域,提到分布式系统,就会提到分布式事务。Paxos协议与分布式事务并不是同一层面的东西。分布式事务的作用是保证跨节点事务的原子性,涉及事务的节点要么都提交(执行成功),要么都不提交(回滚)。分布式事务的一致性通常通过2PC来保证(Two-Phase Commit, 2PC),这里面涉及到一个协调者和若干个参与者。第一阶段,协调者询问参与者事务是否可以执行,参与者回复同意(本地执行成功),回复取消(本地执行失败)。第二阶段,协调者根据第一阶段的投票结果进行决策,当且仅当所有的参与者同意提交事务时才能提交,否则回滚。2PC的最大问题是,协调者是单点(需要有一个备用节点),另外协议是阻塞协议,任何一个参与者故障,都需要等待(可以通过加入超时机制)。Paxos协议用于解决多个副本之间的一致性问题。比如日志同步,保证各个节点的日志一致性,或者选主(主故障情况下),保证投票达成一致,选主的唯一性。简而言之,2PC用于保证多个数据分片上事务的原子性,Paxos协议用于保证同一个数据分片在多个副本的一致性,所以两者可以是互补的关系,绝不是替代关系。对于2PC协调者单点问题,可以利用Paxos协议解决,当协调者出问题时,选一个新的协调者继续提供服务。工程实践中,Google Spanner,Google Chubby就是利用Paxos来实现多副本日志同步。

3.如何将Paxos应用于传统的数据库复制协议中?
    复制协议相当于是对Paxos的定制应用,通过对一系列日志进行投票确认达成多数派,就相当于日志已经在多数派持久化成功。副本通过应用已经持久化的日志,实现与Master节点同步。由于数据库ACID特性,本质是由一个一致的状态到另外一个一致的状态,每次事务操作都是对应数据库状态的变更,并生成一条日志。由于client操作有先后顺序,因此需要保证日志的先后的顺序,在任何副本中,不仅仅要保证所有日志都持久化了,而且要保证顺序。对于每条日志,通过一个logID标示,logID严格递增(标示顺序),由leader对每个日志进行投票达成多数派,如果中途发生了leader切换,对于新leader中logID的“空洞”,需要重新投票,确认日志的有效性。

4.Multi-Paxos的非leader节点可以提供服务吗?
     Multi-Paxos协议中只有leader确保包含了所有已经已经持久化的日志,当然本地已经持久化的日志不一定达成了多数派,因此对于没有confirm的日志,需要再进行一次投票,然后将最新的结果返回给client。而非leader节点不一定有所有最新的数据,需要通过leader确认,所以一般工程实现中,所有的读写服务都由leader提供。

5.客户端请求过程中失败了,如何处理?
     client向leader发起一次请求,leader在返回前crash了。对于client而言,这次操作可能成功也可能失败。因此client需要检查操作的结果,确定是否要重新操作。如果leader在本地持久化后,并没有达成多数派时就crash,新leader首先会从各个副本获取最大的logID作为恢复结束点,对于它本地没有confirm的日志进行Paxos确认,如果此时达成多数派,则应用成功,如果没有则不应用。client进行检查时,会知道它的操作是否成功。当然具体工程实践中,这里面涉及到client超时时间,以及选主的时间和日志恢复时间。

参考文档

https://ramcloud.stanford.edu/~ongaro/userstudy/paxos.pdf

http://www.cs.utexas.edu/users/lorenzo/corsi/cs380d/papers/paper2-1.pdf
http://research.microsoft.com/en-us/um/people/lamport/pubs/paxos-simple.pdf

利用zabbix api进行管理

标签:系统运维,Linux 发布于 2016-07-19 11:13:42
zabbix 现在之所以那么流行,个人感觉跟zabbix 强大的API有一个很大的关系,利用API可以帮我们完成很多事情:

    1、获取相关组,主机信息。

    2、比如有人喜欢获取历史数据重新出图。

    3、添加删除主机,绑定删除模板。

    4、添加删除维护周期


这里我使用pipy提供的zabbix_client模块来进行,这样就不用我们自己去写登录函数,只要在模块开始指定用户名密码即可:


1、安装zabbix_client:

 pip install zabbxi_client


2、API管理脚本,替换成自己用户名密码即可:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
#coding:utf-8
import   time
from   zabbix_client   import   ZabbixServerProxy
class   Zabbix():
      def   __init__(  self  ):
          self  .zb   =   ZabbixServerProxy(  "http://192.168.10.100/zabbix"  )
          self  .zb.user.login(user  =  "Admin"  , password  =  "zabbix"  )
       ############## 查询组所有组获取组id ###############
      def   get_hostgroup(  self  ):
          data   =   {
             "output"  :[  'groupid'  ,  'name'  ]
           }
          ret   =   self  .zb.hostgroup.get(  *  *  data)
          return   ret 
   
       ########### 通过组id获取相关组内的所有主机 ###############
1
2
3
4
5
6
7
8
9
10
11
12
13
      def   get_hostid(  self  ,groupids  =  2  ):
          data   =   {
          "output"  : [  "hostid"    "name"  ],
          "groupids"  : groupids
          }
          ret   =   self  .zb.host.get(  *  *  data)
          return   ret
       ########## 通过获取的hostid查找相关监控想itemid ###################
      def   item_get(  self  , hostids  =  "10115"  ):
          data   =   {
         "output"  :[  "itemids"  ,  "key_"  ],
         "hostids"  : hostids,
          }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
          ret   =   self  .zb.item.get(  *  *  data)
          return   ret
    ######### 通过itemid(传入itemid和i0表示flast类型)获取相关监控项的历史数据 ###########
      def   history_get(  self  , itemid, i ,limit  =  10  ):
          data   =     "output"    "extend"  ,
            "history"  : i,
            "itemids"  : [itemid], 
            "limit"  : limit 
            }
          ret   =   self  .zb.history.get(  *  *  data)
          return   ret
   
     ###############添加主机并且指定到组(传入主机名,IP地址和组ID)#####################
      def   add_zabbix_host(  self  ,hostname  =  "test_zabbix"  ,ip  =  "192.168.10.100"  ,groupid  =  "2"  ):
          data   =   {
           "host"  : hostname,
           "interfaces"  : [
              {
                  "type"    1  ,
                  "main"    1  ,
                  "useip"    1  ,
                  "ip"  : ip,
                  "dns"  : "",
                  "port"    "10050"
              }
           ],
           "groups"  : [
               {
                  "groupid"  : groupid
               }
           ]
          }
          ret   =   self  .zb.host.create(data)
          return   ret
      #####################查看现有模板#######################
      def   get_template(  self  ):
          datalist   =   []
          datadict  =  {}
          data   =   {
              "output"  :[  "templateid"  ,  "name"  ]
          }
          ret   =    self  .zb.template.get(data)
          for     in   ret:
              datadict[i[  'name'  ]]   =   i[  'templateid'  ]
              datalist.append(datadict)
          return   datalist 
     
       #################### 关联主机到模板##################################
      def   link_template(  self  , hostid  =  10156  , templateids  =  10001  ):
          data   =   {
              "hostid"  :hostid,
               "templates"  :templateids
          }      
   
          ret   =   self  .zb.host.update(data)
          return   ret
    
      ###################  添加维护周期,,######################################
  
      def   create_maintenance(  self  ,name  =  "test"  ,hostids  =  10156  ,time  =  2  ):
          data   =    {
              "name"  : name,
              "active_since"    1458142800  ,
              "active_till"    1489678800  ,
              "hostids"  : [
                  hostids
              ],
              "timeperiods"  : [
                  {
                      "timeperiod_type"    0  ,
                      "period"    3600
                  }
              ]
          }
          ret   =   self  .zb.maintenance.create(data)
          self  .host_status(  10130    1  )
          return   ret
      ################获取维护周期,,#########################
      def   get_maintenance(  self  ):
          data   =   {
              "output"    "extend"  ,
              "selectGroups"    "extend"  ,
              "selectTimeperiods"    "extend"
          }
          ret   =   self  .zb.maintenance.get(data)
          return   ret
      ##############获取维护周期之后,通过传入maintenanceid删除维护周期###########
      def   del_maintenance(  self  ,maintenanceids):
          return   self  .zb.maintenance.delete(maintenanceids) 
      #########################添加维护周期时候需要吧zabbix_host设置成非监控状态##################
      def   host_status(  self  , hostid, status):
          data   =   {
              "hostid"  :hostid,
              "status"  :status
          }
          return   self  .zb.host.update(data)
      ###########通过hostids删除主机id,顺带也删除模板#########
     
      def   host_del(  self  ,hostids  =  10155  ):
          return   self  .zb.host.delete(hostids)
if   __name__   =  =   "__main__"  :
      zabbix_server   =   Zabbix()
      #print zabbix_server.get_hostgroup()
      #print zabbix_server.get_hostid()
      #print zabbix_server.item_get(10156)   
      #data = zabbix_server.history_get("24889",0) 
      #print zabbix_server.get_hostgroup()
      #print zabbix_server.add_zabbix_host()
      #data = zabbix_server.get_template()
      #print data[0]['Template OS Linux']
      #print zabbix_server.link_template()
      #print zabbix_server.create_maintenance()
     # print zabbix_server.host_del(10155)
      #print zabbix_server.get_maintenance()
      print   zabbix_server.del_maintenance(  15  )

Nodejs环境配置UEditor,并实现图片上传阿里OSS


UEditor编辑器为百度公司出的一款功能强大的网页在线富文本编辑器,只需简单配置一下就可以使用。

阿里云存储OSS为阿里云推出的一款安全可靠的云存储服务,目前也受到了大部分企业的喜爱。

阿里云存储OSS有着详细的各种语言的API文档让我们使用起来更加得心应手,在这里我们不得不佩服阿里强大的技术力量;相比之下百度的UEditor编辑器的API就显得逊色好多,nodejs作为现在流行的开发语言之一,在他们官网居然找不到相关的图片上传文档。下文我们来给各位介绍在Nodejs环境配置UEditor文件图片上传到阿里OSS的操作方法,希望这个例子能够为大家带来一些帮助。

一、首先引入UEditor的相关文件


<script src="/js/t/ueditor/ueditor.config.js"></script>

<script src="/js/t/ueditor/ueditor.all.js"></script>

<script src="/js/t/ueditor/lang/zh-cn/zh-cn.js"></script>


二、前端配置:新建自己的js文件main.js,并配置自己想要的功能    

   (很多人都直接在UEditor的ueditor.config.js中改config,我个人习惯在插件以外改)

var ue = UE.getEditor('ueditor',{
        serverUrl : "/ueditor",
    	toolbars: ["自定义的工具栏,默认为所有"],
        imagePathFormat: "/upload",
        elementPathEnabled: false,
        maximumWords :20000,
        autoHeight: false        
	})


    这里根据自己的需求去配置,官网有具体的说明,就不再讲解了,要注意一下的是 serverUrl(服务端请求地址,主要用于获取图片上传的一些参数)和 imagePathFormat(指定文件上传路径和返回路径)具体看官方文档


    在编辑器实例化完毕后才可以设置或者获取编辑内容

    ue.ready(function(){
        this.setContent("设置内容");
        
        获取内容
        var content = this.getContent();
    })




三、后端配置:在服务端创建请求路径 /ueditor 即config中设置的serverUrl参数的请求路径

   在初始化时会get的方式向 serverUrl 发起获取后端配置的请求并带有一个action=config的参数,action参数值包括config(配置文件)、uploadimage(图片上传)、listimage(在线管理)、catchimage(抓取图片),所以只需要重写这4个请求就基本上实现了我们的需求。

  请求处理代码如下

    请求参数
    GET {"action": "config"}
    POST "upfile": File Data
    
    返回格式
    // 需要支持callback参数,返回jsonp格式
    {
            "imageUrl": "http://localhost/ueditor/php/controller.php?action=uploadimage",
            "imagePath": "/ueditor/php/",
            "imageFieldName": "upfile",
            "imageMaxSize": 2048,
            "imageAllowFiles": [".png", ".jpg", ".jpeg", ".gif", ".bmp"]
        }


到了这里没意外的话刷新页面就会出现你所配置的编辑器了


四、服务端接收前端图片上传数据,并上传到阿里OSS

   到了最重要的一步,这里用到的中间件有(co-busboy,path,ali-oss)

    

   首先要设置ali-oss的相关参数

    var parse = require('co-busboy');
    var oss = require('ali-oss')
    var part;
    var filename;
    var buffers = [];
    var nread = 0;
    var aliyunOss = {};
    
    var bucket = config.bucket,
    key = config.key,
    domain = config.domain,
    dir = config.dir;
    var store = oss({
        accessKeyId: config.accesskeyid,
        accessKeySecret: config.accesskeysecret,
        bucket: config.bucket,
        region: 'oss-cn-shanghai'
    });


   解析接收数据

    var parts = parse(this, {
        // only allow upload `.jpg` files
        checkFile: function (fieldname, file, filename) {
            if(_.indexOf(filterPicture,path.extname(filename))===-1){
                var err = new Error('invalid jpg image')
                err.status = 400
                return err;
            }
        }
    })


   抓取必要信息,并推送到ali-oss

     function random_string(len) {
      len = len || 32;
      var chars = 'ABCDEFGHJKMNPQRSTWXYZabcdefhijkmnprstwxyz2345678';   
      var maxPos = chars.length;
      var pwd = '';
      for (i = 0; i < len; i++) {
          pwd += chars.charAt(Math.floor(Math.random() * maxPos));
        }
        return pwd;
    }
    
    function get_suffix(filename) {
        pos = filename.lastIndexOf('.')
        suffix = ''
        if (pos != -1) {
            suffix = filename.substring(pos)
        }
        return suffix;
    }
    
    while (part = yield parts) {
        if (part.filename){
            filename = part.filename
        }

        if (filename){
            suffix = get_suffix(filename);
            o_filename = dir + random_string() + suffix
        }

        if (part.mimeType) {
            ctype = part.mimeType;
        };

            console.log(part)
        if (part._readableState.length) {
            csize = part._readableState.length;
        };

        if(filename){

            console.log(o_filename,csize,ctype)
            aliyunOss = yield store.put(o_filename, part, {
                headers: {
                      'Content-Length': csize,
                      'Content-Type': ctype
                    }
                });
            // console.log(aliyunOss);
            console.log('uploading %s -> %s');
        }
    }


    上传oss完成,按照ueditor认识的格式返回信息

    return {
        "state": "SUCCESS",
        "url": !!domain?domain+"/"+aliyunOss.name:aliyunOss.url,
        "title": aliyunOss.name,
        "original": o_filename
}



以上代码均为服务端的上传处理代码,需要根据自己的项目情况做调整。

ZEROC究竟是何方神圣?

标签:框架类,其他 发布于 2016-08-10 15:26:09

本文整理自《ZeroC Ice权威指南》作者Leader-us针对网友提出的ZeroC 问题的解答。


1、RPC又是炒冷饭??

Leader-us:

RPC的确是炒冷饭,但彼一时,此一时。
现在这个江湖早已不是过去那个江湖了。移动设备早已吞噬PC市场,原先为应付移动设备兼容而开发的网页模式的应用逐渐下架,App要界面好看,速度要快,要安全,要省流量,所以,RPC又重新引起大家的重视,现在90%的人都认为Rest没有技术含量,沦为大路货了,但90%的人都觉得Thrift是高大上的技术,在市场驱动下,RPC这个炒冷饭的技术,还真是一盘大餐!


2、Ice到底是个什么东东呢?有什么用处?  

Leader-us:

分布式系统的通信,要么RPC,要么消息队列机制,而且RPC方式的代码通常要占到一半以上。
如果一个系统比较复杂,需要N个服务之间有调用关系,那么这就是一个通用的技术问题,简单的说,就是服务治理/服务总线平台,涉及到服务注册、负载均衡、故障处理、服务扩容、以及最后的RPC调用功能,这些能力都具备的,而且是开源的,目前基本只有Zeroc Ice与 阿里放弃的Duboo,而Zeroc Ice则有超过10年的历史,不断更新,不仅仅支持服务器端的RPC调用,也支持移动设备。
Ice的好处,可以用Java,C++,C#,Python等语言开发服务端,然后大家可以相互通信,最后这些服务组成一个系统,还能被7种语言写的客户端调用,包括PHP,Javascript,不仅仅是网页程序调用,还能移动设备上调用。对于互联网/App开发,节省了80%的工作量.


3、这个Zeroc Ice 与 Thrift 还有 Avro 相比 有什么优缺点?同时Thrift 还有 Avro 在大数据及互联网应用广泛且都有成熟案例,Zeroc Ice如何进入这个圈子?

Leader-us:

我们要看看究竟是谁进谁的圈子,这个问题需要弄明白。
RPC技术最早是由SUN引领并成为标准规范的,后来就产生了一个问题,不同厂家的硬件、软件、不同的开发语言之间如何能进行“标准化”的通信?
当时微软有自己的DCOM技术,SUN 有自己的J2EE/RMI技术,这些都局限于一个小圈子里,于是COBRA成为第一个吃螃蟹的,一大群专家坐在一起,制定了一个跨语言、跨操作系统、跨硬件平台的“宏伟”目标。
但可惜最终这个宏大目标没能实现,由于规范过于庞大、开发中间件的厂商没有人能100%准确理解和遵循规范,导致各种兼容性问题,最终COBRA走向没落。
COBRA没落之时,出现两个分支,其中一个是COBRA领域的资深专家们,这里主要是技术派专家,而非吹水派专家,看到了COBRA失败的本质原因,也很痛心这个伟大尝试的失败,于是他们抱团,成立了
Zeroc公司,开始了破冰之旅,从而诞生了Ice这个跨平台、跨语言、高性能的RPC平台——他们称之为反叛之冰。
这里顺便说下COBRA的没落的一个重要原因:对于中间件和平台这样的技术,产品本身的质量和功能远远超过一纸规范,没有意识到这个问题而导致失败的例子很多,网景公司的JavaScript最终不低微软的JS,SUN的 J2ME最终也让位于谷歌的Android。 Zeroc公司就吸取了这个教训,他们自己实现ICE平台的各个语言的Runtime,包括Java版本的、C版本的、Python、PHP,而且十几年来一直不断完善,移动设备上,Android,IOS都提供Runtime包,因此,连SUN、Borland都倒下了,Zeroc公司仅靠Ice一个产品,屹立至今,试问IT界里,这样的技术型公司还有几个?
COBRA没落的同时,IBM主推的Webservice/SOA这条线发展下去了,他们也借鉴了COBRA的精华,比如WSDL其实就是IDL,但这个路也没能光大下去,很快被Rest/JSON替代,然后这里就没有平台的说法,都变成了API。
由于Zeroc Ice的存在,所以在多语言、高性能的RPC领域,一直没有什么其他产品和开源项目,直到最近,由于移动设备对远程通信性能和流量的要求提升,同时互联网开发中多语言协作的增多,于是RPC技术重新被大家重视,谷歌释放出开源的Protocol Buffers表明其RPC方面的领先性,Facebook则更开放的把Thrift这个框架开源出来,而Avro则是因为Hadoop之父(Avro是Hadoop里的一个组件演化而来的) 看不惯Thrift的思想而打造的一个框架,此框架目前仍然是“半成品”。
与Zeroc Ice相比,Thrift其实只能算作一个FrameWork,而Ice则是一个Platform,另外从成熟度、稳定性等方面来对比,都不是在一个层面上的,目前开源的唯一一个工业级的RPC平台,只有Ice,
Ice的性能不用说,其稳定性更是有目共睹,因为最早很多电信级别的客户使用它。大名鼎鼎的Skype也是用它,国内也不少公司默默的使用。
以下是我对Avro的一个测试研究:
•Apahce Avro框架简单,非接口编译的模式灵活度很高,用Json定义的RPC消息结构和方法简单并容易理解
•Http协议的编码和传输机制效率远远低于长连接的Socket模式,本机对比了Avro的Http协议与Netty实现的Socket协议,请求应答消息相同的情况下,HTTP的TPS是500左右,而Netty Socket模式则是1.5万左右,相差很悬殊,同样的接口,ICE的TPS则达到2.5万TPS!
•多语言客户端支持并不是那么容易的事情,Avro的Phyton客户端目前只实现了基本的Http协议,(Java的同时实现了Neety客户端协议),这种情况下,服务端只能也采用Http协议,从而导致并发性能问题.


4、有没有比较形象一点的比较呢,比如说在实际使用过程中会体现的一些优点,能有几个粗略的数据对比会更加清晰一些啊

Leader-us:

直观的几个好处举例如下:
以使用最多的语言Jar为例,Ice核心Jar包就一个,100多个类,总共几百K,不依赖任何其他第三方包,不容易引发包冲突,因为包很小,所以手机上的APP就能打包很小,快速下载,这很重要。
如果系统比较简单,只是几个服务的远程调用,除了业务代码,Ice相关的编码也就几十行,容易上手,不用注册中心的方式,比Java RMI还简单
常见的互联网应用,涉及到PHP、Java、C (ios),一个Java开发的Ice服务,互联网Web,Android,苹果手机,都搞定了,成本和代价很小
如果涉及到安全问题,客户端从TCP改为SSL,则只要改Ice配置即可,不用改程序,而且一个Ice服务可以同时提供TCP和SSL两种访问端口,也只是配置就解决了。
最后,如果系统比较复杂,几十个上百个服务,涉及到复杂的服务调用,负载均衡问题,那么升级为IceGrid,定义一个XML文件,秒杀了服务的部署拓扑,只要用控制台命令发布即可,
不像Jboss这种系统,需要手工到每个Jboss下 起停等繁琐工作。
总之,可以很简单的使用,也开业很高大上的使用,这就是Zeroc Ice。网上有一个有趣的帖子,有个人说 他认为每个软件都有自己的缺陷,但是Ice,他一直没找到缺陷。


5、在接口调用方面,我用过webserivce SAP的RFC,效率和可移植性均不强。现在的平台太多了,而流量和效率是最需要考虑的方面,
1.RPC的效率应该是没的说,
2.有个问题,Ice的底层是不是也是对OS的API socket的封装?

Leader-us: 

Ice 底层也是Socket通信,使用了NIO最佳模式,比Netty实现的Avro (Apache主席,Hadoop之父的新作) 高出近一倍,相同的接口,Http 接口实现的Avro RPC是 500 TPS,Netty 版的Avro 是1.5万TPS,Ice则高达2.5万。有人根据Ice权威指南里的例子,对比了Duboo,发现Ice比Duboo性能高4倍左右。 
Ice对外宣传的是,高性能,多语言,跨平台,非常稳定。排在第一的是高性能,这是其十年来不断完善与进化的结果,如果你能10年磨一剑,那也是倚天剑了。


6、请问ACE和ICE有什么区别?从架构层面和设计方面,而不是代码(ACE的代码公认的烂,为设计模式而模式)

Leader-us:

ace是对c++基础开发接口和功能的封装,提高了程序的可移植性,并且提供了很好网络类;
ice是分布式框架,提供了消息分发、对象定位、远程调用等功能的实现。
ACE 可以理解为是一个API,而且是面向C++ 的ICE可以理解为一个Platform,是多语言的RPC平台两者不是一个层面的东西另外,Ice又称之为反叛之冰,是当初参与COBRA的一帮资深大牛另起炉灶的产品,团队的实力和影响力都是只能仰望的高人,用流行的一个句话来比较,Ice完美秒杀ace.

Solr原理

标签:其他 发布于 2016-08-08 21:27:24

Solr对外提供标准的http接口来实现对数据的索引的增加、删除、修改、查询。在 Solr 中,用户通过向部署在servlet 容器中的 Solr Web 应用程序发送 HTTP 请求来启动索引和搜索。Solr 接受请求,确定要使用的适当SolrRequestHandler,然后处理请求。通过 HTTP 以同样的方式返回响应。默认配置返回Solr 的标准 XML 响应,也可以配置Solr 的备用响应格式


可以向 Solr 索引 servlet 传递四个不同的索引请求:
add/update 允许向 Solr 添加文档或更新文档。直到提交后才能搜索到这些添加和更新。
commit 告诉 Solr,应该使上次提交以来所做的所有更改都可以搜索到。
optimize 重构 Lucene 的文件以改进搜索性能。索引完成后执行一下优化通常比较好。如果更新比较频繁,则应该在使用率较低的时候安排优化。一个索引无需优化也可以正常地运行。优化是一个耗时较多的过程。
delete 可以通过 id 或查询来指定。按 id 删除将删除具有指定 id 的文档;按查询删除将删除查询返回的所有文档。 

一个典型的Add请求报文

[html] view plain copy

  1. <add>    

  2.   <doc>    

  3.     <field name="id">TWINX2048-3200PROfield>    

  4.     <field name="name">CORSAIR  XMS 2GB (2 x 1GB) 184-Pin DDR SDRAM Unbuffered DDR 400 (PC 3200) Dual Channel Kit System Memory - Retailfield>    

  5.     <field name="manu">Corsair Microsystems Inc.field>    

  6.     <field name="cat">electronicsfield>    

  7.     <field name="cat">memoryfield>    

  8.     <field name="features">CAS latency 2, 2-3-3-6 timing, 2.75v, unbuffered, heat-spreaderfield>    

  9.     <field name="price">185field>    

  10.     <field name="popularity">5field>    

  11.     <field name="inStock">truefield>    

  12.   doc>    

  13.   <doc>    

  14.     <field name="id">VS1GB400C3field>    

  15.     <field name="name">CORSAIR ValueSelect 1GB 184-Pin DDR SDRAM Unbuffered DDR 400 (PC 3200) System Memory - Retailfield>    

  16.     <field name="manu">Corsair Microsystems Inc.field>    

  17.     <field name="cat">electronicsfield>    

  18.     <field name="cat">memoryfield>    

  19.     <field name="price">74.99field>    

  20.     <field name="popularity">7field>    

  21.     <field name="inStock">truefield>    

  22.   doc>    

  23. add>   




一个典型的搜索结果报文:

[html] view plain copy

  1. <response>    

  2.     <lst name="responseHeader">    

  3.         <int name="status">0int>    

  4.         <int name="QTime">6int>    

  5.         <lst name="params">    

  6.             <str name="rows">10str>    

  7.             <str name="start">0str>    

  8.             <str name="fl">*,scorestr>    

  9.             <str name="hl">truestr>    

  10.             <str name="q">content:"faceted browsing"str>    

  11.         lst>    

  12.     lst>    

  13.     

  14.     <result name="response" numFound="1" start="0" maxScore="1.058217">    

  15.         <doc>    

  16.             <float name="score">1.058217float>    

  17.             <arr name="all">    

  18.                 <str>http://localhost/myBlog/solr-rocks-again.htmlstr>    

  19.                 <str>Solr is Greatstr>    

  20.                 <str>solr,lucene,enterprise,search,greatnessstr>    

  21.                 <str>Solr has some really great features, like faceted browsing and replicationstr>    

  22.             arr>    

  23.             <arr name="content">    

  24.                 <str>Solr has some really great features, like faceted browsing and replicationstr>    

  25.             arr>    

  26.             <date name="creationDate">2007-01-07T05:04:00.000Zdate>    

  27.             <arr name="keywords">    

  28.                 <str>solr,lucene,enterprise,search,greatnessstr>    

  29.             arr>    

  30.             <int name="rating">8int>    

  31.             <str name="title">Solr is Greatstr>    

  32.             <str name="url">http://localhost/myBlog/solr-rocks-again.htmlstr>    

  33.         doc>    

  34.     result>    

  35.     

  36.     <lst name="highlighting">    

  37.         <lst name="http://localhost/myBlog/solr-rocks-again.html">    

  38.             <arr name="content">    

  39.                 <str>Solr has some really great features, like <em>facetedem>    

  40.                 <em>browsingem> and replicationstr>    

  41.             arr>    

  42.         lst>    

  43.     lst>    

  44. response>   


关于solr的详细使用说明,请参考
http://wiki.apache.org/solr/FrontPage

常见的web应用漏洞有哪些???

标签:安全 发布于 2016-09-05 16:50:13

总结下web 常见的几个漏洞


1.SQL注入

2.XSS跨站点脚本

3.缓冲区溢出

4.cookies修改

5.上传漏洞

6.命令行注入



1 sql 漏洞 

 SQL注入攻击是黑客对数据库进行攻击的常用手段之一。随着B/S模式应用开发的发展,使用这种模式编写应用程序的程序员也越来越多。但是由于程序员的水平及经验也参差不齐,相当大一部分程序员在编写代码的时候,没有对用户输入数据的合法性进行判断,使应用程序存在安全隐患。用户可以提交一段数据库查询代码,根据程序返回的结果,获得某些他想得知的数据,这就是所谓的SQL Injection,即SQL注入。


2 XSS 夸站点漏洞

   XSS是一种经常出现在web应用中的计算机安全漏洞,它允许恶意web用户将代码植入到提供给其它用户使用的页面中。比如这些代码包括HTML代码和客户端脚本。攻击者利用XSS漏洞旁路掉访问控制——例如同源策略(same origin policy)。这种类型的漏洞由于被黑客用来编写危害性更大的网络钓鱼(Phishing)攻击而变得广为人知。对于跨站脚本攻击,黑客界共识是:跨站脚本攻击是新型的“缓冲区溢出攻击“,而JavaScript是新型的“ShellCode”。



3  缓冲区溢出

 缓冲区溢出漏洞是指在程序试图将数据放到及其内存中的某一个位置的时候,因为没有足够的空间就会发生缓冲区溢出的现象。



4 cookies修改

     

    基于上述建议,即使 Cookie 被窃取,却因 Cookie 被随机更新,且内容无规律性,攻击者无法加以利用。另外利用了时间戳另一大好处就是防止 Cookie 篡改或重放。

Cookie 窃取:搜集用户cookie并发给攻击者的黑客。攻击者将利用cookie信息通过合法手段进入用户帐户。

Cookie 篡改:利用安全机制,攻击者加入代码从而改写 Cookie 内容,以便持续攻击。


  

5上传漏洞

    这个漏洞在DVBBS6.0时代被黑客们利用的最为猖獗,利用上传漏洞可以直接得到WEBSHELL,危害等级超级高,现在的入侵中上传漏洞也是常见的漏洞。

导致该漏洞的原因在于代码作者没有对访客提交的数据进行检验或者过滤不严,可以直接提交修改过的数据绕过扩展名的检验。



6 命令行注入

  所谓的命令行输入就是webshell 了,拿到了权限的黑客可以肆意妄为

dubbo原理解析

标签:JAVA 发布于 2016-09-04 00:52:26

这是本人对于 Dubbo源码分析的系列一 ,没有说明Dubbo是什么,不清楚请先了解,此处只是为了给自己做个笔记,也给正在学习Dubbo的同学一些借鉴,后期会继续奉上所有关于Dubbo的逻辑分析,包括Dubbo简介、初始化与请求细节、注册中心、监控中心、治理中心等(由于Dubbo本身的文档已经非常详细了,这里只是重构)。 

A. Dubbo初始化、请求处理过程:(此处不涉及非常细节处,均以dubbo协议为例) 
一、 Dubbo提供者初始化过程分析:
 
a) Dubbo解析xml,初始化且暴露所有服务 
b) 由服务配置类ServiceConfig进行初始化工作及服务暴露入口 
i. ServiceConfig.export(); 
c) 服务可以多协议暴露 
i. ServiceConfig.doExportUrls(); 
d) 在某个协议下暴露服务 
i. ServiceConfig.doExportUrlsFor1Protocol(); 
e) 将服务实现类转化成invoker 
i. proxyFactory.getInvoker(service,interface,url); 
ii. 提供者端的invoker封装了服务实现类、URL、Type,状态均是只读,线程安全,是Dubbo中核心模型,Dubbo中的是实体域,其他所有模型都向它靠拢或转化成它,是一个可执行体,通过发起invoke来具体调用服务类,它可能是个本地实现类,也可能是个远程实现类,也可能是个集群实现invoker,由ProxyFactory产生,具体是AbstractProxyInvoker 
f) 暴露封装服务的Invoker 
i. Protocol.export(invoker); 
ii. Protocol是Dubbo中的服务域,只在服务启用是加载且无状态,天生线程安全,它是实体域Invoker暴露和引用的主功能入口,它负责Invoker的生命周期管理,是Dubbo中远程服务调用层。Dubbo有多种协议支持,有dubbo、http、rmi、hessian、injvm、webService等,下面具体说明服务暴露的细节,包括服务的注册、订阅、暴露、过滤器、监听器的初始化,其中服务的暴露则为Dubbo中的一重点。 
g) 注册中心协议集成,装饰真正暴露引用服务的协议,增强注册发布功能 
i. RegistryProtocol.export(invoker); 
ii. ServiceConfig中的protocol是被多层装饰的Protocol,是DubboProtocolRegistryProtocolProtocolListenerWrapperProtocolFilterWrapper(此处是以dubbo协议为例,还有HttpPtotocol、HessianProtocol、RmiProtocol),其中ProtocolFilterWrapper是负责初始化invoker所有的Filter、ProtocolListenerWrapper是负责初始化暴露或引用服务的监听器、RegistryProtocol是负责注册服务到注册中心与向注册中心订阅服务、DubboProtocol是负责服务的具体暴露与引用,且DubboProtocol也负责网络传输层、信息交换层的初始化及底层NIO框架的初始化 
h) 注册中心协议处理invoker后交给具体协议进行服务暴露 
i. RegistryProtocol.doLocalExport(invoker) 
ii. RegistryProtocol对原始invoker做一些简单状态后交给具体协议暴露,协议不关系invoker如何生成,由上层传入。接下来就是协议对invoker的暴露,此步骤是Dubbo中的核心。 
i) 协议层暴露服务前初始化过滤器与服务暴露引用的监听器 
i. 此步骤由上面提到的ProtocolListenerWrapper、ProtocolFilterWrapper完成,它们是协议的装饰者,增强功能(装饰模式大量使用在Dubbo中)。 
j) 协议暴露服务 
ii. DubboProtocol.export(); 
iii. 进入远程调用层Protocol,此层封装了所有remote层逻辑,对上层透明,暴露服务大致可以分为两步,第一是将invoker转化成Exporter;第二是根据URL绑定IP与端口建立NIO框架的Server;此两步的联系是通过URL关联在一起,协议层缓存了所有暴露的服务,其中key是由group、serviceName、version、port组成,它们的组合具体一个暴露服务,当NIO客户端发起远程调用时,NIO服务端通过此key来决定具体调用执行哪个Exporter,即执行的Invoker,对于NIO框架的底层通信下面会有讲解。 
j) 协议层创建Exporter后创建NIO Server完成服务的暴露 
i. DubboProtocol.openServer(url); 
ii. 创建封装了Inoker,key的DubboExporter后,通过URL创建NIO Server,且缓存暴露的Exporter,防止重复暴露。另外,同一个JVM中相同协议的服务共享同一个Server,不同服务中只有accept、idleTimeout、threads、heartbeat参数的变化会引用Server中属性的变化,但同JVM中同协议的服务均是引用同一个Server,第一个服务暴露是创建Server,其他服务的暴露是Server最多只是重置个别参数。 
 
k) 协议层创建NIO Server,并缓存Server 
i. DubboProtocol.createServer(url); 
ii. Dubbo底层通信是通过支持异步、事件驱动的NIO网络编程框架,如:Netty、Mina、Grizzly,此框架是典型的Reactor模式使用,使得单个线程处理多个请求,且支持多请求并行执行,NIO接受请求处理流程是读取请求数据解码执行业务逻辑编码发送回应消息,Dubbo是对NIO框架的再次抽象封装,加入一些Dubbo需要的逻辑,通过抽象扩展Handler完成,如HeaderExchangerHandler完成请求-响应模式、同步转异步模式消息发送,AllChannelHandler通过线程池完成请求、响应、连接等并行执行,下面会详细介绍。 
iii. Exchangers.bind(url,requestHanler); 
iv. Exchangers是门面类,Exchanger的逻辑封装在里面,通过此FACADE调用Exchanger逻辑,Dubbo目前只有一个HeaderExanger实现。从协议层进入Exchanger标志着程序进入了remote层,此层有消息交换层、网络传输层。当协议层调用bind(url,requestHanler)方法并传入最原始的处理Handler时,接下来就是remote层的Server和Hanlder及其他参数初始化的过程。 
v. HeaderExchanger.bind(url,requestHandler); 
 
vi. 此处是消息交换层与网络传输层初始化的入口,且负责将初始化后的Server传回给协议层。处理流程大致是Dubbo一系列Handler初始化、Server初始化。Handler包装过程是 协议层传入的原始requestHandlerHeaderExchangerHandlerDecodeHandlerAllChannelHandlerHeartbeatHandlerMultiMessageHandlerNettyServer[NettyHandler、NettyCodecAdapter]HeaderExchanerServer,HeaderExchanerServer封装了最终的Server,返回给上层协议层,NettyHandler、NettyCodecAdapter是NIO框架的直接处理Handler,NIO框架接受到消息后,先由NettyCodecAdapter解码,再由NettyHandler处理具体业务逻辑,再由NettyCodecAdapter编码后发送,NettyServer是个很重要的类,它既是Server又是Handler,而HeaderExchangerServer只是Server,所有NettyServer参与的Handler的处理过程,MultiMessageHandler是多消息处理Handler、HeartbeatHandler是处理心跳事件的Handler、AllChannelHandler是消息派发器,负责将请求放入线程池,并行执行请求,且Dubbo有多种线程模型、DecodeHandler是编码解码Handler、HeaderExchangerHandler是信息交换Handler,将请求转化成请求-响应模式与同步转异步模式,地位非常重要、requestHandler最后执行的Handler,它会在协议层选择Excporter后选择Invoker,进而执行Filter与invoker,最终执行请求服务实现类方法。 
其中NIO框架的通信管道Channel也被Dubbo封装了,Channel直接触发事件并执行Handler,有ChannelNettyChannelHeaderExchangerChannel,通信管道Channel在有客户端连接Server时触发创建并封装成NettyChannel,再由HeaderExchangerHandler创建HeaderExchangerChannel,负责请求-响应模式的处理,注意NettyChannel其实也是个Handler,而HeaderExchangerChannel只是个Channel,是Handler的类说明它也具体Handler特性。 
另外,还初始化一些参数,有AllChannelHandler的线程池模型、NettyServer的codesc解码编码方式,timeout超时时间,connectTimeout连接超时时时间,accepts提供者最大接受连接数设置,ildeTimeout时间设置,此处的参数得到都是为了后期可能重置准备。还有消息的序列化与发序列化工作全在NettyCodecAdapter中发起完成。 
至此,分析了Dubbo初始化remote层所有初始化流程,还有,对于Transporters也是个门面类,内部调用网络传输层的逻辑,如:NettyTransporter、MinaTransporter。 
附上连接过程:(当有客户端连接Server时) 
0.NettyHandler.connected() 
1.NettyServer.connected() 
2.MultiMessageHandler.connected() 
3.HeartbeatHandler.connected() 
4.AllChannelHandler.connected() 
5.DecodeHandler.connected() 
6.HaderExchangeHandler.connected() 
7.requestHandler.connected() 
8.执行服务的onconnect事件的监听方法 
下面是Handler、Server、Channel的结构图: 
 
 
l) 将初始化后的Server返回协议层 
i. 创建好的Server返回,此Server对象很重,缓存 
m) 协议层将暴露后的Exporter返回给注册中心协议层,最后返回给ServiceConfig进行缓存 
i. 协议层成功返回Exporter给注册中心协议层,标志着服务暴露完毕,接下来是与注册中心的操作,逻辑上看,注册中心负责服务的注册与发现,所有提供者向注册中心注册服务,并订阅重载配置,所有消费者向注册中心注册服务,并订阅服务,消费者通过注册中心自动发现所有服务提供者,且本地缓存提供者类表,注册中心宕机也不影响消费者调用;程序上看,注册中心也是普通的RPC服务,所有消费者、提供者与注册中心都是长连接。Dubbo目前注册中心服务有MulticastRegistry、ZookeeperRegistry等,关于注册中心的详细介绍待后期奉上。 
ii. RegistryProtocol.getRegistry(); 
iii. 得到具体注册中心服务且连接注册中心,此时提供者作为消费者引用注册中心核心服务RegistryService 
iv. Registry.register(url); 
v. 调用远端注册中心的register()方法进行服务注册,且若有消费者订阅此服务,则推送消息让消费者引用此服务,注册中心缓存了所有提供者注册的服务以供消费者发现。 
vi. Registry.subscribe(url,listener); 
vii. 提供者向注册中心订阅所有注册服务的覆盖配置,当注册中心有此服务的覆盖配置注册进来时,推送消息给提供者,让它重新暴露服务,这由管理页面完成。 
viii. 返回暴露后的Exporter给上层ServiceConfig进行缓存,便于后期撤销暴露。 
ix. 总结:Exporter的创建、Server的创建、服务的注册与订阅,这些逻辑都是分离的,它们是通过URL联系在一起的。一般情况下,同JVM同协议下的服务共享同一个Server,且消费端的引用这些服务的也可共享一个Client,从而实现多个服务共享同一个通道进行通信,且是基于长连接下,减少了通信的握手次数,高效率通信,另外,远程调用层与信息交换层及网络传输层是Dubbo的核心。 
二、 Dubbo消费者初始化过程分析: 
a) Dubbo解析xml,初始化所有注入的引用服务及init=true引用服务 
b) 所有dubbo引用服务均由ReferenceConfig入口进行服务的引用 
i. ReferenceConfig.get(); ReferenceConfig.init(); 
ii. 消费者最终的得到的是服务的代理,在创建代理前初始化所有配置信息,此过程是线程安全的。引用服务的大致过程是由远程调用创建消费者端Invoker,再由ReferenceConfig创建代理返回,此过程的核心是创建消费端的Invoker。在引用服务前,ReferenceConfig先需要判断是否是引用本地服务injvm、是否是点对点直连、是否是通过注册中心连接,判断之后进行最重要的一步:服务的引用。 
c) 进入远程调用层进行服务的引用 
i. Protocol.refer(interface,url); 
ii. 此方法返回的是个集群invoker,若有多个提供者提供服务,Dubbo将多个服务Invoker伪装成一个集群Invoker,且这个集群Invoker内部的多个invoker,由Directory完成,Directory与List类似,但由不同,当提供者推送消息过来后,Directory可以动态变化,还可以通过Router路由提供者及LoadBalance根据负载均衡算法选中一个提供者,所以当上层进行Invoker调用时,会是:Cluster.invoke()Directory.list()Router.route()LoadBalance.select()invoke.invoke();另外,在invoker转成proxy时,Dubbo对代理也有装饰,如Stub,这个可以实现在真正调用invoker代理前可以做一些事情,类似AOP功能。上面是大致说明以下消费者引用服务的过程,下面详细说明。 
d) 首先进入注册中心远程调用层RegistryProtocol,且它也经过了ProtocolFilterWrapper、ProtocolListenerWrapper装饰,功能增强 
i. RegistryProtocol.refer(); 
ii. 同提供者相同,消费者也首先需要连接注册中心,即引用注册中心这个特殊的RPC服务,并通过注册中心进行服务的订阅与注册。然后判断引用是否是注册中心RegistryService服务,若是绕过注册中心与集群等直接返回刚得到注册中心服务即可,若不是,则说明是普通服务,则需要进入注册中心与集群下面的逻辑。在选择集群策略前,先需要判断引用服务是否需要合并不同实现的返回结果,及是否配置group="*" merger="true" (配置详细说明再说),若配置了,则选择默认的分组聚合集群策略,若没配置,则选择配置的集群策略cluster="failback"或默认策略。下面进入服务引用的重点逻辑分析。 
e) 服务引用,且向上层返回 
i. RegistryProtocol.doRefer(cluster,registry,type,url); 
ii. 消费端引用服务主要逻辑部分,服务引用大致逻辑是组合url、type创建目录类Directory,此类非常重要,它的功能很复杂,可以看成是NotifyListener服务通知监听器、可以看成Protocol、Registry的聚合类、可以看成一个消费端的List,但它又不同于List,他可以随着注册中心的消息推送而动态变化服务的Invoker数,时刻监听着提供者的变化,典型观察者模式的使用,它封装了所有服务真正引用逻辑、覆盖配置、路由规则等逻辑,初始化时只需要向注册中心发起订阅请求,其他逻辑均是异步的处理,包括服务引用等,且对上层Cluster层是透明的,ResitryProtocol将多个Invoker伪装成一个Invoker返回给上层来转化成代理,上层甚至不知道这是个集群Invoker,在伪装成一个Invoker时,Cluster也被装饰了,增强了Mock功能,这个详细暂不在此处说明。顶层得到伪装后的Invoker,当调用时,会根据初始化时的集群策略、负载均衡策略、路由策略进行选择调用某个Invoker。下面看看Directory的初始化与服务异步引用的分析及集群的处理步骤。 
f) 目录类Directory初始化、服务订阅、集群伪装 
i. 在RegistryProtocol中会根据url、type、protocol、registry初始化Directory,Directory功能非常强大,此处暂不说明详细功能。订阅服务前,注册中心首先注册服务,便于后期的监控中心提取数据,通过Directory订阅服务directory.subscribe(url),当有服务提供时,注册中心会推送服务消息给消费者,消费者再进行服务的引用,此处暂不详细说明注册中心的处理逻辑。下面是Directory中的代码块  
,接下来服务的引用与变更全部由Directory异步完成,集群策略会将Directory伪装成一个invoker, cluster.join(directory),此代码就是伪装逻辑,Dubbo有很多集群策略,可以配置切换,具体集群逻辑暂不属于这里,后期说明。RegistryProtocol再将伪装后的Invoker返回给上层ReferenceConfig用来创建代理,所以消费者端的对象引用的远程服务其实引用的都是个代理,真正逻辑只有在调用时触发,包括Stub、Proxy、Mock、Cluster、Router、LoadBalance、Filter、Invoker、NIO框架底层通信。 
g) Directory服务引用、NIO框架初始化 
i. 注册中心接收到消费端发送的订阅请求后,会根据提供者注册服务的列表,推送服务消息给消费者,此处的逻辑不同的注册中心实现逻辑不通,详细暂不说明,消费者端接受到注册中心发来的提供者列表后,进行服务的引用,触发Directory监听器的可以是订阅请求、覆盖策略消息、路由策略消息(后两者由管理页面设置),接下面就是服务的引用过程,这逻辑都隐藏在Directory中。 
invoker = new InvokerDelegete<T>(protocol.refer(serviceType, url), url, providerUrl); 
h) 真正进入远程调用层,进行服务的引用与NIO框架的初始化 
i. DubboProtocol.refer(type,url); 
ii. 同服务的暴露逻辑相同,服务的引用步骤也分为两步,一是消费端Invoker的创建,如DubboInvoker,而是NIO框架的Client创建,这两步骤虽然是也是分离的,但它们不是通过URL联系在一起的,而是Invoker聚合了Client,当调用Invoker时,底层实际上是调用Client逻辑进行底层通信。 
iii. new DubboInvoker<T>(serviceType, url, getClients(url), invokers); 
iv. Invoker创建,可以看出Invoker聚合了Client,此Invoker对象很重,远程调用层进行了缓存invokers.add(invoker);。 
v. getClients(url) 
vi. 此代码负责NIO框架Client创建及初始化,和提供者初始化相似,消费者的初始化也基本上围绕着Client、Handler、Channel对象的创建与不断装饰的过程,不同的是消费者底层是与提供者Server建立连接,此过程在remote层下完成,remote层可分为消息交换层与网路传输层即Exchanger与Transporter层,还有,我们在说提供者初始化时,说过同个JVM中相同协议的服务共享一个Server,同样在消费者初始化时,引用同一个提供者的所有服务可以共享一个Client进行通信,这也就实现了Server-Client在同一个通道中进行通信,实现长连接的高效通信,但是在服务请求数据量比较大时或请求数比较多时,可以设置每服务每连接或每服务多连接可以提高通信效率,具体是通过消费者方connections=2设置连接数。所有消费者端Client有两种,一种是共享型Client,一种是创建型Client,当然共享型Client属于创建型Client一部分,下面具体说说这两种Client创建的细节,也是服务引用的重要细节。 
 
vii. getSharedClient(url) 
viii. 此为创建共享型Client,共享型Client是指消费者引用同一提供者的服务时,使用同一个Client来提高通信效率,所以对于消费者来说,它连接的每个提供者都需要创建一个创建型Client,其他来自相同提供者的服务引用即可共享此Client,关于创建型Client的创建下面再说。对于共享型Client虽然可以提高通信效率,但会带来一个问题,就是如果所有共享一个Client的服务中的某个服务close了Client会导致其他服务都不能继续通信,这是个安全性问题,Dubbo的解决方案是通过计数的方式来控制这个安全问题,并在共享Client真正关闭后创建一个懒加载的幽灵Client,以备特殊情况使用(此处不说非常细节)。 
 
ix. initClient(url) 
x. 此为创建创建型Client,也是消费者端服务引用最核心的地方,封装了服务引用中remote层初始化的所有逻辑,与提供者端类似,就是Client、Handler、Channel的创建与不断装饰的过程,在说Client创建细节前,先说说Client类型,与其他产品一样,Dubbo中也有懒加载的概念,即Client分为正常马上连接的Client与懒加载的Client,懒加载的Client是个Client代理,当消费者真正调用服务时,才会去初始化Client、Handler、Channel,也就是才会与Server建立连接。 
xi. Client、Handler、Channel初始化 
xii. 此步骤是服务引用的核心的核心,逻辑完全封装在Protocol远程调用层,对于上层是完全透明的。在进行创建前,Dubbo默认开启remote层的心跳机制与禁止BIO通信,心跳机制是提供者与消费者之间的心跳通信,主要是防止通信异常,如提供者宕机,消费者自动重连提供者。下面重点是服务引用即Client的创建,此过程完成由Directory发起,有关于Directory的细节,后期会专栏介绍此类。同提供者类似,服务引用无非也就是初始化信息交换层与网络传输层即Exchanger与Transporter,且分别由门面类Exchangers与Transporters发起,Transporter返回的Client再经过Exchanger封装装饰后完成初始化并返回给上层Protocol。 
 
详细是:远程调用层Protocol传入原始Handler,后续将是此Handler不断装饰的过程,下面是Handler与Server初始化过程:requestHandlerHeaderExchangerHandlerDecodeHandlerAllChannelHandlerHeartbeatHandlerMultiMessageHandlerNettyClient[NettyHandler、NettyCodecAdapter]HeaderExchanerClient 此处remote最终返回包装了NettyClient的HeaderExchangerClient到Protocol层,与提供者相比,消费者有以下异同: 
1. 初始化的大致逻辑相同 
2. 提供者暴露服务是绑定IP,而消费者是与提供者建立连接 
3. 与NettyServer相同,NettyClient也是个Handler 
4. 与HeaderExchangerServer不同,HeaderExchangerClient也是个Channel,这点一定注意 
其中各个Handler、Client与提供者那里基本类似,这里不重复说明它们的功能,对于底层无非就是NIO框架的初始化,与Server建立连接。前面也说过了,返回到protocol层的Client被封装成消费端的Invoker,再返回给重要的Directory,那里动态引用了该服务所有与提供者建立后的Invoker,而真正protocol返回给上层的Invoker是封转了Directory的集群伪装Invoker,当真正调用时,才会根据集群策略、路由策略、负载均衡策略从Directory选择一个Invoker进行调用即Client与Server进行通信,所以Directory在Dubbo占有非常重要的位置,它的功能很复杂。 
下面再说说消费者发起的Channel的创建: 
消费者的NIO框架初始化是有一步很重要,就是与提供者建立连接即Channel的创建,NIO框架采用的双向通讯的通道Channel,而Dubbo对Channel也做了封装,封装过程是ChannelNettyChannelHeaderExchangerChannel,还有一点非常重要,查看Dubbo源码可知,NettyChannel其实也是个Handler,而HeaderExchangerChannel只是个Channel。在消费者端发起连接时,提供者端与消费者端的NettyHandler将被触发,将执行一系列的Handler或Server逻辑,在NettyHandler触发连接时,执行channelConnected创建Channel,Dubbo对NIO的Channel进行了包装,实现创建NettyChannel,它封装了NIO的Channel与包装Handler的NettyClient,值得注意的所有的事件都由NIO的Channel触发,如:写事件、读事件、连接事件、断开连接事件、出现异常事件。在Handler执行到HeaderExchangerHandler时,创建HeaderExchangerChannel,并且封装从Handler创建并传下来的NettyChannel。其中HeaderExchangerClient构造中有下面这段代码: 

HeaderExchangerClient也有个封装了NettyClient的HeaderExchangerChannel,注意这个,因为这是消费者发起请求是底层通信的入口。 
下面给出Client与Channel结构图,Handler图上面已有: 
 
总结:所有的初始化,都是为了消费者与提供者之间的通信做准备,下面请结合初始化过程,重点查看通信的过程。再说说,这里的服务引用过程全部隐藏在Directory中,对上层完全透明,只有注册中心触发Directory进而触发服务引用或变更,而上层来说,它接受到的是集群伪装后的Invoker,然后再将Invoker转成Proxy,所以Spring中引用的是一个代理,只有消费者发起调用时,才有一系列的集群、路由、负载均衡逻辑,主要调用逻辑请看下面。 
补充:和提供者暴露服务有暴露监听器一样ExporterListener,消费者端有引用服务的监听器InvokerListener,在服务引用时执行。 
三、 Dubbo消费者--提供者请求过程与响应过程: 
a) 大致过程 
i. 消费者发送请求提供者处理消费者接受请求 
ii. 在提供者与消费者端都初始化完毕时,提供者对外暴露的是Expoter、消费者对外提供的是Proxy,接下来就是从Proxy的执行到Exporter执行的过程,其中Dubbo中的会话域Invocation承载着提供者与消费者端的消息传递,并在每个线程栈中使用。下面是大致处理逻辑: 
----------------------------------1.消费者发起请求------------------------------------------- 
1. testService.hello();//消费者端呈现层引用的远程服务,这其实就是个代理 
2. testServiceSub.hello();//proxy代理被Sub包装了,增强Sub功能,类似AOP 
3. testServiceProxy.hello();//消费者端Invoker代理 
4. InvokerInvocationHandler.invoker();//由代理类执行的invocationHandler 
5. MockClusterInvoker.invoke();//集群对集群Invoker进行的包装,Mock功能 
6. ClusterInvoker.invoke();//执行集群伪装的Invoker 
7. Directory.list();//查找伪装在集群后面的所有Invoker 
8. Router.route();//通过路由规则策略从list中选择一些Invoker 
9. LoadBalance.select();//通过负载均衡选策略选中一个Invoker执行 
10. Filter.invoke();//执行所有消费者端Filter 
11. Invoker.invoke();//执行消费者端的Invoker即DubboInvoker 
12. HeaderExchangerClient.request();//信息交换Client执行请求,其中封装了NettyClient、HeaderExchangerChannel 
13. HeaderExchangerChannel.request();//此类封装了NettyClient,信息交换通道创建Request执行请求,并创建DefaultFuture返回 
14. NettyClient父类AbstractClient.send();//消费者端Client执行请求 
15. NettyChannel.send();//Netty通道执行请求发送 
16. Channel.write();//NIO框架通知执行写操作,并触发Handler 
17. NettyHanlder.writeRequested();//执行NIO框架的顶级Handler 
18. NettyCodecAdapter.encode();//执行NIO框架的编码逻辑,以下执行Handler 
19. NettyClient父类AbstractPeer.send();//执行装饰了Handler的NettyCient 
20. MultiMessageHandler.send();//多消息处理Handler 
21. HeartbeatHandler.send();//心跳处理Handler 
22. AllChannelHandler.send();//消息派发器Handler 
23. DecodeHandler.send();//编码Handler 
24. HeaderExchangerHandler.send();//信息交换Handler 
25. requestHandler父类ChannelHandlerAdapter.send();//最后执行Handler,以上Handler的执行在消费者端是没有意义,因为Channel.write ()执行时,提供者端已经收到消息了,也正在处理了,详细逻辑后面再说,这里为了完整性才这样写(以上是消费者请求大致过程,下面是提供者接受请求后处理并响应消费者过程)。 
------------------------------2.提供者处理并响应请求-------------------------------------- 
26. NettyCodecAdapter.messageReceived();//提供者通过NIO框架通信并接受到消费者发送的信息,当然,这里屏蔽了所有NIO框架的逻辑,也屏蔽了所有编码解码与序列化反序列化的逻辑 
27. NettyHandler.messageReceived();//提供者端的NIO顶级Handler处理 
28. NettyServer.received();//NIO框架的Server接受请求信息 
29. MultiMessageHandler.received ();//多消息处理Handler 
30. HeartbeatHandler.received ();//心跳处理Handler 
31. AllChannelHandler.received ();//消息派发器Handler 
32. DecodeHandler.received ();//编码Handler 
33. HeaderExchangerHandler.received ();//信息交换Handler,请求-响应模式 
34. requestHandler.reply();//执行与Exporter交接的最初Handler 
35. getInvoker();//先得到提供者端的Exporter再得到相应的提供者端Invoker 
36. Filter.invoke();//执行所有提供者端的Filter,所有附加逻辑均由此完成 
37. AbstractInvoker.invoke();//执行封装了服务实现类的原始Invoker 
38. testServiceImple.hello();//执行服务实现类逻辑 
39. NettyChannel.send();//HeaderExchangerHandler得到执行结果Response再返回给消费者,此代码由HeaderExchangerHandler发起 
40. Channel.write ();//NIO框架通知执行写操作,并触发Handler 
41. NettyHanlder.writeRequested();//执行NIO框架的顶级Handler 
42. NettyCodecAdapter.encode();//执行NIO框架的编码逻辑,以下执行Handler 
43. NettyServer父类AbstractPeer.send();//执行装饰了Handler的NettyServer 
44. MultiMessageHandler.send();//多消息处理Handler 
45. HeartbeatHandler.send();//心跳处理Handler 
46. AllChannelHandler.send();//消息派发器Handler 
47. DecodeHandler.send();//编码Handler 
48. HeaderExchangerHandler.send();//信息交换Handler 
49. requestHandler父类ChannelHandlerAdapter.send();//最后执行Handler,以上Handler的执行在提供者端也是是没有意义,因为Channel.write ()执行时,消费者端已经收到响应消息了,也正在处理了,详细逻辑后面再说,这里为了完整性才这样写(以上是消费者请求与提供者接受请求并响应大致过程,下面是消费者接受到提供者响应后处理过程)。 
----------------------------------3.消费者接受响应------------------------------------------ 
50. NettyCodecAdapter.messageReceived();//提供者通过NIO框架通信并接受提供者发送过来的响应 
51. NettyHandler.messageReceived();//消费者端的NIO顶级Handler处理 
52. NettyClient.received();//NIO框架的Client接受响应信息 
53. MultiMessageHandler.received ();//多消息处理Handler 
54. HeartbeatHandler.received ();//心跳处理Handler 
55. AllChannelHandler.received ();//消息派发器Handler 
56. DecodeHandler.received ();//编码Handler 
57. HeaderExchangerHandler.received ();//信息交换Handler,请求-响应模式 
58. DefaultFuture.received();//设置response到消费者请求的Future中,以供消费者通过DefaultFuture.get()取得提供者的响应,此为同步转异步重要一步,且请求超时也由DefaultFuture控制。 
-----------------------------------4.阻塞或异步断点--------------------------------------- 
59. Filter.invoke();//消费者异步得到响应后,DubboInvoker继续执行,从而Filter继续执行,从而返回结果给消费者。 
60. InvokerInvocationHandler.invoker();//执行invocationHandler后续代码 
61. testServiceProxy.hello();//消费者端Invoker代理后续代码 
62. testServiceSub.hello();//执行后续代码 
63. testService.hello();//执行后续代码 
64. 呈现结果给消费者客户端 
总结:消费者端的DubboInvoker发起请求后,后续的逻辑可以说是异步的或是指定超时时间内阻塞的,直到得到响应结果后,继续执行DubboInvoker中逻辑。对于异步请求时,消费者得到Future,其余逻辑均是异步的。以上主要核心逻辑,对于附加功能,大部分由Filter增强完成。消费者还可以通过设置async、sent、return来调整处理逻辑,async指异步还是同步请求,sent指是否等待请求消息发出即阻塞等待是否成功发出请求、return指是否忽略返回值即但方向通信,一般异步时使用以减少Future对象的创建和管理成本。

40个Java多线程问题总结

标签:JAVA 发布于 2016-12-13 10:09:00

40个问题汇总


1、多线程有什么用?


一个可能在很多人看来很扯淡的一个问题:我会用多线程就好了,还管它有什么用?在我看来,这个回答更扯淡。所谓"知其然知其所以然","会用"只是"知其然","为什么用"才是"知其所以然",只有达到"知其然知其所以然"的程度才可以说是把一个知识点运用自如。OK,下面说说我对这个问题的看法:


(1)发挥多核CPU的优势


随着工业的进步,现在的笔记本、台式机乃至商用的应用服务器至少也都是双核的,4核、8核甚至16核的也都不少见,如果是单线程的程序,那么在双核CPU上就浪费了50%,在4核CPU上就浪费了75%。单核CPU上所谓的"多线程"那是假的多线程,同一时间处理器只会处理一段逻辑,只不过线程之间切换得比较快,看着像多个线程"同时"运行罢了。多核CPU上的多线程才是真正的多线程,它能让你的多段逻辑同时工作,多线程,可以真正发挥出多核CPU的优势来,达到充分利用CPU的目的。


(2)防止阻塞


从程序运行效率的角度来看,单核CPU不但不会发挥出多线程的优势,反而会因为在单核CPU上运行多线程导致线程上下文的切换,而降低程序整体的效率。但是单核CPU我们还是要应用多线程,就是为了防止阻塞。试想,如果单核CPU使用单线程,那么只要这个线程阻塞了,比方说远程读取某个数据吧,对端迟迟未返回又没有设置超时时间,那么你的整个程序在数据返回回来之前就停止运行了。多线程可以防止这个问题,多条线程同时运行,哪怕一条线程的代码执行读取数据阻塞,也不会影响其它任务的执行。


(3)便于建模


这是另外一个没有这么明显的优点了。假设有一个大的任务A,单线程编程,那么就要考虑很多,建立整个程序模型比较麻烦。但是如果把这个大的任务A分解成几个小任务,任务B、任务C、任务D,分别建立程序模型,并通过多线程分别运行这几个任务,那就简单很多了。


 


2、创建线程的方式


比较常见的一个问题了,一般就是两种:


(1)继承Thread类


(2)实现Runnable接口


至于哪个好,不用说肯定是后者好,因为实现接口的方式比继承类的方式更灵活,也能减少程序之间的耦合度,面向接口编程也是设计模式6大原则的核心。


 


3、start()方法和run()方法的区别


只有调用了start()方法,才会表现出多线程的特性,不同线程的run()方法里面的代码交替执行。如果只是调用run()方法,那么代码还是同步执行的,必须等待一个线程的run()方法里面的代码全部执行完毕之后,另外一个线程才可以执行其run()方法里面的代码。


 


4、Runnable接口和Callable接口的区别


有点深的问题了,也看出一个Java程序员学习知识的广度。


Runnable接口中的run()方法的返回值是void,它做的事情只是纯粹地去执行run()方法中的代码而已;Callable接口中的call()方法是有返回值的,是一个泛型,和Future、FutureTask配合可以用来获取异步执行的结果。


这其实是很有用的一个特性,因为多线程相比单线程更难、更复杂的一个重要原因就是因为多线程充满着未知性,某条线程是否执行了?某条线程执行了多久?某条线程执行的时候我们期望的数据是否已经赋值完毕?无法得知,我们能做的只是等待这条多线程的任务执行完毕而已。而Callable+Future/FutureTask却可以获取多线程运行的结果,可以在等待时间太长没获取到需要的数据的情况下取消该线程的任务,真的是非常有用。


 


5、CyclicBarrier和CountDownLatch的区别


两个看上去有点像的类,都在java.util.concurrent下,都可以用来表示代码运行到某个点上,二者的区别在于:


(1)CyclicBarrier的某个线程运行到某个点上之后,该线程即停止运行,直到所有的线程都到达了这个点,所有线程才重新运行;CountDownLatch则不是,某线程运行到某个点上之后,只是给某个数值-1而已,该线程继续运行


(2)CyclicBarrier只能唤起一个任务,CountDownLatch可以唤起多个任务


(3)CyclicBarrier可重用,CountDownLatch不可重用,计数值为0该CountDownLatch就不可再用了


 


6、volatile关键字的作用


一个非常重要的问题,是每个学习、应用多线程的Java程序员都必须掌握的。理解volatile关键字的作用的前提是要理解Java内存模型,这里就不讲Java内存模型了,可以参见第31点,volatile关键字的作用主要有两个:


(1)多线程主要围绕可见性和原子性两个特性而展开,使用volatile关键字修饰的变量,保证了其在多线程之间的可见性,即每次读取到volatile变量,一定是最新的数据


(2)代码底层执行不像我们看到的高级语言----Java程序这么简单,它的执行是Java代码-->字节码-->根据字节码执行对应的C/C++代码-->C/C++代码被编译成汇编语言-->和硬件电路交互,现实中,为了获取更好的性能JVM可能会对指令进行重排序,多线程下可能会出现一些意想不到的问题。使用volatile则会对禁止语义重排序,当然这也一定程度上降低了代码执行效率


从实践角度而言,volatile的一个重要作用就是和CAS结合,保证了原子性,详细的可以参见java.util.concurrent.atomic包下的类,比如AtomicInteger。


 


7、什么是线程安全


又是一个理论的问题,各式各样的答案有很多,我给出一个个人认为解释地最好的:如果你的代码在多线程下执行和在单线程下执行永远都能获得一样的结果,那么你的代码就是线程安全的。


这个问题有值得一提的地方,就是线程安全也是有几个级别的:


(1)不可变


像String、Integer、Long这些,都是final类型的类,任何一个线程都改变不了它们的值,要改变除非新创建一个,因此这些不可变对象不需要任何同步手段就可以直接在多线程环境下使用


(2)绝对线程安全


不管运行时环境如何,调用者都不需要额外的同步措施。要做到这一点通常需要付出许多额外的代价,Java中标注自己是线程安全的类,实际上绝大多数都不是线程安全的,不过绝对线程安全的类,Java中也有,比方说CopyOnWriteArrayList、CopyOnWriteArraySet


(3)相对线程安全


相对线程安全也就是我们通常意义上所说的线程安全,像Vector这种,add、remove方法都是原子操作,不会被打断,但也仅限于此,如果有个线程在遍历某个Vector、有个线程同时在add这个Vector,99%的情况下都会出现ConcurrentModificationException,也就是fail-fast机制。


(4)线程非安全


这个就没什么好说的了,ArrayList、LinkedList、HashMap等都是线程非安全的类


 


8、Java中如何获取到线程dump文件


死循环、死锁、阻塞、页面打开慢等问题,打线程dump是最好的解决问题的途径。所谓线程dump也就是线程堆栈,获取到线程堆栈有两步:


(1)获取到线程的pid,可以通过使用jps命令,在Linux环境下还可以使用ps -ef | grep java


(2)打印线程堆栈,可以通过使用jstack pid命令,在Linux环境下还可以使用kill -3 pid


另外提一点,Thread类提供了一个getStackTrace()方法也可以用于获取线程堆栈。这是一个实例方法,因此此方法是和具体线程实例绑定的,每次获取获取到的是具体某个线程当前运行的堆栈,


 


9、一个线程如果出现了运行时异常会怎么样


如果这个异常没有被捕获的话,这个线程就停止执行了。另外重要的一点是:如果这个线程持有某个某个对象的监视器,那么这个对象监视器会被立即释放


 


10、如何在两个线程之间共享数据


通过在线程之间共享对象就可以了,然后通过wait/notify/notifyAll、await/signal/signalAll进行唤起和等待,比方说阻塞队列BlockingQueue就是为线程之间共享数据而设计的


 


11、sleep方法和wait方法有什么区别 


这个问题常问,sleep方法和wait方法都可以用来放弃CPU一定的时间,不同点在于如果线程持有某个对象的监视器,sleep方法不会放弃这个对象的监视器,wait方法会放弃这个对象的监视器


 


12、生产者消费者模型的作用是什么


这个问题很理论,但是很重要:


(1)通过平衡生产者的生产能力和消费者的消费能力来提升整个系统的运行效率,这是生产者消费者模型最重要的作用


(2)解耦,这是生产者消费者模型附带的作用,解耦意味着生产者和消费者之间的联系少,联系越少越可以独自发展而不需要收到相互的制约


 


13、ThreadLocal有什么用


简单说ThreadLocal就是一种以空间换时间的做法,在每个Thread里面维护了一个以开地址法实现的ThreadLocal.ThreadLocalMap,把数据进行隔离,数据不共享,自然就没有线程安全方面的问题了


 


14、为什么wait()方法和notify()/notifyAll()方法要在同步块中被调用


这是JDK强制的,wait()方法和notify()/notifyAll()方法在调用前都必须先获得对象的锁


 


15、wait()方法和notify()/notifyAll()方法在放弃对象监视器时有什么区别


wait()方法和notify()/notifyAll()方法在放弃对象监视器的时候的区别在于:wait()方法立即释放对象监视器,notify()/notifyAll()方法则会等待线程剩余代码执行完毕才会放弃对象监视器。


 


16、为什么要使用线程池


避免频繁地创建和销毁线程,达到线程对象的重用。另外,使用线程池还可以根据项目灵活地控制并发的数目。


 


17、怎么检测一个线程是否持有对象监视器


我也是在网上看到一道多线程面试题才知道有方法可以判断某个线程是否持有对象监视器:Thread类提供了一个holdsLock(Object obj)方法,当且仅当对象obj的监视器被某条线程持有的时候才会返回true,注意这是一个static方法,这意味着"某条线程"指的是当前线程。


 


18、synchronized和ReentrantLock的区别


synchronized是和if、else、for、while一样的关键字,ReentrantLock是类,这是二者的本质区别。既然ReentrantLock是类,那么它就提供了比synchronized更多更灵活的特性,可以被继承、可以有方法、可以有各种各样的类变量,ReentrantLock比synchronized的扩展性体现在几点上:


(1)ReentrantLock可以对获取锁的等待时间进行设置,这样就避免了死锁


(2)ReentrantLock可以获取各种锁的信息


(3)ReentrantLock可以灵活地实现多路通知


另外,二者的锁机制其实也是不一样的。ReentrantLock底层调用的是Unsafe的park方法加锁,synchronized操作的应该是对象头中mark word,这点我不能确定。


 


19、ConcurrentHashMap的并发度是什么


ConcurrentHashMap的并发度就是segment的大小,默认为16,这意味着最多同时可以有16条线程操作ConcurrentHashMap,这也是ConcurrentHashMap对Hashtable的最大优势,任何情况下,Hashtable能同时有两条线程获取Hashtable中的数据吗?


 


20、ReadWriteLock是什么


首先明确一下,不是说ReentrantLock不好,只是ReentrantLock某些时候有局限。如果使用ReentrantLock,可能本身是为了防止线程A在写数据、线程B在读数据造成的数据不一致,但这样,如果线程C在读数据、线程D也在读数据,读数据是不会改变数据的,没有必要加锁,但是还是加锁了,降低了程序的性能。


因为这个,才诞生了读写锁ReadWriteLock。ReadWriteLock是一个读写锁接口,ReentrantReadWriteLock是ReadWriteLock接口的一个具体实现,实现了读写的分离,读锁是共享的,写锁是独占的,读和读之间不会互斥,读和写、写和读、写和写之间才会互斥,提升了读写的性能。


 


21、FutureTask是什么


这个其实前面有提到过,FutureTask表示一个异步运算的任务。FutureTask里面可以传入一个Callable的具体实现类,可以对这个异步运算的任务的结果进行等待获取、判断是否已经完成、取消任务等操作。当然,由于FutureTask也是Runnable接口的实现类,所以FutureTask也可以放入线程池中。


 


22、Linux环境下如何查找哪个线程使用CPU最长


这是一个比较偏实践的问题,这种问题我觉得挺有意义的。可以这么做:


(1)获取项目的pid,jps或者ps -ef | grep java,这个前面有讲过


(2)top -H -p pid,顺序不能改变


这样就可以打印出当前的项目,每条线程占用CPU时间的百分比。注意这里打出的是LWP,也就是操作系统原生线程的线程号,我笔记本山没有部署Linux环境下的Java工程,因此没有办法截图演示,网友朋友们如果公司是使用Linux环境部署项目的话,可以尝试一下。


使用"top -H -p pid"+"jps pid"可以很容易地找到某条占用CPU高的线程的线程堆栈,从而定位占用CPU高的原因,一般是因为不当的代码操作导致了死循环。


最后提一点,"top -H -p pid"打出来的LWP是十进制的,"jps pid"打出来的本地线程号是十六进制的,转换一下,就能定位到占用CPU高的线程的当前线程堆栈了。


 


23、Java编程写一个会导致死锁的程序


第一次看到这个题目,觉得这是一个非常好的问题。很多人都知道死锁是怎么一回事儿:线程A和线程B相互等待对方持有的锁导致程序无限死循环下去。当然也仅限于此了,问一下怎么写一个死锁的程序就不知道了,这种情况说白了就是不懂什么是死锁,懂一个理论就完事儿了,实践中碰到死锁的问题基本上是看不出来的。


真正理解什么是死锁,这个问题其实不难,几个步骤:


(1)两个线程里面分别持有两个Object对象:lock1和lock2。这两个lock作为同步代码块的锁;


(2)线程1的run()方法中同步代码块先获取lock1的对象锁,Thread.sleep(xxx),时间不需要太多,50毫秒差不多了,然后接着获取lock2的对象锁。这么做主要是为了防止线程1启动一下子就连续获得了lock1和lock2两个对象的对象锁


(3)线程2的run)(方法中同步代码块先获取lock2的对象锁,接着获取lock1的对象锁,当然这时lock1的对象锁已经被线程1锁持有,线程2肯定是要等待线程1释放lock1的对象锁的


这样,线程1"睡觉"睡完,线程2已经获取了lock2的对象锁了,线程1此时尝试获取lock2的对象锁,便被阻塞,此时一个死锁就形成了。代码就不写了,占的篇幅有点多,Java多线程7:死锁这篇文章里面有,就是上面步骤的代码实现。


 


24、怎么唤醒一个阻塞的线程


如果线程是因为调用了wait()、sleep()或者join()方法而导致的阻塞,可以中断线程,并且通过抛出InterruptedException来唤醒它;如果线程遇到了IO阻塞,无能为力,因为IO是操作系统实现的,Java代码并没有办法直接接触到操作系统。


 


25、不可变对象对多线程有什么帮助


前面有提到过的一个问题,不可变对象保证了对象的内存可见性,对不可变对象的读取不需要进行额外的同步手段,提升了代码执行效率。


 


26、什么是多线程的上下文切换


多线程的上下文切换是指CPU控制权由一个已经正在运行的线程切换到另外一个就绪并等待获取CPU执行权的线程的过程。


 


27、如果你提交任务时,线程池队列已满,这时会发生什么


如果你使用的LinkedBlockingQueue,也就是无界队列的话,没关系,继续添加任务到阻塞队列中等待执行,因为LinkedBlockingQueue可以近乎认为是一个无穷大的队列,可以无限存放任务;如果你使用的是有界队列比方说ArrayBlockingQueue的话,任务首先会被添加到ArrayBlockingQueue中,ArrayBlockingQueue满了,则会使用拒绝策略RejectedExecutionHandler处理满了的任务,默认是AbortPolicy。


 


28、Java中用到的线程调度算法是什么


抢占式。一个线程用完CPU之后,操作系统会根据线程优先级、线程饥饿情况等数据算出一个总的优先级并分配下一个时间片给某个线程执行。


 


29、Thread.sleep(0)的作用是什么


这个问题和上面那个问题是相关的,我就连在一起了。由于Java采用抢占式的线程调度算法,因此可能会出现某条线程常常获取到CPU控制权的情况,为了让某些优先级比较低的线程也能获取到CPU控制权,可以使用Thread.sleep(0)手动触发一次操作系统分配时间片的操作,这也是平衡CPU控制权的一种操作。


 


30、什么是自旋


很多synchronized里面的代码只是一些很简单的代码,执行时间非常快,此时等待的线程都加锁可能是一种不太值得的操作,因为线程阻塞涉及到用户态和内核态切换的问题。既然synchronized里面的代码执行得非常快,不妨让等待锁的线程不要被阻塞,而是在synchronized的边界做忙循环,这就是自旋。如果做了多次忙循环发现还没有获得锁,再阻塞,这样可能是一种更好的策略。


 


31、什么是Java内存模型


Java内存模型定义了一种多线程访问Java内存的规范。Java内存模型要完整讲不是这里几句话能说清楚的,我简单总结一下Java内存模型的几部分内容:


(1)Java内存模型将内存分为了主内存和工作内存。类的状态,也就是类之间共享的变量,是存储在主内存中的,每次Java线程用到这些主内存中的变量的时候,会读一次主内存中的变量,并让这些内存在自己的工作内存中有一份拷贝,运行自己线程代码的时候,用到这些变量,操作的都是自己工作内存中的那一份。在线程代码执行完毕之后,会将最新的值更新到主内存中去


(2)定义了几个原子操作,用于操作主内存和工作内存中的变量


(3)定义了volatile变量的使用规则


(4)happens-before,即先行发生原则,定义了操作A必然先行发生于操作B的一些规则,比如在同一个线程内控制流前面的代码一定先行发生于控制流后面的代码、一个释放锁unlock的动作一定先行发生于后面对于同一个锁进行锁定lock的动作等等,只要符合这些规则,则不需要额外做同步措施,如果某段代码不符合所有的happens-before规则,则这段代码一定是线程非安全的


 


32、什么是CAS


CAS,全称为Compare and Swap,即比较-替换。假设有三个操作数:内存值V、旧的预期值A、要修改的值B,当且仅当预期值A和内存值V相同时,才会将内存值修改为B并返回true,否则什么都不做并返回false。当然CAS一定要volatile变量配合,这样才能保证每次拿到的变量是主内存中最新的那个值,否则旧的预期值A对某条线程来说,永远是一个不会变的值A,只要某次CAS操作失败,永远都不可能成功。


 


33、什么是乐观锁和悲观锁


(1)乐观锁:就像它的名字一样,对于并发间操作产生的线程安全问题持乐观状态,乐观锁认为竞争不总是会发生,因此它不需要持有锁,将比较-替换这两个动作作为一个原子操作尝试去修改内存中的变量,如果失败则表示发生冲突,那么就应该有相应的重试逻辑。


(2)悲观锁:还是像它的名字一样,对于并发间操作产生的线程安全问题持悲观状态,悲观锁认为竞争总是会发生,因此每次对某资源进行操作时,都会持有一个独占的锁,就像synchronized,不管三七二十一,直接上了锁就操作资源了。


 


34、什么是AQS


简单说一下AQS,AQS全称为AbstractQueuedSychronizer,翻译过来应该是抽象队列同步器。


如果说java.util.concurrent的基础是CAS的话,那么AQS就是整个Java并发包的核心了,ReentrantLock、CountDownLatch、Semaphore等等都用到了它。AQS实际上以双向队列的形式连接所有的Entry,比方说ReentrantLock,所有等待的线程都被放在一个Entry中并连成双向队列,前面一个线程使用ReentrantLock好了,则双向队列实际上的第一个Entry开始运行。


AQS定义了对双向队列所有的操作,而只开放了tryLock和tryRelease方法给开发者使用,开发者可以根据自己的实现重写tryLock和tryRelease方法,以实现自己的并发功能。


 


35、单例模式的线程安全性


老生常谈的问题了,首先要说的是单例模式的线程安全意味着:某个类的实例在多线程环境下只会被创建一次出来。单例模式有很多种的写法,我总结一下:


(1)饿汉式单例模式的写法:线程安全


(2)懒汉式单例模式的写法:非线程安全


(3)双检锁单例模式的写法:线程安全


 


36、Semaphore有什么作用


Semaphore就是一个信号量,它的作用是限制某段代码块的并发数。Semaphore有一个构造函数,可以传入一个int型整数n,表示某段代码最多只有n个线程可以访问,如果超出了n,那么请等待,等到某个线程执行完毕这段代码块,下一个线程再进入。由此可以看出如果Semaphore构造函数中传入的int型整数n=1,相当于变成了一个synchronized了。


 


37、Hashtable的size()方法中明明只有一条语句"return count",为什么还要做同步?


这是我之前的一个困惑,不知道大家有没有想过这个问题。某个方法中如果有多条语句,并且都在操作同一个类变量,那么在多线程环境下不加锁,势必会引发线程安全问题,这很好理解,但是size()方法明明只有一条语句,为什么还要加锁?


关于这个问题,在慢慢地工作、学习中,有了理解,主要原因有两点:


(1)同一时间只能有一条线程执行固定类的同步方法,但是对于类的非同步方法,可以多条线程同时访问。所以,这样就有问题了,可能线程A在执行Hashtable的put方法添加数据,线程B则可以正常调用size()方法读取Hashtable中当前元素的个数,那读取到的值可能不是最新的,可能线程A添加了完了数据,但是没有对size++,线程B就已经读取size了,那么对于线程B来说读取到的size一定是不准确的。而给size()方法加了同步之后,意味着线程B调用size()方法只有在线程A调用put方法完毕之后才可以调用,这样就保证了线程安全性


(2)CPU执行代码,执行的不是Java代码,这点很关键,一定得记住。Java代码最终是被翻译成汇编代码执行的,汇编代码才是真正可以和硬件电路交互的代码。即使你看到Java代码只有一行,甚至你看到Java代码编译之后生成的字节码也只有一行,也不意味着对于底层来说这句语句的操作只有一个。一句"return count"假设被翻译成了三句汇编语句执行,完全可能执行完第一句,线程就切换了。


 


38、线程类的构造方法、静态块是被哪个线程调用的


这是一个非常刁钻和狡猾的问题。请记住:线程类的构造方法、静态块是被new这个线程类所在的线程所调用的,而run方法里面的代码才是被线程自身所调用的。


如果说上面的说法让你感到困惑,那么我举个例子,假设Thread2中new了Thread1,main函数中new了Thread2,那么:


(1)Thread2的构造方法、静态块是main线程调用的,Thread2的run()方法是Thread2自己调用的


(2)Thread1的构造方法、静态块是Thread2调用的,Thread1的run()方法是Thread1自己调用的


 


39、同步方法和同步块,哪个是更好的选择


同步块,这意味着同步块之外的代码是异步执行的,这比同步整个方法更提升代码的效率。请知道一条原则:同步的范围越小越好。


借着这一条,我额外提一点,虽说同步的范围越少越好,但是在Java虚拟机中还是存在着一种叫做锁粗化的优化方法,这种方法就是把同步范围变大。这是有用的,比方说StringBuffer,它是一个线程安全的类,自然最常用的append()方法是一个同步方法,我们写代码的时候会反复append字符串,这意味着要进行反复的加锁->解锁,这对性能不利,因为这意味着Java虚拟机在这条线程上要反复地在内核态和用户态之间进行切换,因此Java虚拟机会将多次append方法调用的代码进行一个锁粗化的操作,将多次的append的操作扩展到append方法的头尾,变成一个大的同步块,这样就减少了加锁-->解锁的次数,有效地提升了代码执行的效率。


 


40、高并发、任务执行时间短的业务怎样使用线程池?并发不高、任务执行时间长的业务怎样使用线程池?并发高、业务执行时间长的业务怎样使用线程池?


这是我在并发编程网上看到的一个问题,把这个问题放在最后一个,希望每个人都能看到并且思考一下,因为这个问题非常好、非常实际、非常专业。关于这个问题,个人看法是:


(1)高并发、任务执行时间短的业务,线程池线程数可以设置为CPU核数+1,减少线程上下文的切换


(2)并发不高、任务执行时间长的业务要区分开看:


  a)假如是业务时间长集中在IO操作上,也就是IO密集型的任务,因为IO操作并不占用CPU,所以不要让所有的CPU闲下来,可以加大线程池中的线程数目,让CPU处理更多的业务


  b)假如是业务时间长集中在计算操作上,也就是计算密集型任务,这个就没办法了,和(1)一样吧,线程池中的线程数设置得少一些,减少线程上下文的切换


(3)并发高、业务执行时间长,解决这种类型任务的关键不在于线程池而在于整体架构的设计,看看这些业务里面某些数据是否能做缓存是第一步,增加服务器是第二步,至于线程池的设置,设置参考(2)。最后,业务执行时间长的问题,也可能需要分析一下,看看能不能使用中间件对任务进行拆分和解耦。

JDK动态代理详解

标签:其他 发布于 2016-12-27 21:58:17

本文主要介绍JDK动态代理的基本原理,让大家更深刻的理解JDK Proxy,知其然知其所以然。明白JDK动态代理真正的原理及其生成的过程,我们以后写JDK Proxy可以不用去查demo,就可以徒手写个完美的Proxy。下面首先来个简单的Demo,后续的分析过程都依赖这个Demo去介绍,例子采用JDK1.8运行。


JDK Proxy HelloWorld

package com.yao.proxy;
/**
 * Created by robin
 */
public interface Helloworld {
    void sayHello();
}
package com.yao.proxy;
import com.yao.HelloWorld;
/**
 * Created by robin
 */
public class HelloworldImpl implements HelloWorld {
    public void sayHello() {
        System.out.print("hello world");
    }
}
package com.yao.proxy;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
/**
 * Created by robin
 */
public class MyInvocationHandler implements InvocationHandler{
    private Object target;
    public MyInvocationHandler(Object target) {
        this.target=target;
    }
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("method :"+ method.getName()+" is invoked!");
        return method.invoke(target,args);
    }
}
package com.yao.proxy;
import com.yao.HelloWorld;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Proxy;

/**
 * Created by robin
 */
public class JDKProxyTest {
    public static void main(String[]args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
        //这里有两种写法,我们采用略微复杂的一种写法,这样更有助于大家理解。
        Class<?> proxyClass= Proxy.getProxyClass(JDKProxyTest.class.getClassLoader(),HelloWorld.class);
        final Constructor<?> cons = proxyClass.getConstructor(InvocationHandler.class);
        final InvocationHandler ih = new MyInvocationHandler(new HelloworldImpl());
        HelloWorld helloWorld= (HelloWorld)cons.newInstance(ih);
        helloWorld.sayHello();

        //下面是更简单的一种写法,本质上和上面是一样的
        /* 
        HelloWorld helloWorld=(HelloWorld)Proxy.
                 newProxyInstance(JDKProxyTest.class.getClassLoader(),
                        new Class<?>[]{HelloWorld.class},
                        new MyInvocationHandler(new HelloworldImpl()));
        helloWorld.sayHello();
        */
    }

}


运行上面的代码,这样一个简单的JDK Proxy就实现了。


代理生成过程


我们之所以天天叫JDK动态代理,是因为这个代理class是由JDK在运行时动态帮我们生成。在解释代理生成过程前,我们先把-Dsun.misc.ProxyGenerator.saveGeneratedFiles=true 这个参数加入到JVM 启动参数中,它的作用是帮我们把JDK动态生成的proxy class 的字节码保存到硬盘中,帮助我们查看具体生成proxy的内容。我用的Intellij IDEA ,代理class生成后直接放在项目的根目录下的,以具体的包名为目录结构。


代理类生成的过程主要包括两部分:


1、代理类字节码生成

2、把字节码通过传入的类加载器加载到虚拟机中


Proxy类的getProxyClass方法入口:需要传入类加载器和interface 

face/JmtjRHJjd5p6MPprTkf5aJeExxS4Sphi.png


然后调用getProxyClass0方法,里面的注解解释很清楚,如果实现当前接口的代理类存在,直接从缓存中返回,如果不存在,则通过ProxyClassFactory来创建。这里可以明显看到有对interface接口数量的限制,不能超过65535。其中proxyClassCache具体初始化信息如下:


proxyClassCache = new WeakCache<>(new KeyFactory(), new ProxyClassFactory());

其中创建代理类的具体逻辑是通过ProxyClassFactory的apply方法来创建的。


face/YXKftAGD7Jmh5i6DijfWFFMySGSDppZk.png

ProxyClassFactory里的逻辑包括了包名的创建逻辑,调用ProxyGenerator. generateProxyClass生成代理类,把代理类字节码加载到JVM。


1、包名生成逻辑默认是com.sun.proxy,如果被代理类是 non-public proxy interface ,则用和被代理类接口一样的包名,类名默认是$Proxy 加上一个自增的整数值。


2、包名类名准备好后,就是通过ProxyGenerator. generateProxyClass根据具体传入的接口创建代理字节码,-Dsun.misc.ProxyGenerator.saveGeneratedFiles=true 这个参数就是在该方法起到作用,如果为true则保存字节码到磁盘。代理类中,所有的代理方法逻辑都一样都是调用invocationHander的invoke方法,这个我们可以看后面具体代理反编译结果。


3、把字节码通过传入的类加载器加载到JVM中: defineClass0(loader, proxyName,proxyClassFile, 0, proxyClassFile.length);。

 private static final class ProxyClassFactory
        implements BiFunction<ClassLoader, Class<?>[], Class<?>>
    {
        // prefix for all proxy class names
        private static final String proxyClassNamePrefix = "$Proxy";

        // next number to use for generation of unique proxy class names
        private static final AtomicLong nextUniqueNumber = new AtomicLong();

        @Override
        public Class<?> apply(ClassLoader loader, Class<?>[] interfaces) {

            Map<Class<?>, Boolean> interfaceSet = new IdentityHashMap<>(interfaces.length);
            for (Class<?> intf : interfaces) {
                /*
                 * Verify that the class loader resolves the name of this
                 * interface to the same Class object.
                 */
                Class<?> interfaceClass = null;
                try {
                    interfaceClass = Class.forName(intf.getName(), false, loader);
                } catch (ClassNotFoundException e) {
                }
                if (interfaceClass != intf) {
                    throw new IllegalArgumentException(
                        intf + " is not visible from class loader");
                }
                /*
                 * Verify that the Class object actually represents an
                 * interface.
                 */
                if (!interfaceClass.isInterface()) {
                    throw new IllegalArgumentException(
                        interfaceClass.getName() + " is not an interface");
                }
                /*
                 * Verify that this interface is not a duplicate.
                 */
                if (interfaceSet.put(interfaceClass, Boolean.TRUE) != null) {
                    throw new IllegalArgumentException(
                        "repeated interface: " + interfaceClass.getName());
                }
            }

            String proxyPkg = null;     // package to define proxy class in
            int accessFlags = Modifier.PUBLIC | Modifier.FINAL;

            /*
             * Record the package of a non-public proxy interface so that the
             * proxy class will be defined in the same package.  Verify that
             * all non-public proxy interfaces are in the same package.
             */
           //生成包名和类名逻辑
            for (Class<?> intf : interfaces) {
                int flags = intf.getModifiers();
                if (!Modifier.isPublic(flags)) {
                    accessFlags = Modifier.FINAL;
                    String name = intf.getName();
                    int n = name.lastIndexOf('.');
                    String pkg = ((n == -1) ? "" : name.substring(0, n + 1));
                    if (proxyPkg == null) {
                        proxyPkg = pkg;
                    } else if (!pkg.equals(proxyPkg)) {
                        throw new IllegalArgumentException(
                            "non-public interfaces from different packages");
                    }
                }
            }

            if (proxyPkg == null) {
                // if no non-public proxy interfaces, use com.sun.proxy package
                proxyPkg = ReflectUtil.PROXY_PACKAGE + ".";
            }

            /*
             * Choose a name for the proxy class to generate.
             */
            long num = nextUniqueNumber.getAndIncrement();
            String proxyName = proxyPkg + proxyClassNamePrefix + num;

            /*
             * Generate the specified proxy class. 生成代理类的字节码
             * -Dsun.misc.ProxyGenerator.saveGeneratedFiles=true 在该部起作用
             */
            byte[] proxyClassFile = ProxyGenerator.generateProxyClass(
                proxyName, interfaces, accessFlags);
            try {
                //加载到JVM中
                return defineClass0(loader, proxyName,
                                    proxyClassFile, 0, proxyClassFile.length);
            } catch (ClassFormatError e) {
                /*
                 * A ClassFormatError here means that (barring bugs in the
                 * proxy class generation code) there was some other
                 * invalid aspect of the arguments supplied to the proxy
                 * class creation (such as virtual machine limitations
                 * exceeded).
                 */
                throw new IllegalArgumentException(e.toString());
            }
        }
    }


我们可以根据代理类的字节码进行反编译,可以得到如下结果,其中HelloWorld只有sayHello方法,但是代理类中有四个方法 包括了Object上的三个方法:equals,toString,hashCode。


代理的大概结构包括4部分:


1、静态字段:被代理的接口所有方法都有一个对应的静态方法变量;

2、静态块:主要是通过反射初始化静态方法变量;

3、具体每个代理方法:逻辑都差不多就是 h.invoke,主要是调用我们定义好的invocatinoHandler逻辑,触发目标对象target上对应的方法;

4、构造函数:从这里传入我们InvocationHandler逻辑;


package com.sun.proxy;

import com.yao.HelloWorld;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.lang.reflect.UndeclaredThrowableException;

public final class $Proxy0 extends Proxy implements HelloWorld {
    private static Method m1;
    private static Method m3;
    private static Method m2;
    private static Method m0;

    public $Proxy0(InvocationHandler var1) throws  {
        super(var1);
    }

    public final boolean equals(Object var1) throws  {
        try {
            return ((Boolean)super.h.invoke(this, m1, new Object[]{var1})).booleanValue();
        } catch (RuntimeException | Error var3) {
            throw var3;
        } catch (Throwable var4) {
            throw new UndeclaredThrowableException(var4);
        }
    }

    public final void sayHello() throws  {
        try {
            super.h.invoke(this, m3, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    public final String toString() throws  {
        try {
            return (String)super.h.invoke(this, m2, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    public final int hashCode() throws  {
        try {
            return ((Integer)super.h.invoke(this, m0, (Object[])null)).intValue();
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    static {
        try {
            m1 = Class.forName("java.lang.Object").getMethod("equals", new Class[]{Class.forName("java.lang.Object")});
            m3 = Class.forName("com.yao.HelloWorld").getMethod("sayHello", new Class[0]);
            m2 = Class.forName("java.lang.Object").getMethod("toString", new Class[0]);
            m0 = Class.forName("java.lang.Object").getMethod("hashCode", new Class[0]);
        } catch (NoSuchMethodException var2) {
            throw new NoSuchMethodError(var2.getMessage());
        } catch (ClassNotFoundException var3) {
            throw new NoClassDefFoundError(var3.getMessage());
        }
    }
}


常见问题:


1、toString() hashCode() equal()方法 调用逻辑:这个三个Object上的方法,如果被调用将和其他接口方法方法处理逻辑一样,都会经过invocationHandler逻辑,从上面的字节码结果就可以明显看出。其他Object上的方法将不会走代理处理逻辑,直接走Proxy继承的Object上方法逻辑。


2、interface 含有equals,toString hashCode方法时,和处理普通接口方法一样,都会走invocation handler逻辑,以目标对象重写的逻辑为准去触发方法逻辑;


3、interface含有重复的方法签名,以接口传入顺序为准,谁在前面就用谁的方法,代理类中只会保留一个,不会有重复的方法签名;


怎么玩转Java线程池?

标签:JAVA 发布于 2017-08-10 18:31:02
一:简介 
线程的使用在java中占有极其重要的地位,在jdk1.4极其之前的jdk版本中,关于线程池的使用是极其简陋的。在jdk1.5之后这一情况有了很大的改观。Jdk1.5之后加入了java.util.concurrent包,这个包中主要介绍java中线程以及线程池的使用。为我们在开发中处理线程的问题提供了非常大的帮助。 

二:线程池 
线程池的作用: 

线程池作用就是限制系统中执行线程的数量。 
根据系统的环境情况,可以自动或手动设置线程数量,达到运行的最佳效果;少了浪费了系统资源,多了造成系统拥挤效率不高。用线程池控制线程数量,其他线程排队等候。一个任务执行完毕,再从队列的中取最前面的任务开始执行。若队列中没有等待进程,线程池的这一资源处于等待。当一个新任务需要运行时,如果线程池中有等待的工作线程,就可以开始运行了;否则进入等待队列。 

为什么要用线程池: 

1.减少了创建和销毁线程的次数,每个工作线程都可以被重复利用,可执行多个任务。 

2.可以根据系统的承受能力,调整线程池中工作线线程的数目,防止因为消耗过多的内存,而把服务器累趴下(每个线程需要大约1MB内存,线程开的越多,消耗的内存也就越大,最后死机)。 

Java里面线程池的顶级接口是Executor,但是严格意义上讲Executor并不是一个线程池,而只是一个执行线程的工具。真正的线程池接口是ExecutorService。 

比较重要的几个类: 

ExecutorService 

真正的线程池接口。 

ScheduledExecutorService 

能和Timer/TimerTask类似,解决那些需要任务重复执行的问题。 

ThreadPoolExecutor 

ExecutorService的默认实现。 

ScheduledThreadPoolExecutor 

继承ThreadPoolExecutor的ScheduledExecutorService接口实现,周期性任务调度的类实现。 

要配置一个线程池是比较复杂的,尤其是对于线程池的原理不是很清楚的情况下,很有可能配置的线程池不是较优的,因此在Executors类里面提供了一些静态工厂,生成一些常用的线程池。 

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

2.newFixedThreadPool 

创建固定大小的线程池。每次提交一个任务就创建一个线程,直到线程达到线程池的最大大小。线程池的大小一旦达到最大值就会保持不变,如果某个线程因为执行异常而结束,那么线程池会补充一个新线程。 

newCachedThreadPool 
创建一个可缓存的线程池。如果线程池的大小超过了处理任务所需要的线程, 

那么就会回收部分空闲(60秒不执行任务)的线程,当任务数增加时,此线程池又可以智能的添加新线程来处理任务。此线程池不会对线程池大小做限制,线程池大小完全依赖于操作系统(或者说JVM)能够创建的最大线程大小。 

4.newScheduledThreadPool 

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

实例 

1:newSingleThreadExecutor

MyThread.java

publicclassMyThread extends Thread {

@Override

publicvoid run() {

    System.out.println(Thread.currentThread().getName() + "正在执行。。。");

}
}

TestSingleThreadExecutor.java

publicclassTestSingleThreadExecutor {

publicstaticvoid main(String[] args) {

    //创建一个可重用固定线程数的线程池

    ExecutorService pool = Executors. newSingleThreadExecutor();

    //创建实现了Runnable接口对象,Thread对象当然也实现了Runnable接口

    Thread t1 = new MyThread();

    Thread t2 = new MyThread();

    Thread t3 = new MyThread();

    Thread t4 = new MyThread();

    Thread t5 = new MyThread();

    //将线程放入池中进行执行

    pool.execute(t1);

    pool.execute(t2);

    pool.execute(t3);

    pool.execute(t4);

    pool.execute(t5);

    //关闭线程池

    pool.shutdown();

}
}

输出结果 

pool-1-thread-1正在执行。。。 

pool-1-thread-1正在执行。。。 

pool-1-thread-1正在执行。。。 

pool-1-thread-1正在执行。。。 

pool-1-thread-1正在执行。。。 

2newFixedThreadPool

TestFixedThreadPool.Java

publicclass TestFixedThreadPool {

publicstaticvoid main(String[] args) {


    //创建一个可重用固定线程数的线程池 

    ExecutorService pool = Executors.newFixedThreadPool(2); 

    //创建实现了Runnable接口对象,Thread对象当然也实现了Runnable接口 

    
Thread t1 = new MyThread();

    Thread t2 = new MyThread();

    Thread t3 = new MyThread();

    Thread t4 = new MyThread();

    Thread t5 = new MyThread();

    //将线程放入池中进行执行 

    
pool.execute(t1);

    pool.execute(t2);

    pool.execute(t3);

    pool.execute(t4);

    pool.execute(t5);


    //关闭线程池 

   
 pool.shutdown();

}
}

输出结果 

pool-1-thread-1正在执行。。。 

pool-1-thread-2正在执行。。。 

pool-1-thread-1正在执行。。。 

pool-1-thread-2正在执行。。。 

pool-1-thread-1正在执行。。。 

3 newCachedThreadPool

TestCachedThreadPool.java

publicclass TestCachedThreadPool {

publicstaticvoid main(String[] args) {


    //创建一个可重用固定线程数的线程池 

    ExecutorService pool = Executors.newCachedThreadPool(); 

    //创建实现了Runnable接口对象,Thread对象当然也实现了Runnable接口 

    
Thread t1 = new MyThread();

    Thread t2 = new MyThread();

    Thread t3 = new MyThread();

    Thread t4 = new MyThread();

    Thread t5 = new MyThread();


    //将线程放入池中进行执行 

   
 pool.execute(t1);

    pool.execute(t2);

    pool.execute(t3);

    pool.execute(t4);

    pool.execute(t5);

    //关闭线程池 

   
 pool.shutdown();

}
}

输出结果: 

pool-1-thread-2正在执行。。。 

pool-1-thread-4正在执行。。。 

pool-1-thread-3正在执行。。。 

pool-1-thread-1正在执行。。。 

pool-1-thread-5正在执行。。。 

4newScheduledThreadPool

TestScheduledThreadPoolExecutor.java

publicclass TestScheduledThreadPoolExecutor {

publicstaticvoid main(String[] args) {

    ScheduledThreadPoolExecutor exec = new ScheduledThreadPoolExecutor(1);

    exec.scheduleAtFixedRate(new Runnable() {//每隔一段时间就触发异常 

                  
@Override

                  publicvoid run() {

                       //throw new RuntimeException();

                       System.out.println("================");

                  }

              }, 1000, 5000, TimeUnit.MILLISECONDS);


    exec.scheduleAtFixedRate(new Runnable() {//每隔一段时间打印系统时间,证明两者是互不影响的 

                  
@Override

                  publicvoid run() {

                       System.out.println(System.nanoTime());

                  }

              }, 1000, 2000, TimeUnit.MILLISECONDS);

}
}


输出结果 

8384644549516 

8386643829034 

8388643830710 

8390643851383 

8392643879319 

8400643939383 

三:ThreadPoolExecutor详解 
ThreadPoolExecutor的完整构造方法的签名是:ThreadPoolExecutor(int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue workQueue, ThreadFactory threadFactory, RejectedExecutionHandler handler) . 

corePoolSize - 池中所保存的线程数,包括空闲线程。 

maximumPoolSize-池中允许的最大线程数。 

keepAliveTime - 当线程数大于核心时,此为终止前多余的空闲线程等待新任务的最长时间。 

unit - keepAliveTime 参数的时间单位。 

workQueue - 执行前用于保持任务的队列。此队列仅保持由 execute方法提交的 Runnable任务。 

threadFactory - 执行程序创建新线程时使用的工厂。 

handler - 由于超出线程范围和队列容量而使执行被阻塞时所使用的处理程序。 

ThreadPoolExecutor是Executors类的底层实现。 

在JDK帮助文档中,有如此一段话: 

“强烈建议程序员使用较为方便的Executors工厂方法Executors.newCachedThreadPool()(无界线程池,可以进行自动线程回收)、Executors.newFixedThreadPool(int)(固定大小线程池)Executors.newSingleThreadExecutor()(单个后台线程) 

它们均为大多数使用场景预定义了设置。” 

下面介绍一下几个类的源码: 

ExecutorService newFixedThreadPool (int nThreads):固定大小线程池。 

可以看到,corePoolSize和maximumPoolSize的大小是一样的(实际上,后面会介绍,如果使用无界queue的话maximumPoolSize参数是没有意义的),keepAliveTime和unit的设值表名什么?-就是该实现不想keep alive!最后的BlockingQueue选择了LinkedBlockingQueue,该queue有一个特点,他是无界的。 

public static ExecutorService newFixedThreadPool(int nThreads) {   
        return new ThreadPoolExecutor(nThreads, nThreads,   
                                      0L, TimeUnit.MILLISECONDS,   
                                      new LinkedBlockingQueue<Runnable>());   
    }

ExecutorService newSingleThreadExecutor():单线程 

public static ExecutorService newSingleThreadExecutor() {   
        return new FinalizableDelegatedExecutorService   
            (new ThreadPoolExecutor(1, 1,   
                                    0L, TimeUnit.MILLISECONDS,   
                                    new LinkedBlockingQueue<Runnable>()));   
    }

ExecutorService newCachedThreadPool():无界线程池,可以进行自动线程回收 

这个实现就有意思了。首先是无界的线程池,所以我们可以发现maximumPoolSize为big big。其次BlockingQueue的选择上使用SynchronousQueue。可能对于该BlockingQueue有些陌生,简单说:该QUEUE中,每个插入操作必须等待另一个线程的对应移除操作。 

public static ExecutorService newCachedThreadPool() {   
        return new ThreadPoolExecutor(0, Integer.MAX_VALUE,   
                                      60L, TimeUnit.SECONDS,   
                                      new SynchronousQueue<Runnable>());   
}

先从BlockingQueue workQueue这个入参开始说起。在JDK中,其实已经说得很清楚了,一共有三种类型的queue。 

所有BlockingQueue 都可用于传输和保持提交的任务。可以使用此队列与池大小进行交互: 

如果运行的线程少于 corePoolSize,则 Executor始终首选添加新的线程,而不进行排队。(如果当前运行的线程小于corePoolSize,则任务根本不会存放,添加到queue中,而是直接抄家伙(thread)开始运行) 

如果运行的线程等于或多于 corePoolSize,则 Executor始终首选将请求加入队列,而不添加新的线程。 

如果无法将请求加入队列,则创建新的线程,除非创建此线程超出 maximumPoolSize,在这种情况下,任务将被拒绝。 

queue上的三种类型。 

排队有三种通用策略: 

直接提交。工作队列的默认选项是 SynchronousQueue,它将任务直接提交给线程而不保持它们。在此,如果不存在可用于立即运行任务的线程,则试图把任务加入队列将失败,因此会构造一个新的线程。此策略可以避免在处理可能具有内部依赖性的请求集时出现锁。直接提交通常要求无界 maximumPoolSizes 以避免拒绝新提交的任务。当命令以超过队列所能处理的平均数连续到达时,此策略允许无界线程具有增长的可能性。 

无界队列。使用无界队列(例如,不具有预定义容量的 LinkedBlockingQueue)将导致在所有corePoolSize 线程都忙时新任务在队列中等待。这样,创建的线程就不会超过 corePoolSize。(因此,maximumPoolSize的值也就无效了。)当每个任务完全独立于其他任务,即任务执行互不影响时,适合于使用无界队列;例如,在 Web页服务器中。这种排队可用于处理瞬态突发请求,当命令以超过队列所能处理的平均数连续到达时,此策略允许无界线程具有增长的可能性。 

有界队列。当使用有限的 maximumPoolSizes时,有界队列(如 ArrayBlockingQueue)有助于防止资源耗尽,但是可能较难调整和控制。队列大小和最大池大小可能需要相互折衷:使用大型队列和小型池可以最大限度地降低 CPU 使用率、操作系统资源和上下文切换开销,但是可能导致人工降低吞吐量。如果任务频繁阻塞(例如,如果它们是 I/O边界),则系统可能为超过您许可的更多线程安排时间。使用小型队列通常要求较大的池大小,CPU使用率较高,但是可能遇到不可接受的调度开销,这样也会降低吞吐量。 

BlockingQueue的选择。 

例子一:使用直接提交策略,也即SynchronousQueue。 

首先SynchronousQueue是无界的,也就是说他存数任务的能力是没有限制的,但是由于该Queue本身的特性,在某次添加元素后必须等待其他线程取走后才能继续添加。在这里不是核心线程便是新创建的线程,但是我们试想一样下,下面的场景。 

我们使用一下参数构造ThreadPoolExecutor: 

new ThreadPoolExecutor(   
            2, 3, 30, TimeUnit.SECONDS,    
            new  SynchronousQueue<Runnable>(),    
            new RecorderThreadFactory("CookieRecorderPool"),    

    new ThreadPoolExecutor.CallerRunsPolicy());  
new ThreadPoolExecutor(

2, 3, 30, TimeUnit.SECONDS,

new SynchronousQueue(),

new RecorderThreadFactory("CookieRecorderPool"),

new ThreadPoolExecutor.CallerRunsPolicy());


当核心线程已经有2个正在运行. 

此时继续来了一个任务(A),根据前面介绍的“如果运行的线程等于或多于 corePoolSize,则Executor始终首选将请求加入队列,而不添加新的线程。”,所以A被添加到queue中。 
又来了一个任务(B),且核心2个线程还没有忙完,OK,接下来首先尝试1中描述,但是由于使用的SynchronousQueue,所以一定无法加入进去。 
此时便满足了上面提到的“如果无法将请求加入队列,则创建新的线程,除非创建此线程超出maximumPoolSize,在这种情况下,任务将被拒绝。”,所以必然会新建一个线程来运行这个任务。 
暂时还可以,但是如果这三个任务都还没完成,连续来了两个任务,第一个添加入queue中,后一个呢?queue中无法插入,而线程数达到了maximumPoolSize,所以只好执行异常策略了。 
所以在使用SynchronousQueue通常要求maximumPoolSize是无界的,这样就可以避免上述情况发生(如果希望限制就直接使用有界队列)。对于使用SynchronousQueue的作用jdk中写的很清楚:此策略可以避免在处理可能具有内部依赖性的请求集时出现锁。 

什么意思?如果你的任务A1,A2有内部关联,A1需要先运行,那么先提交A1,再提交A2,当使用SynchronousQueue我们可以保证,A1必定先被执行,在A1么有被执行前,A2不可能添加入queue中。 

例子二:使用无界队列策略,即LinkedBlockingQueue 

这个就拿newFixedThreadPool来说,根据前文提到的规则: 

如果运行的线程少于 corePoolSize,则 Executor 始终首选添加新的线程,而不进行排队。那么当任务继续增加,会发生什么呢? 

如果运行的线程等于或多于 corePoolSize,则 Executor 始终首选将请求加入队列,而不添加新的线程。OK,此时任务变加入队列之中了,那什么时候才会添加新线程呢? 

如果无法将请求加入队列,则创建新的线程,除非创建此线程超出 maximumPoolSize,在这种情况下,任务将被拒绝。这里就很有意思了,可能会出现无法加入队列吗?不像SynchronousQueue那样有其自身的特点,对于无界队列来说,总是可以加入的(资源耗尽,当然另当别论)。换句说,永远也不会触发产生新的线程!corePoolSize大小的线程数会一直运行,忙完当前的,就从队列中拿任务开始运行。所以要防止任务疯长,比如任务运行的实行比较长,而添加任务的速度远远超过处理任务的时间,而且还不断增加,不一会儿就爆了。 

例子三:有界队列,使用ArrayBlockingQueue。 

这个是最为复杂的使用,所以JDK不推荐使用也有些道理。与上面的相比,最大的特点便是可以防止资源耗尽的情况发生。 

举例来说,请看如下构造方法: 

new ThreadPoolExecutor(   
            2, 4, 30, TimeUnit.SECONDS,    
            new ArrayBlockingQueue<Runnable>(2),    
            new RecorderThreadFactory("CookieRecorderPool"),    
            new ThreadPoolExecutor.CallerRunsPolicy());  
new ThreadPoolExecutor(

2, 4, 30, TimeUnit.SECONDS,

new ArrayBlockingQueue<Runnable>(2),

new RecorderThreadFactory("CookieRecorderPool"),

new ThreadPoolExecutor.CallerRunsPolicy());

假设,所有的任务都永远无法执行完。 

对于首先来的A,B来说直接运行,接下来,如果来了C,D,他们会被放到queue中,如果接下来再来E,F,则增加线程运行E,F。但是如果再来任务,队列无法再接受了,线程数也到达最大的限制了,所以就会使用拒绝策略来处理。 

keepAliveTime 

jdk中的解释是:当线程数大于核心时,此为终止前多余的空闲线程等待新任务的最长时间。 

有点拗口,其实这个不难理解,在使用了“池”的应用中,大多都有类似的参数需要配置。比如数据库连接池,DBCP中的maxIdle,minIdle参数。 

什么意思?接着上面的解释,后来向老板派来的工人始终是“借来的”,俗话说“有借就有还”,但这里的问题就是什么时候还了,如果借来的工人刚完成一个任务就还回去,后来发现任务还有,那岂不是又要去借?这一来一往,老板肯定头也大死了。 

合理的策略:既然借了,那就多借一会儿。直到“某一段”时间后,发现再也用不到这些工人时,便可以还回去了。这里的某一段时间便是keepAliveTime的含义,TimeUnit为keepAliveTime值的度量。 

RejectedExecutionHandler 

另一种情况便是,即使向老板借了工人,但是任务还是继续过来,还是忙不过来,这时整个队伍只好拒绝接受了。 

RejectedExecutionHandler接口提供了对于拒绝任务的处理的自定方法的机会。在ThreadPoolExecutor中已经默认包含了4中策略,因为源码非常简单,这里直接贴出来。 

CallerRunsPolicy:线程调用运行该任务的 execute 本身。此策略提供简单的反馈控制机制,能够减缓新任务的提交速度。 

public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {   
            if (!e.isShutdown()) {   
                r.run();   
            }   
        }  
public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {

       if (!e.isShutdown()) {

           r.run();

       }

   }

这个策略显然不想放弃执行任务。但是由于池中已经没有任何资源了,那么就直接使用调用该execute的线程本身来执行。 

AbortPolicy:处理程序遭到拒绝将抛出运行时RejectedExecutionException 

public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {   
            throw new RejectedExecutionException();   
        }  
public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {

       throw new RejectedExecutionException();

   }

这种策略直接抛出异常,丢弃任务。 

DiscardPolicy:不能执行的任务将被删除 

public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {   
        }  
public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {

   }

这种策略和AbortPolicy几乎一样,也是丢弃任务,只不过他不抛出异常。 

DiscardOldestPolicy:如果执行程序尚未关闭,则位于工作队列头部的任务将被删除,然后重试执行程序(如果再次失败,则重复此过程) 

public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {   
            if (!e.isShutdown()) {   
                e.getQueue().poll();   
                e.execute(r);   
            }   

}  
public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {

   if (!e.isShutdown()) {

       e.getQueue().poll();

       e.execute(r);

   }
}


该策略就稍微复杂一些,在pool没有关闭的前提下首先丢掉缓存在队列中的最早的任务,然后重新尝试运行该任务。这个策略需要适当小心。 

设想:如果其他线程都还在运行,那么新来任务踢掉旧任务,缓存在queue中,再来一个任务又会踢掉queue中最老任务。 

总结: 

keepAliveTime和maximumPoolSize及BlockingQueue的类型均有关系。如果BlockingQueue是无界的,那么永远不会触发maximumPoolSize,自然keepAliveTime也就没有了意义。 

反之,如果核心数较小,有界BlockingQueue数值又较小,同时keepAliveTime又设的很小,如果任务频繁,那么系统就会频繁的申请回收线程。 

public static ExecutorService newFixedThreadPool(int nThreads) {

   return new ThreadPoolExecutor(nThreads, nThreads,

                                 0L, TimeUnit.MILLISECONDS,

                                 new LinkedBlockingQueue<Runnable>());
}

声明:本文内容由网友自发贡献,不代表【wpsshop博客】立场,版权归原作者所有,本站不承担相应法律责任。如您发现有侵权的内容,请联系我们。转载请注明出处:https://www.wpsshop.cn/w/小丑西瓜9/article/detail/627381
推荐阅读
相关标签
  

闽ICP备14008679号