create table address
(
        id INT not null,
        address_line1 VARCHAR(255),
        address_line2 VARCHAR(255),
        county VARCHAR(50),
        address_type VARCHAR(30),
        city VARCHAR(50),
        postal_code VARCHAR(10),
        state_code VARCHAR(10),
        primary key (id)
);
 
create table applicant
(
        id INT not null,
        ssn VARCHAR(15),
        date_of_birth VARCHAR(30),
        first_name VARCHAR(80),
        last_name VARCHAR(80),
        middle_name VARCHAR(50),
        applicant_role VARCHAR(15),
        p_address INT,
        p_application INT,
        primary key (id)
);
 
create table application
(
        id INT not null,
        loan_amount DOUBLE PRECISION,
        loan_type VARCHAR(15),
        p_address INT,
        primary key (id)
);
 
create table cbr_summary
(
        id INT not null,
        credit_score VARCHAR(10),
        credit_bureau VARCHAR(30),
        requested_date VARCHAR(30),
        p_applicant INT,
        primary key (id)
);

 

Click Next to select the Mapping Options. Select List for the Collection Type.

Finish Entity Creation

Click Finish to complete the entity creation process.

Now, your project structure should look as shown below. This opens up the persistence.xml which defines the domain entities and database properties for EclipseLink provider. You may want to add the EclipseLink logging level attribute in persistence.xml (<property name="eclipselink.logging.level" value="FINE"/>) so that you can see the SQL commands performed during each database transaction. On the left side of the project explorer, you see all the domain classes generated as a result of the earlier step.

Project Structure

You may also notice that your POM is automatically updated to include the EclipseLink dependencies.

    <dependencies>
        <dependency>
            <groupId>org.eclipse.persistence</groupId>
            <artifactId>eclipselink</artifactId>
            <version>2.0.0</version>
        </dependency>
        <dependency>
            <groupId>org.eclipse.persistence</groupId>
            <artifactId>javax.persistence</artifactId>
            <version>2.0.0</version>
        </dependency>
        <dependency>
            <groupId>javax.annotation</groupId>
            <artifactId>jsr250-api</artifactId>
            <version>1.0</version>
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>javax.transaction</groupId>
            <artifactId>jta</artifactId>
            <version>1.1</version>
            <scope>provided</scope>
        </dependency>
    </dependencies>

You need to generate the constructors from NetBeans (Alt + Insert shortcut) for all our domain classes. This will be used for creating and persisting entities in our tests.

    public Address(Integer id, String addressLine1, String addressLine2, String county, String addressType, String city, String postalCode, String stateCode) {
        this.id = id;
        this.addressLine1 = addressLine1;
        this.addressLine2 = addressLine2;
        this.county = county;
        this.addressType = addressType;
        this.city = city;
        this.postalCode = postalCode;
        this.stateCode = stateCode;
    }

    public Applicant(Integer id, String ssn, String dateOfBirth, String firstName, String lastName, String middleName, String applicantRole, Integer pAddress, Integer pApplication) {
        this.id = id;
        this.ssn = ssn;
        this.dateOfBirth = dateOfBirth;
        this.firstName = firstName;
        this.lastName = lastName;
        this.middleName = middleName;
        this.applicantRole = applicantRole;
        this.pAddress = pAddress;
        this.pApplication = pApplication;
    }


    public Application(Integer id, Double loanAmount, String loanType, Integer pAddress) {
        this.id = id;
        this.loanAmount = loanAmount;
        this.loanType = loanType;
        this.pAddress = pAddress;
    }

    public CBRSummary(Integer id, String creditScore, String creditBureau, String requestedDate, Integer pApplicant) {
        this.id = id;
        this.creditScore = creditScore;
        this.creditBureau = creditBureau;
        this.requestedDate = requestedDate;
        this.pApplicant = pApplicant;
    }

2.2. Create DAO for domain classes

We need to create DAO for operating on these domain objects. DAO provides CRUD operations on the model. The following classes use the JPA APIs to perform CRUD.

AddressDAO, ApplicantDAO, ApplicationDAO, and CBRSummaryDAO.

We will be defining one of these DAO in this tutorial and you can use same approach to implement other DAOs.

All these classes are defined in the package 'com.mycompany.loanprocessing.dao'. The class AddressDao shown below is self-explanatory.

package com.mycompany.loanprocessing.dao;

import com.mycompany.loanprocessing.Address;
import java.util.Iterator;
import java.util.List;
import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Query;

/**
 *
 * @author aruld
 */
public class AddressDao {

    private EntityManager em;

    public AddressDao(EntityManagerFactory emf) {
        em = emf.createEntityManager();
    }

