import org.alfresco.repo.policy.Behaviour.NotificationFrequency; //导入依赖的package包/类
/**
 * Init method.  Registered behaviours.
 */
public void init()
{  
    PropertyCheck.mandatory(this, "actionService", getActionService());
    PropertyCheck.mandatory(this, "policyComponent", getPolicyComponent());
    
    /**
     * Bind policies
     */
    this.getPolicyComponent().bindClassBehaviour(OnAddAspectPolicy.QNAME, 
        ImapModel.ASPECT_IMAP_CONTENT, 
        new JavaBehaviour(this, "onAddAspect", NotificationFrequency.TRANSACTION_COMMIT));
    
    /**
     * Bind policies
     */
    this.getPolicyComponent().bindClassBehaviour(OnCopyNodePolicy.QNAME , 
        ImapModel.ASPECT_IMAP_CONTENT, 
        new JavaBehaviour(this, "getCopyCallback", NotificationFrequency.EVERY_EVENT));
}
 

import org.alfresco.repo.policy.Behaviour.NotificationFrequency; //导入依赖的package包/类
/**
 * Construct a collection of Policy implementations for the specified binding
 * 
 * @param binding  the binding
 * @return  the collection of policy implementations
 */
@SuppressWarnings("unchecked")
public Collection<P> createList(B binding)
{
    Collection<BehaviourDefinition> behaviourDefs = index.find(binding);
    List<P> policyInterfaces = new ArrayList<P>(behaviourDefs.size());
    for (BehaviourDefinition behaviourDef : behaviourDefs)
    {
        Behaviour behaviour = behaviourDef.getBehaviour();
        P policyIF = behaviour.getInterface(policyClass);
        if (!(behaviour.getNotificationFrequency().equals(NotificationFrequency.EVERY_EVENT)))
        {
            // wrap behaviour in transaction proxy which deals with delaying invocation until necessary
            if (transactionHandlerFactory == null)
            {
                throw new PolicyException("Transaction-level policies not supported as transaction support for the Policy Component has not been initialised.");
            }
            InvocationHandler trxHandler = transactionHandlerFactory.createHandler(behaviour, behaviourDef.getPolicyDefinition(), policyIF);
            policyIF = (P)Proxy.newProxyInstance(policyClass.getClassLoader(), new Class[]{policyClass}, trxHandler);
        }
        policyInterfaces.add(policyIF);
    }
    
    return policyInterfaces;
}
 

import org.alfresco.repo.policy.Behaviour.NotificationFrequency; //导入依赖的package包/类
/**
 * Behaviour unfreezes node's that will no longer he held after delete.
 *
 * @see org.alfresco.repo.node.NodeServicePolicies.BeforeDeleteNodePolicy#beforeDeleteNode(org.alfresco.service.cmr.repository.NodeRef)
 */
@Behaviour(kind=BehaviourKind.CLASS, type="rma:hold", notificationFrequency=NotificationFrequency.EVERY_EVENT)
@Override
public void beforeDeleteNode(final NodeRef hold)
{
    if (nodeService.exists(hold) && isHold(hold))
    {
        RunAsWork<Void> work = new RunAsWork<Void>()
        {
            @Override
            public Void doWork()
            {
                List<NodeRef> frozenNodes = getHeld(hold);
                for (NodeRef frozenNode : frozenNodes)
                {
                    removeFreezeAspect(frozenNode, 1);
                }

                return null;
            }
        };

        // run as system user
        authenticationUtil.runAsSystem(work);
    }
}
 

import org.alfresco.repo.policy.Behaviour.NotificationFrequency; //导入依赖的package包/类
/**
 * @see org.alfresco.module.org_alfresco_module_rm.RecordsManagementPolicies.OnCreateReference#onCreateReference(org.alfresco.service.cmr.repository.NodeRef, org.alfresco.service.cmr.repository.NodeRef, org.alfresco.service.namespace.QName)
 */
