View Javadoc

    1   /*
    2    *  soapUI, copyright (C) 2004-2007 eviware.com
    3    *
    4    *  soapUI is free software; you can redistribute it and/or modify it under the
    5    *  terms of version 2.1 of the GNU Lesser General Public License as published by
    6    *  the Free Software Foundation.
    7    *
    8    *  soapUI is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without
    9    *  even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
    10   *  See the GNU Lesser General Public License for more details at gnu.org.
    11   */
    12
    13  package com.eviware.soapui.support.listener;
    14
    15  import java.io.IOException;
    16  import java.io.InputStream;
    17  import java.util.ArrayList;
    18  import java.util.Collection;
    19  import java.util.HashMap;
    20  import java.util.List;
    21  import java.util.Map;
    22
    23  import com.eviware.soapui.SoapUI;
    24  import com.eviware.soapui.config.SoapUIListenerConfig;
    25  import com.eviware.soapui.config.SoapUIListenersConfig;
    26  import com.eviware.soapui.config.SoapuiListenersDocumentConfig;
    27
    28  public class SoapUIListenerRegistry
    29  {
    30  	private Map<Class<?>, List<Class<?>>> listeners = new HashMap<Class<?>, List<Class<?>>>();
    31  	private Map<Class<?>, List<Object>> singletonListeners = new HashMap<Class<?>, List<Object>>();
    32  	private Map<Class<?>, SoapUIListenerConfig> listenerConfigs = new HashMap<Class<?>, SoapUIListenerConfig>();
    33
    34  	public void addListener( Class<?> listenerInterface, Class<?> listenerClass, SoapUIListenerConfig config )
    35  	{
    36  		List<Class<?>> classes = null;
    37  		if( listeners.containsKey( listenerInterface ) )
    38  		{
    39  			classes = listeners.get( listenerInterface );
    40  		}
    41  		if( classes == null )
    42  		{
    43  			classes = new ArrayList<Class<?>>();
    44  		}
    45  		classes.add( listenerClass );
    46  		listeners.put( listenerInterface, classes );
    47
    48  		if( config != null )
    49  		{
    50  			listenerConfigs.put( listenerClass, config );
    51  		}
    52  	}
    53
    54  	public void removeListener( Class<?> listenerInterface, Class<?> listenerClass )
    55  	{
    56  		List<Class<?>> classes = null;
    57  		if( listeners.containsKey( listenerInterface ) )
    58  		{
    59  			classes = listeners.get( listenerInterface );
    60  		}
    61  		if( classes != null )
    62  		{
    63  			classes.remove( listenerClass );
    64  		}
    65  		if( classes == null || classes.size() == 0 )
    66  		{
    67  			listeners.remove( listenerInterface );
    68  		}
    69
    70  		listenerConfigs.remove( listenerClass );
    71  	}
    72
    73  	public SoapUIListenerRegistry( InputStream config )
    74  	{
    75  		if( config != null )
    76  			addConfig( config, getClass().getClassLoader() );
    77  	}
    78
    79  	public void addConfig( InputStream config, ClassLoader classLoader )
    80  	{
    81  		try
    82  		{
    83  			SoapuiListenersDocumentConfig configDocument = SoapuiListenersDocumentConfig.Factory.parse( config );
    84  			SoapUIListenersConfig soapuiListeners = configDocument.getSoapuiListeners();
    85
    86  			for( SoapUIListenerConfig listenerConfig : soapuiListeners.getListenerList() )
    87  			{
    88  				try
    89  				{
    90  					String listenerInterfaceName = listenerConfig.getListenerInterface();
    91  					String listenerClassName = listenerConfig.getListenerClass();
    92
    93  					Class<?> listenerInterface = Class.forName( listenerInterfaceName, true, classLoader );
    94  					Class<?> listenerClass = Class.forName( listenerClassName, true, classLoader );
    95  					if( !listenerInterface.isInterface() )
    96  					{
    97  						throw new RuntimeException( "Listener interface: " + listenerInterfaceName + " must be an interface" );
    98  					}
    99  					if( !listenerInterface.isAssignableFrom( listenerClass ) )
    100 					{
    101 						throw new RuntimeException( "Listener class: " + listenerClassName + " must implement interface: "
    102 									+ listenerInterfaceName );
    103 					}
    104 					// make sure the class can be instantiated even if factory
    105 					// will instantiate interfaces only on demand
    106 					Object obj = listenerClass.newInstance();
    107 					if( listenerConfig.getSingleton() )
    108 					{
    109 						if( obj instanceof InitializableListener )
    110 						{
    111 							((InitializableListener)obj).init( listenerConfig );
    112 						}
    113
    114 						addSingletonListener( listenerInterface, obj );
    115 					}
    116 					else
    117 					{
    118 						// class can be instantiated, register it
    119 						addListener( listenerInterface, listenerClass, listenerConfig );
    120 					}
    121 				}
    122 				catch( Exception e )
    123 				{
    124 					System.err.println( "Error initializing Listener: " + e );
    125 				}
    126 			}
    127 		}
    128 		catch( Exception e )
    129 		{
    130 			SoapUI.logError( e );
    131 		}
    132 		finally
    133 		{
    134 			try
    135 			{
    136 				config.close();
    137 			}
    138 			catch( IOException e )
    139 			{
    140 				SoapUI.logError( e );
    141 			}
    142 		}
    143 	}
    144
    145 	public void addSingletonListener( Class<?> listenerInterface, Object listener )
    146 	{
    147 		if( !singletonListeners.containsKey( listenerInterface ))
    148 			singletonListeners.put( listenerInterface, new ArrayList<Object>() );
    149
    150 		singletonListeners.get( listenerInterface ).add( listener );
    151 	}
    152
    153 	public void removeSingletonListener( Class<?> listenerInterface, Object listener )
    154 	{
    155 		if( singletonListeners.containsKey( listenerInterface ))
    156 			singletonListeners.get( listenerInterface ).remove( listener );
    157 	}
    158
    159 	@SuppressWarnings("unchecked")
    160 	public <T extends Object> List<T> getListeners( Class<T> listenerType )
    161 	{
    162 		List<T> result = new ArrayList<T>();
    163 		if( listeners.containsKey( listenerType ) )
    164 		{
    165 			List<Class<?>> list = listeners.get( listenerType );
    166 			for( Class<?> listenerClass : list )
    167 			{
    168 				try
    169 				{
    170 					T listener = ( T ) listenerClass.newInstance();
    171 					if( listenerConfigs.containsKey( listenerClass ) && listener instanceof InitializableListener )
    172 						((InitializableListener)listener).init( listenerConfigs.get( listenerClass ) );
    173
    174 					result.add( listener );
    175 				}
    176 				catch( Exception e )
    177 				{
    178 					SoapUI.logError( e );
    179 				}
    180 			}
    181 		}
    182
    183 		if( singletonListeners.containsKey( listenerType ))
    184 			result.addAll( ( Collection<? extends T> ) singletonListeners.get( listenerType) );
    185
    186 		return result;
    187 	}
    188 }