    public void createAddress(Address address) {
        em.getTransaction().begin();
        em.persist(address);
        em.getTransaction().commit();
    }

    public Address findById(Integer id) {
        return em.find(Address.class, id);
    }

    public List findByAddressLine1(String addressLine1) {
        Query query = em.createNamedQuery("Address.findByAddressLine1");
        query.setParameter(addressLine1, em);
        List listOfAddresses = query.getResultList();
        return listOfAddresses;
    }

    public void updateAddress(Address address) {
        em.getTransaction().begin();
        em.merge(address);
        em.getTransaction().commit();
    }

    public void removeAddress(Address address) {
        em.getTransaction().begin();
        em.remove(address);
        em.getTransaction().commit();
    }

    public List getAll() {
        Query query = em.createQuery("select a from Address a");
        List list = query.getResultList();
        return list;
    }

    public void removeAll() {
        em.getTransaction().begin();
        Query query = em.createQuery("select a from Address a");
        List list = query.getResultList();
        Iterator it = list.iterator();
        while (it.hasNext()) {
            Address address = (Address) it.next();
            em.remove(address);
        }
        em.getTransaction().commit();
    }

    public void close() {
        em.close();
    }
}

2.3. Unit testing

Let us unit test our domain classes using JUnit. The below test case creates some sample data and performs CRUD operations on these data using the DAO classes. We create three loan applications and each with a residential and property address. Simple enum types are defined for our domain (AddressType, LoanType, ApplicantRole, DecisionType, CreditBureauType).

package com.mycompany.loanprocessing;

import com.mycompany.loanprocessing.dao.AddressDao;
import com.mycompany.loanprocessing.dao.ApplicantDao;
import com.mycompany.loanprocessing.dao.ApplicationDao;
import com.mycompany.loanprocessing.util.AddressType;
import com.mycompany.loanprocessing.util.ApplicantRole;
import com.mycompany.loanprocessing.util.LoanType;
import java.util.List;
import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;
import org.junit.After;
import org.junit.AfterClass;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Test;
import static org.junit.Assert.*;

/**
 *
 * @author aruld
 */
public class LoanProcessingDAOTest {
    private static ApplicationDao am;
    private static AddressDao adm;
    private static ApplicantDao apm;
    private static EntityManager em;
    private static EntityManagerFactory emf;

    private static final Address address1 = new Address(1, "4209 Van Buren Dr", "Apt # 158", "POLK", AddressType.RESIDENTIAL.toString(), "WEST DES MOINES", "50266", "IA");
    private static final Address address2 = new Address(2, "1265 11th ST", "Apt # 208", "POLK", AddressType.RESIDENTIAL.toString(), "WEST DES MOINES", "50265", "IA");
    private static final Address address3 = new Address(3, "1660 Country Manor Blvd", "Apt # 226B", "YELLOWSTONE", AddressType.RESIDENTIAL.toString(), "BILLINGS", "59102", "MT");

    private static final Address paddress1 = new Address(4, "1120 Jordan Creek PKWY", "Unit # 123", "POLK", AddressType.PROPERTY.toString(), "WEST DES MOINES", "50266", "IA");
    private static final Address paddress2 = new Address(5, "1120 Jordan Creek PKWY", "Unit # 213", "POLK", AddressType.PROPERTY.toString(), "WEST DES MOINES", "50266", "IA");
    private static final Address paddress3 = new Address(6, "1120 Jordan Creek PKWY", "Unit # 312", "POLK", AddressType.PROPERTY.toString(), "WEST DES MOINES", "50266", "IA");

    private static final Application application1 = new Application(1, 120000.00, LoanType.FIXED.toString(), 1);
    private static final Application application2 = new Application(2, 110000.00, LoanType.ADJUSTABLE.toString(), 2);
    private static final Application application3 = new Application(3, 90000.00, LoanType.FIXED.toString(), 3);

    private static final Applicant applicant1 = new Applicant(1, "000-00-0001", "07/11/1960", "KEN", "CUSTOMER", "", ApplicantRole.PRIMARY.toString(), 1, 1);
    private static final Applicant applicant2Primary = new Applicant(2, "000-00-0002", "08/11/1960", "ALAN", "APPLICANT", "", ApplicantRole.PRIMARY.toString(), 2, 2);
    private static final Applicant applicant2Secondary = new Applicant(3, "000-00-0003", "09/11/1965", "EMILY", "APPLICANT", "", ApplicantRole.SECONDARY.toString(), 2, 2);
    private static final Applicant applicant3 = new Applicant(4, "000-00-0004", "10/11/1970", "WILL", "SMITH", "", ApplicantRole.PRIMARY.toString(), 3, 3);

    public LoanProcessingDAOTest() {
    }

    @BeforeClass
    public static void setUpClass() throws Exception {
    }

