确实，对于VB或者VC来说,用Java写桌面程序难度差的不是一个数量级。Java语言，本来就不适合快速开发，对于Java大部分的开发框架，本不是针对快速开发而言，而是为了更好的扩展与重构。

个人认为，Swing的难点在于复杂的布局管理器。只要吃透了这个，写Java桌面程序就简单了。

1.流式布局 (FlowLayout)

这是面板(JPanel)的默认布局管理器。流式布局管理器的特点是在一行上水平排列组件，直到没有足够的空间为止，这时开始新的一行。当用户缩放容器时，布局管理器自动地调整组件的位置使其填充可用的空间。

FlowLayout有三种构造方法,

• FlowLayout() : 使用居中的对齐方式,组件间水平和垂直间距都为5。
• FlowLayout(int align) : align表示对齐方式,可以是LEFT,CENTER或RIGHT。
• FlowLayout(int align, int hgap, int vgap) : hgap 水平间距,vgap 垂直间距。

2.边界布局 (BorderLayout)

这是每个JFrame的内容窗格的默认布局管理器( JFrame.getContentPane() ).

边界布局管理器把组件分成5个区域，NORTH，SOUTH，EAST，WEST，CENTER。先放入边缘组件，当容器缩放的时候，边缘组件不会改变，而中部组件的大小会发生相应变化。

但是BorderLayout有一个问题，就是当添加多个组件到一个区域时，只显示最新添加的组件，而且组件会充满整个区域。解决的方法是在区域上添加一个面板(JPanel)，在面板上放置多个组件。

3.箱式布局 (BoxLayout)

要想创建一个使用箱式布局的新容器,可以调用：

Box b = Box.createHorizontalBox();

或者

Box b = Box.createVerticalBox();

下面是添加组件的常用方法：

b.add(okButton);
b.add(cancelButtn);

在水平的箱子里,组件从左到右排列.在垂直的箱子里,组件从上到下排列。

下面详细的研究一下水平布局。

每个组件有三个尺寸,首选尺寸,最大尺寸,最小尺寸。

下面是箱式布局管理器的工作细节：

1. 计算最高组件的最大高度。
2. 尝试把所有的组件在垂直方向上增至这个高度。
3. 如果一个组件没有增至这个高度，那么它的y对齐方式要通过调用getAlignmentY()方法获得。这个方法将返回一个介于0(顶端对齐)到1(底端对齐)之间的浮点数，组件的默认值是0.5。
4. 获得每个组件的首选宽度，然后把所有首选宽度累加起来。
5. 如果所有的首选宽度的总和小于箱的宽度，那么组件的宽度就会延伸到不超过最大宽度的值，直到适应箱的宽度为止。组件从左到右依次排列，并且相邻的组件之间没有空间。如果所有的首选宽度的总和大于箱的宽度，组件就会被压缩,但不会小于各自的最小宽度，直到适应箱子的宽度为止。如果组件的最小宽度之和大于箱的宽度，有些组件就会显示不出来。

默认情况下，箱式布局各组件是没有间距的。如果需要添加间距,可以添加不可见的填充件。有这样三种填充件：支柱，固定区，胶水。

b.add(label)
b.add(Box.createHorizontalStrut(10));
b.add(textField);

固定区填充件有点像一对支柱。例如：

b.add(Box.createRightArea(new Dimension(5,20)));

将添加一个宽度为5像素，高度是20像素的不可见区域。

胶水将组件互相拉开，直至充满整个空间。例如

b.add(button1);
b.add(Box.createGlue());
b.add(button2);

如果这个箱子不包含其他的组件，那么button1就会被放在最左边，button2就会被放置到最右边。

4.网格组布局 (GridBagLayout)

网格组布局是所有布局管理器之首。可以认为网格组布局是没有限制的网格布局。在网格组布局中，行和列的尺寸都可以改变。可以通过将响铃的单元合并来适应更大的组件。使用网格组布局可能相当复杂，但是它最灵活且使用范围最广。

要想使用网格组布局管理器进行布局，必须经过下列过程：

1. 建立GridBagLayout类型的对象。不需要指定网格的行数和列数，布局管理器会根据后面所给的信息猜测出来。
2. 把GridBagLayout对象设置成组件的布局管理器。
3. 为每个组件建立一个GridBagConstraints类型的对象。设置GridBagConstraints对象的域值以便制定组件在网格组中的布局方案。
4. 最后通过下面的调用添加组件的约束。

add(component,constrants);

示例代码：

JPanel panel = new JPanel();
JLabel label = new JLabel("Test");
 
GridBagLayout layout = new GridBagLayout();
panel.setLayout(layout);
GridBagConstraints constrants = new GridBagConstraints();
constrants.weightx = 100;
constrants.weighty = 100;
constrants.gridx = 0;
constrants.gridy = 2;
constrants.gridwidth = 2;
constrants.gridheight = 1;
panel.add(label, constrants);

知道如何设置GridBagConstraints对象的状态是很重要的，下面详细介绍GridBagConstraints的约束属性。

1.gridxgridy，gridwidth，gridheight

gridx，gridy表示组件在网格中的行列位置(第N行,第N列,从0开始计算)。gridwidth，gridheight表示组件所占的网格的行数和列数。示例代码中constrants应用的组件在第0行，第2列，横向占用2格，纵向占用1格。

2.weightx，weighty

增量字段，如果增量字段设置为0，这个区域永远是初始尺寸。默认增量字段的值为1，代表等比例拉伸组件大小。

3.fill

表示组件填充当前网格的属性。它有四个有效值，NONE，HORIZONTAL，VERTICAL，BOTH (为GridBagConstraints的static final成员变量)，分表代表：不填充，横向填充，纵向填充，填充整个区域。

4.anchor

表示当组件在当前网格区域中的位置。有效值可以设置为CENTER，NORTH，SOUTH，NORTHEAST，EAST等。仅当组件没有充满整个区域时有效。

5.insets

表示外部填塞，用来设置组件周围增加的空白区域。通过设置Insets对象的left，right，top，button值在设置组件周围的空间量。

6.ipadx，ipady

表示内部填塞，该参数用以设置组件的最小尺寸。如果参数值为正值则组件的最小尺寸将比原始最小尺寸大，如果为负值，则组件的最小尺寸将会变得比原始的最小尺寸小。该参数也可以理解为直接为组件指定大小，这个设置的大小就是组件的最小尺寸。其设置后组件的大小为组件的原始最小尺寸加上ipadx(y)*2个像素。

对于GridBagLayout对象来说，本身也有columnWidths,rowHeights,columnWidths,rowWeights这四个属性。

1.columnWidths,rowHeights 设置一个int数组对象来表示各个网格的长度和宽度。例如

gbl.columnWidths = new int[] { 30, 80, 80, 80, 30 };
gbl.rowHeights = new int[] { 45, 200, 30, 45 };

表示网格中的前四列宽度为30，80，80，80，30,前四行宽度为45，200，30，45。

2.columnWeights，rowWeights 设置一个double数组对象来表示各个网格的长度和宽度的权重。当面板被拉伸时，会根据权重拉伸相对应的网格。权重为0表示不拉伸网格。为1表示等比例拉伸。

个人认为这个属性和GridBagConstraints中的weightx，weighty是一个意思，只是一个针对面板上的所有组件，一个针对相应组件而已。不过在实际的设计中，个人比较倾向于使用columnWeights， rowWeights而不是weightx，weighty。因为这样更全局，也更直观。

在使用GridBagLayout布局时，最好使用GridBagContraints帮助类(GBC)代替GridBagContraints类.这样会使得代码更加易读而且便于调试。

public class GBC extends GridBagConstraints {
 
	private static final long serialVersionUID = 2242355893259876283L;
 
	public GBC(int gridx, int gridy) {
		this.gridx = gridx;
		this.gridy = gridy;
	}
 
 
	public GBC(int gridx, int gridy, int gridwidth, int gridheight) {
		this.gridx = gridx;
		this.gridy = gridy;
		this.gridwidth = gridwidth;
		this.gridheight = gridheight;
	}
 
	public GBC setAnchor(int anchor) {
		this.anchor = anchor;
		return this;
	}
 
	public GBC setFill(int fill) {
		this.fill = fill;
		return this;
	}
 
	public GBC setWeight(double weightx, double weighty) {
		this.weightx = weightx;
		this.weighty = weighty;
		return this;
	}
 
	public GBC setInsets(int distance) {
		this.insets = new Insets(distance, distance, distance, distance);
		return this;
	}
 
	public GBC setIpad(int ipadx, int ipady) {
		this.ipadx = ipadx;
		this.ipady = ipady;
		return this;
	}
 
}

下面是帮助类的使用方法

panel.add(label,new GBC(0,2,2,1).setFill(GBC.BOTH).setInsets(1));

注：本文参考《Java2核心技术卷一：基础知识》部分内容。

我一直想做一个这样的工具.很多单位(包括我们单位)实行的是弹性工作制,上班时间只要满8小时就可以下班.因为我老是忘记早上什么时候打的卡,以至于经常在单位多待N久(其实也就是十几二十分钟).这个工具能很好的满足我的要求.

这个工具有什么功能?

1.针对弹性工作制的下班提醒,在某个时间段后程序会自动弹出对话框提示。

2.最小化到系统托盘,双击后显示程序界面。

3.下班提醒时,系统托盘变成闪烁状态(类似于QQ新消息)。

4.程序默认9小时之后提醒,用户可自由设置具体的工作时间。

5.当程序被关闭,如果用户在下班提醒之前重新打开,程序计时依然有效。

如何使用?

1.首先要安装Jre,下载地址:http://www.java.com/zh_CN/download/manual.jsp

2.双击运行该程序。

3.建议将程序设置为开机启动(将程序快捷方式拖到 开始->所有程序->启动 中,并将文件setting.properties 中的autoStart设为true)

下载地址

对于这个工具有什么问题可以联系我。

登录apache.org，下载log4j最新jar文件。将jar文件导入到项目中.

快速应用

1.Log4J应用Demo

package com.log4j.test;
 
import org.apache.log4j.Level;
import org.apache.log4j.Logger;
import org.apache.log4j.PropertyConfigurator;
 
public class StartUp {
 
	public static Logger logger;
 
	public static void main(String[] args) {
		StartUp s = new StartUp();
		s.configLog4J();
		s.go();
	}
 
	private void configLog4J() {
		// 1.获取日志记录器,Name一般取本类的名字
		logger = Logger.getLogger(getClass().getName());
		// 2.配置Log4j环境
		// BasicConfigurator.configure();自动快速地使用缺省Log4j环境。
		// PropertyConfigurator.configure ( String configFilename);
		// 读取使用Java的特性文件编写的配置文件。
		// DOMConfigurator.configure ( String filename ) ：读取XML形式的配置文件。
		PropertyConfigurator.configure("Log4j.properties");
 
	}
 
	private void go() {
		for (int i=0;i<100;i++) {
			logger.debug("test debug");
			logger.log(Level.INFO, "test info");
		}
	}
}

2.新建配置文件 Log4j.properties

log4j.rootLogger=INFO, A1 ,A2
 
log4j.appender.A1=org.apache.log4j.ConsoleAppender
log4j.appender.A1.layout=org.apache.log4j.PatternLayout
log4j.appender.A1.layout.ConversionPattern=[%-5p] [%t] %c - %m%n
 
log4j.appender.A2=org.apache.log4j.FileAppender
log4j.appender.A2.File=A2.log
log4j.appender.A2.Append=true
log4j.appender.A2.layout=org.apache.log4j.PatternLayout
log4j.appender.A2.layout.ConversionPattern=[%-5p] [%t] %c - %m%n

3.运行Demo即可看到效果

Log4J详细配置

log4j.rootLogger=INFO, A1
log4j.appender.A1=org.apache.log4j.ConsoleAppender
log4j.appender.A1.layout=org.apache.log4j.PatternLayout
log4j.appender.A1.layout.ConversionPattern=%-4r [%-5p] [%t] %l - %m%n

1.配置根Logger，其语法为：

log4j.rootLogger = [ level ] , appenderName, appenderName, …

其中，level 是日志记录的优先级，分为OFF、FATAL、ERROR、WARN、INFO、DEBUG、ALL或者您定义的级别。

Log4j建议只使用四个级别，优先级从高到低分别是ERROR、WARN、INFO、DEBUG。通过在这里定义的级别，您可以控制到应用程序中相应级别的日志信息的开关。
比如在这里定义了INFO级别，则应用程序中所有DEBUG级别的日志信息将不被打印出来。
appenderName就是指定日志信息输出到哪个地方。您可以同时指定多个输出目的地。

2.配置日志信息输出目的地Appender，其语法为

log4j.appender.appenderName = fully.qualified.name.of.appender.class
log4j.appender.appenderName.option1 = value1
…
log4j.appender.appenderName.option = valueN
其中，Log4j提供的appender有以下几种：
org.apache.log4j.ConsoleAppender（控制台），
org.apache.log4j.FileAppender（文件），
org.apache.log4j.DailyRollingFileAppender（每天产生一个日志文件），
org.apache.log4j.RollingFileAppender（文件大小到达指定尺寸的时候产生一个新的文件），
org.apache.log4j.WriterAppender（将日志信息以流格式发送到任意指定的地方）

其中，Log4j提供的layout有以下几种：

org.apache.log4j.HTMLLayout（以HTML表格形式布局），
org.apache.log4j.PatternLayout（可以灵活地指定布局模式），
org.apache.log4j.SimpleLayout（包含日志信息的级别和信息字符串），
org.apache.log4j.TTCCLayout（包含日志产生的时间、线程、类别等等信息）

3.pattern

%c 输出类的名字，默认是输出全名，可以指定输出多少层次，比如
%c{2}这样配置的话 "a.b.c" 是全类名，会输出"b.c".
%d 用来输出log事件发生的时间。
可以指定格式，比如：%d{yyyy-MM-dd HH:mm:ss}会输出
2007-04-26 20:12:03
%F    输出log事件发生的文件。
%l    输出log事件发生的位置，会输出全类名和在源码的哪一行。
%L    输出log事件发生在源码的第几行。
%m    输出message的内容，就是logger.info(message)的内容。
%M    输出log事件发生的方法名。
%n    输出一个换行符。不用担心系统的问题。
%p    输出log事件的级别，即info，debug，warn等。
%r    输出log事件所用的时间。
%t    输出log事件所在的线程。
%x    输出NDC(不明白什么意思，没试验出来)
%X    输出MDC
%%    输出%

前天去上海参加了SCJP的考试，终于过了，看来一个月的复习没白费。

考试地点在交大慧科南洋，提前一天去的预约。第二天中午到了那里，不过不知道是因为老师太热情的缘故，突然感觉有点紧张。在考场外面看了一个多小时的书，让自己调整下心情。

开始有几个问题好像是SUN的调查问卷（貌似还计入考试时间了），我没怎么看，都是胡乱填的。一共60道题（之前以为有72道），考试时间是3个小时，时间上还是比较充裕的。而且之前以为选择题是不定项选择题，后来才发现会告诉本题的答案数量，这也大大降低了难度。做题花了两个小时，检查了一个小时，最后成绩出来，81分，还是比较满意的。

SCJP的考试总体来说不难，但是设计J2SE的方方面面，虽然有的题看起来比较偏，但是确实能反映对一些知识的掌握程度。怎么说对自己这两年的技术有个交待了，很欣慰，哈哈！

接下来要等6周后才能拿到SUN寄出的考试证书，比较期待。

1
2
3
4
5
6
7
8
9
10
11
12
13
14

package test;
 
public class TestA {
	public static void main(String[] args) {
                String s="ab";
		String s1="a";
		String s2="b";
		String s3=s1+s2;
		String s4="a"+"b";
		System.out.println(s3==s4);
		System.out.println(s3=="ab");
		System.out.println(s4=="ab");
	}
}

结果：false
false
true

s3和s4虽然值相同，但是显然s3和s4并没有指向同一个String常量池中的String常量。String s4=”a”+”b”;，字符串连接的行为是在编译期间，编译器给优化了。而String s3=s1+s2;中的字符串连接是在代码运行期间进行的。这也间接的说明一个问题，就是String常量池在代码运行前就已经分配好了，代码运行时生成的String对象不会增加到String常量池中。因为s4指向的对象是在代码运行时新生成的对象，所以s3和s4没有指向同一个对象。

推荐这篇文章《Java编译器对于String常量表达式的优化》

No.2 Java编译涉及到的基本变量的问题。下面的代码

1
2
3
4
5
6
7
8
9
10
11

package test;
 
public class TestA {
	public static void main(String[] args) {
		short s=10;//这行代码可以通过编译
		new TestA().go(11);//无法通过编译，需要进行类型转换
	}
	short go(short s){
		return 12;//可以通过编译
	}
}

之前我一直无法理解为什么第5行和第9行可以通过编译，第6行不能通过编译，需要进行强制类型转换。因为这三行同样都是基本变量赋值的问题。后来我发现，这里面涉及到一个重载的问题。比如下面的代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

package test;
 
public class TestA {
	public static void main(String[] args) {
		short s=10;
		new TestA().go(11);//go方法会取调用最匹配的重载方法
	}
 
	short go(short s){
		return 12;
	}
//	short go(int i){
//		return 12;
//	}
	short go(long l){
		return 12;
	}
}

在go(int i)的方法注释掉之前，自然会调用go(int i)方法，注释掉之后，g(11)会调用最匹配的重载方法，而11既可以赋值给short型(强制类型转换)，也可以赋值给long型（隐式类型转换），这是不可能的，不存在两个重载方法都匹配的情况，那样的话编译器无法知道真正要调用的方法到底是哪个。所以编译器无法为你主动做强制类型转换,，只能调用go(long l)方法。所以java规定第6行那样的情况需要做强制类型转换。

对于实例变量和静态变量来说，有一些区别

TestA

package test4;
 
public class TestA {
	protected static int i = 11;
	protected int i2=12;
}

TestB

package test5;
 
import test4.TestA;
 
public class TestB extends TestA{
	public static void main(String[] args) {
		TestA ta=new TestA();
		System.out.println(ta.i);//
		System.out.println(TestA.i);//
		System.out.println(TestB.i);//
		//System.out.println(ta.i2); 这行代码不能被编译*
 
		TestB tb=new TestB();
		System.out.println(tb.i2);
		System.out.println(tb.i);
		new TestA.go();
	}
 	public void go() {
		System.out.println(i);
		System.out.println(i2);
	}
}

一开始觉得奇怪，因为在TestA里，System.out.println(ta.i);可以被编译，而System.out.println(ta.i2);不能被编译。

事实是，protected并不是父类的方法能在子类中访问，而是父类方法在子类中被继承，所以子类通过继承访问protected方法。

在TestA中，ta.i可以被访问，是因为静态变量i被继承，而静态变量是class级变量，ta.i相当于TestA.i而TestA.i也就相当于TestB.i(TestB继承了此静态变量),这点和对象不一样

而ta.i2,因为i2只能通过子类继承访问,所以从对象ta中无法访问实例变量i2

因为是继承访问，go方法中的两句代码可以被编译

public class TestA {
	public static void main(String[] args) {
		throw new RuntimeException();
	}
}

上面代码的编译没有问题。

常见的RuntimeException有：

NullPointerException：空指针异常
 
NumberFormatException：继承IllegalArgumentException，字符串转换为数字时异常。
比如int i= Integer.parseInt("ab3");
 
ArrayIndexOutOfBoundsException:数组越界
比如 int[] a=new int[3]; int b=a[3]; 
 
StringIndexOutOfBoundsException：字符串越界
比如 String s="hello"; char c=s.chatAt(6);
 
ClassCastException:类型转换错误
比如 Object obj=new Object(); String s=(String)obj; 
 
ClassCastException:类型转换错误
比如 Object obj=new Object(); String s=(String)obj; 
 
UnsupportedOperationException:该***作不被支持，如果我们希望不支持这个方法，可以抛出这个异常。既然不支持还要这个干吗？有可能子类中不想支持父类中有的方法，可以直接抛出这个异常。
 
ArithmeticException：算术错误，典型的就是0作为除数的时候。
 
IllegalArgumentException：非法参数，在把字符串转换成数字的时候经常出现的一个异常，我们可以在自己的程序中好好利用这个异常。

1.静态代码块是类在加载到类加载器后即执行的代码块，所以比其他二者都优先执行。

2.在同一个类中，如果碰到有多个静态代码块，则顺序执行各代码块。在父类与子类中，先执行父类的静态代码块，再执行子类的静态代码块。

3.在构建新对象时，先执行基本代码块，后执行构造方法。在父类与子类中，先执行父类的代码块/构造方法，后执行子类的代码块/构造方法

示例代码：

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

class Bird {
	{
		System.out.print("b1 ");
	}
 
	public Bird() {
		System.out.print("b2 ");
	}
	static{
		System.out.print("b3 ");
	}
}
 
class Raptor extends Bird {
	static {
		System.out.print("r1 ");
	}
 
	public Raptor() {
		System.out.print("r2 ");
	}
 
	static {
		System.out.print("r3 ");
	}
}
 
class Hawk extends Raptor {
	public static void main(String[] args) {
		System.out.print("pre ");
		new Hawk();
		System.out.print("hawk ");
	}
}

Result:b3 r1 r3 pre b1 b2 r2 hawk

AOP实际是GoF设计模式的延续,设计模式孜孜不倦追求的是调用者和被调用者之间的解耦,AOP可以说也是这种目标的一种实现。它可以解决OOP和过程化方法不能够很好解决的横切（crosscut）问题,如：事务、安全、日志等横切关注。当未来系统变得越来越复杂,横切关注点就成为一个大问题的时候,AOP就可以很轻松的解决横切关注点这个问题。

Spring主要通过代理来实现AOP
下面是AOP的一些基本概念:
切面(Aspect):对横切关注点的抽象(类似类对对象的抽象)
连接点(JoinPoint):被拦截到的点,泛指方法
切入点(CutPoint):对哪些连接点进行拦截的定义
通知(Advice):在特定的连接点，AOP框架执行的动作.前置/后置/例外/最终/环绕通知(调用方法之前执行,全部执行完毕之后)
引入（Introduction）: 添加方法或字段到被通知的类。 Spring允许引入新的接口到任何被通知的对象。例如，你可以使用一个引入使任何对象实现 IsModified接口，来简化缓存。
目标对象（Target Object）: 包含连接点的对象。也被称作 被通知或被代理对象。
AOP代理（AOP Proxy）: AOP框架创建的对象，包含通知。 在Spring中，AOP代理可以是JDK动态代理或者CGLIB代理。
织入（Weaving）: 组装方面来创建一个被通知对象。这可以在编译时 完成（例如使用AspectJ编译器），也可以在运行时完成。Spring和其他纯Java AOP框架一样， 在运行时完成织入。
Spring主要通过代理来实现AOP 。

下面是AOP的一些基本概念:

切面(Aspect):对横切关注点的抽象(类似类对对象的抽象)

连接点(JoinPoint):被拦截到的点,泛指方法

切入点(CutPoint):对哪些连接点进行拦截的定义

通知(Advice):在特定的连接点，AOP框架执行的动作.前置/后置/例外/最终/环绕通知(调用方法之前执行,全部执行完毕之后)

引入（Introduction）: 添加方法或字段到被通知的类。 Spring允许引入新的接口到任何被通知的对象。例如，你可以使用一个引入使任何对象实现 IsModified接口，来简化缓存。

目标对象（Target Object）: 包含连接点的对象。也被称作 被通知或被代理对象。

AOP代理（AOP Proxy）: AOP框架创建的对象，包含通知。 在Spring中，AOP代理可以是JDK动态代理或者CGLIB代理。

织入（Weaving）: 组装方面来创建一个被通知对象。这可以在编译时 完成（例如使用AspectJ编译器），也可以在运行时完成。Spring和其他纯Java AOP框架一样， 在运行时完成织入。

Spring提供两种方式实现AOP，一种是XML配置的方式，一种是annotation注解的方式

总结一下AOP的优点:
面对方法编程并不是要取代面对对象编程，而是要提高它。AOP程序员一般来说都是90％使用OOP来解决问题,而10％是用AOP来解决OOP不能解决的问题。

横切关注点（Cross-cutting Concerns）
很多时候你发现你的类并不能十分清晰和明白的表到你所想表达的功能意义，因为你真正的代码
大多被其它代码所包围了。如果你想很好的扩展或集成你所想表达的功能意义，你最好就用方面
的思想来考虑它了。

开发中的分层(Layering Based on Deployment)
AOP另外一个很有用的地方就是可以用来为你的应用程序分层。很多时候你希望的一些特殊应用或
类是可以很好的配置的，但同时也希望这些东西是不臃肿和可以扩展的。AOP提供了很好的途径来
分层这些复杂的东西。JBOSS AOP提供了XML配置的机制来配置每个方面的开发。最好的例子就是
缓存服务，它提供了不同的锁机制。这些缓存锁机制可以很好的织入你的类，而不影响你的类的
代码，这样你的类就是很好的扩展性了。

透明性(Transparency)
很多时候你都想把你的程序的焦点集中在商务应用和应用逻辑上，而不是关注于中间件的开发。
AOP允许你透明的应用中间件而不再使你的代码收到污染。一个很好的例子就是JBOSS AOP中的
用户认证上面。

异常处理
处理异常是AOP提供给我们另外一个很有用的东西。例如，SQLException异常包含了SQL语句的
异常信息或者数据库的死锁等信息，但这些信息却使用不同错误代码和信息。AOP可以让你拦截
SQL语句信息，并分类处理数据库死锁信息。

参考：http://www.javaeye.com/topic/480860

spring.jar,commons-logging.jar,log4j-1.2.14.jar

2.拷贝spring配置文件applicationContext.xml到src下

<bean id=”UserDao” class=”com.spring.dao.UserDao4MySqlImp”></bean>

<bean id=”UserManage” class=”com.spring.manage.UserManageImp”>

<property name=”ud” ref=”UserDao”></property>

</bean>

3.在UserManageImp中提供构造函数或setter方法，spring将构造好的UserDao实现注入给我们。

4.让spring管理我们的对象创建和依赖，必须在spring配置中定义

5.编写客户端

BeanFactory factory = new ClassPathXmlApplicationContext(“applicationContext.xml”);

UserManage um = (UserManage) factory.getBean(“UserManage”);

um.save(“张三”, “123456″);

Spring Ioc容器的关键点

1.必须将被管理的对象定义到spring配置文件中

2.必须定义构造函数或setter方法，让spring将对象注入过来