동적인 언어를 동적으로 호출하기, Part 2: 런타임 시 스크립트 찾기, 실행하기, 변경하기 (한글)

                
// Imports and Javadoc not shown.
public class ScriptMortgageQualifier {
    private ScriptEngineManager scriptEngineManager = new ScriptEngineManager();

    public MortgageQualificationResult qualifyMortgage(
        Borrower borrower,
        Property property,
        Loan loan,
        File mortgageRulesFile
    ) throws FileNotFoundException, IllegalArgumentException, ScriptException
    {
        ScriptEngine scriptEngine = getEngineForFile(mortgageRulesFile);
        if (scriptEngine == null) {
            throw new IllegalArgumentException(
                "No script engine on classpath to handle file: " + mortgageRulesFile
            );
        }

        // Make params accessible to scripts by adding to engine's context.
        scriptEngine.put("borrower", borrower);
        scriptEngine.put("property", property);
        scriptEngine.put("loan", loan);

        // Make return-value object available to scripts.
        MortgageQualificationResult scriptResult = new MortgageQualificationResult();
        scriptEngine.put("result", scriptResult);

        // Add an object scripts can call to exit early from processing.
        scriptEngine.put("scriptExit", new ScriptEarlyExit());

        try {
            scriptEngine.eval(new FileReader(mortgageRulesFile));
        } catch (ScriptException se) {
            // Re-throw exception unless it's our early-exit exception.
            if (se.getMessage() == null ||
                !se.getMessage().contains("ScriptEarlyExitException")
            ) {
                throw se;
            }
            // Set script result message if early-exit exception embedded.
            Throwable t = se.getCause();
            while (t != null) {
                if (t instanceof ScriptEarlyExitException) {
                    scriptResult.setMessage(t.getMessage());
                    break;
                }
                t = t.getCause();
            }
        }

        return scriptResult;
    }

    /** Returns a script engine based on the extension of the given file. */
    private ScriptEngine getEngineForFile(File f) {
        String fileExtension = getFileExtension(f);
        return scriptEngineManager.getEngineByExtension(fileExtension);
    }

    /** Returns the file's extension, or "" if the file has no extension */
    private String getFileExtension(File file) {
        String scriptName = file.getName();
        int dotIndex = scriptName.lastIndexOf('.');

        if (dotIndex != -1) {
            return scriptName.substring(dotIndex + 1);
        } else {
            return "";
        }
    }

    /** Internal exception so ScriptEarlyExit.exit can exit scripts early */
    private static class ScriptEarlyExitException extends Exception {
        public ScriptEarlyExitException(String msg) {
            super(msg);
        }
    }

    /** Object passed to all scripts so they can indicate an early exit. */
    private static class ScriptEarlyExit {
        public void noMessage() throws ScriptEarlyExitException {
            throw new ScriptEarlyExitException(null);
        }
        public void withMessage(String msg) throws ScriptEarlyExitException {
            throw new ScriptEarlyExitException(msg);
        }
    }
}

                
// Imports and some helper methods not shown.
public class ScriptMortgageQualifierRunner {
    private static File scriptDirectory;
    private static Borrower goodBorrower = createGoodBorrower();
    private static Borrower averageBorrower = createAverageBorrower();
    private static Borrower investorBorrower = createInvestorBorrower();
    private static Borrower riskyBorrower = createRiskyBorrower();
    private static Property property = createProperty();
    private static Loan loan = createLoan();

    /**
     * Main method to create a File for the directory name on the command line,
     * then call the run method if that directory exists.
     */
    public static void main(String[] args) {
        if (args.length > 0 && args[0].contains("-help")) {
            printUsageAndExit();
        }
        String dirName;
        if (args.length == 0) {
            dirName = "."; // Current directory.
        } else {
            dirName = args[0];
        }

        scriptDirectory = new File(dirName);
        if (!scriptDirectory.exists() || !scriptDirectory.isDirectory()) {
            printUsageAndExit();
        }

        run();
    }