    @AfterClass
    public static void tearDownClass() throws Exception {
    }

    @Before
    public void setUp() {
        emf = Persistence.createEntityManagerFactory("LoanDBPU");
        em = emf.createEntityManager();
        am = new ApplicationDao(emf);
        apm = new ApplicantDao(emf);
        adm = new AddressDao(emf);
        adm.removeAll();
        apm.removeAll();
        am.removeAll();
    }

    @After
    public void tearDown() {
        //this will remove all the entries in case if there are uncomplete/failed tests.
        //adm.removeAll();
        //apm.removeAll();
        //am.removeAll();
        am.close();
        adm.close();
        apm.close();
        em.close();
        emf.close();
    }

    @Test
    public void testCRUD() {
        adm.createAddress(address1);
        Address address = adm.findById(1);
        assertEquals(address.getAddressLine1(), "4209 Van Buren Dr");

        address.setAddressLine1("4210 Van Buren Dr");
        adm.updateAddress(address);

        address = adm.findById(1);
        assertEquals(address.getAddressLine1(), "4210 Van Buren Dr");

        adm.createAddress(address2);
        adm.createAddress(address3);

        adm.createAddress(paddress1);
        Address paddress = adm.findById(4);
        assertEquals(paddress.getAddressLine1(), "1120 Jordan Creek PKWY");

        paddress.setAddressLine2("AshCreek Apartments Unit # 123");
        adm.updateAddress(paddress);

        paddress = adm.findById(4);
        assertEquals(paddress.getAddressLine2(), "AshCreek Apartments Unit # 123");

        paddress.setAddressLine2("Unit # 123");
        adm.updateAddress(paddress);

        adm.createAddress(paddress2);
        adm.createAddress(paddress3);

        am.createApplication(application1);
        Application application = am.findById(1);
        assertEquals(application.getLoanAmount(), Double.valueOf(120000.00));

        application.setLoanAmount(117000.00);
        am.updateApplication(application);

        application = am.findById(1);
        assertEquals(application.getLoanAmount(), Double.valueOf(117000.00));

        am.createApplication(application2);
        am.createApplication(application3);

        apm.createApplicant(applicant1);
        Applicant applicant = apm.findById(1);
        assertEquals(applicant.getFirstName(), "KEN");

        applicant.setFirstName("KENNETH");
        apm.updateApplicant(applicant);

        applicant = apm.findById(1);
        assertEquals(applicant.getFirstName(), "KENNETH");

        apm.createApplicant(applicant2Primary);
        apm.createApplicant(applicant2Secondary);
        apm.createApplicant(applicant3);

        List applicantList = apm.getAll();
        assertEquals(applicantList.size(), 4);

        //uncomment to clean up the database
        /*apm.removeAll();
        applicantList = apm.getAll();
        assertEquals(applicantList.size(), 0);*/

        List applicationList = am.getAll();
        assertEquals(applicationList.size(), 3);

        //uncomment to clean up the database
        /*am.removeAll();
        applicationList = am.getAll();
        assertEquals(applicationList.size(), 0);*/

        List addressList = adm.getAll();
        assertEquals(addressList.size(), 6);

        //uncomment to clean up the database
        /*adm.removeAll();
        addressList = adm.getAll();
        assertEquals(addressList.size(), 0);       */


    }

}

You may want to include test dependencies for MySQL JDBC driver and JUnit in your Maven POM. Click F11 to build the project and run the tests.

Build Main Project

You can also run the test directly by right clicking on the Test and select 'Test File' (Ctrl + F6) and make sure the simple CRUD test passes.

Executing JUnit tests

Chapter 3. CXF Services

3.1. Interface definition for credit and decision services

The interfaces for credit and decision services are defined in the package 'com.mycompany.loanprocessing.services'.

package com.mycompany.loanprocessing.services;

import com.mycompany.loanprocessing.Address;

import com.mycompany.loanprocessing.Applicant;

import com.mycompany.loanprocessing.CbrSummary;

import javax.jws.WebMethod;

import javax.jws.WebParam;

import javax.jws.WebResult;

/**

 *

 * @author aruld

 */

public interface CreditService {

    @WebMethod(operationName = "getCredit")

    @WebResult(name="creditBureauResponse")

    public CbrSummary getCredit(@WebParam(name = "applicant")

    Applicant applicant, @WebParam(name = "address")

    Address address);

}

The mock implementation for the credit service is provided below. In real scenario, credit rating systems will expose these web services and consumers should access these services remotely.

package com.mycompany.loanprocessing.services;

import com.mycompany.loanprocessing.Address;

import com.mycompany.loanprocessing.Applicant;

import com.mycompany.loanprocessing.CbrSummary;