@Override
@Behaviour
(
   kind = BehaviourKind.CLASS,
   notificationFrequency = NotificationFrequency.TRANSACTION_COMMIT
)
public void onCreateReference(NodeRef fromNodeRef, NodeRef toNodeRef, QName reference)
{
    // Deal with versioned records
    if (reference.equals(CUSTOM_REF_VERSIONS))
    {
        // Apply the versioned aspect to the from node
        nodeService.addAspect(fromNodeRef, ASPECT_VERSIONED_RECORD, null);
    }

    // Execute script if for the reference event
    executeReferenceScript("onCreate", reference, fromNodeRef, toNodeRef);
}
 

import org.alfresco.repo.policy.Behaviour.NotificationFrequency; //导入依赖的package包/类
/**
 * Ensure that the content of a ghosted node can not be updated.
 *
 * @see org.alfresco.repo.content.ContentServicePolicies.OnContentUpdatePolicy#onContentUpdate(org.alfresco.service.cmr.repository.NodeRef, boolean)
 */
@Override
@Behaviour
(
   // required, use ASSOC for association behaviors
   kind = BehaviourKind.CLASS,
   // (defaults to EVERY_EVENT)
   notificationFrequency = NotificationFrequency.EVERY_EVENT,
   // (defaults to alf:<methodname>)
   policy = "alf:onContentUpdate",
   // required, unless defaultType set
   type = "rma:ghosted"

   // isService (default false)
   // name (only needs to specified if associated behvaiour object needs to be accessed)
   // assocType (defaults to cm:contains, used with BehaviourKind.ASSOC)
)
public void onContentUpdate(NodeRef content, boolean bNew)
{
    throw new AlfrescoRuntimeException(I18NUtil.getMessage(MSG_GHOSTED_PROP_UPDATE));
}
 

import org.alfresco.repo.policy.Behaviour.NotificationFrequency; //导入依赖的package包/类
/**
 * @see org.alfresco.repo.node.NodeServicePolicies.OnUpdatePropertiesPolicy#onUpdateProperties(org.alfresco.service.cmr.repository.NodeRef, java.util.Map, java.util.Map)
 */
@Override
@Behaviour
(
   kind = BehaviourKind.CLASS,
   notificationFrequency = NotificationFrequency.TRANSACTION_COMMIT
)
public void onUpdateProperties(final NodeRef nodeRef, final Map<QName, Serializable> before, final Map<QName, Serializable> after)
{
    AuthenticationUtil.runAs(new RunAsWork<Void>()
    {
        @Override
        public Void doWork()
        {
            if (nodeService.exists(nodeRef))
            {
                lookupAndExecuteScripts(nodeRef, before, after);
            }

            return null;
        }
    }, AuthenticationUtil.getAdminUserName());
}
 

import org.alfresco.repo.policy.Behaviour.NotificationFrequency; //导入依赖的package包/类
/**
 * @see org.alfresco.repo.node.NodeServicePolicies.OnAddAspectPolicy#onAddAspect(org.alfresco.service.cmr.repository.NodeRef, org.alfresco.service.namespace.QName)
 */
@Override
@Behaviour
(
        kind = BehaviourKind.CLASS,
        notificationFrequency = NotificationFrequency.EVERY_EVENT
)
public void onAddAspect(final NodeRef nodeRef, final QName aspect)
{
    if (nodeService.exists(nodeRef))
    {
        AuthenticationUtil.runAsSystem(new RunAsWork<Void>()
        {
            @Override
            public Void doWork()
            {
                dispositionService.refreshDispositionAction(nodeRef);
                return null;
            }
        });
    }
}
 

import org.alfresco.repo.policy.Behaviour.NotificationFrequency; //导入依赖的package包/类
/**
 * Cleans up the {@link RecordsManagementModel#PROP_IDENTIFIER rma:identifier} property unique triplet.
 *
 * @see org.alfresco.repo.node.NodeServicePolicies.BeforeDeleteNodePolicy#beforeDeleteNode(org.alfresco.service.cmr.repository.NodeRef)
 */
