BijectionInterceptor

//$Id: BijectionInterceptor.java 9561 2008-11-14 03:26:13Z dan.j.allen $
package org.jboss.seam.core;

import java.util.concurrent.locks.ReentrantLock;

import org.jboss.seam.Component;
import org.jboss.seam.CyclicDependencyException;
import org.jboss.seam.annotations.intercept.AroundInvoke;
import org.jboss.seam.annotations.intercept.Interceptor;
import org.jboss.seam.intercept.AbstractInterceptor;
import org.jboss.seam.intercept.InvocationContext;
import org.jboss.seam.util.Exceptions;

/**
 * Before invoking the component, inject all dependencies. After
 * invoking, outject dependencies back into their context.
 * 
 * @author Gavin King
 * @author Shane Bryzak
 */
@Interceptor
public class BijectionInterceptor extends AbstractInterceptor
{
   private static final long serialVersionUID = 4686458105931528659L;
   
   private boolean injected; //是否注入
   
   private boolean injecting;//正在注入
   
   private int clients = 0; //数量
   
   private ReentrantLock lock = new ReentrantLock(); //可重复使用的锁
   
   @Override
   public void setComponent(Component component)
   {
      super.setComponent(component); //设置需要注入的组件
   }
      
   @AroundInvoke //注入标记
   public Object aroundInvoke(InvocationContext invocation) throws Exception
   {
      Component component = getComponent();
      boolean enforceRequired = !component.isLifecycleMethod( invocation.getMethod() );  //忽略生命周期方法    
      
      try
      {    
         lock.lock();
         try
         {
            if (!injected)
            {              
               if (injecting)
               {
                  throw new CyclicDependencyException();
               }

               injecting = true;
               try
               {
                  component.inject(invocation.getTarget(), enforceRequired);//注入目标对象
               }
               finally
               {
                  injecting = false;
               }
               injected = true;
            }
            
            clients++;
         }
         finally
         {
            lock.unlock();
         }
                           
         Object result = invocation.proceed(); //处理业务或处理下个拦截
            
         lock.lock();
         try
         {
            if (clients == 1) //判断是否是一个客户端,可以消除多线程的危险,做到线程安全
            {
               try
               {                     
                  component.outject( invocation.getTarget(), enforceRequired );
               }
               finally
               {
                  // Avoid an extra lock by disinjecting here instead of the finally block
                  if (injected)
                  {
                     injected = false;
                     clients--;
                     component.disinject( invocation.getTarget() ); //解散注入,将注入的对象拿出或消除
                  }
               }   
            }
         }
         finally
         {
            lock.unlock();
         }
         
         return result;
      }
      catch (Exception e)
      {
         Exception root = e;
         while (Exceptions.getCause(root) != null)
         {
            root = Exceptions.getCause(root);
         }
         if (root instanceof CyclicDependencyException)
         {
            CyclicDependencyException cyclicDependencyException = (CyclicDependencyException) root;
            cyclicDependencyException.addInvocation(getComponent().getName(), invocation.getMethod());
         }
         throw e;
      }
      finally //不至是一个客户端
      {            
         if (injected)
         {
            lock.lock();
            try
            {
               clients--;
               
               if (clients == 0)
               {
                  injected = false;
                  component.disinject( invocation.getTarget() );     
               }
            }
            finally
            {
               lock.unlock();
            }
         }
      }
   }

   public boolean isInterceptorEnabled()
   {
      return getComponent().needsInjection() || getComponent().needsOutjection();
   }
   
}