loadermanager.java

本程序在Unix_Linux环境下用Java语言编写的文件下载程序

package loader.manager;

import loader.viewer.*;
import loader.recorder.*;
import loader.controller.*;
import loader.listener.*;
import loader.loader.*;
import java.net.*;
import java.io.*;
import java.util.*;
/**

*/
public class LoaderManager implements CompleteListener {
	//when class loader loading this class, it will automatically
	//load the properties we need.
	public static Properties pros;
	static{
		pros = new Properties();
		try{
			pros.load( new FileInputStream( new File( "conf/loader.pros" ) ) );
		}catch( Exception e ){
			System.err.println( "when loading conf file, failed." );
                        e.printStackTrace();
			System.exit( -1 );
		}
	}
	protected Viewer viewer;
	protected Controller controller;

	protected LoadRecorder recorder;

	protected URL resourceURL;
	protected File destFile;

	protected File tmpFile;
	
	/**
		when loading new resources, use this constructure to create one loadManager to load them.
	*/
	public LoaderManager( URL url, File file){
		resourceURL = url;
		destFile = file;

		controller = new LoaderController();
		controller.init( Controller.CONTINUE );

		recorder = null;
		//viewer = null;
	}
	
	/**
		when loading legace resources, use this constructure.
	*/
	public LoaderManager( LoadRecorder recorder ){
		//this( url, new File( LoaderManager.pros.getProperty( "destBaseFile" ) ) );
		this.recorder = recorder;

		controller = new LoaderController();
		controller.init( Controller.CONTINUE );

		resourceURL = null;
		destFile = null;
	}
	/**
		set get viewer of this manager.
	*/
	public void setViewer( Viewer viewer ){
		this.viewer = viewer;
	}
	public Viewer getViewer(){
		return this.viewer;
	}
	/**
		get this instance's recorder. when load method is called, it must return null.
	*/
	public LoadRecorder getRecorder(){
		return this.recorder;
	}
	/**
		get controller of this instance. if controlled the loaders this loadermanager started, it's only interface.
	*/
	public Controller getController(){
		return this.controller;
	}

	/**
		load the remote file specified by this.resourceURL, and save it in local destFile.
	*/
	public void load(){
		if( this.viewer == null ){
			System.out.println( "viewer is null. please set it." );
			return;
		}
                
		viewer.registerCompleteListener( this );
                
		if( this.recorder == null ){
			loadByURL();
		} else {
			loadByRecorder();
		}
	}

	protected void loadByURL(){
		System.out.println( "recorder has not been set. create it now." );

		int times = 2;
		try{
			times = Integer.parseInt( LoaderManager.pros.getProperty( "testTimes" ) );
		}catch( Exception e ){
			System.out.println( "when getting testTimes from conf, an error occurred. so using default vlaue: 2." );
		}
                System.out.println( "testTimes: " + times );
		this.recorder = getResponseHeader( this.resourceURL, times );
                if( recorder == null ){
                    System.out.println( "when getting header from " + this.resourceURL + " an error occurred." );
                    return;
                }
		recorder.put( "ResourceUrl", recorder.getList( this.resourceURL.toExternalForm() ) );
		recorder.put( "DestinationFile", recorder.getList( this.destFile.getAbsolutePath() ) );

		String base = LoaderManager.pros.getProperty( "tmpBaseFile" );
                System.out.println( "tmp: " + base );
		String name = this.destFile.getName();
                System.out.println( "tmp: " + name );
		this.tmpFile = new File( base + "/" + name );
		tmpFile.mkdirs();
                System.out.println( "tmp: " + tmpFile.toString() );
		recorder.put( "tmpDestinationFile", recorder.getList( tmpFile.getAbsolutePath() )  );

		if( getResponseCode( recorder ) != 200 ){
			System.out.println( "response code is not 200. just return" );
			return;
		}
		int totalLength;

		viewer.setMini_Max( 0, ( totalLength =  getContentLength( recorder ) ) );
		viewer.setLength( 0 );

		if( getAccept_Ranges( recorder ).equals( "bytes" ) ) {

			int threads = 10;
			try{
				//get threads
				threads = Integer.parseInt( LoaderManager.pros.getProperty( "threadsNum" ) );
			}catch( Exception e ){}

			recorder.put( "ThreadsNum", recorder.getList( ""+threads ) );
			recorder.put( "BufferSize", recorder.getList( LoaderManager.pros.getProperty( "bufferSize" ) ) );

			int interval = ( int )totalLength/threads;
			for( int i=0; i<threads; i++ ){

				Loader loader = new Loader( "thread"+i );

				if( i == ( threads -1 ) ){
					recorder.put( loader.getName(), recorder.getList( 0+","+(totalLength -1)+","+i*interval ) );
					loader.setProperties( getProperties( "" + i, i*interval, totalLength - 1 ) );
				} else {
					recorder.put( loader.getName(), recorder.getList( 0+","+( (i+1)*interval - 1 )+","+i*interval ) );
					loader.setProperties( getProperties( "" + i, i*interval, ( (i+1)*interval - 1 ) ) );
				}
                                    
				loader.setViewer( this.viewer );
				loader.setRecorder( this.recorder );
				loader.setController( this.controller );
                                this.viewer.doInit();
                                
				loader.start();
			}
		} else {
			Loader loader = new Loader( "thread"+0 );

			recorder.put( "ThreadsNum", recorder.getList( ""+1 ) );
			recorder.put( "BufferSize", recorder.getList( ""+1024 ) );
			recorder.put( loader.getName(), recorder.getList( 0+","+(totalLength-1)+","+0 ) );

			loader.setProperties( getProperties( ""+0, 0, totalLength-1 ) );
			loader.setViewer( this.viewer );
			loader.setRecorder( this.recorder );
			loader.setController( this.controller );
                        this.viewer.doInit();
                        
			loader.start();
		}
	}

