|
/*
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)