package com.test;

import java.text.SimpleDateFormat;

import java.util.Date;

import java.util.concurrent.BrokenBarrierException;

import java.util.concurrent.CyclicBarrier;

import java.util.concurrent.ExecutorService;

import java.util.concurrent.Executors;

public class TestCyclicBarrier {

private static int[] timeWalk = { 5, 8, 15, 15, 10 };  // 徒步需要的时间

private static int[] timeSelf = { 1, 3, 4, 4, 5 };           // 自驾游

private static int[] timeBus = { 2, 4, 6, 6, 7 };           // 旅游大巴

static String now() {

            SimpleDateFormat sdf = new SimpleDateFormat("HH:mm:ss");

            return sdf.format(new Date()) + ": ";

}

static class Tour implements Runnable {

            private   int[]     times;

            private   CyclicBarrier    barrier;

            private   String   tourName;

public Tour(CyclicBarrier barrier, String tourName, int[] times) {

            this.times = times;

            this.tourName = tourName;

            this.barrier = barrier;

}

public void run() {

        try {

                 Thread.sleep(times[0] * 1000);

                  System.out.println(now() + tourName + " 合肥");

                  barrier.await();

                  Thread.sleep(times[1] * 1000);

                  System.out.println(now() + tourName + " 南京");

                   barrier.await();

                  Thread.sleep(times[4] * 1000);

                   System.out.println(now() + tourName + " 上海");

                   barrier.await();

                   System.out.println(tourName + "飞机 合肥");

         } catch (InterruptedException e) {

                   e.printStackTrace();

          } catch (BrokenBarrierException e) {

                    e.printStackTrace();

          }

    }

}

public static void main(String[] args) {

              CyclicBarrier barrier = new CyclicBarrier(3);

               ExecutorService exec = Executors.newFixedThreadPool(3);

               exec.submit(new Tour(barrier, "徒步", timeWalk));

               exec.submit(new Tour(barrier, "自驾", timeSelf));

               exec.submit(new Tour(barrier, "大巴", timeBus));

              exec.shutdown();

  }

}

最后执行结果如下：

16:24:35: 自驾 合肥

16:24:36: 大巴 合肥

16:24:39: 徒步 合肥

16:24:42: 自驾 南京

16:24:43: 大巴 南京

16:24:47: 徒步 南京

16:24:52: 自驾 上海

16:24:54: 大巴 上海

16:24:57: 徒步 上海

徒步飞机 合肥

自驾飞机 合肥

大巴飞机 合肥

用法一：常量

在JDK1.5 之前，我们定义常量都是： public static fianl.... 。现在好了，有了枚举，可以把相关的常量分组到一个枚举类型里，而且枚举提供了比常量更多的方法。

Java代码  

1. public enum Color {  
2.   RED, GREEN, BLANK, YELLOW  
3. }  

用法二：switch

JDK1.6之前的switch语句只支持int,char,enum类型，使用枚举，能让我们的代码可读性更强。

Java代码  

1. enum Signal {  
2.     GREEN, YELLOW, RED  
3. }  
4. public class TrafficLight {  
5.     Signal color = Signal.RED;  
6.     public void change() {  
7.         switch (color) {  
8.         case RED:  
9.             color = Signal.GREEN;  
10.             break;  
11.         case YELLOW:  
12.             color = Signal.RED;  
13.             break;  
14.         case GREEN:  
15.             color = Signal.YELLOW;  
16.             break;  
17.         }  
18.     }  
19. }  

用法三：向枚举中添加新方法

如果打算自定义自己的方法，那么必须在enum实例序列的最后添加一个分号。而且 Java 要求必须先定义 enum实例。

Java代码  

1. public enum Color {  
2.     RED("红色", 1), GREEN("绿色", 2), BLANK("白色", 3), YELLO("黄色", 4);  
3.     // 成员变量  
4.     private String name;  
5.     private int index;  
6.     // 构造方法  
7.     private Color(String name, int index) {  
8.         this.name = name;  
9.         this.index = index;  
10.     }  
11.     // 普通方法  
12.     public static String getName(int index) {  
13.         for (Color c : Color.values()) {  
14.             if (c.getIndex() == index) {  
15.                 return c.name;  
16.             }  
17.         }  
18.         return null;  
19.     }  
20.     // get set 方法  
21.     public String getName() {  
22.         return name;  
23.     }  
24.     public void setName(String name) {  
25.         this.name = name;  
26.     }  
27.     public int getIndex() {  
28.         return index;  
29.     }  
30.     public void setIndex(int index) {  
31.         this.index = index;  
32.     }  
33. }  

用法四：覆盖枚举的方法

下面给出一个toString()方法覆盖的例子。

Java代码  

1. public enum Color {  
2.     RED("红色", 1), GREEN("绿色", 2), BLANK("白色", 3), YELLO("黄色", 4);  
3.     // 成员变量  
4.     private String name;  
5.     private int index;  
6.     // 构造方法  
7.     private Color(String name, int index) {  
8.         this.name = name;  
9.         this.index = index;  
10.     }  
11.     //覆盖方法  
12.     @Override  
13.     public String toString() {  
14.         return this.index+"_"+this.name;  
15.     }  
16. }  

用法五：实现接口

所有的枚举都继承自java.lang.Enum类。由于Java 不支持多继承，所以枚举对象不能再继承其他类。

Java代码  

1. public interface Behaviour {  
2.     void print();  
3.     String getInfo();  
4. }  
5. public enum Color implements Behaviour{  
6.     RED("红色", 1), GREEN("绿色", 2), BLANK("白色", 3), YELLO("黄色", 4);  
7.     // 成员变量  
8.     private String name;  
9.     private int index;  
10.     // 构造方法  
11.     private Color(String name, int index) {  
12.         this.name = name;  
13.         this.index = index;  
14.     }  
15. //接口方法  
16.     @Override  
17.     public String getInfo() {  
18.         return this.name;  
19.     }  
20.     //接口方法  
21.     @Override  
22.     public void print() {  
23.         System.out.println(this.index+":"+this.name);  
24.     }  
25. }  