	protected void loadByRecorder(){
		int threads;
		try{
			this.resourceURL = new URL( recorder.get( "ResourceUrl" ).get( 0 ) );
                        
			this.destFile = new File ( recorder.get( "DestinationFile" ).get( 0 ) );
			tmpFile = new File( recorder.get( "tmpDestinationFile" ).get( 0 ) );
			threads = Integer.parseInt( recorder.get( "ThreadsNum").get( 0 ) );
		}catch( Exception e ){
			System.err.println( "when getting params from recorder, an error occurred." );
			return;
		}

		int totalLength;
		viewer.setMini_Max( 0, ( totalLength = getContentLength( recorder ) ) );

		int curlength = 0;
		for( int ii=0; ii<threads; ii++ ){
			try{
				curlength += Integer.parseInt( recorder.get( "thread"+ii ).get( 0 ) );
			}catch( Exception e ){
				System.err.println( "when getting the current loading position, failed." );
				return;
			}
		}
		viewer.setLength( curlength );//***********

		for( int i=0; i<threads; i++ ){
			Loader loader = new Loader( "thread"+i );
			try{
                                int le = Integer.parseInt( recorder.get( loader.getName() ).get( 0 ) );
                                int end = Integer.parseInt( recorder.get( loader.getName() ).get( 1 ) );
                                int sta = Integer.parseInt( recorder.get( loader.getName() ).get( 2 ) );
                                if( le+sta > end ){
                                    System.out.print( "le + sta > end" );
                                    continue;
                                }
				loader.setProperties( getProperties( ""+i, le+sta, end ) );
			}catch( Exception e ){
				System.err.println( "when getting ranges, failed." );
				return;
			}

			loader.setViewer( viewer );
			loader.setRecorder( recorder );
			loader.setController( controller );

			loader.start();
		}
	}
        
	public void stop(){
		this.controller.control( Controller.STOP );
                this.controller.waitDie();
	}

	public void log( File logFile ){
		try{			
			this.recorder.log( logFile );
		}catch( Exception e ){
			System.err.println( "when log recorders, there's an error occurred." );
			e.printStackTrace();
		}
	}

	public void complete( CompleteEvent e ){

		Viewer v = e.getSource();

		SequenceInputStream s = null;
		FileOutputStream fout = null;

		System.out.println( "complete" );

		try{
				s = new SequenceInputStream( getSequenceFile( this.tmpFile ) );
				fout = new FileOutputStream( this.destFile );

				byte[] buffer = new byte[1024*6];
				int bt;
				while( ( bt = s.read( buffer ) ) != -1) {
					fout.write( buffer, 0, bt );
				}
				s.close();
				fout.close();
				
				this.deleteFiles( this.tmpFile );
                                this.tmpFile.delete();
				
				v.doEnd();				
		} catch( Exception ee ) {
			System.err.println( "complete error" );
                        ee.printStackTrace();
		} finally {
			try{
				if( s != null ) {
					s.close();
				}
				if( fout != null ) {
					fout.close();
				}
			}catch( Exception ex ) {}

			v.doEnd();
		}
	}