import com.mycompany.loanprocessing.util.CreditBureauType;

import java.text.DateFormat;

import java.text.SimpleDateFormat;

import javax.jws.WebService;

/**

 *

 * @author aruld

 */

@WebService(endpointInterface = "com.mycompany.loanprocessing.services.CreditService", serviceName = "CreditService")

public class CreditServiceImpl implements CreditService {

    public CbrSummary getCredit(Applicant applicant, Address address) {

        //TODO write your implementation code here:

        //Invoke External CreditBureau Web Service to get the actual credit report

        //Mocking up response.

        DateFormat dateFormat = new SimpleDateFormat("MM/dd/yyyy HH:mm:ss");

        java.util.Date date = new java.util.Date();

        String datetime = dateFormat.format(date);

        CbrSummary cbr = new CbrSummary();

        cbr.setCreditBureau(CreditBureauType.EQUIFAX.toString());

        cbr.setRequestedDate(datetime);

        cbr.setCreditScore("750");

        cbr.setPApplicant(applicant.getId());

        return cbr;

    }

}

Let us also define the decision service interface and implementation.

package com.mycompany.loanprocessing.services;

import com.mycompany.loanprocessing.Applicant;

import com.mycompany.loanprocessing.CbrSummary;

import com.mycompany.loanprocessing.util.DecisionType;

import javax.jws.WebMethod;

import javax.jws.WebParam;

import javax.jws.WebResult;

import javax.jws.WebService;

/**

 *

 * @author aruld

 */

@WebService

public interface DecisionService {

    @WebMethod(operationName = "getRiskDecision")

    @WebResult(name="decisionResponse")

    public DecisionType getRiskDecision(@WebParam(name = "applicant")

    Applicant applicant, @WebParam(name = "cbrSummary")

    CbrSummary cbrSummary);

}

The mock implementation for the decision service is provided below. This service always returns a decision type of 'APPROVE'. This needs to be plugged in with the real decision service.

package com.mycompany.loanprocessing.services;

import com.mycompany.loanprocessing.Applicant;

import com.mycompany.loanprocessing.CbrSummary;

import com.mycompany.loanprocessing.util.DecisionType;

import javax.jws.WebService;

/**

 *

 * @author aruld

 */

@WebService(endpointInterface = "com.mycompany.loanprocessing.services.DecisionService", serviceName = "DecisionService")

public class DecisionServiceImpl implements DecisionService {

    public DecisionType getRiskDecision(Applicant applicant, CbrSummary cbrSummary) {

        //TODO write your implementation code here:

        //Invoke External Decision Web Service to get the actual credit report

        //Mocking up response.

        return DecisionType.APPROVE;

    }

}

3.2. Securing the CXF services using WS-Security

In order to secure the above web services, we will use WSS4J APIs to implement security for these services. This requires callback handlers to be defined for server and the client. These handlers are invoked when ever a request is received from the client and processed at the server. For simplicity, we have hard-coded the credentials in the server handler. The credentials sent by the client should match these server credentials. Once the request is authenticated, the client can access the methods on the web service.

package com.mycompany.loanprocessing.services.security;

import java.io.IOException;

import javax.security.auth.callback.Callback;

import javax.security.auth.callback.CallbackHandler;

import javax.security.auth.callback.UnsupportedCallbackException;

import org.apache.ws.security.WSPasswordCallback;

import org.apache.ws.security.WSSecurityException;

/**

 *

 * @author aruld

 */

public class ServerPasswordCallback  implements CallbackHandler {

    //this can be moved to a resource bundle

    private static final String username = "cxfuser";

    private static final String password = "secret";

    public void handle(Callback[] callbacks) throws IOException, UnsupportedCallbackException {

        WSPasswordCallback pc = (WSPasswordCallback) callbacks[0];

        String strClientPwd = pc.getPassword();

        int usage = pc.getUsage();

        if(pc.getIdentifier().equals(username)) {

            if(usage == WSPasswordCallback.USERNAME_TOKEN) { //PasswordDigest

                pc.setPassword(password);

            } else if(usage == WSPasswordCallback.USERNAME_TOKEN_UNKNOWN) { //PasswordText

                pc.setPassword(password);

                if(!strClientPwd.equalsIgnoreCase(password)){ //DIY compare

                    throw new WSSecurityException(WSSecurityException.FAILED_AUTHENTICATION);

                }

            }

        }

    }

}

package com.mycompany.loanprocessing.services.security;

import java.io.IOException;

import javax.security.auth.callback.Callback;

import javax.security.auth.callback.CallbackHandler;

import javax.security.auth.callback.UnsupportedCallbackException;

import org.apache.ws.security.WSPasswordCallback;

