Konular

Mysql'e Bağlanmak

İngilizce bir makale

Introduction

In almost every good Java program, data storage is used. Have you ever wondered how this is done? If yes, you'll be satisfied, beacause this tutorial will cover databases in Java: how to set up one, access it, modify data... A database is 100 times faster than using plain text files to manage your data, and it allows to search and order the results using SQL syntax (don't worry if it is unknown to you, it will be covered later). First of all, we need to set up your database. You need to have some basic knowledge about Java and packages to be able to follow.

Setting a database

In the vast world of databases, there are quite a lot of database systems which can be used: MySQL, Oracle, SQLServer... This tutorial will expalin MySQL. If you've ever used PHP before, you may be familiar with MySQL. First of all, let's get MySQL since it is not included with Java (and it is in no way related to Java, we will need a driver). The URL of the MySQL downloads page is http://www.mysql.org/downloads/. Get the most recent version with no installation. Don't put any password for the "root" user because we will only use this for testing purposes. For the tutorial, let's suppose the install directory is C:mysql. Unzip the downloaded archive in your C:mysql directory, then create a batch file named start.bat in C:mysqlbin with this line:

CODE
mysqld --defaults-file=..my.ini


Then create stop.bat in the same directory with that line:



CODE
mysqladmin -u root shutdown


Create admin.bat with this line:



CODE
mysql -h 127.0.0.1 -u root -p


In the C:mysql directory, create a file named my.ini, and write:



CODE
[mysqld]
# set basedir to your installation path
basedir=C:mysql
# set datadir to the location of your data directory
datadir=C:mysqldata


Run admin.bat and don't enter any password. When the invite turns to mysql>, type "CREATE DATABASE `data`;". This will create a database named data and it will be used in this tutorial. That's all, our database is prepared. Now let's get the driver to allow Java to communicate with the database.



Using the Java MySQL driver

In the MySQL download page, get MySQL Connector/J and put the packages in your Java project directory. You need to have 2 directories: com and org. Depending on which version of the driver you get, these 2 directories may be in a jar archive, so unzip it to get the packages. Once you have your packages in your directory, we're ready to dig in programming!



Opening a connection to the database

Execute the file start.bat that you created earlier. Let the command window open to ensure MySQL is running. Create a class in your project and add the main method to it. You need to put a few instructions, i'll explain just after:



import java.sql.*;



CODE
public class SQLProject{
    public static void main (String[] args){
        try{
            Class.forName("org.gjt.mm.mysql.Driver"); //Load the driver
            Connection conn = DriverManager.getConnection("jdbc:mysql://localhost/data", "root", ""); //Connect
        }
        catch (Exception err){}
    }
}


What does all that stuff mean? We need to create our class and the main method, this requires no explanation. We open a try block, because every statement related to SQL may throw a SQLException, so we have to handle it. Since Class.forName("") also throws a ClassNotFoundException, and error handling is not the goal of the tutorial, let's just catch Exception to make the compiler happy. The first instruction loads the driver. You only need to put it once in your whole program and the driver will be loaded. The org.gjt.mm.mysql.Driver is in the org directory we extracted from the downloaded archive. The other statement opens a connection to the database and returns it as a java.sql.Connection object. This method takes 3 parameters: host, username, password. The 3 parameters are pretty self-explanatory. We specified the "data" database in the host parameter. Now that our connection is set, we are ready to execute some statements with SQL syntax.



How SQL syntax works

Every query (command sent to the server) has a syntax. SQL syntax is not the main purpose of this tutorial, however a few commands will be covered here. First of all, to create a database, the syntax is:



CODE
CREATE DATABASE `<database name>`;


This was the statement we used earlier to create our "data" database. Each database must have tables to store data. Each table can have its own fields, data types, values and so on. To create a table, the following will be used:



CODE
CREATE TABLE `<table name>`(
`<column name>` <data type>([data modifier]) NOT NULL,
`<another column name>` <data type>([data modifier]) NOT NULL,
FULLTEXT(`<fulltext column name>`, `<another fulltext column>`));


To select some lines from a table, the following is used. However, the WHERE clause is optional if you wish to select the whole table:



