Thursday, September 17, 2009

Pengolahan database dengan Java

Aplikasi dan database adalah dua hal yang sangat berkaitan. Hampir mustahil rasanya jika kita membuat sebuah aplikasi yang cukup besar, tanpa adanya database. Sebaliknya, dengan database yang besar, tapi tidak ada aplikasi, user akan mengalami kesulitan saat akan melakukan pengolahan data. Untuk ini semua, kita membutuhkan bahasa pemrograman yang menyediakan fasilitas untuk melakukan pengolahan database dengan mudah.
Java menyediakan fitur pengolahan database ini dengan cukup baik melalui teknologi yang dinamakan Java Database Connectivity (JDBC). JDBC ini sebenarnya adalah sebuah spesifikasi yang mengatur bagaimana sebuah database server dapat diolah dari aplikasi Java. Implementasi dari JDBC ini dibuat oleh masing-masing vendor database berupa sebuah library yang berisi kumpulan class yang mengikuti standar/spesifikasi JDBC, biasanya disebut juga sebagai JDBC driver. Oleh karena itu, masing-masing database mempunyai driver JDBC sendiri seperti Oracle menamainya SQLJ/JDBC, MySQL menamainya MySQL Connector/J.
Lho ? Jadi cara akses databasenya beda-beda, sesuai dengan database yang digunakan ?
Untungnya tidak demikian, jangan khawatir. Idealnya, kita bisa menggunakan konsep yang sama, cara pengolahan yang sama, source code yang sama, class yang sama untuk mengolah berbagai macam database yang sudah memiliki implementasi JDBC driver. Jadi jika kita ingin menghubungkan aplikasi Java kita dengan database lain, kita cukup mengubah JDBC driver dan connection propertiesnya saja.
Pada contoh kali ini kita akan melakukan pengolahan data sederhana menggunakan database MySQL. Untuk ini, kita membutuhkan MySQL versi 5 dan MySQL JDBC Driver versi 5.0. Silahkan install MySQL servernya, jika belum terinstall. Ada baiknya anda menginstall MySQL GUI Tools juga untuk memudahkan administrasi database. Untuk Java nya, Anda dapat menggunakan IDE apa saja, saya menggunakan Eclipse IDE.

Asumsi saya, Anda sudah:
1. Paham tentang dasar pemrograman Java.
2. Paham tentang dasar-dasar SQL.
Setup database
Anda bisa pakai command line, MySQL GUI, atau Eclipse Data Tools untuk melakukan langkah-langkah berikut.
a. Create database
  1. create database myblog;  
b. Create table
  1. CREATE TABLE `myblog`.`MASTER_BARANG` (  
  2. `N_ID` INTEGER UNSIGNED NOT NULL,  
  3. `S_NAMA` VARCHAR(100) NOT NULL DEFAULT '',  
  4. `N_HARGA` DECIMAL(10,2) NOT NULL DEFAULT 0,  
  5. `S_KATEGORI` VARCHAR(255) NOT NULL DEFAULT '',  
  6. `N_STOK` INTEGER UNSIGNED NOT NULL DEFAULT 0,  
  7. PRIMARY KEY(`N_ID`)  
  8. )  
  9. ENGINE = InnoDB;  
Hasilnya seperti ini:

Kita mulai java-nya
1. Setup project di eclipse

Ekstrak file mysql-connector-java-5.0.8-bin.jar dari dalam file zip hasil download JDBC driver dan copy ke folder lib di dalam project. Kemudian, include file jar tersebut ke dalam build path project, caranya klik kanan di file tersebut, pilih Build Path -> Add to Build Path.
2. DB Connection Manager