/**

 *

 * @author aruld

 */

public class ClientPasswordCallback implements CallbackHandler {

    //this can be moved to a resource bundle

    private static final String password = "secret";

    public void handle(Callback[] callbacks) throws IOException, UnsupportedCallbackException {

        WSPasswordCallback pc = (WSPasswordCallback) callbacks[0];

        // set the password for our message.

        pc.setPassword(password);

    }

}

Next, we need to deploy these services in a web container. CXF comes with an embedded Jetty server which we can use it to run our services and see CXF in action. The Server code looks as shown below. We create instances of credit and decision services and register them with the JaxWsServerFactoryBean. Your services is ready to be accessed with security.

package com.mycompany.loanprocessing;

import com.mycompany.loanprocessing.services.CreditService;

import com.mycompany.loanprocessing.services.CreditServiceImpl;

import com.mycompany.loanprocessing.services.DecisionService;

import com.mycompany.loanprocessing.services.DecisionServiceImpl;

import com.mycompany.loanprocessing.services.security.ServerPasswordCallback;

import java.util.HashMap;

import java.util.Map;

import org.apache.cxf.binding.soap.saaj.SAAJInInterceptor;

import org.apache.cxf.endpoint.Endpoint;

import org.apache.cxf.interceptor.LoggingInInterceptor;

import org.apache.cxf.interceptor.LoggingOutInterceptor;

import org.apache.cxf.jaxws.JaxWsServerFactoryBean;

import org.apache.cxf.ws.security.wss4j.WSS4JInInterceptor;

import org.apache.ws.security.WSConstants;

import org.apache.ws.security.handler.WSHandlerConstants;

/**

 *

 * @author aruld

 */

public class CXFServer {

    public static void main(String args[]) throws Exception {

        CreditServiceImpl creditServiceImpl = new CreditServiceImpl();

        DecisionServiceImpl decisionServiceImpl = new DecisionServiceImpl();

        createCreditService(creditServiceImpl);

        createDecisionService(decisionServiceImpl);

    }

    private static void createCreditService(Object serviceObj) {

        JaxWsServerFactoryBean svrFactory = new JaxWsServerFactoryBean();

        svrFactory.setServiceClass(CreditService.class);

        svrFactory.setAddress("http://localhost:9000/services/CreditService");

        svrFactory.setServiceBean(serviceObj);

        org.apache.cxf.endpoint.Server server = svrFactory.create();

        Endpoint cxfEndpoint = server.getEndpoint();

        cxfEndpoint.getInInterceptors().add(new LoggingInInterceptor());

        cxfEndpoint.getOutInterceptors().add(new LoggingOutInterceptor());

        Map<String, Object> inProps = new HashMap<String, Object>();

        inProps.put(WSHandlerConstants.ACTION, WSHandlerConstants.USERNAME_TOKEN);

        // Password type : plain text

        inProps.put(WSHandlerConstants.PASSWORD_TYPE, WSConstants.PW_TEXT);

        // for hashed password use:

        //properties.setProperty(WSHandlerConstants.PASSWORD_TYPE, WSConstants.PW_DIGEST);

        // Callback used to retrive password for given user.

        inProps.put(WSHandlerConstants.PW_CALLBACK_CLASS, ServerPasswordCallback.class.getName());

        WSS4JInInterceptor wssIn = new WSS4JInInterceptor(inProps);

        cxfEndpoint.getInInterceptors().add(wssIn);

    }

    private static void createDecisionService(Object serviceObj) {

        JaxWsServerFactoryBean svrFactory = new JaxWsServerFactoryBean();

        svrFactory.setServiceClass(DecisionService.class);

        svrFactory.setAddress("http://localhost:9000/services/DecisionService");

        svrFactory.setServiceBean(serviceObj);

        org.apache.cxf.endpoint.Server server = svrFactory.create();

        Endpoint cxfEndpoint = server.getEndpoint();

        cxfEndpoint.getInInterceptors().add(new LoggingInInterceptor());

        cxfEndpoint.getOutInterceptors().add(new LoggingOutInterceptor());

        Map<String, Object> inProps = new HashMap<String, Object>();

        inProps.put(WSHandlerConstants.ACTION, WSHandlerConstants.USERNAME_TOKEN);

        // Password type : plain text

        inProps.put(WSHandlerConstants.PASSWORD_TYPE, WSConstants.PW_TEXT);

        // for hashed password use:

        //properties.setProperty(WSHandlerConstants.PASSWORD_TYPE, WSConstants.PW_DIGEST);

        // Callback used to retrive password for given user.

        inProps.put(WSHandlerConstants.PW_CALLBACK_CLASS, ServerPasswordCallback.class.getName());

        WSS4JInInterceptor wssIn = new WSS4JInInterceptor(inProps);

        cxfEndpoint.getInInterceptors().add(wssIn);

    }

}

