山月风成个人页面-阿里云开发者社区

logger异常日志要点总结

Logger异常日志，企业项目中非常重要的一步，在系统调试、出错时，能够快速排查，修复。以下是关于异常日志使用的关键点。 1、真正有意义的Logger 一些用户异常信息，是返回到View层显示给用户看的，那么在前端可能就能够完成处理（例如：提示两次输入的密码不一致），要么根本不是异常（例如：提示用户没有注册）。这样的用户异常不应该出现在异常日志中，而需要记录的是技术性异常（例如：“服务器编译文件未找到”），反映真正有意义的异常到logger中。 2、察觉需要捕获异常的代码块，进行捕获 后端在进行数据更新的时候， updat/savae、insert、delete没有正确执行，此时，用try…catch去捕获异常。 //使用日志类logger import org.apache.log4j.Logger; public class ActAreaServiceImpl implements ActAreaService{ //在编写类时，得到ActAreaServiceImpl.class产生的异常日志 private static final Logger logger = Logger.getLogger(ActAreaServiceImpl.class); ... try{ //可能抛出异常的代码 //Service层多数情况是 updat/savae、insert、delete没有正确执行 }catch(Exception e) { //捕获异常并在日志中打印出来 logger.error(e.getMessage(), e); } 3、合理使用Logger框架的异常信息输出方法 运行中异常，错误信息异常，debug调试异常，Root时异常，了解、知道和会使用在常用的异常方法。 一般是logger.error（）。 4、异常追踪堆栈的关键信息 异常框架在处理异常时，会保证打印输出所有相关的堆栈追踪信息，异常的所有原因记录在日志文件中，所以在调试代码时，最上层的异常就是程序异常的起因，这个信息是最重要的。 5、错误：记录日志后又向外抛出 记录日志后又重新抛出异常叫做——异常反模式(anti-pattern)，不要这么做，冗余重复。 try{ ... } catch (Exception e) { logger.error(e.getMessage(), e); throw new RuntimeException(e.getMessage()); } 6、任何时候都不要使用System.out或者System.err记录来记录logger Java发展至今，已经有非常多的日志框架了，要相信成熟的架构体系的异常处理。不成熟的程序员异常处理会有很多逻辑漏洞，不合理的地方，使用框架比你自己处理要更好。

java中instanceof的用法和实战