@Override
@Behaviour
(
   kind = BehaviourKind.CLASS,
   notificationFrequency = NotificationFrequency.EVERY_EVENT
)
public void beforeDeleteNode(final NodeRef nodeRef)
{
    AuthenticationUtil.runAs(new RunAsWork<Object>()
    {
        public Object doWork()
        {
            String beforeId = (String) nodeService.getProperty(nodeRef, PROP_IDENTIFIER);
            updateUniqueness(nodeRef, beforeId, null);
            return null;
        }
    }, AuthenticationUtil.getSystemUserName());
}
 

import org.alfresco.repo.policy.Behaviour.NotificationFrequency; //导入依赖的package包/类
@SuppressWarnings("rawtypes")
@Override
@Behaviour
(
   kind = BehaviourKind.CLASS,
   notificationFrequency = NotificationFrequency.TRANSACTION_COMMIT
)
public void onCopyComplete(QName classRef, NodeRef sourceNodeRef, NodeRef targetNodeRef, boolean copyToNewNode, Map copyMap)
{
    //Generate the id for the copy
    String id = identifierService.generateIdentifier(
                                        nodeService.getType(nodeService.getPrimaryParent(targetNodeRef).getParentRef()),
                                        nodeService.getPrimaryParent(targetNodeRef).getParentRef());

    //We need to allow the id to be overwritten disable the policy protecting changes to the id
    behaviourFilter.disableBehaviour();
    try
    {
        nodeService.setProperty(targetNodeRef, PROP_IDENTIFIER, id);
    }
    finally
    {
        behaviourFilter.enableBehaviour();
    }
}
 

import org.alfresco.repo.policy.Behaviour.NotificationFrequency; //导入依赖的package包/类
/**
* Ensure that the visibility of a RM site can not be changed to anything but public.
*
* TODO support other site visibilities
*
* @see org.alfresco.repo.node.NodeServicePolicies.OnUpdatePropertiesPolicy#onUpdateProperties(org.alfresco.service.cmr.repository.NodeRef, java.util.Map, java.util.Map)
*/
  @Behaviour
  (
          kind = BehaviourKind.CLASS,
          notificationFrequency = NotificationFrequency.FIRST_EVENT
  )
  public void onUpdateProperties(NodeRef nodeRef, Map<QName, Serializable> before, Map<QName, Serializable> after)
  {
      if (nodeService.exists(nodeRef))
      {
          Map<QName, Serializable> changed = PropertyMap.getChangedProperties(before, after);
          if (changed.containsKey(SiteModel.PROP_SITE_VISIBILITY) &&
              changed.get(SiteModel.PROP_SITE_VISIBILITY) != null &&
              !SiteVisibility.PUBLIC.equals(changed.get(SiteModel.PROP_SITE_VISIBILITY)))
          {
              // we do not current support non-public RM sites
              throw new AlfrescoRuntimeException("The records management site must have public visibility.  It can't be changed to " + changed.get(SiteModel.PROP_SITE_VISIBILITY));
          }
      }
  }
 

import org.alfresco.repo.policy.Behaviour.NotificationFrequency; //导入依赖的package包/类
/**
 * @see org.alfresco.repo.node.NodeServicePolicies.OnCreateChildAssociationPolicy#onCreateChildAssociation(org.alfresco.service.cmr.repository.ChildAssociationRef, boolean)
 */
