Java Event.PROPERTY_ADDED属性代码示例

public void onEvent(EventIterator eventIterator) {
	try {
		while (eventIterator.hasNext()) {
			Event event = eventIterator.nextEvent();
			int type = event.getType();
			switch (type) {
				case Event.PROPERTY_CHANGED:
					changedProperties.add(event.getPath());
					break;
				case Event.PROPERTY_ADDED:
					addedProperties.add(event.getPath());
					break;
				case Event.PROPERTY_REMOVED:
					removedProperties.add(event.getPath());
					break;
			}
		}
		eventBundlesProcessed++;
	} catch (RepositoryException e) {
		fail(e.getMessage());
	}
}
 

protected void activate(ComponentContext ctx) {
    try {
        session = repository.loginService("serviceUser", null);
        observationManager = session.getWorkspace().getObservationManager();

        String[] nodeTypes = {"cq:PageContent"};
        int eventTypes = Event.PROPERTY_ADDED | Event.PROPERTY_CHANGED | Event.PROPERTY_REMOVED;
        observationManager.addEventListener(this, eventTypes, "/content", true, null, nodeTypes, true);

        log.info("Activated JCR event listener");
    } catch (LoginException le) {
        log.error("Error activating JCR event listener: {}", le.getMessage());
    } catch (Exception e) {
        log.error("Error activating JCR event listener", e);
    }
}
 

/**
 * Trigger on event
 *
 * @param eventIterator The event iterator object
 */
@Override
public void onEvent(EventIterator eventIterator) {
    ResourceResolver resourceResolver = null;
    try {
        Map<String, Object> authenticationInfo = new HashMap<String, Object>();
        authenticationInfo.put(ResourceResolverFactory.SUBSERVICE, CONFIG_SERVICE);
        resourceResolver = resourceResolverFactory.getServiceResourceResolver(authenticationInfo);

        ComponentManager componentManager = resourceResolver.adaptTo(ComponentManager.class);
        if (resourceResolver != null) {
            while (eventIterator.hasNext()) {
                Event event = eventIterator.nextEvent();
                String path = event.getPath();
                switch (event.getType()) {
                    case Event.PROPERTY_REMOVED:
                    case Event.NODE_REMOVED:
                    case Event.PROPERTY_CHANGED:
                    case Event.PROPERTY_ADDED:
                        path = path.substring(0, path.lastIndexOf('/'));
                        break;
                    case Event.NODE_MOVED:
                        path = event.getInfo().get("srcChildRelPath").toString();
                        break;
                    case Event.NODE_ADDED:
                    default:
                }
                Resource resource = resourceResolver.getResource(path);
                if (resource != null) {
                    com.day.cq.wcm.api.components.Component component = ResourceUtils.findContainingComponent(resource);
                    if (component != null) {
                        configCache.clear();
                    }
                }
            }
        }
    } catch (Exception ew) {
        LOG.error(ERROR, ew);
    } finally {
        if (resourceResolver != null)
            resourceResolver.close();
    }
}
 

public void onEvent(final EventIterator events) {
    // Handle events
    while (events.hasNext()) {
        try {
            Event event = events.nextEvent();

            // IMPORTANT!
            //
            // JCR Events are NOT cluster-aware and this event listener will be invoked on every node in the cluster.

            // Check if this event was spawned from the server this event handler is running on or from another
            if (event instanceof JackrabbitEvent && ((JackrabbitEvent) event).isExternal()) {
                // Event did NOT originate from this server

                // Skip, Let only the originator process;

                // This is usual to avoid having the same processing happening for every node in a cluster. This
                // is almost always the case when the EventListener modifies the JCR.

                // A possible use-case for handling the event on EVERY member of a cluster would be clearing out an
                // in memory (Service-level) cache.

                return;
            } else {
                // Event originated from THIS server
                // Continue processing this Event
            }

            final String path = event.getPath();

            if (Event.NODE_ADDED == event.getType()) {
                // Node added!
            } else if (Event.PROPERTY_ADDED == event.getType()) {
                // Property added!
            }

            // Dummy variable; You'd never conditionally pick the approach in real code.
            boolean handleAsJcrEvent = true;

            if (handleAsJcrEvent) {
                // Execute handler logic in this event handler...

                // Make sure you handle this quickly else your event handler may get blacklisted!

                // Get a resourceResolver or JCR Session using the usual ways
                // Always make sure to close them if you open them though!

                // ... do some work
            } else {
                // Alternatively to doing work in the event, you can kick off a new Sling Event OR Job

                // Example of kicking off a Sling Event which will then pick up and do the work via a Sling Event
                // Listener; Generally this can be simply avoided by making a Sling Event Handler directly.

                final Map<String, Object> jobProperties = new HashMap<String, Object>();
                jobProperties.put("resourcePath", path);

                // Kick off a new job based on the event
                jobManager.addJob("com/adobe/acs/samples/sample-job", jobProperties);
            }

        } catch (RepositoryException ex) {
            log.error("Something bad happened!", ex);
        }
    }
}