Creating a Graphical Client for Twitter

In this tutorial, you use the NetBeans IDE to create a simple, graphical, REST-based client that displays Twitter public timeline messages and lets you view and update your Twitter status. The application uses Swing and NetBeans IDE's support for Twitter's SaaS operations.

If you do not have a Twitter account, go to twitter.com and create an account before proceeding with this tutorial.

A complete sample of this application is available for download. Click here to download the sample.

Contents

• Designing the JFrame
• Showing Your User Status
• Setting Up Twitter Authentication
• Adding the updateStatus Operation
• Displaying Usernames and Statuses in the JFrame
• Creating a TimerTask
• Adding a run Method With the getPublicTimeline Operation
• Creating a List Cell Rendering Component
• Displaying the Component in TwitterJFrame

To complete this tutorial, you need the following software and resources.

Designing the JFrame

In this step you create the GUI elements that will display the Twitter public timeline, your user icon, and where you read and update your status. The GUI elements are all wrapped in a JFrame. You do not have to lay out the GUI elements exactly as described in this section. This layout is a suggestion only. For example, you may add more functionality. However you need to create at least all the elements described in this tutorial.

To design the JFrame:

1. Choose File > New Project. The New Project wizard opens. Select the Java category, then a Java Application project. Click Next.
2. Name the project TwitterSwingClient. Select a Project Location. Unselect Create Main Class. (The JFrame will be the main class.) Click Finish.
   
3. The IDE creates the TwitterSwingClient project, which appears in the Projects window. Right-click the TwitterSwingClient project node and choose New > JFrame Form (or New > Other > Swing GUI Forms > JFrame Form). The New JFrame Form wizard opens.
4. Name the form TwitterJFrame and create a package for it called twitterclient. Click Finish.
   
5. The IDE opens TwitterJFrame in the editor, in the Design view. Here you have a palette of all the Swing components you can drag and drop into the JFrame.
   
6. Click on the Button icon under Swing Controls in the Palette. Drag and drop it into the bottom right corner of the JFrame. Note that the button displays jButton1, which is the name of this JButton object.
   
7. Right-click jButton1 and select Edit Text from the context menu. Change the display text to "Update."
8. Drag and drop a Label (jLabel1) to the bottom left corner of the JFrame. Change its display text to "Icon." Your user icon will be displayed in this label.
9. Drag and drop a Text Field (jTextField1) between the Label and the Button. Change its display text to "Status." Click on the right border of the text field and stretch it across towards the button. Blue guidelines appear showing you suggested distances from the button.
10. Right-click on jLabel1 and select Properties from the context menu. The jLabel1 Properties dialog opens. Set the labelFor property to point to jTextField1. (This increases accessibility.)
11. Find the properties Maximum Size, Minimum Size, and Preferred Size. Set each of these properties to [48,48], to match the 48px X 48px dimensions of Twitter icons.
    
12. Drag and drop a Scroll Pane into the upper part of the JFrame. Drag its borders to expand it to fill most or all of the space above the text field and button. (You may leave a margin if you want to add more functionality later, such as the menu in the sample.)
13. Drag and drop a List into the Scroll Pane. A sample list of items appears. Save TwitterJFrame. The JFrame should look like the following image:
    

You now have all the basic GUI components for the Swing client. It is time to add the first Twitter SaaS (Software as a Service) operation.

Showing Your User Status

In this section you create a new method and add the Twitter getUserTimeline operation to this method. The getUserTimeline operation gets your user icon and your current status. You then add code to the method to display your icon and status in jLabel1 and jTextField, respectively. Finally you add a line to the JFrame's constructor to initialize the method.

To show your user status:

1. Switch to the Source view of TwitterJFrame.
2. In the code, add a few empty lines above the main method.
   
3. In the empty space, type in the following code to create the method initUserInfo.

   private void initUserInfo() {
   
   
   
   
               }

4. Open the Services window in the IDE. Under Web Services, navigate to Twitter > What Are You Doing Service > [statuses] > [user_timeline.{format}] > getUserTimeline.
   
5. Drag and drop getUserTimeline into the method body of initUserInfo. The Customize GET SaaS Service dialog opens. Type "1" for the value of count, because you only want to see the last status message. Exit the value cell for count and click OK. (If you do not exit the cell before you click OK, your change will not be saved. Alternatively, you can change the value of count in the code.)
   
6. The IDE generates code for the getUserStatusById operation. The IDE also creates the org.netbeans.saas package, which contains the RESTful communication code, and the org.netbeans.saas.twitter package, which contains the authenticaton code and the Twitter WhatAreYouDoingService class. The IDE adds an import statement for this class to TwitterJFrame.

   Note: In the Sample, objects and variables in this method such as format and result are numbered format2, result2, etc, because the getUserTimeline code was added after the getPublicTimeline code.

   private void initUserInfo() {
   
   
       try {
   
           String since = null;
   
           String sinceId = null;
   
           String page = null;
   
           String count = "1";
   
           String format = "xml";
   
   
           RestResponse result = TwitterWhatAreYouDoingService.getUserTimeline(since, sinceId, page, count, format);
   
           if (result.getDataAsObject(twitter.whatareyoudoingservice.twitterresponse.Statuses.class) instanceof twitter.whatareyoudoingservice.twitterresponse.Statuses) {
   
               twitter.whatareyoudoingservice.twitterresponse.Statuses resultObj = result.getDataAsObject(twitter.whatareyoudoingservice.twitterresponse.Statuses.class);
   
           } else if (result.getDataAsObject(twitter.whatareyoudoingservice.twitterresponse.NilClasses.class) instanceof twitter.whatareyoudoingservice.twitterresponse.NilClasses) {
   
               twitter.whatareyoudoingservice.twitterresponse.NilClasses resultObj = result.getDataAsObject(twitter.whatareyoudoingservice.twitterresponse.NilClasses.class);
   
           }
   
       //TODO - Uncomment the print Statement below to print result.
   
       //System.out.println("The SaasService returned: "+result.getDataAsString());
   
       } catch (Exception ex) {
   
           ex.printStackTrace();
   
       }
   
   
               }

7. In the generated code, locate the if block.

   if (result.getDataAsObject(twitter.whatareyoudoingservice.twitterresponse.Statuses.class) instanceof twitter.whatareyoudoingservice.twitterresponse.Statuses) {
   
       twitter.whatareyoudoingservice.twitterresponse.Statuses resultObj = result.getDataAsObject(twitter.whatareyoudoingservice.twitterresponse.Statuses.class);
   
                   } 

8. At the end of the if block, insert code that gets your user status text and icon URL and uses this data to display your status in jTextField1 and jLabel1.

   if (result.getDataAsObject(twitter.whatareyoudoingservice.twitterresponse.Statuses.class) instanceof twitter.whatareyoudoingservice.twitterresponse.Statuses){
   
       twitter.whatareyoudoingservice.twitterresponse.Statuses resultObj = result.getDataAsObject(twitter.whatareyoudoingservice.twitterresponse.Statuses.class);
   
       StatusType st = resultObj.getStatus().get(0);
   
       jTextField1.setText(st.getText().trim());
   
       UserType user = st.getUser();
   
       String iconSrc = user.getProfileImageUrl();
   
       URL iconUrl = new URL(iconSrc);
   
       ImageIcon icon = new ImageIcon(iconUrl, user.getScreenName());
   
       jLabel1.setIcon(icon);
   
               }