    /**
     * Determines mortgage loan-qualification status for four test borrowers by
     * processing all script files in the given directory. Each script will determine
     * whether the given borrower is qualified for a particular mortgage type
     */
    public static void run() {
        ScriptMortgageQualifier mortgageQualifier = new ScriptMortgageQualifier();

        for(;;) { // Requires Ctrl-C to exit
            runQualifications(mortgageQualifier, goodBorrower, loan, property);
            runQualifications(mortgageQualifier, averageBorrower, loan, property);

            loan.setDownPayment(30000.0); // Reduce down payment to 10%
            runQualifications(mortgageQualifier, investorBorrower, loan, property);

            loan.setDownPayment(10000.0); // Reduce down payment to 3 1/3%
            runQualifications(mortgageQualifier, riskyBorrower, loan, property);

            waitOneMinute();
        }
    }

    /**
     * Reads all script files in the scriptDirectory and runs them with this borrower's
     * information to see if he/she qualifies for each mortgage product.
     */
    private static void runQualifications(
        ScriptMortgageQualifier mortgageQualifier,
        Borrower borrower,
        Loan loan,
        Property property
    ) {
        for (File scriptFile : getScriptFiles(scriptDirectory)) {
            // Print info about the borrower, loan and property.
            System.out.println("Processing file: " + scriptFile.getName());
            System.out.println("  Borrower: " + borrower.getName());
            System.out.println("  Credit score: " + borrower.getCreditScore());
            System.out.println("  Sales price: " + property.getSalesPrice());
            System.out.println("  Down payment: " + loan.getDownPayment());

            MortgageQualificationResult result = null;
            try {
                // Run the script rules for this borrower on the loan product.
                result = mortgageQualifier.qualifyMortgage(
                    borrower, property, loan, scriptFile
                );
            } catch (FileNotFoundException fnfe) {
                System.out.println(
                    "Can't read script file: " + fnfe.getMessage()
                );
            } catch (IllegalArgumentException e) {
                System.out.println(
                    "No script engine available to handle file: " +
                    scriptFile.getName()
                );
            } catch (ScriptException e) {
                System.out.println(
                    "Script '" + scriptFile.getName() +
                    "' encountered an error: " + e.getMessage()
                );
            }

            if (result == null) continue; // Must have hit exception.

            // Print results.
            System.out.println(
                "* Mortgage product: " + result.getProductName() +
                ", Qualified? " + result.isQualified() +
                "\n* Interest rate: " + result.getInterestRate() +
                "\n* Message: " + result.getMessage()
            );
            System.out.println();
        }
    }

    /** Returns files with a '.' other than as the first or last character. */
    private static File[] getScriptFiles(File directory) {
        return directory.listFiles(new FilenameFilter() {
            public boolean accept(File dir, String name) {
                int indexOfDot = name.indexOf('.');
                // Ignore files w/o a dot, or with dot as first or last char.
                if (indexOfDot < 1 || indexOfDot == (name.length() - 1)) {
                    return false;
                } else {
                    return true;
                }
            }
        });
    }

    private static void waitOneMinute() {
        System.out.println(
            "\nSleeping for one minute before reprocessing files." +
            "\nUse Ctrl-C to exit..."
        );
        System.out.flush();
        try {
            Thread.sleep(1000 * 60);
        } catch (InterruptedException e) {
            System.exit(1);
        }
    }
}

                
public class MortgageQualificationResult {
    private boolean qualified;
    private double interestRate;
    private String message;
    private String productName;

    // .. Standard setters and getters not shown.
}

                
/*
   This Groovy script defines the "Groovy Mortgage" product.
   This product is relaxed in its requirements of borrowers.
   There is a higher interest rate to make up for the looser standard.
   All borrowers will be approved if their credit history is good, they can
   make a down payment of at least 5%, and they either earn more than
   $2,000/month or have a net worth (assets minus liabilities) of $25,000.
*/

// Our product name.
result.productName = 'Groovy Mortgage'

//  Check for the minimum income and net worth
def netWorth = borrower.totalAssets - borrower.totalLiabilities
if (borrower.monthlyIncome < 2000 && netWorth < 25000) {
    scriptExit.withMessage "Low monthly income of ${borrower.monthlyIncome}" +
       ' requires a net worth of at least $25,000.'
}