Kita akan membuat sebuah class sederhana, yang bertugas untuk melakukan koneksi ke database. Di method main, saya tulis cara penggunaannya sekaligus untuk mengetes koneksinya.
Langkah-langkah untuk membuat koneksi ke database:
a. Load class JDBC drivernya.
b. Register ke DriverManager
c. Get connection, dengan menyertakan username, password dan connection URL.
Cara paling sederhana untuk melakukan query adalah menggunakan object Statement.
a. Create object Statement dari connection.
b. Panggil method executeQuery untuk melakukan pembacaan data (query SELECT).
c. Panggil method executeUpdate untuk melakukan perubahan data (INSERT, UPDATE, DELETE, dsb).
  1. package suhearie.blog.jdbc;  
  2.   
  3. import java.sql.Connection;  
  4. import java.sql.Driver;  
  5. import java.sql.DriverManager;  
  6. import java.sql.ResultSet;  
  7. import java.sql.SQLException;  
  8. import java.sql.Statement;  
  9.   
  10. public class DBManager {  
  11.   
  12.     // nama class driver yang digunakan  
  13.     private String dbDriver = "com.mysql.jdbc.Driver";  
  14.   
  15.     // connection url, format [protokol]://[hostname]/[databasename]  
  16.     private String dbUrl = "jdbc:mysql://localhost/myblog";  
  17.   
  18.     // username  
  19.     private String dbUser = "hendra";  
  20.   
  21.     // password  
  22.     private String dbPswd = "hendra";  
  23.   
  24.     public DBManager() {  
  25.         try {  
  26.             // load class driver  
  27.             Driver driver = (Driver) Class.forName(dbDriver).newInstance();  
  28.   
  29.             // register ke driver manager  
  30.             DriverManager.registerDriver(driver);  
  31.   
  32.         } catch (Exception e) {  
  33.             e.printStackTrace();  
  34.         }  
  35.     }  
  36.   
  37.     public Connection getConnection() {  
  38.         // connect ke database  
  39.         try {  
  40.             return DriverManager.getConnection(dbUrl, dbUser, dbPswd);  
  41.         } catch (SQLException e) {  
  42.             e.printStackTrace();  
  43.             return null;  
  44.         }  
  45.     }  
  46.   
  47.     public ResultSet executeQuery(String sql) {  
  48.         Connection conn = getConnection();  
  49.         try {  
  50.             Statement stmt = conn.createStatement();  
  51.             return stmt.executeQuery(sql);  
  52.         } catch (SQLException e) {  
  53.             e.printStackTrace();  
  54.             return null;  
  55.         }  
  56.     }  
  57.   
  58.     public int executeUpdate(String sql) {  
  59.         Connection conn = getConnection();  
  60.         try {  
  61.             Statement stmt = conn.createStatement();  
  62.             return stmt.executeUpdate(sql);  
  63.         } catch (SQLException e) {  
  64.             e.printStackTrace();  
  65.             return -1;  
  66.         }  
  67.     }  
  68.   
  69.     public static void main(String[] args) {  
  70.         DBManager manager = new DBManager();  
  71.         Connection conn = manager.getConnection();  
  72.   
  73.         try {  
  74.             // Print beberapa informasi tentang server  
  75.             System.out.println(conn.getMetaData().getDatabaseProductName());  
  76.             System.out.println(conn.getMetaData().getDatabaseProductVersion());  
  77.         } catch (SQLException e) {  
  78.             e.printStackTrace();  
  79.         }  
  80.   
  81.     }  
  82.   
  83. }  
3. Entity class
Di Java, kita dapat melakukan operasi database secara langsung dengan memberikan parameter-parameter berupa nilai dari tiap kolom yang ada di tabel. Tapi, itu bukan cara yang baik. Kita membutuhkan class (biasanya disebut bean class atau entity) yang merupakan representasi dari data yang tersimpan dalam tabel. Umumnya, satu instance dari class ini mewakili satu row di database.
Keuntungan menggunakan entity ini, data lebih mudah diolah dan code akan lebih mudah dibaca. Skenarionya adalah, kita membaca data dari tabel, mengubahnya menjadi sebuah object di memory, memanipulasi object tersebut, kemudian menyimpannya kembali ke database. Jadi data yang ada di tabel, tidak berserakan kemana-mana, karena kita mempunyai object “pembungkusnya”. Metode ini akan sangat berguna sebagai dasar jika kita melangkah ke teknologi Java yang lebih canggih, yaitu persistence engine.
  1. package suhearie.blog.jdbc;  
  2.   
  3. public class BarangBean {  
  4.   
  5.     private int id = 0;  
  6.   
  7.     private String nama = "";  
  8.   
  9.     private double harga = 0;  
  10.   
  11.     private String kategori = "";  
  12.   
  13.     private int stok = 0;  
  14.   
  15.     public BarangBean() {}  
  16.   
  17.     public BarangBean(int id, String nama, double harga, String kategori,  
  18.             int stok) {  
  19.         super();  
  20.         this.id = id;  
  21.         this.nama = nama;  
  22.         this.harga = harga;  
  23.         this.kategori = kategori;  
  24.         this.stok = stok;  
  25.     }  
  26.   
  27.     public int getId() {  
  28.         return id;  
  29.     }  
  30.   
  31.     public void setId(int id) {  
  32.         this.id = id;  
  33.     }  
  34.   
  35.     public String getNama() {  
  36.         return nama;  
  37.     }  
  38.   
  39.     public void setNama(String nama) {  
  40.         this.nama = nama;  
  41.     }  
  42.   
  43.     public double getHarga() {  
  44.         return harga;  
  45.     }  
  46.   
  47.     public void setHarga(double harga) {  
  48.         this.harga = harga;  
  49.     }  
  50.   
  51.     public String getKategori() {  
  52.         return kategori;  
  53.     }  
  54.   
  55.     public void setKategori(String kategori) {  
  56.         this.kategori = kategori;  
  57.     }  
  58.   
  59.     public int getStok() {  
  60.         return stok;  
  61.     }  
  62.   
  63.     public void setStok(int stok) {  
  64.         this.stok = stok;  
  65.     }  
  66.   
  67. }  