9. Press Ctrl-Shift-I to add import statements. A dialog opens with a choice of URL classes to import. Select the default, java.net.URL.
10. At the top of the TwitterJFrame class, locate the constructor. Add the line initUserInfo(); to the constructor's body.

    public class TwitterJFrame extends javax.swing.JFrame {
    
    
        /** Creates new form TwitterJFrame */
    
        public TwitterJFrame() {
    
            initComponents();
    
            initUserInfo();
    
                    }

After you set up authentication, you can run the project. Right-click the project node and select Run from the context menu. An application opens showing your user icon and status.

Setting Up Twitter Authentication

There are two ways you can set up your application to log into Twitter:

• Automatic login. Set your username and password in the application and the application will automatically log into Twitter when you run it.
• Login screen. If you do not set your username and password in the application, a login screen appears when you run the application.

To set up automatic login, open org.netbeans.saas.twitter.twitterwhatareyoudoingserviceauthenticator.properties. Type in your username and password and save the file.

If you do not set up these properties, a preconfigured login screen appears when you run the application.

Warning: On Windows XP and linux, there are problems rendering the preconfigured login screen. To work around this problem, either set up automatic login or use an alternative login screen. An alternative login screen is provided in the sample. To use the alternative login screen:

1. Copy the sample's twitterclient.AuthDialog.java to your own twitterclient package.
2. Replace your version of org.netbeans.saas.twitter.TwitterWhatAreYouDoingServiceAuthenticator.java with the version in the sample.

Adding the updateStatus Operation

In this section you add the Twitter updateStatus operation to JButton1 (the "Update" button), which you created when you designed the JFrame. You also add the code so that when the button is clicked, the client gets the text from JTextField1 (the "Status" field) and sends it to Twitter.

To add the updateStatus operation:

1. Return to the Design view of TwitterJFrame. Double-click the Update button in the JFrame. The editor switches back to the Source view, in the body of the jButton1ActionPerformed method, which the IDE just created for you.
   
2. Open the Services window. Under Web Services, navigate to Twitter > WhatAreYouDoingService > Statuses > [update.{format}] > updateStatus.
   
3. Drag and drop the updateStatus operation into the method body of jButton1ActionPerformed. The Customization POST SaaS dialog appears. Accept the defaults and click OK. The IDE generates the code for the updateStatus operation into the method body.
4. In the generated try block, locate the line String status = "";. Change it to String status = jTextField1.getText().trim();. (Try changing it with code completion!) This gets the text typed into the text field and puts it in the status object that is sent by POST to Twitter.

The application can now update your Twitter status, when you are authenticated.

Displaying Usernames and Statuses in the JFrame

Now you set up the application to display the usernames and public statuses of everyone in the Twitter public timeline.

• To get the usernames and public statuses from Twitter, the application calls the Twitter getPublicTimeline operation when the application runs. To set this up, create a new run method that overrides the run method in main, then drag and drop getPublicTimeline into this method.
• To have the display update automatically, wrap the run method containing the getPublicTimeline operation in a java.util.TimerTask that executes the run method every 75 seconds.
• The application displays the data as cells in a list. You need to pass the data into GUI components that can be rendered as cells in the list, and you also want to format the display of the data. To accomplish this, create a new JPanel that implements javax.swing.ListCellRenderer. This JPanel returns a java.awt.Component object with the username and status passed in JLabels. Tweak the format of the JPanel.
• In TwitterJFrame, set up the JList to display the Component objects returned by the JPanel.

Creating a TimerTask

To update the display of the Twitter public timeline automatically, wrap the execution code in a TimerTask. Write the TimerTask wrapper first and then fill it in with execution code. Otherwise your code will be full of error warnings.

To create the TimerTask:

1. Open TwitterJFrame in the Sources view of the editor.
2. Find the class declaration and the constructor.

   public class TwitterJFrame extends javax.swing.JFrame {
   
   
       /** Creates new form TwitterJFrame */
   
       public TwitterJFrame() {
   
           initComponents();
   
           initUserInfo();
   
                       }

3. In the method body of the constructor, above initComponents();, instantiate the java.util.Timer class. The parameters name the Timer thread "Twitter Updater" and specify that it cannot be run as a daemon.

   public class TwitterJFrame extends javax.swing.JFrame {
   
   
       /** Creates new form TwitterJFrame */
   
       public TwitterJFrame() {
   
           Timer t = new Timer("Twitter Updater`", false);
   
           initComponents();
   
           initUserInfo();
   
       }
   
                       

4. Right-click anywhere in the editor and select Fix Imports from the context menu, or press Ctrl-Shift-I. A dialog opens and gives you a choice of classes to import. Add an import statement for java.util.Timer.
5. Below the instantiation of Timer, create a new Timer.scheduleAtFixedRate method. The method's parameters are a TimerTask object, the delay before it first runs the task, and the frequency with which it runs the task. Set the method to wait 1.5 seconds and run every 75 seconds. The exact code follows, in bold. An empty line is left where you put the execution code. Note that you have to add an import statement for java.util.TimerTask.

   public class TwitterJFrame extends javax.swing.JFrame {
   
   
       /** Creates new form TwitterJFrame */
   
       public TwitterJFrame() {
   
           Timer t = new Timer("Twitter Updater`", false);
   
           t.scheduleAtFixedRate(new TimerTask() {
   
   
   
   
           }, 1500, 75000);
   
           initComponents();
   
           initUserInfo();
   
                       }

The TimerTask wrapper code is now complete. Next you add the execution code.

Adding a run Method With the getPublicTimeline Operation

To display usernames and statuses, the application first gets this data from Twitter. Twitter SaaS provides the getPublicTimeline operation for getting public usernames and statuses. To execute the getPublicTimeline operation when the application runs, the operation needs to be inside a run method. Finally, because the application displays the usernames and statuses in a JList, the application needs to add the results of getPublicTimeline as elements of a DefaultListModel object.

To add a run method with the getPublicTimeline operation:

1. Above the TwitterJFrame constructor, create a DefaultListModel object named statuses.

   public class TwitterJFrame extends javax.swing.JFrame {
   
   
       private DefaultListModel statuses = new DefaultListModel();
   
   
   
   
   
       /** Creates new form TwitterJFrame */
   
       public TwitterJFrame() {
   
                       

2. Right-click anywhere in the editor and select Fix Imports from the context menu, or press Ctrl-Shift-I. This action adds an import statement for DefaultListModel.
3. In the body of the TimerTask object, create a new run method. Use the @Override annotation to override the run method in main.

   public class TwitterJFrame extends javax.swing.JFrame {
   
   
       private DefaultListModel statuses = new DefaultListModel();
   
   
   
   
   
   
   
   
       /** Creates new form TwitterJFrame */
   
       public TwitterJFrame() {
   
           Timer t = new Timer("Twitter Updater`", false);
   
           t.scheduleAtFixedRate(new TimerTask() {
   
               @Override
   
               public void run(){
   
                
   
               }
   
           }, 1500, 75000);
   
           initComponents();
   
           initUserInfo();
   
                       }

4. Open the Services window. In the Web Services tree, navigate to Twitter > What Are You Doing Service > [statuses] > [public_timeline.{format}] > getPublicTimeline.
   
5. Drag and drop getPublicTimeline into the body of the run method. A dialog box opens where you can customize the parameters of the GET operation. Accept the defaults and click OK. The IDE adds a try block with getPublicTimeline into your code.

   public class TwitterJFrame extends javax.swing.JFrame {
   
   
       private DefaultListModel statuses = new DefaultListModel();
   
   
       /** Creates new form TwitterJFrame */
   
       public TwitterJFrame() {
   
           Timer t = new Timer("Twitter Updater`", false);
   
           t.scheduleAtFixedRate(new TimerTask() {
   
   
               @Override
   
               public void run() {
   
   
                   try {
   
                       String format2 = "xml";
   
   
                       RestResponse result2 = TwitterWhatAreYouDoingService.getPublicTimeline(format2);
   
                       if (result2.getDataAsObject(twitter.whatareyoudoingservice.twitterresponse.Statuses.class) instanceof twitter.whatareyoudoingservice.twitterresponse.Statuses) {
   
                           twitter.whatareyoudoingservice.twitterresponse.Statuses result2Obj = result2.getDataAsObject(twitter.whatareyoudoingservice.twitterresponse.Statuses.class);
   
                       } else if (result2.getDataAsObject(twitter.whatareyoudoingservice.twitterresponse.NilClasses.class) instanceof twitter.whatareyoudoingservice.twitterresponse.NilClasses) {
   
                           twitter.whatareyoudoingservice.twitterresponse.NilClasses result2Obj = result2.getDataAsObject(twitter.whatareyoudoingservice.twitterresponse.NilClasses.class);
   
                       }
   
                   //TODO - Uncomment the print Statement below to print result.
   
                   //System.out.println("The SaasService returned: "+result2.getDataAsString());
   
                   } catch (Exception ex) {
   
                       ex.printStackTrace();
   
                   }
   
   
               }
   
           }, 1500, 75000);
   
           initComponents();
   
           initUserInfo();
   
                   }

6. In the try block, locate the if block.

   if (result2.getDataAsObject(twitter.whatareyoudoingservice.twitterresponse.Statuses.class) instanceof twitter.whatareyoudoingservice.twitterresponse.Statuses) {
   
        twitter.whatareyoudoingservice.twitterresponse.Statuses result2Obj = result2.getDataAsObject(twitter.whatareyoudoingservice.twitterresponse.Statuses.class);
   
                   }

7. At the end of the if block, insert code that adds a list element to statuses (your DefaultListModel object created in Step 1) for every Status object that the method gets from Twitter.

   if (result2.getDataAsObject(twitter.whatareyoudoingservice.twitterresponse.Statuses.class) instanceof twitter.whatareyoudoingservice.twitterresponse.Statuses) {
   
        twitter.whatareyoudoingservice.twitterresponse.Statuses result2Obj = result2.getDataAsObject(twitter.whatareyoudoingservice.twitterresponse.Statuses.class);
   
        for (final StatusType st : result2Obj.getStatus()) {
   
             SwingUtilities.invokeLater(new Runnable() {
   
   
                 public void run() {
   
                      statuses.addElement(st);
   
                 }
   
             });
   
        }
   
                       }

8. Press Ctrl-Shift-I to add an import statement for StatusType.

The code for getting statuses from the Twitter public timeline is now complete. Next you write a new class that returns a Component with list elements rendered in GUI components.

Creating a List Cell Rendering Component

Now you have code that gets Status objects from the Twitter Public Timeline and creates a list element for each status. However, you cannot display these raw list elements in a JList. You need to pass the data into GUI components . To accomplish this, create a new JPanel that implements javax.swing.ListCellRenderer. This JPanel returns a java.awt.Component object with the username and status passed in JLabels. You can customize the appearance of the JLabels in the JPanel.

To add a list cell rendering Component:

1. Right-click the project's node and choose New > JPanel Form. The New JPanel Form wizard opens.
2. Name the JPanel Item and place it in the twitterclient package.
   
3. Click Finish. Item.java opens in the Design view of the editor.
4. Drag and drop a Label and a Text Pane into the JPanel. The Label will display the username and the Text Pane will display that user's status message.
5. Position the Label and the Text Pane to match how you want the data to be displayed. In the following image, the username is on the left top while the status text is below and slightly indented. The sample project has the data on the top left and the username on the bottom right. Leave enough empty space in the JPanel below the Text Pane for the Text Pane to expand when it contains longer text.
   
6. Right-click on the JLabel element and select Properties from the context menu. In the Properties, you can change the font, the color, the alignment and other qualities. Set the labelFor property to point to jTextPane1. This improves accessibility. Experiment with the properties of the label until you like the appearance. In the following image, the font color is set to blue in the Foreground property.
   
7. Open the Properties dialog of the JTextPane and experiment with its appearance.
8. Change to the Source view for Item.java. Find the Generated Code block and expand it. This shows you the code generated by the IDE when you set the properties of the JLabel and JTextPane.

   In the following image, note the blue color setting for JLabel1. Can you see what properties are set for the JTextPane?

   
9. Find the class declaration and add the code implements ListCellRenderer.

   public class Item extends javax.swing.JPanel implements ListCellRenderer {

10. Press Ctrl-Shift-I. This action adds an import statement for javax.swing.ListCellRenderer. A warning appears saying that you need to implement all abstract methods.
11. Add a few empty lines between the generated code block and the variable declarations. Into that space, add the following code, which implements the abstract method getListCellRendererComponent. (You can copy and paste the code, or you can try to reproduce it with code completion.) This code replaces the default label texts "username" and "text" with the Text, User, and ScreenName objects you get with the Twitter StatusType class. The code then returns an instance of Component with these new JLabel text values.

    public Component getListCellRendererComponent(JList list, Object value, int index, boolean sel, boolean focus) {
    
            StatusType st = (StatusType) value;
    
            jTextPane1.setText(st.getText());
    
            jLabel1.setText("<html>" + st.getUser().getScreenName() + "</html>");
    
            return this;
    
                        }

12. Press Ctrl-Shift-I. This adds import statements for the StatusType and Component classes. Save Item.java.

Now you have an Item class that returns a Component object with username and status displayed in a JLabel and a JTextPane. Next you modify TwitterJFrame to use this Component.

Displaying the Component in TwitterJFrame

In order to display the Component object created in Item.java, the JList in TwitterJFrame has to use Item.java as its cell renderer.

1. Return to TwitterJFrame. In the Design view, select the JList. Right-click and open its Properties.
   
2. Select the model property. Press Ctrl-Space. The custom property editor opens, showing the default text displayed in the list.
   
3. In the "Set jLlist1's model property using:" drop-down menu, select Custom Code. A text field appears where you type in the properties for jLabel1.setModel. Type statuses in the field and click OK.
   
4. In the Properties dialog, select cellRenderer and press Ctrl-Space. The custom property editor opens.
5. In the "Set jList1's cellRenderer property using:" drop-down menu, select Custom Code. A text field appears where you type in the properties for jList1.cellRenderer. Type new Item() and click OK.
   

Your client application is now complete! Save all files and run the application. (Right-click project node and select Run.) The application opens, showing a list of public timeline messages and a field with your own status.

More Exercises

Here are a few more ideas for you to explore:

• Change your Twitter user icon (in a browser) and run the client again. Does the new icon appear?
• Add a toolbar with some functions to the JFrame.
• Add a new Scroll Pane with a new List that displays your friends' statuses, using the What Are You Doing Service > [statuses] > [friends_timeline.{format}] > getFriendsTimeline operation. The code is similar to the code for displaying the public timeline.

See Also

For more information about using NetBeans IDE to create and consume web services and to design GUIs, see the following resources:

• Getting Started with RESTful Web Services
• GUI Building in NetBeans IDE
• Handling Images in A GUI Application
• EJB & Web Service Applications Learning Trail
• Java and JavaFX GUI Application Learning Trail

Exposing a MySQL Database with RESTful Web Services

This tutorial shows you how to use NetBeans IDE to expose a MySQL database as a RESTful web service endpoint. You will deploy the "sakila" sample database on GlassFish v2 using the RESTful Web Services plugin. In this tutorial, you learn to create:

• A database connection to MySQL
• A new data source using that connection
• Entity classes from the MySQL database
• RESTful web services from those entity classes

Contents

• Introduction
• Creating a Database Connection
• Setting Up a Web Application Project
• Generating Entity Classes from a Database
• Configuring the Persistence File
• Generating RESTful Web Services from Entity Classes
• Testing the RESTful Web Services
• More Exercises

To follow this tutorial, you need the following software and resources.

Both Tomcat and GlassFish can be installed, optionally, with the Web and Java EE distribution of NetBeans IDE. Alternatively, you can visit the GlassFish downloads page or the Apache Tomcat downloads page.

This tutorial also requires the RESTful Web Services plugin. In the IDE, go to the Plugin Manager, under the Tools menu, and check whether the RESTful Web Services Plugin is installed, under the Installed tab. If it is not, install it from the Available Plugins tab, as shown below:

Introduction

MySQL is the world's most popular open source database software, with over 100 million copies of its software downloaded or distributed throughout its history. With superior speed, reliability, and ease of use, MySQL has become the preferred choice of corporate IT Managers because it eliminates the major problems associated with downtime, maintenance, administration and support.

The IDE supports rapid development of RESTful web services from databases, by the creation and exposure of entity classes. RESTful web services are services based on HTTP header operations. Building web services using the RESTful approach is emerging as a popular alternative to using SOAP-based technologies for deploying services on the internet, due to its lightweight nature and the ability to transmit data directly over HTTP.

To celebrate the announcement that Sun Microsystems is acquiring MySQL, Arun Gupta originally created this demonstration, showing how a MySQL database could be exposed as a RESTful web service using the IDE.

Before you use this tutorial, you should see the following:

• Introduction to Web Services
• Getting Started with RESTful Web Services on GlassFish
• Connecting to a MySQL Database

Creating a Database Connection

The IDE contains the MySQL Connector/J JDBC Driver, allowing you to connect to a MySQL database. The goal of this exercise is to create that connection.

1. Start your MySQL database.
   • On Windows, type the command mysqld-nt --user root --password=your_root_user_password. You must be in the MySQL bin directory or the bin directory must be on your path. If you get an error that mysql could not connect to localhost, start the MySQL service (Control Panel > Administrative Tools > Services).
   • On UNIX systems, type the command ./bin/mysqld_safe from the MySQL directory.
2. Start the IDE. Open the Services tab. Expand Databases > Drivers. Look for the MySQL driver. If it is not there, right-click the Drivers node, choose New Driver and fill in the dialog with the path to your MySQL Connector/J driver.
   
   
3. Right-click on the MySQL (Connector/J) driver node and choose Connect Using... The New Database Connection dialog opens.
4. Leave the Name and Driver fields with default values. For Database URL, type jdbc:mysql://localhost:sakila. For User Name, type root, and for Password type your "root" user password. The dialog should resemble the following. Click OK when done.
   

Setting Up a Web Application Project

The goal of this exercise is to create a new Web Application project. This project will contain entity classes and RESTful web services.

1. Choose File > New Project (Ctrl-Shift-N) from the main menu. Under Categories, select Web. Under Projects, select Web Application and click Next.
2. Type sakila in the Project Name field. Note that the Context Path becomes /sakila.
3. Specify the Project Location to any directory on your computer. You can accept the default location.
4. Under Server, select GlassFish. GlassFish is a Java EE5-certified application server and is bundled with the Web and Java EE insallation of NetBeans IDE. If you use a server other than GlassFish, such as the bundled Tomcat web server, you may need to configure the server, which is outside the scope of this tutorial.
5. Leave the Set as Main Project option selected and click Finish. The IDE creates the Sakila project folder. The project folder contains all of your sources and project metadata, such as the project's Ant build script. The HelloWeb project opens in the IDE. The welcome page, index.jsp, opens in the Source Editor in the main window. You can view the project's file structure in the Files window (Ctrl-2), and its logical structure in the Projects window (Ctrl-1).
   

Generating Entity Classes from a Database

The goal of this exercise is to generate entity classes from the sakila database.

1. Right-click the sakila node and choose New > Entity Classes from Database, as shown below:

   
   

2. In the Database Tables panel, select New Data Source from the Data Source drop-down field. The Create Data Source dialog opens.
3. Type jndi/sakila in the JNDI Name field. From the Database Connection drop-down field, select jdbc:mysql://localhost/sakila [root on Default schema], as shown below. Click OK. The dialog closes and you return to the Database Tables panel.
   
   
4. Under Available Tables, click "film" and then click Add >. The Database Tables page should now look like the image below. Click Next.
   
   
5. The Entity Classes page opens. Click Create Persistence Unit... Accept all the defaults shown below and click Create. You return to the Entity Classes page.
   
6. Under Package, type sakila. The Entity Classes page should now appear as follows:
   

7. Click Finish. The IDE creates the entity classes.

8. Look in the Projects window. You should now see the following:
   

Configuring the Persistence File

In Generating Entity Classes from a Database, you created a perstence unit. The configuration of this persistence unit is stored in the file persistence.xml. In your Projects view, you can find persistence.xml in your project, in the Configuration Files node.

You need to change this persistence file to pass the username and password. Open the XML tab. Edit the file to include toplink.jdbc.user and toplink.jdbc.password properties. It matches the following snippet (the parts you add or change are boldface):

<persistence-unit name="sakilaPU" transaction-type="JTA">

  <jta-data-source>jndi/sakila</jta-data-source>

  <properties>

    <property name="toplink.jdbc.user" value="root"/>

    <property name="toplink.jdbc.password" value="your_root_user_password"/>

  </properties>

</persistence-unit>

    

Generating RESTful Web Services from Entity Classes

The goal of this exercise is to generate RESTful web services from the entity classes that we generated in the previous section.

1. Right-click the package that contains the entity classes and choose New > RESTful Web Services from Entity Classes, as shown below:
   
2. In the New RESTful Web Services from Entity Classes wizard, click Add All. You should now see the following:
   
3. Click Next. The Generated Classes panel opens. Accept all defaults and click Finish. The IDE now creates the RESTful web services.
   

   The RESTful Web Services node in the Projects window displays all the RESTful web services in your project. The value between the square brackets, such as [/films/], is the value for the URI template. You can also navigate to the source file by doubling clicking on this node. This view also displays all the HTTP methods and Sub-resource locator methods. Again, you can navigate to the methods by double clicking on the nodes.

Now that our entity classes and RESTful web services have been generated, let's test our application. The IDE provides a useful utility for testing RESTful web services. We will make use of it in the next section.

Testing the RESTful Web Services

The goal of this exercise is to try out our application.

1. Right-click the project node and choose Test RESTful Web Services, as shown below:
   

   The server starts and the application is deployed. Finally, the browser should display your application, with a link for each of the web services:
   

   On the left-hand side is the set of root resources. Here they are named languages and films.

2. Click Films and then click Test or the URL "http://localhost:8080/sakila/resources/films/". The result is the RESTful representation of the Film table. The default representation shows 10 records from the table where each entry returns the id of the film and a reference to the detailed entry.
   
   

You can view more entries by appending /?max=n to the URL. For example, "http://localhost:8080/sakila/resources/films/?max=40" shows the first 40 entries. Additional fields from the table can be displayed by adding getter methods to the "converter.FilmRefConverter" class, such as:

@XmlElement

public String getTitle() {

    return entity.getTitle();

}

More Exercises

Here are a few more ideas for you to explore:

• Create RESTful representations of other tables using the steps described above.
• Display the data from different tables in a jMaki-wrapped Yahoo or Dojo data table as explained in TOTD #10.
• Display the data retrieved from the database in a JSP page as described in Hello JPA World.
• Create a CRUD application using jMaki Data Table as described in TOTD #15 or Screencast #Web10.

A JRuby-on-Rails application using MySQL is explained here. TOTD #9 explains how JDBC connection pooling in GlassFish can be used for a JRuby-on-Rails application using MySQL.

The key message here is MySQL can be very easily used with GlassFish and NetBeans IDE makes it possible.

See Also

For more information about using NetBeans IDE 6.0 to develop Java EE applications, see the following resources:

• Developing JAX-WS Web Service Clients
• Getting Started with JAX-WS Web Services
• Getting Started with RESTful Web Services on GlassFish
• Introduction to Developing Web Applications
• Connecting to a MySQL Database
• Advanced Web Service Interoperability
• EJB & Web Service Applications Learning Trail

To send comments and suggestions, get support, and keep informed on the latest developments on the NetBeans IDE Java EE development features, join the nbj2ee@netbeans.org mailing list.

엄격한 의미로 REST는 네트워크 아키텍처 원리의 모음이다. 여기서 네트워크 아키텍처 원리란 리소스를 정의하고 리소스에 대한 주소를 지정하는 방법에 대한 개괄을 말한다. 간단한 의미로는, 도메인 지향 데이터를 HTTP위에서 SOAP이나 쿠키를 통한 세션 트랙킹 같은 부가적인 전송 레이어 없이, 전송하기 위한 아주 간단한 인터페이스를 말한다. 이 두 가지의 의미는 당연히 겹치는 부분과 충돌되는 부분이 있다. 필딩의 REST 아키텍처 형식을 따르면 HTTP 프로토콜을 사용하지 않은채로 또 월드 와이드 웹에서 전송하지 않고도 아주 커다란 소프트웨어 시스템을 설계하는것도 가능하다. 또한 리모트 프로시져 콜을 이용하는 대신에 간단한 XML과 HTTP 인터페이스(REST 원리에 부합하지는 않지만)를 이용해 설계하는것도 가능하다. 현실 세계에서의 REST 용어에 대한 이러한 두가지 의미는 기술 토론에서 종종 혼란을 야기한다.

REST 서비스 작성하기

자바 기술과 Atom Publishing Protocol로 REST 서비스 만들기

본 튜토리얼은 REST(Representation State Transfer)와 Atom Publishing Protocol(이하 APP)의 개념에 대해 토론하고 서비스에 이것들을 적용하는 방법을 다룹니다. 또한 Java™ 기술을 사용하여 REST/APP 기반 서비스를 구현하는 방법도 살펴봅니다.

목표

본 튜토리얼에서는 다루는 사항은 다음과 같다.

• REST 기초와 APP 이면의 기본 개념
• 조직에 이 기술을 적용하여 자바 서블릿 기반 시스템을 통해 HTTP 요청 및 응답을 주고 받는다.
• 포드캐스트, 블로그 엔트리, 이미지 저장소, 달력 엔트리 등을 위해 리소스 데이터에 접근하고 수정한다

Representational State Transfer

REST는 월드 와이드 웹처럼 자원을 정의하고 접근하는 메커니즘을 기반으로 한 네트워크가 가능한 시스템을 만드는 아키텍처 원칙과 소프트웨어 아키텍처 스타일의 집합이다. Roy Fielding의 논문(참고자료 참조)에서 정의된 용어인 REST는 부수적인 시맨틱 레이어나 세션 관리를 추가하지 않고도 HTTP 같은 프로토콜로 데이터를 전달하는 프레임워크를 설명하는 데 전반적으로 쓰인다.

REST 는 클라이언트 서버 시스템에 참여하는 구성요소(component) 간에 관심의 분리(separation of concerns)를 엄격히 정의하여 관련된 구현을 간단하게 만든다. 또한 네트워크로 연결된 시스템에서 커뮤니케이션 시맨틱을 단순화하여 확장성과 성능을 높인다. REST는 자율적인 요청에 의존해 메시지를 교환하는데, 이 때 요청은 클라이언트와 서버가 요청 컨텍스트를 이해할 수 있도록 모든 컨텍스트를 포함해야 한다. REST 기반 시스템에서는 가능한 적은 요청 세트를 사용하여 표준 미디어 타입을 교환한다.

REST 원칙은 URI(Uniform Resource Identifiers)를 사용하여 주어진 자원 표현의 위치를 알아내고 접근한다. 표현 상태(representational state)라 알려진 자원 표현은 만들어질 수도, 찾아올 수도, 수정될 수도, 삭제될 수도 있다. 예를 들어 REST를 적용하여 문서를 발행해 독자들이 이 문서를 읽을 수 있게 할 수 있다. 언제든 문서를 발행할 때는 웹 URL을 보여줘야 한다. 그래야 독자들이 그 문서의 정보(표현 상태)에 접근할 수 있다. 문서를 읽는 사람은 URL만 알면 문서 정보를 읽을 수 있고 승인이 있다면 정보를 수정할 수 있다.

Roy Fielding이 설명했듯이 REST의 기본 원칙 중 하나는 HTTP처럼 웹과 관련된 기존 기술, 표준, 프로토콜을 활용할 수 있다는 것이다. 기존 기술 및 프로토콜에 의존하므로 REST는 대다수의 기타 웹 기반 메시징 표준보다 쉽고 간단하게 사용할 수 있다. 효과적인 정보 교환을 위해 약간의 오버헤드만 있으면 되기 때문이다.

Fielding에 따르면 REST 기반 대화는 무상태 대화(stateless conversation) 내에서 동작하기 때문에 RSS, RDF, OWL, Atom 같은 등록 기반의 기술이 쉽게 보급될 수 있게 영향을 미쳤다. 여기에서 콘텐츠는 이미 등록한 클라이언트에 전달된다.

REST의 기본 개체

REST는 다음 기본 개체를 정의한다.

• 데이터 요소: 데이터, 식별자(URI와 URL), HTML 문서, XML 문서, 이미지와 같은 데이터 표현
• 컴포넌트: 아파치(Apache) httpd와 마이크로소프트® IIS(Internet Information Serivces) 같은 고유 서버, 스퀴드(Squid)와 CGI 같은 게이트웨이(gateways), 건틀렛(Gauntlet)과 넷스케이프(Netscape) 프록시 같은 프록시, 웹 브라우저나 모바일 기기 같은 사용자 에이전트
• 커넥터: libwww 같은 클라이언트 커넥터, NSAPI 같은 서버 커넥터, 브라우저 캐시 같은 캐시 등

그림 1은 기본 REST 개체와 그것들이 전형적인 네트워크 시스템과 어떻게 상호작용하는지 보여준다. 이 때 커넥터에 의해 전달되거나 받게 되는 요청은 서버나 데이터베이스 같은 주어진 개체와 엮인다는 것에 주의하자. 커넥터는 주어진 프로토콜에서 전달하는 업무를 담당하므로 커넥터가 특정 프로토콜을 위해 존재하지 않는 한 개체는 어떤 프로토콜에서나 같은 방식으로 요청을 전달하거나 받는다.

그림에서 볼 수 있듯이 이런 시스템의 커넥터는 컴포넌트 간에 통신할 수 있게는 프로토콜 포트로 구체화된다. REST 시스템에서 컴포넌트는 여러 개의 클라이언트 또는 서버 커넥터를 가지고 다른 컴포넌트와의 통신을 처리한다.

REST와 HTTP

Fielding의 논문에 따르면 HTTP 기반 REST 시스템에서는 GET, PUT, POST, DELETE라는 표준 HTTP 메서드를 사용하여 자원의 표현 상태에 접근해야 한다.

• GET : 발행자가 소비자에게 자원의 현재 표현 상태를 전달할 때 이 메서드를 사용한다.
• PUT : 소비자가 발행자에게 자원의 수정된 표현 상태를 전달할 때 이 메서드를 사용한다.
• POST : 소비자가 발행자에게 자원의 새 표현 상태를 전달할 때 이 메서드를 사용한다.
• DELETE : 자원의 표현 상태를 삭제 상태로 변경해야 하는 정보를 전달할 때 이 메서드를 사용한다.

The Atom Publishing Protocol

APP 는 HTTP 기반 프로토콜로 자원을 발행, 삭제, 갱신하는 기능을 한다. APP는 발행, 갱신 등이 가능한 자원과 피드를 포함하는 인트로스펙션(introspection) 문서와 컬렉션(collection) 문서의 인스턴스를 전달하기 위해 HTTP 프로토콜이 제공하는 (GET, PUT, POST, DELETE 같은) 기본 기능을 사용하는 개념을 강조한다. 자원과 피드가 발견된 후 관련된 URI는 발행과 수정에 사용된다. 멤버 피드에는 블로그 엔트리, 포드캐스트, 위키 문서, 달력 이벤트 등이 있다. APP는 또한 데이터베이스 서버, 문서와 내용 관리 서비스, 소프트웨어 저장소 같은 폭넓은 데이터 저장 서비스를 위한 프론트 엔드 API로 쓰이고 연구되고 있다.

APP는 REST 개념과 기술을 사용하여 의미적으로 풍부한 콘텐츠 교환에 쓰이는 여러 메커니즘을 정형화기 위해 인기있는 아톰 배급 포맷(Atom Syndication Format) 위에 구축된다. 프로토콜은 컬렉션이 라 알려진 웹 자원 컨테이너에서 작동한다. 컬렉션은 인트로스펙션 문서에서 발견되는 것을 나타낸다. 모든 컬렉션에는 멤버 자원이 들어 있다. 이것들은 생성, 접근, 수정, 삭제를 위한 최종 타깃이다. 컬렉션과 이 멤버 자원 간의 상호작용은 일반적인 HTTP 동사(verb)를 기반으로 한다.

• GET: 컬렉션이나 멤버 자원 표현을 찾아오는 데 쓰인다.
• POST: 새 멤버 자원을 만드는 데 쓰인다.
• PUT: 멤버 자원을 갱신하는 데 쓰인다.
• DELETE: 멤버 자원을 삭제하는 데 쓰인다.

APP의 기본 개체

APP는 다음과 같은 기본 개체를 정의한다.

• 인트로스펙션 문서: 인트로스펙션 문서는 application/atomserv+xml 미디어 타입을 가지고 컬렉션의 임의 서버 정의 그루핑인 workspaces를 기술한다. 컬렉션은 하나 이상의 작업공간에 나타날 수 있다. Listing 1은 전형적인 인트로스펙션 문서의 예다.
  
  
  Listing 1. 전형적인 인트로스펙션 문서
  

  <?xml version="1.0" encoding="utf-8" ?> <service xmlns="http://www.w3.org/2007/app" xmlns:atom="http://www.w3.org/2005/Atom"> - <workspace> <atom:title>Main Site</atom:title> - <collection href="http://localhost:8080/atompub/services/collections/main"> <atom:title>My Main Page</atom:title> <accept>application/atom+xml;type=entry</accept> <categories fixed="yes" /> </collection> <collection href="http://localhost:8080/atompub/services/collections/pics"> <atom:title>My Pictures</atom:title> <accept>*/*</accept> <categories fixed="yes" /> </collection> </workspace> - <workspace> <atom:title>Documents</atom:title> - <collection href="http://localhost:8080/atompub/services/collections/docs"> <atom:title>My Documents</atom:title> <accept>application/atom+xml;type=entry</accept> <categories fixed="yes" /> </collection> </workspace> </service>

  
  

  위에 보인 인트로스펙션 문서는 두 개의 작업공간으로 서비스를 정의한다. 첫 번째 작업공간은 "Main Site"라 부르는데 "My Main Page"와 "My Picture"라는 두 개의 컬렉션을 정의한다. "My Main Page" 컬렉션은 http://localhost:8080/atompub/services/collections/main에, "My Pictures" 컬렉션은 http://localhost:8080/atompub/services/collections/pics에 있다. 두 번째 작업공간인 "Documents"는 "My Documents"라는 하나의 컬렉션을 가지고 있고 이는 http://localhost:8080/atompub/services/collections/docs에 있다.

• URI: 자원 식별자
• IRI: 국제 자원 식별자 (참고자료 참조)
• 멤버 자원: IRI나 URI가 지정하는 엔트리 자원 또는 미디어 자원으로 알려진 데이터 객체 또는 서비스. 엔트리 자원은 아톰 엔트리 문서로 표현된다. 미디어 자원은 어떤 미디어 타입에서든 표현을 가질 수 있다. 미디어 자원은 미디어 링크 엔트리를 사용하여 컬렉션 내에서 기술된다.
• 표현: 요청이나 응답에 의해 전달되는 주어진 자원의 상태
• 컬렉션: 특정 URI에 의해 식별된 멤버 자원의 컨테이너. 컬렉션은 아톰 피드로 표현된다. 컬렉션에서 새 엔트리를 만들려면 클라이언트는 컬렉션의 URI에 HTTP POST 요청을 보낸다. 새 엔트리에는 특정 URI가 부여되어 위치 레퍼런스로 사용된다. 컬렉션에서 엔트리를 수정하려면 클라이언트는 그 URI를 사용하여 자원을 찾아오고 수정을 한 후 PUT을 사용하여 자원의 수정된 표현을 서버로 옮긴다. 컬렉션에서 멤버 자원을 삭제하려면 멤버 자원의 URI로 HTTP DELETE 요청을 보낸다. 컬렉션의 모든 멤버는 컬렉션 문서에 따라 updated 속성을 가져야 한다.
• 작업공간: 명명된 컬렉션 그룹
• 서비스 문서/요소: 인트로스펙션 문서의 최상위 요소로 하나 또는 그 이상의 컬렉션 기능과 위치를 기술하고 작업공간으로 묶음
• 카테고리 문서: 컬렉션에서 허용되는 카테고리를 기술하는 문서

심화학습

HTTP 프로토콜을 거쳐 자원을 전달하는 시스템에 REST 원칙을 적용하는 데 자바 프로그래밍 언어를 사용할 수 있다. APP를 사용하여 이런 시스템을 확장하고 블로그 엔트리, 포드캐스트, 위키 페이지, 달력 엔트리 등을 사용하여 자원 접근 및 조작을 용이하게 할 수 있다. 본 튜토리얼에서는 자바 서블릿 기반 시스템을 사용하여 웹 애플리케이션 내에서 기본 REST와 APP를 적용하여 HTTP 요청 및 응답을 거쳐 자원을 전달하는 방법에 대해 보여준다.

아톰 프로토콜 명세는 클라이언트가 APP 엔드포인트를 인트로스펙트하는 데 사용할 수 있는 XML 문서를 정의한다. 인트로스펙션 문서는 주어진 엔드포인트 URI에 있는 모든 컬렉션의 목록을 가진다. 그러므로 APP가 가능한 서비스를 사용하는 첫 단계는 서비스 엔드포인트의 URI에서 가능한 컬렉션과 각 컬렉션이 포함할 수 있는 멤버 자원의 타입이 무엇인가를 결정하는 것이다. 인트로스펙션 문서를 찾아오려면 클라이언트는 GET 요청을 서버에 보낸다. 그리고 나면 서버는 서비스를 제공하는 컬렉션의 위치 URI를 포함하는 인트로스펙션 문서로 클라이언트에 응답한다.

인트로스펙션 문서에 있는 각각의 컬렉션 요소는 컨테이너가 컬렉션에 있는 각 멤버 자원의 정보에 저장됐다는 것을 나타낸다. 인트로스펙션 문서 안의 각 컬렉션은 특별한 URI를 가진다. 이 URI에 HTTP GET 요청을 보내면 컬렉션에 포함된 멤버 자원에 관한 정보를 포함하는 아톰 피드 문서를 반환해야 한다.

컬렉션에서 새 멤버 자원 엔트리를 만들려면 클라이언트는 컬렉션에 추가할 멤버 자원의 표현 상태와 함께 컬렉션 URI에 HTTP POST 요청을 보낸다. 새 멤버 자원 엔트리는 자신만의 URI를 받는데 이 URI로 각 멤버 자원 엔트리의 표현 상태를 찾아오도록 질의할 수 있다. 멤버 자원 엔트리를 수정하려면 클라이언트는 멤버 자원의 URI에 HTTP GET 요청을 함으로써 자원을 찾아오고 원하는 수정을 GET 요청이 반환하는 자원의 표현 상태로 만든다. 그리고 나서 HTTP PUT 요청을 사용하여 수정된 표현 상태를 컬렉션에 다시 보낸다. 컬렉션에서 멤버 자원 엔트리를 지우는 것은 클라이언트가 해당 멤버 자원 URI에 HTTP DELETE 요청을 할 때 유용하다.

REST를 사용하는 간단한 APP 애플리케이션

본 튜토리얼의 예제 애플리케이션은 컨트롤러 서블릿을 사용하여 들어오는 요청을 처리하고 결과 응답을 내보내도록 설계됐다. 들어오는 요청은 REST 기반 서비스 프레임워크로 발송되고(dispatch) 여기서 APP 인트로스펙션 문서, 컬렉션, 멤버 자원 상에서 기능을 처리할 수 있다.

REST 기반 APP 프레임워크는 그림 2처럼 클래스와 인터페이스를 포함한다.

이 클래스 다이어그램에서 보는 것처럼 FrontController 서블릿은 대다수의 주요 REST 개체를 위한 중요한 레퍼런스다. FrontController 서블릿이 요청을 받으면 커넥터와 상호작용하여 각 요청의 비즈니스 로직을 처리할 BusinessService 객체를 위치시키는 데 쓰이는 ServerComponent 객체를 찾아온다. javax.activation 패키지에 있는 클래스를 사용하여 구현되는 Representation 인터페이스는 자원을 정의한다.

이제 각각의 주요 REST 엔티티와 APP 엔티티가 각 엔티티를 나타내는 특정 자바 컴포넌트와 함께 예제 프레임워크 안에서 어떻게 상호작용하는지에 관해 설명하겠다.

REST 컴포넌트

REST 컴포넌트는 주어진 시스템에서 역할에 따라 정의된다. 반복하자면 REST 시스템의 전형적인 컴포넌트는 다음과 같다.

• 사용자 에이전트: 사용자 에이전트에 다시 응답하는 서버 컴포넌트 형태로 요청을 초기화하는 컴포넌트. 사용자 에이전트는 모바일 기기, 웹 브라우저 등이 될 수 있다.
• 원 서버: 원(origin) 서버는 자원의 컬렉션을 위해 주어진 이름공간을 포함한다. 그리고 포함된 자원의 상태 표현을 관리한다. 사용자 에이전트에서 요청을 받고 목표 컬렉션이나 멤버 자원 상에서 필요한 동작을 수행한다. 그리고 나서 컬렉션 문서나 자원의 표현 상태로 사용자 에이전트에 응답한다.

자바 언어에서 마커 인터페이스를 사용해 REST 컴포넌트를 나타내야 할지도 모른다.

public interface Component
{
}

자바 언어의 서버 컴포넌트는 어떤 자원 컨텍스트가 참조되는지에 의해 메서드와 속성을 드러낼 것이다. Listing 2를 보자.

                    

public abstract class ServerComponent

  implements Component

{

  private java.util.HashMap<String, Context> contexts =

    new java.util.HashMap<String, Context>();

  

  abstract public Context addContext(String contextRootPath,

                                     String contextPath);

  

  public java.util.Iterator<String> getContextPaths()

  {

    return contexts.keySet().iterator();

  }

  

  public Context getContext(String contextPath)

  {

    return contexts.get(contextPath);

  }

  

  protected java.util.HashMap<String, Context> getContexts()

  {

    return contexts;

  }

}

ServerComponent 클래스가 주어진 내용을 루트/문서 경로에 어떻게 매핑을 하는지에 주목하자. 필요에 따라 각 특정 서버 컴포넌트는 루트/문서 경로를 주어진 컨텍스트에 매핑하는 데 사용한다. 예를 들어 HTTP에 한정된 서버 컴포넌트는 Listing 3처럼 HTTP에 한정된 내용을 관리할 것이다.

                    ;

public Context addContext(String contextRootPath, String contextPath)

{

  Context context = getContexts().get(contextPath);

  if (context == null)

  {

    context = new HTTPContext(contextRootPath, contextPath);

    getContexts().put(contextPath, context);

  }

  

  return context;

}

HTTP에 한정된 컨텍스트는 각각의 주요 HTTP 메서드를 정의하는 인터페이스를 구현하고 목표한 컬렉션과 멤버 자원 표현 요청을 신속히 처리하는 수단을 제공한다. Listing 4는 HTTP GET 메서드 구현의 예를 보여준다. 특정 수직 도메인 서비스나 멤버 자원 피드의 자세한 비즈니스 로직은 특정 비즈니스 서비스 구현 내에서 캡슐화된다.

                    

public Representation handleGet(Request request)

  throws ContextRequestException

{

  String uri = ((HTTPRequest)request).getRequest().getRequestURI();

  if (uri.startsWith(contextPath))

  {

    uri = reqURI.substring(contextPath.length());

  }


  BusinessService businessService =

    ServiceLocator.locateService(contextRootPath, contextPath, uri);


  Representation representation = null;

  

  try

  {

    representation = businessService.read(request);

  }

  catch (ServiceExecutionException e)

  {

    e.printStackTrace();

    throw new ContextRequestException(e);

  }

  

  return representation;

}

Listing 4에서 GET 요청은 요청에서 URI를 처음 추출함으로써 처리되고 URI를 사용하여 원하는 비즈니스 서비스의 위치를 찾는다. 그리고 나서 비즈니스 서비스는 요청을 처리하기 위해 호출된다.

REST 컴포넌트는 두 개씩 묶이고 커넥터 객체를 통해 각각 상호작용한다.

REST 커넥터

REST 의 커넥터는 REST 컴포넌트 사이에 통신하기 위해 속성과 메서드를 정의한 일반적인(generic) 인터페이스를 노출한다. 커넥터는 커뮤니케이션 프로토콜의 한 부분이나 엔드포인트를 나타낸다. 커넥터를 구현하여 클라이언트 커넥션이나 서버 커넥션을 나타낼 수 있다. 사용자 에이전트는 클라이언트 커넥터를 사용하여 원(origin) 서버에 대한 요청을 초기화한다. 원 서버는 서버 커넥터에 의존하여 사용자 에이전트에서 들어오는 요청을 처리하고 컬렉션이나 멤버 자원의 표현 상태로 응답한다.

Listing 5에서 인터페이스는 주어진 포트에 서버 컴포넌트를 추가하기 위해 하나의 메서드를 정의한 커넥터를 보여준다.

                    

public interface Connector

{

  public ServerComponent addServer(int port);

}

factory 클래스는 프로토콜에 한정된 커넥터를 관리하는 데 유용하다. factory 클래스는 상황이 지시한 대로 factory 커넥터를 묶을 수 있다. Listing 6은 커넥터 factory 클래스의 예를 제공한다.

                    ;

public static Connector getConnector(Protocol protocol)

    throws ConnectorException

  {

    String key = protocol.getScheme();

    Connector instance = instances.get(key);

    

    if (instance == null)

    {

      if (key.equalsIgnoreCase(Protocol.HTTP.getScheme()))

      {

        instance = new HTTPConnector();

        instances.put(key, instance);

      }

      else

      {

        throw new ConnectorException("Invalid protocol: "

                                     + protocol.getScheme());

      }

    }

    

    return instance;

  }

HTTP에 한정된 서버 커넥터를 위한 커넥터 인터페이스는 Listing 7처럼 특정 포트에 HTTP에 한정된 서버 컴포넌트를 추가하기 위한 속성과 메서드를 정의한다.

                    

  public ServerComponent addServer(int port)

  {

    return new HTTPServerComponent(port);

  }

커넥터는 사용자 에이전트와 원 서버 사이의 통신을 가능하게 한다. 원 서버는 서버 컴포넌트에 의해 나타나며 멤버 자원을 포함하고 관리한다. 더 자세한 내용은 다음 절에서 다루겠다.

REST 자원 표현

사용자 에이전트가 요청을 하면 URI는 목표한 컬렉션이나 요청의 멤버 자원을 식별하는 원 서버로 전달된다. 원 서버를 나타내는 서버 컴포넌트가 요청을 받으면 요청에서 URI를 추출하고 요청을 처리하는 데 필요한 동작을 수행한다. 멤버 자원을 목표로 하는 요청은 자원의 표현 상태를 만들거나 읽거나 수정하거나 삭제할 수 있다. 그리고 나서 필요하다면 자원의 표현 상태 결과를 반환한다.

HTTP 요청을 처리할 컴포넌트 만들기

사용자 에이전트에서 원 서버로, 그리고 다시 사용자 에이전트로 HTTP 요청을 처리하는 데 필요한 컴포넌트를 만들고 접근하려면 다음 단계를 밟아야 한다.

1. 서버 커넥터를 만들고 나서 이를 적절한 HTTP 서버 컴포넌트에 추가한다.
2. 주어진 서버 컨텍스트를 위해 HTTP 컨텍스트를 추가하거나 이에 접근한다.
3. 서버 컴포넌트는 들어오는 사용자 에이전트 요청을 받아 목표한 비즈니스 서비스로 보낸다.
4. 비즈니스 서비스가 생성하는 자원을 나타내는 데이터 모델을 만들고 파퓰레이트한다. 그리고 이를 목표 자원의 표현 상태로 캡슐화한다.
5. 자원의 표현 상태를 사용자 에이전트에 다시 보낸다.

그림 3은 이 과정을 보여준다.

DataHandler 클래스 확장하기

JAF(JavaBean Activation Framework)는 멤버 자원의 상태를 효과적으로 나타낼 수 있는 컴포넌트인 javax.activation.DataHander 클래스를 제공한다. DataHandler 컴포넌트를 사용하여 자원을 표현내면 임의의 콘텐츠 타입이 들어 있는 이종 자원을 똑같은 일반적인 인터페이스로 나타낼 수 있다.

Listing 8에서 보여주는 추상 클래스는 DataHandler 클래스를 확장하여 멤버 자원을 나타내는 객체의 일반적인 기본 클래스를 제공한다.

                    

public abstract class Representation extends javax.activation.DataHandler

{

  public Representation(DataSource dataSource)

  {

    super(dataSource);

  }

}

본 튜토리얼의 목적처럼 아톰 피드 자원을 캡슐화하는 Representation 인터페이스의 특정 구현은 Listing 9처럼 만들 수 있다.

                    

public class FeedRepresentation extends Representation

{

  public static final String MEDIA_TYPE = "application/atom+xml";  

  public static final String CONTENT_TYPE = MEDIA_TYPE + "; charset=utf-8";

  

  public FeedRepresentation(File file)

  {

    super(new FeedDataSource(file, CONTENT_TYPE));

  }

  

  public String getContentType()

  {

    return CONTENT_TYPE;

  }

}

Listing 9를 보면 피드 자원은 FeedRepresentation 클래스 내에서 캡슐화된다. 이 클래스는 FeedDataSource 클래스를 사용하여 파일 자원의 입출력 동작을 처리한다.

구현을 위해 속성과 메서드 정의하기

JAF 또한 임의의 컬렉션 데이터를 보여주는 자원에 의해 구현된 속성과 메서드를 정의하는 인터페이스인 javax.activation.DataSource를 제공한다. 인터페이스는 메서드를 제공하여 자원과 자원의 데이터에서 작동하는 입출력 스트림의 콘텐츠 타입을 보여준다. DataHandler는 객체를 사용하여 DataSource 인터페이스를 구현함으로써 똑같은 일반 인터페이스를 통해 기본적인 자원에 접근한다.

FeedDataSource의 각 구현은 기초를 이루는 자원 저장 메커니즘(예로 데이터베이스, 파일 시스템)에 의존하여 피드 데이터를 저장하고 찾아온다. Listing 10처럼 FeedDataSource 구현은 파일 시스템에 의존한다.

                    

public class FeedDataSource

  implements DataSource

{

  private File file = null;

  private String contentType = "";

  

  public FeedDataSource(File file, String contentType)

  {

    this.file = file;

    this.contentType = contentType;

  }


  public String getContentType()

  {

    return contentType;

  }


  public InputStream getInputStream()

      throws IOException

  {

    return new FileInputStream(file);

  }


  public String getName()

  {

    return file.getName();

  }


  public OutputStream getOutputStream()

      throws IOException

  {

    return new FileOutputStream(file);

  }


}

Listing 10에서 파일 자원은 FeedDataSource 클래스 내에서 캡슐화된다. 이 클래스는 주어진 파일 자원의 입/출력 기능을 수행한다.

FrontController 서블릿 구현하기

FrontController 서블릿을 구현하여 다양한 컴포넌트, 커넥터, 컨텍스트 클래스와 상호작용함으로써 사용자 에이전트로부터 들어오는 요청을 처리한다. 그리고 나서 서블릿이 나타내는 요청에 적합하면 서블릿은 비즈니스 서비스에서 생성된 자원의 표현 상태와 함께 사용자 에이전트에 응답한다.

Listing 11은 표준 HttpServlet doGet() 메서드를 처리하는 예를 보여준다. 목표를 요청하는 컨텍스트는 추출되고 요청 데이터를 처리하는 서버 컴포넌트를 찾아오는 데 쓰인다.

                    

  protected void doGet(HttpServletRequest request,

                       HttpServletResponse response)

    throws ServletException,

           IOException

  {

    HTTPConnector connector =

      (HTTPConnector)Connectors.getConnector(Protocol.HTTP);

    HTTPServerComponent serverComponent =

      (HTTPServerComponent)connector.addServer(request.getServerPort());


    String contextRootPath = this.getServletContext().getRealPath("/");

    String contextPath = request.getContextPath() + "/"

                         + this.getServletName();

    serverComponent.addContext(contextRootPath, contextPath);


    Representation representation = null;

    

    try

    {

      representation =

        serverComponent.getContext(request,

                                   this).handleGet(new HTTPRequest(request));

    }

    catch (Exception e)

    {

      e.printStackTrace();

      throw new ServletException("Error: " + e);

    }

    

    new HTTPResponse(response).write(representation.getContentType(),

                                     representation.getInputStream());

  }

Listing 11에서 FrontController 클래스의 doGet 메서드는 요청을 받고 처리하는 방법을 보여준다. HTTP 프로토콜의 커넥터는 서버 컴포넌트를 추가하고 찾아오는 데 사용된다. 목표한 자원 컨텍스트 객체는 서버 컴포넌트에서 찾아온다. 그러면 자원 컨텍스트 객체는 GET 요청을 처리하는 데 쓰인다. Resource 표현 객체는 자원 컨텍스트 객체에 의해 반환된다. 그리고 나서 표현 객체는 HTTPResponse 클래스를 사용하여 요청자에 다시 전달된다.

비즈니스 로직 구현하기

BusinessService 클래스를 사용하여 특정 APP 컬렉션의 멤버 자원을 나타내는 모델 데이터를 반환할 비즈니스 로직을 구현한다. BusinessService 클래스는 로직을 구체화한다. 이 때 로직은 특정 컬렉션과 자원 표현에서 컬렉션이나 멤버 자원의 아톰 피드에 적절한 javax.activation.DataHandler 클래스 구현과 javax.activation.DataSource 인터페이스로 작동한다.

Listing 12는 아톰 피드 자원의 컬렉션을 캡슐화하는 비즈니스 서비스의 예를 제공한다.

                    

public class CollectionService

    implements BusinessService

{

  // todo: read RESOURCES_DIR from config or system property

  //

  private static final String RESOURCES_DIR = "resources";


  private String contextRootPath = "";


  private String contextPath = "";


  public CollectionService(String contextRootPath,

                           String contextPath)

  {

    this.contextRootPath = contextRootPath;

    this.contextPath = contextPath;

  }


  protected String getContextPath()

  {

    return contextPath;

  }


  protected String filePathFromRequest(Request httpReq)

  {

    return contextRootPath + RESOURCES_DIR

           + ((HTTPRequest) httpReq).getRequest().getPathInfo();

  }


  protected void writeToFile(Request request,

                             File file,

                             boolean append)

      throws IOException,

        FileNotFoundException

  {

    System.out.println("writeToFile called");


    InputStream inStream = ((HTTPRequest) request).getInputStream();

    byte[] dataBuf = new byte[4096];


    FileOutputStream outStream = new FileOutputStream(file, append);

    int bytesRead = 0;

    while ((bytesRead = inStream.read(dataBuf)) > 0)

    {

      System.out.println("Writing [" + bytesRead + " bytes]");

      outStream.write(dataBuf, 0, bytesRead);

    }


    outStream.flush();

    outStream.close();

  }


  public Representation create(Request request)

      throws ServiceExecutionException

  {

    System.out.println("CollectionService.create()");


    // todo: create feed from structured storage with DAO

    //

    String filePath = filePathFromRequest(request);

    File file = new File(filePath);


    try

    {

      boolean append = false;

      writeToFile(request, file, append);

    }

    catch (Exception e)

    {

      e.printStackTrace();

      throw new ServiceExecutionException(e);

    }


    FeedRepresentation representation = new FeedRepresentation(file);


    return representation;

  }


  public Representation read(Request request)

      throws ServiceExecutionException

  {

    System.out.println("CollectionService.read()");


    // todo: read feed from structured storage with DAO

    //

    String filePath = filePathFromRequest(request);

    File file = new File(filePath);

    if (file.exists() == false)

    {

      throw new ServiceExecutionException("Feed file ["

                                          + filePath + "] does not exist.");

    }


    FeedRepresentation representation = new FeedRepresentation(file);


    return representation;

  }


  public Representation update(Request request)

      throws ServiceExecutionException

  {

    System.out.println("CollectionService.update()");


    // todo: update feed from structured storage with DAO

    //

    String filePath = filePathFromRequest(request);

    File file = new File(filePath);

    FeedRepresentation representation = new FeedRepresentation(file);


    try

    {

      boolean append = (file.exists() ? true : false);

      writeToFile(request, file, append);

    }

    catch (Exception e)

    {

      e.printStackTrace();

      throw new ServiceExecutionException(e);

    }


    return representation;

  }


  public void delete(Request request)

      throws ServiceExecutionException

  {

    System.out.println("CollectionService.delete()");


    // todo: delete feed from structured storage with DAO

    //

    String filePath = filePathFromRequest(request);

    System.out.println("CollectionService.delete() - resolving feed file ["

                       + filePath + "]");

    File file = new File(filePath);

    System.out.println("CollectionService.delete() - feed file resolved");

    if (file.exists())

    {

      System.out.println("CollectionService.delete() - deleting feed file");


      if (file.delete() == false)

      {

        System.out.println("CollectionService.delete() - feed deletion failed");

        throw new ServiceExecutionException("Error deleting feed ["

                                            + filePath + "]");

      }

      System.out.println("CollectionService.delete() - feed deletion succeeded");

    }

    else

    {

      System.out.println("CollectionService.delete() - feed file ["

                         + filePath + "] does not exist");

    }

  }

}

Listing 12는 아톰 피드 자원의 컬렉션을 캡슐화하는 비즈니스 서비스 클래스의 예를 제공한다. 이 클래스는 물리적 파일을 각 피드 자원의 소스로 사용한다. 각 피드 자원에 관한 동작은 "CRUD" 메서드(create, read, update, delete)에 의해 정의된다. 이 동작의 일반적인 추상화는 메서드 서명이나 서비스 인터페이스에 영향을 주지 않고 기초가 되는 물리적 소스를 변경할 수 있도록 한다.

특정 피드 자원의 컬렉션을 나타내는 비즈니스 서비스를 가지고 있다면 이제 사용자 에이전트는 적절한 비즈니스 서비스에 대한 요청을 처리하는 원 서버의 FrontController에 요청을 보낼 수 있다. 비즈니스 서비스는 목표한 자원에서 실행되면서 필요한 비즈니스 로직을 수행한다. 목표 자원은 논리의 명령에 따라 생성, 접근, 갱신, 삭제를 실행한다. 요청에서 발생되는 목표 멤버 자원의 표현 상태는 FrontController 서블릿에 다시 전달된다. 이 서블릿은 필요하다면 HTTP 응답 형태로 사용자 에이전트로 다시 중계된다.

요약하기

REST 는 기존 프로토콜과 표준을 사용하여 데이터나 서비스를 나타내는 자원에서 작동하는 분산 시스템을 만드는 소프트웨어 아키텍처 스타일이자 원칙의 집합이다. REST는 추가적인 시맨틱 레이어나 세션 관리에 의존하지 않고 HTTP 같은 프로토콜에 데이터를 전달하는 프레임워크를 기술하는 데 진화해 왔다.

APP는 데이터나 서비스를 나타내는 자원에 접근, 작성, 수정하는 HTTP 기반 프로토콜이다. APP는 HTTP 프로토콜이 제공하는 표준 동작(GET, PUT, POST, DELETE)을 사용하여 멤버 자원의 컬렉션을 인트로스펙트하고 블로그 엔트리, 이미지, 문서, 달력 엔트리 등을 나타내는 멤버 자원을 조작한다.)

본 튜토리얼에서는 기본 REST와 APP를 다뤘다. 또한 엔터프라이즈 시스템 내에 REST를 적용하는 법을 배웠다. 멤버 자원의 표현 상태와 컨테이너에 접근 및 조작을 수월하게 하기 위해 APP를 사용하여 자바 서블릿 기반 시스템을 통해 HTTP 요청과 응답을 주고 받았다.

필자소개

		Jeff Hanson은 윈도우 오픈독(Windows OpenDoc) 프로젝트의 선임 엔지니어 및 노벨 Route 66 프레임워크의 책임 아키텍트 등을 포함 20년 이상 소프트웨어 업계에서 경력을 쌓아왔다. 현재 Max International에서 CTO로 재직 중이며 웹 서비스, 마이크로 포맷, XML, 자바/J2EE, PHP, 모바일 기술, 윈도우 API를 사용해 시스템을 설계하고 만드는 업무를 담당하고 있다. Jeff는 .NET versus J2EE Web Services: A Comparison of Approaches, Pro JMX: Java Management Extensions, Web Services Business Strategies and Architectures 등 많은 저서와 기사를 쓰고 있다.

2007 년 8 월 21 일

서비스 지향 아키텍처(SOA)는 많은 비즈니스 변형 노력의 중심에 있습니다. 많은 기업들은 점증적으로 SOA로의 변형을 시도하고 있고, 귀중한 레거시 IT 시스템들을 서비스 공급자로서 참여시키고 있습니다. 솔루션 아키텍트는 변형을 도모하는 수단으로서 SOA 인프라스트럭처를 제공해야 할 뿐만 아니라, 기업 중심의 비즈니스 연산들을 강력하고 순응적인 것으로 유지해야 하는 도전에 직면해 있습니다. 여러분의 기업은 SOA의 일부가 될 수 있는 엔터프라이즈 정보 관리 전략을 개발하고 모든 비즈니스 연산에서 전체적인 데이터 및 콘텐트 일관성을 관리해야 합니다. 이와 같은 변화 과정에 대해 알아보고 디자인 전략을 공부해 봅시다.

머리말

여러분의 비즈니스가 거의 비슷하다면, 비즈니스 전략과 핵심 경쟁력 분석은 비즈니스 리엔지니어링과 IT 현대화에 초점을 맞춰야 한다. 일반적인 산물이(엔터프라이즈의 핵심 측면에서 볼 때) 서비스 지향 비즈니스로의 변형 및 SOA에 대한 의존성이다. 비즈니스 연산은 현재 IT 시스템이 재 엔지니어링 되고 서비스 공급자로서 통합되어야 하는 서비스 세트를 중심으로 설계된다. 변형 역시 새로운 서비스 공급자를 도입한다. 목표는 내부 워크플레이스 포털 애플리케이션 또는 인터넷 커머스 애플리케이션 같은 새로운 복합 애플리케이션들을 구현하여 특수한 비즈니스 필요를 채우는 것이다.

이렇게 도전이 되는 변형의 일부로서, 엔터프라이즈는 많은 중요한 비즈니스와 IT 프로그램에 개입되어 있다. 주요한 변형에는 다음이 포함된다.

• 비즈니스 서비스 모델 중심의 엔터프라이즈 아키텍처 정렬.
• 비즈니스 서비스 모델의 관련 부분들을 실현할 수 있는 서비스 기반 IT 인프라스트럭처의 도입.
• 레거시 IT 시스템이 변형, 확장, 래퍼 적용을 통해 서비스 기반 IT 인프라스트럭처로 통합될 수 있도록 함.
• IT 애플리케이션들을 지원하는 효율적이고 유연한 구현을 가능케 하는 강력한 디자인 및 개발 환경 및 딜리버리 프로세스.

이러한 변형의 산물들은 구현상의 문제를 만들어 낸다. 엔터프라이즈는 변형의 의도를 전달하고 변화를 적용하여 유연성을 실현할 수 있는지를 확인해야 한다. 이러한 변형 노력은 다음의 원리를 따른다.

• 엔터프라이즈는 강력하고 순응적인 비즈니스 연산을 제공해야 한다.
• 전체 비즈니스 서비스 모델과 IT 시스템 구현이 변형 원리에 순응할 수 있도록 하는 거버넌스 프로세스와 디자인 권한이 필요하다.
• 엔터프라이즈는 비즈니스와 IT 서비스 관리의 통합적인 뷰를 통해 측정과 응답성 변화가 이루어 질 수 있도록 해야 한다.

일부 엔터프라이즈는 전체 조직에 걸쳐 SOA로 비즈니스 변형을 할 수 있다. 이러한 방식은 기본적인 변형 인도물에 대한 더 큰 도전을 시사하고 있지만, 결과적으로, 부차적인 변형 인도물을 성장시키고 개발하기에는 더 쉽다. 이러한 유형의 시나리오는 엔터프라이즈에 비즈니스 및 IT 변화를 이룩하고자 하는 최고위 간부들이 전략적인 문제를 지원하기로 결정할 때 발생한다.

그러나, 대부분의 엔터프라이즈 변형은 점증적이고 거대하며 전략적이다. 레거시 IT 시스템들은 리엔지니어링 되어, 다른 IT 시스템들을 결합하여 고객 주문 프로세싱을 단순화 하는 등, 새로운 비즈니스 연산 지원에 참여할 수 있어야 한다. 이러한 IT 시스템들은 현재 갖고 있는 모든 또는 대부분의 기능을 계속해서 수행한다. SOA 변형의 범위 밖에서의 비즈니스 연산들도 여전히 지속된다.

변형 시나리오에서, SOA IT 인프라스트럭처에 대해 신중한 구현 디자인을 모색해야 한다. 이러한 IT 시스템 내에서의 데이터 프로세싱은 이 범위 밖에서의 데이터 프로세싱에 영향을 주고, 이 프로세싱에 의해 영향을 받는다. 전체적인 데이터 프로세싱 환경은 전체 비즈니스 연산에 대하 강력함과 순응성을 유지해야 한다.

그림 1의 예제는 세 개의 레거시 시스템들이 서비스 프로바이더가 되도록 엔지니어링 되는 모습을 보여준다

그림 1. 새로운 SOA 환경에서의 레거시 IT
 

그림 1에서, 비즈니스 변형 프로그램이 SOA 인프라스트럭처를 구현했고, 비즈니스 서비스들은 여기에서 퍼블리시 되고 새로운 애플리케이션에 의해 소비될 수 있다. 이러한 인프라스트럭처에는 일반적으로, 소프트웨어 간 다중 프로토콜 연결, 비동기식 및 동기식 메시지 플로우 관리, 메시지 트랜슬레이션, 규칙 실행, 프로세스 구성법을 실행하는 미들웨어가 포함된다. 이러한 서비스들을 사용하는 복합 애플리케이션들이 구현되었고, 레거시 시스템들은 새로운 서비스들을 호출함으로써 강화되었다.

SOA에서의 프로세스와 정보 아키텍처

SOA 인프라스트럭처를 구현하기 위해, 비즈니스 서비스 모델(business service model)이 생성, 관리, 향상된다. IBM® Service Oriented Modeling and Architecture (참고자료) 같은 기술들은 이러한 모델을 개발하는데 사용된다. 전형적인 엔터프라이즈에서, top-down 분석, bottom-up 분석, 목표 서비스 모델링이 포함된다. 변형의 목표는 새로운 비즈니스 연산과 지원하는 IT 애플리케이션들의 구현을 실행하는데 사용되는 프로세스 및 정보 아키텍처로 귀결된다.

• 프로세스 아키텍처는 엔터프라이즈 연산을 받치고 있는 비즈니스 프로세스를 형성하기 위해 결합될 수 있는 액션의 기능적 계층이다. 인간 대 시스템, 시스템 대 시스템의 플로우 컨트롤을 책임진다. 예를 들어, 고객이 제품 주문을 하고 그 제품의 전달을 기다리는 상태가 되는 동안 필요한 액션들이 포함된다.
• 정보 아키텍처는 엔터프라이즈 연산에 상태와 의미를 제공하기 위해 액세스, 조작, 저장되는 관련 데이터 및 콘텐트 세트이다. 데이터 및 콘텐트의 정보 관리를 수행한다. 단순한 액세스 이벤트나 프로세스 플로우 정황이든 상관이 없다. 제품 개발 라이프 사이클 동안 소비 및 생성되는 데이터와 콘텐트가 하나의 예이다.

프로세스와 정보 아키텍처 뷰포인트는 프로세스-데이터(CRUD) 매트릭스 같은 것을 통해서 개발 및 제시된다. 이들은 서비스 아키텍처를 구성하는 많은 서비스들을 정의한다. 서비스는 메시지 데이터가 전달된 곳에서 호출되는 연산 세트이다. 서비스 구현은 영속 스토리지나 액세스를 사용하여 데이터나 콘텐트를 조작하는 프로세싱을 수행하고 결과를 리턴한다. 서비스는 동기식 및 비동기식으로 사용될 수 있고, 호출은 통합 인프라스트럭처에 의해 일반적으로 중재된다. 완전히 분리된 시스템에서, 일부 서비스들은 변경 사항들이 상태를 처리하도록 한다. (예를 들어, 요청된 정보가 제공될 때, 고객 X에 대한 새로운 주소의 유효성 검사가 수행된다.) 다른 서비스들은 정보 상태가 바뀌도록 하면서, 데이터와 콘텐트가 향후 서비스 이벤트가 의존할 수 있는 원하는 상태가 되도록 조작한다. (예를 들어, 새로운 선적 주소가 고객 X에 적용된다.)

레거시 데이터 프로세싱 문제

레거시 IT 시스템들은 의심할 여지 없이 엔터프라이즈의 서비스 공급자 구현의 일부이고 SOA 인프라스트럭처로 통합된다. 레거시에는 전통적인 메인프레임 프로세싱 뿐만 아니라, 엔터프라이즈 리소스 플래닝(ERP) 애플리케이션, 내/외부 웹 애플리케이션, 워크플로우 애플리케이션, 스캐닝 및 프린팅 시스템 등이 포함된다. 이러한 레거시 시스템들이 사용되고 서비스-공급자 구현으로 결합되기 위해서는 많은 일들이 발생할 수 있다.

• 프로세싱 함수는 노출되고 액세스 되어 서비스 공급자 구현에 결합된다. 이는 CICS® 트랜잭션의 SOAP 래퍼처럼, 새로운 프로토콜과 호출 메커니즘을 통해 트랜잭션을 노출하는 것을 의미한다.
• 함수들은 트랜잭션을 노출할 때 프로세싱 무결성을 관리하도록 리엔지니어링 되어야 한다. 트랜잭션은 기존에 존재했던 것 또는 한 개 이상의 기존 트랜잭션을 호출하기 위해 생성되어야 한다. 서비스 세분성 전략은 그러한 서비스의 호출 디자인에 영향을 미친다.
• 특정 프로세싱 함수는 데이터 프로세싱이 서비스 공급자 구현을 통해 호출되는 새로운 함수에 의해 수행되기 때문에 스위치를 꺼야 한다.
• 기존 액세스 권한과 보안 및 감사 요구 사항들은 새로운 액세스 메커니즘을 위해 실행되어야 한다.
• 기존 시스템의 서비스 품질(Quality of Service (QoS)) 기준은 확장 또는 보충되어야 한다. 예를 들어, 오프라인 일괄 프로세싱 윈도우는 대리 프로세싱 솔루션에 의해 다루어져야 한다.
• SOA는 기존 시스템에 새롭고 예측할 수 없는 부하를 가져오는데, 이는 기존 프로세스에 부정적인 영향을 미친다.

레거시 IT 시스템들이 SOA에 참여하고자 하는 노력으로 노출될 때, 변형의 범위 밖에서 비즈니스 연산을 지원하는 특정 함수들이 데이터 프로세싱을 지속한다. 여기에는 일반적으로 데이터 동시성과 동기화 문제를 이해하고 다룰 수 있어야 한다.

사용자는 계속해서 원래의 애플리케이션 수단을 사용하여 레거시 IT 시스템을 호출한다. 주로 사용자 인터페이스(메인프레임 터미널 또는 애플리케이션의 UI)를 통해서 호출한다. SOA는 SOA 생태계 주위로 흐르는 메시지를 기술하기 위해 사용되는 데이터 스키마에 의존한다. 이러한 데이터 스키마들은 서비스 연산의 협업 세트 내에서 통합되는 물리적인 데이터 메시지로서 실현된다. 여기에는 런타임 데이터 트랜슬레이션, 의미 매핑, 또는 메시지 데이터의 추가 등이 포함된다. 데이터는 기반 레거시 IT 시스템에 의해 사용 및 처리된다.

SOA에서 실행될 수 있는 프로세스 세트는 특정 상태로 되어 있어야 하는 데이터와 콘텐트에 의존한다. SOA 함수와 레거시 IT 시스템들을 통한 병렬 프로세싱은 상태 모델에 불안정하게 만들 뿐이다.

그림 1의 예제에서, 변형은 고객의 보험 정책을 설정하고 관리하는 단순한 프로세싱 기능을 갖고 있는 새로운 인터넷 애플리케이션을 실행했다. 이 새로운 애플리케이션들은 고객과의 연락을 실행하고 보험 정책이 갱신될 때 갱신 처리를 제공한다. 하지만, SOA 범위 밖에 있는 기존 비즈니스 연산들은 문제를 일으킬 수 있다. 고객들은 거주지를 옮겼던 경로에 따라 회사에 공지할 수 있는 수단이 있다. 새로운 인터넷 애플리케이션을 통해 정책이 처음 구매되었더라도, 고객은 SOA 애플리케이션을 사용하여 회사에 주소 변경을 알리지 않고, 대신 편지를 보낼 수 있다. 백 오피스(back- office) 프로세스는 고객의 새로운 주소가 고객 관리(CRM) 시스템에만 적용되도록 한다. 기존의 CRM 시스템의 일괄 프로세싱이 Insurance Contract Administration 시스템을 고객 데이터로 업데이트 한다. 새로운 SOA 기반 시스템은 거의 실시간 트랜잭션으로 설계되므로, 데이터 동기화 타이밍 문제가 발생한다. 새로운 애플리케이션은 오래된 주소의 갱신에 대해 고객과 연락을 시도할 수 있고, 응답 및 콘텍스트 인식 SOA 애플리케이션이 새로운 주소에 있는 사람에게 연락하여 오래된 정책을 취소하고 새로운 정책을 설정한다

서비스 공급자

SOA 아키텍트의 역할은 서비스 실행 인프라스트럭처의 디자인과 구현과 관련되어 있다. SOA 모델링 기술은 프로세스와 정보 아키텍처가 소비할 서비스를 결정하고, 서비스 공급자와 연락하고, 프로세싱 실행과 데이터 프로세싱의 일부로서 서비스 연산을 호출하는 애플리케이션을 구현할 수 있게 도와준다. 서비스 소비자는 동의된 계약에 따라 데이터를 처리하고 관리하는 한 서비스 공급자가 서비스를 구현하는 방식은 신경 쓰지 않는다.

특정 시나리오에서, 모델이 작동한다. 특히, 여러분이 서비스 공급자 구현을 기업 외부에서 아웃소싱 했을 경우에 그렇다. 이 글에서는 오늘날 많은 기업들이 SOA를 채택하면서 겪게 되는 특수하지만 공통적인 시나리오에 초점을 맞춘다.

현실은, SOA 변형에서 전체적인 솔루션 아키텍트는 많은 책임을 갖고 있고, 특히 점증적인 변형을 해야 하는 기업의 경우 특히 그렇다. 이러한 책임은 기업 거버넌스 프로세스의 영역 안에서 수행된다. ("SOA 거버넌스" [developerWorks, 2005년 8월]).

우선, 솔루션 아키텍트는 SOA 인프라스트럭처의 디자인과 구현에 관련되어 있다. 여기에는 서비스 공급자 구현의 일부를 형성하는 소프트웨어 시스템으로서 작동할 레거시 IT 시스템을 구분하는 것이 포함된다. 두 번째, 솔루션 아키텍트는 서비스 소비 애플리케이션을 조합할 수 있는 개발 프로세스와 환경을 제공한다. 여기에는 디자인 패턴과 표준, 툴링 환경이 포함된다. 셋째, 솔루션 아키텍트는 비즈니스와 IT 아키텍처를 구성할 수 있어야 한다. 비즈니스 아키텍트는 기능과 콘트랙트와 관련하여 비즈니스 전략을 짜야 한다. IT 아키텍처는 전체적인 비즈니스 연산을 지원하는데 필요한 IT 시스템을 제공할 것이다. 대형 엔터프라이즈 내에서, 이는 전략적 애플리케이션의 대형 포트폴리오가 된다

디자인 전략

전체적인 엔터프라이즈 순응성을 실행하는 강력한 정보 관리 아키텍처를 구현하기 위해서는 이 문제를 다룰 많은 디자인 전략과 원리를 생각해야 한다.

비즈니스 프로세스 분석에 있어서 범위 변경 계획

변형 프로그램 동안, 일반적으로 시스템 분석과 디자인이 바람직하지 못한 데이터 프로세싱 시나리오를 발견하게 된다. 이전에 범위에서 벗어났던 비즈니스 연산들은 다시 범위로 가져와서 새로운 시스템을 수용할 수 있도록 수정될 수 있다. 새로운 SOA 기반 시스템들은 고객 상세를 업데이트 하는 추가 프로세싱 단계 같은 변화된 비즈니스 연산을 위해 내부 애플리케이션을 제공해야 한다.

레거시 엔터티 변화를 퍼블리시 및 등록하기

동의된 엔터티와 애트리뷰트 데이터가 서비스 공급자로서 참여하는 레거시 IT 시스템에서 변화될 때, 추가 프로세싱은 SOA에 알리도록 개발되어야 한다. 이상적으로 이것은 실시간으로 되어야 하지만, 스케줄링이 된 일괄 액티비티가 된다. 데이터 기록이 바뀔 때 탐지하는 레거시 IT 시스템으로 계측 코드를 적용하는 데는 비용이 많이 들고, 오래되고 구조가 형편없는 애플리케이션 코드에서는 거의 불가능 하다.

엔터프라이즈가 수행해야 하는 한 가지는 레거시 시스템이 소유한 데이터와 관련 당사자에게 변화를 공지하는 시스템 기능을 평가하는 것이다. SOA에 중요한 데이터가 자주 변하고 이것이 레코드 레벨 이벤트 트리거를 생성하는 시스템의 무능력과 결합한다면 레거시 시스템의 리엔지니어링 또는 대체를 다시 고려해야 한다. 비즈니스 서비스의 QoS는 계획된 엔지니어링 노력으로 정렬되어야 한다 핵심 서비스 데이터의 일괄 프로세싱에서 실시간 메시지 중심 프로세싱으로 옮기는 것 같은, 엔지니어링 향상을 통해, QoS가 시간이 흐르면서 향상되고 있다는 것을 나타내야 한다.

정보 서비스 쿼리 facade

정보 관리 서비스는 데이터 또는 콘텐트에 적용될 수 있는 단순한 액션들을 나타내야 한다. 쿼리 facade는 정보가 액세스 되고 조작되는 방법을 숨기고, 물리적 IT 시스템들이 얼마나 많이 있는지도 숨긴다. 기본적으로, 쿼리 facade는 데이터 통합을 이룩하기 위해 두 개의 패턴을 구현할 수 있다. 엔터프라이즈 내에 다양한 시나리오와 레거시 시스템들 때문에 서비스를 구현하는데 이 두 가지가 사용될 것이다.

• 데이터를 쿼리로 가져오기. 천천히 변하는 정보를 데이터 스토어(웨어하우스)로 가져오고, 그곳에서 데이터에 대해 작동한다. Extract, Transform, Load (ETL) 기술들이 여기에서 사용될 수 있다.
• 쿼리를 데이터로 가져오기. 빠르게 변화하는 트랜잭션 데이터의 경우, 액션은 이를 조작할 수 있는 물리적 소스로 가야 한다. 커넥터와 어댑터 기술을 사용하여 액세스 할 수 있다. (읽기 및 업데이트)

SOA 내에서, 실제 쿼리 facade는 federation과 population (참고자료 섹션의 데이터 통합 애플리케이션 패턴 참조) 같은 다양한 패턴들을 사용하여 구현되고, Service Data Objects와 Data Access Services (참고자료) 같은 기술을 사용하여 구현된다. 다양한 서비스 구현을 위한 전체적인 디자인 패턴("서비스 지향 아키텍쳐와 통합을 위한 패턴 언어, Part 1" [한국 developerWorks, 2005년 7월])은 이러한 결정에 영향을 미친다. 하지만, 이러한 문제 공간에서, 구현 디자인은 확장되어 서비스를 더욱 지능적인 것으로 만든다. 엔터티 데이터 변경 사항을 퍼블리시 하는 레거시 시스템을 위한 솔루션이 정비된 상황에서(QoS), 정보 시스템은 변경 사항을 등록하고 변경 사항들을 각각의 물리적 시스템에 적용해야 한다.

이것은 엔터티 결정을 완성하는 아키텍처의 장소이다. 어떤 레거시 IT 시스템이 마스터로 간주되어야 할까? 여기에서 마스터 데이터 관리 기술은 구현을 도울 수 있고, 옵션과 결정들은 레거시 시스템의 통합 기능과 균형을 맞추어서 아키텍처 정의의 중요한 부분이 되어야 한다.

비즈니스 규칙 배치

SOA로의 변형에는 통합 미들웨어와 새로운 복합 애플리케이션들을 포함하고 있는 새로운 IT 인프라스트럭처가 도입된다. 비즈니스 규칙들은 하나의 애플리케이션 안에서만 더 이상 제한되지 않는다. 상태는 비즈니스 규칙의 실행을 통해 효과적으로 관리된다. 정보 관리 디자인을 개발하는 것의 일환으로 비즈니스 규칙 로직의 유형과 위치가 이해되어야 한다.

SOA 내에서 비즈니스 규칙의 유형에는 다음이 포함된다.

• 참조 무결성 규칙
• 애플리케이션 작동 규칙
• 크로스 애플리케이션 통합 규칙
• 트랜잭션 프로세싱 비즈니스 로직 규칙
• 저장 프로시저 같은 데이터 엔터티 프로세싱 규칙

전략은 비즈니스 규칙을 다시 만드는 것이 아닌 재사용이 되어야 한다. SOA의 도입으로 기존의 비즈니스 규칙과 새로운 비즈니스 규칙을 실행하는 것을 신중하게 생각해야 한다. 규칙 로직 그 자체는 특정 프로세싱 시나리오를 위해 무결성을 관리하기 위해 호출될 수 있는 서비스로서 노출되어야 한다.

잠재적인 디자인 전략 영향

이와 같은 디자인 결정에 다다르면 여러분이 고려해야 하는 솔루션에 미치는 영향은 다음과 같다.

• 더블-키 프로세싱. SOA의 도입으로 인해 하나의 비즈니스 영역에서 얻어진 효율성은 추가 데이터 엔트리 태스크(그리고 데이터 엔트리 에러의 위험)에 비례하여 균형이 맞춰져야 한다. 하지만, 이것은 데이터-동기화 타이밍 시나리오를 대처하기 위한 유일한 옵션이다. 이러한 시나리오는 보통 가볍게 취해진다. 엔터프라이즈는 밤마다 수행되는 일괄 업데이트의 시간 지연을 피하기 위해 이벤트 중심 더블 키(keying)를 수행하는 인원수를 확립해야 한다. 데이터 동기화를 보조할 시스템에서 자동화된 인터페이스를 개발하는 비용도 계산해야 한다. 자동화된 인터페이스를 구현하는데 필요한 시간이 전체적인 딜리버리 타임 스케일을 구성하는지 여부도 평가해야 한다.
• 불필요한 피드백 루프. CRM 시스템에서의 고객 기록 업데이트는 SOA로의 수동 또는 자동 호출로 이어져서 영역 KR의 고객 데이터 변경에 대해 다른 애플리케이션에 알려야 한다. 고객을 업데이트 하려면, SOA는 정보 서비스를 호출하고, 이는 그 자체로 원래의 CRM 시스템을 호출하고 고객 데이터를 업데이트 한다. 정보 서비스 아키텍처는 사용 모델에 기반하여 업데이트 고객의 다른 스타일을 구현해야 한다.
• 범위 이동. SOA 범위가 정의될 때, 레거시 IT 시스템에 대한 지식의 부족과 프로세스 및 정보 관리 기능도 변하게 된다. 서비스 모델의 파생은 레거시 분석을 이끌어 내고, 보다 미묘한 SOA 인프라스트럭처 구현이 필요하다는 것을 드러낸다. 전체적인 비즈니스 서비스와 엔지니어링 프로그램의 전체 범위를 정의하기 전에 단계를 플래닝 해야 한다.

결론

이 글에서는 SOA로의 성공적인 비즈니스 변형 프로그램을 제공하는 것에 초점을 맞추었다. SOA로의 비즈니스 변형의 문제는 매우 많다. 대부분의 기업들은 새로운 복합 애플리케이션들이 구현될 수 있는 SOA 인프라스트럭처를 도입함으로써 점증적인 변형을 시도하고 있다. 이들은 레거시 IT 시스템들을 사용하여 서비스 공급자를 구현한다.

강력하고 순응적인 연산을 기업이 유지하려면, 변형 프로그램은 엔터프라이즈 정보 관리 솔루션을 개발해야 한다. 이 솔루션은 SOA에서의 레거시 IT 시스템들에서 데이터의 일관성과 동기화 문제를 다루어서 정보 서비스들이 안전하게 노출될 수 있도록 해야 한다.

SOA 변형을 제공하는 책임이 있는 솔루션 아키텍트는 전체적인 엔터프라이즈 아키텍처 및 예산의 정황 속에서 SOA의 필요와 레거시 IT 시스템의 기능에 균형을 맞춰야 한다. 데이터 통합을 위한 기술과 주 데이터 관리는 정보 관리 솔루션을 위한 구현 전략에 포함된다

감사의 말

이 글을 검토해 준 Rick Robinson, Patrick Dantressangle, Bob Lojek, Claudio Cozzi에 감사의 말을 전하고 싶다.

참고자료

교육

• Ali Arsanjani의 기술자료, "서비스 지향 모델링과 아키텍쳐 (한글)" (한국 developerWorks, 2004년 11월) : SOA 서비스의 정의, 특성화, 구현 방법.
• Tilak Mitra의 기술자료 "SOA 거버넌스" (developerWorks, 2005년 8월)
• 데이터 통합 애플리케이션 패턴: IBM Patterns for e-business 사이트.
• "Service Data Objects 소개" (developerWorks, 2004년 9월): Bertrand Portier와 Frank Budinsky의 Service Data Objects를 활용한 차세대 데이터 프로그래밍 소개.
• Service Data Objects 스팩.
• Ali Arsanjani의 기술자료 "서비스 지향 아키텍쳐와 통합을 위한 패턴 언어, Part 1: 서비스 생태계 구현하기 (한글)" (한국 developerWorks, 2005년 7월) : 이 시리즈에서 이들의 사용법과 관련된 패턴과 경험들을 나눌 것이다. 또한 SOA와 SOI의 마이그레이션, 모델링, 디자인, 구현과 관련된 문제에 대한 솔루션도 모색해 볼 것이다.
• developerWorks 기술 이벤트와 웹캐스트.
• IBM SOA 웹사이트
• 한국 developerWorks의 SOA와 웹서비스 존
• Safari bookstore.

제품 및 기술 얻기

• IBM 시험판 소프트웨어를 다운로드하여 차기 개발 프로젝트에 활용해보라(다운로드 또는 DVD)

토론

• 포럼에 참여하기.
• developerWorks 블로그와 커뮤니티 참여하기.

필자소개