BlogJava-yuyee-随笔分类-aophttp://www.blogjava.net/yuyee/category/46754.htmlzh-cnWed, 03 Nov 2010 20:53:54 GMTWed, 03 Nov 2010 20:53:54 GMT60cglib入门http://www.blogjava.net/yuyee/archive/2010/10/26/336181.html羔羊羔羊Tue, 26 Oct 2010 06:27:00 GMThttp://www.blogjava.net/yuyee/archive/2010/10/26/336181.htmlhttp://www.blogjava.net/yuyee/comments/336181.htmlhttp://www.blogjava.net/yuyee/archive/2010/10/26/336181.html#Feedback0http://www.blogjava.net/yuyee/comments/commentRss/336181.htmlhttp://www.blogjava.net/yuyee/services/trackbacks/336181.htmlCGLIB是一个强大的代码生成包，在ASM上建立，在一些开源工具中经常可以看到他的身影，比如hibernate,spring。
CGLIB底层通过字节码处理框架ASM来将字节码生成新的类，在spring AOP中不强制使用CGLIB，默认是JDK动态代理。
CGLIB 包情况：
net.sf.cglib.core:底层字节码处理类，大部分与ASM有关。
net.sf.cglib.transform:编译期或运行期和类文件的转换
net.sf.cglib.proxy：实现创建代理和方法拦截器的类
net.sf.cglib.reflect:实现快速放射
net.sf.cglib.util:工具包
net.sf.cglib.beans:javabean相关工具类
通过CGLIB创建动态代理，本质上，他是动态的生成目标类的子类，覆盖目标类所有不是final的方法，并给他们设置好callback,因此，原有类的每个方法调用就会变成自定义的拦截方法。
创建动态代理时通常要用到如下api:net.sf.cglib.proxy.Callback这个接口，他是很关键的一个接口，所有被net.sf.cglib.proxy.Enhancer类调用的回调借口都要继承这个接口
如：public interface MethodInterceptor
extends Callback
{
    /**
     * All generated proxied methods call this method instead of the original method.
     * The original method may either be invoked by normal reflection using the Method object,
     * or by using the MethodProxy (faster).
     * @param obj "this", the enhanced object
     * @param method intercepted Method
     * @param args argument array; primitive types are wrapped
     * @param proxy used to invoke super (non-intercepted method); may be called
     * as many times as needed
     * @throws Throwable any exception may be thrown; if so, super method will not be invoked
     * @return any value compatible with the signature of the proxied method. Method returning void will ignore this value.
     * @see MethodProxy
     */    
    public Object intercept(Object obj, java.lang.reflect.Method method, Object[] args,
                               MethodProxy proxy) throws Throwable;

}
这个是基与方法的回调，第一个参数是代理对象，第二个是被拦截的方法对象，第三个是方法参数，第四个是方法的代理对象。
public class MyClass {
public void method1() {
System.out.println("method1");
}

public void method2() {
System.out.println("method2");
}
}
拦截器：
public class MethodInterceptImpl implements MethodInterceptor {

public Object intercept(Object arg0, Method arg1, Object[] arg2,
MethodProxy arg3) throws Throwable {
System.out.println(arg1.getName()+"--intercept");
arg3.invokeSuper(arg0, arg2);// 这里其实也可以用原来的方法对象来执行，但是性能上不如cglib的方法代理类
return null;
}
public class MainTest {
public static void main(String[] args) {
simpleTest();
}

private static void simpleTest() {
Enhancer en = new Enhancer();
en.setCallback(new MethodInterceptImpl());
en.setSuperclass(MyClass.class);
MyClass m = (MyClass) en.create();
m.method1();
m.method2();
}
结果：method1--intercept
method1
method2--intercept
method2
现实项目中可能存在某些需求，比如method1需要拦截，而method2不需要拦截。那我们可以对callback做下选择,使用net.sf.cglib.proxy.CallbackFilter做一些过滤。
public class MethodFilterImpl implements CallbackFilter {

private final static int execute = 0;
private final static int unexecute = 1;

public int accept(Method method) {
String methodName = method.getName();
if("method1".equals(methodName)){
return execute;
}
return unexecute;
}

}

调用的时候需要给callback设置好索引位置，因为accept的返回值就是callbacks数组的索引位置。
private static void filterTest() {
Enhancer en = new Enhancer();
Callback[] callbacks = new Callback[] { new MethodInterceptImpl(),
NoOp.INSTANCE };//这里拦截器的索引位置要与filter里的设置一致
en.setCallbacks(callbacks);
en.setSuperclass(MyClass.class);
en.setCallbackFilter(new MethodFilterImpl());
MyClass m = (MyClass) en.create();
m.method1();
m.method2();
}
这里callbacks[1]这个位置使用了NoOp这个回调接口
public interface NoOp extends Callback
{
    /**
     * A thread-safe singleton instance of the <code>NoOp</code> callback.
     */
    public static final NoOp INSTANCE = new NoOp() { };
}
这个callback其实就是直接把任务委派给这个方法在父类中的实现，其实也等同于没做什么额外的事情
执行结果：method1--intercept
method1
method2
method2 并未被MethodInterceptImpl拦截

}


羔羊 2010-10-26 14:27 发表评论
]]>使用Annotation来完成spring aophttp://www.blogjava.net/yuyee/archive/2010/10/25/336106.html羔羊羔羊Mon, 25 Oct 2010 08:52:00 GMThttp://www.blogjava.net/yuyee/archive/2010/10/25/336106.html使用annotation来表示pointcut，需要在xml里配置org.springframework.aop.support.annotation.AnnotationMatchingPointcut，
如：<bean name="timeoutPointcut"
class="org.springframework.aop.support.annotation.AnnotationMatchingPointcut">
<constructor-arg index="0"
value="com.hengtian.fxfundsystem.aop.annotation.UseAOPAnnotation">
</constructor-arg>
<constructor-arg index="1"
value="com.hengtian.fxfundsystem.aop.annotation.TimeoutAnnotation" />
</bean>
第一个参数是标在目标类上的annotation,第二天参数是标注在方法上的Annotation
因此，首先要在自己的工程里定义2个annotation，一个为TimeoutAnnotation，一个为UseAOPAnnotation
@Target({ElementType.TYPE })//表示类标注
@Retention(RetentionPolicy.RUNTIME)
@Inherited
public @interface UseAOPAnnotation {

}
@Target({ElementType.METHOD})//表示方法标注
@Retention(RetentionPolicy.RUNTIME)
public @interface TimeoutAnnotation {
/**
* 默认值(-1)：表示不启用超时
*/
public static final long DefaultValue = -1;

/**
* 超时时间，单位是ms
* 
* @return
*/
long value() default DefaultValue;

}
在需要AOP的类上使用
@UseAOPAnnotation
@Component("StrongDuck")  
public class StrongDuck {
@TimeoutAnnotation(70000)
public void say(){
System.out.println("I am a strong duck");
}
}
timeout通知：
public class TimeoutAdvice implements MethodInterceptor {

/*
* (non-Javadoc)
* 
* @see
* org.aopalliance.intercept.MethodInterceptor#invoke(org.aopalliance.intercept
* .MethodInvocation)
*/
public Object invoke(final MethodInvocation methodInvocation)
throws Throwable {

Method targetMethod = methodInvocation.getMethod();
TimeoutAnnotation timeoutAnnotation = targetMethod
.getAnnotation(TimeoutAnnotation.class);
if (timeoutAnnotation != null) {
long waitTime = timeoutAnnotation.value();
if (waitTime != TimeoutAnnotation.DefaultValue) {
Future<?> task = ThreadManager.ExecutorService
.submit(encapsulateSyncToAsync(methodInvocation));
return getAsyncResult(waitTime, task);
}

}
return methodInvocation.proceed();
}
XML中配置拦截器：
<bean id="timeoutInterceptor" class="org.springframework.aop.support.DefaultPointcutAdvisor">
<property name="advice" ref="timeoutAdvice" />
<property name="pointcut" ref="timeoutPointcut" />
</bean>
<bean
class="org.springframework.aop.framework.autoproxy.DefaultAdvisorAutoProxyCreator">
<property name="proxyTargetClass"><!-- 基于类的代理 -->
<value>true</value>
</property>
</bean>
这样，spring就会为你生成aop代理类实现AOP




羔羊 2010-10-25 16:52 发表评论
]]>JDK代理http://www.blogjava.net/yuyee/archive/2010/10/25/336046.html羔羊羔羊Sun, 24 Oct 2010 16:20:00 GMThttp://www.blogjava.net/yuyee/archive/2010/10/25/336046.html
/**
 * 行为接口
 * 
 * @author Administrator
 * 
 */
