361 lines
14 KiB
Java
361 lines
14 KiB
Java
package com.rosetta.im.database;
|
||
|
||
import java.util.HashMap;
|
||
import java.util.List;
|
||
|
||
import org.hibernate.Session;
|
||
import org.hibernate.Transaction;
|
||
import org.hibernate.query.Query;
|
||
|
||
/**
|
||
* Базовый репозиторий для работы с сущностями базы данных
|
||
*/
|
||
public abstract class Repository<T> {
|
||
|
||
protected Class<T> entityClass;
|
||
|
||
public Repository(Class<T> entityClass) {
|
||
this.entityClass = entityClass;
|
||
}
|
||
|
||
/**
|
||
* Сохранение сущности в базе данных
|
||
* @param entity сущность для сохранения
|
||
* @return сохраненная сущность
|
||
*/
|
||
public T save(T entity) {
|
||
return executeInTransaction(session -> {
|
||
session.persist(entity);
|
||
return entity;
|
||
});
|
||
}
|
||
|
||
/**
|
||
* Обновление сущности в базе данных
|
||
* @param entity сущность для обновления
|
||
* @return обновленная сущность
|
||
*/
|
||
public T update(T entity) {
|
||
return executeInTransaction(session -> {
|
||
session.merge(entity);
|
||
return entity;
|
||
});
|
||
}
|
||
|
||
/**
|
||
* Удаление сущности из базы данных
|
||
* @param entity сущность для удаления
|
||
*/
|
||
public void delete(T entity) {
|
||
executeInTransaction(session -> {
|
||
session.remove(entity);
|
||
return null;
|
||
});
|
||
}
|
||
|
||
/**
|
||
* Поиск сущности по значению одного поля
|
||
* @param fieldName поле
|
||
* @param value значение
|
||
* @return найденная сущность или null
|
||
*/
|
||
public T findByField(String fieldName, Object value) {
|
||
return executeInSession(session -> {
|
||
String queryString = "FROM " + entityClass.getSimpleName() + " WHERE " + fieldName + " = :value";
|
||
return session.createQuery(queryString, entityClass)
|
||
.setParameter("value", value)
|
||
.uniqueResult();
|
||
});
|
||
}
|
||
|
||
/**
|
||
* Поиск сущности по значению одного поля с использованием оператора LIKE
|
||
* @param fieldName поле
|
||
* @param value значение
|
||
* @return найденная сущность или null
|
||
*/
|
||
public T likeSearch(String fieldName, String value) {
|
||
return executeInSession(session -> {
|
||
String queryString = "FROM " + entityClass.getSimpleName() + " WHERE " + fieldName + " LIKE :value";
|
||
return session.createQuery(queryString, entityClass)
|
||
.setParameter("value", "%" + value + "%")
|
||
.uniqueResult();
|
||
});
|
||
}
|
||
|
||
/**
|
||
* Поиск сущности по значению одного поля с использованием оператора LIKE
|
||
* @param fieldName поле
|
||
* @param value значение
|
||
* @return найденная сущность или null
|
||
*/
|
||
public List<T> likeSearchAll(String fieldName, String value) {
|
||
return executeInSession(session -> {
|
||
String queryString = "FROM " + entityClass.getSimpleName() + " WHERE " + fieldName + " LIKE :value";
|
||
return session.createQuery(queryString, entityClass)
|
||
.setParameter("value", value + "%")
|
||
.list();
|
||
});
|
||
}
|
||
|
||
/**
|
||
* Поиск сущности по значению одного поля с использованием оператора LIKE и ограничения LIMIT
|
||
* @param fieldName поле
|
||
* @param value значение
|
||
* @return найденная сущность или null
|
||
*/
|
||
public List<T> likeSearchAll(String fieldName, String value, int take) {
|
||
return executeInSession(session -> {
|
||
String queryString = "FROM " + entityClass.getSimpleName() + " WHERE " + fieldName + " LIKE :value";
|
||
return session.createQuery(queryString, entityClass)
|
||
.setParameter("value", value + "%")
|
||
.setMaxResults(take)
|
||
.list();
|
||
});
|
||
}
|
||
|
||
/**
|
||
* Поиск сущности по набору полей
|
||
* @param fields карта полей и их значений
|
||
* @return найденная сущность или null
|
||
*/
|
||
public T findByField(HashMap<String, Object> fields) {
|
||
return executeInSession(session -> {
|
||
StringBuilder queryString = new StringBuilder("FROM " + entityClass.getSimpleName() + " WHERE ");
|
||
int index = 0;
|
||
for (String fieldName : fields.keySet()) {
|
||
if (index > 0) {
|
||
queryString.append(" AND ");
|
||
}
|
||
queryString.append(fieldName).append(" = :").append(fieldName);
|
||
index++;
|
||
}
|
||
var query = session.createQuery(queryString.toString(), this.entityClass);
|
||
for (var entry : fields.entrySet()) {
|
||
query.setParameter(entry.getKey(), entry.getValue());
|
||
}
|
||
return query.uniqueResult();
|
||
});
|
||
}
|
||
|
||
/**
|
||
* Удаление сущностей по значению одного поля
|
||
* @param fieldName поле
|
||
* @param value значение
|
||
*/
|
||
public void deleteByField(String fieldName, Object value) {
|
||
executeInTransaction(session -> {
|
||
String queryString = "DELETE FROM " + entityClass.getSimpleName() + " WHERE " + fieldName + " = :value";
|
||
session.createQuery(queryString, entityClass)
|
||
.setParameter("value", value)
|
||
.executeUpdate();
|
||
return null;
|
||
});
|
||
}
|
||
|
||
/**
|
||
* Поиск всех сущностей по значению одного поля
|
||
* @param fieldName поле
|
||
* @param value значение
|
||
* @return список найденных сущностей
|
||
*/
|
||
public List<T> findAllByField(String fieldName, Object value) {
|
||
return executeInSession(session -> {
|
||
String queryString = "FROM " + entityClass.getSimpleName() + " WHERE " + fieldName + " = :value";
|
||
return session.createQuery(queryString, entityClass)
|
||
.setParameter("value", value)
|
||
.list();
|
||
});
|
||
}
|
||
|
||
/**
|
||
* Поиск всех сущностей по значению набора полей
|
||
* @param fields карта полей и их значений
|
||
* @return список найденных сущностей
|
||
*/
|
||
public List<T> findAllByField(HashMap<String, Object> fields) {
|
||
return executeInSession(session -> {
|
||
StringBuilder queryString = new StringBuilder("FROM " + entityClass.getSimpleName() + " WHERE ");
|
||
int index = 0;
|
||
for (String fieldName : fields.keySet()) {
|
||
if (index > 0) {
|
||
queryString.append(" AND ");
|
||
}
|
||
queryString.append(fieldName).append(" = :").append(fieldName);
|
||
index++;
|
||
}
|
||
var query = session.createQuery(queryString.toString(), this.entityClass);
|
||
for (var entry : fields.entrySet()) {
|
||
query.setParameter(entry.getKey(), entry.getValue());
|
||
}
|
||
return query.list();
|
||
});
|
||
}
|
||
|
||
/**
|
||
* Поиск всех сущностей, тяжелый метод, лучше не выполнять без необходимости
|
||
* @return список всех сущностей
|
||
*/
|
||
public List<T> findAll() {
|
||
return executeInSession(session -> {
|
||
String queryString = "FROM " + entityClass.getSimpleName();
|
||
return session.createQuery(queryString, entityClass).list();
|
||
});
|
||
}
|
||
|
||
/**
|
||
* Подсчет всех сущностей в таблице
|
||
* @return количество сущностей
|
||
*/
|
||
public long countAll() {
|
||
return executeInSession(session -> {
|
||
String queryString = "SELECT COUNT(*) FROM " + entityClass.getSimpleName();
|
||
return session.createQuery(queryString, Long.class).uniqueResult();
|
||
});
|
||
}
|
||
|
||
/**
|
||
* Подсчет сущностей по значению одного поля
|
||
* @param fieldName поле
|
||
* @param value значение
|
||
* @return количество сущностей
|
||
*/
|
||
public long countByField(String fieldName, Object value) {
|
||
return executeInSession(session -> {
|
||
String queryString = "SELECT COUNT(*) FROM " + entityClass.getSimpleName() + " WHERE " + fieldName + " = :value";
|
||
return session.createQuery(queryString, Long.class)
|
||
.setParameter("value", value)
|
||
.uniqueResult();
|
||
});
|
||
}
|
||
|
||
/**
|
||
* Выполняет запрос с параметрами и возвращает список сущностей
|
||
* @param queryString SQL запрос
|
||
* @param parameters параметры запроса
|
||
* @return список сущностей
|
||
*/
|
||
public QuerySession<T> buildQuery(String queryString, HashMap<String, Object> parameters) {
|
||
Session session = HibernateUtil.openSession();
|
||
try {
|
||
Query<T> query = session.createQuery(queryString, entityClass);
|
||
for (var entry : parameters.entrySet()) {
|
||
query.setParameter(entry.getKey(), entry.getValue());
|
||
}
|
||
return new QuerySession<>(session, query);
|
||
} catch (Exception e) {
|
||
session.close();
|
||
throw e;
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Подсчет сущностей по набору полей
|
||
* @param fields карта полей и их значений
|
||
* @return количество сущностей
|
||
*/
|
||
public long countByField(HashMap<String, Object> fields) {
|
||
return executeInSession(session -> {
|
||
StringBuilder queryString = new StringBuilder("SELECT COUNT(*) FROM " + entityClass.getSimpleName() + " WHERE ");
|
||
int index = 0;
|
||
for (String fieldName : fields.keySet()) {
|
||
if (index > 0) {
|
||
queryString.append(" AND ");
|
||
}
|
||
queryString.append(fieldName).append(" = :").append(fieldName);
|
||
index++;
|
||
}
|
||
var query = session.createQuery(queryString.toString(), Long.class);
|
||
for (var entry : fields.entrySet()) {
|
||
query.setParameter(entry.getKey(), entry.getValue());
|
||
}
|
||
return query.uniqueResult();
|
||
});
|
||
}
|
||
|
||
/**
|
||
* Обновление полей сущности по заданным условиям
|
||
* @param fieldsToUpdate поля для обновления
|
||
* @param whereFields условия для выбора сущностей
|
||
*/
|
||
public void update(HashMap<String, Object> fieldsToUpdate, HashMap<String, Object> whereFields) {
|
||
executeInTransaction(session -> {
|
||
StringBuilder queryString = new StringBuilder("UPDATE " + entityClass.getSimpleName() + " SET ");
|
||
int index = 0;
|
||
for (String fieldName : fieldsToUpdate.keySet()) {
|
||
if (index > 0) {
|
||
queryString.append(", ");
|
||
}
|
||
queryString.append(fieldName).append(" = :").append(fieldName);
|
||
index++;
|
||
}
|
||
queryString.append(" WHERE ");
|
||
index = 0;
|
||
for (String fieldName : whereFields.keySet()) {
|
||
if (index > 0) {
|
||
queryString.append(" AND ");
|
||
}
|
||
/**
|
||
* Добавляем префикс where_ к параметрам условия WHERE,
|
||
* чтобы избежать конфликтов имен с параметрами SET
|
||
*/
|
||
queryString.append(fieldName).append(" = :where_").append(fieldName);
|
||
index++;
|
||
}
|
||
var query = session.createQuery(queryString.toString(), this.entityClass);
|
||
for (var entry : fieldsToUpdate.entrySet()) {
|
||
query.setParameter(entry.getKey(), entry.getValue());
|
||
}
|
||
for (var entry : whereFields.entrySet()) {
|
||
/**
|
||
* Устанавливаем параметры с префиксом where_ для условий WHERE,
|
||
* чтобы избежать конфликтов имен с параметрами SET
|
||
*/
|
||
query.setParameter("where_" + entry.getKey(), entry.getValue());
|
||
}
|
||
query.executeUpdate();
|
||
return null;
|
||
});
|
||
}
|
||
|
||
protected <R> R executeInTransaction(TransactionCallback<R> callback) {
|
||
Session session = HibernateUtil.openSession();
|
||
Transaction transaction = null;
|
||
try {
|
||
transaction = session.beginTransaction();
|
||
R result = callback.execute(session);
|
||
transaction.commit();
|
||
return result;
|
||
} catch (Exception e) {
|
||
if (transaction != null) {
|
||
transaction.rollback();
|
||
}
|
||
throw new RuntimeException("Transaction failed: " + e.getMessage(), e);
|
||
} finally {
|
||
session.close();
|
||
}
|
||
}
|
||
|
||
protected <R> R executeInSession(SessionCallback<R> callback) {
|
||
try (Session session = HibernateUtil.openSession()) {
|
||
return callback.execute(session);
|
||
}
|
||
}
|
||
|
||
|
||
/**
|
||
* Функциональный интерфейс для обратного вызова транзакции.
|
||
* (Коллбэки)
|
||
*/
|
||
@FunctionalInterface
|
||
protected interface TransactionCallback<R> {
|
||
R execute(Session session);
|
||
}
|
||
|
||
@FunctionalInterface
|
||
protected interface SessionCallback<R> {
|
||
R execute(Session session);
|
||
}
|
||
|
||
}
|