Ejb and JDBC : JDBC EJB « Database SQL JDBC « Java





Ejb and JDBC

/*

MySQL and Java Developer's Guide

Mark Matthews, Jim Cole, Joseph D. Gradecki
Publisher Wiley,
Published February 2003, 
ISBN 0471269239

*/


import java.awt.BorderLayout;
import java.awt.GridLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.util.Enumeration;
import java.util.StringTokenizer;
import java.util.Vector;

import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JMenu;
import javax.swing.JMenuBar;
import javax.swing.JMenuItem;
import javax.swing.JOptionPane;
import javax.swing.JPanel;
import javax.swing.JPasswordField;
import javax.swing.JTextField;
import javax.swing.border.TitledBorder;

public class TaskManager extends JFrame {
  TaskManager(Tasks taskList) {
    super("MySQL-Java Task Manager");

    this.taskList = taskList;

    buildGui();

    pack();
    setVisible(true);
  }

  private void buildGui() {
    fileMenu.add(fileExit);
    menuBar.add(fileMenu);
    setJMenuBar(menuBar);

    frameContainer.setLayout(new BorderLayout());
    frameContainer.add(new TaskPanel(taskList));
    setContentPane(frameContainer);

    addWindowListener(new WindowHandler());
    fileExit.addActionListener(new MenuHandler());
  }

  private JPanel frameContainer = new JPanel();

  private JMenuBar menuBar = new JMenuBar();

  private JMenu fileMenu = new JMenu("File");

  private JMenuItem fileExit = new JMenuItem("Exit");

  private Tasks taskList;

  class WindowHandler extends WindowAdapter {
    public void windowClosing(WindowEvent we) {
      System.exit(0);
    }
  }

  class MenuHandler implements ActionListener {
    public void actionPerformed(ActionEvent ae) {
      if (ae.getActionCommand().equals("Exit")) {
        System.exit(0);
      }
    }
  }

  public static void main(String[] args) {
    String configFileName = "tasks.conf";

    if (args.length == 1) {
      configFileName = args[0];
    }

    File configFile = new File(configFileName);

    if (!configFile.exists() || !configFile.canRead()) {
      System.err.println("Can't read config file '" + configFileName
          + "'");
      System.exit(1);
    }

    FileReader configReader = null;

    try {
      configReader = new FileReader(configFile);
    } catch (FileNotFoundException fnfX) {
    }

    Tasks taskList = new Tasks(configReader);

    try {
      configReader.close();
    } catch (IOException ioX) {
    }

    TaskManager ex = new TaskManager(taskList);
  }
}

interface TaskDelegate {
  public boolean execute(Connection conn);
}

class TaskPanel extends JPanel {
  public TaskPanel(Tasks taskList) {
    this.taskList = taskList;

    setLayout(new BorderLayout());

    connPane = new ConnectionPane();
    connPane.setBorder(new TitledBorder("Connection Data"));

    taskPane = new TaskPane();
    taskPane.setBorder(new TitledBorder("Tasks"));

    add(connPane, BorderLayout.NORTH);
    add(taskPane, BorderLayout.SOUTH);
  }

  private Tasks taskList;

  private ConnectionPane connPane;

  private TaskPane taskPane;

  class ConnectionPane extends JPanel {
    ConnectionPane() {
      setLayout(new GridLayout(5, 2));

      add(hostNameLabel);
      add(hostNameField);
      add(dbNameLabel);
      add(dbNameField);
      add(portNumberLabel);
      add(portNumberField);
      add(usernameLabel);
      add(usernameField);
      add(passwordLabel);
      add(passwordField);
    }

    ConnectionData getConnectionData() {
      String password = new String(passwordField.getPassword());

      ConnectionData data = new ConnectionData(hostNameField.getText(),
          dbNameField.getText(), portNumberField.getText(),
          usernameField.getText(), password);

      return (data);
    }

    private JLabel hostNameLabel = new JLabel("Host Name:");

    private JLabel dbNameLabel = new JLabel("Database Name:");

    private JLabel portNumberLabel = new JLabel("Port Number:");

    private JLabel usernameLabel = new JLabel("Username:");

    private JLabel passwordLabel = new JLabel("Password:");

    private JTextField hostNameField = new JTextField(20);

    private JTextField dbNameField = new JTextField(20);

    private JTextField portNumberField = new JTextField("3306", 6);

    private JTextField usernameField = new JTextField(20);

    private JPasswordField passwordField = new JPasswordField(20);
  }

  class TaskPane extends JPanel {
    TaskPane() {
      int taskCount = TaskPanel.this.taskList.getTaskCount();

      int rows = ((taskCount % COLS) == 0) ? (taskCount / COLS)
          : ((taskCount / COLS) + 1);

      setLayout(new GridLayout(rows, COLS));

      taskButtons = new JButton[taskCount];

      TaskHandler handler = new TaskHandler();

      Enumeration tasks = taskList.getTasks();

      int task = 0;

      while (tasks.hasMoreElements()) {
        TaskDefinition taskDef = (TaskDefinition) (tasks.nextElement());

        if (!taskDef.isEnabled()) {
          continue;
        }

        String taskName = taskDef.getName();
        taskButtons[task] = new JButton(taskName);
        taskButtons[task].addActionListener(handler);
        add(taskButtons[task++]);
      }
    }

    private JButton[] taskButtons;

    final static int COLS = 2;
  }