@Override
@Behaviour
(
         kind = BehaviourKind.ASSOCIATION,
         notificationFrequency = NotificationFrequency.FIRST_EVENT
)
public void onCreateChildAssociation(ChildAssociationRef childAssocRef, boolean bNew)
{
    NodeRef nodeRef = childAssocRef.getChildRef();
    if (nodeService.exists(nodeRef) && instanceOf(nodeRef, TYPE_RECORD_FOLDER))
    {
        // ensure nothing is being added to a closed record folder
        NodeRef recordFolder = childAssocRef.getParentRef();
        Boolean isClosed = (Boolean) nodeService.getProperty(recordFolder, PROP_IS_CLOSED);
        if (isClosed != null && Boolean.TRUE.equals(isClosed))
        {
            throw new AlfrescoRuntimeException("You can't add new items to a closed record folder.");
        }
    }
}
 

import org.alfresco.repo.policy.Behaviour.NotificationFrequency; //导入依赖的package包/类
/**
 * Ensure that the DOD record aspect meta-data is applied.
 *
 * @see org.alfresco.repo.node.NodeServicePolicies.OnAddAspectPolicy#onAddAspect(org.alfresco.service.cmr.repository.NodeRef, org.alfresco.service.namespace.QName)
 */
@Behaviour
(
        kind=BehaviourKind.CLASS,
        type="rma:record",
        notificationFrequency = NotificationFrequency.FIRST_EVENT
)
@Override
public void onAddAspect(NodeRef nodeRef, QName aspect)
{
    if (nodeService.exists(nodeRef) &&
        !nodeService.hasAspect(nodeRef, ASPECT_DOD_5015_RECORD) &&
        isDODFilePlan(nodeRef))
    {
        nodeService.addAspect(nodeRef, ASPECT_DOD_5015_RECORD, null);
    }
}
 

import org.alfresco.repo.policy.Behaviour.NotificationFrequency; //导入依赖的package包/类
/**
 * @see org.alfresco.repo.rule.ruletrigger.RuleTrigger#registerRuleTrigger()
 */
public void registerRuleTrigger()
{
    if (isClassBehaviour)
    {
        this.policyComponent.bindClassBehaviour(
                QName.createQName(NamespaceService.ALFRESCO_URI, POLICY),
                this,
                new JavaBehaviour(this, POLICY, NotificationFrequency.FIRST_EVENT));
    }
    else
    {
        this.policyComponent.bindAssociationBehaviour(
                QName.createQName(NamespaceService.ALFRESCO_URI, POLICY),
                this,
                new JavaBehaviour(this, POLICY, NotificationFrequency.FIRST_EVENT));
    }
}
 

import org.alfresco.repo.policy.Behaviour.NotificationFrequency; //导入依赖的package包/类
/**
 * Spring initilaise method used to register the policy behaviours
 */
public void init()
{
    PropertyCheck.mandatory(this, "policyComponent", policyComponent);
    PropertyCheck.mandatory(this, "nodeService", nodeService);
    PropertyCheck.mandatory(this, "attributeService", attributeService);
    
    // Register the policy behaviours
    policyComponent.bindClassBehaviour(OnAddAspectPolicy.QNAME, 
       EmailServerModel.ASPECT_ALIASABLE, 
        new JavaBehaviour(this, "onAddAspect", NotificationFrequency.FIRST_EVENT));
 
    policyComponent.bindClassBehaviour(BeforeRemoveAspectPolicy.QNAME,
       EmailServerModel.ASPECT_ALIASABLE, 
       new JavaBehaviour(this, "beforeRemoveAspect", NotificationFrequency.FIRST_EVENT));

    policyComponent.bindClassBehaviour(OnUpdatePropertiesPolicy.QNAME, 
        EmailServerModel.ASPECT_ALIASABLE, 
        new JavaBehaviour(this, "onUpdateProperties"));
    
    policyComponent.bindClassBehaviour(BeforeDeleteNodePolicy.QNAME, 
            EmailServerModel.ASPECT_ALIASABLE, 
            new JavaBehaviour(this, "beforeDeleteNode"));
    
    policyComponent.bindClassBehaviour(CopyServicePolicies.OnCopyNodePolicy.QNAME, 
        EmailServerModel.ASPECT_ALIASABLE, 
        new JavaBehaviour(this, "getCopyCallback"));
}
 