public interface Study {
public void doStudy();
}
/**
 * 目标对象
 * 
 * @author Administrator
 * 
 */
public class StudyImpl implements Study {

@Override
public void doStudy() {
System.out.println("study jdk proxy");
}

}


/**
 * 代理类
 * @author Administrator
 *
 */
public class JDKProxy implements InvocationHandler {

private Study s;

public JDKProxy(Study s) {
this.s = s;
}

@Override
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
System.out.println("before jdkproxy");
method.invoke(s, args);
System.out.println("after jdkproxy");
return null;
}
}

应用中进行调用：
public class Test {
public static void main(String[] args) throws SecurityException,
NoSuchMethodException, IllegalArgumentException,
InstantiationException, IllegalAccessException,
InvocationTargetException {
Class clazz = StudyImpl.class;//获取目标类的Class对象
Study st = new StudyImpl();//实例化一个目标类
Class proxClass = Proxy.getProxyClass(clazz.getClassLoader(), clazz
.getInterfaces());//通过Proxy静态方法，获取一个于目标类实现同样接口的Class对象，也可以说是兄弟类
Constructor c = proxClass
.getConstructor(new Class[] { InvocationHandler.class });//给这个类一个指定的公开的构造方法
Study ds = (Study) c.newInstance(new Object[] { new JDKProxy(st) });//实例化一个代理类
}
}