Tidak ada yang istimewa dari class ini. Hanya merupakan kumpulan property yang sinkron dengan kolom di tabel, dan selebihnya merupakan getter (accessor) dan setter (mutator) method.
4. GUI tabel
Kita menggunakan JFrame untuk menampilkan data dalam bentuk tabel. Selain itu kita mempunyai toolbar yang berisi tombol-tombol untuk add, edit, dan delete.

  1. package suhearie.blog.jdbc;  
  2.   
  3. import javax.swing.SwingUtilities;  
  4. import java.awt.BorderLayout;  
  5. import javax.swing.JPanel;  
  6. import javax.swing.JFrame;  
  7. import java.awt.Dimension;  
  8. import java.awt.GridBagLayout;  
  9. import javax.swing.JToolBar;  
  10. import java.awt.GridBagConstraints;  
  11. import java.sql.ResultSet;  
  12. import java.sql.SQLException;  
  13.   
  14. import javax.swing.JScrollPane;  
  15. import javax.swing.JTable;  
  16. import javax.swing.JButton;  
  17. import javax.swing.table.DefaultTableModel;  
  18.   
  19. public class MainFrame extends JFrame {  
  20.   
  21.     private static final long serialVersionUID = 1L;  
  22.     private JPanel jContentPane = null;  
  23.     private JToolBar jJToolBarBar = null;  
  24.     private JScrollPane jScrollPane = null;  
  25.     private JTable table = null;  
  26.     private JButton btnAdd = null;  
  27.     private JButton btnEdit = null;  
  28.     private JButton btnDelete = null;  
  29.     private DBManager manager = null;  //  @jve:decl-index=0:visual-constraint="537,53"  
  30.   
  31.     /** 
  32.      * This method initializes jJToolBarBar 
  33.      * 
  34.      * @return javax.swing.JToolBar 
  35.      */  
  36.     private JToolBar getJJToolBarBar() {  
  37.         if (jJToolBarBar == null) {  
  38.             jJToolBarBar = new JToolBar();  
  39.             jJToolBarBar.add(getBtnAdd());  
  40.             jJToolBarBar.add(getBtnEdit());  
  41.             jJToolBarBar.add(getBtnDelete());  
  42.         }  
  43.         return jJToolBarBar;  
  44.     }  
  45.   
  46.     /** 
  47.      * This method initializes jScrollPane 
  48.      * 
  49.      * @return javax.swing.JScrollPane 
  50.      */  
  51.     private JScrollPane getJScrollPane() {  
  52.         if (jScrollPane == null) {  
  53.             jScrollPane = new JScrollPane();  
  54.             jScrollPane.setViewportView(getTable());  
  55.         }  
  56.         return jScrollPane;  
  57.     }  
  58.   
  59.     /** 
  60.      * This method initializes table 
  61.      * 
  62.      * @return javax.swing.JTable 
  63.      */  
  64.     private JTable getTable() {  
  65.         if (table == null) {  
  66.             DefaultTableModel model = new DefaultTableModel(null, new String[] {  
  67.                     "ID", "NAMA", "HARGA", "KATEGORI", "STOK"});  
  68.             table = new JTable(model);  
  69.         }  
  70.         return table;  
  71.     }  
  72.   
  73.     /** 
  74.      * This method initializes btnAdd 
  75.      * 
  76.      * @return javax.swing.JButton 
  77.      */  
  78.     private JButton getBtnAdd() {  
  79.         if (btnAdd == null) {  
  80.             btnAdd = new JButton();  
  81.             btnAdd.setText("Add");  
  82.             btnAdd.addActionListener(new java.awt.event.ActionListener() {  
  83.                 public void actionPerformed(java.awt.event.ActionEvent e) {  
  84.                     add();  
  85.                 }  
  86.             });  
  87.         }  
  88.         return btnAdd;  
  89.     }  
  90.   
  91.     private void add() {  
  92.         new EditorDialog(this, null).setVisible(true);  
  93.     }  
  94.   
  95.     /** 
  96.      * This method initializes btnEdit 
  97.      * 
  98.      * @return javax.swing.JButton 
  99.      */  
  100.     private JButton getBtnEdit() {  
  101.         if (btnEdit == null) {  
  102.             btnEdit = new JButton();  
  103.             btnEdit.setText("Edit");  
  104.             btnEdit.addActionListener(new java.awt.event.ActionListener() {  
  105.                 public void actionPerformed(java.awt.event.ActionEvent e) {  
  106.                     edit();  
  107.                 }  
  108.             });  
  109.         }  
  110.         return btnEdit;  
  111.     }  
  112.   
  113.     private void edit() {  
  114.         Integer id = (Integer) table.getValueAt(table.getSelectedRow(), 0);  
  115.         String sql = "SELECT * FROM MASTER_BARANG WHERE N_ID = "+id;  
  116.         ResultSet rs = getManager().executeQuery(sql);  
  117.         try {  
  118.             if (rs.next()) {  
  119.                 BarangBean bean = new BarangBean(rs.getInt("N_ID"),  
  120.                         rs.getString("S_NAMA"),  
  121.                         rs.getDouble("N_HARGA"),  
  122.                         rs.getString("S_KATEGORI"),  
  123.                         rs.getInt("N_STOK"));  
  124.                 new EditorDialog(this, bean).setVisible(true);  
  125.             }  
  126.             else {  
  127.                 refresh();  
  128.             }  
  129.         } catch (SQLException e) {  
  130.             e.printStackTrace();  
  131.         }  
  132.     }  
  133.   
  134.     /** 
  135.      * This method initializes btnDelete 
  136.      * 
  137.      * @return javax.swing.JButton 
  138.      */  
  139.     private JButton getBtnDelete() {  
  140.         if (btnDelete == null) {  
  141.             btnDelete = new JButton();  
  142.             btnDelete.setText("Delete");  
  143.             btnDelete.addActionListener(new java.awt.event.ActionListener() {  
  144.                 public void actionPerformed(java.awt.event.ActionEvent e) {  
  145.                     delete();  
  146.                 }  
  147.             });  
  148.         }  
  149.         return btnDelete;  
  150.     }  
  151.   
  152.     private void delete() {  
  153.         int[] rows = table.getSelectedRows();  
  154.         String sql = "DELETE FROM MASTER_BARANG WHERE N_ID IN (";  
  155.         for (int row : rows) {  
  156.             sql += table.getValueAt(row, 0)+",";  
  157.         }  
  158.         // remove last comma  
  159.         sql = sql.substring(0, sql.length()-1);  
  160.         sql += ")";  
  161.         manager.executeUpdate(sql);  
  162.         refresh();  
  163.     }  
  164.   
  165.     /** 
  166.      * This method initializes manager1 
  167.      * 
  168.      * @return suhearie.blog.jdbc.DBManager 
  169.      */  
  170.     public DBManager getManager() {  
  171.         if (manager == null) {  
  172.             manager = new DBManager();  
  173.         }  
  174.         return manager;  
  175.     }  
  176.   
  177.     /** 
  178.      * @param args 
  179.      */  
  180.     public static void main(String[] args) {  
  181.         // TODO Auto-generated method stub  
  182.         SwingUtilities.invokeLater(new Runnable() {  
  183.             public void run() {  
  184.                 MainFrame thisClass = new MainFrame();  
  185.                 thisClass.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);  
  186.                 thisClass.setVisible(true);  
  187.             }  
  188.         });  
  189.     }  
  190.   
  191.     /** 
  192.      * This is the default constructor 
  193.      */  
  194.     public MainFrame() {  
  195.         super();  
  196.         initialize();  
  197.     }  
  198.   
  199.     /** 
  200.      * This method initializes this 
  201.      * 
  202.      * @return void 
  203.      */  
  204.     private void initialize() {  
  205.         this.setSize(415, 297);  
  206.         this.setContentPane(getJContentPane());  
  207.         this.setTitle("Main Frame");  
  208.         refresh();  
  209.     }  
  210.   
  211.     public void refresh() {  
  212.         String sql = "SELECT * FROM MASTER_BARANG ORDER BY N_ID";  
  213.         ResultSet rs = getManager().executeQuery(sql);  
  214.         if (rs != null) {  
  215.             DefaultTableModel model = (DefaultTableModel) table.getModel();  
  216.             for (int i=table.getRowCount()-1; i>=0; i--) {  
  217.                 model.removeRow(i);  
  218.             }  
  219.             try {  
  220.                 while (rs.next()) {  
  221.                     Object[] data = new Object[] {  
  222.                             rs.getInt("N_ID"),  
  223.                             rs.getString("S_NAMA"),  
  224.                             rs.getDouble("N_HARGA"),  
  225.                             rs.getString("S_KATEGORI"),  
  226.                             rs.getInt("N_STOK")  
  227.                             };  
  228.                     model.addRow(data);  
  229.                 }  
  230.             } catch (SQLException e) {  
  231.                 e.printStackTrace();  
  232.             }  
  233.         }  
  234.     }  
  235.   
  236.     /** 
  237.      * This method initializes jContentPane 
  238.      * 
  239.      * @return javax.swing.JPanel 
  240.      */  
  241.     private JPanel getJContentPane() {  
  242.         if (jContentPane == null) {  
  243.             GridBagConstraints gridBagConstraints1 = new GridBagConstraints();  
  244.             gridBagConstraints1.fill = GridBagConstraints.BOTH;  
  245.             gridBagConstraints1.gridy = 1;  
  246.             gridBagConstraints1.weightx = 1.0;  
  247.             gridBagConstraints1.weighty = 1.0;  
  248.             gridBagConstraints1.gridx = 0;  
  249.             GridBagConstraints gridBagConstraints = new GridBagConstraints();  
  250.             gridBagConstraints.fill = GridBagConstraints.BOTH;  
  251.             gridBagConstraints.gridy = 0;  
  252.             gridBagConstraints.weightx = 1.0;  
  253.             gridBagConstraints.gridx = 0;  
  254.             jContentPane = new JPanel();  
  255.             jContentPane.setLayout(new GridBagLayout());  
  256.             jContentPane.add(getJJToolBarBar(), gridBagConstraints);  
  257.             jContentPane.add(getJScrollPane(), gridBagConstraints1);  
  258.         }  
  259.         return jContentPane;  
  260.     }  
  261.   
  262. }  //  @jve:decl-index=0:visual-constraint="10,10"  