  class TaskHandler implements ActionListener {
    public void actionPerformed(ActionEvent ae) {
      ConnectionData connData = connPane.getConnectionData();

      Connection conn = connData.buildConnection();

      if (conn == null) {
        String msg = "Could not build connection. Check provided\n"
            + "connection data and verify server availability.";
        JOptionPane.showMessageDialog(TaskPanel.this, msg,
            "Connection Failure", JOptionPane.ERROR_MESSAGE);

        return;
      }

      String taskName = ae.getActionCommand();

      Enumeration tasks = taskList.getTasks();

      boolean dispatched = false;

      while (tasks.hasMoreElements()) {
        TaskDefinition taskDef = (TaskDefinition) (tasks.nextElement());

        if (!taskDef.isEnabled()) {
          continue;
        }

        if (taskName.equals(taskDef.getName())) {
          try {
            Class delegateClass = taskDef.getDelegate();
            Object delegateObject = delegateClass.newInstance();
            TaskDelegate delegate = (TaskDelegate) delegateObject;

            dispatched = delegate.execute(conn);

            if (!dispatched) {
              String msg = "Could not execute task: "
                  + taskDef.getName();
              JOptionPane.showMessageDialog(TaskPanel.this, msg,
                  "Task Failure", JOptionPane.ERROR_MESSAGE);
            }
          } catch (InstantiationException iX) {
            String msg = "Failed to instantiate delegate for task: "
                + taskDef.getName();
            JOptionPane.showMessageDialog(TaskPanel.this, msg,
                "Task Failure", JOptionPane.ERROR_MESSAGE);
          } catch (IllegalAccessException iaX) {
            String msg = "Cound not access delegate for task: "
                + taskDef.getName();
            JOptionPane.showMessageDialog(TaskPanel.this, msg,
                "Task Failure", JOptionPane.ERROR_MESSAGE);
          }

          break;
        }
      }

      if (!dispatched) {
        try {
          conn.close();
        } catch (SQLException sqlX) {
        }
      }
    }
  }
}

class ConnectionData {
  public ConnectionData(String hostName, String dbName, String port,
      String username, String password) {
    this.hostName = hostName;
    this.dbName = dbName;
    this.port = port;
    this.username = username;
    this.password = password;
  }

  public String getUsername() {
    return (username);
  }

  public String getPassword() {
    return (password);
  }

  public String getUrl() {
    String url = "jdbc:mysql://" + hostName + ":" + port + "/" + dbName;

    return (url);
  }

  public Connection buildConnection() {
    try {
      Class.forName("com.mysql.jdbc.Driver");
    } catch (ClassNotFoundException cnfX) {
      cnfX.printStackTrace(System.err);
      return (null);
    }

    try {
      Connection conn = DriverManager.getConnection(getUrl(),
          getUsername(), getPassword());

      return (conn);
    } catch (SQLException sqlX) {
      System.out.println(SqlExceptionReader.readException(sqlX));
      return (null);
    }
  }

  private String hostName;

  private String dbName;

  private String port;

  private String username;

  private String password;
}

class SqlExceptionReader {
  public static String readException(SQLException sqlX) {
    StringBuffer msg = new StringBuffer(1024);
    SQLException nextX;
    int exceptionNumber = 0;

    do {
      ++exceptionNumber;

      msg.append("Exception " + exceptionNumber + ": \n");
      msg.append("  Message: " + sqlX.getMessage() + "\n");
      msg.append("  State  : " + sqlX.getSQLState() + "\n");
      msg.append("  Code   : " + sqlX.getErrorCode() + "\n");
    } while ((nextX = sqlX.getNextException()) != null);

    return (msg.toString());
  }
}

class Tasks {
  public Tasks(InputStreamReader taskS) {
    readTasks(taskS);
  }

  public int getTaskCount() {
    return (taskDefs.size());
  }

  public Enumeration getTasks() {
    return (taskDefs.elements());
  }

  private void readTasks(InputStreamReader taskS) {
    try {
      BufferedReader reader = new BufferedReader(taskS);

      String taskLine;

      while ((taskLine = reader.readLine()) != null) {
        addTaskDefinition(taskLine);
      }
    } catch (IOException ioX) {
      System.err.println("Failed to fully parse task file: " + ioX);
    }
  }

  private void addTaskDefinition(String taskLine) {
    StringTokenizer taskTok = new StringTokenizer(taskLine, DELIM);

    if (taskTok.countTokens() != TOKEN_NUM) {
      System.err.println("Invalid task definition: " + taskLine);
      return;
    }

    Class taskClass = null;
    String taskClassName = taskTok.nextToken();

    try {
      taskClass = Class.forName(taskClassName);
    } catch (ClassNotFoundException cnfX) {
      System.err.println("Class '" + taskClassName + "' not found: "
          + cnfX);
      return;
    }

    boolean taskEnabled = false;

    if (taskTok.nextToken().equalsIgnoreCase("enabled")) {
      taskEnabled = true;
    }

    String taskName = taskTok.nextToken();

    TaskDefinition def = new TaskDefinition(taskName, taskClass,
        taskEnabled);

    taskDefs.add(def);
  }

  private Vector taskDefs = new Vector();

  final static int TOKEN_NUM = 3;

  final static String DELIM = ":";
}

class TaskDefinition {
  public TaskDefinition(String name, Class delegate, boolean enabled) {
    this.name = name;
    this.delegate = delegate;
    this.enabled = enabled;
  }

  public String getName() {
    return (name);
  }

  public Class getDelegate() {
    return (delegate);
  }

  public boolean isEnabled() {
    return (enabled);
  }

  private String name;

  private Class delegate;

  private boolean enabled;
}

           
       










JdbcEjb.zip( 35 k)

Related examples in the same category