import org.alfresco.repo.policy.Behaviour.NotificationFrequency; //导入依赖的package包/类
protected void bindBehaviour()
{
    if (logger.isDebugEnabled())
    {
        logger.debug("[bindBeahaviour] Binding behaviours");
    }
    PolicyComponent policyComponent = (PolicyComponent) serviceRegistry.getService(QName.createQName(NamespaceService.ALFRESCO_URI, "policyComponent"));

    // Only listen to folders we've tagged with imap properties - not all folders or we'll really slow down the repository!
    policyComponent.bindAssociationBehaviour(
            OnCreateChildAssociationPolicy.QNAME,
            ImapModel.ASPECT_IMAP_FOLDER,
            ContentModel.ASSOC_CONTAINS,
            new JavaBehaviour(this, "onCreateChildAssociation", NotificationFrequency.EVERY_EVENT));
    policyComponent.bindAssociationBehaviour(
            OnDeleteChildAssociationPolicy.QNAME,
            ImapModel.ASPECT_IMAP_FOLDER,
            ContentModel.ASSOC_CONTAINS,
            new JavaBehaviour(this, "onDeleteChildAssociation", NotificationFrequency.EVERY_EVENT));
    policyComponent.bindClassBehaviour(
            OnUpdatePropertiesPolicy.QNAME,
            ContentModel.TYPE_CONTENT,
            new JavaBehaviour(this, "onUpdateProperties", NotificationFrequency.EVERY_EVENT));
    policyComponent.bindClassBehaviour(
            BeforeDeleteNodePolicy.QNAME,
            ContentModel.TYPE_CONTENT,
            new JavaBehaviour(this, "beforeDeleteNode", NotificationFrequency.EVERY_EVENT));
    policyComponent.bindClassBehaviour(
            OnRestoreNodePolicy.QNAME,
            ContentModel.TYPE_CONTENT,
            new JavaBehaviour(this, "onRestoreNode", NotificationFrequency.EVERY_EVENT));
}
 

import org.alfresco.repo.policy.Behaviour.NotificationFrequency; //导入依赖的package包/类
/**
    * {@inheritDoc}
    */
public void registerRuleTrigger()
{
	if (isClassBehaviour == true)
	{
		this.policyComponent.bindClassBehaviour(
				QName.createQName(NamespaceService.ALFRESCO_URI, POLICY), 
				this, 
				new JavaBehaviour(this, POLICY));
	}
	else
	{
		this.policyComponent.bindAssociationBehaviour(
				QName.createQName(NamespaceService.ALFRESCO_URI, POLICY), 
				this, 
				new JavaBehaviour(this, POLICY));
	}	
	
       for (QName ignoreAspect : getIgnoredAspects())
       {
           // Register interest in the addition and removal of the sys:noContent aspect
           this.policyComponent.bindClassBehaviour(
                   NodeServicePolicies.OnAddAspectPolicy.QNAME, 
                   ignoreAspect, 
                   new JavaBehaviour(this, "onAddAspect", NotificationFrequency.EVERY_EVENT));
           this.policyComponent.bindClassBehaviour(
                   NodeServicePolicies.OnRemoveAspectPolicy.QNAME, 
                   ignoreAspect, 
                   new JavaBehaviour(this, "onRemoveAspect", NotificationFrequency.EVERY_EVENT));
       }
   }
 