You can access the WSDL for both the services in the following URLs.

http://localhost:9000/services/CreditService?wsdl http://localhost:9000/services/DecisionService?wsdl

Running the Server

The below is the Client program which can access the credit and decision services. CXF provides Java APIs as well as spring based XML configuration for deploying services as well as defining clients as Spring beans.

package com.mycompany.loanprocessing;

import com.mycompany.loanprocessing.dao.AddressDao;

import com.mycompany.loanprocessing.dao.ApplicantDao;

import com.mycompany.loanprocessing.dao.CbrSummaryDao;

import com.mycompany.loanprocessing.services.CreditService;

import com.mycompany.loanprocessing.services.DecisionService;

import com.mycompany.loanprocessing.services.security.ClientPasswordCallback;

import com.mycompany.loanprocessing.util.DecisionType;

import java.util.HashMap;

import java.util.Map;

import javax.persistence.EntityManagerFactory;

import javax.persistence.Persistence;

import org.apache.cxf.binding.soap.saaj.SAAJOutInterceptor;

import org.apache.cxf.endpoint.Endpoint;

import org.apache.cxf.interceptor.LoggingInInterceptor;

import org.apache.cxf.interceptor.LoggingOutInterceptor;

import org.apache.cxf.jaxws.JaxWsProxyFactoryBean;

import org.apache.cxf.ws.security.wss4j.WSS4JOutInterceptor;

import org.apache.ws.security.WSConstants;

import org.apache.ws.security.handler.WSHandlerConstants;

/**

 *

 * @author aruld

 */

public class CXFClient {

   public static void main(String args[]) throws Exception {

        CreditService creditClient = createCreditServiceClient();

        DecisionService decisionClient = createDecisionServiceClient();

        EntityManagerFactory emf = Persistence.createEntityManagerFactory("LoanDBPU");

        ApplicantDao apm = new ApplicantDao(emf);

        Applicant applicant = apm.findById(1);

        AddressDao adm = new AddressDao(emf);

        Address address = adm.findById(4);

        CbrSummaryDao cbrm = new CbrSummaryDao(emf);

        //clear the existing entries for testing purpose only

        cbrm.removeAll();

     CbrSummary cbr = creditClient.getCredit(applicant, address);

        cbr.setId(1);

        cbrm.createCreditBureauResponse(cbr);

     System.out.println("Credit Score for : " + applicant.getFirstName() + " " + cbr.getCreditScore());

        DecisionType decision = decisionClient.getRiskDecision(applicant, cbr);

        System.out.println("Decision for : " + applicant.getFirstName() + " : " + decision);

        //close the resources

        apm.close();

        adm.close();

        emf.close();

     System.exit(0);

    }

    private static CreditService createCreditServiceClient() {

     JaxWsProxyFactoryBean factory = new JaxWsProxyFactoryBean();

     factory.getInInterceptors().add(new LoggingInInterceptor());

     factory.getOutInterceptors().add(new LoggingOutInterceptor());

     factory.setServiceClass(CreditService.class);

     factory.setAddress("http://localhost:9000/services/CreditService");

        CreditService service = (CreditService)factory.create();

        org.apache.cxf.endpoint.Client client = org.apache.cxf.frontend.ClientProxy.getClient(service);

        org.apache.cxf.endpoint.Endpoint cxfEndpoint = client.getEndpoint();

        Map<String,Object> outProps = new HashMap<String,Object>();

        outProps.put(WSHandlerConstants.ACTION, WSHandlerConstants.USERNAME_TOKEN);

        // Specify our username

        outProps.put(WSHandlerConstants.USER, "cxfuser");

        // Password type : plain text

        outProps.put(WSHandlerConstants.PASSWORD_TYPE, WSConstants.PW_TEXT);

        // for hashed password use:

        //properties.setProperty(WSHandlerConstants.PASSWORD_TYPE, WSConstants.PW_DIGEST);

        // Callback used to retrive password for given user.

        outProps.put(WSHandlerConstants.PW_CALLBACK_CLASS, ClientPasswordCallback.class.getName());

        WSS4JOutInterceptor wssOut = new WSS4JOutInterceptor(outProps);

        cxfEndpoint.getOutInterceptors().add(wssOut);

        return service;

    }

    private static DecisionService createDecisionServiceClient() {

     JaxWsProxyFactoryBean factory = new JaxWsProxyFactoryBean();

     factory.getInInterceptors().add(new LoggingInInterceptor());

     factory.getOutInterceptors().add(new LoggingOutInterceptor());

     factory.setServiceClass(DecisionService.class);

     factory.setAddress("http://localhost:9000/services/DecisionService");

        DecisionService service = (DecisionService)factory.create();

        org.apache.cxf.endpoint.Client client = org.apache.cxf.frontend.ClientProxy.getClient(service);

        org.apache.cxf.endpoint.Endpoint cxfEndpoint = client.getEndpoint();

        Map<String,Object> outProps = new HashMap<String,Object>();

        outProps.put(WSHandlerConstants.ACTION, WSHandlerConstants.USERNAME_TOKEN);

        // Specify our username

        outProps.put(WSHandlerConstants.USER, "cxfuser");

        // Password type : plain text

        outProps.put(WSHandlerConstants.PASSWORD_TYPE, WSConstants.PW_TEXT);

        // for hashed password use:

        //properties.setProperty(WSHandlerConstants.PASSWORD_TYPE, WSConstants.PW_DIGEST);

        // Callback used to retrive password for given user.

        outProps.put(WSHandlerConstants.PW_CALLBACK_CLASS, ClientPasswordCallback.class.getName());

        WSS4JOutInterceptor wssOut = new WSS4JOutInterceptor(outProps);

        cxfEndpoint.getOutInterceptors().add(wssOut);

        return service;

    }    

}

Running the Client

The SOAP request and response is shown in the CXF client logs.

'Credit service request/response':

<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
    <soap:Header>
        <wsse:Security xmlns:wsse="http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-secext-1.0.xsd" soap:mustUnderstand="1">
            <wsse:UsernameToken xmlns:wsse="http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-secext-1.0.xsd" xmlns:wsu="http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-utility-1.0.xsd" wsu:Id="UsernameToken-1">
                <wsse:Username>cxfuser</wsse:Username>
                <wsse:Password Type="http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-username-token-profile-1.0#PasswordText">secret</wsse:Password>
            </wsse:UsernameToken>
        </wsse:Security>
    </soap:Header>
    <soap:Body>
        <ns2:getCredit xmlns:ns2="http://services.loanprocessing.mycompany.com/">
            <applicant>
                <applicantRole>PRIMARY</applicantRole>
                <dateOfBirth>07/11/1960</dateOfBirth>
                <firstName>KENNETH</firstName>
                <id>1</id>
                <lastName>CUSTOMER</lastName>
                <middleName></middleName>
                <PAddress>1</PAddress>
                <PApplication>1</PApplication>
                <ssn>000-00-0001</ssn>
            </applicant>
            <address>
                <addressLine1>1120 Jordan Creek PKWY</addressLine1>
                <addressLine2>Unit # 123</addressLine2>
                <addressType>PROPERTY</addressType>
                <city>WEST DES MOINES</city>
                <county>POLK</county>
                <id>4</id>
                <postalCode>50266</postalCode>
                <stateCode>IA</stateCode>
            </address>
        </ns2:getCredit>
    </soap:Body>
</soap:Envelope>

<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
    <soap:Body>
        <ns2:getCreditResponse xmlns:ns2="http://services.loanprocessing.mycompany.com/">
            <creditBureauResponse>
                <creditBureau>EQUIFAX</creditBureau>
                <creditScore>750</creditScore>
                <PApplicant>1</PApplicant>
                <requestedDate>02/28/2010 17:11:42</requestedDate>
            </creditBureauResponse>
        </ns2:getCreditResponse>
    </soap:Body>
</soap:Envelope>

'Decision service request/response':

<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
    <soap:Header>
        <wsse:Security xmlns:wsse="http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-secext-1.0.xsd" soap:mustUnderstand="1">
            <wsse:UsernameToken xmlns:wsse="http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-secext-1.0.xsd" xmlns:wsu="http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-wssecurity-utility-1.0.xsd" wsu:Id="UsernameToken-2">
                <wsse:Username>cxfuser</wsse:Username>
                <wsse:Password Type="http://docs.oasis-open.org/wss/2004/01/oasis-200401-wss-username-token-profile-1.0#PasswordText">secret</wsse:Password>
            </wsse:UsernameToken>
        </wsse:Security>
    </soap:Header>
    <soap:Body>
        <ns2:getRiskDecision xmlns:ns2="http://services.loanprocessing.mycompany.com/">
            <applicant>
                <applicantRole>PRIMARY</applicantRole>
                <dateOfBirth>07/11/1960</dateOfBirth>
                <firstName>KENNETH</firstName>
                <id>1</id>
                <lastName>CUSTOMER</lastName>
                <middleName></middleName>
                <PAddress>1</PAddress>
                <PApplication>1</PApplication>
                <ssn>000-00-0001</ssn>
            </applicant>
            <cbrSummary>
                <creditBureau>EQUIFAX</creditBureau>
                <creditScore>750</creditScore>
                <id>1</id>
                <PApplicant>1</PApplicant>
                <requestedDate>02/28/2010 17:11:42</requestedDate>
            </cbrSummary>
        </ns2:getRiskDecision>
    </soap:Body>
