我们在前面的文章已经看到，ConnectorCoordinatorImpl类也实现了ChangeHandler接口，本文接下来分析实现该接口的作用
class ConnectorCoordinatorImpl implements ConnectorCoordinator, ChangeHandler, BatchResultRecorder
我们先查看一下ChangeHandler接口声明了哪些方法
/** * Handles change notifications from a {@link ChangeListener} * for a specific connector instance. */ interface ChangeHandler { void connectorAdded(TypeInfo typeInfo, Configuration configuration) throws InstantiatorException; void connectorRemoved() throws InstantiatorException; void connectorCheckpointChanged(String checkpoint) throws InstantiatorException; void connectorScheduleChanged(Schedule schedule) throws InstantiatorException; void connectorConfigurationChanged(TypeInfo typeInfo, Configuration configuration) throws InstantiatorException; }
通过注释我们可以了解到，该接口主要是一个事件句柄，当ChangeListener对象监听到连接器实例的相关事件时，便由该事件处理器处理连接器实例的相关状态
上面的方法分别为添加连接器实例、一处连接器实例、设置连接器实例断点状态、改变连接器实例的定时调度、改变连接器实例配置信息等
ConnectorCoordinatorImpl类实现ChangeHandler接口方法如下
/** * 新增连接器实例 */ /* @Override */ public void connectorAdded(TypeInfo newTypeInfo, Configuration configuration) throws InstantiatorException { if (instanceInfo != null) { throw new IllegalStateException( "Create new connector when one already exists."); } File connectorDir = getConnectorDir(newTypeInfo); //生成连接器目录 boolean didMakeConnectorDir = makeConnectorDirectory(connectorDir); try { connectorConfigurationChanged(newTypeInfo, configuration); } catch (InstantiatorException ie) { if (didMakeConnectorDir) { removeConnectorDirectory(connectorDir); } throw (ie); } } /** * 移除连接器实例 * Removes this {@link Connector} instance. Halts traversals, * removes the Connector instance from the known connectors, * and removes the Connector's on-disk representation. */ /* @Override */ public synchronized void connectorRemoved() { LOGGER.info("Dropping connector: " + name); try { resetBatch(); if (instanceInfo != null) { File connectorDir = instanceInfo.getConnectorDir(); shutdownConnector(true); removeConnectorDirectory(connectorDir); } } finally { instanceInfo = null; typeInfo = null; traversalSchedule = null; traversalDelayEnd = 0; } } /** * 改变断点状态 * Handle a change to the Connector's traversal state. The only change * that matters is a change from non-null to null. This indicates that * the Repository should be retraversed from the beginning. * * @param checkpoint a String representation of the traversal state. */ /* @Override */ public void connectorCheckpointChanged(String checkpoint) { // If checkpoint has been nulled, then traverse the repository from scratch. if (checkpoint == null) { synchronized(this) { // Halt any traversal in progress. resetBatch(); // Shut down any Lister. stopLister(); try { // Restart Lister. startLister(); } catch (InstantiatorException e) { LOGGER.log(Level.WARNING, "Failed to restart Lister for connector " + name, e); } // Kick off a restart immediately. delayTraversal(TraversalDelayPolicy.IMMEDIATE); } LOGGER.info("Restarting traversal from beginning for connector " + name); } } /** * 改变连接器实例定时调度 * Handles a change to the traversal {@link Schedule} for the * {@link Connector}. * * @param schedule new Connector Schedule */ /* @Override */ public synchronized void connectorScheduleChanged(Schedule schedule) { LOGGER.config("Schedule changed for connector " + name + ": " + schedule); // Refresh the cached Schedule. traversalSchedule = schedule; // Update the LoadManager with the new load. loadManager.setLoad((schedule == null) ? HostLoadManager.DEFAULT_HOST_LOAD : schedule.getLoad()); // Let the traversal manager know the schedule changed. setTraversalSchedule(traversalManager, schedule); // Let the lister know the schedule changed. setTraversalSchedule(lister, schedule); // New Schedule may alter DelayPolicy. delayTraversal(TraversalDelayPolicy.IMMEDIATE); } /** * 改变连接器配置 * Handles a change to a Connector's Configuration. Shuts down any * current instance of the Connector and starts up a new instance with * the new Configuration. * * @param newTypeInfo the {@link TypeInfo} for this this Connector. * @param config a new {@link Configuration} for this Connector. */ /* @Override */ public void connectorConfigurationChanged(TypeInfo newTypeInfo, Configuration config) throws InstantiatorException { if (LOGGER.isLoggable(Level.CONFIG)) { LOGGER.config("New configuration for connector " + name + ": " + config); } File connectorDir = getConnectorDir(newTypeInfo); // We have an apparently valid configuration. Create a connector instance // with that configuration. InstanceInfo newInstanceInfo = new InstanceInfo(name, connectorDir, newTypeInfo, addGoogleProperties(config, connectorDir)); // Tell old connector instance to shut down, as it is being replaced. resetBatch(); shutdownConnector(false); setDatabaseAccess(newInstanceInfo); instanceInfo = newInstanceInfo; typeInfo = newTypeInfo; // Prefetch an AuthorizationManager to avoid AuthZ time-outs // when logging in to repository at search time. try { getAuthorizationManager(); } catch (ConnectorNotFoundException cnfe) { // Not going to happen here, but even if it did, we don't care. } catch (InstantiatorException ie) { // Likely failed connector.login(). This attempt to cache AuthZMgr failed. // However it is not important yet, so log it and continue on. LOGGER.log(Level.WARNING, "Failed to get AuthorizationManager for connector " + name, ie); } // The load value in a Schedule is docs/minute. loadManager.setLoad(getSchedule().getLoad()); // Start up a Lister, if the Connector supports one. startLister(); // Allow newly modified connector to resume traversals immediately. delayTraversal(TraversalDelayPolicy.IMMEDIATE); }
接了下来我们进一步分析作为事件监听器ChangeListener的相关方法
/** * Accepts change notifications from a {@link ChangeDetector}. */ interface ChangeListener { void connectorAdded(String instanceName, Configuration configuration) throws InstantiatorException; void connectorRemoved(String instanceName); void connectorCheckpointChanged(String instanceName, String checkpoint); void connectorConfigurationChanged(String instanceName, Configuration configuration) throws InstantiatorException; void connectorScheduleChanged(String instanceName, Schedule schedule); }
当监听器监听到相关事件时，便调用ChangeHandler接口对象进行处理，这里的事件处理器也就是上面的ConnectorCoordinatorImpl类的实例对象
ChangeListenerImpl类实现了ChangeHandler接口，作为具体的事件监听器类，在其相关方法里面都是调用ChangeHandler接口类型对象的相应方法
/** * Accepts change notifications from a {@link ChangeDetector}, and * calls the change handlers in ConnectorCoordinator. */ class ChangeListenerImpl implements ChangeListener { private static final Logger LOGGER = Logger.getLogger(ChangeListenerImpl.class.getName()); private final TypeMap typeMap; private final ConnectorCoordinatorMap coordinatorMap; ChangeListenerImpl(TypeMap typeMap, ConnectorCoordinatorMap coordinatorMap) { this.typeMap = typeMap; this.coordinatorMap = coordinatorMap; } /* @Override */ public void connectorAdded(String instanceName, Configuration configuration) throws InstantiatorException { LOGGER.config("Add connector " + instanceName + " of type " + configuration.getTypeName()); try { ChangeHandler handler = coordinatorMap.getChangeHandler(instanceName); TypeInfo type = typeMap.getTypeInfo(configuration.getTypeName()); handler.connectorAdded(type, configuration); } catch (InstantiatorException e) { LOGGER.log(Level.WARNING, "Failed to handle addition of new connector " + instanceName, e); // Propagate InstantiatorException, so ChangeDetector can retry later. throw e; } catch (ConnectorTypeNotFoundException e) { LOGGER.log(Level.WARNING, "Failed to handle addition of new connector " + instanceName, e); } } /* @Override */ public void connectorRemoved(String instanceName) { LOGGER.config("Remove connector " + instanceName); try { coordinatorMap.getChangeHandler(instanceName).connectorRemoved(); } catch (InstantiatorException e) { LOGGER.log(Level.WARNING, "Failed to handle removal of connector " + instanceName, e); } } /* @Override */ public void connectorCheckpointChanged(String instanceName, String checkpoint) { LOGGER.finest("Checkpoint changed for connector " + instanceName); try { coordinatorMap.getChangeHandler(instanceName) .connectorCheckpointChanged(checkpoint); } catch (InstantiatorException e) { LOGGER.log(Level.WARNING, "Failed to handle checkpoint change for " + "connector " + instanceName, e); } } /* @Override */ public void connectorScheduleChanged(String instanceName, Schedule schedule) { LOGGER.config("Schedule changed for connector " + instanceName + ": " + schedule); try { coordinatorMap.getChangeHandler(instanceName) .connectorScheduleChanged(schedule); } catch (InstantiatorException e) { LOGGER.log(Level.WARNING, "Failed to handle schedule change for " + "connector " + instanceName, e); } } /* @Override */ public void connectorConfigurationChanged(String instanceName, Configuration configuration) throws InstantiatorException { LOGGER.config("Configuration changed for connector " + instanceName); try { ChangeHandler handler = coordinatorMap.getChangeHandler(instanceName); TypeInfo type = typeMap.getTypeInfo(configuration.getTypeName()); handler.connectorConfigurationChanged(type, configuration); } catch (InstantiatorException e) { LOGGER.log(Level.WARNING, "Failed to handle configuration change for " + "connector " + instanceName, e); // Propagate InstantiatorException, so ChangeDetector can retry later. throw e; } catch (ConnectorTypeNotFoundException e) { LOGGER.log(Level.WARNING, "Failed to handle configuration change for " + "connector " + instanceName, e); } } }
现在事件监听器和事件处理器都具备了，那么事件由哪里发出，接下来要进一步追溯事件源了，即下面要分析的ChangeDetector接口，该接口声明的方法很简单
/** * Checks for changes in a persistent store. Intended to be run both * manually to handle local servlet changes, and periodically to check * for remote connector manager changes. * * @see com.google.enterprise.connector.persist.PersistentStore * @see ChangeListener */ interface ChangeDetector { /** * Compares the version stamps for the in-memory objects and * persisted objects, and notifies the {@link ChangeListener} of the * needed updates. * * <p> * The in-memory objects should reflect the persistent store, even * if the store contains older objects. If the version stamp for a * persisted object is older, then the in-memory object should be * reverted. */ void detect(); }
从该接口的注释我们可以知道，连接器实现了两种事件依赖的机制 ，其一是我们手动操作连接器实例时；其二是由连接器的自动更新机制
ChangeDetectorImpl类实现了ChangeDetector接口，该类对象实例依赖于连接器实例的存储类对象和监听器对象实例
/** * Checks for changes in a persistent store. Intended to be run both * manually to handle local servlet changes, and periodically to check * for remote connector manager changes. * * @see com.google.enterprise.connector.persist.PersistentStore * @see ChangeListener */ // TODO: Change StoreContext to String and x.getConnectorName() to x. class ChangeDetectorImpl implements ChangeDetector { private final PersistentStore store; private final ChangeListener listener; /** The stamps from the previous run. */ private ImmutableMap<StoreContext, ConnectorStamps> inMemoryInventory = ImmutableMap.of(); /** A sorted set of the keys of {@code inMemoryInventory}. */ private SortedSet<StoreContext> inMemoryInstances = new TreeSet<StoreContext>(); /** * Constructs the detector. * * @param store the persistent store to look for changes in * @param listener the change listener to notify of changes */ ChangeDetectorImpl(PersistentStore store, ChangeListener listener) { this.store = store; this.listener = listener; } /* @Override */ public synchronized void detect() { NDC.push("Change"); try { ImmutableMap<StoreContext, ConnectorStamps> persistentInventory = store.getInventory(); SortedSet<StoreContext> persistentInstances = new TreeSet<StoreContext>(persistentInventory.keySet()); // Compare the last known (inMemory) inventory with the new inventory // from the persistent store. Notify ChangeListeners of any differences. // Save in memory, the new inventory of unchanged items and successfully // applied changes. inMemoryInventory = compareInventoriesAndNotifyListeners( inMemoryInstances.iterator(), persistentInstances.iterator(), persistentInventory); inMemoryInstances = persistentInstances; } finally { NDC.pop(); } } /** * Gets the next element of an {@code Iterator} iterator, or * {@code null} if there are no more elements. * * @return the next element or {@code null} */ private StoreContext getNext(Iterator<StoreContext> it) { return it.hasNext() ? it.next() : null; } /** * Iterates over the sorted sets of instance names to find additions * and deletions. When matching names are found, compare the version * stamps for changes in the individual persisted objects. * * @param mi the sorted keys to the in-memory instances * @param pi the sorted keys to the persistent instances * @param persistentInventory the persistent object stamps * @return a new inventory of stamps, derived from the * persistentInventory, but reflecting instantiation failures. */ private ImmutableMap<StoreContext, ConnectorStamps> compareInventoriesAndNotifyListeners( Iterator<StoreContext> mi, Iterator<StoreContext> pi, ImmutableMap<StoreContext, ConnectorStamps> persistentInventory) { // This map will accumulate items for the new in-memory inventory. // Generally, this map will end up being identical to the // persistentInventory. However, failed connector instantiations // may cause changes to be dropped from this map, so that they may // be retried next time around. ImmutableMap.Builder<StoreContext, ConnectorStamps> mapBuilder = new ImmutableMap.Builder<StoreContext, ConnectorStamps>(); StoreContext m = getNext(mi); StoreContext p = getNext(pi); while (m != null && p != null) { // Compare instance names. int diff = m.getConnectorName().compareTo(p.getConnectorName()); NDC.pushAppend((diff < 0 ? m : p).getConnectorName()); try { if (diff == 0) { // Compare the inMemory vs inPStore ConnectorStamps for a // connector instance. Notify ChangeListeners for items whose // Stamps have changed. ConnectorStamps stamps = compareInstancesAndNotifyListeners( m, p, inMemoryInventory.get(m), persistentInventory.get(p)); // Remember the new ConnetorStamps for our new inMemory inventory. mapBuilder.put(p, stamps); // Advance to the next connector instance. m = getNext(mi); p = getNext(pi); } else if (diff < 0) { listener.connectorRemoved(m.getConnectorName()); m = getNext(mi); } else { // diff > 0 try { listener.connectorAdded(p.getConnectorName(), store.getConnectorConfiguration(p)); mapBuilder.put(p, persistentInventory.get(p)); } catch (InstantiatorException e) { // Forget about this one and retry on the next time around. pi.remove(); } p = getNext(pi); } } finally { NDC.pop(); } } while (m != null) { NDC.pushAppend(m.getConnectorName()); try { listener.connectorRemoved(m.getConnectorName()); } finally { NDC.pop(); } m = getNext(mi); } while (p != null) { NDC.pushAppend(p.getConnectorName()); try { listener.connectorAdded(p.getConnectorName(), store.getConnectorConfiguration(p)); mapBuilder.put(p, persistentInventory.get(p)); } catch (InstantiatorException e) { // Forget about this one and retry on the next time around. pi.remove(); } finally { NDC.pop(); } p = getNext(pi); } return mapBuilder.build(); } /** * Compares the version stamps for the given instance. Notify ChangeListeners * of any differences. * * @param m the key for the in-memory instance * @param p the key for the persistent instance * @param ms the stamps for the in-memory instance * @param ps the stamps for the persistent instance * @return possibly modified stamps for the persistent instance */ // TODO: When StoreContext becomes String, we only need one key // parameter because we will have m.equals(p). NOTE: This may be // false now, if the connector type has changed. private ConnectorStamps compareInstancesAndNotifyListeners( StoreContext m, StoreContext p, ConnectorStamps ms, ConnectorStamps ps) { if (compareStamps(ms.getCheckpointStamp(), ps.getCheckpointStamp()) != 0) { listener.connectorCheckpointChanged(p.getConnectorName(), store.getConnectorState(p)); } if (compareStamps(ms.getScheduleStamp(), ps.getScheduleStamp()) != 0) { listener.connectorScheduleChanged(p.getConnectorName(), store.getConnectorSchedule(p)); } // Save configuration for last, because it may fail. if (compareStamps(ms.getConfigurationStamp(), ps.getConfigurationStamp()) != 0) { try { listener.connectorConfigurationChanged(p.getConnectorName(), store.getConnectorConfiguration(p)); } catch (InstantiatorException e) { // Instantiation of the connector failed. Remember a null configuration // stamp so we will try the new configuration again next time through. // This is an attempt to handle connectors that fail instantiation // due to transient causes (such as a server off-line). return new ConnectorStamps(ps.getCheckpointStamp(), null, ps.getScheduleStamp()); } } // Return the original stamps. return ps; } /** * Compares two version stamps. Stamps may be {@code null}, in which * case they are sorted lower than any non-{@code null} object. * * @param memoryStamp the stamp for the in-memory object * @param persistentStamp the stamp for the persistent object * @return a negative integer, zero, or a positive integer as the * in-memory stamp is less than, equal to, or greater than the * persistent stamp * @see java.util.Comparator#compare(Object, Object) */ private int compareStamps(Stamp memoryStamp, Stamp persistentStamp) { if (memoryStamp == null && persistentStamp == null) { return 0; } else if (memoryStamp == null) { return -1; } else if (persistentStamp == null) { return +1; } else { return memoryStamp.compareTo(persistentStamp); } } }
当detect()方法检测到连接器存储状态改变时，便通知事件监听器对象（事件监听器对象调用事件处理器处理该事件）
现在问题是由谁来调用detect()方法检测连接器实例的存储状态的变化呢，连接器在内部通过定时线程不断扫描连接器实例的存储状态
抽象类ScheduledTimerTask扩展了（extends）TimerTask类（定时任务类*TimerTask implements Runnable）
/** * Extends {@link TimerTask} to include the desired schedule. Note * that unlike {@link java.util.Timer} schedules, the schedule here is * specified in seconds for consistency with other time specifications * in the connector manager. */ public abstract class ScheduledTimerTask extends TimerTask { /** Gets the delay in seconds before the task is to be executed. */ public abstract long getDelay(); /** Gets the time in seconds between successive task executions. */ public abstract long getPeriod(); }
ChangeDetectorTask类继承自抽象类ScheduledTimerTask，在其run方法里面调用changeDetector.detect()方法
public class ChangeDetectorTask extends ScheduledTimerTask { private final ChangeDetector changeDetector; private final long delay; private final long period; /** * Constructs a task with a schedule. Note that unlike * {@link java.util.Timer} schedules, the schedule here is specified * in seconds for consistency with other time specifications in the * connector manager. * * @param delay delay in seconds before task is to be executed * @param period time in seconds between successive task executions */ public ChangeDetectorTask(ChangeDetector changeDetector, long delay, long period) { this.changeDetector = changeDetector; this.delay = delay; this.period = period; } @Override public long getDelay() { return delay; } @Override public long getPeriod() { return period; } @Override public void run() { changeDetector.detect(); } }
最后我们看到，在SpringInstantiator类对象的初始化方法里面，由定时执行器执行了上面的定时任务ScheduledTimerTask
//定时执行器 private final ScheduledTimer timer = new ScheduledTimer(); /** * Initializes the Context, post bean construction. */ public synchronized void init() { LOGGER.info("Initializing instantiator"); // typeMap must be initialized before the ChangeDetector task is run. typeMap.init(); //启动定时任务 // Run the ChangeDetector periodically to update the internal // state. The initial execution will create connector instances // from the persistent store. timer.schedule(changeDetectorTask); }
定时执行器ScheduledTimer timer是对java的Timer timer对象的封装
/** * A timer for {@link ScheduledTimerTask}s. This class does not start * a timer thread until a task is scheduled to be executed in the * future. */ /* * In order to not create a thread during construction, this class * must not extend Timer. */ public class ScheduledTimer { @VisibleForTesting static final String THREAD_NAME = "ScheduledTimer"; private Timer timer; /** * Schedules the task to run. If a delay of zero is given, it will * be run immediately in the calling thread, rather than running in * the timer thread. */ public void schedule(ScheduledTimerTask task) { long delay; if (task.getDelay() == 0L) { task.run(); delay = task.getPeriod(); } else { delay = task.getDelay(); } // Only schedule the task in the timer if it needs to be executed // in the future. N.B.: Do not test delay here instead of // task.getDelay. if (task.getDelay() > 0L || task.getPeriod() > 0L) { synchronized (this) { if (timer == null) { // Create a timer with a named thread. timer = new Timer(THREAD_NAME); } } // Timer requires milliseconds, rather than seconds. if (task.getPeriod() > 0L) { timer.schedule(task, delay * 1000L, task.getPeriod() * 1000L); } else { timer.schedule(task, delay * 1000L); } } } public void cancel() { if (timer != null) { timer.cancel(); } } }
至此，定时任务初始化、定时任务执行器、事件源、事件监听器、事件处理器都已经分析完毕，我们可以通过查看spring容器的配置文件清晰的查看到这一连串对象实例的依赖序列
<bean id="ConnectorCoordinatorMap" class="com.google.enterprise.connector.instantiator.ConnectorCoordinatorMap"> <property name="connectorCoordinatorFactory" ref="ConnectorCoordinatorFactory" /> </bean> <bean id="TypeMap" class="com.google.enterprise.connector.instantiator.TypeMap"/> <bean id="ChangeListener" class="com.google.enterprise.connector.instantiator.ChangeListenerImpl"> <constructor-arg index="0" ref="TypeMap"/> <constructor-arg index="1" ref="ConnectorCoordinatorMap"/> </bean> <bean id="ChangeDetector" class="com.google.enterprise.connector.instantiator.ChangeDetectorImpl"> <constructor-arg index="0" ref="PersistentStore"/> <constructor-arg index="1" ref="ChangeListener"/> </bean> <bean id="ChangeDetectorTask" class="com.google.enterprise.connector.instantiator.ChangeDetectorTask"> <constructor-arg index="0" ref="ChangeDetector"/> <constructor-arg index="1" value="1"/> <constructor-arg index="2" value="${config.change.detect.interval}"/> </bean> <bean id="Instantiator" class="com.google.enterprise.connector.instantiator.SpringInstantiator"> <property name="connectorCoordinatorMap" ref="ConnectorCoordinatorMap" /> <property name="threadPool" ref="ThreadPool" /> <property name="typeMap" ref="TypeMap" /> <property name="changeDetectorTask" ref="ChangeDetectorTask" /> </bean>
最后，本人画了一张uml类图，可以很清晰的了解相关类的依赖关系
---------------------------------------------------------------------------
本系列企业搜索引擎开发之连接器connector系本人原创
转载请注明出处 博客园 刺猬的温驯
本人邮箱： chenying998179@163#com （#改为.）