Слайд 2
JDBC
JDBC – это стандартный прикладной интерфейс (API) языка
Java для организации взаимодействия между приложением и СУБД.
Это
взаимодействие осуществляется с помощью драйверов JDBC, обеспечивающих реализацию общих интерфейсов для конкретных СУБД и конкретных протоколов.
В JDBC определяются четыре типа драйверов:
Слайд 3
Тип 1 – драйвер, использующий другой прикладной интерфейс,
в частности ODBC, для работы с СУБД (так называемый
JDBC-ODBC – мост). Стандартный драйвер первого типа sun.jdbc.odbc.JdbcOdbcDriver входит в JSDK
Тип 2 – драйвер, работающий через нативные библиотеки (т.е. клиента) СУБД.
Тип 3 – драйвер, работающий по сетевому и независимому от СУБД протоколу с промежуточным Java-сервером, который, в свою очередь, подключается к нужной СУБД.
4. Тип 4 – сетевой драйвер, работающий напрямую с нужной СУБД и не требующий установки native-библиотек.
Слайд 4
Предпочтение естественным образом отдается второму типу, однако если
приложение выполняется на машине, на которой не предполагается установка
клиента СУБД, то выбор производится между третьим и четвертым типами.
Причем четвертый тип работает напрямую с СУБД по ее протоколу, поэтому драйвер четвертого типа будет более эффективным по сравнению с третьим типом с точки зрения производительности.
Первый же тип, как правило, используется редко, т.е. в тех случаях, когда у СУБД нет своего драйвера JDBC, зато есть драйвер ODBC.
Слайд 5
JDBC предоставляет интерфейс для разработчиков, использующих различные СУБД.
С помощью JDBC отсылаются SQL-запросы только к реляционным базам
данных (БД), для которых существуют драйверы, знающие способ общения с реальным сервером базы данных.
Рассмотрим обычную последовательность действий при работе с базой данных:
Необходимо подключить библиотеку
import java.sql.*;
2. Загрузка класса драйвера базы данных при отсутствии экземпляра этого класса(для JavaDB)
String driverName = "org.apache.derby.jdbc.EmbeddedDriver";
После этого выполняется собственно загрузка драйвера в память:
Class.forName(driverName).newInstance();
и становится возможным соединение с СУБД.
Слайд 6
Эти же действия можно выполнить, импортируя библиотеку и
создавая объект явно (например для DB2):
import COM.ibm.db2.jdbc.net.DB2Driver;
а
затем,
new DB2Driver();
3. Установка соединения с БД в виде
String connectionURL=
“jdbc:derby:NeuronNetwork;create=true";
//create=true –означает, что БД будет создана, если до этого она не создавалась
Connection conn =
DriverManager.getConnection(
connectionURL, "login", "password");
Слайд 7
В результате будет возвращен объект Connection и будет
одно установленное соединение с БД NeuronNetwork.
Класс DriverManager предоставляет средства
для управления набором драйверов баз данных.
Методу getConnection() необходимо передать тип и физическое месторасположение БД, а также логин и пароль для доступа.
С помощью метода registerDriver() драйвера регистрируются, а методом getDrivers() можно получить список всех драйверов.
Слайд 8
4. Создание объекта для передачи запросов
Statement st = conn.createStatement();
Объект класса Statement используется для выполнения
запроса и команд SQL.
Могут применяться также операторы для выполнения подготовленных запросов и хранимых процедур PreparedStatement и CallableStatement.
Созданный объект можно использовать для выполнения запроса.
Слайд 9
Основные методы класса Statement:
public void addBatch(String sql) throws
SQLException
Добавляет заданную команду SQL к текущему пакету команд.
public void
cancel() throws SQLException
В многопоточной среде с помощью этого метода можно потребовать прекращения всякой обработки, связанной с данным Statement.
В этом смысле метод аналогичен методу stop() для
объектов Thread.
public boolean execute(String sql) throws SQLException
public ResultSet executeQuery(String sql) throws SQLException
public int executeUpdate(String sql) throws SQLException
Выполняет Statement, передавая базе данных заданную SQL-строку.
Первый метод, execute(), позволяет вам выполнить Statement,
когда неизвестно заранее, является SQL-строка запросом или
обновлением.
Метод возвращает true, если команда создала результирующий
набор.
Слайд 10
Метод executeQuery() используется для выполнения
запросов (на извлечение данных).
Он возвращает для
обработки результирующий набор.
Метод executeUpdate() используется для выполнения
обновлений.
Он возвращает количество обновленных строк.
public int[ ] executeBatch(String sql) throws SQLException
Посылает базе данных пакет SQL-команд для выполнения.
И возвращает ко-во строк, которые были изменены
public ResultSet getResultSet() throws SQLException
Метод возвращает текущий ResultSet.
Для каждого результата его следует вызывать только
однажды.
Его не нужно вызывать после обращения к executeQuery(),
возвращающему единственный результат.
Слайд 11
public void close() throws SQLException
Вручную закрывает объект Statement.
Обычно этого не требуется, так как Statement
автоматически закрывается при закрытии связанного с ним
объекта Connection.
Класс ResultSet
Этот класс представляет результирующий набор базы данных.
Он обеспечивает приложению построчный доступ к результатам запросов в базе данных.
Во время обработки запроса ResultSet поддерживает указатель на текущую обрабатываемую строку.
Приложение последовательно перемещается по результатам, пока они не будут все обработаны или не будет закрыт ResultSet.
Рассмотрим методы класса ResultSet
Слайд 12
public boolean absolute(int row) throws SQLException
Метод перемещает курсор
на заданное число строк от начала, если число положительно,
и от конца - если отрицательно.
public void afterLast() throws SQLException
Этот метод перемещает курсор в конец результирующего набора за последнюю строку.
public void beforeFirst() throws SQLException
Этот метод перемещает курсор в начало результирующего набора перед первой строкой.
public void deleteRow() throws SQLException
Удаляет текущую строку из результирующего набора и базы данных.
Слайд 13
public ResultSetMetaData getMetaData() throws SQLException
Предоставляет объект метаданных для
данного ResultSet.
Класс ResultSetMetaData содержит
информацию о результирующие таблице, такую
как количество столбцов, их заголовок и т.д.
public int getRow() throws SQLException
Возвращает номер текущей строки.
public Statement getStatement() throws SQLException
Возвращает экземпляр Statement, который произвел данный результирующий набор.
Слайд 14
public boolean next() throws SQLException
public boolean previous() throws
SQLException
Эти методы позволяют переместиться в результирующем наборе на одну
строку вперед или назад.
Во вновь созданном результирующем наборе курсор
устанавливается перед первой строкой, поэтому первое
обращение к методу next() влечет позиционирование на
первую строку.
Эти методы возвращают true, если остается
строка для дальнейшего перемещения.
Если строк для обработки больше нет, возвращается false.
Если открыт поток InputStream для предыдущей строки, он
закрывается.
Также очищается цепочка предупреждений SQLWarning.
public void close() throws SQLException
Осуществляет немедленное закрытие ResultSet вручную.
Обычно этого не требуется, так как закрытие Statement, связанного с
ResultSet, автоматически закрывает ResultSet.
Слайд 15
Рассмотрим пример:
package mssql;
import java.sql.*;
public class Main
{
private static Connection con = null;
private static String username = "name";
private static String password = "pass";
private static String URL ="jdbc:mysql://localhost:3306/mybase?profileSQL=true";
// profileSQL=true –означает, делать трассировку запросов и их
выполнения с использованием логгера, который должен быть
сконфигурирован
public static void main(String[] args) throws SQLException{
//Загружаем драйвер
String driverName = "com.mysql.jdbc.Driver";
Class.forName(driverName);
//соединяемся
con = DriverManager.getConnection(URL, username, password);
if(con!=null) System.out.println("Connection Successful !\n");
if (con==null) System.exit(0);
Слайд 16
//Statement позволяет отправлять запросы базе данных
Statement st = con.createStatement();
//ResultSet получает
результирующую таблицу
ResultSet rs = st.executeQuery( "select hd from pc group by hd
having count(hd)>=2" );
//Resultset.getMetaData() получаем информацию о
результирующей таблице
int x = rs.getMetaData().getColumnCount();
while(rs.next()){
for(int i=1; i<=x;i++){
System.out.print(rs.getString(i) + "\t");
}
System.out.println();
}
System.out.println();
if(rs!=null)rs.close();
if(st!=null)st.close();
if(con!=null)con.close(); } }
Слайд 17
Интерфейс CallableStatement расширяет возможности интерфейса PreparedStatement и обеспечивает
выполнение хранимых процедур.
Стоит заметить, что PreparedStatement расширяет интерфейс Statement.
Хранимая
процедура – это в общем случае именованная последовательность команд SQL, рассматриваемых как единое целое, и выполняющаяся в адресном пространстве процессов СУБД, который можно вызвать извне (в зависимости от политики доступа используемой СУБД).
В данном случае хранимая процедура будет рассматриваться в более узком смысле как последовательность команд SQL, хранимых в БД и доступных любому пользователю этой СУБД.
Слайд 18
Интерфейс CallableStatement позволяет исполнять хранимые процедуры, которые находятся
непосредственно в БД.
Одна из особенностей этого процесса в
том, что CallableStatement способен обрабатывать не только входные (IN) параметры, но и выходящие (OUT) и смешанные (INOUT) параметры.
Тип выходного параметра должен быть зарегистрирован методом registerOutParameter().
После установки входных и выходных параметров вызываются методы execute(), executeQuery() или executeUpdate().
Рассмотрим пример использования CallableStatement.
Слайд 19
Пусть в БД существует хранимая процедура getempname, которая
по уникальному для каждой записи в таблице employee числу
SSN будет возвращать соответствующее ему имя:
Delimiter //
CREATE PROCEDURE `getempname`
(IN emp_ssn INT, OUT emp_name VARCHAR(30))
AS
BEGIN
SELECT name
INTO emp_name
FROM employee
WHERE SSN = EMP_SSN;
END;
//
Слайд 20
Тогда для получения имени служащего employee через вызов
данной процедуры необходимо исполнить java-код вида:
String SQL = "{call
getempname (?,?)}";
CallableStatement cs = conn.prepareCall(SQL);
int ssn=822301;
cs.setInt(1,ssn);
//регистрация выходящего параметра
cs.registerOutParameter(2,
java.sql.Types.VARCHAR);
cs.execute();
String empName = cs.getString(2);
System.out.println("Employee with SSN:" + ssn
+ " is " + empName);
Слайд 21
В результате будет выведено, приблизительно следующее:
Employee with SSN:822301
is Spiridonov
В JDBC также существует механизм batch-команд, который позволяет
запускать на исполнение в БД массив запросов SQL вместе, как одну единицу.
Statement stmt = con.createStatement();
stmt.addBatch("INSERT INTO employee VALUES
(10, 'Joe ')");
stmt.addBatch("INSERT INTO location VALUES
(260, ‘Kiev’)");
stmt.addBatch("INSERT INTO emp_dept VALUES
(1000, 260)");
Слайд 22
//выполняем запрос
int[] updateCounts = stmt.executeBatch();
В массиве updateCounts содержаться
числа:
1.>=0 – означает, что запрос выполнился успешно и в
данном элементе массива содержится ко-во строк в таблице, измененные запросом.
2. SUCCESS_NO_INFO – означает, что команда выполнилась успешно, но ко-во строк в таблице, которые были изменены запросом, неизвестно.
Если один из запросов выполнен не будет, то будет возбуждено исключение BatchUpdateException.
При этом JDBC может продолжить выполнение остальных запросов.
3. EXECUTE_FAILED – означает, что выполнение запроса провалилось.
Слайд 23
Если используется объект PreparedStatement, batch-команда состоит из параметризованного
SQL-запроса и ассоциируемого с ним множества параметров.
Рассмотрим пример:
Слайд 24
try {
Employee[] employees = new Employee[10];
PreparedStatement statement=
con.prepareStatement(
"INSERT INTO employee VALUES (?,?,?,?,?)");
for (int i = 0; i < employees.length; i++) {
Employee currEmployee = employees[i];
statement.setInt(1, currEmployee.getSSN());
statement.setString(2, currEmployee.getName());
statement.setDouble(3, currEmployee.getSalary());
statement.setString(4,currEmployee.getHireDate());
statement.setInt(5, currEmployee.getLoc_Id());
statement.addBatch();} }
Слайд 25
int [] updateCounts = statement.executeBatch();
} catch (BatchUpdateException
e) {
e.printStackTrace(); }
Транзакции
Транзакцию (деловую операцию) определяют как
единицу работы, обладающую свойствами ACID:
Атомарность – две или более операций выполняются все или не выполняется ни одна.
Успешно завершенные транзакции
фиксируются, в случае неудачного
завершения происходит откат всей
транзакции.
Слайд 26
Согласованность – при возникновении сбоя система возвращается в
состояние до начала неудавшейся транзакции.
Если транзакция
завершается успешно, то
проверка согласованности удостоверяется в
успешном завершении всех операций транзакции.
Изолированность – во время выполнения транзакции все объекты-сущности, участвующие в ней, должны быть синхронизированы.
Долговечность – все изменения, произведенные с данными во время транзакции, сохраняются, например, в базе данных.
Слайд 27
Для фиксации результатов работы SQL-операторов, логически выполняемых в
рамках некоторой транзакции, используется SQL-оператор COMMIT.
В API JDBC
эта операция выполняется по умолчанию после каждого вызова методов executeQuery() и executeUpdate().
Если же необходимо сгруппировать запросы и только после этого выполнить операцию COMMIT, сначала вызывается метод setAutoCommit(boolean param) интерфейса Connection с параметром false, в результате выполнения которого текущее соединение с БД переходит в режим неавтоматического подтверждения операций.
Слайд 28
После этого выполнение любого запроса на изменение информации
в таблицах базы данных не приведет к необратимым последствиям,
пока операция COMMIT не будет выполнена непосредственно.
Подтверждает выполнение SQL-запросов метод commit() интерфейса Connection, в результате действия которого все изменения таблицы производятся как одно логическое действие.
Если же транзакция не выполнена, то методом rollback() отменяются действия всех запросов SQL, начиная от последнего вызова commit().
Слайд 29
try{
Connection cn=…….;
cn.setAutoCommit(false);
Statement st = cn.createStatement();
String upd =
"INSERT INTO student
(id, name) VALUES
('"+ id + "', '" + name + "')";
st.executeUpdate(upd);
………………………………………….
cn.commit(); //подтверждение.
} catch(SQLException e){
cn.rollback();
………………………….
}
Слайд 30
Для транзакций существует несколько типов чтения:
Грязное чтение (dirty
reads) происходит, когда транзакциям разрешено видеть несохраненные изменения данных.
Иными словами, изменения, сделанные в одной
транзакции, видны вне ее до того, как она была
сохранена.
Если изменения не будут сохранены, то, вероятно,
другие транзакции выполняли работу на основе
некорректных данных;
Непроверяющееся чтение (nonrepeatable reads) происходит, когда транзакция А читает строку, транзакция B изменяет эту строку, транзакция А читает ту же строку и получает обновленные данные;
Слайд 31
Фантомное чтение (phantom reads) происходит, когда транзакция А
считывает все строки, удовлетворяющие WHERE-условию, транзакция B вставляет новую
или удаляет одну из строк, которая удовлетворяет этому условию, транзакция А еще раз считывает все строки, удовлетворяющие WHERE-условию, уже вместе с новой строкой или недосчитавшись старой.
Слайд 32
JDBC удовлетворяет четырем уровням изоляции транзакций, определенным в
стандарте SQL.
Уровни изоляции транзакций определены в виде констант интерфейса
Connection (по возрастанию уровня ограничения):
TRANSACTION_NONE – информирует о том, что драйвер не поддерживает транзакции;
TRANSACTION_READ_UNCOMMITTED – позволяет транзакциям видеть несохраненные изменения данных, что разрешает грязное, непроверяющееся и фантомное чтения;
Слайд 33
TRANSACTION_READ_COMMITTED – означает, что любое изменение, сделанное в
транзакции, не видно вне неё, пока она не сохранена.
Это предотвращает грязное чтение, но
разрешает непроверяющееся и фантомное;
TRANSACTION_REPEATABLE_READ – запрещает грязное и непроверяющееся, но фантомное чтение разрешено;
TRANSACTION_SERIALIZABLE – определяет, что грязное, непроверяющееся и фантомное чтения запрещены.
Слайд 34
Метод
boolean supportsTransactionIsolationLevel
(int level)
интерфейса DatabaseMetaData определяет, поддерживается ли заданный уровень изоляции транзакций.
В свою очередь, методы интерфейса Connection определяют доступ к уровню изоляции:
int getTransactionIsolation() – возвращает текущий уровень изоляции;
void setTransactionIsolation(int level) – устанавливает нужный уровень.
Слайд 35
Точки сохранения
Точки сохранения дают дополнительный контроль над транзакциями.
Установкой точки сохранения обозначается логическая точка внутри
транзакции, которая может быть использована для отката данных.
Таким образом, если произойдет ошибка, можно вызвать метод rollback() для отмены всех изменений, которые были сделаны после точки сохранения.
Метод boolean supportsSavepoints() интерфейса DatabaseMetaData используется для того, чтобы определить, поддерживает ли точки сохранения драйвер JDBC и сама СУБД.
Слайд 36
Методы setSavepoint(String name) и setSavepoint() (оба возвращают объект
Savepoint) интерфейса Connection используются для установки именованной или неименованной
точки сохранения во время текущей транзакции.
Рассмотрим пример:
Слайд 37
……………………….
Class.forName ("com.mysql.jdbc.Driver")
.newInstance();
Connection cn = null;
Savepoint savepoint = null;
cn = DriverManager.getConnection(
"jdbc:mysql://localhost/db3","root","pass");
cn.setAutoCommit(false);
Statement stmt = cn.createStatement();
String trueSQL = "INSERT INTO emp
(id,name,surname,salary)" +
"VALUES(2607,'Петя','Иванов',540)";
stmt.executeUpdate(trueSQL);
Слайд 38
//установка точки сохранения
savepoint = cn.setSavepoint("savepoint1");
//выполнение некорректного запроса
String
Слайд 39
Рассмотрим пример, двухмерный массив на основе базы данных.
import
java.sql.*;
import java.util.*;
//здесь хранится имя массива, ко-во строк
и ко-во столбцов.
class MasSize {
private int columns;
private int rows;
private String name;
public void setName(String n){name=new String(n);}
public void setColumns(int n){columns=n;}
public void setRows(int n){rows=n;}
public String getName(){return name;}
public int getColumns(){return columns;}
public int getRows(){return rows;}
public boolean equals(Object o){
MasSize o1=(MasSize) o;
if(name.equals(o1.name)) return true;
else return false; } };
Слайд 40
public class DB{
private
String name; //имя базы данных
private
LinkedList tables=new LinkedList();//список имен
массивов в базе данных
private Connection conn;
public DB(String preambula, String n, String driver){
name=new String(n);
String connectionURL=preambula+””
+name+";create=true";
try{
Class.forName( driver);
conn = DriverManager.getConnection(connectionURL);
} catch(Exception e){
System.out.println("In function DB");
e.printStackTrace();
}
Слайд 41
public void createMas(String name_of_massive,
int number_of_rows,
int number_of_columns){
try {
//добавляем имя массива в список имен массивов
MasSize m=new MasSize();
m.setName(name_of_massive);
m.setColumns(number_of_columns);
m.setRows(number_of_rows);
if(!tables.contains(m)) { tables.add(m);}
else {
System.out.println("Massive with such name
already exists");
return;
}
Слайд 42
//создание таблицы
String createString="CREATE TABLE
"+name_of_massive+
" ( NUMBER int generated by default as identity
(START WITH 1, INCREMENT BY 1), "+
"w0 DOUBLE )";
Statement stmt = conn.createStatement();
stmt.executeUpdate(createString);
for(int i=1; i< number_of_columns; i++) {
//добавление столбцов в таблицу
String stradd="ALTER TABLE "+name_of_massive+
“ADD"+"w"+String.valueOf(i)+" DOUBLE";
stmt.executeUpdate(stradd); }
into “
+name_of_massive+" ( w0 )"+
" values "+"( ?)";
PreparedStatement psInsert =
conn.prepareStatement(str_query);
psInsert.setDouble(1,0.0);
psInsert.executeUpdate();}}
catch (Exception e) {
System.out.println("In function createMas");
e.printStackTrace();} }
Слайд 44
public void set(String name_of_massive, int row,
int column, double value){
//изменение значения элемента с координатами row и column на значение value
try{
//проверка существует ли массив с именем name_of_massive
MasSize m=new MasSize();
m.setName(name_of_massive);
m.setColumns(0);
m.setRows(0);
if(!tables.contains(m)) {
System.out.println("there is no such massive");
return; }
Слайд 45
String str="update "+name_of_massive+
"set"+"w"+String.valueOf(column)+"=?"+
"where NUMBER="+String.valueOf(row+1);
PreparedStatement
psInsert =
conn.prepareStatement(str);
psInsert.setDouble(1,value);
psInsert.executeUpdate();}
catch(Exception e){
System.out.println("In function set");
e.printStackTrace();}
Слайд 46
public double get(String name_of_massive,
int row, int column){
//получение элемента массива с координатами row и column
try{
MasSize m=new MasSize();
m.setName(name_of_massive);
m.setColumns(0);
m.setRows(0);
if(!tables.contains(m)){
System.out.println("there is no such
massive");
return -1; }
Слайд 47
String str=“select“
+"w"+String.valueOf(column)+”from“
+name_of_massive+
"where NUMBER="+String.valueOf(row+1);
Statement stmt2 = conn.createStatement();
ResultSet rs = stmt2.executeQuery(str);
rs.next();
double d=rs.getDouble(1);
rs.close();
return d;}
catch(Exception e){
System.out.println("In function get");
e.printStackTrace();
return -1;}}
Слайд 48
public int Ncolumns(String name_of_massive) {
//кол-во столбцов в массиве name_of_massive
try{
MasSize m=new MasSize();
m.setName(name_of_massive);
m.setColumns(0);
m.setRows(0);
if(!tables.contains(m)) {
System.out.println("there is no such massive");
return -1; }
MasSize m1=(MasSize)
tables.get(tables.indexOf(m));
return m1.getColumns();}
catch(Exception e){
System.out.println("In function Ncolumns");
e.printStackTrace();
return -1;}}
Слайд 49
public int Nrows(String name_of_massive){
//кол-во строк
в массиве name_of_massiv
try{
MasSize
m=new MasSize();
m.setName(name_of_massive);
m.setColumns(0);
m.setRows(0);
if(!tables.contains(m)) {
System.out.println("there is no such massive");
return -1; }
MasSize m1=(MasSize)
tables.get(tables.indexOf(m));
return m1.getRows();}
catch(Exception e){
System.out.println("In function Ncolumns");
e.printStackTrace();
return -1;}}
Слайд 50
public void delete_mas(String name_of_massive){
//удаление массива
name_of_massive из базы данных
try{
MasSize m=new MasSize();
m.setName(name_of_massive);
m.setColumns(0);
m.setRows(0);
if(!tables.contains(m)) {
System.out.println("there is no such massive");
return; }
String str="drop table "+name_of_massive;
Statement stmt2 = conn.createStatement();
stmt2.executeUpdate(str);}
catch(Exception e){
System.out.println("In function delete_mas");
e.printStackTrace();}}}
Слайд 51
Использование данного класса может выглядеть следующим образом:
class m1{
public static void main(String[] args){
DB data=new
DB("jdbc:derby:","NeuronNetwork",
"org.apache.derby.jdbc.EmbeddedDriver");
data.createMas("mas",3,3);
data.set("mas",1,1,3.56);
double d=data.get("mas",1,1);
System.out.println(d);
data.set("mas",1,2,4.78);
d=data.get("mas",1,2);
System.out.println(d);
int r=data.Ncolumns("mas");
int c=data.Nrows("mas");
System.out.println("rows= "+r);
System.out.println("cols= "+c);
data.set("mas",1,2,5.5);
d=data.get("mas",1,2);
System.out.println(d); }
}
Слайд 52
Метаданные
С помощью методов интерфейсов ResultSetMetaData и DatabaseMetaData
можно получить
список таблиц, определить типы, свойства и количество столбцов БД.
Получить
объект ResultSetMetaData можно следующим образом:
ResultSetMetaData rsMetaData=rs.getMetaData();
где rs имеет тип ResultSet.
Рассмотрим некоторые методы интерфейса ResultSetMetaData:
int getColumnCount() – возвращает число столбцов набора результатов объекта ResultSet;
String getColumnName(int column) – возвращает имя указанного столбца объекта ResultSet;
Слайд 53
int getColumnType(int column) – возвращает тип данных указанного
столбца объекта ResultSet.
Получить объект DatabaseMetaData можно следующим образом:
DatabaseMetaData dbMetaData
= conn.getMetaData();
где cn объект класса Connection.
Рассмотрим некоторые методы интерфейса DatabaseMetaData:
String getDatabaseProductName() – возвращает название СУБД;
String getDatabaseProductVersion() – возвращает номер версии СУБД
String getDriverName() – возвращает имя драйвера JDBC;
String getUserName() – возвращает имя пользователя БД;
String getURL() – возвращает местонахождение источника данных;
ResultSet getTables(String catalog, String schemaPattern, String tableNamePattern, String[] types ) – возвращает набор типов таблиц, доступных для данной БД
Слайд 54
catalog - Значение String, содержащее имя каталога. Задание
значения NULL для этого параметра указывает на то, что
имя каталога использовать не нужно.
schema - Значение String, содержащее шаблон имени схемы. Задание значения NULL для этого параметра указывает на то, что имя схемы использовать не нужно.
tableName - Значение String, содержащее шаблон имени таблицы.
types - Массив строковых значений, содержащий включаемые типы таблиц. Значение NULL показывает, что нужно включать все типы таблиц. Типы таблиц можно получить вызвав функцию getTableTypes(). Бывают следующие типы "TABLE", "VIEW", "SYSTEM TABLE", "GLOBAL TEMPORARY", "LOCAL TEMPORARY", "ALIAS", "SYNONYM".
Рассмотрим пример.
Возврат описания таблицы Person.Contact в базы данных AdventureWorks.
Слайд 55
public static void executeGetTables(Connection con) {
try {
DatabaseMetaData dbmd = con.getMetaData();
ResultSet rs = dbmd.getTables("AdventureWorks",
"Person", "Contact", null);
ResultSetMetaData rsmd = rs.getMetaData();
int cols = rsmd.getColumnCount();
while(rs.next()) {
for (int i = 1; i <= cols; i++) {
System.out.println(rs.getString(i)); }
}
rs.close();
} catch (Exception e) { e.printStackTrace(); }
}
Слайд 56
Результирующий набор, возвращаемый методом getTables, включает следующие данные:
TABLE_CAT
- Имя базы данных, в которой расположена указанная таблица
TABLE_SCHEM-
Имя схемы для таблицы.
TABLE_NAME- Имя таблицы.
TABLE_TYPE - Табличный тип.
REMARKS- Описание таблицы.
Слайд 57
Пул соединений
При большом количестве клиентов приложения к БД
этого приложения выполняется большое количество запросов.
Соединение с БД
является дорогостоящей (по требуемым ресурсам) операцией.
Эффективным способом решения данной проблемы является организация пула используемых соединений, которые не закрываются физически, а хранятся в очереди и предоставляются повторно для других запросов.
Слайд 58
Разделяемый доступ к источнику данных можно организовать путем
объявления статической переменной типа DataSource из пакета javax.sql.
Источник
данных типа DataSource – это компонент, предоставляющий соединение с приложением СУБД.
Класс InitialContext, как часть JNDI API, обеспечивает работу с каталогом именованных объектов.
В этом каталоге можно связать объект источника данных DataSource с некоторым именем (не только с именем БД, но и вообще с любым), предварительно создав объект DataSource.
Слайд 59
Затем созданный объект можно получить с помощью метода
lookup() по его имени.
Методу lookup() передается
имя, всегда начинающееся с имени корневого контекста(Если пул организовывается с помощью Tomcat)
javax.naming.Context ct =
new javax.naming.InitialContext();
DataSource ds =
(DataSource)ct.lookup(“java:jdbc/mybd”);
Connection cn = ds.getConnection(“name”, “pass”);
После выполнения запроса соединение завершается и его объект возвращается обратно в пул вызовом:
cn.close();
Слайд 60
Пул соединений Tomcat
Для организации пула необходимо изменить файл
factory org.apache.commons.dbcp.BasicDataSourceFactory driverClassName org.gjt.mm.mysql.Driver ">
server.xml, который находится в папке conf (в директории, в
которой установлен Tomcat):
factory
org.apache.commons.dbcp.BasicDataSourceFactory
driverClassName
org.gjt.mm.mysql.Driver
Слайд 61
username
root
password
pass
maxActive 500
maxIdle
10
параметра maxWait (в миллисекундах), пользователь получит Exception. При значении
maxWait равным -1, время ожидания не ограничено.-->
maxWait 10000
removeAbandoned
true
removeAbandonedTimeout
60
logAbandoned
true
Слайд 63
Некоторые производители СУБД для облегчения создания пула соединений
определяют собственный класс на основе интерфейса DataSource.
В этом
случае пул соединений может быть создан, например, следующим образом:
import COM.ibm.db2.jdbc.DB2DataSource;
...
DB2DataSource ds = new DB2DataSource();
ds.setServerName("//localhost:6061/mybd");
Connection cn =
ds.getConnection("db2adm","pass");
Драйвер определяется автоматически в объекте DB2DataSource.
Слайд 64
Также существует специальный пакет для создания пула соединений
с БД DBPool (необходимы пакеты DBPool-5.0 и commons-logging-1.1.1-bin). Можно
также использовать пул DBCP
Рассмотрим пример использования DBpool 5.0
…………………………………..
Connection conn = null;
try{
String userName = "muser";
String password = "qwertyui";
String url = "jdbc:mysql://localhost/mybase";
Class.forName ("com.mysql.jdbc.Driver").newInstance();
//Создаем пул
ConnectionPool pool=new ConnectionPool("local",1,10,20,180000,url,
userName,password);
//Здесь “local”- имя пула, 1-минимальное количество соединений в пуле, 10-максимальное ко-во соединений в пуле, 20-максимальное количество соединений, которое может быть создано. Избыточные соединения будут уничтожены, когда их вернут в пул.
//Создаем соединение, если оно не было создано или достаем из пула
conn=pool.getConnection();
Слайд 65
String SQL="{call getmname(?,?)}";
CallableStatement cs = conn.prepareCall(SQL);
int ssn=251;
cs.setInt(1, ssn);
cs.registerOutParameter(2, Types.VARCHAR);
cs.execute();
String name=cs.getString(2);
System.out.println("Employee with SSN:" + ssn+
" is " + name);
conn.close();
………//снова используем соединение
//закрываем пул
pool.release();
………………………………………………
Слайд 66
Паттерн Data Access Object
Data Access Object (DAO)
используется для абстрагирования и инкапсулирования доступа к источнику данных.
Использующие DAO бизнес-компоненты работают с более простым интерфейсом, предоставляемым объектом DAO своим клиентам.
DAO полностью скрывает детали реализации источника данных от клиентов.
Поскольку при изменениях реализации источника данных представляемый DAO интерфейс не изменяется, этот паттерн дает возможность DAO принимать различные схемы хранилищ без влияния на клиенты или бизнес-компоненты.
Слайд 67
Диаграмма классов для DAO имеет вид:
Слайд 68
Диаграмма последовательности, показывающая взаимодействия между участниками в данном
паттерне имеет вид:
Слайд 69
BusinessObject
BusinessObject представляет клиента данных. Это объект, который нуждается
в доступе к источнику данных для получения и сохранения
данных.
BusinessObject может быть реализован как сессионный компонент, компонент управления данными или другой Java-объект, сервлет или вспомогательный компонент.
Слайд 70
DataAccessObject
DataAccessObject является первичным объектом данного паттерна.
DataAccessObject абстрагирует используемую
реализацию доступа к данным для BusinessObject, обеспечивая прозрачный доступ
к источнику данных.
BusinessObject передает также ответственность за выполнение операций загрузки и сохранения данных объекту DataAccessObject.
Слайд 71
DataSource
Представляет реализацию источника данных.
Источником данных может быть база
данных, XML-репозиторий и др.
Источником данных может быть также
другая система (традиционная/мэйнфрейм), служба (B2B-служба или система обслуживания кредитных карт), или какой-либо репозиторий (LDAP).
Слайд 72
TransferObject
Представляет собой объект, используемый для передачи данных.
DataAccessObject
может использовать
TransferObject для возврата данных клиенту.
DataAccessObject может
также принимать данные от клиента в объекте TransferObject для их обновления в источнике данных.
Слайд 73
Стратегии
Стратегия Automatic DAO Code Generation
Поскольку BusinessObject соответствует конкретному
DAO, есть возможность установить взаимоотношения между BusinessObject, DAO, и
применяемыми реализациями (например, таблицы в RDBMS).
После установления взаимоотношений появляется возможность написать простую утилиту для генерации кода, зависящую от приложения, которая может генерировать код для всех нужных приложению объектов DAO.
Метаданные для генерации DAO могут определяться разработчиком в файле-дескрипторе.
В качестве альтернативы генератор кода может автоматически проанализировать базу данных и предоставить необходимые для доступа к ней объекты DAO.
Слайд 74
Стратегия Factory for Data Access Objects
Паттерн DAO может
быть сделан очень гибким при использовании паттернов Abstract Factory
и Factory Method.
Данная стратегия может быть реализована с использованием паттерна Factory Method для генерации нескольких объектов DAO, которые нужны приложению, в тех случаях, когда применяемое хранилище данных не изменяется при переходе от одной реализации к другой.
Слайд 75
Диаграмма классов этого случая имеет вид:
Слайд 76
Когда используемое хранилище данных может измениться при переходе
от одной реализации к другой, данная стратегия может быть
реализована с применением паттерна Abstract Factory.
Диаграмма классов этой стратегии имеет следующий вид:
Слайд 78
Диаграмма последовательности, описывающая взаимодействия для этой стратегии имеет
вид:
Слайд 79
Рассмотрим пример кода для паттерна DAO.
// DAO Factory
public abstract class DAOFactory {
// Список DAO типов
поддерживаемых фабрикой
public static final int CLOUDSCAPE = 1;
public static final int ORACLE = 2;
public static final int SYBASE = 3;
...
// Методы для создания DAO
public abstract CustomerDAO getCustomerDAO();
public abstract AccountDAO getAccountDAO();
public abstract OrderDAO getOrderDAO();
...
public static DAOFactory getDAOFactory( int whichFactory) {
switch (whichFactory) {
case CLOUDSCAPE: return new CloudscapeDAOFactory();
case ORACLE : return new OracleDAOFactory();
case SYBASE : return new SybaseDAOFactory();
...
default : return null;
} } }
Слайд 80
public class CloudscapeDAOFactory extends DAOFactory {
public
static final String DRIVER=
"COM.cloudscape.core.RmiJdbcDriver";
public static final String DBURL=
"jdbc:cloudscape:rmi://localhost:1099/CoreJ2EEDB";
// метод для создания соединения к Cloudscape
public static Connection createConnection() {…….}
public CustomerDAO getCustomerDAO() {
return new CloudscapeCustomerDAO(); }
public AccountDAO getAccountDAO() {
return new CloudscapeAccountDAO(); }
public OrderDAO getOrderDAO() {
return new CloudscapeOrderDAO(); }
... }
Слайд 81
Интерфейс для CustomerDAO
public interface CustomerDAO {
public
int insertCustomer(...);
public boolean deleteCustomer(...);
public Customer findCustomer(...);
public boolean updateCustomer(...);
public RowSet selectCustomersRS(...);
public Collection selectCustomersTO(...);
...
}
Слайд 82
Имплементация интерфейса CustomerDAO
public class CloudscapeCustomerDAO
implements CustomerDAO {
public CloudscapeCustomerDAO() {…. }
public int insertCustomer(...) {
//метод возвращает номер нового созданного
//Customer или -1 в случае ошибки
}
public boolean deleteCustomer(...) { …….. }
………………………
}
Слайд 83
Customer Transfer Object
public class Customer implements
java.io.Serializable {
int CustomerNumber;
String name;
String streetAddress;
String city;
...
// getter and setter
... ...
}
Слайд 84
Использование DAO Factory
…………………………………
DAOFactory cloudscapeFactory =
DAOFactory.getDAOFactory(
DAOFactory.DAOCLOUDSCAPE);
CustomerDAO custDAO =
cloudscapeFactory.getCustomerDAO();
int newCustNo = custDAO.insertCustomer(...);
//Создаем Customer объект
Customer cust = custDAO.findCustomer(...);
//изменяем значение Customer объекта
cust.setAddress(...);
cust.setEmail(...);
custDAO.updateCustomer(cust);
………………………………………………………….
Слайд 85
Hibernate
Hibernate - это механизм отображения в реляционной базе
данных объектов java.
На практике наибольшую популярность получили реляционные
модели баз данных, хотя в современных методологиях программирования пользуется популярностью объектно-ориентированное программирование.
Для стыковки данных технологий разработано множество технологий, спецификаций и фреймворков для маппинга объектов на таблицы реляционных баз данных.
Слайд 86
Java разработчикам доступно множество технологий для работы с
данными это может быть просто сериализация объектов, JDBC, JDO,
JPA и множество других.
Java Persistence API (JPA), являющееся составной частью Hibernate сочетает в себе простоту сериализации объектов с возможностью работы с данными на уровне объектно-ориентированной модели.
При этом остается возможность комбинирования доступа к данным как в JDBC на уровне реляционных данных.
Слайд 87
Рассмотрим примеры использования Hibernate.
В базе данных создадим
таблицу Student с тремя полями:
1) id — идентификатор
2) name
— имя студента
3) age — его возраст
Другими словами выполним запрос
CREATE TABLE Student(id NUMBER(10) NOT NULL,
name varchar(100) NOT NULL,
age NUMBER(3) NOT NULL,
CONSTRAINT pk_Student PRIMARY KEY(id));
Теперь создадим пакет logic.
В нем опишем класс-сущность, который будем хранить в БД:
Слайд 88
package logic;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.Table;
import org.hibernate.annotations.GenericGenerator;
@Entity
@Table(name="Student")
public
class Student {
private Long id;
private String name;
private Long age;
public Student(){
name = null;
}
public Student(Student s){
name = s.getName();
}
Слайд 89
@Id
@GeneratedValue (generator="increment")
@GenericGenerator (name="increment", strategy
Слайд 90
Аннотации здесь используются для Mapping Java классов с
таблицами базы данных.
Проще говоря для того, чтобы Hibernate
знал, что данный класс является сущностью, то есть объекты данного класса мы будем хранить в базе данных.
Использованные здесь аннотации имеют следующий смысл:
@Entity — указывает на то, что данный класс является сущностью.
@Table — задает имя таблицы, в которой будут храниться объекты класса
@Id — обозначает поле id
@GeneratedValue(generator="increment") и @GenericGenerator(name="increment", strategy = "increment") — указывает на то, как будет генерироваться id (в данном случае по возростанию)
@Column — обозначает имя колонки, соответствующей данному полю.
Стоит отметить также, что все классы-сущности должны обязательно иметь геттеры, сеттеры и конструктор по умолчанию.
Теперь создадим главный конфигурационный файл hibernate.cfg.xml и поместим его в папку bin проекта.
Из этого файла Hibernate будет брать всю необходимую ему информацию:
3.0//EN"
"http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">
oracle.jdbc.driver.OracleDriver
name="connection.url">jdbc:oracle:thin:@localhost:1521:MyDB
Your_Login
Your_Password
10
org.hibernate.dialect.OracleDialect
true
update
false
thread
Слайд 92
Создадим пакет util, а в нем класс HibernateUtil,
который будет отвечать за обработку данного xml файла и
установление соединения с базой данных:
package util;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
public class HibernateUtil {
private static SessionFactory sessionFactory = null;
static {
try {
//creates the session factory from hibernate.cfg.xml
sessionFactory = new Configuration().configure().buildSessionFactory();
} catch (Exception e) {
e.printStackTrace();
}
}
public static SessionFactory getSessionFactory() {
return sessionFactory;
}
}
Слайд 93
Теперь осталось разобраться со взаимодействием приложения с базой
данных.
Тогда для класса-сущности, определим интерфейс StudentDAO из пакета
DAO, содержащий набор необходимых методов:
package DAO;
import java.sql.SQLException;
import java.util.List;
import logic.Student;
public interface StudentDAO {
public void addStudent(Student student) throws SQLException; //добавить
студента
public void updateStudent(Student student) throws SQLException; //обновить
студента
public Student getStudentById(Long id) throws SQLException; //получить
стедента по id
public List getAllStudents() throws SQLException; //получить всех студентов
public void deleteStudent(Student student) throws SQLException; //удалить
студента
}
Слайд 94
Теперь определим реализацию этого интерфейса в классе SudentDAOImpl
в пакете DAO.Impl:
package DAO.Impl;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;
import javax.swing.JOptionPane;
import org.hibernate.Session;
import
util.HibernateUtil;
import DAO.StudentDAO;
import logic.Student;
public class StudentDAOImpl implements StudentDAO {
public void addStudent(Student stud) throws SQLException {
Session session = null;
try {
session = HibernateUtil.getSessionFactory().openSession();
session.beginTransaction();
session.save(stud);
session.getTransaction().commit();
} catch (Exception e) {
JOptionPane.showMessageDialog(null, e.getMessage(), "Ошибка I/O",
JOptionPane.OK_OPTION);
} finally {
if (session != null && session.isOpen()) {
session.close();
} }
}
Слайд 95
public void updateStudent(Student stud) throws SQLException {
Session session = null;
try {
session = HibernateUtil.getSessionFactory().openSession();
session.beginTransaction();
session.update(stud);
session.getTransaction().commit();
} catch (Exception e) {
JOptionPane.showMessageDialog(null, e.getMessage(), "Ошибка I/O",
JOptionPane.OK_OPTION);
} finally {
if (session != null && session.isOpen()) {
session.close();
}
}
}
Слайд 96
public Student getStudentById(Long id) throws SQLException {
Session session = null;
Student stud = null;
try {
session = HibernateUtil.getSessionFactory().openSession();
stud = (Student) session.load(Student.class, id);
} catch (Exception e) {
JOptionPane.showMessageDialog(null, e.getMessage(), "Ошибка I/O",
JOptionPane.OK_OPTION);
} finally {
if (session != null && session.isOpen()) {
session.close();
}
}
return stud;
}
Слайд 97
public List getAllStudents() throws SQLException {
Session session = null;
List studs = new ArrayList();
try {
session = HibernateUtil.getSessionFactory().openSession();
studs = session.createCriteria(Student.class).list();
} catch (Exception e) {
JOptionPane.showMessageDialog(null, e.getMessage(), "Ошибка I/O",
JOptionPane.OK_OPTION);
} finally {
if (session != null && session.isOpen()) {
session.close();
}
}
return studs;
}
Слайд 98
public void deleteStudent(Student stud) throws SQLException {
Session session = null;
try {
session = HibernateUtil.getSessionFactory().openSession();
session.beginTransaction();
session.delete(stud);
session.getTransaction().commit();
} catch (Exception e) {
JOptionPane.showMessageDialog(null, e.getMessage(),
"Ошибка I/O", JOptionPane.OK_OPTION);
} finally {
if (session != null && session.isOpen()) {
session.close();
}
}
}
}
Слайд 99
Создадим класс Factory в пакете DAO, к которому
будем обращаться за нашими реализациями DAO, от которых и
будем вызывать необходимые нам методы:
package DAO;
import DAO.Impl.StudentDAOImpl;
public class Factory {
private static StudentDAO studentDAO = null;
private static Factory instance = null;
public static synchronized Factory getInstance(){
if (instance == null){
instance = new Factory();
}
return instance;
}
public StudentDAO getStudentDAO(){
if (studentDAO == null){
studentDAO = new StudentDAOImpl();
}
return studentDAO;
}
}
Слайд 100
Метод main будет иметь вид:
import DAO.Factory;
public class Main
{
public static void main(String[] args)
throws SQLException {
//Создадим двух студентов
Student s1 = new Student();
Student s2 = new Student();
//Проинициализируем их
s1.setName("Ivanov Ivan");
s1.setAge(21l);
s2.setName("Petrova Alisa");
s2.setAge(24l);
//Сохраним их в бд, id будут сгенерированы автоматически
Factory.getInstance().getStudentDAO().addStudent(s1);
Factory.getInstance().getStudentDAO().addStudent(s2);
//Выведем всех студентов из бд
List studs = Factory.getInstance().getStudentDAO().getAllStudents();
for(int i = 0; i < studs.size(); ++i) {
System.out.println("Имя студента : " + studs.get(i).getName() + ", Возраст : " +
studs.get(i).getAge() +", id : " + studs.get(i).getId());
System.out.println("=============================");
}
}
}
Слайд 101
Запросы в Hibernate
Запросы возвращают набор данных из базы
данных, удовлетворяющих заданному условию.
Библиотека Hibernate предлагает три вида
запросов к БД:
1) Criteria
2) SQL
3) HQL
Слайд 102
Запросы с использованием Criteria
Объект Criteria создается с помощью
метода createCriteria экземпляра класса Session:
Criteria crit = session.createCriteria(Student.class); //создаем
критерий
запроса
crit.setMaxResults(50); //ограничиваем число результатов
List studs = crit.list(); //помещаем результаты в список
В данном примере был создан критерий запроса на основе класса Student
Сужение выборки осуществляется следующим образом:
List studs = session.createCriteria(Student.class)
.add( Expression.like("name", "Ivanov%") )
.add( Expression.between("age", 18, 25) )
.list();
List studs = session.createCriteria(Student.class)
.add( Expression.like("name", "_van%") )
.add( Expression.or(
Expression.eq( "age", new Integer(20) ),
Expression.isNull("age")
) ).list();
Слайд 103
List studs = session.createCriteria(Student.class)
.add( Expression.in( "name",
new String[] { "Ivanov Ivan",
"Petrov Petia", "Zubin Egor" } ) )
.add( Expression.disjunction()
.add( Expression.isNull("age") )
.add( Expression.eq("age", new Integer(20) ) )
.add( Expression.eq("age", new Integer(21) ) )
.add( Expression.eq("age", new Integer(22) ) )
) ).list();
Слайд 104
Expression.like — указывает шаблон, где ‘_’ — любой
один символ, ‘%’ — любое количество символов
Expression.isNull — значение
поля равно NULL.
Expression.between — ‘age’ — имя поля, 18 — минимальное значение указанного поля, 25 — его максимальное значение
Expression.in — указывает диапазон значений конкретного поля
Expression.disjunction, Expression.or — дизъюнкция (OR) — объединяет в себе несколько других выражений оператором ИЛИ.
Expression.eq — определяет равенство поля какому-то значению.
Результаты также можно отсортировать:
List studs = sess.createCriteria(Student.class)
.add( Expression.like("name", "Iv%")
.addOrder( Order.asc("name") ) //по возрастанию
.addOrder( Order.desc("age") ) //по убыванию
.list();
Также есть возможность запроса по данным экземпляра класса:
Student s = new Student();
s.setName("Ivanov Ivan");
s.setAge(20l);
List results = session.createCriteria(Student.class)
.add( Example.create(s))
.list();
Слайд 105
Поля объекта, имеющие значение null или являющиеся идентификаторами,
будут игнорироваться.
Example также можно настраивать:
Example example = Example.create(s)
.excludeZeroes() //исключает поля с нулевыми значениями
.excludeProperty("name") //исключает поле "name"
.ignoreCase() //задает независимое от регистра сравнение строк
.enableLike(); //использует like для сравнения строк
List results = session.createCriteria(Student.class)
.add(example)
.list();
Слайд 106
Запросы с использованием SQL
Hibernate позволяет выражать запросы на
родном для базы данных диалекте SQL. Выглядеть это будет,
примерно, следующим образом:
sess.createSQLQuery("select * fromStudent").addEntity(Student.class).list();
sess.createSQLQuery("select id, name, age from Student")
.addEntity(Student.class).list()
В запросах также можно указывать параметры:
Query query = session.createSQLQuery("select * from Student where
name like ?").addEntity(Student.class);
List result = query.setString(0, "Ivan%").list();
query = session.createSQLQuery("select * from Student where name like
:name").addEntity(Student.class);
List result = query.setString("name", "Ivan%").list();
В первом случае с помощью query.setString указывается порядковый номер параметра (?) и значение типа String, которое вместо него подставится.
Если значение типа Long, то будет setLong, если Date, то setDate и так далее.
Во втором случае имя параметра задано явно, поэтому значение задается параметру по имени.
Слайд 107
Запросы с использованием HQL
Hibernate позволяет производить запросы на
HQL(The Hibernate Query Language — Язык запросов Hibernate), который
во многом похож на язык SQL, с той разницей, что является полностью объектно-ориентированным.
Если запрос с помощью SQL производился методом createSQLQuery, то в HQL будет просто createQuery.
Простой пример:
List studs = (List)session.createQuery("from Student
order by name").list()
Видно, что select в начале запроса можно не указывать.
Поскольку HQL — объектно-ориентированный язык, то значение полей можно выбрать и так:
List names = (List)session.createQuery("select
stud.name from Student stud order by name").list();
А можно и так:
List result = session.createQuery("select new list(stud, name, stud.age)
from Student as stud").list();
Язык HQL относительно сложен, но зато богат и дает очень много возможностей.
Слайд 108
Отношения в Hibernate
Помимо таблицы Student, создадим еще две
таблицы Test и Statistics.
Они будут связаны следующим образом:
Таблица
Statistics служит для связи таблиц Student и Test, чтобы избежать отношения многие ко многим.
Слайд 109
Создадим эти две таблицы:
CREATE TABLE Test(tid NUMBER(10) NOT
NULL,
tname varchar(100) NOT NULL, CONSTRAINT pk_Test PRIMARY KEY(tid));
CREATE TABLE
Statistics(stid NUMBER(10) NOT NULL,
id NUMBER(10) NOT NULL,
tid NUMBER(10) NOT NULL,
CONSTRAINT pk_Statistics PRIMARY KEY(stid),
CONSTRAINT fk_Student FOREIGN KEY(id) REFERENCES Student(id), CONSTRAINT fk_Test FOREIGN KEY(tid) REFERENCES Test(tid));
Также в файл hibernate.cfg.xml добавим маппинги новых классов:
Рассмотрим код.
Создаем в пакете logic классы-сущности:
Слайд 110
Test
package logic;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.JoinTable;
import javax.persistence.Table;
import
javax.persistence.JoinColumn;
import org.hibernate.annotations.GenericGenerator;
@Entity
@Table(name="Test")
public class Test {
private
Long tid;
private String tname;
public Test(){
tname = null;
}
Слайд 111
public Test(Test s){
tname =
s.getTName();
}
@Id
@GeneratedValue(generator="increment")
@GenericGenerator(name="increment", strategy = "increment")
@Column(name="tid")
public Long getTid() {
return tid;
}
@Column(name="tname")
public String getTName(){
return tname;
}
public void setId(Long i){
tid = i;
}
public void setTName(String s){
tname = s;
}
}
Слайд 112
Statistics
package logic;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.Table;
import org.hibernate.annotations.GenericGenerator;
@Entity
@Table(name="Statistics")
public
class Statistics {
private
Long stid;
private Long id;
private Long tid;
public Statistics(){
}
Слайд 113
@Id
@GeneratedValue(generator="increment")
@GenericGenerator(name="increment", strategy = "increment")
@Column(name="stid")
public Long getStid(){
return stid;
}
@Column(name="id")
public Long getId(){
return id;
}
@Column(name="tid")
public Long getTid(){
return tid;
}
}
Слайд 114
Классы TestDAO и TestDAOImpl создаются аналогично как для
сущности Student.
Осталось только показать Hibernate, как эти таблицы
между собой связаны.
В Hibernate для этого предусмотрены следующие виды аннотаций: @OneToOne, @OneToMany, @ManyToOne, @ManyToMany.
Например, чтобы связать таблицы Student и Statistics связью многие к одному, следует добавить в класс Student следующей код:
private Statistics stat;
@ManyToOne
@JoinTable(name = "id")
public Statistics getStat(){
return stat;
}
Слайд 115
В классе Statistics аннотируем связь один ко многим
с классом Student:
private Set studs = new HashSet(0);
@OneToMany
@JoinTable(name =
"id")
public Set getStuds() {
return studs;
}
В классе Student объявили атрибут типа Statistics и обозначили, что данная таблица связана отношением многие к одному с таблицей, представленной классом-сущностью Statistics.
А в классе Statistics указали связь один ко многим с классом Student.
С помощью аннотации @JoinTable мы указываем, какое поле является внешним ключом к текущей таблице.
Слайд 116
Так же обозначаем отношение таблицы Test и Statistics,
просто добавив в класс Test код:
private Statistics stat;
@ManyToOne
@JoinTable(name =
"id")
public Statistics getStat(){
return stat;
}
В классе Statistics аннотируем связь один ко многим с классом Test:
private Set tests = new HashSet(0);
@OneToMany
@JoinTable(name = "id")
public Set getTests() {
return tests;
}
Слайд 117
Поскольку таблица Statistics является не просто таблицей, связанной
со Student и Test, а она разбивает нежелательную связь
многие ко многим, мы также можем показать это Hibernate.
Просто вместо того, чтобы отдельно обозначать связь в каждой таблице, мы обозначим всю связь в одной, к примеру, в таблице Test добавив код:
private Student stud;
@ManyToOne
@JoinTable(name = "Statistics",
joinColumns = @JoinColumn(name = "tid"),
inverseJoinColumns = @JoinColumn(name = "id"))
public Student getStud(){
return stud;
}
C помощью параметра name аннотации @JoinTable мы обозначаем связующую таблицу,
joinColumns = @JoinColumn — указываем через какой ключ связаны таблицы Test и Statistics,
inverseJoinColumns = @JoinColumn — указываем, через какие ключи связаны уже Statistics и Student.
Слайд 118
Если бы мы обозначали эту связь в классе
Student:
private Test test;
@ManyToOne
@JoinTable(name = "Statistics", joinColumns = @JoinColumn(name =
"id"), inverseJoinColumns = @JoinColumn(name = "tid"))
public Test getTest(){
return test;
}
Слайд 119
Другой пример реализации Hibernate JPA
Рассмотрим пример работы с
базой данный с использованием объектно-ориентированной модели.
Пусть имеется СУБД
MySQL.
Предположим, что создана база данный с именем mybase, а в ней имеется следующая таблица, с именем mytable:
Слайд 120
Создадим класс mytable, который соответствует записи в таблице:
import
java.io.Serializable;
import javax.persistence.*;
@Entity
@Table(name= “mytable”)
public class mytable implements Serializable {
private static final long serialVersionUID = 1L;
@Id
@Column(name= “id”)
@GeneratedValue(strategy = GenerationType.AUTO)
private Long id;
@Column(name= “name”, length=64)
private String name;
@Column(name= “age”, length=64)
private Byte age;
Слайд 121
public mytable() {};
public mytable(String name,Byte b){
this.age=b;
this.name=name;
}
public Long getId() {return id; }
public void setId(Long id) {this.id = id;}
public void setname(String name){
this.name=name;
};
public void setAge(Byte age){
this.age=age;
};
public String toString() {
return "testproject.mytable[id=" + id + "]";
}
}
Слайд 122
Hibernate для своей работы требует специальный файл конфигурации(если
точнее, то он используется во время компиляции), который называется
persistence.xml. Файл имеет вид:
transaction-type="RESOURCE_LOCAL">
org.eclipse.persistence.jpa.PersistenceProvider
mytable
value="jdbc:mysql://localhost:3306/mybase" />
value="qwertyui" />
value="alex" />
Слайд 124
Тогда работа с базой данных будет иметь вид:
import
javax.persistence.*;
public class Main {
public static final EntityManagerFactory emf
=
Persistence.createEntityManagerFactory(
"JavaApplication3PU");
public static EntityManager em = emf.createEntityManager();
public static void main(String[] args) {
mytable te=new mytable("aaaa",new Byte((byte)34));
te.setname("bbb");
te.setage(new Byte((byte)56));
em.getTransaction().begin();
em.persist(te);
em.getTransaction().commit();
}
}
Слайд 125
Компиляция и запуск
Для компиляции удобно воспользоваться утилитой ant(разработка
Apache foundation http://ant.apache.org/).
Создаем директорию, например base.
В base создаем поддиректорию
src, в которую помещаем файлы Main.java и mytable.java
В base создаем поддиректорию META-INF и в нее помещаем файл persistence.xml
В base создаем поддиректорию lib и в нее помещаем библиотеки
eclipselink-2.0.2.jar
eclipselink-javax.persistence-2.0.jar
mysql-connector-java-5.1.6-bin.jar
Слайд 126
5. В base помещаем файл build.xml, который имеет
вид:
default="deploy">
jboss-4.2.3.GA/server/default/deploy" />
value="${basedir}/src" />
value="${basedir}/build" />
"clean,copy-resources,compile">
classpathref="libraries">
Слайд 131
6. Перейти в директорию base и из консоли
запустить ant
D:\base>ant
В результате в папке build будут находится скомпилированные
файлы.
7. Запуск приложения будет иметь вид:
>java –cp .;d:\base\lib\eclipselink-2.0.2.jar; d:\base\lib\eclipselink-javax.persistence-2.0.jar;
d:\base\lib\ mysql-connector-java-5.1.6-bin.jar Main
Слайд 132
Пакет JOOQ
Данный пакет представляет собой Linq для Java.
С помощью данной библиотеки можно строить запросы прямо в
Java коде.
Рассмотрим пример.
Пусть имеется база данных mybase и в ней таблица mytable, которая имеет вид:
Слайд 133
Создаем файл mybase.properties:
jdbc.Driver=com.mysql.jdbc.Driver
jdbc.URL=jdbc:mysql://localhost:3306/mybase
jdbc.Schema=mybase
jdbc.User=muser
jdbc.Password=qwertyui
#The default code generator. You can
override this one, to generate your own code style
#Defaults
to org.jooq.util.DefaultGenerator
generator=org.jooq.util.DefaultGenerator
#The database type. The format here is:
#generator.database=org.util.[database].[database]Database
generator.database=org.jooq.util.mysql.MySQLDatabase
#All elements that are generated from your schema (several Java regular expressions, separated by comma)
#Watch out for case-sensitivity. Depending on your database, this might be important!
generator.database.includes=.*
#All elements that are excluded from your schema (several Java regular expressions, separated by comma). Excludes match before includes
generator.database.excludes=
Слайд 134
#Primary key / foreign key relations should be
generated and used.
#This will be a prerequisite for
various advanced features
#Defaults to false
generator.generate.relations=true
#Generate deprecated code for backwards compatibility
#Defaults to true
generator.generate.deprecated=false
#The destination package of your generated classes (within the destination directory)
generator.target.package=jooqs.Generated.test.generated
#The destination directory of your generated classes
generator.target.directory=C:/Java/Generated
Слайд 135
Генерируем классы, соответствующие базе данных
java -classpath jooq-1.6.9.jar;jooq-meta-1.6.9.jar;
jooq-codegen-1.6.9.jar;mysql-connector-java-
5.1.18-bin.jar;. org.jooq.util.GenerationTool
/mybase.properties
Тогда получение записей из таблицы mytable
будет иметь следующий вид:
package jooqs;
import java.sql.*;
import jooqs.Generated.test.generated.*;
import jooqs.Generated.test.generated.tables.*;
import org.jooq.Record;
import org.jooq.Result;
Слайд 136
public class Main {
public static void
main(String[] args) {
Connection conn =
null;
try{
String userName = "muser";
String password = "qwertyui";
String url = "jdbc:mysql://localhost/mybase";
Class.forName ("com.mysql.jdbc.Driver").newInstance();
conn = DriverManager.getConnection (url, userName,
password);
//создаем объект соответствующий базе данных
MybaseFactory mb=new MybaseFactory(conn);
![//выполняем запросint[] updateCounts = stmt.executeBatch();В массиве updateCounts содержаться числа:1.>=0 – означает, что](/img/tmb/15/1413755/e4251a80ef2bd64dd55c91cb10edfef8-720x.jpg "JDBC стандартный прикладной интерфейс (API) языка Java. (Лекция 16)")
![try {Employee[] employees = new Employee[10];PreparedStatement statement=](/img/tmb/15/1413755/18de6e77b1cbf006418069ff9a51d8a6-720x.jpg "JDBC стандартный прикладной интерфейс (API) языка Java. (Лекция 16)")
![int [] updateCounts = statement.executeBatch(); } catch (BatchUpdateException e) { e.printStackTrace();](/img/tmb/15/1413755/fe90aae65fb695bee7cb504eea6aa508-720x.jpg "JDBC стандартный прикладной интерфейс (API) языка Java. (Лекция 16)")
![public class Main { public static void main(String[] args) {](/img/tmb/15/1413755/b185cdd499af664e424f70a8999f2bfb-720x.jpg "JDBC стандартный прикладной интерфейс (API) языка Java. (Лекция 16)")
