Domain logic in database

Question

Hi.
I know this is off topic, but I need some feedback.
My company is relativly new to J2EE. We are currently moving our existing application portfolio to J2EE from a two tier client-server architecture developed on Centura and Oracle. Our data model is pretty strong, and much of the domain logic of the application has been moved to the database over the course of the last few years, so there is quite a bit of PL/SQL code in there.
Now there is a heated discussion internally about the validity of making the transition to J2EE with the databases intact and reusing this PL/SQL based domain logic. We have individual proclaiming that every operation on data is domain logic and all domain logic should reside on the application server with J2EE.
I personally feel that J2EE fully allows for keeping domain logic in the database, and that one should always apply the principle of the "best technology for the job" in each case. For instance data intensive transformations and calculations belong on the database.
Please provide me with some support to use in our internal discussions as I feel overpowered by the "darker forces", and would very much like to know how the industry at large feels about this issue.
Regards,
Jorn Olmheim
Senior Java Developer

Answer 1

The purpose of getting the license and joining local and national Realtor associations is to get closer to the target audience. In order to build an effective marketing strategy, a business must learn as much as possible about their target audience. As a Realtor I will be able to easily network with potential clients. Another benefit of getting the license is that it greatly supports the business requirements gathering process for the applications. Actually, many of the features that we are building into the application will enable the broker to streamline business operations and reduce transaction costs. They could then feasilbly reduce the number of sales agents and maintain steady profit margins.
Very interesting.
Whatever happens in the markets, real estate is here to stay and there will always be land and property to buy and sell. Brokers that operate smartly and utilize technology efficiently will survive. Brokers that still maintain antiquated business models and still are in "legal pad" mode might experience difficulties with their business.
Good points, and a good attitude. I only asked because the bursting of the bubble will result in realtors leaving the field, not entering. But in your case it sounds like you've got a plan and a backup.
>
In regards to the math, there are equations for :
calculating the capitalization rate on income-generating properties
calculating annual taxes, monthly taxes and assessed value
finding a sellers net proceeds and sales price of property to meet specificed goals
rent per square foot
determining front footage and find the sales price off of these measurements
amortization of specified loan numbersThis one is usually a problem for folks.
>
measuring lot size and room dimensions with odd shapes
/>You can handle the rest. Not much more than multiplication and addition.
PS - Take these if you think they'll help:
AmortizationCalculatorForm.java
package finance.model;
import java.util.List;
import java.util.ArrayList;
* AmortizationCalculator
* User: Michael
* Date: Jul 16, 2007
* Time: 10:38:16 PM
public class AmortizationCalculator
   private static final int INITIAL_BUILDER_CAPACITY = 2048;
   private double principle;
   private double ratePercentage;
   private int numberOfPayments;
   private double payment;
   private List<AmortizationLineItem> amortizationLineItems;
    * Constructor
    * @param principle to start; must be greater than zero.
    * @param ratePercentage interest rate as a percentage (e.g., 10% interest means a value of 10.0)
    * @param numberOfPayments to be made.  A thirty-year mortgage with monthly payments would have 30*12 = 360 payments
   public AmortizationCalculator(double principle, double ratePercentage, int numberOfPayments)
      this.principle = principle;
      this.ratePercentage = ratePercentage;
      this.numberOfPayments = numberOfPayments;
      this.calculateAmortizationSchedule();
   private void calculateAmortizationSchedule()
      this.payment = calculatePayment(this.principle, this.ratePercentage, this.numberOfPayments);
      this.amortizationLineItems = calculateAmortizationTable(this.principle, this.ratePercentage, this.numberOfPayments, this.payment);
   public static List<AmortizationLineItem> calculateAmortizationTable(double principle, double ratePercentage, int numberOfPayments, double payment)
      List<AmortizationLineItem> amortizationLineItems = new ArrayList<AmortizationLineItem>(numberOfPayments);
      double balance = principle;
      for (int i = 0; i < numberOfPayments; ++i)
         int period = i+1;
         double interest = balance*ratePercentage/100.0;
         double principleReduction = payment-interest;
         amortizationLineItems.add(new AmortizationLineItem(period, balance, payment, principleReduction, interest));
         balance -= principleReduction;
      return amortizationLineItems;
    * Calculate the periodic payment
    * @param principle to be paid; should be a currency type; must be greater than zero
    * @param ratePercentage interest rate as a percentage (e.g., 10% rate means a value of 10.0 here)
    * @param numberOfPayments to complete payment; must be greater than zero.
    * @return periodic payment amount
    * @link http://en.wikipedia.org/wiki/Amortization_schedule
   public static double calculatePayment(double principle, double ratePercentage, int numberOfPayments)
      if (principle < 0.0)
         throw new IllegalArgumentException("Principle must be greater than zero");
      if (numberOfPayments <= 0)
         throw new IllegalArgumentException("Number of payments must be greater than zero");
      double rate = ratePercentage/100.0;
      double mult = Math.pow((1.0 + rate), numberOfPayments);
      return rate*mult*principle/(mult-1.0);
   public double getPrinciple()
      return principle;
   public void setPrinciple(double principle)
      this.principle = principle;
   public double getRatePercentage()
      return ratePercentage;
   public void setRatePercentage(double ratePercentage)
      this.ratePercentage = ratePercentage;
   public int getNumberOfPayments()
      return numberOfPayments;
   public void setNumberOfPayments(int numberOfPayments)
      this.numberOfPayments = numberOfPayments;
   public double getPayment()
      return payment;
    * Given a period number, return the AmortizationLineItem
    * @param period, starting with 1 and going up to numberOfPayments
    * @return AmortizationLineItem for the given period
   public AmortizationLineItem getLineItem(int period)
      return this.amortizationLineItems.get(period-1);
   public String toString()
      StringBuilder builder = new StringBuilder(INITIAL_BUILDER_CAPACITY);
      String newline = System.getProperty("line.separator");
      for (AmortizationLineItem amortizationLineItem : amortizationLineItems)
         builder.append(amortizationLineItem).append(newline);
      return builder.toString();
}AmortizationCalculatorTest.java
package finance.model;
import org.junit.Assert;
import org.junit.Test;
* AmortizationCalculatorTest
* User: Michael
* Date: Jul 16, 2007
* Time: 11:09:37 PM
public class AmortizationCalculatorTest
   public static final double TOLERANCE = 1.0E-3;
   @Test
   public void testCalculatePayment()
      double principle = 100.0;
      double ratePercentage = 10.0;
      int numberOfPayments = 5;
      double expected = 26.38;
      double actual = AmortizationCalculator.calculatePayment(principle, ratePercentage, numberOfPayments);
      Assert.assertEquals("Wrong period payment returned", expected, actual, TOLERANCE);
   @Test(expected = IllegalArgumentException.class)
   public void testNegativePrinciple()
      double principle = -100.0;
      double ratePercentage = 10.0;
      int numberOfPayments = 5;
      AmortizationCalculator.calculatePayment(principle, ratePercentage, numberOfPayments);
   @Test(expected = IllegalArgumentException.class)
   public void testNegativeNumberOfPayments()
      double principle = 100.0;
      double ratePercentage = 10.0;
      int numberOfPayments = -5;
      AmortizationCalculator.calculatePayment(principle, ratePercentage, numberOfPayments);
   @Test
   public void testAmortizationTable()
      double principle = 100.0;
      double ratePercentage = 10.0;
      int numberOfPayments = 5;
      AmortizationLineItem [] expected =
         new AmortizationLineItem(1, 100.0, 26.38, 16.38, 10.0),
         new AmortizationLineItem(2, 83.62, 26.38, 18.02, 8.36),
         new AmortizationLineItem(3, 65.60, 26.38, 19.82, 6.56),
         new AmortizationLineItem(4, 45.78, 26.38, 21.80, 4.58),
         new AmortizationLineItem(5, 23.98, 26.38, 23.98, 2.40),
      AmortizationCalculator calculator = new AmortizationCalculator(principle, ratePercentage, numberOfPayments);
      for (int i = 0; i < expected.length; ++i)
         Assert.assertEquals("Expected " + i + " does not equal actual", expected, calculator.getLineItem(i+1));
AmortizationLineItem.java
package finance.model;
import java.text.NumberFormat;
* AmortizationLineItem
* User: Michael
* Date: Jul 17, 2007
* Time: 11:40:38 AM
public class AmortizationLineItem
   public static final double TOLERANCE = 5.0e-3;
   private final int period;
   private final double outstandingBalance;
   private final double payment;
   private final double principle;
   private final double interest;
   public AmortizationLineItem(int period, double outstandingBalance, double payment, double principle, double interest)
      this.period = period;
      this.outstandingBalance = outstandingBalance;
      this.payment = payment;
      this.principle = principle;
      this.interest = interest;
   public int getPeriod()
      return period;
   public double getOutstandingBalance()
      return outstandingBalance;
   public double getPayment()
      return payment;
   public double getPrinciple()
      return principle;
   public double getInterest()
      return interest;
   public boolean equals(Object o)
      if (this == o)
         return true;
      if (o == null || getClass() != o.getClass())
         return false;
      AmortizationLineItem that = (AmortizationLineItem) o;
      if (Math.abs(that.interest - interest) > TOLERANCE)
         return false;
      if (Math.abs(that.outstandingBalance - outstandingBalance) > TOLERANCE)
         return false;
      if (Math.abs(that.payment - payment) > TOLERANCE)
         return false;
      if (period != that.period)
         return false;
      if (Math.abs(that.principle - principle) > TOLERANCE)
         return false;
      return true;
   public int hashCode()
      int result;
      long temp;
      result = period;
      temp = outstandingBalance != +0.0d ? Double.doubleToLongBits(outstandingBalance) : 0L;
      result = 31 * result + (int) (temp ^ (temp >>> 32));
      temp = payment != +0.0d ? Double.doubleToLongBits(payment) : 0L;
      result = 31 * result + (int) (temp ^ (temp >>> 32));
      temp = principle != +0.0d ? Double.doubleToLongBits(principle) : 0L;
      result = 31 * result + (int) (temp ^ (temp >>> 32));
      temp = interest != +0.0d ? Double.doubleToLongBits(interest) : 0L;
      result = 31 * result + (int) (temp ^ (temp >>> 32));
      return result;
   public String toString()
      return
         "period=" + period +
         ", balance=" + NumberFormat.getCurrencyInstance().format(outstandingBalance) +
         ", payment=" + NumberFormat.getCurrencyInstance().format(payment) +
         ", principle=" + NumberFormat.getCurrencyInstance().format(principle) +
         ", interest=" + NumberFormat.getCurrencyInstance().format(interest);
}SimpleInterestCalculator.java
package finance.model;
import java.text.DecimalFormat;
* A simple interest calculator
* @link http://mathforum.org/dr.math/faq/faq.interest.html
public class SimpleInterestCalculator
    public static final double DEFAULT_PRINCIPAL = 6000.0;
    public static final double DEFAULT_AMOUNT = 7680.0;
    public static final double DEFAULT_PERCENT = 0.04;
    public static final int DEFAULT_PERIODS = 7;
    public static final DecimalFormat DEFAULT_FORMAT = new DecimalFormat("0.00");
     * Command line driver
     * @param args command line
    public static void main(String [] args)
        try
            double principal = ((args.length > 0) ? Double.parseDouble(args[0]) : DEFAULT_PRINCIPAL);
            double amount   = ((args.length > 1) ? Double.parseDouble(args[1]) : DEFAULT_AMOUNT);
            double percent = ((args.length > 2) ? Double.parseDouble(args[2]) : DEFAULT_PERCENT);
            int numPeriods = ((args.length > 3) ? Integer.parseInt(args[3]) : DEFAULT_PERIODS);
            System.out.println("amount   : " + DEFAULT_FORMAT.format(SimpleInterestCalculator.calcAmount(principal, percent, numPeriods)));
            System.out.println("principal: " + DEFAULT_FORMAT.format(SimpleInterestCalculator.calcPrincipal(amount, percent, numPeriods)));
            System.out.println("interest : " + DEFAULT_FORMAT.format(SimpleInterestCalculator.calcInterest(principal, amount, numPeriods)));
            System.out.println("# periods: " + DEFAULT_FORMAT.format(SimpleInterestCalculator.calcNumPeriods(principal, amount, percent)));
        catch (Exception e)
            e.printStackTrace();
     * Calculate the amount after a number of periods for a given
     * starting principal and interest rate
     * @param principal at start
     * @param percent interest rate (e.g., percent = 0.10 for 10% interest)
     * @param numPeriods number of periods
     * @return amount accumulated after numPeriods
     * @throws IllegalArgumentException if the number of periods is negative
    public static double calcAmount(double principal, double percent, int numPeriods)
        if (numPeriods < 0)
            throw new IllegalArgumentException("Scalar of periods must be positive");
        // A = P(1+ni)
        return principal*(1.0 + percent*numPeriods);
     * Calculate the principal to start with given a desired amount,
     * interest rate, and number of periods
     * @param amount at end
     * @param percent interest rate (e.g., percent = 0.10 for 10% interest)
     * @param numPeriods number of periods
     * @return principal at start
     * @throws IllegalArgumentException if the number of periods is negative
    public static double calcPrincipal(double amount, double percent, int numPeriods)
        if (numPeriods < 0)
            throw new IllegalArgumentException("Scalar of periods must be positive");
        // P = A/(1+ni)
        return amount/(1.0 + percent*numPeriods);
     * Calculate the interest rate for a given amount, principal, and number of periods
     * @param principal at start
     * @param amount at end
     * @param numPeriods number of periods
     * @return interest rate
     * @throws IllegalArgumentException if the number of periods is non-positive
    public static double calcInterest(double principal, double amount, int numPeriods)
        if (numPeriods <= 0)
            throw new IllegalArgumentException("Scalar of periods must be greater than zero");
        // i = ([A/P]-1)/n.
        return ((amount/principal) - 1.0)/numPeriods;
     * Calculate the number of periods for a given amount, principal, and rate
     * @param principal at start
     * @param amount at end
     * @param percent rate
     * @return number of periods
    public static double calcNumPeriods(double principal, double amount, double percent)
        //n = ([A/P]-1)/i
        return ((amount/principal) - 1.0)/percent;