CODE
SELECT `<column name>`, `<another field name>` FROM `<table name>` WHERE <conditions>;


To remove some lines from a table, we use this syntax, here again the WHERE clause is optional but be careful! Deleted data can't be brought back, so always use the WHERE clause:



CODE
DELETE FROM `<table name>` WHERE <conditions>;


If you really want to empty the table, you can use this shortcut (again, the lost data is lost forever so be careful):



CODE
TRUNCATE `<table name>`;


If we want to change a certain value in a table, we shall use:



CODE
UPDATE `<table name>` SET `<field>` = '<some value>' WHERE <conditions>;


Finally, to insert some data in a table, we'll use this code. Make sure the values are matching the data types:



CODE
INSERT INTO `<table name>` (`<field 1>`, `<field 2>`) VALUES ('<value 1>', '<value 2>');


Don't worry if it seems complicated for now, we'll practice them by giving examples of how it's done. Remember, SQL syntax is not case sensitive but it is recommended to use the same case as in the examples above. Let's create our first table.



Creating a table

In order to be able to store anything in our database, we need to have tables. We'll make a table that will look like that:



CODE
Table: people
+------+-----------------------------+---------------------------+
| id   | name                        | address                   |
+------+-----------------------------+---------------------------+
| 1    | Bob                         | 123 Fake Street           |
| 2    | Roger                       | 666 Devil Street          |
| 3    | John                        | 325 Red Street            |
+------+-----------------------------+---------------------------+


As you probably noticed, this table has 3 columns: id, name, address. It has 3 records (rows) in it. Every column has a data type. In this example, an appropriate structure of the data types should be as follow: ID is an int, name and address are Strings. In SQL language, the word "String" does not exist, it is a varchar. To send a statement to the MySQL server in Java, we need to use conn.createStatement().execute("<some command>"). Let's take a look at the Java code to create the table:



CODE
import java.sql.*;

public class SQLProject{
    public static void main (String[] args){
        try{
            Class.forName("org.gjt.mm.mysql.Driver"); //Load the driver
            Connection conn = DriverManager.getConnection("jdbc:mysql://localhost/data", "root", ""); //Connect

                  conn.createStatement().execute("+
            +"CREATE TABLE `people` ("+
            +"`id` int(64) NOT NULL AUTO_INCREMENT,"+
            +"`name` varchar(255) NOT NULL,"+
            +"`address` varchar(255) NOT NULL,"+
            +"UNIQUE (`id`),"+
            +"FULLTEXT(`name`, `address`))");
        }
        catch (Exception err){}
    }
}


As you noticed, we sent this query to the database (the lines have been numbered):



CODE
1) CREATE TABLE `people` (
2) `id` int(64) NOT NULL AUTO_INCREMENT,
3) `name` varchar(255) NOT NULL,
4) `address` varchar(255) NOT NULL,
5) UNIQUE (`id`),
6) FULLTEXT(`name`, `address`));


If you read the basic SQL syntax part above, this command may seem familiar to you. Let's look at each line:



Line 1: Nothing special here, we tell MySQL that we want to create a table names "people".


Line 2: We add a column named "id" having a int(64) data type (explained later). Something is new here: AUTO_INCREMENT. If you want to make any software that stores record, this flag is a way to make each line (each item) have its own unique ID. No need to specify a value for this line, it is automatically set when you add a record! In my opinion, almost all tables should have a column like that (but it is not needed).


Line 3: We add a "name" column with a varchar(255) type, explained later.


Line 4: Nothing special here.


Line 5: This is an important part. Remember we set the "id" column to AUTO_INCREMENT? Well you must tell here which column is the autoindex one. In this case, it is "id".


Line 6: All columns containing text (varchar and text data types) must be declared here. In this case, "name" and "address" are like that.



Data types

Choosing the correct data type for a column can cause headaches if you're not familiar with them. Here's the ones you'll most likely use:



int(N): An integer (number without decimals) with a size of N. Example: 45425


varchar(N): A string (chain of characters) with a max character limit of N. Example: "Hello world"


double: A number that can have decimals. Example: 3.1416


