Swing and web services have been around for years, however it has only been in recent times that things have gotten much easier in implementing web services and building complex Swing applications. This is mainly due to improvements in the Java language and better IDEs.
This tutorial aims to be a comprehensive guide to getting an end-to-end configuration of a Swing application communicating with a web service deployed on the server.
This tutorial also touches on Maven and the Netbeans IDE, two technologies that go hand in hand. You don’t specifically need either of these technologies to get up and running, but for the purposes of this tutorial it is highly recommended.
Part 1. Client
We are going to start off with a basic application. In our example we are going to be building an airline application that talks to a web service. Its very simple, just a table which lists all the airlines, and a button which creates a new row in the table.
Create Project
Lets create a Maven project and call it client. It is going to be our desktop client, so we want it to be packaged as a jar file.
Write Some Swing Code
We want a simple entry point to our application, so we will add a main method to our MainFrame class which serves as the main Window for the application.
public class MainFrame extends JFrame {
public MainFrame() {
JPanel panel1 = new JPanel();
AirlinePanel userPanel = new AirlinePanel();
panel1.setLayout(new BorderLayout());
panel1.add(userPanel);
this.getContentPane().add(userPanel);
this.setTitle("Airlines");
this.setDefaultCloseOperation(DISPOSE_ON_CLOSE);
this.setLocationRelativeTo(null);
pack();
setSize(900, 600);
setVisible(true);
}
public static void main(String[] args) {
new MainFrame();
}
}
Inside out frame code you may notice an AirlinePanel class, which is basically a JPanel with a JTable and buttons. Let’s add our table inside a scrollpane, and add a button to the top. The aim of the table is to list all the airlines in the system, and the button will eventually create new rows in the table after persisting across the network.
public class AirlinePanel extends JPanel {
private JScrollPane scrollPane;
private JTable userTable;
public AirlinePanel() {
initComponents();
}
private void initComponents() {
this.setLayout(new BorderLayout());
scrollPane = new JScrollPane();
userTable = new JTable();
AirlineTableModel model = new AirlineTableModel();
userTable.setModel(model);
scrollPane.setViewportView(userTable);
JPanel buttonPanel = new JPanel();
JButton createUserButton = new JButton("Create Airline");
buttonPanel.add(createUserButton);
this.add(scrollPane);
this.add(buttonPanel, BorderLayout.NORTH);
}
}
Swing uses MVC for its complex components, so for our table object, we need to have a model object that contains the business data. Lets create AirlineTableModel, an AbstractTableModel, which acts as a model for AirlineVO objects.
public class AirlineTableModel extends AbstractTableModel {
private List airlines = new ArrayList();
@Override
public String getColumnName(int i) {
switch (i) {
case 0:
return "airline name";
case 1:
return "number of fleet";
case 2:
return "home city";
case 3:
return "country";
}
return "";
}
public int getRowCount() {
return this.airlines.size();
}
public int getColumnCount() {
return 4;
}
public Object getValueAt(int rowIndex, int columnIndex) {
AirlineVO a = this.airlines.get(rowIndex);
switch (columnIndex) {
case 0:
return a.getName();
case 1:
return a.getNumberOfFleet();
case 2:
return a.getHomeCity();
case 3:
return a.getCountry();
}
return null;
}
public void setAirlines(List airlines) {
this.airlines = airlines;
}
}
So now we should have three classes :
- MainFrame
- AirlinePanel
- AirlineTableModel
However AirlineVO is missing.
Create an AirlineVO class somewhere in the project. We will be deleting the AirlineVO class a bit later, instead using the web service generated object. But for now you can add some dummy Value Objects into the code, and see that the client application works with some dummy data.
Now let’s move on to the web service project.
Part 2. Webservices
Create Web Service Project
Create a web application project. In Netbeans you can do this via choosing a Web Application project.
The Pom project you have should be named like this. We want the groupId to be the same for the client and the server. It needs to be packaged as a WAR file, and dependencies should be present which includes javaee-web-api and webservices-rt. Both these scopes should be set to PROVIDED. This basically means the web server has its own versions of these two libraries which it will use instead.
Create the Web Service Class
Create a java class called AirlineWS. This will be our entry point for our airline application. All methods that we need will exist in this class.
On Netbeans go to New —> WebService
Annotate the class with the @WebService annotation, which tell the application server to treat the class as a web service.
@WebService(serviceName = "AirlineWS")
public class AirlineWS {
/**
* This is a sample web service operation
*/
@WebMethod(operationName = "hello")
public String hello(@WebParam(name = "name") String txt) {
return "Hello " + txt + " !";
}
}
Create the Value Object Class
In our client code we can see that the code uses something called an AirlineVO object. We want to define this on the server side as well. If we also have the AirlineVO defined in the web service (WSDL), then there is no need to have a separately maintained copy on the client side. The AirlineVO object can be generated via a ws-import (more on that later).
NOTE : While in this example we are using the AirlineVO object throughout the client code, this in general is bad practise. Once the VO object is received by the client, it should be converted to a client specific object: eg: Airline guiAirlineObject = new Airline(airlineVO). This reduced the dependencies on the generated code, and also allows for decorations. That is to say, it is a decorator pattern.
So we create an AirlineVO class and put it in the web server project.
public class AirlineVO {
public AirlineVO() {}
public AirlineVO(String name, Integer numberOfFleet, String homeCity, String country) {
this.name = name;
this.numberOfFleet = numberOfFleet;
this.homeCity = homeCity;
this.country = country;
}
private String name;
private Integer numberOfFleet;
private String homeCity;
private String country;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Integer getNumberOfFleet() {
return numberOfFleet;
}
public void setNumberOfFleet(Integer numberOfFleet) {
this.numberOfFleet = numberOfFleet;
}
public String getHomeCity() {
return homeCity;
}
public void setHomeCity(String homeCity) {
this.homeCity = homeCity;
}
public String getCountry() {
return country;
}
public void setCountry(String country) {
this.country = country;
}
}
Implement the WebService Methods
We can now add some business logic to the web server. Normally a web server delegates to another layer such as the EJB layer, however for demonstration purposes this web service will be our end point. In a constructor we will create some of these Value objects and put them into an array list.
We will then create a couple of methods. We need to annotate them, this way the web server know to treat them as a web service end point.
@WebService(serviceName = "AirlineWS")
public class AirlineWS {
ArrayList airlines = new ArrayList();
public AirlineWS() {
airlines.add(new AirlineVO("QANTAS",2, "Australia","Sydney"));
airlines.add(new AirlineVO("Lufthansa",1000, "Germany","Frankfurt"));
}
@WebMethod(operationName = "create")
public void create(@WebParam(name = "airline") AirlineVO airlineVO) throws Exception {
airlines.add(airlineVO);
}
@WebMethod(operationName = "getAll")
public ArrayList getAll() throws Exception {
return airlines;
}
}
We can add a constructor which creates some dummy data. Of course we should have a proper database for our application, but for illustrative purposes this should suffice. The other two methods do a basic add, and a basic create.
Clean, Build, and Deploy
Now that we have our server code we can clean and build the project. In Netbeans there is a Clean and Build option on the context menu for the project.
Follow this up with Run. This can also be found on the project context menu.
‘Running’ a server project in Netbeans and in most other IDEs, actually deploys the application to the server. Per default Netbeans has a Glassfish instance running on localhost, so an instance of Glassfish is booted up, if it hasn’t already been started, and the WAR file is deployed as an application.
If you visit the administration console for glassfish, you will see something like this.
From this screen you can select ‘View Endpoint’ and view that the WSDL is there. This is what is exposed to the outside world, and is what ws-import uses to figure out what classes are needed to talk to this interface.
Part 3. Back to the Client…
Delegate
Let’s create the skeleton of a delegate class as we want to use the delegate pattern to shield the GUI code from all the backend code. Swing is also not Thread-safe so we also need to make all calls to the backend through a thread safe singleton.
public class Delegate {
private Delegate() {
}
public static Delegate getInstance() {
return DelegateHolder.INSTANCE;
}
private static class DelegateHolder {
private static final Delegate INSTANCE = new Delegate();
}
}
WsImport
Now we need to add wsimport support. WsImport is a maven plugin that needs to be defined in the POM file, in the plugins section. The webservice endpoints that we are interested in should be defined in the <wsdlUrl> tag. In our case, it is the AirlineWS web service.
Clean and build the client project. The wsimport plugin attaches itself to the build process, and you may notice that building has gotten a little slower. After it has finished you may now notice a folder called ‘Generated Sources (wsimport)’.
It contains all the artefacts that the wsimport has created during the build process. We can get access to a port for a particular web service, and from that port object, we can call any method we want. This is how we use the generated code :
com.bluewalrus.AirlineWS_Service service = new com.bluewalrus.AirlineWS_Service(); com.bluewalrus.AirlineWS port = service.getAirlineWSPort(); port.create(airline);
Notice how the AirlineVO class is also there. This is not the same object as exists on the server side. This object was generated based on the Web Service definition (WSDL).
Lets add two methods to the delegate object, using the generated code :
public class Delegate {
private Delegate() {
}
public static Delegate getInstance() {
return DelegateHolder.INSTANCE;
}
private static class DelegateHolder {
private static final Delegate INSTANCE = new Delegate();
}
public void createAirline(AirlineVO airline) {
try {
com.bluewalrus.AirlineWS_Service service = new com.bluewalrus.AirlineWS_Service();
com.bluewalrus.AirlineWS port = service.getAirlineWSPort();
port.create(airline);
}catch(Exception e) {
JOptionPane pane = new JOptionPane(e.getMessage(), JOptionPane.ERROR_MESSAGE);
pane.setVisible(true);
}
}
public List getAirlines() {
com.bluewalrus.AirlineWS_Service service = new com.bluewalrus.AirlineWS_Service();
com.bluewalrus.AirlineWS port = service.getAirlineWSPort();
try {
return port.getAll();
} catch (Exception e) {
JOptionPane pane = new JOptionPane(e.getMessage(), JOptionPane.ERROR_MESSAGE);
pane.setVisible(true);
}
return null;
}
}
Now we can call these delegate methods from within the Swing code.
We can do two things.
- On the create button add an actionlistener. In a later tutorial we will add a proper dialog for creating a new airline object. For now, we just send the same data across to the server, as in this tutorial we are just interested in a proof of concept.
- At the end of the initComponents method we call getAll from the web service. This will getall the value object from the backend and display them in the table. We also call a getAll in the create button code, because we want to perform a refresh of the data once we have created something.
public class AirlinePanel extends JPanel {
private JScrollPane scrollPane;
private JTable userTable;
public AirlinePanel() {
initComponents();
}
private void initComponents() {
this.setLayout(new BorderLayout());
scrollPane = new JScrollPane();
userTable = new JTable();
AirlineTableModel model = new AirlineTableModel();
userTable.setModel(model);
scrollPane.setViewportView(userTable);
JPanel buttonPanel = new JPanel();
JButton createUserButton = new JButton("Create Airline");
createUserButton.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
AirlineVO vo = new AirlineVO();
vo.setCountry("Egypt");
vo.setName("Egypt Air");
vo.setHomeCity("Cairo");
vo.setNumberOfFleet(150);
Delegate.getInstance().createAirline(vo);
List airlines = Delegate.getInstance().getAirlines();
AirlineTableModel model = (AirlineTableModel)userTable.getModel();
model.setAirlines(airlines);
model.fireTableDataChanged();
}
});
buttonPanel.add(createUserButton);
List airlines = Delegate.getInstance().getAirlines();
model.setAirlines(airlines);
model.fireTableDataChanged();
this.add(scrollPane);
this.add(buttonPanel, BorderLayout.NORTH);
}
}
You should see something like this. The table is being filled from data supplied by the web service, and clicking on the Create button creates a new row in the table.
(Source Code is here)
Comments are very appreciated J