Tombol Add ditekan, tampilkan EditorDialog kosong, sehingga user bisa memasukkan data baru.
Tombol Edit ditekan, tampilkan EditorDialog yang berisi data yang ingin diedit.
Tombol Delete ditekan, hapus data yang dipilih.
5. GUI data editor
Kita menggunakan JDialog untuk menampilkan form untuk menambah data baru dan mengedit data.

  1. package suhearie.blog.jdbc;  
  2.   
  3. import javax.swing.JPanel;  
  4. import java.awt.Frame;  
  5. import java.awt.BorderLayout;  
  6. import javax.swing.JDialog;  
  7. import java.awt.GridBagLayout;  
  8. import java.awt.Dimension;  
  9. import javax.swing.JLabel;  
  10. import java.awt.GridBagConstraints;  
  11. import javax.swing.JTextField;  
  12. import java.awt.Insets;  
  13. import javax.swing.JButton;  
  14.   
  15. public class EditorDialog extends JDialog {  
  16.   
  17.     private static final long serialVersionUID = 1L;  
  18.     private boolean newBean;  
  19.     private MainFrame parent;  
  20.     private BarangBean bean;  //  @jve:decl-index=0:  
  21.     private JPanel jContentPane = null;  
  22.     private JLabel jLabel = null;  
  23.     private JLabel jLabel1 = null;  
  24.     private JLabel jLabel2 = null;  
  25.     private JLabel jLabel3 = null;  
  26.     private JLabel jLabel4 = null;  
  27.     private JTextField txtId = null;  
  28.     private JTextField txtNama = null;  
  29.     private JTextField txtHarga = null;  
  30.     private JTextField txtKategori = null;  
  31.     private JTextField txtStok = null;  
  32.     private JButton btnSave = null;  
  33.     private JButton btnCancel = null;  
  34.   
  35.     /** 
  36.      * @param owner 
  37.      */  
  38.     public EditorDialog(Frame owner) {  
  39.         super(owner);  
  40.         initialize();  
  41.     }  
  42.   
  43.     public EditorDialog(MainFrame parent, BarangBean bean) {  
  44.         super(parent, true);  
  45.         initialize();  
  46.         this.parent = parent;  
  47.         this.bean = bean;  
  48.         displayBean();  
  49.     }  
  50.   
  51.     private void displayBean() {  
  52.         if (bean == null) {  
  53.             bean = new BarangBean();  
  54.             newBean = true;  
  55.         }  
  56.         else {  
  57.             newBean = false;  
  58.             txtId.setEditable(false);  
  59.         }  
  60.         txtId.setText(String.valueOf(bean.getId()));  
  61.         txtNama.setText(bean.getNama());  
  62.         txtHarga.setText(String.valueOf(bean.getHarga()));  
  63.         txtKategori.setText(bean.getKategori());  
  64.         txtStok.setText(String.valueOf(bean.getStok()));  
  65.     }  
  66.   
  67.     /** 
  68.      * This method initializes this 
  69.      * 
  70.      * @return void 
  71.      */  
  72.     private void initialize() {  
  73.         this.setSize(359, 257);  
  74.         this.setTitle("Add / Edit Barang");  
  75.         this.setContentPane(getJContentPane());  
  76.     }  
  77.   
  78.     /** 
  79.      * This method initializes jContentPane 
  80.      * 
  81.      * @return javax.swing.JPanel 
  82.      */  
  83.     private JPanel getJContentPane() {  
  84.         if (jContentPane == null) {  
  85.             GridBagConstraints gridBagConstraints41 = new GridBagConstraints();  
  86.             gridBagConstraints41.gridx = 2;  
  87.             gridBagConstraints41.anchor = GridBagConstraints.WEST;  
  88.             gridBagConstraints41.insets = new Insets(15, 5, 5, 5);  
  89.             gridBagConstraints41.gridy = 5;  
  90.             GridBagConstraints gridBagConstraints31 = new GridBagConstraints();  
  91.             gridBagConstraints31.gridx = 1;  
  92.             gridBagConstraints31.anchor = GridBagConstraints.WEST;  
  93.             gridBagConstraints31.insets = new Insets(15, 5, 5, 5);  
  94.             gridBagConstraints31.gridy = 5;  
  95.             GridBagConstraints gridBagConstraints21 = new GridBagConstraints();  
  96.             gridBagConstraints21.fill = GridBagConstraints.VERTICAL;  
  97.             gridBagConstraints21.gridy = 4;  
  98.             gridBagConstraints21.weightx = 1.0;  
  99.             gridBagConstraints21.anchor = GridBagConstraints.WEST;  
  100.             gridBagConstraints21.insets = new Insets(5, 5, 5, 5);  
  101.             gridBagConstraints21.gridwidth = 2;  
  102.             gridBagConstraints21.gridx = 1;  
  103.             GridBagConstraints gridBagConstraints11 = new GridBagConstraints();  
  104.             gridBagConstraints11.fill = GridBagConstraints.VERTICAL;  
  105.             gridBagConstraints11.gridy = 3;  
  106.             gridBagConstraints11.weightx = 1.0;  
  107.             gridBagConstraints11.anchor = GridBagConstraints.WEST;  
  108.             gridBagConstraints11.insets = new Insets(5, 5, 5, 5);  
  109.             gridBagConstraints11.gridwidth = 2;  
  110.             gridBagConstraints11.gridx = 1;  
  111.             GridBagConstraints gridBagConstraints7 = new GridBagConstraints();  
  112.             gridBagConstraints7.fill = GridBagConstraints.VERTICAL;  
  113.             gridBagConstraints7.gridy = 2;  
  114.             gridBagConstraints7.weightx = 1.0;  
  115.             gridBagConstraints7.anchor = GridBagConstraints.WEST;  
  116.             gridBagConstraints7.insets = new Insets(5, 5, 5, 5);  
  117.             gridBagConstraints7.gridwidth = 2;  
  118.             gridBagConstraints7.gridx = 1;  
  119.             GridBagConstraints gridBagConstraints6 = new GridBagConstraints();  
  120.             gridBagConstraints6.fill = GridBagConstraints.VERTICAL;  
  121.             gridBagConstraints6.gridy = 1;  
  122.             gridBagConstraints6.weightx = 1.0;  
  123.             gridBagConstraints6.anchor = GridBagConstraints.WEST;  
  124.             gridBagConstraints6.insets = new Insets(5, 5, 5, 5);  
  125.             gridBagConstraints6.gridwidth = 2;  
  126.             gridBagConstraints6.gridx = 1;  
  127.             GridBagConstraints gridBagConstraints5 = new GridBagConstraints();  
  128.             gridBagConstraints5.fill = GridBagConstraints.VERTICAL;  
  129.             gridBagConstraints5.gridy = 0;  
  130.             gridBagConstraints5.weightx = 1.0;  
  131.             gridBagConstraints5.anchor = GridBagConstraints.WEST;  
  132.             gridBagConstraints5.insets = new Insets(5, 5, 5, 5);  
  133.             gridBagConstraints5.gridwidth = 2;  
  134.             gridBagConstraints5.gridx = 1;  
  135.             GridBagConstraints gridBagConstraints4 = new GridBagConstraints();  
  136.             gridBagConstraints4.gridx = 0;  
  137.             gridBagConstraints4.anchor = GridBagConstraints.WEST;  
  138.             gridBagConstraints4.insets = new Insets(5, 5, 5, 5);  
  139.             gridBagConstraints4.gridy = 4;  
  140.             jLabel4 = new JLabel();  
  141.             jLabel4.setText("Stok");  
  142.             GridBagConstraints gridBagConstraints3 = new GridBagConstraints();  
  143.             gridBagConstraints3.gridx = 0;  
  144.             gridBagConstraints3.anchor = GridBagConstraints.WEST;  
  145.             gridBagConstraints3.insets = new Insets(5, 5, 5, 5);  
  146.             gridBagConstraints3.gridy = 3;  
  147.             jLabel3 = new JLabel();  
  148.             jLabel3.setText("Ketegori");  
  149.             GridBagConstraints gridBagConstraints2 = new GridBagConstraints();  
  150.             gridBagConstraints2.gridx = 0;  
  151.             gridBagConstraints2.anchor = GridBagConstraints.WEST;  
  152.             gridBagConstraints2.insets = new Insets(5, 5, 5, 5);  
  153.             gridBagConstraints2.gridy = 2;  
  154.             jLabel2 = new JLabel();  
  155.             jLabel2.setText("Harga");  
  156.             GridBagConstraints gridBagConstraints1 = new GridBagConstraints();  
  157.             gridBagConstraints1.gridx = 0;  
  158.             gridBagConstraints1.anchor = GridBagConstraints.WEST;  
  159.             gridBagConstraints1.insets = new Insets(5, 5, 5, 5);  
  160.             gridBagConstraints1.gridy = 1;  
  161.             jLabel1 = new JLabel();  
  162.             jLabel1.setText("Nama");  
  163.             GridBagConstraints gridBagConstraints = new GridBagConstraints();  
  164.             gridBagConstraints.gridx = 0;  
  165.             gridBagConstraints.anchor = GridBagConstraints.WEST;  
  166.             gridBagConstraints.insets = new Insets(5, 5, 5, 5);  
  167.             gridBagConstraints.gridy = 0;  
  168.             jLabel = new JLabel();  
  169.             jLabel.setText("ID Barang");  
  170.             jContentPane = new JPanel();  
  171.             jContentPane.setLayout(new GridBagLayout());  
  172.             jContentPane.add(jLabel, gridBagConstraints);  
  173.             jContentPane.add(jLabel1, gridBagConstraints1);  
  174.             jContentPane.add(jLabel2, gridBagConstraints2);  
  175.             jContentPane.add(jLabel3, gridBagConstraints3);  
  176.             jContentPane.add(jLabel4, gridBagConstraints4);  
  177.             jContentPane.add(getTxtId(), gridBagConstraints5);  
  178.             jContentPane.add(getTxtNama(), gridBagConstraints6);  
  179.             jContentPane.add(getTxtHarga(), gridBagConstraints7);  
  180.             jContentPane.add(getTxtKategori(), gridBagConstraints11);  
  181.             jContentPane.add(getTxtStok(), gridBagConstraints21);  
  182.             jContentPane.add(getBtnSave(), gridBagConstraints31);  
  183.             jContentPane.add(getBtnCancel(), gridBagConstraints41);  
  184.         }  
  185.         return jContentPane;  
  186.     }  
  187.   
  188.     /** 
  189.      * This method initializes txtId 
  190.      * 
  191.      * @return javax.swing.JTextField 
  192.      */  
  193.     private JTextField getTxtId() {  
  194.         if (txtId == null) {  
  195.             txtId = new JTextField();  
  196.             txtId.setColumns(10);  
  197.         }  
  198.         return txtId;  
  199.     }  
  200.   
  201.     /** 
  202.      * This method initializes txtNama 
  203.      * 
  204.      * @return javax.swing.JTextField 
  205.      */  
  206.     private JTextField getTxtNama() {  
  207.         if (txtNama == null) {  
  208.             txtNama = new JTextField();  
  209.             txtNama.setColumns(15);  
  210.         }  
  211.         return txtNama;  
  212.     }  
  213.   
  214.     /** 
  215.      * This method initializes txtHarga 
  216.      * 
  217.      * @return javax.swing.JTextField 
  218.      */  
  219.     private JTextField getTxtHarga() {  
  220.         if (txtHarga == null) {  
  221.             txtHarga = new JTextField();  
  222.             txtHarga.setColumns(10);  
  223.         }  
  224.         return txtHarga;  
  225.     }  
  226.   
  227.     /** 
  228.      * This method initializes txtKategori 
  229.      * 
  230.      * @return javax.swing.JTextField 
  231.      */  
  232.     private JTextField getTxtKategori() {  
  233.         if (txtKategori == null) {  
  234.             txtKategori = new JTextField();  
  235.             txtKategori.setColumns(15);  
  236.         }  
  237.         return txtKategori;  
  238.     }  
  239.   
  240.     /** 
  241.      * This method initializes txtStok 
  242.      * 
  243.      * @return javax.swing.JTextField 
  244.      */  
  245.     private JTextField getTxtStok() {  
  246.         if (txtStok == null) {  
  247.             txtStok = new JTextField();  
  248.             txtStok.setColumns(10);  
  249.         }  
  250.         return txtStok;  
  251.     }  
  252.   
  253.     /** 
  254.      * This method initializes btnSave 
  255.      * 
  256.      * @return javax.swing.JButton 
  257.      */  
  258.     private JButton getBtnSave() {  
  259.         if (btnSave == null) {  
  260.             btnSave = new JButton();  
  261.             btnSave.setText("Save");  
  262.             btnSave.addActionListener(new java.awt.event.ActionListener() {  
  263.                 public void actionPerformed(java.awt.event.ActionEvent e) {  
  264.                     save();  
  265.                 }  
  266.             });  
  267.         }  
  268.         return btnSave;  
  269.     }  
  270.   
  271.     private void save() {  
  272.         BarangBean bean = new BarangBean();  
  273.         bean.setId(Integer.parseInt(txtId.getText()));  
  274.         bean.setNama(txtNama.getText());  
  275.         bean.setHarga(Double.parseDouble(txtHarga.getText()));  
  276.         bean.setKategori(txtKategori.getText());  
  277.         bean.setStok(Integer.parseInt(txtStok.getText()));  
  278.   
  279.         String sql = "";  
  280.         if (newBean) {  
  281.             sql = "INSERT INTO MASTER_BARANG (N_ID, S_NAMA, N_HARGA, S_KATEGORI, N_STOK)" +  
  282.                     " VALUES ("+bean.getId()+",'"+bean.getNama()+"',"+  
  283.                     bean.getHarga()+",'"+bean.getKategori()+"',"+bean.getStok()+")";  
  284.         }  
  285.         else {  
  286.             sql = "UPDATE MASTER_BARANG SET S_NAMA = '"+bean.getNama()+"',"+  
  287.                     "N_HARGA = "+bean.getHarga()+", S_KATEGORI = '"+bean.getKategori()+  
  288.                     "', N_STOK = "+bean.getStok()+  
  289.                     " WHERE N_ID = "+bean.getId();  
  290.         }  
  291.   
  292.         parent.getManager().executeUpdate(sql);  
  293.         parent.refresh();  
  294.         dispose();  
  295.     }  
  296.   
  297.     /** 
  298.      * This method initializes btnCancel 
  299.      * 
  300.      * @return javax.swing.JButton 
  301.      */  
  302.     private JButton getBtnCancel() {  
  303.         if (btnCancel == null) {  
  304.             btnCancel = new JButton();  
  305.             btnCancel.setText("Cancel");  
  306.             btnCancel.addActionListener(new java.awt.event.ActionListener() {  
  307.                 public void actionPerformed(java.awt.event.ActionEvent e) {  
  308.                     dispose();  
  309.                 }  
  310.             });  
  311.         }  
  312.         return btnCancel;  
  313.     }  
  314.   
  315. }  //  @jve:decl-index=0:visual-constraint="10,10"  
Class EditorDialog ini menerima input dari MainFrame berupa object BarangBean. Jika object tersebut null, akan dibuat object BarangBean baru. Jika tidak null, maka EditorDialog akan menampilkan property-property yang dimiliki oleh object BarangBean tersebut ke dalam masing-masing textfield yang berkaitan. Jika tombol save ditekan, EditorDialog akan mengupdate object BarangBean yang dengan nilai yang yang ada pada textfield. Jika object ini adalah object baru, maka akan dilakukan operasi insert. Jika EditorDialog berada pada mode edit, maka akan dilakukan operasi update.

No comments: