Spring Aop之我见
深入理解AOP (读SpringGuide随笔)<o:p></o:p>
前言：最近2年一阵春（Spring）风吹变了世界各地，当然也把俺吹的昏头转向（差点没吹趴下，这那里是春风啊，简直就是头骨的阴风，:（ ），故写一篇小文来迎接一哈这阵阵春风，希望对学习Spring的人，有一些帮助。好那，不说废话那，进入正题。
<o:p> </o:p>
Spring 中提供的AOP支持，是基于动态的AOP机制实现的。
这里什么是动态的的AOP呢？
即通过动态的Proxy模式，在目标对象的方法调用的前后插入相应的处理代码。
那么是么是动态的Proxy模式呢？
在Spring中的动态Proxy模式，是基于Java Dynamic Proxy（面向Interface）和CGLIB(面向Class)的实现。
那什么是Dynamic Proxy是JDK1.3版本中引入的一种动态代理机制。它是Proxy模式的一种动态实现版本。
而Proxy模式又分为两种
A:静态Proxy模式
B：动态Proxy模式
首先我们来看看什么是静态Proxy模式
假设我们有一个UserDAO接口以及一个实现类UserDAOImp
UserDAO.Java
Public interface UserDAO{
Public void saveUser(User user);
}
UserDAOImp.java
Public class UserDAOImp implents UserDAO{
Public void saveUser(User user){
………………………
}
}
<o:p> </o:p>
UserDAOProxy.java
Public class UserDAOProxy implments UserDAO{
//可以看到代理UserDAOProxy也是实现那UserDAO
· //UserDAOProxyinstanceofUserDAO 将返回TRUE
<o:p> </o:p>
Private UserDAO userDAO;
Public UserDAOProxy(UserDAO userDAO){
This.userDAO= userDAO;
}
Public void saveUser(User user){
Transaction tx =null;<o:p></o:p>
Try{<o:p></o:p>
Tx=new Transaction();<o:p></o:p>
UserDAO.saveUser(user);
}catch(Excption e){<o:p></o:p>
Tx.rollBack();<o:p></o:p>
}<o:p></o:p>
}
}
当外部调用UserDAO或UserDAOImp的saveUser方法的时候，实际上是调用了UserDAOProxy的saveUser方法
注意UserDAOProxy同样也实现了UserDAO接口，对于调用者来说，saveuser方法的使用完全相同，不同的是内部的实现机制发生了一些改变，UserDAOProxy中为UserDAO.saveUser方法加了一层JTA事务管理的外壳。
好那，现在我们看看如何创建一个动态代理类的实例<o:p></o:p>
java.lang.reflect.Proxy用于Proxy 提供用于创建动态代理类和实例的静态方法，它还是由这些方法创建的所有动态代理类的超类。<o:p></o:p>
创建某一接口 Foo 的代理：
Foo f = (Foo) Proxy.newProxyInstance(Foo.class.getClassLoader(),
new Class[] { Foo.class },
handler);
<o:p> </o:p>
public static Object newProxyInstance(ClassLoader loader,<o:p></o:p>
Class[] interfaces,<o:p></o:p>
InvocationHandler h)<o:p></o:p>
throws IllegalArgumentException<o:p></o:p>
返回一个指定接口的代理类实例，该接口可以将方法调用指派到指定的调用处理程序。此方法相当于： <o:p></o:p>
参数： <o:p></o:p>
loader - 定义代理类的类加载器 <o:p></o:p>
interfaces - 代理类要实现的接口列表 <o:p></o:p>
h - 指派方法调用的调用处理程序 <o:p></o:p>
返回： <o:p></o:p>
一个带有代理类的指定调用处理程序的代理实例，它由指定的类加载器定义，并实现指定的接口 <o:p></o:p>
动态代理类（以下简称为代理类）是一个实现在创建类时在运行时指定的接口列表的类。
代理接口 是代理类实现的一个接口。
代理实例 是代理类的一个实例。 每个代理实例都有一个关联的调用处理程序 对象
- 由于代理类将实现所有在其创建时指定的接口，所以对其 Class 对象调用 getInterfaces 将返回一个包含相同接口列表的数组（按其创建时指定的顺序），对其 Class 对象调用 getMethods 将返回一个包括这些接口中所有方法的 Method 对象的数组，并且调用 getMethod 将会在代理接口中找到期望的一些方法。 <o:p></o:p>
每个代理实例都有一个关联的调用处理程序，它会被传递到其构造方法中。静态 Proxy.getInvocationHandler 方法将返回与作为其参数传递的代理实例相关的调用处理程序。
public interface InvocationHandler{
Object invoke(Object proxy,
Method method,
Object[] args)
throws Throwable}
参数： <o:p></o:p>
proxy - 在其上调用方法的代理实例 <o:p></o:p>
method - 对应于在代理实例上调用的接口方法的 Method 实例。Method 对象的声明类将是在其中声明方法的接口，该接口可以是代理类赖以继承方法的代理接口的超接口。 <o:p></o:p>
args - 包含传入代理实例上方法调用的参数值的对象数组，如果接口方法不使用参数，则为 null。基本类型的参数被包装在适当基本包装器类（如 java.lang.Integer 或 java.lang.Boolean）的实例中。<o:p></o:p>
<o:p> </o:p>
<o:p> </o:p>
Spring的 HibernateDaoSupport 基类提供了访问与当前事务绑定的 Session 对象的函数，因而能保证在这种情况下异常的正确转化。类似的函数同样可以在 SessionFactoryUtils 类中找到，但他们以静态方法的形式出现。 值得注意的是，通常将一个false作为参数（表示是否允许创建）传递到 getSession(..) 方法中进行调用。 此时，整个调用将在同一个事务内完成（它的整个生命周期由事务控制，避免了关闭返回的 Session 的需要）。 <o:p></o:p>
public class ProductDaoImpl extends HibernateDaoSupport implements ProductDao {<o:p></o:p>
<o:p> </o:p>
public Collection loadProductsByCategory(String category)<o:p></o:p>
throws DataAccessException, MyException {<o:p></o:p>
<o:p> </o:p>
Session session = getSession(getSessionFactory(), false);<o:p></o:p>
try {<o:p></o:p>
List result = session.find(<o:p></o:p>
"from test.Product product where product.category=?",<o:p></o:p>
category, Hibernate.STRING);<o:p></o:p>
if (result == null) {<o:p></o:p>
throw new MyException("invalid search result");<o:p></o:p>
}<o:p></o:p>
return result;<o:p></o:p>
}<o:p></o:p>
catch (HibernateException ex) {<o:p></o:p>
throw convertHibernateAccessException(ex);<o:p></o:p>
}<o:p></o:p>
}<o:p></o:p>
}<o:p></o:p>
这种直接使用Hibernate访问代码的主要好处在于它允许你在数据访问代码中抛出checked exception，而 HibernateTemplate 却受限于回调中的unchecked exception。 注意，你通常可以将这些应用程序的异常处理推迟到回调函数之后，这样，你依然可以正常使用 HibernateTemplate。 一般来说，HibernateTemplate 所提供的许多方法在许多情况下看上去更简单和便捷。 <o:p></o:p>
声明式的事务划分<o:p></o:p>