用法六：使用接口组织枚举

Java代码  

1. public interface Food {  
2.     enum Coffee implements Food{  
3.         BLACK_COFFEE,DECAF_COFFEE,LATTE,CAPPUCCINO  
4.     }  
5.     enum Dessert implements Food{  
6.         FRUIT, CAKE, GELATO  
7.     }  
8. }  

用法七：关于枚举集合的使用

java.util.EnumSet和java.util.EnumMap是两个枚举集合。EnumSet保证集合中的元素不重复；EnumMap中的key是enum类型，而value则可以是任意类型。关于这个两个集合的使用就不在这里赘述，可以参考JDK文档。

关于枚举的实现细节和原理请参考：

-Xms3000m：设置JVM促使内存为3000M。可设置与-Xmx相同，避免每次gc后JVM重新分配内存。

-Xmn1200m：设置年轻代大小为1200m。整个堆大小=年轻代大小+年老代大小。增大年轻代后，将会减小年老代大小。此值对系统性能影响较大，Sun官方推荐配置为整个堆的3/8。

-Xss256k： 设置每个线程的堆栈大小。JDK5.0以后每个线程堆栈大小为1024k，以前每个线程堆栈大小为256K。根据应用的线程所需内存大小进行调整。在相同物理内存下，减小这个值能生成更多的线程。但是操作系统对一个进程内的线程数还是有限制的，不能无限生成，经验值在3000~5000左右。

-XX:PermSize=96m  -XX:MaxPermSize=96m:设置持久代大小为64m，根据应用自身class文件大小进行设置，运行时空余量在10%------20%左右。

-XX:+UseConcMarkSweepGC：设置年老代为并发收集。

-XX:+UseParNewGC:设置年轻代为并行收集。可与CMS收集同时使用。JDK5.0以上，JVM会根据系统配置自行设置，所以无需再设置此值。

-XX:-CMSParallelRemarkEnabled ：If the -XX:+UseParNewGC option is in use the remark pauses may be decreased with the -XX:+CMSParallelRemarkEnabled option.

-XX:+UseCMSCompactAtFullCollection：打开对年老代的压缩。可能会影响性能，但是可以消除碎片(-XX:CMSFullGCsBeforeCompaction=5：由于并发收集器不对内存空间进行压缩、整理，所以运行一段时间以后会产生"碎片"，使得运行效率降低。此值设置运行多少次GC以后对内存空间进行压缩、整理, 避免每次压缩性能消耗)

*-XX:+CMSClassUnloadingEnabled:*Perm Gen的使用到达一定的比率(默认为92% ) 出发cms回收

-XX:+DisableExplicitGC：屏蔽system.gc(), 这种显示调用垃圾回收

-XX:+HeapDumpOnOutOfMemoryError：内存溢出打印堆栈信息

-XX:HeapDumpPath=/home/app_admin/logs/oom.log：heapdump的日志文件路径

-XX:+PrintGCDetails：打印gc日志详情

-XX:+PrintGCDateStamps：打印gc时的具体时间

-Xloggc:/home/app_admin/logs/gc.log：gc打印日志文件的路径

JVM内存结构

•      Method Area------方法区，被Class Loader所装载的class文件以及相关的方法信息、域信息、静态变量等都存放在这个区域内。该区域是所有Java线程所共享的。(设置方法区内存大小:-XX:PermSize -XX:MaxPermSize)

•      Heap------堆区，这个区域就是用来存放java对象的，通常GC也是针对该区域。一个Java虚拟机实例只有一个堆，并直接由java虚拟机进行管理，在虚拟机启动时创建。该区域可以被所有Java线程所共享。(设置堆内存大小:-Xms  -Xmx -Xmn)

•      Stack------栈区，用来存放JVM的内存局部变量和操作数栈。通常虚拟机对它的操作比较简单（以帧为单位的压栈和出栈），速度也很快。每个线程都有自己的栈，且栈可以不连续。(设置栈内存大小:-Xss)

•      Program Counter Register------每一个线程都有自己的一个PC寄存器，用于存放下一条被执行的指令的地址。每个线程的PC寄存器在线程启动时产生。

•      Native Method Stack------保存本地方法进入区域的地址。(设置栈内存大小:-Xss)
  






GC日志格式说明：

[GC [<collector>: <starting occupancy1> -> <ending occupancy1>, <pause time1> secs] <starting occupancy3> -> <ending occupancy3>, <pause time3> secs]

<collector>GC收集器的名称

<starting occupancy1> 新生代在GC前占用的内存

<ending occupancy1> 新生代在GC后占用的内存

<pause time1> 新生代局部收集时jvm暂停处理的时间

<starting occupancy3> JVM Heap 在GC前占用的内存

<ending occupancy3> JVM Heap 在GC后占用的内存

<pause time3> GC过程中jvm暂停处理的总时间

YGC收集信息

2012-2-7T19:24:29.040+0800: 10429.503: [GC [PSYoungGen: 484520K->2577K(495936K)] 734774K->254308K(3129664K), 0.0118730 secs] [Times: user=0.03 sys=0.00, real=0.01 secs]

FGC收集信息

2012-2-7T19:38:37.391+0800: 10804.897: [Full GC (System) [PSYoungGen: 684K->0K(468416K)] [PSOldGen: 342164K->257451K(1060864K)] 342849K->257451K(1529280K) [PSPermGen: 123775K->122206K(237248K)], 1.1808050 secs] [Times: user=0.99 sys=0.18, real=1.18 secs] 

JVM运行期分析工具

jps 虚拟机进程状况工具

jinfo java配置信息工具

jstat 虚拟机统计信息监视工具

