PostgreSQL/src/interfaces/jdbc/example/ImageViewer.java

package example;

import java.awt.*;
import java.awt.event.*;
import java.io.*;
import java.sql.*;
import org.postgresql.largeobject.*;

/**
 * This example is a small application that stores and displays images
 * held on a postgresql database.
 *
 * Before running this application, you need to create a database, and
 * on the first time you run it, select "Initialise" in the "PostgreSQL"
 * menu.
 *
 * Important note: You will notice we import the org.postgresql.largeobject
 * package, but don't import the org.postgresql package. The reason for this is
 * that importing postgresql can confuse javac (we have conflicting class names
 * in org.postgresql.* and java.sql.*). This doesn't cause any problems, as
 * long as no code imports org.postgresql.
 *
 * Under normal circumstances, code using any jdbc driver only needs to import
 * java.sql, so this isn't a problem.
 *
 * It's only if you use the non jdbc facilities, do you have to take this into
 * account.
 *
 * Note: For PostgreSQL 6.4, the driver is now Thread safe, so this example
 * application has been updated to use multiple threads, especially in the
 * image storing and retrieving methods.
 */

public class ImageViewer implements ItemListener
{
  Connection db;
  Statement stat;
  LargeObjectManager lom;
  Frame frame;
  Label label;		// Label used to display the current name
  List list;		// The list of available images
  imageCanvas canvas;	// Canvas used to display the image
  String currentImage;	// The current images name
  
  // This is a simple component to display our image
  public class imageCanvas extends Canvas
  {
    // holds the image
    private Image image;
    
    // holds the background buffer
    private Image bkg;
    
    // the size of the buffer
    private Dimension size;
    
    public imageCanvas()
    {
      image=null;
    }
    
    public void setImage(Image img)
    {
      image=img;
      repaint();
    }
    
    // This defines our minimum size
    public Dimension getMinimumSize()
    {
      return new Dimension(400,400);
    }
    
    public Dimension getPreferedSize()
    {
      return getMinimumSize();
    }
    
    public void update(Graphics g)
    {
      paint(g);
    }
    
    /**
     * Paints the image, using double buffering to prevent screen flicker
     */
    public void paint(Graphics gr)
    {
      Dimension s = getSize();
      
      if(size==null || bkg==null || !s.equals(size)) {
	size = s;
	bkg = createImage(size.width,size.height);
      }
      
      // now set the background
      Graphics g = bkg.getGraphics();
      g.setColor(Color.gray);
      g.fillRect(0,0,s.width,s.height);
      
      // now paint the image over the background
      if(image!=null)
	g.drawImage(image,0,0,this);
      
      // dispose the graphics instance
      g.dispose();
      
      // paint the image onto the component
      gr.drawImage(bkg,0,0,this);
      
    }
    
  }
  
  public ImageViewer(Frame f,String url,String user,String password) throws ClassNotFoundException, FileNotFoundException, IOException, SQLException
  {
    frame = f;
    
    MenuBar mb = new MenuBar();
    Menu m;
    MenuItem i;
    
    f.setMenuBar(mb);
    mb.add(m = new Menu("PostgreSQL"));
    m.add(i= new MenuItem("Initialise"));
    i.addActionListener(new ActionListener() {
      public void actionPerformed(ActionEvent e) {
	ImageViewer.this.init();
      }
    });
    
    m.add(i= new MenuItem("Exit"));
    ActionListener exitListener = new ActionListener() {
      public void actionPerformed(ActionEvent e) {
	ImageViewer.this.close();
      }
    };
    m.addActionListener(exitListener);
    
    mb.add(m = new Menu("Image"));
    m.add(i= new MenuItem("Import"));
    ActionListener importListener = new ActionListener() {
      public void actionPerformed(ActionEvent e) {
	ImageViewer.this.importImage();
      }
    };
    i.addActionListener(importListener);
    
    m.add(i= new MenuItem("Remove"));
    ActionListener removeListener = new ActionListener() {
      public void actionPerformed(ActionEvent e) {
	ImageViewer.this.removeImage();
      }
    };
    i.addActionListener(removeListener);
    
    // To the north is a label used to display the current images name
    f.add("North",label = new Label());
    
    // We have a panel to the south of the frame containing the controls
    Panel p = new Panel();
    p.setLayout(new FlowLayout());
    Button b;
    p.add(b=new Button("Refresh List"));
    b.addActionListener(new ActionListener() {
      public void actionPerformed(ActionEvent e) {
	ImageViewer.this.refreshList();
      }
    });
    p.add(b=new Button("Import new image"));
    b.addActionListener(importListener);
    p.add(b=new Button("Remove image"));
    b.addActionListener(removeListener);
    p.add(b=new Button("Quit"));
    b.addActionListener(exitListener);
    f.add("South",p);
    
    // And a panel to the west containing the list of available images
    f.add("West",list=new List());
    list.addItemListener(this);
    
    // Finally the centre contains our image
    f.add("Center",canvas = new imageCanvas());
    
    // Load the driver
    Class.forName("org.postgresql.Driver");
    
    // Connect to database
    db = DriverManager.getConnection(url, user, password);
    
    // Create a statement
    stat = db.createStatement();
    
    // Also, get the LargeObjectManager for this connection
    lom = ((org.postgresql.Connection)db).getLargeObjectAPI();
    
    // Now refresh the image selection list
    refreshList();
  }
  
  
  /**
   * This method initialises the database by creating a table that contains
   * the image names, and Large Object OID's
   */
  public void init()
  {
    try {
      //db.setAutoCommit(true);
      stat.executeUpdate("create table images (imgname name,imgoid oid)");
      label.setText("Initialised database");
      db.commit();
    } catch(SQLException ex) {
      label.setText(ex.toString());
    }
    
    // This must run outside the previous try{} catch{} segment
    //try {
    //db.setAutoCommit(true);
    //} catch(SQLException ex) {
    //label.setText(ex.toString());
    //}
  }
  
  /**
   * This closes the connection, and ends the application
   */
  public void close()
  {
    try {
      db.close();
    } catch(SQLException ex) {
      System.err.println(ex.toString());
    }
    System.exit(0);
  }
  
  /**
   * This imports an image into the database, using a Thread to do this in the
   * background.
   */
  public void importImage()
  {
    FileDialog d = new FileDialog(frame,"Import Image",FileDialog.LOAD);
    d.setVisible(true);
    String name = d.getFile();
    String dir = d.getDirectory();
    d.dispose();
    
    // now start the true importer
    Thread t = new importer(db,name,dir);
    //t.setPriority(Thread.MAX_PRIORITY);
    t.start();
  }
  
  /**
   * This is an example of using a thread to import a file into a Large Object.
   * It uses the Large Object extension, to write blocks of the file to the
   * database.
   */
  class importer extends Thread
  {
    String name,dir;
    Connection db;
    
    public importer(Connection db,String name,String dir) {
      this.db = db;
      this.name = name;
      this.dir = dir;
    }
    
    public void run() {
      
      // Now the real import stuff
      if(name!=null && dir!=null) {
	Statement stat = null;
	
	try {
	  // fetch the large object manager
	  LargeObjectManager lom = ((org.postgresql.Connection)db).getLargeObjectAPI();
	  
	  db.setAutoCommit(false);
	  
	  // A temporary buffer - this can be as large as you like
	  byte buf[] = new byte[2048];
	  
	  // Open the file
	  FileInputStream fis = new FileInputStream(new File(dir,name));
	  
	  // Now create the large object
	  int oid = lom.create();
	  LargeObject blob = lom.open(oid);
	  
	  // Now copy the file into the object.
	  //
	  // Note: we dont use write(buf), as the last block is rarely the same
	  // size as our buffer, so we have to use the amount read.
	  int s,t=0;
	  while((s=fis.read(buf,0,buf.length))>0) {
	    t+=s;
	    blob.write(buf,0,s);
	  }
	  
	  // Close the object
	  blob.close();
	  
	  // Now store the entry into the table
	  
	  // As we are a different thread to the other window, we must use
	  // our own thread
	  stat = db.createStatement();
	  stat.executeUpdate("insert into images values ('"+name+"',"+oid+")");
	  db.commit();
	  db.setAutoCommit(false);
	  
	  // Finally refresh the names list, and display the current image
	  ImageViewer.this.refreshList();
	  ImageViewer.this.displayImage(name);
	} catch(Exception ex) {
	  label.setText(ex.toString());
	} finally {
	  // ensure the statement is closed after us
	  try {
	    if(stat != null)
	      stat.close();
	  } catch(SQLException se) {
	    System.err.println("closing of Statement failed");
	  }
	}
      }
    }
  }
  