</soap:Envelope>

<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
    <soap:Body>
        <ns2:getRiskDecisionResponse xmlns:ns2="http://services.loanprocessing.mycompany.com/">
            <decisionResponse>APPROVE</decisionResponse>
        </ns2:getRiskDecisionResponse>
    </soap:Body>
</soap:Envelope>

The project structure looks as shown below.

Project Structure

Once the client is run, then you should be seeing the CBRSummary table getting populated with the response from credit service.

Querying the CBRSummary table after running the Client

3.3. Testing Web Services using NetBeans IDE

NetBeans IDE provides built-in support for testing web services. Click the services tab and expand the Web Services node. Add a service group 'LoanProcessing'.

Adding a Web Service Group

Now, add the credit service WSDL and decision service WSDL to the web service group.

Now, you are ready to test the web services. Right click the operation getCredit to test the credit service. This fails because it does not provide a way to pass the credentials to the web service. If you remove the security, then it should work just fine. As we are mocking up the response, you should always receive the same response.

Right click the operation getRiskDecision to test the decision service. This also fails for the same above mentioned reason. It will be useful to enhance the NetBeans IDE webservices tools to support testing secure web services.

Testing Decision Service

3.4. Testing Web Services using soapUI NetBeans plugin

soapUI is a web service testing tool which provides features such as functional/load/mock testing of web services. The soapUI NetBeans plugin is feature rich and can accomplish more testing including secured web services.

We need to install the soapUI plugin from the NetBeans plugin manager. Please refer to the soapUI documentation here for details.

Once the plugin installation is successful, create a soapUI web service testing project 'WebServiceTestProject'.

Create soapUI project

Let us provide the WSDL location for our Credit web service. We need to make sure our Server program is running for this step to work.

Expand the getCredit operation in the project tree. Open 'Request 1' and copy the SOAP request for our credit service shown in previous section and submit the request to specified endpoint URL. You should see the SOAP response in the right side of the same window. This is basic testing of our secured web service. More testing can be done with soapUI. For instance, you can simulate the requests and do a load testing and measure the response times. This tool is very powerful and rock solid.

Test getCredit operation

We can create test cases and run the tests as part of the test suite. Right click 'Request 1' and select 'Add to TestCase' option.

Add request to TestCase

Add TestSuite name

Add TestCase name

TestCase Options

Project Structure

Running the TestCase

Decision service can be tested in the same manner and this is left as an exercise to the readers. You can find the SOAP request for the decision service in the previous section. There are many different ways to test your web services from soapUI plugin. Let us try testing decision service by configuring security headers in soapUI for the getRiskDecision request. The first step is to add the WSDL to our existing soapUI project. Right click the soapUI project node and select 'Add WSDL from URL' option.

Specify the Decision service WSDL URL

Click yes to create default requests for all the operations in the decision web service. We do not care for changing the input in the request as we hard code the response in the web service. So, we leave the input request generated by soapUI with empty optional elements.

Open the 'Request 1' from the 'DecisionServiceServiceSoapBinding' tree. Select the 'Aut' tab below the request and provide the security credentials.

Add WSS credentials

Right click the request and select 'Add WSS Username Token' option. Select password type as 'PasswordText'. This will generate the WSS header in the the SOAP request.

Add WSS Username Token to the SOAP request

SOAP request with WSS headers

Click 'Submit request to specified endpoint URL'. You may need to enter valid integer for the request parameters. You will find the response on the right side of the window.

SOAP response from the Decision Service

These are just two ways of testing our web services from soapUI plugin. You can generate the client-side stubs and then invoke the web service programatically. Our Client discussed earlier uses CXF APIs to invoke the service. CXF provides server and client side APIs to develop and test web services. It also comes with embedded Jetty server to see the CXF services in action. In real application scenario, we could deploy these services to any servlet container.

Logging can be configured both on the client and server side and it can be configured programmatically or through XML files. In our application, we have programatically configured the logging as shown below.

In CXFServer.java, the following code in createCreditService and createDecisionService enables logging for all the incoming SOAP requests and SOAP responses on the server side and the same interceptors are added to the CXFClient.java for logging on the client side.

'Logging configuration in CXFServer.java':

        cxfEndpoint.getInInterceptors().add(new LoggingInInterceptor());
        cxfEndpoint.getOutInterceptors().add(new LoggingOutInterceptor());

4. References

• Download NetBeans Project Sources for the Loan Processing application here.
• Apache CXF User Guide