羔羊 2010-10-25 00:20 发表评论
]]>AOP日记http://www.blogjava.net/yuyee/archive/2010/10/24/336045.html羔羊羔羊Sun, 24 Oct 2010 15:48:00 GMThttp://www.blogjava.net/yuyee/archive/2010/10/24/336045.html
  最近在学着总结，因为常感觉做完东西，长久不用，过段时间就忘，下次想复习下都不行。
 AOP，面向方面编程，我们系统中有很多组件组成，每一个组件负责一部分业务功能,
 但是这些组件往往又带有一部分核心功能外的附加功能，而且是重复代码，如：日志，安全，事务！ 通过AOP，实现这些附加功能的可重复利用。
 
 AOP其实可以看作是代理模式的扩展,写一个简单的代理
 
public class ProxySubject implements ProxyInterface {
private Subject innerObj;// 真正的对象

@Override
public void handle() {
innerObj = new Subject();
// 做额外的事情
innerObj.handle();// 真正的处理业务
// 做额外的事情
}
}

 Aop中叫代理类为advice,可以有多个连接起来，一个事件链

  实现AOP，还需要涉及到JAVA的反射，通过反射，获取method对象，并执行方法，AOP规范包里有个接口

 

 

public interface MethodInterceptor extends Interceptor {

    

     *Implement this method to perform extra treatments before and

     * after the invocation. Polite implementations would certainly

     * like to invoke {@link Joinpoint#proceed()}.

     *

     * @param invocation the method invocation joinpoint

     * @return the result of the call to {@link

     * Joinpoint#proceed()}, might be intercepted by the

     * interceptor.

     *

     * @throws Throwable if the interceptors or the

     * target-object throws an exception.  

     Object invoke(MethodInvocation invocation) throws Throwable;

      ｝

      通过 MethodInvocation的 getMethod()获得方法对象，并执行

      这样，如果你一个类中有很多方法，就可以通过这么一个

      

      AOP中生成代理类有3种方式，

      1.静态编译时期，源代码生成，为每个符合条件的类生成一个代理类

      2.静态字节码增强通过ASM/CGLIB分析字节码，生成代理类

      3.动态字节码增强，spring aop就是这样,ASM/CGLIB或者JDK的动态代理

      AOP的原理可以理解为代理模式+放射+自动字节码生成

Spring中动态代理有2种方式，一种是通过CGLIB，一种是JDK。

什么时候采用JDK什么时候采用CGLIB动态生成，主要取决于你又没实现接口，JDK动态代理需要目标类实现某接口，而CGLIB则是生成目标类的子类

public AopProxy createAopProxy(AdvisedSupport config) throws AopConfigException {

if (config.isOptimize() || config.isProxyTargetClass() || hasNoUserSuppliedProxyInterfaces(config)) {

Class targetClass = config.getTargetClass();

if (targetClass == null) {

throw new AopConfigException("TargetSource cannot determine target class: " +

"Either an interface or a target is required for proxy creation.");

}

if (targetClass.isInterface()) {

return new JdkDynamicAopProxy(config);

}

if (!cglibAvailable) {

throw new AopConfigException(

"Cannot proxy target class because CGLIB2 is not available. " +

"Add CGLIB to the class path or specify proxy interfaces.");

}

return CglibProxyFactory.createCglibProxy(config);

}

else {

return new JdkDynamicAopProxy(config);

}

}

这个是DefaultAopProxyFactory里创建代理类的方法


 

 



羔羊 2010-10-24 23:48 发表评论
]]>