  /**
   * This refreshes the list of available images
   */
  public void refreshList()
  {
    try {
      // First, we'll run a query, retrieving all of the image names
      ResultSet rs = stat.executeQuery("select imgname from images order by imgname");
      if(rs!=null) {
	list.removeAll();
	while(rs.next())
	  list.addItem(rs.getString(1));
	rs.close();
      }
    } catch(SQLException ex) {
      label.setText(ex.toString()+" Have you initialised the database?");
    }
  }
  
  /**
   * This removes an image from the database
   *
   * Note: With postgresql, this is the only way of deleting a large object
   * using Java.
   */
  public void removeImage()
  {
    try {
      //
      // Delete any large objects for the current name
      //
      // Note: We don't need to worry about being in a transaction
      // here, because we are not opening any blobs, only deleting
      // them
      //
      ResultSet rs = stat.executeQuery("select imgoid from images where imgname='"+currentImage+"'");
      if(rs!=null) {
	// Even though there should only be one image, we still have to
	// cycle through the ResultSet
	while(rs.next()) {
	  lom.delete(rs.getInt(1));
	}
      }
      rs.close();
      
      // Finally delete any entries for that name
      stat.executeUpdate("delete from images where imgname='"+currentImage+"'");
      
      label.setText(currentImage+" deleted");
      currentImage=null;
      refreshList();
    } catch(SQLException ex) {
      label.setText(ex.toString());
    }
  }
  
  /**
   * This displays an image from the database.
   *
   * For images, this is the easiest method.
   */
  public void displayImage(String name)
  {
    try {
      //
      // Now as we are opening and reading a large object we must
      // turn on Transactions. This includes the ResultSet.getBytes()
      // method when it's used on a field of type oid!
      //
      db.setAutoCommit(false);
      
      ResultSet rs = stat.executeQuery("select imgoid from images where imgname='"+name+"'");
      if(rs!=null) {
	// Even though there should only be one image, we still have to
	// cycle through the ResultSet
	while(rs.next()) {
	  canvas.setImage(canvas.getToolkit().createImage(rs.getBytes(1)));
	  label.setText(currentImage = name);
	}
      }
      rs.close();
    } catch(SQLException ex) {
      label.setText(ex.toString());
    } finally {
	try {
	  db.setAutoCommit(true);
	} catch(SQLException ex2) {
	}
    }
  }
  
  public void itemStateChanged(ItemEvent e) {
    displayImage(list.getItem(((Integer)e.getItem()).intValue()));
  }
  
  /**
   * This is the command line instructions
   */
  public static void instructions()
  {
    System.err.println("java example.ImageViewer jdbc-url user password");
    System.err.println("\nExamples:\n");
    System.err.println("java -Djdbc.driver=org.postgresql.Driver example.ImageViewer jdbc:postgresql:test postgres password\n");
    
    System.err.println("This example tests the binary large object api of the driver.\nBasically, it will allow you to store and view images held in the database.");
    System.err.println("Note: If you are running this for the first time on a particular database,\nyou have to select \"Initialise\" in the \"PostgreSQL\" menu.\nThis will create a table used to store image names.");
  }
  
  /**
   * This is the application entry point
   */
  public static void main(String args[])
  {
    if(args.length!=3) {
      instructions();
      System.exit(1);
    }
    
    try {
      Frame frame = new Frame("PostgreSQL ImageViewer v7.0 rev 1");
      frame.setLayout(new BorderLayout());
      ImageViewer viewer = new ImageViewer(frame,args[0],args[1],args[2]);
      frame.pack();
      frame.setLocation(0,50);
      frame.setVisible(true);
    } catch(Exception ex) {
      System.err.println("Exception caught.\n"+ex);
      ex.printStackTrace();
    }
  }
}