各位帮忙想想怎样监视一个类，当调用其方法时可以接获方法的名称。

[ZHUIG]

怎样监视一个类，当调用其任何方法时可以接获方法的名称。
我以前看过，现在忘了，怎么也想不起来在那里看的了，谢谢！

[ZHUIG]

是监视一个实例

[kingofhawks]

学习

[ZHUIG]

帮帮忙啊，

[低调的小青蛙]

cglib

http://cglib.sourceforge.net/

具体怎么做我也记不住了，好久没有用了。

[ZHUIG]

各位帮帮忙，谢了！

[liwei_0223]

是不是监视一个类的实例?

[ZHUIG]

谁来回答？

[skycncomp]

不会,学习...

[changxy123]

知道怎么监视实例对象运行次数，不知道行不

[zgysc]

是反射类吗？

[低调的小青蛙]

我告诉搂主去看 cglib，搂主看来是懒了，我还是给你找找吧。

后边是我在工作中写过的一个类，其中有 2 个 static 的 load 方法，一个传入 Class ，另一个传入具体实例。这 2 个 load 方法都是返回另一个实例，返回的类型是 Object，你只要再将返回来的 Object 再类型转换成你传入的类型就可以了。比如：（看第二个 load）

... static Object load(Object obj, ...

（后边哪个省略号省掉的部分只是跟我的功能相关的附加参数；你的功能不同，关键是传入一个实例）

用法：
String str_a = "a";
String str_b = (String)Lazy.load(str_a，null, null); // 只是举例而已

这样，只要你调用 str_b.length() 等任何方法，都会进入到 intercept 部分。


————————————————————————————————————

import java.lang.reflect.Method;

import jp.co.isetan.core.model.Model;
import net.sf.cglib.proxy.*;

/**
* Lazy
*
* @author shishouwei
* @version $Revision: 1.1.2.4 $
*/

public class Lazy implements MethodInterceptor {

/**
* Target object to be wrapped
*/
private Object target = null;

/**
* Data Access Object
*/
private Dao loadDao = null;

/**
* If data loaded
*/
private boolean isLoaded = false;

/**
* Temporarily stop check loaded or not
*/
private boolean pauseCheck = false;

/**
* Create a new object and lazy load it if not loaded
*
* @param clazz
* @return
*/
public static Object load(Class clazz, Dao dao, boolean loaded) {

try{
Lazy interceptor = new Lazy();
Enhancer e = new Enhancer ();

e.setSuperclass(clazz);
e.setCallback (interceptor);

Object obj = e.create();
interceptor.loadDao = dao ;

// enable lasy load if it is Model and it is not load
if( obj instanceof Model )
interceptor.isLoaded = loaded;
else
interceptor.isLoaded = true;

return obj;
}catch( Throwable e ){
e.printStackTrace();
throw new Error(e.getMessage());
}
}

/**
* Lazy load an object if not loaded
*
* @param obj
* @return
*/
public static Object load(Object obj, Dao dao, boolean loaded) {

try{
Lazy interceptor = new Lazy();
Enhancer e = new Enhancer ();

e.setSuperclass(obj.getClass());
e.setCallback (interceptor);

interceptor.target = obj ;
interceptor.loadDao = dao ;

// enable lasy load if it is Model and it is not load
if( obj instanceof Model )
interceptor.isLoaded = loaded;
else
interceptor.isLoaded = true;

return e.create();

}catch( Throwable e ){
e.printStackTrace();
throw new Error(e.getMessage());
}
}

/**
* Lazy load an object
*
* @param obj
* @param dao
* @return
*/
public static Object load(Object obj, Dao dao) {
return load(obj, dao, false);
}

/**
* Check preload
*/
public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {

if( target != null ) {
// check loaded
if( ! isLoaded && method.getName().startsWith("get") ) {
// load data
loadDao.refresh( (Model)target );
isLoaded = true;
}

return method.invoke(target, args);
}
else {
// check loaded
if( ! isLoaded && ! pauseCheck && method.getName().startsWith("get") ) {
pauseCheck = true;

// load data
loadDao.refresh( (Model)obj );
isLoaded = true;

pauseCheck = false;
}

return proxy.invokeSuper(obj, args);
}
}

}

[低调的小青蛙]

我把它精简了一下，把跟我以前工作相关的部分删掉了，得到了一个没有任何影响的类，封装了一下，但是封装出来的实例作用跟以前一样，但是每次调用方法会进入 intercept 里来：

————————————————————————————————————————

import java.lang.reflect.Method;

import jp.co.isetan.core.model.Model;
import net.sf.cglib.proxy.*;

public class Lazy implements MethodInterceptor {

/**
* Target object to be wrapped
*/
private Object target = null;

public static Object load(Object obj) {

try{
Lazy interceptor = new Lazy();
Enhancer e = new Enhancer ();

e.setSuperclass(obj.getClass());
e.setCallback (interceptor);

return e.create();
}catch( Throwable e ){
e.printStackTrace();
throw new Error(e.getMessage());
}
}

public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {

return method.invoke(target, args);

}

}

[低调的小青蛙]

前面的“精简”漏掉一行，纠正：

——————————————————————————————————————

import java.lang.reflect.Method;

import jp.co.isetan.core.model.Model;
import net.sf.cglib.proxy.*;

public class Lazy implements MethodInterceptor {

/**
* Target object to be wrapped
*/
private Object target = null;

public static Object load(Object obj) {

try{
Lazy interceptor = new Lazy();
Enhancer e = new Enhancer ();

e.setSuperclass(obj.getClass());
e.setCallback (interceptor);

interceptor.target = obj ; // 这行是前面漏掉的，不能精简掉

return e.create();
}catch( Throwable e ){
e.printStackTrace();
throw new Error(e.getMessage());
}
}

public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {

return method.invoke(target, args);

}

}

[soctober]

楼上的辛苦了！

同意楼上的说法，学习中！~

[低调的小青蛙]

前面我举的例子中，不应该用 String 来举例，因为 String 是 final 类，在此再次纠正。搂主可以用其他不是 final 的来试一下。


我这样反复纠正，实在不好意思了。我整理了一下，放在一个单独的网页上了，欢迎大家批评指正：

http://www29.websamba.com/sswater/myref/index.asp?id=14