jmap java内存映射工具

jhat 虚拟机堆转储快照分析工具

jstack java堆栈跟踪工具 

一、final 
　根据程序上下文环境，Java关键字final有“这是无法改变的”或者“终态的”含义，它可以修饰非抽象类、非抽象类成员方法和变量。你可能出于两种理解而需要阻止改变：设计或效率。 
final类不能被继承，没有子类，final类中的方法默认是final的。 
final方法不能被子类的方法覆盖，但可以被继承。 
final成员变量表示常量，只能被赋值一次，赋值后值不再改变。 
final不能用于修饰构造方法。 
注意：父类的private成员方法是不能被子类方法覆盖的，因此private类型的方法默认是final类型的。 

1、final类 
　final类不能被继承，因此final类的成员方法没有机会被覆盖，默认都是final的。在设计类时候，如果这个类不需要有子类，类的实现细节不允许改变，并且确信这个类不会载被扩展，那么就设计为final类。 

2、final方法 
如果一个类不允许其子类覆盖某个方法，则可以把这个方法声明为final方法。 
使用final方法的原因有二： 
第一、把方法锁定，防止任何继承类修改它的意义和实现。 
第二、高效。编译器在遇到调用final方法时候会转入内嵌机制，大大提高执行效率。 
例如：

3、final变量（常量） 
　用final修饰的成员变量表示常量，值一旦给定就无法改变！ 
　final修饰的变量有三种：静态变量、实例变量和局部变量，分别表示三种类型的常量。 
　从下面的例子中可以看出，一旦给final变量初值后，值就不能再改变了。 
　另外，final变量定义的时候，可以先声明，而不给初值，这中变量也称为final空白，无论什么情况，编译器都确保空白final在使用之前必须被初始化。但是，final空白在final关键字final的使用上提供了更大的灵活性，为此，一个类中的final数据成员就可以实现依对象而有所不同，却有保持其恒定不变的特征。

 
4、final参数 
当函数参数为final类型时，你可以读取使用该参数，但是无法改变该参数的值。

二、static 

　static表示“全局”或者“静态”的意思，用来修饰成员变量和成员方法，也可以形成静态static代码块，但是Java语言中没有全局变量的概念。 

　被static修饰的成员变量和成员方法独立于该类的任何对象。也就是说，它不依赖类特定的实例，被类的所有实例共享。只要这个类被加载，Java虚拟机就能根据类名在运行时数据区的方法区内定找到他们。因此，static对象可以在它的任何对象创建之前访问，无需引用任何对象。 

　用public修饰的static成员变量和成员方法本质是全局变量和全局方法，当声明它类的对象市，不生成static变量的副本，而是类的所有实例共享同一个static变量。 

　static变量前可以有private修饰，表示这个变量可以在类的静态代码块中，或者类的其他静态成员方法中使用（当然也可以在非静态成员方法中使用--废话），但是不能在其他类中通过类名来直接引用，这一点很重要。实际上你需要搞明白，private是访问权限限定，static表示不要实例化就可以使用，这样就容易理解多了。static前面加上其它访问权限关键字的效果也以此类推。 

　static修饰的成员变量和成员方法习惯上称为静态变量和静态方法，可以直接通过类名来访问，访问语法为： 
类名.静态方法名(参数列表...) 
类名.静态变量名 

　用static修饰的代码块表示静态代码块，当Java虚拟机（JVM）加载类时，就会执行该代码块（用处非常大，呵呵）。 

1、static变量 
　按照是否静态的对类成员变量进行分类可分两种：一种是被static修饰的变量，叫静态变量或类变量；另一种是没有被static修饰的变量，叫实例变量。两者的区别是： 
　对于静态变量在内存中只有一个拷贝（节省内存），JVM只为静态分配一次内存，在加载类的过程中完成静态变量的内存分配，可用类名直接访问（方便），当然也可以通过对象来访问（但是这是不推荐的）。 
　对于实例变量，没创建一个实例，就会为实例变量分配一次内存，实例变量可以在内存中有多个拷贝，互不影响（灵活）。 

2、静态方法 
　静态方法可以直接通过类名调用，任何的实例也都可以调用，因此静态方法中不能用this和super关键字，不能直接访问所属类的实例变量和实例方法(就是不带static的成员变量和成员成员方法)，只能访问所属类的静态成员变量和成员方法。因为实例成员与特定的对象关联！这个需要去理解，想明白其中的道理，不是记忆！！！ 
　因为static方法独立于任何实例，因此static方法必须被实现，而不能是抽象的abstract。 

3、static代码块 
　static代码块也叫静态代码块，是在类中独立于类成员的static语句块，可以有多个，位置可以随便放，它不在任何的方法体内，JVM加载类时会执行这些静态的代码块，如果static代码块有多个，JVM将按照它们在类中出现的先后顺序依次执行它们，每个代码块只会被执行一次。例如：

cron is a UNIX tool that has been around for a long time, so its scheduling capabilities are powerful and proven. TheCronTrigger class is based on the scheduling capabilities of cron.

CronTrigger uses "cron expressions", which are able to create firing schedules such as: "At 8:00am every Monday through Friday" or "At 1:30am every last Friday of the month".

Cron expressions are powerful, but can be pretty confusing. This tutorial aims to take some of the mystery out of creating a cron expression, giving users a resource which they can visit before having to ask in a forum or mailing list.

Format

A cron expression is a string comprised of 6 or 7 fields separated by white space. Fields can contain any of the allowed values, along with various combinations of the allowed special characters for that field. The fields are as follows:

So cron expressions can be as simple as this: * * * * ? *

or more complex, like this: 0/5 14,18,3-39,52 * ? JAN,MAR,SEP MON-FRI 2002-2010

Special characters

• * ("all values") - used to select all values within a field. For example, "" in the minute field means *"every minute".

• ? ("no specific value") - useful when you need to specify something in one of the two fields in which the character is allowed, but not the other. For example, if I want my trigger to fire on a particular day of the month (say, the 10th), but don't care what day of the week that happens to be, I would put "10" in the day-of-month field, and "?" in the day-of-week field. See the examples below for clarification.

• - - used to specify ranges. For example, "10-12" in the hour field means "the hours 10, 11 and 12".

• , - used to specify additional values. For example, "MON,WED,FRI" in the day-of-week field means "the days Monday, Wednesday, and Friday".

• / - used to specify increments. For example, "0/15" in the seconds field means "the seconds 0, 15, 30, and 45". And "5/15" in the seconds field means "the seconds 5, 20, 35, and 50". You can also specify '/' after the '' character - in this case '' is equivalent to having '0' before the '/'. '1/3' in the day-of-month field means "fire every 3 days starting on the first day of the month".

• L ("last") - has different meaning in each of the two fields in which it is allowed. For example, the value "L" in the day-of-month field means "the last day of the month" - day 31 for January, day 28 for February on non-leap years. If used in the day-of-week field by itself, it simply means "7" or "SAT". But if used in the day-of-week field after another value, it means "the last xxx day of the month" - for example "6L" means "the last friday of the month". When using the 'L' option, it is important not to specify lists, or ranges of values, as you'll get confusing results.

• W ("weekday") - used to specify the weekday (Monday-Friday) nearest the given day. As an example, if you were to specify "15W" as the value for the day-of-month field, the meaning is: "the nearest weekday to the 15th of the month". So if the 15th is a Saturday, the trigger will fire on Friday the 14th. If the 15th is a Sunday, the trigger will fire on Monday the 16th. If the 15th is a Tuesday, then it will fire on Tuesday the 15th. However if you specify "1W" as the value for day-of-month, and the 1st is a Saturday, the trigger will fire on Monday the 3rd, as it will not 'jump' over the boundary of a month's days. The 'W' character can only be specified when the day-of-month is a single day, not a range or list of days.

The 'L' and 'W' characters can also be combined in the day-of-month field to yield 'LW', which translates to *"last weekday of the month"*.

• # - used to specify "the nth" XXX day of the month. For example, the value of "6#3" in the day-of-week field means"the third Friday of the month" (day 6 = Friday and "#3" = the 3rd one in the month). Other examples: "2#1" = the first Monday of the month and "4#5" = the fifth Wednesday of the month. Note that if you specify "#5" and there is not 5 of the given day-of-week in the month, then no firing will occur that month.

The legal characters and the names of months and days of the week are not case sensitive. MON is the same as mon.

Examples

Here are some full examples:

Pay attention to the effects of '?' and '*' in the day-of-week and day-of-month fields!

Notes

• Support for specifying both a day-of-week and a day-of-month value is not complete (you must currently use the '?' character in one of these fields).
• Be careful when setting fire times between mid-night and 1:00 AM - "daylight savings" can cause a skip or a repeat depending on whether the time moves back or jumps forward.

jps类似linux的ps命令，不同的是ps是用来显示进程，而jps只显示java进程，准确的说是当前用户已启动的部分java进程信息，信息包括进程号和简短的进程command。

2、某个java进程已经启动，用jps却显示不了该进程进程号

这个问题已经碰到过两次了，所以在这里总结下。

现象：

用ps -ef|grep java能看到启动的java进程，但是用jps查看却不存在该进程的id。待会儿解释过之后就能知道在该情况下，jconsole、jvisualvm可能无法监控该进程，其他java自带工具也可能无法使用

分析：

java程序启动后，默认（请注意是默认）会在/tmp/hsperfdata_userName目录下以该进程的id为文件名新建文件，并在该文件中存储jvm运行的相关信息，其中的userName为当前的用户名，/tmp/hsperfdata_userName目录会存放该用户所有已经启动的java进程信息。对于windows机器/tmp用Windows存放临时文件目录代替。

而jps、jconsole、jvisualvm等工具的数据来源就是这个文件（/tmp/hsperfdata_userName/pid)。所以当该文件不存在或是无法读取时就会出现jps无法查看该进程号，jconsole无法监控等问题

原因：

（1）、磁盘读写、目录权限问题

若该用户没有权限写/tmp目录或是磁盘已满，则无法创建/tmp/hsperfdata_userName/pid文件。或该文件已经生成，但用户没有读权限

（2）、临时文件丢失，被删除或是定期清理

对于linux机器，一般都会存在定时任务对临时文件夹进行清理，导致/tmp目录被清空。这也是我第一次碰到该现象的原因。常用的可能定时删除临时目录的工具为crontab、redhat的tmpwatch、ubuntu的tmpreaper等等

这个导致的现象可能会是这样，用jconsole监控进程，发现在某一时段后进程仍然存在，但是却没有监控信息了。

（3）、java进程信息文件存储地址被设置，不在/tmp目录下

上面我们在介绍时说默认会在/tmp/hsperfdata_userName目录保存进程信息，但由于以上1、2所述原因，可能导致该文件无法生成或是丢失，所以java启动时提供了参数(-Djava.io.tmpdir)，可以对这个文件的位置进行设置，而jps、jconsole都只会从/tmp目录读取，而无法从设置后的目录读物信息，这是我第二次碰到该现象的原因

关于设置该文件位置的参数为-Djava.io.tmpdir

其他：

/tmp/hsperfdata_userName/pid文件会在对应java进程退出后被清除。如果java进程非正常退出（如kill -9），那么pid文件会被保留，直到执行一次java命令或是加载了jvm程序的命令（如jps、javac、jstat），会将所有无用的pid文件都清除掉

Occurs when an exception is thrown in the contextInitialized method of a ServletContextListener

SEVERE: Error filterStart

Occurs when an exception is thrown in the init method of a Filter

Unfortunately by default, tomcat won't provide you with any details about the cause of the error. Infact it wont even tell you which filter or listener is failing. This can be big problem in applications of significant size that have many filters and listeners configured. Fortunately there is a solution. In your webapplication's WEB-INF/classes folder you can create a logging.properties file with the following contents

org.apache.catalina.core.ContainerBase.[Catalina].level = INFO
org.apache.catalina.core.ContainerBase.[Catalina].handlers = java.util.logging.ConsoleHandler

Now you will be presented with the stacktrace

　　 %p 输出优先级，即DEBUG，INFO，WARN，ERROR，FATAL 
　　%r 输出自应用启动到输出该log信息耗费的毫秒数 
　　%c 输出所属的类目，通常就是所在类的全名 
　　%t 输出产生该日志事件的线程名 
　　%n 输出一个回车换行符，Windows平台为“\r\n”，Unix平台为“\n” 
　　%d 输出日志时间点的日期或时间，默认格式为ISO8601，也可以在其后指定格式，比如：%d{yyy MMM dd HH:mm:ss,SSS}，输出类似： 2002年10月18日 22：10：28，921 
　　%l 输出日志事件的发生位置，包括类目名、发生的线程，以及在代码中的行数。举例：Testlog4.main(TestLog4.java:10)

AOP技术即（面向切面编程）技术是在面向对象编程基础上的发展，AOP技术是对所有对象或一类对象编程。核心是在不增加代码的基础上，还增加了新的功能。AOP编程在开发框架本身用的比较多，而实际项目中，用的比较少。它是将分散在各个业务逻辑代码中的相同代码抽取出来形成一个独立的模块。

1、定义AOP术语

（1）切面（aspect）：要实现的交叉功能，是系统模块化的一个切面或领域。

（2）通知（advice）：切面的具体实现，包含五类通知。

（3）连接点（jointpoint）：应用程序执行过程中插入切面的地点。

（4）切点（cutpoint）：定义通知应该应用哪些连接点。

（5）引入（introduction）：为类添加新方法和属性。

（6）目标对象（target）：通知逻辑的织入目标类。

（7）代理（proxy）：将通知应用到目标对象后创建的对象，应用系统的其他部分不用为了支持代理对象而改变

（8）织入（weaving）：将切面应用到目标对象从而创建一个新代理对象的过程。

2、AOP原理和实例

（1）基础接口和类的实现：

（2）实现类如下：

package com.jasson.aop;

public class TestService implements TestServiceInter1,TestServiceInter2 {

    public void sayHello() {
        System.out.println("sayHello() method ");
    }

    public void sayBye() {
        System.out.println("sayBye() method");
    }
    
    public void sayHi() {
        System.out.println("sayHi() method");
    }
}

（1）前置通知：要求在每个方法调用前进行日志记录，则用的前置通知，定义如下：

package com.jasson.aop;

import java.lang.reflect.Method;

import org.springframework.aop.MethodBeforeAdvice;

public class MyMethodBeforeAdvice implements MethodBeforeAdvice {

    /**
     * method: 方法名
     * args: 输入参数
     * target: 目标对象
     */
    public void before(Method method, Object[] args, Object target)
            throws Throwable {
        System.out.println("前置通知调用 记录日志"+method.getName());
    }
}

配置文件如下：

} 

 执行结果如下：

31-May-2012 18:19:53 org.springframework.beans.factory.support.DefaultListableBeanFactory preInstantiateSingletons
INFO: Pre-instantiating singletons in org.springframework.beans.factory.support.DefaultListableBeanFactory@c8f6f8: defining beans [testService,myMethodBeforeAdvice,
myAfterReturningAdvice,myMethodInterceptor,myThrowsAdvice,proxyFactoryBean]; root of factory hierarchy
前置通知调用 记录日志sayHello
sayHello() method 
*******************************************
前置通知调用 记录日志sayBye
sayBye() method
*******************************************
前置通知调用 记录日志sayHi
sayHi() method

（2）后置通知：要求在调用每个方法后执行的功能，例如在调用每个方法后关闭资源

package com.jasson.aop;

import java.lang.reflect.Method;

import org.springframework.aop.AfterReturningAdvice;

public class MyAfterReturningAdvice implements AfterReturningAdvice {

    @Override
    public void afterReturning(Object returnValue, Method method, Object[] arg,
            Object target) throws Throwable {
        // TODO Auto-generated method stub
        System.out.println("后置通知调用，关闭资源"+method.getName());
    }

}
 bean 配置如下：

<?xml version="1.0" encoding="utf-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xmlns:context="http://www.springframework.org/schema/context"
        xmlns:tx="http://www.springframework.org/schema/tx"
        xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
                http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd
                http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd" 
                >
<!-- 配置被代理的对象,即目标对象 -->
<bean id="testService" class="com.jasson.aop.TestService" />
<!-- 配置前置通知 -->
<bean id="myMethodBeforeAdvice" class="com.jasson.aop.MyMethodBeforeAdvice" />
<!-- 配置后置通知 -->
<bean id="myAfterReturningAdvice" class="com.jasson.aop.MyAfterReturningAdvice" />
<!-- 配置代理对象 -->
<bean id="proxyFactoryBean" class="org.springframework.aop.framework.ProxyFactoryBean">
    <!-- 代理接口集 -->
    <property name="proxyInterfaces">
        <list>
            <value>com.jasson.aop.TestServiceInter1</value>
            <value>com.jasson.aop.TestServiceInter2</value>
        </list>
    </property>
    <!-- 把通知织入到代理对象  -->
    <property name="interceptorNames">
        <!-- 相当于包MyMethodBeforeAdvice前置通知和代理对象关联,我们也
        可以把通知看出拦截器,struts2核心拦截器 -->
        <list>
            <value>myMethodBeforeAdvice</value>
            <value>myAfterReturningAdvice</value>
        </list>
    </property>
    <!-- 配置被代理对象,即目标对象 -->
    <property name="target" ref="testService"/>