def downPaymentPercent = loan.downPayment / property.salesPrice * 100
if (downPaymentPercent < 5) {
    scriptExit.withMessage 'Down payment of ' +
        "${String.format('%1$.2f', downPaymentPercent)}% is insufficient." +
        ' 5% minimum required.'
}
if (borrower.creditScore < 600) {
    scriptExit.withMessage 'Credit score of 600 required.'
}

// Everyone else qualifies. Find interest rate based on down payment percent.
result.qualified = true
result.message = 'Groovy! You qualify.'

switch (downPaymentPercent) {
    case 0..5:   result.interestRate = 0.08; break
    case 6..10:  result.interestRate = 0.075; break
    case 11..15: result.interestRate = 0.07; break
    case 16..20: result.interestRate = 0.065; break
    default:     result.interestRate = 0.06; break
}

                
/**
 * This script defines the "JavaScript FirstTime Mortgage" product.
 * It is a government-sponsored mortgage intended for low-income, first-time
 * home buyers without a lot of assets who intend to live in the home.
 * Bankruptcies and bad (but not terrible!) credit are OK.
 */
result.productName = 'JavaScript FirstTime Mortgage'

if (!borrower.intendsToOccupy) {
    result.message = 'This mortgage is not intended for investors.'
    scriptExit.noMessage()
}
if (!borrower.firstTimeBuyer) {
    result.message = 'Only first-time home buyers qualify for this mortgage.'
    scriptExit.noMessage()
}
if (borrower.monthlyIncome > 4000) {
    result.message = 'Monthly salary of $' + borrower.monthlyIncome +
        ' exceeds the $4,000 maximum.'
    scriptExit.noMessage()
}
if (borrower.creditScore < 500) {
    result.message = 'Your credit score of ' + borrower.creditScore +
        ' does not meet the 500 requirement.'
    scriptExit.noMessage()
}

// Qualifies. Determine interest rate based on loan amount and credit score.
result.qualified = true
result.message = 'Congratulations, you qualify.'

if (loan.loanAmount > 450000) {
    result.interestRate = 0.08 // Big loans and poor credit require higher rate.
} else if (borrower.creditScore < 550) {
    result.interestRate = 0.08
} else if (borrower.creditScore < 600) {
    result.interestRate = 0.07
} else if (borrower.creditScore < 700) {
    result.interestRate = 0.065
} else { // Good credit gets best rate.
    result.interestRate = 0.06
}

                
# This Ruby script defines the "Ruby Mortgage" product.
# It is intended for premium borrowers with its low interest rate
# and 20% down payment requirement.

# Our product name
$result.product_name = 'Ruby Mortgage'

# Borrowers with credit unworthiness do not qualify.
if $borrower.credit_score < 700
    $scriptExit.with_message "Credit score of #{$borrower.credit_score}" +
        " is lower than 700 minimum"
end

$scriptExit.with_message 'No bankruptcies allowed' if $borrower.hasDeclaredBankruptcy

# Check other negatives
down_payment_percent = $loan.down_payment / $property.sales_price * 100
if down_payment_percent < 20
    $scriptExit.with_message 'Down payment must be at least 20% of sale price.'
end

# Borrower qualifies. Determine interest rate of loan
$result.message = "Qualified!"
$result.qualified = true

# Give the best interest rate to the best credit risks.
if $borrower.credit_score > 750 || down_payment_percent > 25
    $result.interestRate = 0.06
elsif $borrower.credit_score > 700 && $borrower.totalAssets > 100000
    $result.interestRate = 0.062
else
    $result.interestRate = 0.065
end

                
> ant run
Buildfile: build.xml

compile:
    [mkdir] Created dir: C:\temp\script-article\build-main\classes
    [javac] Compiling 10 source files to C:\temp\script-article\build-main\classes