import org.alfresco.repo.policy.Behaviour.NotificationFrequency; //导入依赖的package包/类
@Override
protected void setUp() throws Exception
{
    applicationContext = ApplicationContextHelper.getApplicationContext();
    // initialise policy test model
    DictionaryBootstrap bootstrap = new DictionaryBootstrap();
    List<String> bootstrapModels = new ArrayList<String>();
    bootstrapModels.add(TEST_MODEL);
    bootstrap.setModels(bootstrapModels);
    bootstrap.setDictionaryDAO((DictionaryDAO)applicationContext.getBean("dictionaryDAO"));
    bootstrap.setTenantService((TenantService)applicationContext.getBean("tenantService"));
    bootstrap.bootstrap();
    
    // retrieve policy component
    this.policyComponent = (PolicyComponent)applicationContext.getBean("policyComponent");
    this.behaviourFilter = (BehaviourFilter) applicationContext.getBean("policyBehaviourFilter");
    this.trxService = (TransactionService) applicationContext.getBean("transactionComponent");
    this.nodeService = (NodeService) applicationContext.getBean("nodeService");
    this.nodeLocatorService = (NodeLocatorService) applicationContext.getBean("nodeLocatorService");
    this.authenticationComponent = (AuthenticationComponent)applicationContext.getBean("authenticationComponent");
    this.authenticationComponent.setSystemUserAsCurrentUser();
    
    // Register Policy
    if (sideEffectDelegate == null)
    {
     sideEffectDelegate = policyComponent.registerClassPolicy(SideEffectTestPolicy.class);
	
     // Bind Behaviour to side effect policy
     QName policyName = QName.createQName(TEST_NAMESPACE, "sideEffect");
     Behaviour baseBehaviour = new JavaBehaviour(this, "sideEffectTest", NotificationFrequency.TRANSACTION_COMMIT);
     this.policyComponent.bindClassBehaviour(policyName, BASE_TYPE, baseBehaviour);
    }

    this.companyHome = nodeLocatorService.getNode(CompanyHomeNodeLocator.NAME, null, null);
    createAndEnableBehaviours();
}
 

import org.alfresco.repo.policy.Behaviour.NotificationFrequency; //导入依赖的package包/类
/**
 *
 * {@inheritDoc}
 */
@Override
public void afterPropertiesSet()
{
    PropertyCheck.mandatory(this, "policyComponent", this.policyComponent);
    PropertyCheck.mandatory(this, "nodeService", this.nodeService);
    PropertyCheck.mandatory(this, "nodeArchiveService", this.nodeArchiveService);
    PropertyCheck.mandatory(this, "permissionService", this.permissionService);

    this.policyComponent.bindClassBehaviour(OnDeleteNodePolicy.QNAME, this,
            new JavaBehaviour(this, "onDeleteNode", NotificationFrequency.EVERY_EVENT));
    this.policyComponent.bindClassBehaviour(OnRestoreNodePolicy.QNAME, this,
            new JavaBehaviour(this, "onRestoreNode", NotificationFrequency.EVERY_EVENT));
}
 

import org.alfresco.repo.policy.Behaviour.NotificationFrequency; //导入依赖的package包/类
public void init() {
	if (logger.isDebugEnabled()) logger.debug("Initializing process invitation behavior");

	// Create behaviours
	this.onUpdateNode = new JavaBehaviour(this, "onUpdateNode", NotificationFrequency.TRANSACTION_COMMIT);

	// Bind behaviours to node policies
	this.policyComponent.bindClassBehaviour(
		QName.createQName(NamespaceService.ALFRESCO_URI, "onUpdateNode"),
		ContentModel.ASPECT_EMAILED,
		this.onUpdateNode
	);
}
 

import org.alfresco.repo.policy.Behaviour.NotificationFrequency; //导入依赖的package包/类
public void init() {
	if (logger.isDebugEnabled()) logger.debug("Initializing site node update behavior");

	// Create behaviours
	this.onUpdateNode = new JavaBehaviour(this, "onUpdateNode", NotificationFrequency.TRANSACTION_COMMIT);

	// Bind behaviours to node policies
	this.policyComponent.bindClassBehaviour(
		QName.createQName(NamespaceService.ALFRESCO_URI, "onUpdateNode"),
		SiteModel.TYPE_SITE,
		this.onUpdateNode
	);
}