	/**********************************************************************/
        protected LoadRecorder getResponseHeader( URL url, int times ) {
		for( int i=0; i<times; i++ ) {
			HttpURLConnection con = null;
			try{
				con = ( HttpURLConnection ) url.openConnection();
				con.connect();
				System.out.println( "getResponseHeader method." );
                                
                                Map<String,List<String>> h = con.getHeaderFields();
                                Hashtable<String, List<String>> hh = new Hashtable<String,List<String>>();
                                
                                String tmpKey = "Response-Line";
                                Set<String> keys = h.keySet();
                                Iterator<String> ie = keys.iterator();
                                
                                while( ie.hasNext() ){
                                    String key = ie.next();
                                    if( key == null ){
                                        hh.put( tmpKey, h.get( key ) );
                                    } else {
                                        hh.put( key, h.get( key ) );
                                    }
                                }
                                keys = hh.keySet();
                                ie = keys.iterator();
                                while( ie.hasNext() ){
                                    String key = ie.next();
                                    System.out.print( key + "=" );
                                    System.out.println( hh.get( key ) );
                                }
				return new LoadRecorder( hh );
			} catch( Exception t ) {
                            t.printStackTrace();
                            continue;
			} finally{
				try{
					if( con != null ){
						con.disconnect();
					}
				}catch( Exception e ){}
			}
		}
		return null;
	}

	private int getContentLength( LoadRecorder header ) {
		String lengthStr = header.get( "Content-Length" ).get( 0 );
		try{
			return Integer.parseInt( lengthStr );
		} catch( NumberFormatException e ){
		}
		return -1;
	}
	private String getAccept_Ranges( LoadRecorder header ) {
		return header.get( "Accept-Ranges" ).get( 0 );
	}
	private int getResponseCode( LoadRecorder header ) {
		StringTokenizer  res = new StringTokenizer( header.get( "Response-Line" ).get( 0 ) );
		String code = null;
		if( res.hasMoreTokens() ) {
			code = res.nextToken();
		}
		if( res.hasMoreTokens() ) {
			code = res.nextToken();
		}
		try{
			return Integer.parseInt( code );
		}catch( NumberFormatException e ) {
		}
		return -1;
	}
	private Properties getProperties( String fileName, int mini, int max ) {
		Properties p = new Properties();
		p.put( "ResourceUrl", this.resourceURL.toExternalForm() );
		p.put( "tmpDestinationFile", new File( this.tmpFile, fileName ).getAbsolutePath() );
		p.put( "Range", "bytes=" + mini + "-" + max );
		p.put( "BufferSize", recorder.get( "BufferSize" ).get( 0 ) );
		return p;
	}

	private  Enumeration<FileInputStream> getSequenceFile( final File baseFile ) {
		return new Enumeration<FileInputStream>() {
			File[] list = sort( baseFile.listFiles() );
			int ii = 0;
			public boolean hasMoreElements() {
				if( ii < list.length ) {
					return true;
				} else {
					return false;
				}
			}
			public FileInputStream nextElement() {
				FileInputStream fin = null;
				try{
					fin = new FileInputStream( list[ii] );
					ii++;
					return fin;
				}catch( Exception e ){
				}
				return fin;
			}
			private File[] sort( File[] files ) {
				
				/*????????????*/
				for( int i=1; i<files.length; i++ ) {
					int j;
					if( getInt( files[i-1] ) > getInt( files[i] ) ) {
						File f;
						for( j=i; getInt( files[j-1] ) > getInt( files[j] ); ) {
							f = files[j];
							files[j] = files[j-1];
							files[j-1] = f;
								j--;
							if( j== 0 ) {
								break;
							}
						}
					}
				}
				return files;
			}
			private int getInt( File f ) {
				String fint = f.getName();
				try{
					return Integer.parseInt( fint );
				} catch( Exception e ) {
				}
				return -1;
			}
		};
	}
	private void deleteFiles( File baseFile ) {
		File[] files = baseFile.listFiles();
		for( int i=0; i<files.length; i++ ) {
			files[i].delete();
		}
	}
}