run:
     [java] Processing file: GroovyMortgage.groovy
     [java]   Borrower: Good Borrower
     [java]   Credit score: 800
     [java]   Sales price: 300000.0
     [java]   Down payment: 60000.0
     [java] * Mortgage product: Groovy Mortgage, Qualified? true
     [java] * Interest rate: 0.06
     [java] * Message: Groovy! You qualify.

     [java] Processing file: JavaScriptFirstTimeMortgage.js
     [java]   Borrower: Good Borrower
     [java]   Credit score: 800
     [java]   Sales price: 300000.0
     [java]   Down payment: 60000.0
     [java] * Mortgage product: JavaScript FirstTime Mortgage, Qualified? false
     [java] * Interest rate: 0.0
     [java] * Message: Only first-time home buyers qualify for this mortgage.

     [java] Processing file: RubyPrimeMortgage.rb
     [java]   Borrower: Good Borrower
     [java]   Credit score: 800
     [java]   Sales price: 300000.0
     [java]   Down payment: 60000.0
     [java] * Mortgage product: Ruby Mortgage, Qualified? true
     [java] * Interest rate: 0.06
     [java] * Message: Qualified!

     [java] Processing file: GroovyMortgage.groovy
     [java]   Borrower: Average Borrower
     [java]   Credit score: 700
     [java]   Sales price: 300000.0
     [java]   Down payment: 60000.0
     [java] * Mortgage product: Groovy Mortgage, Qualified? true
     [java] * Interest rate: 0.06
     [java] * Message: Groovy! You qualify.

     [java] Processing file: JavaScriptFirstTimeMortgage.js
     [java]   Borrower: Average Borrower
     [java]   Credit score: 700
     [java]   Sales price: 300000.0
     [java]   Down payment: 60000.0
     [java] * Mortgage product: JavaScript FirstTime Mortgage, Qualified? false
     [java] * Interest rate: 0.0
     [java] * Message: Monthly salary of $4500 exceeds the $4,000 maximum.

     [java] Processing file: RubyPrimeMortgage.rb
     [java]   Borrower: Average Borrower
     [java]   Credit score: 700
     [java]   Sales price: 300000.0
     [java]   Down payment: 60000.0
     [java] * Mortgage product: Ruby Mortgage, Qualified? true
     [java] * Interest rate: 0.065
     [java] * Message: Qualified!

     [java] Processing file: GroovyMortgage.groovy
     [java]   Borrower: Investor Borrower
     [java]   Credit score: 720
     [java]   Sales price: 300000.0
     [java]   Down payment: 30000.0
     [java] * Mortgage product: Groovy Mortgage, Qualified? true
     [java] * Interest rate: 0.06
     [java] * Message: Groovy! You qualify.

     [java] Processing file: JavaScriptFirstTimeMortgage.js
     [java]   Borrower: Investor Borrower
     [java]   Credit score: 720
     [java]   Sales price: 300000.0
     [java]   Down payment: 30000.0
     [java] * Mortgage product: JavaScript FirstTime Mortgage, Qualified? false
     [java] * Interest rate: 0.0
     [java] * Message: This mortgage is not intended for investors.

     [java] Processing file: RubyPrimeMortgage.rb
     [java]   Borrower: Investor Borrower
     [java]   Credit score: 720
     [java]   Sales price: 300000.0
     [java]   Down payment: 30000.0
     [java] * Mortgage product: Ruby Mortgage, Qualified? false
     [java] * Interest rate: 0.0
     [java] * Message: Down payment must be at least 20% of sale price.

     [java] Processing file: GroovyMortgage.groovy
     [java]   Borrower: Risk E. Borrower
     [java]   Credit score: 520
     [java]   Sales price: 300000.0
     [java]   Down payment: 10000.0
     [java] * Mortgage product: Groovy Mortgage, Qualified? false
     [java] * Interest rate: 0.0
     [java] * Message: Down payment of 3.33% is insufficient. 5% minimum required.

     [java] Processing file: JavaScriptFirstTimeMortgage.js
     [java]   Borrower: Risk E. Borrower
     [java]   Credit score: 520
     [java]   Sales price: 300000.0
     [java]   Down payment: 10000.0
     [java] * Mortgage product: JavaScript FirstTime Mortgage, Qualified? true
     [java] * Interest rate: 0.08
     [java] * Message: Congratulations, you qualify.

     [java] Processing file: RubyPrimeMortgage.rb
     [java]   Borrower: Risk E. Borrower
     [java]   Credit score: 520
     [java]   Sales price: 300000.0
     [java]   Down payment: 10000.0
     [java] * Mortgage product: Ruby Mortgage, Qualified? false
     [java] * Interest rate: 0.0
     [java] * Message: Credit score of 520 is lower than 700 minimum


     [java] Sleeping for one minute before reprocessing files.
     [java] Use Ctrl-C to exit...