</bean>
</beans>

执行结果如下：

INFO: Pre-instantiating singletons in org.springframework.beans.factory.support.DefaultListableBeanFactory@122cdb6: defining beans [testService,myMethodBeforeAdvice,myAfterReturningAdvice,myMethodInterceptor,myThrowsAdvice,proxyFactoryBean]; root of factory hierarchy
前置通知调用 记录日志sayHello
sayHello() method 
后置通知调用，关闭资源sayHello
*******************************************
前置通知调用 记录日志sayBye
sayBye() method
后置通知调用，关闭资源sayBye
*******************************************
前置通知调用 记录日志sayHi
sayHi() method

后置通知调用，关闭资源sayHi 

（3）环绕通知：指在某个具体的方法中，添加相应的操作

package com.jasson.aop;

import org.aopalliance.intercept.MethodInterceptor;
import org.aopalliance.intercept.MethodInvocation;

public class MyMethodInterceptor implements MethodInterceptor {

    @Override
    public Object invoke(MethodInvocation arg) throws Throwable {
        // TODO Auto-generated method stub
        System.out.println("环绕通知调用方法前");
        Object obj = arg.proceed();
        System.out.println("环绕通知调用方法后");
        return obj;
    }
}

配置文件如下：

</beans>
 执行结果如下：

INFO: Pre-instantiating singletons in org.springframework.beans.factory.support.DefaultListableBeanFactory@1ce2dd4: defining beans [testService,myMethodBeforeAdvice,myAfterReturningAdvice,myMethodInterceptor,proxyFactoryBean]; root of factory hierarchy
前置通知调用 记录日志sayHello
环绕通知调用方法前
sayHello() method 
环绕通知调用方法后
后置通知调用，关闭资源sayHello
*******************************************
前置通知调用 记录日志sayBye
环绕通知调用方法前
sayBye() method
环绕通知调用方法后
后置通知调用，关闭资源sayBye
*******************************************
前置通知调用 记录日志sayHi
环绕通知调用方法前
sayHi() method
环绕通知调用方法后

后置通知调用，关闭资源sayHi
 （4）异常通知：当发生异常时，要执行的通知

 
执行结果如下：

INFO: Pre-instantiating singletons in org.springframework.beans.factory.support.DefaultListableBeanFactory@1ce2dd4: defining beans [testService,myMethodBeforeAdvice,myAfterReturningAdvice,myMethodInterceptor,myThrowsAdvice,proxyFactoryBean]; root of factory hierarchy
前置通知调用 记录日志sayHello
环绕通知调用方法前
sayHello() method 
环绕通知调用方法后
后置通知调用，关闭资源sayHello
*******************************************
前置通知调用 记录日志sayBye
环绕通知调用方法前
sayBye() method
环绕通知调用方法后
后置通知调用，关闭资源sayBye
*******************************************
前置通知调用 记录日志sayHi
环绕通知调用方法前
异常通知产生异常，进行处理/ by zero

Exception in thread "main" java.lang.ArithmeticException: / by zero 

（5）上面的通知都是针对每个方法的，如果只是对单个或者一类的方法进行相应处理的时，可采用名字或者正则表达式的方式进行处理

配置如下：

<?xml version="1.0" encoding="utf-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xmlns:context="http://www.springframework.org/schema/context"
        xmlns:tx="http://www.springframework.org/schema/tx"
        xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
                http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd
                http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd" 
                >
<!-- 配置被代理的对象,即目标对象 -->
<bean id="testService" class="com.jasson.aop.TestService" />
<!-- 配置前置通知 -->
<bean id="myMethodBeforeAdvice" class="com.jasson.aop.MyMethodBeforeAdvice" />
<!-- 配置后置通知 -->
<bean id="myAfterReturningAdvice" class="com.jasson.aop.MyAfterReturningAdvice" />
<!-- 配置环绕通知 -->
<bean id="myMethodInterceptor" class="com.jasson.aop.MyMethodInterceptor" />
<!-- 配置异常通知 -->
<bean id="myThrowsAdvice" class="com.jasson.aop.MyThrowsAdvice" />

<!-- 通知与正则表达式切入点一起配置 -->  
<!-- Advisor等于切入点加通知,所有say开头的方法添加前置通知 -->  
<bean id="regexpPointcutAdvisor" class="org.springframework.aop.support.RegexpMethodPointcutAdvisor">  
    <property name="advice" ref="myMethodBeforeAdvice"/>  
    <property name="patterns">  
        <list>  
            <value>.*say.*</value>  
        </list>  
    </property>  
</bean>  

<!-- 方法名匹配切入点配置器：只对 sayHello方法添加环绕通知-->  
<bean id="namePointcutAdvisor" class="org.springframework.aop.support.NameMatchMethodPointcutAdvisor">  
    <property name="advice" ref="myMethodInterceptor"/>  
    <property name="mappedNames">  
        <list>  
            <value>sayHello</value>  
        </list>  
    </property>  
</bean> 

<!-- 配置代理对象 -->
<bean id="proxyFactoryBean" class="org.springframework.aop.framework.ProxyFactoryBean">
    <!-- 代理接口集 -->
    <property name="proxyInterfaces">
        <list>
            <value>com.jasson.aop.TestServiceInter1</value>
            <value>com.jasson.aop.TestServiceInter2</value>
        </list>
    </property>
    <!-- 把通知织入到代理对象  -->
    <property name="interceptorNames">
        <!-- 相当于包MyMethodBeforeAdvice前置通知和代理对象关联,我们也
        可以把通知看出拦截器,struts2核心拦截器 -->
        <list>
            <value>namePointcutAdvisor</value>
            <value>myAfterReturningAdvice</value>
            <value>regexpPointcutAdvisor</value>
            <value>myThrowsAdvice</value>
        </list>
    </property>
    <!-- 配置被代理对象,即目标对象 -->
    <property name="target" ref="testService"/>