text: The name says it all, it is text. This can store a textarea's contents. Example: "This is some text..."


tinyint(1): A boolean value which can be either 0 or 1. Example: 1



For a column, many data types could fit, but only one can be chosen. Pick the one that's most likely to ensure maximum compatibility. If you try to insert a line with a bad data type (e.g. Inserting "Hello" in a int column) then the SQL server will send an error and the line won't be inserted. Remember, you can change the data type later whenever you want.



Inserting records in a table

Now, we're at the point where we are ready to insert our data in the table. We already know which data we want to insert (refer at the table drawn above). We will use the INSERT statement. Here's the full code to insert the rows:



CODE
import java.sql.*;

public class SQLProject{
    public static void main (String[] args){
        try{
            Class.forName("org.gjt.mm.mysql.Driver"); //Load the driver
            Connection conn = DriverManager.getConnection("jdbc:mysql://localhost/data", "root", ""); //Connect

                  conn.createStatement().execute(CREATE TABLE `people` ("
            +"`id` int(64) NOT NULL AUTO_INCREMENT,"
            +"`name` varchar(255) NOT NULL,"
            +"`address` varchar(255) NOT NULL,"
            +"UNIQUE (`id`),"
            +"FULLTEXT(`name`, `address`))"); //Create the table

            conn.createStatement().execute("INSERT INTO `people` (`name`, `address`) VALUES ('Bob', '123 Fake Street')"); //Insert a row
            conn.createStatement().execute("INSERT INTO `people` (`name`, `address`) VALUES ('Roger', '666 Devil Street')");
            conn.createStatement().execute("INSERT INTO `people` (`name`, `address`) VALUES ('John', '325 Red Street')");

        }
        catch (Exception err){}
    }
}


All right, we specified to add "Bob" and "123 Fake Street" in the respective fields "name" and "address". But, wait a minute you'd say, what about the "id" field? Remember we set an AUTO_INCREMENT flag? We don't need to specify a value for that field, it will be automatically set to the autoindex value. With the only piece of code above, we have our table with its 3 rows inserted.



Deleting a row in the table

Now, let's say we don't want John in the table. We have many ways to delete his row, here's the safest one:



CODE
conn.createStatement().execute("DELETE FROM `people` WHERE `id` = '3' LIMIT 1");


This removed the row containing John. We have only 2 rows remaining: Bob and Roger, and they have IDs 1 and 2. If we would insert another row, it would have an ID of 4, even if we deleted the 3. The autoindex value never goes down, so EVERY row will be unique!



The LIMIT clause

In the statement above, you noticed the LIMIT keyword. This is a simple thing, as it allows to limit the number of rows affected (and at the same time speed up the query time). If we put only one number (e.g. LIMIT 2), the number of rows affected will be of that number (e.g. 2). If, in the other hand, we use a SELECT statement and we want, let's say, to page our results in pages of 100 elements, and we're at page 3, we'd use LIMIT 200, 100. The first number decided with row to start at (0 is the first row of all, so 200 is the 201st element) and the second number tell how many rows we want to return, which is 100 in this case. It is important that you understand the LIMIT clause before making any SQL-based program. Finally, the LIMIT clause is never required, but recommended.



Printing a table column's contents in the console

In this example, we'll "read" the table and print the results in the console:


CODE

ResultSet rs = conn.createStatement().executeQuery("SELECT `name` FROM `people` WHERE `id` < 4 ORDER BY `id`");
while (rs.next() == true){
    System.out.println(rs.getString("name");
}


When you select some lines from a table, use the Statement.executeQuery("") method which returns a ResultSet containing the results. By reading the above line, you can tell that we want to select the "name" column from the "people" table where the "id" value is less than 4, and we order the results by the "id" column. Since all IDs are lesser than 4, all rows are returned (the two remaining rows, because we deleted John's row). Now, we have the 2 rows stored in the java.sql.ResultSet object "rs". The next() method of ResultSet returns a boolean that tells if another row is present, and if yes it jumps to that row. The rs.getString("name") statement returns the string (varchar) stored in the "name" column of the current ResultSet's line. In that case the output will be:



CODE
Bob
Roger


You can do anything you want with these results. I suggest you to explore the java.sql.ResultSet methods to find out how you can treat your results.



Security measures

Have you ever heard about SQL injections? Well when a SQL statement contains some input from the user, he might enter a part of SQL statement to screw up the table! You can prevent a lot of these by "escaping" a ' character by using the following:



CODE
String input = textfield.getText().replace("'", "\'");


Now the "input" string is safe and can be added in a column. This is one thing that quite a lot of programmers forget to do.



Putting it all together

All right, we're near the end. To make sure you understood all, we're going to test the code. Start your server (remember: start.bat) then run the following code:



CODE
import java.sql.*;

public class SQLProject{
    public static void main (String[] args){
        try{
            Class.forName("org.gjt.mm.mysql.Driver"); //Load the driver
            Connection conn = DriverManager.getConnection("jdbc:mysql://localhost/data", "root", ""); //Connect

                  conn.createStatement().execute("CREATE TABLE `people` ("
            +"`id` int(64) NOT NULL AUTO_INCREMENT,"
            +"`name` varchar(255) NOT NULL,"
            +"`address` varchar(255) NOT NULL,"
            +"UNIQUE (`id`),"
            +"FULLTEXT(`name`, `address`))"); //Create the table

            conn.createStatement().execute("INSERT INTO `people` (`name`, `address`) VALUES ('Bob', '123 Fake Street')"); //Insert a row
            conn.createStatement().execute("INSERT INTO `people` (`name`, `address`) VALUES ('Roger', '666 Devil Street')");
            conn.createStatement().execute("INSERT INTO `people` (`name`, `address`) VALUES ('John', '325 Red Street')");

            conn.createStatement().execute("DELETE FROM `people` WHERE `id` = '3' LIMIT 1"); //Delete John's row

            ResultSet rs = conn.createStatement().executeQuery("SELECT `name` FROM `people` WHERE `id` < 4 ORDER BY `id`"); //Select the rows
            while (rs.next() == true){ //Loop through results
                System.out.println(rs.getString("name")); //Print the result
            }

            rs.close(); //Close the result set
            conn.close(); //Close the connection
        }
        catch (Exception err){}
    }
}


If everything is OK, the output will be:



CODE
Bob
Roger



You can run stop.bat to shutdown the server, we're finished with it.

Conclusion

Yeah, that's it, the tutorial is over. SQL and databases together make a vast world from which we have barely scratched the surface. Remember, if you have trouble with SQL syntax, there are tons of tutorials floating over about it, like the MySQL official website. I hope the tutorial helped you to learn the basics of databases in Java. Good luck if you're making a SQL-based application! Never use text files to store your data, you must learn SQL, so it is important you fully understand this tutorial!

Kaynak www.dreamincode.net/forums/showtopic32360.htm

Yorumunuzu Ekleyin

Java'da Analog Saat Örneği

AWT kütüphanesi kullanılarak yapılan Java'da analog bir saat örneği anlatılıyor

30,269 Okunma Henüz yorum yapılmamış 26/01/2009 22:12:54

Java'da Animasyon Örneği

Java'da bir grup resmin artarda hızla gösterilmesi esasına dayanarak canlandırma yapan bir örnek. Resim yüklemeyi ve zamanlayıcı kullanımını da içeriyor.

27,360 Okunma Henüz yorum yapılmamış 26/01/2009 22:15:24

Java'da Görüntü Haraketleri

Java'da resim nesnelerinin nasıl haraket ettirildiğine dair bir örnek. Zamanlayıcı kullanımı ve klavyeyi dinlemeye ilişkin kodlar da içeriyor.

24,046 Okunma Henüz yorum yapılmamış 26/01/2009 22:14:31

Sayı Tahmin Oyunu

NetBeans Kullanılarak yapılmış, Tarayıcı üzerinden çalışan Applet örneği

20,297 Okunma 1 Yorum 20/11/2008 16:02:36

Applet + Java Nesnesi

Applet içerisinde Java Nesnesinin kullanımı

15,860 Okunma Henüz yorum yapılmamış 01/12/2008 15:56:26

Yükleniyor...