spring方法拦截 只要是给我讲明白我把分全给他,嫌少还可以再加.

Question

要理解方法拦截，先要理解java的动态Proxy在Spring中，被拦截方法的类，都不是直接new出来，而是配置在Spring的工厂中，由Spring负责创建的。例如我们程序需要一个Coupe类的instance，Spring返回给我们程序的实际不是Coupe，而是Coupe的proxy，接下来调用Coupe的方法其实都是通过proxy进行的，自然就可以在proxy中拦截Coupe的所有方法了下面是使用java dynamic proxy的使用方法，当然，Spring不是这么做的，而是使用CGLIB和ASM来动态的生成proxy的。如果大家有兴趣，可以另开话题讨论。package com.skykiller.dyproxy;import java.lang.reflect.*;
import java.io.PrintWriter;public class TracingHandler implements InvocationHandler { private Object target;
private PrintWriter out;

public TracingHandler(Object target, PrintWriter out) {
this.target = target;
this.out = out;
} public static Object createProxy(Object obj, PrintWriter out) {
return Proxy.newProxyInstance(obj.getClass().getClassLoader(), 
obj.getClass().getInterfaces(),
new TracingHandler(obj,out) );
} public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
Object result = null;
out.println( method.getName() + " called.");
try {
result = method.invoke( target, args);
} catch (InvocationTargetException e) {
out.println( method.getName() + " throw "+e.getCause());
throw e.getCause();
}
out.println(method.getName() + " return");
out.flush();
return result;
}
}
package com.skykiller.dyproxy;public interface Car { void init(String name, int passengers); void show();}package com.skykiller.dyproxy;public class Coupe implements Car { private String name;
private int passengers; public void init(String name, int passengers) {
this.name = name;
this.passengers = passengers;
}

public String toString() {
return name + " is a " + passengers + " seats car.";
} public void show() {
System.out.println(toString());
}
/**
 * @param args
 */
public static void main(String[] args) {
CarFactory coupeFactory = new CarFactory("com.skykiller.dyproxy.Coupe",true);

Car coupe = coupeFactory.newInstance("my coupe", 2);
System.out.println("Class name:"+coupe.getClass().getName());
System.out.println("My coupe's info:"+coupe);
coupe.show();
}}

Answer 1

其实就是用cglib动态生成指定类的子类
然后在调用的实际上是子类的方法
在子类方法中加入需要的代码 
然后再调用超类的方法 
这就是所谓的方法拦截用cglib的好处在与 他可以生成类的子类 拦截所有超类的方法
而jdk的代理类需要接口 只能拦截接口中的方法

Answer 2

例子的话 自己google 或者买本书看看就有了  很简单的东西

Answer 3

楼上正解使用jdk1.3的动态代理方式，要求被拦截的类一定要实现某个接口，而代理是针对接口的。对于自己写的系统当然没问题，可是第三方库，就不一定满足这个要求了。使用JDK5的泛型可以简化动态代理的制作，但是依然需要被拦截的类实现了某个接口。使用CGLIB可以克服这个限制，它的原理是动态生成被拦截对象的子类，外面拿到的其实是这个子类，外面调用这个类的方法的时候，就有机会在执行父类（被拦截的对象）的方法前后插入其他动作，实现拦截。

Answer 4

夏昕的spring开发指南说的都很明白了,有空翻翻吧

Answer 5

LZ 想知道的是不是Spring中关于AOP的部分啊？其实网上有很多这样的例子，简单的说，就是在不触动原有程序的基础上，你可以添加一个类，这个类继承了Spring中AOP部分的通知（有的书上叫装备），其实就是定义在指定方法前、后或前后等时候触发，这样做权限/日志管理等，就只需在这个类的方法里编写你需要的功能，然后在spring的配置文件中配置一下监控的方法就可以了,这样你就可以监控一个指定方法或者一个类的某个方法。

Answer 6

http://blog.csdn.net/lemonfamily/archive/2007/01/30/1498246.aspx
例子比较简单，你可以参看spring参考手册第6章：
http://www.redsaga.com/spring_ref/2.0/html/aop.html#aop-introduction-defn