rulebaseloader.java

drools 一个开放源码的规则引擎

        {
            if ( bis != null )
            {
                bis.close();
            }
            if ( in != null )
            {
                in.close();
            }
        }
                        
    }

    private void addRuleSetBinary(byte[] ruleSetBytes)
    {
        this.ruleSetBinaries.add(ruleSetBytes);
    }   

 
    


    /**
     * this adds to the classloader.
     * @param classes
     * @param classLoader
     */
    private void addToClassLoader(Map classes,
                                  ByteArrayClassLoader classLoader)
    {
        for ( Iterator iter = classes.keySet().iterator( ); iter.hasNext( ); )
        {
            String name = (String) iter.next( );
            byte[] data = (byte[]) classes.get(name);
            classLoader.addByteArray( name, data );
            
        }
    }

    public void addFromRuleSet(RuleSet ruleSet) throws SAXException,
                                               IOException,
                                               IntegrationException
    {
        this.builder.addRuleSet( ruleSet );
    }

    public void addFromRuleSet(RuleSet[] ruleSets) throws SAXException,
                                                  IOException,
                                                  IntegrationException
    {
        for ( int i = 0; i < ruleSets.length; i++ )
        {
            addFromRuleSet( ruleSets[i] );
        }
    }
    
  
    
    /**
     * This will return a rulebase based on the added rulesets.
     * The rulebase should be serializable by default.
     * @return
     */
    public RuleBase buildRuleBase() {
       RuleBase ruleBase = this.builder.build();
       if (this.ruleSetBinaries.size() > 0) {
           SerializableRuleBaseProxy proxy = new SerializableRuleBaseProxy(ruleBase, this.ruleSetBinaries);
           return proxy;
       } else {
           return ruleBase;
       }
    }
    
    class ByteArrayClassLoader extends  ClassLoader
    {
        ByteArrayClassLoader(ClassLoader parent) {
          super(parent);
        }
        public void addByteArray(String name, byte[] bytes)
        {
            defineClass(name, bytes, 0, bytes.length);
        }
    }   

    private static class ObjectInputStreamWithLoader extends ObjectInputStream
    {
        private final ClassLoader classLoader;

        public ObjectInputStreamWithLoader(InputStream in,
                                           ClassLoader classLoader) throws IOException
        {
            super( in );
            this.classLoader = classLoader;
            enableResolveObject( true );
        }

        protected Class resolveClass(ObjectStreamClass desc) throws IOException,
                                                            ClassNotFoundException
        {
            if ( this.classLoader == null )
            {
                return super.resolveClass( desc );
            }
            else
            {
                String name = desc.getName();
                return this.classLoader.loadClass( name );
            }
        }
    }

    
    //-------------------------------------------------------
    // Added old static api methods back in for compatability
    //-------------------------------------------------------
    
    /**
     * Loads a RuleBase from a URL using the default ConflictResolver
     *
     * This is a convenience method and calls public static RuleBase
     * loadFromUrl(URL url, ConflictResolver resolver) passing the
     * DefaultConflictResolver
     *
     *
     * @param url A URL to the DRL to compile and load.
     * @return RuleBase
     */
    public static RuleBase loadFromUrl( URL url )
        throws SAXException,
               IOException,
               IntegrationException
    {
        return loadFromUrl( url, DefaultConflictResolver.getInstance( ) );
    }

    /**
     * Loads a RuleBase from a URL using the given ConflictResolver
     *
     * @param url
     * @param resolver
     * @return RuleBase
     */
    public static RuleBase loadFromUrl( URL url, ConflictResolver resolver )
        throws SAXException,
               IOException,
               IntegrationException
    {
        return loadFromUrl( new URL[]{url}, resolver );
    }

    /**
     * Loads a RuleBase using several URLs, using the DefaultConflictResolver.
     *
     * This is a convenience method and calls public static RuleBase
     * loadFromUrl(URL[] url, ConflictResolver resolver) passing the
     * DefaultConflictResolver
     *
     * @param urls
     * @return RuleBase
     */
    public static RuleBase loadFromUrl( URL[] urls )
        throws SAXException,
               IOException,
               IntegrationException
    {
        return loadFromUrl( urls, DefaultConflictResolver.getInstance( ) );
    }

    /**
     * Loads a RuleBase from several URLS, merging them and using the specified
     * ConflictResolver
     *
     * @param urls
     * @param resolver
     * @return RuleBase
     */
    public static RuleBase loadFromUrl( URL[] urls, ConflictResolver resolver )
        throws SAXException,
               IOException,
               IntegrationException
    {              
      RuleSetLoader ruleSetLoader = new RuleSetLoader();
      ruleSetLoader.addFromUrl(urls);
      
      return buildFromLoader( resolver,
                              ruleSetLoader );      
    }

    /**
     * Loads a RuleBase from an InputStream using the default ConflictResolver
     *
     * This is a convenience method and calls public static RuleBase
     * loadFromInputStream(InputStream in, ConflictResolver resolver) passing
     * the DefaultConflictResolver
     *
     * @param in
     * @return ruleBase
     */
    public static RuleBase loadFromInputStream( InputStream in )
        throws SAXException,
               IOException,
               IntegrationException
    {
        return loadFromInputStream( in, DefaultConflictResolver.getInstance( ) );

    }

    /**
     * Loads a RuleBase from an InputStream using the default ConflictResolver
     *
     * @param in
     * @param resolver
     * @return ruleBase
     */
    public static RuleBase loadFromInputStream( InputStream in,
                                                ConflictResolver resolver )
        throws SAXException,
               IOException,
               IntegrationException
    {
        return loadFromInputStream( new InputStream[]{in}, resolver );
    }

    /**
     * Loads a RuleBase from an InputStream using the default ConflictResolver
     *
     * This is a convenience method and calls public static RuleBase
     * loadFromInputStream(InputStream[] ins, ConflictResolver resolver)
     * passing the DefaultConflictResolver
     *
     * @param ins
     * @return ruleBase
     */
    public static RuleBase loadFromInputStream( InputStream[] ins )
        throws SAXException,
               IOException,
               IntegrationException
    {
        return loadFromInputStream( ins, DefaultConflictResolver.getInstance( ) );
    }

    /**
     * Loads a RuleBase from an InputStream using the default ConflictResolver
     *
     * @param ins
     * @param resolver
     * @return ruleBase
     */
    public static RuleBase loadFromInputStream( InputStream[] ins,
                                                ConflictResolver resolver )
        throws SAXException,
               IOException,
               IntegrationException
    {
        RuleSetLoader ruleSetLoader = new RuleSetLoader();
        ruleSetLoader.addFromInputStream(ins);
        
        return buildFromLoader( resolver,
                                  ruleSetLoader );                  
    }



    /**
     * Loads a RuleBase from a Reader using the default ConflictResolver
     *
     * This is a convenience method and calls public static RuleBase
     * loadFromReader(Reader in, ConflictResolver resolver) passing the
     * DefaultConflictResolver
     *
     * @param in
     * @return ruleBase
     */
    public static RuleBase loadFromReader( Reader in )
        throws SAXException,
               IOException,
               IntegrationException
    {
        return loadFromReader( in, DefaultConflictResolver.getInstance( ) );
    }

    /**
     * Loads a RuleBase from a Reader using the given ConflictResolver
     *
     * @param in
     * @param resolver
     * @return ruleBase
     */
    public static RuleBase loadFromReader( Reader in, ConflictResolver resolver )
        throws SAXException,
               IOException,
               IntegrationException
    {
        return loadFromReader( new Reader[]{in}, resolver );
    }

    /**
     * Loads a RuleBase from a Reader using the default ConflictResolver
     *
     * This is a convenience method and calls public static RuleBase
     * loadFromReader(Reader[] ins, ConflictResolver resolver) passing the
     * DefaultConflictResolver
     *
     * @param ins
     * @return ruleBase
     */
    public static RuleBase loadFromReader( Reader[] ins )
        throws SAXException,
               IOException,
               IntegrationException
    {
        return loadFromReader( ins, DefaultConflictResolver.getInstance( ) );
    }

    /**
     * Loads a RuleBase from a Reader using the given ConflictResolver
     *
     * @param ins
     * @param resolver
     * @return ruleBase
     */
    public static RuleBase loadFromReader( Reader[] ins,
                                             ConflictResolver resolver )
        throws SAXException,
               IOException,
               IntegrationException
    {
        RuleSetLoader ruleSetLoader = new RuleSetLoader();
        ruleSetLoader.addFromReader(ins);
        
        return buildFromLoader( resolver,
                                  ruleSetLoader );  
    }

    private static RuleBase buildFromLoader(ConflictResolver resolver,
                                              RuleSetLoader ruleSetLoader) throws SAXException,
                                                                          IOException,
                                                                          IntegrationException
    {
        RuleBaseLoader ruleBaseLoader = new RuleBaseLoader(resolver);
        ruleBaseLoader.addFromRuleSetLoader(ruleSetLoader);

        return ruleBaseLoader.buildRuleBase();
    }    

}