java 中的instanceof 是一个二元操作符（运算符）运算符，由于是字母组成，所以是Java的保留关键字，但是和>=，<=，==属同一类，它的作用是用来判断，instanceof 左边对象是否为instanceof 右边类的实例，返回一个boolean类型值。还可以用来判断子父类的所属关系。 用法： boolean result = object instanceof class 参数： Result：布尔类型。 Object：必选项。任意对象表达式。 Class：必选项。任意已定义的对象类。 说明： 如果 object 是 class 的一个实例，则 instanceof 运算符返回 true。如果 object 不是指定类的一个实例，或者 object 是 null，则返回 false。 在做项目中用到的实战应用。 public void exportExcelFileReflect(SXSSFSheet sheet,List<String> properties, List<Object> list, int startRow) throws Exception{ for(Object o : list){ SXSSFRow row = sheet.createRow(++startRow);//从下一行开始 SXSSFCell cell = null; //T t = dataList.get(i); //使用反射将数据填充到cell int cellnum = 0; for(String p : properties){ PropertyDescriptor pd2 = getPropertyDescriptor(o.getClass(),p); Method rm = pd2.getReadMethod(); cell = row.createCell(cellnum); Object value = rm.invoke(o, new Object[] {}); if(value instanceof Double){ cell.setCellValue((Double)value); }else if(value instanceof Date){ cell.setCellValue(DateUtil.dateToLongString((Date)value)); }else if(value instanceof String){ cell.setCellValue((String)value); }else if(value instanceof Boolean){ cell.setCellValue((Boolean)value); }else if(value instanceof Long){ cell.setCellValue((Long)value); }else if(value instanceof Integer){ cell.setCellValue((Integer)value); }else if(value instanceof Float){ cell.setCellValue((Float)value); }else if(value instanceof Short){ cell.setCellValue((Short)value); }else if(value == null){ cell.setCellValue(""); }else{ cell.setCellValue(value+""); } cellnum ++ ; } if(startRow % 100 == 0) { ((SXSSFSheet)sheet).flushRows(100); } } } 主要看if（value instanceof Double）之后那一段，其他和这个知识点无关。判断value是不是属于这个Class类的，如果是，返回是true，执行方法体中的cell实例对象的POJO方法）

UML类图

Oracle新建表时，复制另一张旧表的结构和数据

1、创建一张和已经存在的表一样结构的表，同时复制数据 create table newTableName as select * from oldTableName; //--newTableName 新建表的表名 oldTableName：系统中已经存在的表 truncate table tablename; --删除表数据

深入理解ArrayList 和 LinkedList 区别

ArrayList的内部实现是基于数组，因此，它使用get方法访问列表中的任意一个元素时，它的速度要比LinkedList快。LinkedList的内部实现是基于链表的，LinkedList中的get方法是按顺序从列表的一端到另一端。对LinkedList而言，只有这种查找方法。 Bruca Eckel描述如下： Java编程思想对List的描述（4版P233）： 基本的ArrayList，它长于随机访问，但是在List的中间插入和一处速度较慢。 LinkedList，它通过代价较低的在List中间进行插入和删除操作，提供了优化的顺序访问，LinkedList在随机访问方面相对较慢，但是它的特性较ArrayList更大。 实现分析： 问题：假设一个很大的列表，其中元素已经排序（在静态代码块中实现），这个列表可能是ArrayList类型的也可能是LinkedList类型的，现在我们对这个列表来进行二分查找(binary search)，比较ArrayList和LinkedList时的查询速度。然后在比较插入/删除的速度。 测试结果 N=1000时，在前段1/10,1/5处两者几乎无差别，可忽略。 N=10000时，在前段1/5处或更前面的位置，LinkedList的效率更高， N=100000时，在前段1/10处或更前面的位置，LinkedList的效率更高 代码如下，第一，保证ArrayList和Linked先被创建出来，排除ArratList自动扩容的问题。 package demo; import java.util.ArrayList; import java.util.Arrays; import java.util.Collections; import java.util.LinkedList; import java.util.List; import java.util.Random; public class Test3 { public static final int N = 100000; public static List values; //保证在静态代码块中先生成List，排除扩容问题 static{ Integer vals[] = new Integer[N]; Random r = new Random(); for(int i=0 ,currval = 0;i < N;i++){ //Integer数组 vals[]的每一个元素 初始化都为0 vals[i] = new Integer(currval); currval += r.nextInt(100) + 1; //currval=currval+r.nextInt(100)+1; } //数组生成集合List values = Arrays.asList(vals); } static long getTime(List lst){ long start = System.currentTimeMillis(); //当前时间 for(int i=0;i<N;i++){ int index = Collections.binarySearch(lst, values.get(i)); //二分法 if(index!=i) System.out.println("***错误***"); } return System.currentTimeMillis() - start; } public static long insertTime(List list){ long time = System.currentTimeMillis(); //控制在List插入删除的位置 int index = N/10; for(int i=100;i<N;i++){ //在下标index出插入 list.add(index,i); //N=100000,1/10处之后 LinkedList就开始变慢了 //将下标index处的删除 list.remove(index); //remove掉之前添加的对象 执行次数是（index-100）次 if(i == index) break; } return System.currentTimeMillis()-time; } public static void main(String[] args) { System.out.println("linked time:"+getTime(new LinkedList(values))); System.out.println("array time:"+getTime(new ArrayList(values))); System.out.println("linked insert time:"+insertTime(new LinkedList(values))); System.out.println("array insert time:"+insertTime(new ArrayList(values))); } } 结果： N=100000时，index=N/10时 linked time:19794 array time:10 linked insert time:334 array insert time:463 如果插入到1/10后段 结果： N=10000时，index=N/5时 linked time:188 array time:5 linked insert time:12 array insert time:12 结果： N=1000时，index=N/10或者index=N/5两者几乎无差别 linked time:7 array time:2 linked insert time:0 array insert time:1 讨论： 集合元素很多时，当需要插入数据的时候，如果是在集合的前段（大概集合容量的前1/10）处插入数据时，linkedlist性能明显（内存开销、时间）优于arraylist，但是！！！！当在集合的中部甚至靠后的位置插入大量数据时，arraylist的性能反而远远优于linkedlist，所以，linkedlist相较于arraylist的优势在于集合前段的数据的插入和内存的开销。 对于ArraList，对列表中间插入和删除LinkedList是廉价操作，但是对于ArrayList，这可是代价高昂的操作。因为对内存的开销很大，是数组复制的原因。 ArrayList源码 public ArrayList(Collection<? extends E> c) { elementData = c.toArray(); size = elementData.length; // c.toArray might (incorrectly) not return Object[] (see 6260652) if (elementData.getClass() != Object[].class) elementData = Arrays.copyOf(elementData, size, Object[].class); } Arrays.copyOf()，显然在数据很大时，任然需要数组复制，必然对内存的开销增大。 LinkedList源码： public LinkedList(Collection<? extends E> c) { this(); addAll(c); } public boolean addAll(int index, Collection<? extends E> c) { checkPositionIndex(index); Object[] a = c.toArray(); int numNew = a.length; if (numNew == 0) return false; Node<E> pred, succ; if (index == size) { succ = null; pred = last; } else { succ = node(index); pred = succ.prev; } for (Object o : a) { @SuppressWarnings("unchecked") E e = (E) o; Node<E> newNode = new Node<>(pred, e, null); if (pred == null) first = newNode; else pred.next = newNode; pred = newNode; } if (succ == null) { last = pred; } else { pred.next = succ; succ.prev = pred; } size += numNew; modCount++; return true; } 在LinkedList中有一个私有的内部类 private static class Entry { Object element; Entry next; Entry previous; } 每个Entry对象reference列表中的一个元素，同时还有在LinkedList中它的上一个元素和下一个元素。一个有1000个元素的LinkedList对象将有1000个链接在一起的Entry对象，每个对象都对应于列表中的一个元素。这样的话，在一个LinkedList结构中将有一个很大的空间开销，因为它要存储这1000个Entity对象的相关信息。 ArrayList使用一个内置的数组来存储元素，这个数组的起始容量是10.当数组需要增长时，新的容量按如下公式获得：新容量=(旧容量*3)/2+1，也就是说每一次容量大概会增长50%。这就意味着，如果你有一个包含大量元素的ArrayList对象，那么最终将有很大的空间会被浪费掉，这个浪费是由ArrayList的工作方式本身造成的。如果没有足够的空间来存放新的元素，数组将不得不被重新进行分配以便能够增加新的元素。对数组进行重新分配，将会导致性能急剧下降。如果我们知道一个ArrayList将会有多少个元素，我们可以通过构造方法来指定容量。我们还可以通过trimToSize方法在ArrayList分配完毕之后去掉浪费掉的空间。 LinkedList是基于链表来操作的，LinkedList保存了前后元素的信息，LinkedList在随机访问方面相对较慢，但是它的特性较ArrayList更大，系统不单也要考虑速度，对内存的开销也要考虑。 总结 ArrayList和LinkedList在性能上各有优缺点，都有各自所适用的地方，总的说来可以描述如下： 1．对ArrayList和LinkedList而言，在列表末尾增加一个元素所花的开销都是固定的。对ArrayList而言，主要是在内部数组中增加一项，指向所添加的元素，偶尔可能会导致对数组重新进行分配；而对LinkedList而言，这个开销是统一的，分配一个内部Entry对象。 2．在ArrayList的中间插入或删除一个元素意味着这个列表中剩余的元素都会被移动；而在LinkedList的中间插入或删除一个元素的开销是固定的。 3．LinkedList无法进行高效的元素访问。 4．ArrayList的空间浪费主要体现在在list列表的结尾预留一定的容量空间，而LinkedList的空间花费是它的每一个元素都需要消耗相当的空间来保存前后元素的位置。 在一列数据(无论数据是大是少)的后面部分添加/删除数据—不是在前面或中间；或者任何时候需要访问List元素时,使用ArrayList更好；在一列数据(无论数据量很大)的前面或中间部分添加/删除数据,就应该使用LinkedList了。 总体而言，ArrayList实际开发中用的更多。