</bean>
</beans>

执行结果如下：

INFO: Pre-instantiating singletons in org.springframework.beans.factory.support.DefaultListableBeanFactory@1ef9157: defining beans 
[testService,myMethodBeforeAdvice,myAfterReturningAdvice,myMethodInterceptor,myThrowsAdvice,regexpPointcutAdvisor,namePointcutAdvisor,proxyFactoryBean]; 
root of factory hierarchy
环绕通知调用方法前
前置通知调用 记录日志sayHello
sayHello() method 
后置通知调用，关闭资源sayHello
环绕通知调用方法后
*******************************************
前置通知调用 记录日志sayBye
sayBye() method
后置通知调用，关闭资源sayBye
*******************************************
前置通知调用 记录日志sayHi
异常通知产生异常，进行处理/ by zero
Exception in thread "main" java.lang.ArithmeticException: / by zero

The serializable class xxx does not declare a static final serialVersionUID field of type long

So…what is serialVersionUID?

The serialVersionUID is used as a version control in a Serializable class. If you do not explicitly declare a serialVersionUID, JVM will do it for you automatically, based on various aspects of your Serializable class, as described in the Java(TM) Object Serialization Specification.

1. SerialVersionUID Example

The above statement is a bit hard to understand at the beginning (at least I did), let start an example to understand how Serializable class use SerialVersionUID to implement version control.

1.1 Address.java

A serializable class with a serialVersionUID of 1L.

1.2 WriteObject.java

A simple class to write / serialize the Address object into a file – “c:\\address.ser”.

1.3 ReadObject.java

A simple class to read / deserialize the Address object from file – “c:\\address.ser”.

2. Testing

Let do some testing to demonstrate the use of serialVersionUID.

2.1 Same serialVersionUID

Same serialVersionUID , there is no problem during the deserialization process

2.2 Different serialVersionUID

In Address.java, change the serialVersionUID to 2L (it was 1L), and compile it again.

javac Address.java
java ReadObject
java.io.InvalidClassException: Address; local class incompatible: 
stream classdesc serialVersionUID = 1, local class serialVersionUID = 2
         
        at ReadObject.main(ReadObject.java:14)

The “InvalidClassException” will raise, because you write a serialization class with serialVersionUID “1L” but try to retrieve it back with updated serialization class, serialVersionUID “2L”.

The serialVersionUID have to match during the serialization and deserialization process.

3. What’s wrong with the default serialVersionUID?

If no serialVersionUID is declared, JVM will use its own algorithm to generate a default SerialVersionUID, you can check the algorithm here.

The default serialVersionUID computation is highly sensitive to class details and may vary from different JVM implementation, and result in an unexpected InvalidClassExceptions during the deserialization process.

3.1 Client / Server environment

- Client is using SUN’s JVM in Windows.
- Server is using JRockit in Linux.

The client sends a serializable class with default generated serialVersionUID (e.g 123L) to the server over socket, the server may generate a different serialVersionUID (e.g 124L) during deserialization process, and raises an unexpected InvalidClassExceptions.

3.2 File / Database environment

- App #1 is using SUN’s JVM in Windows.
- App #2 is using JRockit in Linux.

Serialization has allowed to save into a file or database. App #1 stores a serializable class into database by default generated serialVersionUID (e.g 123L), while App #2 may generate a different serialVersionUID (e.g 124L) during deserialization process, and raise an unexpected InvalidClassExceptions.

You can check here for the List of the JVM implementation.

4. How to generate serialVersionUID

You can use JDK “serialver” or Eclipse IDE to generate serialVersionUID automatically, see detail.

Conclusion

SUN is highly recommended developers to declare the serialVersionUID in order to avoid the different JVM issue listed above, however I rather recommend you should understand what is serialization, how serialVersionUID implement version control and why your class need to use serialization. Understand the serialVersionUID concept is better than blindfold to any recommendation.

假如我们有两个类型People和Student，其中student继承自People。如果执行下面的代码：

1．  接口注入

2．  Setter方法注入

3．  构造方法注入

下面介绍一下这三种依赖注入在Spring中是怎么样实现的。

首先我们需要以下几个类：

接口 Logic.java

接口实现类 LogicImpl.java

一个处理类 LoginAction.java

还有一个测试类 TestMain.java

Logic.java如下：

package com.spring.test.di;

public interface Logic {

    public String getName();

}

LogicImpl.java如下：

package com.spring.test.di;

public class LogicImpl implements Logic{

    public String getName(){

       return "fengyun";

    }

}

TestMain.java

package com.spring.test.di;

import org.springframework.context.ApplicationContext;

import org.springframework.context.support.FileSystemXmlApplicationContext;

public class TestMain {

    /**

     * @param args

     */

    public static void main(String[] args) {

       // 得到ApplicationContext对象

       ApplicationContext ctx = new FileSystemXmlApplicationContext(

              "applicationContext.xml");

       // 得到Bean

       LoginAction loginAction = (LoginAction) ctx.getBean("loginAction");

       loginAction.execute();

    }

}

LoginAction.java 会根据使用不同的注入方法而稍有不同

下面按照注入的方法来看LoginAction.java类

Setter方法注入：

package com.spring.test.di;

public class LoginAction {

    private Logic logic;

    public void execute() {

       String name = logic.getName();

       System.out.print("My Name Is " + name);  

    }

    /**

     * @return the logic

     */

    public Logic getLogic() {

       return logic;

    }

    /**

     * @param logic

     *            the logic to set

     */

    public void setLogic(Logic logic) {

       this.logic = logic;

    }

}

定义了一个Logic 类型的变量 logic, 在LoginAction并没有对logic 进行实例化，而只有他对应的setter/getter方法，因为我们这里使用的是Spring的依赖注入的方式

applicationContext.xml配置文件如下:

<bean id="logic" class="com.spring.test.di.LogicImpl"/>

<bean id="loginAction" class="com.spring.test.di.LoginAction">

 <property name="logic" ref="logic"></property>

</bean>

现在可以运行testMain.java了，我们可以看到控制台打出了 My Name Is fengyun

OK了，这就是spring的setter方法注入，非常简单

下面我们来看看构造方法注入

顾名思义，构造方法注入，就是我们依靠LoginAction的构造方法来达到DI的目的，如下所示：

LoginAction.java

package com.spring.test.di;

public class LoginAction {

    private Logic logic;

    public LoginAction(Logic logic) {

       this.logic = logic;

    }

    public void execute() {

       String name = logic.getName();

       System.out.print("My Name Is " + name);

    }

}

这里我们添加了一个LoginAction的构造方法

applicationContext.xml配置文件如下:

<bean id="logic" class="com.spring.test.di.LogicImpl"/>

<bean id="loginAction" class="com.spring.test.di.LoginAction">

 <constructor-arg index="0" ref="logic"></constructor-arg>

</bean>

我们使用constructor-arg来进行配置, index属性是用来表示构造方法中参数的顺序的，如果有多个参数，则按照顺序，从 0,1...来配置

我们现在可以运行testMain.java了,结果跟使用Setter方法注入完全一样.

其中需要注意一点有：构造函数有多个参数的话，如：参数1，参数2，而参数2依赖于参数1，这中情况则要注意构造函数的顺序，必须将参数1放在参数2之前。

下面继续说说我们不常用到的接口注入，还是以LogicAction为例，我们对他进行了修改，如下所示：

LogicAction.java

package com.spring.test.di;

public class LoginAction {

    private Logic logic;

    public void execute() {

       try {

           Object obj = Class.forName("com.spring.test.di.LogicImpl")

                  .newInstance();

           logic = (Logic) obj;

           String name = logic.getName();

           System.out.print("My Name Is " + name);

       } catch (Exception e) {

           e.printStackTrace();

       }

    }

}

配置文件：

<bean id="logic" class="com.spring.test.di.LogicImpl"/>

<bean id="loginAction" class="com.spring.test.di.LoginAction">

</bean>

对于接口注入这种方式，以上也只是我个人理解，不知道是否有什么问题。呵呵

我们最常用就是Setter和构造函数这两种注入方法，至于他们各自的对比，我想在只要baidu一下就可以有清楚的答案了。

对于Spring的依赖注入，最重要的就是理解他的，一旦理解了，将会觉得非常的简单。无非就是让容器来给我们实例化那些类，我们要做的就是给容器提供这个接口，这个接口就我们的set方法或者构造函数了。

• 强引用：除非将引用置为null，否则JVM不会对它垃圾，这是最常用的引用方式
• 软引用：在堆内存不足的时候，GC会将其垃圾回收
• 弱引用：每次GC都会将其垃圾回收
• 幻影引用：跟没有引用一样，每次获得的都是空的，没有太多使用的意义，仅是为了追踪对象在JVM的状态

      一般对于大数据量的Cache信息或大对象，使用软引用/弱引用是一种非常好的习惯，或者至少使用一种淘汰算法，避免在堆内存拥挤大量的对象导致内存不足，如下是两个非常好的JDK默认提供的HashMap替代者：

• org.apache.commons.collections.map.ReferenceMap：支持强引用/软引用和弱引用来存储key/value对
• org.apache.commons.collections.map.LRUMap：可以控制总容量，采用LRU淘汰算法，将不常使用的数据淘汰出去

       介绍完一些背景，我们开始进入主题。在开始分析之前，我们需要先dump下JVM的堆内存信息（虽然Eclipse Memory Analyzer直接attach到JVM上获取栈再分析，实际应用价值不大）

     现在我们有了test.bin这个堆文件，使用Eclipse Memory Analyzer打开，分析完堆，我们可以选择“Leak Suspects Report”进行内存泄露分析。通过这个视图，我们可以大概得到内存泄露的初步结论
 
     Historygram也是一个非常常用的视图，可以获得堆中对象的数据统计，有排序、过滤的功能，非常好用
 
       Eclipse Memory Analyzer还包括如下功能：

• 在Historygram视图中右击对象弹出的功能框中，可以获得对象相互引用的关系的功能
• Dominator Tree的视图采用Tree的方式来展现整个栈对象相互引用的情况
• OQL视图支持使用OQL语言来查询对象信息

JProfile or YourKit

Finding a memory leak can be difficult, even when you've got some good tools to give you an idea what's happening in your heap. If you can narrow down the operations that are leak suspects that goes a long way to finding the problem.

However, if you aren't sure where to start, your best bet is to find a good profiler that will let you walk the heap. My favorites are JProfiler and YourKit, though some of the others people here have suggested are decent as well. They both cost money, but getting a trial license isn't terribly difficult.

Once in there you'll want to look for what objects are taking up the most heap size. Unfortunately, it's almost always char[], byte[], and String taking up the most space, so you can walk the heap to find what objects are holding onto the largest instances of those objects. Also, the profiler should have the ability to show you the deep size of an object, so be on the lookout for instances of your own classes that have fairly large deep sizes.

Another technique is if you have a suspect operation, is to see if the heap is growing as you perform the operation. The profiler will have the ability to force a garbage collection (you can also do this through jconsole), so perform this operation before and after your operation and see if the heap has grown in size.

Sometimes the leak could be undetectable by these means though since you might see totally random results. A few months ago, I was looking at a leak that was caused by someone synchronizing the finalize method of an object which halted garbage collection. Another time, the leak wasn't a leak, but rather just a certain request was throwing out of memory because even though the heap was 50% free, there wasn't a large enough contiguous block for that request. So it's a lot of trail and error, and the best approach is to try to form a hypothesis and prove it to be true or false as quickly as you can.