iSharkFly-Docs
/
java-tutorials
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

JAVA-2432: Moved 5 articles to spring-data-jpa-query-2

This commit is contained in:
sampadawagde 2020-09-28 23:17:31 +05:30
parent 7de65d1211
commit 2dd77a259d
91 changed files with 3681 additions and 141 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
persistence-modules/spring-data-jpa-query-2/README.md
View File

@ -6,6 +6,12 @@ This module contains articles about querying data using Spring Data JPA
- [Spring Data JPA @Query Annotation](https://www.baeldung.com/spring-data-jpa-query)
- [Use Criteria Queries in a Spring Data Application](https://www.baeldung.com/spring-data-criteria-queries)
- [Query Entities by Dates and Times with Spring Data JPA](https://www.baeldung.com/spring-data-jpa-query-by-date)
- [Hibernate Pagination](https://www.baeldung.com/hibernate-pagination)
- [Sorting with Hibernate](https://www.baeldung.com/hibernate-sort)
- [Stored Procedures with Hibernate](https://www.baeldung.com/stored-procedures-with-hibernate-tutorial)
- [Eager/Lazy Loading In Hibernate](https://www.baeldung.com/hibernate-lazy-eager-loading)
- [Auditing with JPA, Hibernate, and Spring Data JPA](https://www.baeldung.com/database-auditing-jpa)
- More articles: [[<-- prev]](../spring-data-jpa-query)
### Eclipse Config

58
persistence-modules/spring-data-jpa-query-2/pom.xml
View File

@ -18,6 +18,10 @@
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-jpa</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.security</groupId>
<artifactId>spring-security-core</artifactId>
</dependency>
<dependency>
<groupId>com.h2database</groupId>
@ -28,6 +32,55 @@
<groupId>com.fasterxml.jackson.core</groupId>
<artifactId>jackson-databind</artifactId>
</dependency>
<dependency>
<groupId>org.hibernate</groupId>
<artifactId>hibernate-envers</artifactId>
</dependency>
<dependency>
<groupId>javax.transaction</groupId>
<artifactId>jta</artifactId>
<version>${jta.version}</version>
</dependency>
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
</dependency>
<dependency>
<groupId>com.google.guava</groupId>
<artifactId>guava</artifactId>
<version>${guava.version}</version>
</dependency>
<dependency>
<groupId>org.apache.tomcat</groupId>
<artifactId>tomcat-dbcp</artifactId>
<version>${tomcat-dbcp.version}</version>
</dependency>
<dependency>
<groupId>org.hibernate</groupId>
<artifactId>hibernate-core</artifactId>
<version>${hibernate.version}</version>
</dependency>
<dependency>
<groupId>org.hibernate</groupId>
<artifactId>hibernate-envers</artifactId>
<version>${hibernate.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-test</artifactId>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.springframework.security</groupId>
<artifactId>spring-security-test</artifactId>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.hsqldb</groupId>
<artifactId>hsqldb</artifactId>
<scope>test</scope>
</dependency>
</dependencies>
<properties>
@ -35,5 +88,10 @@
<maven-surefire-plugin.version>2.22.2</maven-surefire-plugin.version>
<junit-jupiter.version>5.6.2</junit-jupiter.version>
<junit.version>4.13</junit.version>
<tomcat-dbcp.version>9.0.0.M26</tomcat-dbcp.version>
<jta.version>1.1</jta.version>
<guava.version>21.0</guava.version>
<!-- persistence -->
<hibernate.version>5.2.10.Final</hibernate.version>
</properties>
</project>

186
persistence-modules/spring-data-jpa-query-2/src/main/java/com/baeldung/config/PersistenceConfig.java Normal file
View File

@ -0,0 +1,186 @@
package com.baeldung.config;
import java.util.Properties;
import javax.sql.DataSource;
import org.apache.tomcat.dbcp.dbcp2.BasicDataSource;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.PropertySource;
import org.springframework.core.env.Environment;
import org.springframework.dao.annotation.PersistenceExceptionTranslationPostProcessor;
import org.springframework.data.domain.AuditorAware;
import org.springframework.data.jpa.repository.config.EnableJpaAuditing;
import org.springframework.data.jpa.repository.config.EnableJpaRepositories;
import org.springframework.orm.hibernate5.HibernateTransactionManager;
import org.springframework.orm.hibernate5.LocalSessionFactoryBean;
import org.springframework.orm.jpa.JpaTransactionManager;
import org.springframework.orm.jpa.JpaVendorAdapter;
import org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean;
import org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter;
import org.springframework.transaction.PlatformTransactionManager;
import org.springframework.transaction.annotation.EnableTransactionManagement;
import com.baeldung.hibernate.audit.AuditorAwareImpl;
import com.baeldung.persistence.dao.IBarAuditableDao;
import com.baeldung.persistence.dao.IBarDao;
import com.baeldung.persistence.dao.IFooAuditableDao;
import com.baeldung.persistence.dao.IFooDao;
import com.baeldung.persistence.dao.impl.BarAuditableDao;
import com.baeldung.persistence.dao.impl.BarDao;
import com.baeldung.persistence.dao.impl.BarJpaDao;
import com.baeldung.persistence.dao.impl.FooAuditableDao;
import com.baeldung.persistence.dao.impl.FooDao;
import com.baeldung.persistence.service.IBarAuditableService;
import com.baeldung.persistence.service.IBarService;
import com.baeldung.persistence.service.IFooAuditableService;
import com.baeldung.persistence.service.IFooService;
import com.baeldung.persistence.service.impl.BarAuditableService;
import com.baeldung.persistence.service.impl.BarJpaService;
import com.baeldung.persistence.service.impl.BarSpringDataJpaService;
import com.baeldung.persistence.service.impl.FooAuditableService;
import com.baeldung.persistence.service.impl.FooService;
import com.google.common.base.Preconditions;
@Configuration
@EnableTransactionManagement
@EnableJpaRepositories(basePackages = { "com.baeldung.persistence" }, transactionManagerRef = "jpaTransactionManager", entityManagerFactoryRef = "jpaEntityManager")
@EnableJpaAuditing(auditorAwareRef = "auditorProvider")
@PropertySource({ "classpath:persistence-h2.properties" })
@ComponentScan({ "com.baeldung.persistence" })
public class PersistenceConfig {
@Autowired
private Environment env;
public PersistenceConfig() {
super();
}
@Bean("auditorProvider")
public AuditorAware<String> auditorProvider() {
return new AuditorAwareImpl();
}
@Bean
public LocalSessionFactoryBean sessionFactory() {
final LocalSessionFactoryBean sessionFactory = new LocalSessionFactoryBean();
sessionFactory.setDataSource(restDataSource());
sessionFactory.setPackagesToScan(new String[] { "com.baeldung.persistence.model" });
sessionFactory.setHibernateProperties(hibernateProperties());
return sessionFactory;
}
@Bean("jpaEntityManager")
public LocalContainerEntityManagerFactoryBean entityManagerFactory() {
final LocalContainerEntityManagerFactoryBean emf = new LocalContainerEntityManagerFactoryBean();
emf.setDataSource(restDataSource());
emf.setPackagesToScan(new String[] { "com.baeldung.persistence.model" });
final JpaVendorAdapter vendorAdapter = new HibernateJpaVendorAdapter();
emf.setJpaVendorAdapter(vendorAdapter);
emf.setJpaProperties(hibernateProperties());
return emf;
}
@Bean
public DataSource restDataSource() {
final BasicDataSource dataSource = new BasicDataSource();
dataSource.setDriverClassName(Preconditions.checkNotNull(env.getProperty("jdbc.driverClassName")));
dataSource.setUrl(Preconditions.checkNotNull(env.getProperty("jdbc.url")));
dataSource.setUsername(Preconditions.checkNotNull(env.getProperty("jdbc.user")));
dataSource.setPassword(Preconditions.checkNotNull(env.getProperty("jdbc.pass")));
return dataSource;
}
@Bean
public PlatformTransactionManager hibernateTransactionManager() {
final HibernateTransactionManager transactionManager = new HibernateTransactionManager();
transactionManager.setSessionFactory(sessionFactory().getObject());
return transactionManager;
}
@Bean
public PlatformTransactionManager jpaTransactionManager() {
final JpaTransactionManager transactionManager = new JpaTransactionManager();
transactionManager.setEntityManagerFactory(entityManagerFactory().getObject());
return transactionManager;
}
@Bean
public PersistenceExceptionTranslationPostProcessor exceptionTranslation() {
return new PersistenceExceptionTranslationPostProcessor();
}
@Bean
public IBarService barJpaService() {
return new BarJpaService();
}
@Bean
public IBarService barSpringDataJpaService() {
return new BarSpringDataJpaService();
}
@Bean
public IFooService fooHibernateService() {
return new FooService();
}
@Bean
public IBarAuditableService barHibernateAuditableService() {
return new BarAuditableService();
}
@Bean
public IFooAuditableService fooHibernateAuditableService() {
return new FooAuditableService();
}
@Bean
public IBarDao barJpaDao() {
return new BarJpaDao();
}
@Bean
public IBarDao barHibernateDao() {
return new BarDao();
}
@Bean
public IBarAuditableDao barHibernateAuditableDao() {
return new BarAuditableDao();
}
@Bean
public IFooDao fooHibernateDao() {
return new FooDao();
}
@Bean
public IFooAuditableDao fooHibernateAuditableDao() {
return new FooAuditableDao();
}
private final Properties hibernateProperties() {
final Properties hibernateProperties = new Properties();
hibernateProperties.setProperty("hibernate.hbm2ddl.auto", env.getProperty("hibernate.hbm2ddl.auto"));
hibernateProperties.setProperty("hibernate.dialect", env.getProperty("hibernate.dialect"));
hibernateProperties.setProperty("hibernate.show_sql", "true");
// hibernateProperties.setProperty("hibernate.format_sql", "true");
// hibernateProperties.setProperty("hibernate.globally_quoted_identifiers", "true");
// Envers properties
hibernateProperties.setProperty("org.hibernate.envers.audit_table_suffix", env.getProperty("envers.audit_table_suffix"));
return hibernateProperties;
}
}

18
persistence-modules/spring-data-jpa-query-2/src/main/java/com/baeldung/config/PersistenceXmlConfig.java Normal file
View File

@ -0,0 +1,18 @@
package com.baeldung.config;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.ImportResource;
import org.springframework.transaction.annotation.EnableTransactionManagement;
@Configuration
@EnableTransactionManagement
@ComponentScan({ "com.baeldung.persistence.dao", "com.baeldung.persistence.service" })
@ImportResource({ "classpath:hibernate4Config.xml" })
public class PersistenceXmlConfig {
public PersistenceXmlConfig() {
super();
}
}

18
persistence-modules/spring-data-jpa-query-2/src/main/java/com/baeldung/hibernate/audit/AuditorAwareImpl.java Normal file
View File

@ -0,0 +1,18 @@
package com.baeldung.hibernate.audit;
import java.util.Optional;
import org.springframework.data.domain.AuditorAware;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.context.SecurityContextHolder;
public class AuditorAwareImpl implements AuditorAware<String> {
@Override
public Optional<String> getCurrentAuditor() {
return Optional.ofNullable(SecurityContextHolder.getContext())
.map(e -> e.getAuthentication())
.map(Authentication::getName);
}
}

58
persistence-modules/spring-data-jpa-query-2/src/main/java/com/baeldung/hibernate/fetching/model/OrderDetail.java Normal file
View File

@ -0,0 +1,58 @@
package com.baeldung.hibernate.fetching.model;
import javax.persistence.*;
import java.io.Serializable;
import java.sql.Date;
@Entity
@Table(name = "USER_ORDER")
public class OrderDetail implements Serializable {
private static final long serialVersionUID = 1L;
@Id
@GeneratedValue
@Column(name = "ORDER_ID")
private Long orderId;
public OrderDetail() {
}
public OrderDetail(Date orderDate, String orderDesc) {
super();
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + ((orderId == null) ? 0 : orderId.hashCode());
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
OrderDetail other = (OrderDetail) obj;
if (orderId == null) {
if (other.orderId != null)
return false;
} else if (!orderId.equals(other.orderId))
return false;
return true;
}
public Long getOrderId() {
return orderId;
}
public void setOrderId(Long orderId) {
this.orderId = orderId;
}
}

71
persistence-modules/spring-data-jpa-query-2/src/main/java/com/baeldung/hibernate/fetching/model/UserEager.java Normal file
View File

@ -0,0 +1,71 @@
package com.baeldung.hibernate.fetching.model;
import javax.persistence.*;
import java.io.Serializable;
import java.util.HashSet;
import java.util.Set;
@Entity
@Table(name = "USER")
public class UserEager implements Serializable {
private static final long serialVersionUID = 1L;
@Id
@GeneratedValue
@Column(name = "USER_ID")
private Long userId;
@OneToMany(fetch = FetchType.EAGER)
private Set<OrderDetail> orderDetail = new HashSet();
public UserEager() {
}
public UserEager(final Long userId) {
super();
this.userId = userId;
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + ((userId == null) ? 0 : userId.hashCode());
return result;
}
@Override
public boolean equals(final Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
final UserEager other = (UserEager) obj;
if (userId == null) {
if (other.userId != null)
return false;
} else if (!userId.equals(other.userId))
return false;
return true;
}
public Long getUserId() {
return userId;
}
public void setUserId(final Long userId) {
this.userId = userId;
}
public Set<OrderDetail> getOrderDetail() {
return orderDetail;
}
public void setOrderDetail(Set<OrderDetail> orderDetail) {
this.orderDetail = orderDetail;
}
}

71
persistence-modules/spring-data-jpa-query-2/src/main/java/com/baeldung/hibernate/fetching/model/UserLazy.java Normal file
View File

@ -0,0 +1,71 @@
package com.baeldung.hibernate.fetching.model;
import javax.persistence.*;
import java.io.Serializable;
import java.util.HashSet;
import java.util.Set;
@Entity
@Table(name = "USER")
public class UserLazy implements Serializable {
private static final long serialVersionUID = 1L;
@Id
@GeneratedValue
@Column(name = "USER_ID")
private Long userId;
@OneToMany(fetch = FetchType.LAZY)
private Set<OrderDetail> orderDetail = new HashSet();
public UserLazy() {
}
public UserLazy(final Long userId) {
super();
this.userId = userId;
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + ((userId == null) ? 0 : userId.hashCode());
return result;
}
@Override
public boolean equals(final Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
final UserLazy other = (UserLazy) obj;
if (userId == null) {
if (other.userId != null)
return false;
} else if (!userId.equals(other.userId))
return false;
return true;
}
public Long getUserId() {
return userId;
}
public void setUserId(final Long userId) {
this.userId = userId;
}
public Set<OrderDetail> getOrderDetail() {
return orderDetail;
}
public void setOrderDetail(Set<OrderDetail> orderDetail) {
this.orderDetail = orderDetail;
}
}

29
persistence-modules/spring-data-jpa-query-2/src/main/java/com/baeldung/hibernate/fetching/util/HibernateUtil.java Normal file
View File

@ -0,0 +1,29 @@
package com.baeldung.hibernate.fetching.util;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
public class HibernateUtil {
@SuppressWarnings("deprecation")
public static Session getHibernateSession(String fetchMethod) {
// two config files are there
// one with lazy loading enabled
// another lazy = false
SessionFactory sf;
if ("lazy".equals(fetchMethod)) {
sf = new Configuration().configure("fetchingLazy.cfg.xml").buildSessionFactory();
} else {
sf = new Configuration().configure("fetching.cfg.xml").buildSessionFactory();
}
// fetching.cfg.xml is used for this example
return sf.openSession();
}
public static Session getHibernateSession() {
return new Configuration().configure("fetching.cfg.xml").buildSessionFactory().openSession();
}
}

68
persistence-modules/spring-data-jpa-query-2/src/main/java/com/baeldung/hibernate/fetching/view/FetchingAppView.java Normal file
View File

@ -0,0 +1,68 @@
package com.baeldung.hibernate.fetching.view;
import com.baeldung.hibernate.fetching.model.OrderDetail;
import com.baeldung.hibernate.fetching.model.UserEager;
import com.baeldung.hibernate.fetching.model.UserLazy;
import com.baeldung.hibernate.fetching.util.HibernateUtil;
import org.hibernate.Session;
import org.hibernate.Transaction;
import java.util.List;
import java.util.Set;
public class FetchingAppView {
public FetchingAppView() {
}
// lazily loaded
public Set<OrderDetail> lazyLoaded() {
final Session sessionLazy = HibernateUtil.getHibernateSession("lazy");
List<UserLazy> users = sessionLazy.createQuery("From UserLazy").list();
UserLazy userLazyLoaded = users.get(0);
// since data is lazyloaded so data won't be initialized
return (userLazyLoaded.getOrderDetail());
}
// eagerly loaded
public Set<OrderDetail> eagerLoaded() {
final Session sessionEager = HibernateUtil.getHibernateSession();
// data should be loaded in the following line
// also note the queries generated
List<UserEager> user = sessionEager.createQuery("From UserEager").list();
UserEager userEagerLoaded = user.get(0);
return userEagerLoaded.getOrderDetail();
}
// creates test data
// call this method to create the data in the database
public void createTestData() {
final Session session = HibernateUtil.getHibernateSession("lazy");
Transaction tx = session.beginTransaction();
final UserLazy user1 = new UserLazy();
final UserLazy user2 = new UserLazy();
final UserLazy user3 = new UserLazy();
session.save(user1);
session.save(user2);
session.save(user3);
final OrderDetail order1 = new OrderDetail();
final OrderDetail order2 = new OrderDetail();
final OrderDetail order3 = new OrderDetail();
final OrderDetail order4 = new OrderDetail();
final OrderDetail order5 = new OrderDetail();
session.saveOrUpdate(order1);
session.saveOrUpdate(order2);
session.saveOrUpdate(order3);
session.saveOrUpdate(order4);
session.saveOrUpdate(order5);
tx.commit();
session.close();
}
}

9
persistence-modules/spring-data-jpa-query-2/src/main/java/com/baeldung/persistence/dao/BookRepository.java
View File

@ -1,9 +0,0 @@
package com.baeldung.persistence.dao;
import com.baeldung.persistence.model.Book;
import org.springframework.data.jpa.repository.JpaRepository;
import org.springframework.data.jpa.repository.JpaSpecificationExecutor;
public interface BookRepository extends JpaRepository<Book, Long>, BookRepositoryCustom, JpaSpecificationExecutor<Book> {
}

11
persistence-modules/spring-data-jpa-query-2/src/main/java/com/baeldung/persistence/dao/BookRepositoryCustom.java
View File

@ -1,11 +0,0 @@
package com.baeldung.persistence.dao;
import com.baeldung.persistence.model.Book;
import java.util.List;
public interface BookRepositoryCustom {
List<Book> findBooksByAuthorNameAndTitle(String authorName, String title);
}

44
persistence-modules/spring-data-jpa-query-2/src/main/java/com/baeldung/persistence/dao/BookRepositoryImpl.java
View File

@ -1,44 +0,0 @@
package com.baeldung.persistence.dao;
import com.baeldung.persistence.model.Book;
import org.springframework.stereotype.Repository;
import javax.persistence.EntityManager;
import javax.persistence.TypedQuery;
import javax.persistence.criteria.CriteriaBuilder;
import javax.persistence.criteria.CriteriaQuery;
import javax.persistence.criteria.Predicate;
import javax.persistence.criteria.Root;
import java.util.ArrayList;
import java.util.List;
@Repository
public class BookRepositoryImpl implements BookRepositoryCustom {
private EntityManager em;
public BookRepositoryImpl(EntityManager em) {
this.em = em;
}
@Override
public List<Book> findBooksByAuthorNameAndTitle(String authorName, String title) {
CriteriaBuilder cb = em.getCriteriaBuilder();
CriteriaQuery<Book> cq = cb.createQuery(Book.class);
Root<Book> book = cq.from(Book.class);
List<Predicate> predicates = new ArrayList<>();
if (authorName != null) {
predicates.add(cb.equal(book.get("author"), authorName));
}
if (title != null) {
predicates.add(cb.like(book.get("title"), "%" + title + "%"));
}
cq.where(predicates.toArray(new Predicate[0]));
TypedQuery<Book> query = em.createQuery(cq);
return query.getResultList();
}
}

25
persistence-modules/spring-data-jpa-query-2/src/main/java/com/baeldung/persistence/dao/BookService.java
View File

@ -1,25 +0,0 @@
package com.baeldung.persistence.dao;
import com.baeldung.persistence.model.Book;
import org.springframework.stereotype.Service;
import java.util.List;
import static com.baeldung.persistence.dao.BookSpecifications.hasAuthor;
import static com.baeldung.persistence.dao.BookSpecifications.titleContains;
import static org.springframework.data.jpa.domain.Specification.where;
@Service
public class BookService {
private BookRepository bookRepository;
public BookService(BookRepository bookRepository) {
this.bookRepository = bookRepository;
}
public List<Book> query(String author, String title) {
return bookRepository.findAll(where(hasAuthor(author)).and(titleContains(title)));
}
}

16
persistence-modules/spring-data-jpa-query-2/src/main/java/com/baeldung/persistence/dao/BookSpecifications.java
View File

@ -1,16 +0,0 @@
package com.baeldung.persistence.dao;
import com.baeldung.persistence.model.Book;
import org.springframework.data.jpa.domain.Specification;
public class BookSpecifications {
public static Specification<Book> hasAuthor(String author) {
return (book, cq, cb) -> cb.equal(book.get("author"), author);
}
public static Specification<Book> titleContains(String title) {
return (book, cq, cb) -> cb.like(book.get("title"), "%" + title + "%");
}
}

8
persistence-modules/spring-data-jpa-query-2/src/main/java/com/baeldung/persistence/dao/IBarAuditableDao.java Normal file
View File

@ -0,0 +1,8 @@
package com.baeldung.persistence.dao;
import com.baeldung.persistence.dao.common.IAuditOperations;
import com.baeldung.persistence.model.Bar;
public interface IBarAuditableDao extends IBarDao, IAuditOperations<Bar> {
//
}

10
persistence-modules/spring-data-jpa-query-2/src/main/java/com/baeldung/persistence/dao/IBarCrudRepository.java Normal file
View File

@ -0,0 +1,10 @@
package com.baeldung.persistence.dao;
import java.io.Serializable;
import com.baeldung.persistence.model.Bar;
import org.springframework.data.repository.CrudRepository;
public interface IBarCrudRepository extends CrudRepository<Bar, Serializable> {
//
}

8
persistence-modules/spring-data-jpa-query-2/src/main/java/com/baeldung/persistence/dao/IBarDao.java Normal file
View File

@ -0,0 +1,8 @@
package com.baeldung.persistence.dao;
import com.baeldung.persistence.dao.common.IOperations;
import com.baeldung.persistence.model.Bar;
public interface IBarDao extends IOperations<Bar> {
//
}

8
persistence-modules/spring-data-jpa-query-2/src/main/java/com/baeldung/persistence/dao/IChildDao.java Normal file
View File

@ -0,0 +1,8 @@
package com.baeldung.persistence.dao;
import com.baeldung.persistence.model.Child;
import com.baeldung.persistence.dao.common.IOperations;
public interface IChildDao extends IOperations<Child> {
//
}

8
persistence-modules/spring-data-jpa-query-2/src/main/java/com/baeldung/persistence/dao/IFooAuditableDao.java Normal file
View File

@ -0,0 +1,8 @@
package com.baeldung.persistence.dao;
import com.baeldung.persistence.dao.common.IAuditOperations;
import com.baeldung.persistence.model.Foo;
public interface IFooAuditableDao extends IFooDao, IAuditOperations<Foo> {
//
}

8
persistence-modules/spring-data-jpa-query-2/src/main/java/com/baeldung/persistence/dao/IFooDao.java Normal file
View File

@ -0,0 +1,8 @@
package com.baeldung.persistence.dao;
import com.baeldung.persistence.model.Foo;
import com.baeldung.persistence.dao.common.IOperations;
public interface IFooDao extends IOperations<Foo> {
//
}

8
persistence-modules/spring-data-jpa-query-2/src/main/java/com/baeldung/persistence/dao/IParentDao.java Normal file
View File

@ -0,0 +1,8 @@
package com.baeldung.persistence.dao;
import com.baeldung.persistence.model.Parent;
import com.baeldung.persistence.dao.common.IOperations;
public interface IParentDao extends IOperations<Parent> {
//
}

14
persistence-modules/spring-data-jpa-query-2/src/main/java/com/baeldung/persistence/dao/common/AbstractDao.java Normal file
View File

@ -0,0 +1,14 @@
package com.baeldung.persistence.dao.common;
import java.io.Serializable;
import com.google.common.base.Preconditions;
public abstract class AbstractDao<T extends Serializable> implements IOperations<T> {
protected Class<T> clazz;
protected final void setClazz(final Class<T> clazzToSet) {
clazz = Preconditions.checkNotNull(clazzToSet);
}
}

37
persistence-modules/spring-data-jpa-query-2/src/main/java/com/baeldung/persistence/dao/common/AbstractHibernateAuditableDao.java Normal file
View File

@ -0,0 +1,37 @@
package com.baeldung.persistence.dao.common;
import java.io.Serializable;
import java.util.List;
import org.hibernate.envers.AuditReader;
import org.hibernate.envers.AuditReaderFactory;
import org.hibernate.envers.query.AuditQuery;
@SuppressWarnings("unchecked")
public class AbstractHibernateAuditableDao<T extends Serializable> extends AbstractHibernateDao<T> implements IAuditOperations<T> {
@Override
public List<T> getEntitiesAtRevision(final Number revision) {
final AuditReader auditReader = AuditReaderFactory.get(getCurrentSession());
final AuditQuery query = auditReader.createQuery().forEntitiesAtRevision(clazz, revision);
final List<T> resultList = query.getResultList();
return resultList;
}
@Override
public List<T> getEntitiesModifiedAtRevision(final Number revision) {
final AuditReader auditReader = AuditReaderFactory.get(getCurrentSession());
final AuditQuery query = auditReader.createQuery().forEntitiesModifiedAtRevision(clazz, revision);
final List<T> resultList = query.getResultList();
return resultList;
}
@Override
public List<T> getRevisions() {
final AuditReader auditReader = AuditReaderFactory.get(getCurrentSession());
final AuditQuery query = auditReader.createQuery().forRevisionsOfEntity(clazz, true, true);
final List<T> resultList = query.getResultList();
return resultList;
}
}

59
persistence-modules/spring-data-jpa-query-2/src/main/java/com/baeldung/persistence/dao/common/AbstractHibernateDao.java Normal file
View File

@ -0,0 +1,59 @@
package com.baeldung.persistence.dao.common;
import java.io.Serializable;
import java.util.List;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.springframework.beans.factory.annotation.Autowired;
import com.google.common.base.Preconditions;
@SuppressWarnings("unchecked")
public abstract class AbstractHibernateDao<T extends Serializable> extends AbstractDao<T> implements IOperations<T> {
@Autowired
protected SessionFactory sessionFactory;
// API
@Override
public T findOne(final long id) {
return (T) getCurrentSession().get(clazz, id);
}
@Override
public List<T> findAll() {
return getCurrentSession().createQuery("from " + clazz.getName()).list();
}
@Override
public void create(final T entity) {
Preconditions.checkNotNull(entity);
getCurrentSession().saveOrUpdate(entity);
}
@Override
public T update(final T entity) {
Preconditions.checkNotNull(entity);
return (T) getCurrentSession().merge(entity);
}
@Override
public void delete(final T entity) {
Preconditions.checkNotNull(entity);
getCurrentSession().delete(entity);
}
@Override
public void deleteById(final long entityId) {
final T entity = findOne(entityId);
Preconditions.checkState(entity != null);
delete(entity);
}
protected Session getCurrentSession() {
return sessionFactory.getCurrentSession();
}
}

56
persistence-modules/spring-data-jpa-query-2/src/main/java/com/baeldung/persistence/dao/common/AbstractJpaDao.java Normal file
View File

@ -0,0 +1,56 @@
package com.baeldung.persistence.dao.common;
import java.io.Serializable;
import java.util.List;
import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;
import javax.persistence.TypedQuery;
import javax.persistence.criteria.CriteriaBuilder;
import javax.persistence.criteria.CriteriaQuery;
import javax.persistence.criteria.Root;
public class AbstractJpaDao<T extends Serializable> extends AbstractDao<T> implements IOperations<T> {
@PersistenceContext(unitName = "jpaEntityManager")
private EntityManager em;
// API
@Override
public T findOne(final long id) {
return em.find(clazz, Long.valueOf(id).intValue());
}
@Override
public List<T> findAll() {
final CriteriaBuilder cb = em.getCriteriaBuilder();
final CriteriaQuery<T> cq = cb.createQuery(clazz);
final Root<T> rootEntry = cq.from(clazz);
final CriteriaQuery<T> all = cq.select(rootEntry);
final TypedQuery<T> allQuery = em.createQuery(all);
return allQuery.getResultList();
}
@Override
public void create(final T entity) {
em.persist(entity);
}
@Override
public T update(final T entity) {
em.merge(entity);
return entity;
}
@Override
public void delete(final T entity) {
em.remove(entity);
}
@Override
public void deleteById(final long entityId) {
delete(findOne(entityId));
}
}

13
persistence-modules/spring-data-jpa-query-2/src/main/java/com/baeldung/persistence/dao/common/GenericHibernateDao.java Normal file
View File

@ -0,0 +1,13 @@
package com.baeldung.persistence.dao.common;
import java.io.Serializable;
import org.springframework.beans.factory.config.BeanDefinition;
import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Repository;
@Repository
@Scope(BeanDefinition.SCOPE_PROTOTYPE)
public class GenericHibernateDao<T extends Serializable> extends AbstractHibernateDao<T> implements IGenericDao<T> {
//
}

14
persistence-modules/spring-data-jpa-query-2/src/main/java/com/baeldung/persistence/dao/common/IAuditOperations.java Normal file
View File

@ -0,0 +1,14 @@
package com.baeldung.persistence.dao.common;
import java.io.Serializable;
import java.util.List;
public interface IAuditOperations<T extends Serializable> {
List<T> getEntitiesAtRevision(Number revision);
List<T> getEntitiesModifiedAtRevision(Number revision);
List<T> getRevisions();
}

7
persistence-modules/spring-data-jpa-query-2/src/main/java/com/baeldung/persistence/dao/common/IGenericDao.java Normal file
View File

@ -0,0 +1,7 @@
package com.baeldung.persistence.dao.common;
import java.io.Serializable;
public interface IGenericDao<T extends Serializable> extends IOperations<T> {
//
}

20
persistence-modules/spring-data-jpa-query-2/src/main/java/com/baeldung/persistence/dao/common/IOperations.java Normal file
View File

@ -0,0 +1,20 @@
package com.baeldung.persistence.dao.common;
import java.io.Serializable;
import java.util.List;
public interface IOperations<T extends Serializable> {
T findOne(final long id);
List<T> findAll();
void create(final T entity);
T update(final T entity);
void delete(final T entity);
void deleteById(final long entityId);
}

28
persistence-modules/spring-data-jpa-query-2/src/main/java/com/baeldung/persistence/dao/impl/BarAuditableDao.java Normal file
View File

@ -0,0 +1,28 @@
package com.baeldung.persistence.dao.impl;
import java.util.List;
import com.baeldung.persistence.dao.IBarAuditableDao;
import com.baeldung.persistence.dao.common.AbstractHibernateAuditableDao;
import com.baeldung.persistence.model.Bar;
public class BarAuditableDao extends AbstractHibernateAuditableDao<Bar> implements IBarAuditableDao {
public BarAuditableDao() {
super();
setClazz(Bar.class);
}
// API
@Override
public List<Bar> getRevisions() {
final List<Bar> resultList = super.getRevisions();
for (final Bar bar : resultList) {
bar.getFooSet().size(); // force FooSet initialization
}
return resultList;
}
}

19
persistence-modules/spring-data-jpa-query-2/src/main/java/com/baeldung/persistence/dao/impl/BarDao.java Normal file
View File

@ -0,0 +1,19 @@
package com.baeldung.persistence.dao.impl;
import com.baeldung.persistence.dao.common.AbstractHibernateDao;
import com.baeldung.persistence.dao.IBarDao;
import com.baeldung.persistence.model.Bar;
import org.springframework.stereotype.Repository;
@Repository
public class BarDao extends AbstractHibernateDao<Bar> implements IBarDao {
public BarDao() {
super();
setClazz(Bar.class);
}
// API
}

19
persistence-modules/spring-data-jpa-query-2/src/main/java/com/baeldung/persistence/dao/impl/BarJpaDao.java Normal file
View File

@ -0,0 +1,19 @@
package com.baeldung.persistence.dao.impl;
import com.baeldung.persistence.dao.IBarDao;
import com.baeldung.persistence.dao.common.AbstractJpaDao;
import com.baeldung.persistence.model.Bar;
import org.springframework.stereotype.Repository;
@Repository
public class BarJpaDao extends AbstractJpaDao<Bar> implements IBarDao {
public BarJpaDao() {
super();
setClazz(Bar.class);
}
// API
}

19
persistence-modules/spring-data-jpa-query-2/src/main/java/com/baeldung/persistence/dao/impl/ChildDao.java Normal file
View File

@ -0,0 +1,19 @@
package com.baeldung.persistence.dao.impl;
import com.baeldung.persistence.dao.common.AbstractHibernateDao;
import com.baeldung.persistence.model.Child;
import com.baeldung.persistence.dao.IChildDao;
import org.springframework.stereotype.Repository;
@Repository
public class ChildDao extends AbstractHibernateDao<Child> implements IChildDao {
public ChildDao() {
super();
setClazz(Child.class);
}
// API
}

17
persistence-modules/spring-data-jpa-query-2/src/main/java/com/baeldung/persistence/dao/impl/FooAuditableDao.java Normal file
View File

@ -0,0 +1,17 @@
package com.baeldung.persistence.dao.impl;
import com.baeldung.persistence.dao.common.AbstractHibernateAuditableDao;
import com.baeldung.persistence.model.Foo;
import com.baeldung.persistence.dao.IFooAuditableDao;
public class FooAuditableDao extends AbstractHibernateAuditableDao<Foo> implements IFooAuditableDao {
public FooAuditableDao() {
super();
setClazz(Foo.class);
}
// API
}

19
persistence-modules/spring-data-jpa-query-2/src/main/java/com/baeldung/persistence/dao/impl/FooDao.java Normal file
View File

@ -0,0 +1,19 @@
package com.baeldung.persistence.dao.impl;
import com.baeldung.persistence.dao.common.AbstractHibernateDao;
import com.baeldung.persistence.dao.IFooDao;
import com.baeldung.persistence.model.Foo;
import org.springframework.stereotype.Repository;
@Repository
public class FooDao extends AbstractHibernateDao<Foo> implements IFooDao {
public FooDao() {
super();
setClazz(Foo.class);
}
// API
}

19
persistence-modules/spring-data-jpa-query-2/src/main/java/com/baeldung/persistence/dao/impl/ParentDao.java Normal file
View File

@ -0,0 +1,19 @@
package com.baeldung.persistence.dao.impl;
import com.baeldung.persistence.dao.IParentDao;
import com.baeldung.persistence.dao.common.AbstractHibernateDao;
import com.baeldung.persistence.model.Parent;
import org.springframework.stereotype.Repository;
@Repository
public class ParentDao extends AbstractHibernateDao<Parent> implements IParentDao {
public ParentDao() {
super();
setClazz(Parent.class);
}
// API
}

242
persistence-modules/spring-data-jpa-query-2/src/main/java/com/baeldung/persistence/model/Bar.java Normal file
View File

@ -0,0 +1,242 @@
package com.baeldung.persistence.model;
import java.io.Serializable;
import java.util.Date;
import java.util.Set;
import javax.persistence.CascadeType;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.EntityListeners;
import javax.persistence.FetchType;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.NamedQuery;
import javax.persistence.OneToMany;
import javax.persistence.PrePersist;
import javax.persistence.PreRemove;
import javax.persistence.PreUpdate;
import org.hibernate.annotations.OrderBy;
import org.hibernate.envers.Audited;
import org.jboss.logging.Logger;
import org.springframework.data.annotation.CreatedBy;
import org.springframework.data.annotation.CreatedDate;
import org.springframework.data.annotation.LastModifiedBy;
import org.springframework.data.annotation.LastModifiedDate;
import org.springframework.data.jpa.domain.support.AuditingEntityListener;
import com.google.common.collect.Sets;
@Entity
@NamedQuery(name = "Bar.findAll", query = "SELECT b FROM Bar b")
@Audited
@EntityListeners(AuditingEntityListener.class)
public class Bar implements Serializable {
private static Logger logger = Logger.getLogger(Bar.class);
public enum OPERATION {
INSERT, UPDATE, DELETE;
private String value;
OPERATION() {
value = toString();
}
public String getValue() {
return value;
}
public static OPERATION parse(final String value) {
OPERATION operation = null;
for (final OPERATION op : OPERATION.values()) {
if (op.getValue().equals(value)) {
operation = op;
break;
}
}
return operation;
}
};
@Id
@GeneratedValue(strategy = GenerationType.AUTO)
@Column(name = "id")
private int id;
@Column(name = "name")
private String name;
@OneToMany(mappedBy = "bar", cascade = CascadeType.ALL, fetch = FetchType.LAZY)
@OrderBy(clause = "NAME DESC")
// @NotAudited
private Set<Foo> fooSet = Sets.newHashSet();
@Column(name = "operation")
private String operation;
@Column(name = "timestamp")
private long timestamp;
@Column(name = "created_date", updatable = false, nullable = false)
@CreatedDate
private long createdDate;
@Column(name = "modified_date")
@LastModifiedDate
private long modifiedDate;
@Column(name = "created_by")
@CreatedBy
private String createdBy;
@Column(name = "modified_by")
@LastModifiedBy
private String modifiedBy;
public Bar() {
super();
}
public Bar(final String name) {
super();
this.name = name;
}
// API
public Set<Foo> getFooSet() {
return fooSet;
}
public void setFooSet(final Set<Foo> fooSet) {
this.fooSet = fooSet;
}
public int getId() {
return id;
}
public void setId(final int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(final String name) {
this.name = name;
}
public OPERATION getOperation() {
return OPERATION.parse(operation);
}
public void setOperation(final OPERATION operation) {
this.operation = operation.getValue();
}
public long getTimestamp() {
return timestamp;
}
public void setTimestamp(final long timestamp) {
this.timestamp = timestamp;
}
public long getCreatedDate() {
return createdDate;
}
public void setCreatedDate(final long createdDate) {
this.createdDate = createdDate;
}
public long getModifiedDate() {
return modifiedDate;
}
public void setModifiedDate(final long modifiedDate) {
this.modifiedDate = modifiedDate;
}
public String getCreatedBy() {
return createdBy;
}
public void setCreatedBy(final String createdBy) {
this.createdBy = createdBy;
}
public String getModifiedBy() {
return modifiedBy;
}
public void setModifiedBy(final String modifiedBy) {
this.modifiedBy = modifiedBy;
}
public void setOperation(final String operation) {
this.operation = operation;
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + ((name == null) ? 0 : name.hashCode());
return result;
}
@Override
public boolean equals(final Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
final Bar other = (Bar) obj;
if (name == null) {
if (other.name != null)
return false;
} else if (!name.equals(other.name))
return false;
return true;
}
@Override
public String toString() {
final StringBuilder builder = new StringBuilder();
builder.append("Bar [name=").append(name).append("]");
return builder.toString();
}
@PrePersist
public void onPrePersist() {
logger.info("@PrePersist");
audit(OPERATION.INSERT);
}
@PreUpdate
public void onPreUpdate() {
logger.info("@PreUpdate");
audit(OPERATION.UPDATE);
}
@PreRemove
public void onPreRemove() {
logger.info("@PreRemove");
audit(OPERATION.DELETE);
}
private void audit(final OPERATION operation) {
setOperation(operation);
setTimestamp((new Date()).getTime());
}
}

36
persistence-modules/spring-data-jpa-query-2/src/main/java/com/baeldung/persistence/model/Book.java
View File

@ -1,36 +0,0 @@
package com.baeldung.persistence.model;
import javax.persistence.Entity;
import javax.persistence.Id;
@Entity
public class Book {
@Id
private Long id;
private String title;
private String author;
public Long getId() {
return id;
}
public String getTitle() {
return title;
}
public void setTitle(String title) {
this.title = title;
}
public String getAuthor() {
return author;
}
public void setAuthor(String author) {
this.author = author;
}
}

51
persistence-modules/spring-data-jpa-query-2/src/main/java/com/baeldung/persistence/model/Child.java Normal file
View File

@ -0,0 +1,51 @@
package com.baeldung.persistence.model;
import java.io.Serializable;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.OneToOne;
@Entity
public class Child implements Serializable {
@Id
@GeneratedValue
private long id;
@OneToOne(mappedBy = "child")
private Parent parent;
public Child() {
super();
}
// API
public long getId() {
return id;
}
public void setId(final long id) {
this.id = id;
}
public Parent getParent() {
return parent;
}
public void setParent(final Parent parent) {
this.parent = parent;
}
//
@Override
public String toString() {
final StringBuilder builder = new StringBuilder();
builder.append("Child [id=").append(id).append("]");
return builder.toString();
}
}

105
persistence-modules/spring-data-jpa-query-2/src/main/java/com/baeldung/persistence/model/Foo.java Normal file
View File

@ -0,0 +1,105 @@
package com.baeldung.persistence.model;
import java.io.Serializable;
import javax.persistence.CascadeType;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.ManyToOne;
import javax.persistence.NamedNativeQueries;
import javax.persistence.NamedNativeQuery;
import org.hibernate.envers.Audited;
@NamedNativeQueries({ @NamedNativeQuery(name = "callGetAllFoos", query = "CALL GetAllFoos()", resultClass = Foo.class), @NamedNativeQuery(name = "callGetFoosByName", query = "CALL GetFoosByName(:fooName)", resultClass = Foo.class) })
@Entity
@Audited
// @Proxy(lazy = false)
public class Foo implements Serializable {
@Id
@GeneratedValue(strategy = GenerationType.AUTO)
@Column(name = "id")
private long id;
@Column(name = "name")
private String name;
@ManyToOne(targetEntity = Bar.class, cascade = CascadeType.ALL, fetch = FetchType.EAGER)
@JoinColumn(name = "BAR_ID")
private Bar bar = new Bar();
public Foo() {
super();
}
public Foo(final String name) {
super();
this.name = name;
}
//
public Bar getBar() {
return bar;
}
public void setBar(final Bar bar) {
this.bar = bar;
}
public long getId() {
return id;
}
public void setId(final long id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(final String name) {
this.name = name;
}
//
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + ((name == null) ? 0 : name.hashCode());
return result;
}
@Override
public boolean equals(final Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
final Foo other = (Foo) obj;
if (name == null) {
if (other.name != null)
return false;
} else if (!name.equals(other.name))
return false;
return true;
}
@Override
public String toString() {
final StringBuilder builder = new StringBuilder();
builder.append("Foo [name=").append(name).append("]");
return builder.toString();
}
}

60
persistence-modules/spring-data-jpa-query-2/src/main/java/com/baeldung/persistence/model/Parent.java Normal file
View File

@ -0,0 +1,60 @@
package com.baeldung.persistence.model;
import java.io.Serializable;
import javax.persistence.CascadeType;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.JoinColumn;
import javax.persistence.OneToOne;
@Entity
public class Parent implements Serializable {
@Id
@GeneratedValue
private long id;
@OneToOne(cascade = { CascadeType.PERSIST, CascadeType.MERGE, CascadeType.REFRESH, CascadeType.DETACH })
@JoinColumn(name = "child_fk")
private Child child;
public Parent() {
super();
}
public Parent(final Child child) {
super();
this.child = child;
}
// API
public long getId() {
return id;
}
public void setId(final long id) {
this.id = id;
}
public Child getChild() {
return child;
}
public void setChild(final Child child) {
this.child = child;
}
//
@Override
public String toString() {
final StringBuilder builder = new StringBuilder();
builder.append("Parent [id=").append(id).append("]");
return builder.toString();
}
}

31
persistence-modules/spring-data-jpa-query-2/src/main/java/com/baeldung/persistence/model/Person.java Normal file
View File

@ -0,0 +1,31 @@
package com.baeldung.persistence.model;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
@Entity
public class Person {
@Id
@GeneratedValue
private Long id;
private String name;
public Long getId() {
return id;
}
public void setId(Long id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}

8
persistence-modules/spring-data-jpa-query-2/src/main/java/com/baeldung/persistence/service/IBarAuditableService.java Normal file
View File

@ -0,0 +1,8 @@
package com.baeldung.persistence.service;
import com.baeldung.persistence.dao.common.IAuditOperations;
import com.baeldung.persistence.model.Bar;
public interface IBarAuditableService extends IBarService, IAuditOperations<Bar> {
}

8
persistence-modules/spring-data-jpa-query-2/src/main/java/com/baeldung/persistence/service/IBarService.java Normal file
View File

@ -0,0 +1,8 @@
package com.baeldung.persistence.service;
import com.baeldung.persistence.dao.common.IOperations;
import com.baeldung.persistence.model.Bar;
public interface IBarService extends IOperations<Bar> {
//
}

8
persistence-modules/spring-data-jpa-query-2/src/main/java/com/baeldung/persistence/service/IChildService.java Normal file
View File

@ -0,0 +1,8 @@
package com.baeldung.persistence.service;
import com.baeldung.persistence.model.Child;
import com.baeldung.persistence.dao.common.IOperations;
public interface IChildService extends IOperations<Child> {
//
}

8
persistence-modules/spring-data-jpa-query-2/src/main/java/com/baeldung/persistence/service/IFooAuditableService.java Normal file
View File

@ -0,0 +1,8 @@
package com.baeldung.persistence.service;
import com.baeldung.persistence.dao.common.IAuditOperations;
import com.baeldung.persistence.model.Foo;
public interface IFooAuditableService extends IFooService, IAuditOperations<Foo> {
//
}

8
persistence-modules/spring-data-jpa-query-2/src/main/java/com/baeldung/persistence/service/IFooService.java Normal file
View File

@ -0,0 +1,8 @@
package com.baeldung.persistence.service;
import com.baeldung.persistence.model.Foo;
import com.baeldung.persistence.dao.common.IOperations;
public interface IFooService extends IOperations<Foo> {
//
}

8
persistence-modules/spring-data-jpa-query-2/src/main/java/com/baeldung/persistence/service/IParentService.java Normal file
View File

@ -0,0 +1,8 @@
package com.baeldung.persistence.service;
import com.baeldung.persistence.model.Parent;
import com.baeldung.persistence.dao.common.IOperations;
public interface IParentService extends IOperations<Parent> {
//
}

30
persistence-modules/spring-data-jpa-query-2/src/main/java/com/baeldung/persistence/service/common/AbstractHibernateAuditableService.java Normal file
View File

@ -0,0 +1,30 @@
package com.baeldung.persistence.service.common;
import java.io.Serializable;
import java.util.List;
import com.baeldung.persistence.dao.common.IAuditOperations;
import com.baeldung.persistence.dao.common.IOperations;
import org.springframework.transaction.annotation.Transactional;
@Transactional(value = "hibernateTransactionManager")
public abstract class AbstractHibernateAuditableService<T extends Serializable> extends AbstractHibernateService<T> implements IOperations<T>, IAuditOperations<T> {
@Override
public List<T> getEntitiesAtRevision(final Number revision) {
return getAuditableDao().getEntitiesAtRevision(revision);
}
@Override
public List<T> getEntitiesModifiedAtRevision(final Number revision) {
return getAuditableDao().getEntitiesModifiedAtRevision(revision);
}
@Override
public List<T> getRevisions() {
return getAuditableDao().getRevisions();
}
abstract protected IAuditOperations<T> getAuditableDao();
}

42
persistence-modules/spring-data-jpa-query-2/src/main/java/com/baeldung/persistence/service/common/AbstractHibernateService.java Normal file
View File

@ -0,0 +1,42 @@
package com.baeldung.persistence.service.common;
import java.io.Serializable;
import java.util.List;
import com.baeldung.persistence.dao.common.IOperations;
import org.springframework.transaction.annotation.Transactional;
@Transactional(value = "hibernateTransactionManager")
public abstract class AbstractHibernateService<T extends Serializable> extends AbstractService<T> implements IOperations<T> {
@Override
public T findOne(final long id) {
return super.findOne(id);
}
@Override
public List<T> findAll() {
return super.findAll();
}
@Override
public void create(final T entity) {
super.create(entity);
}
@Override
public T update(final T entity) {
return super.update(entity);
}
@Override
public void delete(final T entity) {
super.delete(entity);
}
@Override
public void deleteById(final long entityId) {
super.deleteById(entityId);
}
}

42
persistence-modules/spring-data-jpa-query-2/src/main/java/com/baeldung/persistence/service/common/AbstractJpaService.java Normal file
View File

@ -0,0 +1,42 @@
package com.baeldung.persistence.service.common;
import java.io.Serializable;
import java.util.List;
import com.baeldung.persistence.dao.common.IOperations;
import org.springframework.transaction.annotation.Transactional;
@Transactional(value = "jpaTransactionManager")
public abstract class AbstractJpaService<T extends Serializable> extends AbstractService<T> implements IOperations<T> {
@Override
public T findOne(final long id) {
return super.findOne(id);
}
@Override
public List<T> findAll() {
return super.findAll();
}
@Override
public void create(final T entity) {
super.create(entity);
}
@Override
public T update(final T entity) {
return super.update(entity);
}
@Override
public void delete(final T entity) {
super.delete(entity);
}
@Override
public void deleteById(final long entityId) {
super.deleteById(entityId);
}
}

42
persistence-modules/spring-data-jpa-query-2/src/main/java/com/baeldung/persistence/service/common/AbstractService.java Normal file
View File

@ -0,0 +1,42 @@
package com.baeldung.persistence.service.common;
import java.io.Serializable;
import java.util.List;
import com.baeldung.persistence.dao.common.IOperations;
public abstract class AbstractService<T extends Serializable> implements IOperations<T> {
@Override
public T findOne(final long id) {
return getDao().findOne(id);
}
@Override
public List<T> findAll() {
return getDao().findAll();
}
@Override
public void create(final T entity) {
getDao().create(entity);
}
@Override
public T update(final T entity) {
return getDao().update(entity);
}
@Override
public void delete(final T entity) {
getDao().delete(entity);
}
@Override
public void deleteById(final long entityId) {
getDao().deleteById(entityId);
}
protected abstract IOperations<T> getDao();
}

48
persistence-modules/spring-data-jpa-query-2/src/main/java/com/baeldung/persistence/service/common/AbstractSpringDataJpaService.java Normal file
View File

@ -0,0 +1,48 @@
package com.baeldung.persistence.service.common;
import java.io.Serializable;
import java.util.List;
import java.util.Optional;
import com.baeldung.persistence.dao.common.IOperations;
import org.springframework.data.repository.CrudRepository;
import org.springframework.transaction.annotation.Transactional;
import com.google.common.collect.Lists;
@Transactional(value = "jpaTransactionManager")
public abstract class AbstractSpringDataJpaService<T extends Serializable> implements IOperations<T> {
@Override
public T findOne(final long id) {
Optional<T> opt = getDao().findById(Long.valueOf(id));
return opt.get();
}
@Override
public List<T> findAll() {
return Lists.newArrayList(getDao().findAll());
}
@Override
public void create(final T entity) {
getDao().save(entity);
}
@Override
public T update(final T entity) {
return getDao().save(entity);
}
@Override
public void delete(final T entity) {
getDao().delete(entity);
}
@Override
public void deleteById(final long entityId) {
getDao().deleteById(Long.valueOf(entityId));
}
protected abstract CrudRepository<T, Serializable> getDao();
}

41
persistence-modules/spring-data-jpa-query-2/src/main/java/com/baeldung/persistence/service/impl/BarAuditableService.java Normal file
View File

@ -0,0 +1,41 @@
package com.baeldung.persistence.service.impl;
import com.baeldung.persistence.dao.common.IAuditOperations;
import com.baeldung.persistence.service.common.AbstractHibernateAuditableService;
import com.baeldung.persistence.dao.IBarAuditableDao;
import com.baeldung.persistence.dao.IBarDao;
import com.baeldung.persistence.dao.common.IOperations;
import com.baeldung.persistence.model.Bar;
import com.baeldung.persistence.service.IBarAuditableService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Service;
@Service
public class BarAuditableService extends AbstractHibernateAuditableService<Bar> implements IBarAuditableService {
@Autowired
@Qualifier("barHibernateDao")
private IBarDao dao;
@Autowired
@Qualifier("barHibernateAuditableDao")
private IBarAuditableDao auditDao;
public BarAuditableService() {
super();
}
// API
@Override
protected IOperations<Bar> getDao() {
return dao;
}
@Override
protected IAuditOperations<Bar> getAuditableDao() {
return auditDao;
}
}

30
persistence-modules/spring-data-jpa-query-2/src/main/java/com/baeldung/persistence/service/impl/BarJpaService.java Normal file
View File

@ -0,0 +1,30 @@
package com.baeldung.persistence.service.impl;
import com.baeldung.persistence.dao.IBarDao;
import com.baeldung.persistence.dao.common.IOperations;
import com.baeldung.persistence.model.Bar;
import com.baeldung.persistence.service.IBarService;
import com.baeldung.persistence.service.common.AbstractJpaService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Service;
@Service
public class BarJpaService extends AbstractJpaService<Bar> implements IBarService {
@Autowired
@Qualifier("barJpaDao")
private IBarDao dao;
public BarJpaService() {
super();
}
// API
@Override
protected IOperations<Bar> getDao() {
return dao;
}
}

30
persistence-modules/spring-data-jpa-query-2/src/main/java/com/baeldung/persistence/service/impl/BarService.java Normal file
View File

@ -0,0 +1,30 @@
package com.baeldung.persistence.service.impl;
import com.baeldung.persistence.dao.IBarDao;
import com.baeldung.persistence.dao.common.IOperations;
import com.baeldung.persistence.model.Bar;
import com.baeldung.persistence.service.IBarService;
import com.baeldung.persistence.service.common.AbstractHibernateService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Service;
@Service
public class BarService extends AbstractHibernateService<Bar> implements IBarService {
@Autowired
@Qualifier("barHibernateDao")
private IBarDao dao;
public BarService() {
super();
}
// API
@Override
protected IOperations<Bar> getDao() {
return dao;
}
}

26
persistence-modules/spring-data-jpa-query-2/src/main/java/com/baeldung/persistence/service/impl/BarSpringDataJpaService.java Normal file
View File

@ -0,0 +1,26 @@
package com.baeldung.persistence.service.impl;
import java.io.Serializable;
import com.baeldung.persistence.service.common.AbstractSpringDataJpaService;
import com.baeldung.persistence.dao.IBarCrudRepository;
import com.baeldung.persistence.model.Bar;
import com.baeldung.persistence.service.IBarService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.repository.CrudRepository;
public class BarSpringDataJpaService extends AbstractSpringDataJpaService<Bar> implements IBarService {
@Autowired
private IBarCrudRepository dao;
public BarSpringDataJpaService() {
super();
}
@Override
protected CrudRepository<Bar, Serializable> getDao() {
return dao;
}
}

28
persistence-modules/spring-data-jpa-query-2/src/main/java/com/baeldung/persistence/service/impl/ChildService.java Normal file
View File

@ -0,0 +1,28 @@
package com.baeldung.persistence.service.impl;
import com.baeldung.persistence.model.Child;
import com.baeldung.persistence.service.IChildService;
import com.baeldung.persistence.dao.IChildDao;
import com.baeldung.persistence.dao.common.IOperations;
import com.baeldung.persistence.service.common.AbstractHibernateService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
@Service
public class ChildService extends AbstractHibernateService<Child> implements IChildService {
@Autowired
private IChildDao dao;
public ChildService() {
super();
}
// API
@Override
protected IOperations<Child> getDao() {
return dao;
}
}

41
persistence-modules/spring-data-jpa-query-2/src/main/java/com/baeldung/persistence/service/impl/FooAuditableService.java Normal file
View File

@ -0,0 +1,41 @@
package com.baeldung.persistence.service.impl;
import com.baeldung.persistence.dao.common.IAuditOperations;
import com.baeldung.persistence.service.IFooAuditableService;
import com.baeldung.persistence.service.common.AbstractHibernateAuditableService;
import com.baeldung.persistence.dao.IFooAuditableDao;
import com.baeldung.persistence.dao.IFooDao;
import com.baeldung.persistence.dao.common.IOperations;
import com.baeldung.persistence.model.Foo;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Service;
@Service
public class FooAuditableService extends AbstractHibernateAuditableService<Foo> implements IFooAuditableService {
@Autowired
@Qualifier("fooHibernateDao")
private IFooDao dao;
@Autowired
@Qualifier("fooHibernateAuditableDao")
private IFooAuditableDao auditDao;
public FooAuditableService() {
super();
}
// API
@Override
protected IOperations<Foo> getDao() {
return dao;
}
@Override
protected IAuditOperations<Foo> getAuditableDao() {
return auditDao;
}
}

30
persistence-modules/spring-data-jpa-query-2/src/main/java/com/baeldung/persistence/service/impl/FooService.java Normal file
View File

@ -0,0 +1,30 @@
package com.baeldung.persistence.service.impl;
import com.baeldung.persistence.dao.IFooDao;
import com.baeldung.persistence.dao.common.IOperations;
import com.baeldung.persistence.model.Foo;
import com.baeldung.persistence.service.IFooService;
import com.baeldung.persistence.service.common.AbstractHibernateService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Service;
@Service
public class FooService extends AbstractHibernateService<Foo> implements IFooService {
@Autowired
@Qualifier("fooHibernateDao")
private IFooDao dao;
public FooService() {
super();
}
// API
@Override
protected IOperations<Foo> getDao() {
return dao;
}
}

28
persistence-modules/spring-data-jpa-query-2/src/main/java/com/baeldung/persistence/service/impl/ParentService.java Normal file
View File

@ -0,0 +1,28 @@
package com.baeldung.persistence.service.impl;
import com.baeldung.persistence.model.Parent;
import com.baeldung.persistence.service.IParentService;
import com.baeldung.persistence.dao.IParentDao;
import com.baeldung.persistence.dao.common.IOperations;
import com.baeldung.persistence.service.common.AbstractHibernateService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
@Service
public class ParentService extends AbstractHibernateService<Parent> implements IParentService {
@Autowired
private IParentDao dao;
public ParentService() {
super();
}
// API
@Override
protected IOperations<Parent> getDao() {
return dao;
}
}

20
persistence-modules/spring-data-jpa-query-2/src/main/resources/fetching.cfg.xml Normal file
View File

@ -0,0 +1,20 @@
<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE hibernate-configuration PUBLIC
"-//Hibernate/Hibernate Configuration DTD 3.0//EN"
"http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
<session-factory>
<property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
<property name="hibernate.connection.url">jdbc:mysql://localhost:3306/test</property>
<property name="hibernate.connection.username">root</property>
<property name="hibernate.connection.password">iamtheking</property>
<property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>
<property name="show_sql">true</property>
<property name="hbm2ddl.auto">validate</property>
<mapping class="com.baeldung.hibernate.fetching.model.UserEager" />
<mapping class="com.baeldung.hibernate.fetching.model.OrderDetailEager" />
</session-factory>
</hibernate-configuration>

17
persistence-modules/spring-data-jpa-query-2/src/main/resources/fetchingLazy.cfg.xml Normal file
View File

@ -0,0 +1,17 @@
<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE hibernate-configuration PUBLIC
"-//Hibernate/Hibernate Configuration DTD 3.0//EN"
"http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
<session-factory>
<property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
<property name="hibernate.connection.url">jdbc:mysql://localhost:3306/test</property>
<property name="hibernate.connection.username">root</property>
<property name="hibernate.connection.password">iamtheking</property>
<property name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>
<property name="show_sql">true</property>
<mapping class="com.baeldung.hibernate.fetching.model.UserLazy" />
<mapping class="com.baeldung.hibernate.fetching.model.OrderDetail" />
</session-factory>
</hibernate-configuration>

14
persistence-modules/spring-data-jpa-query-2/src/main/resources/fetching_create_queries.sql Normal file
View File

@ -0,0 +1,14 @@
CREATE TABLE `user` (
`user_id` int(10) NOT NULL AUTO_INCREMENT,
PRIMARY KEY (`user_id`)
) ENGINE=InnoDB AUTO_INCREMENT=8 DEFAULT CHARSET=latin1 ;
CREATE TABLE `user_order` (
`ORDER_ID` int(10) NOT NULL AUTO_INCREMENT,
`USER_ID` int(10) NOT NULL DEFAULT '0',
PRIMARY KEY (`ORDER_ID`,`USER_ID`),
KEY `USER_ID` (`USER_ID`),
CONSTRAINT `user_order_ibfk_1` FOREIGN KEY (`USER_ID`) REFERENCES `USER` (`user_id`)
) ENGINE=InnoDB AUTO_INCREMENT=7 DEFAULT CHARSET=latin1;

34
persistence-modules/spring-data-jpa-query-2/src/main/resources/hibernate5Config.xml Normal file
View File

@ -0,0 +1,34 @@
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="
http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.2.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.2.xsd"
>
<context:property-placeholder location="classpath:persistence-mysql.properties"/>
<bean id="sessionFactory" class="org.springframework.orm.hibernate5.LocalSessionFactoryBean">
<property name="dataSource" ref="dataSource"/>
<property name="packagesToScan" value="com.baeldung.persistence.model"/>
<property name="hibernateProperties">
<props>
<prop key="hibernate.hbm2ddl.auto">${hibernate.hbm2ddl.auto}</prop>
<prop key="hibernate.dialect">${hibernate.dialect}</prop>
</props>
</property>
</bean>
<bean id="dataSource" class="org.apache.tomcat.dbcp.dbcp2.BasicDataSource">
<property name="driverClassName" value="${jdbc.driverClassName}"/>
<property name="url" value="${jdbc.url}"/>
<property name="username" value="${jdbc.eventGeneratedId}"/>
<property name="password" value="${jdbc.pass}"/>
</bean>
<bean id="txManager" class="org.springframework.orm.hibernate5.HibernateTransactionManager">
<property name="sessionFactory" ref="sessionFactory"/>
</bean>
<bean id="persistenceExceptionTranslationPostProcessor" class="org.springframework.dao.annotation.PersistenceExceptionTranslationPostProcessor"/>
</beans>

30
persistence-modules/spring-data-jpa-query-2/src/main/resources/hibernate5Configuration.xml Normal file
View File

@ -0,0 +1,30 @@
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="
http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">
<context:property-placeholder location="classpath:persistence-h2.properties"/>
<bean id="sessionFactory" class="org.springframework.orm.hibernate5.LocalSessionFactoryBean">
<property name="dataSource" ref="dataSource"/>
<property name="packagesToScan" value="com.baeldung.persistence.model"/>
<property name="hibernateProperties">
<props>
<prop key="hibernate.hbm2ddl.auto">${hibernate.hbm2ddl.auto}</prop>
<prop key="hibernate.dialect">${hibernate.dialect}</prop>
</props>
</property>
</bean>
<bean id="dataSource" class="org.apache.tomcat.dbcp.dbcp2.BasicDataSource">
<property name="driverClassName" value="${jdbc.driverClassName}"/>
<property name="url" value="${jdbc.url}"/>
<property name="username" value="${jdbc.user}"/>
<property name="password" value="${jdbc.pass}"/>
</bean>
<bean id="txManager" class="org.springframework.orm.hibernate5.HibernateTransactionManager">
<property name="sessionFactory" ref="sessionFactory"/>
</bean>
</beans>

38
persistence-modules/spring-data-jpa-query-2/src/main/resources/immutable.cfg.xml Normal file
View File

@ -0,0 +1,38 @@
<?xml version='1.0' encoding='utf-8'?>
<!DOCTYPE hibernate-configuration PUBLIC
"-//Hibernate/Hibernate Configuration DTD 3.0//EN"
"http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
<session-factory>
<!-- Database connection settings -->
<property name="connection.driver_class">org.hsqldb.jdbcDriver</property>
<property name="connection.url">jdbc:hsqldb:hsql:mem://localhost/xdb</property>
<property name="connection.username">sa</property>
<property name="connection.password"></property>
<!-- JDBC connection pool (use the built-in) -->
<property name="connection.pool_size">1</property>
<!-- SQL dialect -->
<property name="dialect">org.hibernate.dialect.HSQLDialect</property>
<!-- Enable Hibernate's automatic session context management -->
<property name="current_session_context_class">thread</property>
<!-- Disable the second-level cache -->
<property name="cache.provider_class">org.hibernate.cache.NoCacheProvider</property>
<!-- Echo all executed SQL to stdout -->
<property name="show_sql">true</property>
<!-- Drop and re-create the database schema on startup -->
<property name="hbm2ddl.auto">update</property>
<mapping class="com.baeldung.hibernate.immutable.entities.Event"/>
</session-factory>
</hibernate-configuration>

31
persistence-modules/spring-data-jpa-query-2/src/main/resources/insert_statements.sql Normal file
View File

@ -0,0 +1,31 @@
insert into item (item_id, item_name, item_desc, item_price)
values(1,'item One', 'test 1', 35.12);
insert into item (item_id, item_name, item_desc, item_price)
values(2,'Pogo stick', 'Pogo stick', 466.12);
insert into item (item_id, item_name, item_desc, item_price)
values(3,'Raft', 'Raft', 345.12);
insert into item (item_id, item_name, item_desc, item_price)
values(4,'Skate Board', 'Skating', 135.71);
insert into item (item_id, item_name, item_desc, item_price)
values(5,'Umbrella', 'Umbrella for Rain', 619.25);
insert into item (item_id, item_name, item_desc, item_price)
values(6,'Glue', 'Glue for home', 432.73);
insert into item (item_id, item_name, item_desc, item_price)
values(7,'Paint', 'Paint for Room', 1311.40);
insert into item (item_id, item_name, item_desc, item_price)
values(8,'Red paint', 'Red paint for room', 1135.71);
insert into item (item_id, item_name, item_desc, item_price)
values(9,'Household Chairs', 'Chairs for house', 25.71);
insert into item (item_id, item_name, item_desc, item_price)
values(10,'Office Chairs', 'Chairs for office', 395.98);
insert into item (item_id, item_name, item_desc, item_price)
values(11,'Outdoor Chairs', 'Chairs for outdoor activities', 1234.36);

19
persistence-modules/spring-data-jpa-query-2/src/main/resources/logback.xml Normal file
View File

@ -0,0 +1,19 @@
<?xml version="1.0" encoding="UTF-8"?>
<configuration>
<appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
<encoder>
<pattern>%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n
</pattern>
</encoder>
</appender>
<logger name="org.springframework" level="WARN" />
<logger name="org.springframework.transaction" level="WARN" />
<!-- in order to debug some marshalling issues, this needs to be TRACE -->
<logger name="org.springframework.web.servlet.mvc" level="WARN" />
<root level="INFO">
<appender-ref ref="STDOUT" />
</root>
</configuration>

13
persistence-modules/spring-data-jpa-query-2/src/main/resources/persistence-mysql.properties Normal file
View File

@ -0,0 +1,13 @@
# jdbc.X
jdbc.driverClassName=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/spring_hibernate4_01?createDatabaseIfNotExist=true
jdbc.user=tutorialuser
jdbc.pass=tutorialmy5ql
# hibernate.X
hibernate.dialect=org.hibernate.dialect.MySQL5Dialect
hibernate.show_sql=false
hibernate.hbm2ddl.auto=create-drop
# envers.X
envers.audit_table_suffix=_audit_log

20
persistence-modules/spring-data-jpa-query-2/src/main/resources/stored_procedure.sql Normal file
View File

@ -0,0 +1,20 @@
DELIMITER //
CREATE PROCEDURE GetFoosByName(IN fooName VARCHAR(255))
LANGUAGE SQL
DETERMINISTIC
SQL SECURITY DEFINER
BEGIN
SELECT * FROM foo WHERE name = fooName;
END //
DELIMITER ;
DELIMITER //
CREATE PROCEDURE GetAllFoos()
LANGUAGE SQL
DETERMINISTIC
SQL SECURITY DEFINER
BEGIN
SELECT * FROM foo;
END //
DELIMITER ;

37
persistence-modules/spring-data-jpa-query-2/src/main/resources/webSecurityConfig.xml Normal file
View File

@ -0,0 +1,37 @@
<?xml version="1.0" encoding="UTF-8"?>
<beans:beans xmlns="http://www.springframework.org/schema/security" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:beans="http://www.springframework.org/schema/beans"
xsi:schemaLocation="
http://www.springframework.org/schema/security http://www.springframework.org/schema/security/spring-security-4.2.xsd
http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.3.xsd"
>
<http use-expressions="true">
<access-denied-handler error-page="/access-denied.html"/>
<intercept-url pattern="/access-denied*" access="hasAnyRole('ROLE_LOCATION_WRITE','ROLE_POLYGON_WRITE')"/>
<intercept-url pattern="/admin/**" access="hasAnyRole('ROLE_ADMIN')"/>
<intercept-url pattern="/organization/**" access="hasAnyRole('ROLE_ORGANIZATION')"/>
<intercept-url pattern="/location/edit*" access="hasAnyRole('ROLE_LOCATION_WRITE')"/>
<intercept-url pattern="/location/view*" access="permitAll"/>
<intercept-url pattern="/login*" access="isAnonymous()"/>
<intercept-url pattern="/register*" access="isAnonymous()"/>
<intercept-url pattern="/login-denied/**" access="isAnonymous()"/>
<intercept-url pattern="/**" access="permitAll"/>
<form-login login-page='/login.html' default-target-url="/" always-use-default-target="false" authentication-failure-url="/login.html?error=true"/>
<logout/>
<anonymous/>
<session-management invalid-session-url="/">
<concurrency-control max-sessions="1"/>
</session-management>
</http>
<authentication-manager alias="authenticationManager" erase-credentials="false">
<authentication-provider ref="restAuthenticationProvider"/>
</authentication-manager>
</beans:beans>

42
persistence-modules/spring-data-jpa-query-2/src/test/java/com/baeldung/hibernate/fetching/HibernateFetchingIntegrationTest.java Normal file
View File

@ -0,0 +1,42 @@
package com.baeldung.hibernate.fetching;
import com.baeldung.hibernate.fetching.model.OrderDetail;
import com.baeldung.hibernate.fetching.view.FetchingAppView;
import org.hibernate.Hibernate;
import org.junit.Before;
import org.junit.Test;
import java.util.Set;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertTrue;
public class HibernateFetchingIntegrationTest {
// this loads sample data in the database
@Before
public void addFecthingTestData() {
FetchingAppView fav = new FetchingAppView();
fav.createTestData();
}
// testLazyFetching() tests the lazy loading
// Since it lazily loaded so orderDetalSetLazy won't
// be initialized
@Test
public void testLazyFetching() {
FetchingAppView fav = new FetchingAppView();
Set<OrderDetail> orderDetalSetLazy = fav.lazyLoaded();
assertFalse(Hibernate.isInitialized(orderDetalSetLazy));
}
// testEagerFetching() tests the eager loading
// Since it eagerly loaded so orderDetalSetLazy would
// be initialized
@Test
public void testEagerFetching() {
FetchingAppView fav = new FetchingAppView();
Set<OrderDetail> orderDetalSetEager = fav.eagerLoaded();
assertTrue(Hibernate.isInitialized(orderDetalSetEager));
}
}

25
persistence-modules/spring-data-jpa-query-2/src/test/java/com/baeldung/persistence/IntegrationTestSuite.java Normal file
View File

@ -0,0 +1,25 @@
package com.baeldung.persistence;
import org.junit.runner.RunWith;
import org.junit.runners.Suite;
import com.baeldung.persistence.audit.AuditTestSuite;
import com.baeldung.persistence.hibernate.FooPaginationPersistenceIntegrationTest;
import com.baeldung.persistence.hibernate.FooSortingPersistenceIntegrationTest;
import com.baeldung.persistence.service.FooServiceBasicPersistenceIntegrationTest;
import com.baeldung.persistence.service.FooServicePersistenceIntegrationTest;
import com.baeldung.persistence.service.ParentServicePersistenceIntegrationTest;
@RunWith(Suite.class)
@Suite.SuiteClasses({ // @formatter:off
AuditTestSuite.class
,FooServiceBasicPersistenceIntegrationTest.class
,FooPaginationPersistenceIntegrationTest.class
,FooServicePersistenceIntegrationTest.class
,ParentServicePersistenceIntegrationTest.class
,FooSortingPersistenceIntegrationTest.class
}) // @formatter:on
public class IntegrationTestSuite {
//
}

14
persistence-modules/spring-data-jpa-query-2/src/test/java/com/baeldung/persistence/audit/AuditTestSuite.java Normal file
View File

@ -0,0 +1,14 @@
package com.baeldung.persistence.audit;
import org.junit.runner.RunWith;
import org.junit.runners.Suite;
@RunWith(Suite.class)
@Suite.SuiteClasses({ // @formatter:off
EnversFooBarAuditIntegrationTest.class,
JPABarAuditIntegrationTest.class,
SpringDataJPABarAuditIntegrationTest.class
}) // @formatter:on
public class AuditTestSuite {
//
}

146
persistence-modules/spring-data-jpa-query-2/src/test/java/com/baeldung/persistence/audit/EnversFooBarAuditIntegrationTest.java Normal file
View File

@ -0,0 +1,146 @@
package com.baeldung.persistence.audit;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
import java.util.List;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.junit.After;
import org.junit.AfterClass;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.test.annotation.DirtiesContext;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.springframework.test.context.support.AnnotationConfigContextLoader;
import com.baeldung.persistence.model.Bar;
import com.baeldung.persistence.model.Foo;
import com.baeldung.persistence.service.IBarAuditableService;
import com.baeldung.persistence.service.IFooAuditableService;
import com.baeldung.spring.config.PersistenceTestConfig;
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = { PersistenceTestConfig.class }, loader = AnnotationConfigContextLoader.class)
@DirtiesContext(classMode = DirtiesContext.ClassMode.BEFORE_CLASS)
public class EnversFooBarAuditIntegrationTest {
private static Logger logger = LoggerFactory.getLogger(EnversFooBarAuditIntegrationTest.class);
@BeforeClass
public static void setUpBeforeClass() throws Exception {
logger.info("setUpBeforeClass()");
}
@AfterClass
public static void tearDownAfterClass() throws Exception {
logger.info("tearDownAfterClass()");
}
@Autowired
@Qualifier("fooHibernateAuditableService")
private IFooAuditableService fooService;
@Autowired
@Qualifier("barHibernateAuditableService")
private IBarAuditableService barService;
@Autowired
private SessionFactory sessionFactory;
private Session session;
@Before
public void setUp() throws Exception {
logger.info("setUp()");
makeRevisions();
session = sessionFactory.openSession();
}
@After
public void tearDown() throws Exception {
logger.info("tearDown()");
session.close();
}
private void makeRevisions() {
final Bar bar = rev1();
rev2(bar);
rev3(bar);
rev4(bar);
}
// REV #1: insert BAR & FOO1
private Bar rev1() {
final Bar bar = new Bar("BAR");
final Foo foo1 = new Foo("FOO1");
foo1.setBar(bar);
fooService.create(foo1);
return bar;
}
// REV #2: insert FOO2 & update BAR
private void rev2(final Bar bar) {
final Foo foo2 = new Foo("FOO2");
foo2.setBar(bar);
fooService.create(foo2);
}
// REV #3: update BAR
private void rev3(final Bar bar) {
bar.setName("BAR1");
barService.update(bar);
}
// REV #4: insert FOO3 & update BAR
private void rev4(final Bar bar) {
final Foo foo3 = new Foo("FOO3");
foo3.setBar(bar);
fooService.create(foo3);
}
@Test
public final void whenFooBarsModified_thenFooBarsAudited() {
List<Bar> barRevisionList;
List<Foo> fooRevisionList;
// test Bar revisions
barRevisionList = barService.getRevisions();
assertNotNull(barRevisionList);
assertEquals(4, barRevisionList.size());
assertEquals("BAR", barRevisionList.get(0).getName());
assertEquals("BAR", barRevisionList.get(1).getName());
assertEquals("BAR1", barRevisionList.get(2).getName());
assertEquals("BAR1", barRevisionList.get(3).getName());
assertEquals(1, barRevisionList.get(0).getFooSet().size());
assertEquals(2, barRevisionList.get(1).getFooSet().size());
assertEquals(2, barRevisionList.get(2).getFooSet().size());
assertEquals(3, barRevisionList.get(3).getFooSet().size());
// test Foo revisions
fooRevisionList = fooService.getRevisions();
assertNotNull(fooRevisionList);
assertEquals(3, fooRevisionList.size());
assertEquals("FOO1", fooRevisionList.get(0).getName());
assertEquals("FOO2", fooRevisionList.get(1).getName());
assertEquals("FOO3", fooRevisionList.get(2).getName());
}
}

104
persistence-modules/spring-data-jpa-query-2/src/test/java/com/baeldung/persistence/audit/JPABarAuditIntegrationTest.java Normal file
View File

@ -0,0 +1,104 @@
package com.baeldung.persistence.audit;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import org.junit.After;
import org.junit.AfterClass;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.springframework.test.context.support.AnnotationConfigContextLoader;
import com.baeldung.persistence.model.Bar;
import com.baeldung.persistence.model.Bar.OPERATION;
import com.baeldung.persistence.service.IBarService;
import com.baeldung.spring.config.PersistenceTestConfig;
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = { PersistenceTestConfig.class }, loader = AnnotationConfigContextLoader.class)
public class JPABarAuditIntegrationTest {
private static Logger logger = LoggerFactory.getLogger(JPABarAuditIntegrationTest.class);
@BeforeClass
public static void setUpBeforeClass() throws Exception {
logger.info("setUpBeforeClass()");
}
@AfterClass
public static void tearDownAfterClass() throws Exception {
logger.info("tearDownAfterClass()");
}
@Autowired
@Qualifier("barJpaService")
private IBarService barService;
@Autowired
@Qualifier("jpaEntityManager")
private EntityManagerFactory entityManagerFactory;
private EntityManager em;
@Before
public void setUp() throws Exception {
logger.info("setUp()");
em = entityManagerFactory.createEntityManager();
}
@After
public void tearDown() throws Exception {
logger.info("tearDown()");
em.close();
}
@Test
public final void whenBarsModified_thenBarsAudited() {
// insert BAR1
Bar bar1 = new Bar("BAR1");
barService.create(bar1);
// update BAR1
bar1.setName("BAR1a");
barService.update(bar1);
// insert BAR2
Bar bar2 = new Bar("BAR2");
barService.create(bar2);
// update BAR1
bar1.setName("BAR1b");
barService.update(bar1);
// get BAR1 and BAR2 from the DB and check the audit values
// detach instances from persistence context to make sure we fire db
em.detach(bar1);
em.detach(bar2);
bar1 = barService.findOne(bar1.getId());
bar2 = barService.findOne(bar2.getId());
assertNotNull(bar1);
assertNotNull(bar2);
assertEquals(OPERATION.UPDATE, bar1.getOperation());
assertEquals(OPERATION.INSERT, bar2.getOperation());
assertTrue(bar1.getTimestamp() > bar2.getTimestamp());
barService.deleteById(bar1.getId());
barService.deleteById(bar2.getId());
}
}

78
persistence-modules/spring-data-jpa-query-2/src/test/java/com/baeldung/persistence/audit/SpringDataJPABarAuditIntegrationTest.java Normal file
View File

@ -0,0 +1,78 @@
package com.baeldung.persistence.audit;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import org.junit.After;
import org.junit.AfterClass;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.security.test.context.support.WithMockUser;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.springframework.test.context.support.AnnotationConfigContextLoader;
import com.baeldung.persistence.model.Bar;
import com.baeldung.persistence.service.IBarService;
import com.baeldung.spring.config.PersistenceTestConfig;
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = { PersistenceTestConfig.class }, loader = AnnotationConfigContextLoader.class)
public class SpringDataJPABarAuditIntegrationTest {
private static Logger logger = LoggerFactory.getLogger(SpringDataJPABarAuditIntegrationTest.class);
@BeforeClass
public static void setUpBeforeClass() throws Exception {
logger.info("setUpBeforeClass()");
}
@AfterClass
public static void tearDownAfterClass() throws Exception {
logger.info("tearDownAfterClass()");
}
@Autowired
@Qualifier("barSpringDataJpaService")
private IBarService barService;
@Autowired
@Qualifier("jpaEntityManager")
private EntityManagerFactory entityManagerFactory;
private EntityManager em;
@Before
public void setUp() throws Exception {
logger.info("setUp()");
em = entityManagerFactory.createEntityManager();
}
@After
public void tearDown() throws Exception {
logger.info("tearDown()");
em.close();
}
@Test
@WithMockUser(username = "tutorialuser")
public final void whenBarsModified_thenBarsAudited() {
Bar bar = new Bar("BAR1");
barService.create(bar);
assertEquals(bar.getCreatedDate(), bar.getModifiedDate());
assertEquals("tutorialuser", bar.getCreatedBy(), bar.getModifiedBy());
bar.setName("BAR2");
bar = barService.update(bar);
assertTrue(bar.getCreatedDate() < bar.getModifiedDate());
assertEquals("tutorialuser", bar.getCreatedBy(), bar.getModifiedBy());
}
}

101
persistence-modules/spring-data-jpa-query-2/src/test/java/com/baeldung/persistence/hibernate/FooFixtures.java Normal file
View File

@ -0,0 +1,101 @@
package com.baeldung.persistence.hibernate;
import java.util.List;
import com.baeldung.persistence.model.Foo;
import com.baeldung.persistence.model.Bar;
import org.hibernate.HibernateException;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import com.google.common.collect.Lists;
public class FooFixtures {
private SessionFactory sessionFactory;
public FooFixtures(final SessionFactory sessionFactory) {
super();
this.sessionFactory = sessionFactory;
}
// API
public void createBars() {
Session session = null;
Transaction tx = null;
session = sessionFactory.openSession();
tx = session.getTransaction();
try {
tx.begin();
for (int i = 156; i < 160; i++) {
final Bar bar = new Bar();
bar.setName("Bar_" + i);
final Foo foo = new Foo("Foo_" + (i + 120));
foo.setBar(bar);
session.save(foo);
final Foo foo2 = new Foo(null);
if (i % 2 == 0)
foo2.setName("LuckyFoo" + (i + 120));
foo2.setBar(bar);
session.save(foo2);
bar.getFooSet().add(foo);
bar.getFooSet().add(foo2);
session.merge(bar);
}
tx.commit();
session.flush();
} catch (final HibernateException he) {
if (tx != null)
tx.rollback();
System.out.println("Not able to open session");
he.printStackTrace();
} catch (final Exception e) {
e.printStackTrace();
} finally {
if (session != null)
session.close();
}
}
public void createFoos() {
Session session = null;
Transaction tx = null;
session = sessionFactory.openSession();
tx = session.getTransaction();
final List<Foo> fooList = Lists.newArrayList();
for (int i = 35; i < 46; i++) {
final Foo foo = new Foo();
foo.setName("Foo_" + (i + 120));
final Bar bar = new Bar("bar_" + i);
bar.getFooSet().add(foo);
foo.setBar(bar);
fooList.add(foo);
}
try {
tx.begin();
for (final Foo foo : fooList) {
session.save(foo.getBar());
session.save(foo);
}
tx.commit();
session.flush();
} catch (final HibernateException he) {
if (tx != null)
tx.rollback();
System.out.println("Not able to open session");
he.printStackTrace();
} catch (final Exception e) {
e.printStackTrace();
} finally {
if (session != null)
session.close();
}
}
}

185
persistence-modules/spring-data-jpa-query-2/src/test/java/com/baeldung/persistence/hibernate/FooPaginationPersistenceIntegrationTest.java Normal file
View File

@ -0,0 +1,185 @@
package com.baeldung.persistence.hibernate;
import static org.apache.commons.lang3.RandomStringUtils.randomAlphabetic;
import static org.hamcrest.Matchers.hasSize;
import static org.hamcrest.Matchers.lessThan;
import static org.junit.Assert.assertThat;
import java.util.List;
import org.hibernate.Criteria;
import org.hibernate.Query;
import org.hibernate.ScrollMode;
import org.hibernate.ScrollableResults;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.criterion.Projections;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.springframework.test.context.support.AnnotationConfigContextLoader;
import com.baeldung.persistence.model.Foo;
import com.baeldung.persistence.service.IFooService;
import com.baeldung.spring.config.PersistenceTestConfig;
import com.google.common.collect.Lists;
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = { PersistenceTestConfig.class }, loader = AnnotationConfigContextLoader.class)
public class FooPaginationPersistenceIntegrationTest {
@Autowired
private IFooService fooService;
@Autowired
private SessionFactory sessionFactory;
private Session session;
// tests
@Before
public final void before() {
final int minimalNumberOfEntities = 25;
if (fooService.findAll().size() <= minimalNumberOfEntities) {
for (int i = 0; i < minimalNumberOfEntities; i++) {
fooService.create(new Foo(randomAlphabetic(6)));
}
}
session = sessionFactory.openSession();
}
@After
public final void after() {
session.close();
}
// tests
@Test
public final void whenContextIsBootstrapped_thenNoExceptions() {
//
}
@SuppressWarnings("unchecked")
@Test
public final void whenRetrievingPaginatedEntities_thenCorrectSize() {
final int pageNumber = 1;
final int pageSize = 10;
final Query query = session.createQuery("From Foo");
query.setFirstResult((pageNumber - 1) * pageSize);
query.setMaxResults(pageSize);
final List<Foo> fooList = query.list();
assertThat(fooList, hasSize(pageSize));
}
@SuppressWarnings("unchecked")
@Test
public final void whenRetrievingAllPages_thenCorrect() {
int pageNumber = 1;
final int pageSize = 10;
final String countQ = "Select count (f.id) from Foo f";
final Query countQuery = session.createQuery(countQ);
final Long countResult = (Long) countQuery.uniqueResult();
final List<Foo> fooList = Lists.newArrayList();
int totalEntities = 0;
final Query query = session.createQuery("From Foo");
while (totalEntities < countResult) {
query.setFirstResult((pageNumber - 1) * pageSize);
query.setMaxResults(pageSize);
fooList.addAll(query.list());
totalEntities = fooList.size();
pageNumber++;
}
}
@SuppressWarnings("unchecked")
@Test
public final void whenRetrievingLastPage_thenCorrectSize() {
final int pageSize = 10;
final String countQ = "Select count (f.id) from Foo f";
final Query countQuery = session.createQuery(countQ);
final Long countResults = (Long) countQuery.uniqueResult();
final int lastPageNumber = (int) (Math.ceil(countResults / pageSize));
final Query selectQuery = session.createQuery("From Foo");
selectQuery.setFirstResult((lastPageNumber - 1) * pageSize);
selectQuery.setMaxResults(pageSize);
final List<Foo> lastPage = selectQuery.list();
assertThat(lastPage, hasSize(lessThan(pageSize + 1)));
}
// testing - scrollable
@Test
public final void givenUsingTheScrollableApi_whenRetrievingPaginatedData_thenCorrect() {
final int pageSize = 10;
final String hql = "FROM Foo f order by f.name";
final Query query = session.createQuery(hql);
final ScrollableResults resultScroll = query.scroll(ScrollMode.FORWARD_ONLY);
// resultScroll.last();
// final int totalResults = resultScroll.getRowNumber() + 1;
resultScroll.first();
resultScroll.scroll(0);
final List<Foo> fooPage = Lists.newArrayList();
int i = 0;
while (pageSize > i++) {
fooPage.add((Foo) resultScroll.get(0));
if (!resultScroll.next()) {
break;
}
}
assertThat(fooPage, hasSize(lessThan(10 + 1)));
}
@SuppressWarnings("unchecked")
@Test
public final void givenUsingTheCriteriaApi_whenRetrievingFirstPage_thenCorrect() {
final int pageSize = 10;
final Criteria criteria = session.createCriteria(Foo.class);
criteria.setFirstResult(0);
criteria.setMaxResults(pageSize);
final List<Foo> firstPage = criteria.list();
assertThat(firstPage, hasSize(pageSize));
}
@SuppressWarnings("unchecked")
@Test
public final void givenUsingTheCriteriaApi_whenRetrievingPaginatedData_thenCorrect() {
final Criteria criteriaCount = session.createCriteria(Foo.class);
criteriaCount.setProjection(Projections.rowCount());
final Long count = (Long) criteriaCount.uniqueResult();
int pageNumber = 1;
final int pageSize = 10;
final List<Foo> fooList = Lists.newArrayList();
final Criteria criteria = session.createCriteria(Foo.class);
int totalEntities = 0;
while (totalEntities < count.intValue()) {
criteria.setFirstResult((pageNumber - 1) * pageSize);
criteria.setMaxResults(pageSize);
fooList.addAll(criteria.list());
totalEntities = fooList.size();
pageNumber++;
}
}
}

174
persistence-modules/spring-data-jpa-query-2/src/test/java/com/baeldung/persistence/hibernate/FooSortingPersistenceIntegrationTest.java Normal file
View File

@ -0,0 +1,174 @@
package com.baeldung.persistence.hibernate;
import static org.junit.Assert.assertNull;
import java.util.List;
import java.util.Set;
import org.hibernate.Criteria;
import org.hibernate.NullPrecedence;
import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.criterion.Order;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.springframework.test.context.support.AnnotationConfigContextLoader;
import com.baeldung.persistence.model.Bar;
import com.baeldung.persistence.model.Foo;
import com.baeldung.spring.config.PersistenceTestConfig;
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = { PersistenceTestConfig.class }, loader = AnnotationConfigContextLoader.class)
@SuppressWarnings("unchecked")
public class FooSortingPersistenceIntegrationTest {
@Autowired
private SessionFactory sessionFactory;
private Session session;
@Before
public void before() {
session = sessionFactory.openSession();
session.beginTransaction();
final FooFixtures fooData = new FooFixtures(sessionFactory);
fooData.createBars();
}
@After
public void after() {
session.getTransaction().commit();
session.close();
}
@Test
public final void whenHQlSortingByOneAttribute_thenPrintSortedResults() {
final String hql = "FROM Foo f ORDER BY f.name";
final Query query = session.createQuery(hql);
final List<Foo> fooList = query.list();
for (final Foo foo : fooList) {
System.out.println("Name: " + foo.getName() + ", Id: " + foo.getId());
}
}
@Test
public final void whenHQlSortingByStringNullLast_thenLastNull() {
final String hql = "FROM Foo f ORDER BY f.name NULLS LAST";
final Query query = session.createQuery(hql);
final List<Foo> fooList = query.list();
assertNull(fooList.get(fooList.toArray().length - 1).getName());
for (final Foo foo : fooList) {
System.out.println("Name: " + foo.getName() + ", Id: " + foo.getId());
}
}
@Test
public final void whenSortingByStringNullsFirst_thenReturnNullsFirst() {
final String hql = "FROM Foo f ORDER BY f.name NULLS FIRST";
final Query query = session.createQuery(hql);
final List<Foo> fooList = query.list();
assertNull(fooList.get(0).getName());
for (final Foo foo : fooList) {
System.out.println("Name:" + foo.getName());
}
}
@Test
public final void whenHQlSortingByOneAttribute_andOrderDirection_thenPrintSortedResults() {
final String hql = "FROM Foo f ORDER BY f.name ASC";
final Query query = session.createQuery(hql);
final List<Foo> fooList = query.list();
for (final Foo foo : fooList) {
System.out.println("Name: " + foo.getName() + ", Id: " + foo.getId());
}
}
@Test
public final void whenHQlSortingByMultipleAttributes_thenSortedResults() {
final String hql = "FROM Foo f ORDER BY f.name, f.id";
final Query query = session.createQuery(hql);
final List<Foo> fooList = query.list();
for (final Foo foo : fooList) {
System.out.println("Name: " + foo.getName() + ", Id: " + foo.getId());
}
}
@Test
public final void whenHQlSortingByMultipleAttributes_andOrderDirection_thenPrintSortedResults() {
final String hql = "FROM Foo f ORDER BY f.name DESC, f.id ASC";
final Query query = session.createQuery(hql);
final List<Foo> fooList = query.list();
for (final Foo foo : fooList) {
System.out.println("Name: " + foo.getName() + ", Id: " + foo.getId());
}
}
@Test
public final void whenHQLCriteriaSortingByOneAttr_thenPrintSortedResults() {
final Criteria criteria = session.createCriteria(Foo.class, "FOO");
criteria.addOrder(Order.asc("id"));
final List<Foo> fooList = criteria.list();
for (final Foo foo : fooList) {
System.out.println("Id: " + foo.getId() + ", FirstName: " + foo.getName());
}
}
@Test
public final void whenHQLCriteriaSortingByMultipAttr_thenSortedResults() {
final Criteria criteria = session.createCriteria(Foo.class, "FOO");
criteria.addOrder(Order.asc("name"));
criteria.addOrder(Order.asc("id"));
final List<Foo> fooList = criteria.list();
for (final Foo foo : fooList) {
System.out.println("Id: " + foo.getId() + ", FirstName: " + foo.getName());
}
}
@Test
public final void whenCriteriaSortingStringNullsLastAsc_thenNullsLast() {
final Criteria criteria = session.createCriteria(Foo.class, "FOO");
criteria.addOrder(Order.asc("name").nulls(NullPrecedence.LAST));
final List<Foo> fooList = criteria.list();
assertNull(fooList.get(fooList.toArray().length - 1).getName());
for (final Foo foo : fooList) {
System.out.println("Id: " + foo.getId() + ", FirstName: " + foo.getName());
}
}
@Test
public final void whenCriteriaSortingStringNullsFirstDesc_thenNullsFirst() {
final Criteria criteria = session.createCriteria(Foo.class, "FOO");
criteria.addOrder(Order.desc("name").nulls(NullPrecedence.FIRST));
final List<Foo> fooList = criteria.list();
assertNull(fooList.get(0).getName());
for (final Foo foo : fooList) {
System.out.println("Id: " + foo.getId() + ", FirstName: " + foo.getName());
}
}
@Test
public final void whenSortingBars_thenBarsWithSortedFoos() {
final String hql = "FROM Bar b ORDER BY b.id";
final Query query = session.createQuery(hql);
final List<Bar> barList = query.list();
for (final Bar bar : barList) {
final Set<Foo> fooSet = bar.getFooSet();
System.out.println("Bar Id:" + bar.getId());
for (final Foo foo : fooSet) {
System.out.println("FooName:" + foo.getName());
}
}
}
}

55
persistence-modules/spring-data-jpa-query-2/src/test/java/com/baeldung/persistence/service/FooServiceBasicPersistenceIntegrationTest.java Normal file
View File

@ -0,0 +1,55 @@
package com.baeldung.persistence.service;
import static org.apache.commons.lang3.RandomStringUtils.randomAlphabetic;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.springframework.test.context.support.AnnotationConfigContextLoader;
import com.baeldung.persistence.model.Foo;
import com.baeldung.spring.config.PersistenceTestConfig;
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = { PersistenceTestConfig.class }, loader = AnnotationConfigContextLoader.class)
public class FooServiceBasicPersistenceIntegrationTest {
@Autowired
private SessionFactory sessionFactory;
@Autowired
private IFooService fooService;
private Session session;
// tests
@Before
public final void before() {
session = sessionFactory.openSession();
}
@After
public final void after() {
session.close();
}
// tests
@Test
public final void whenContextIsBootstrapped_thenNoExceptions() {
//
}
@Test
public final void whenEntityIsCreated_thenNoExceptions() {
fooService.create(new Foo(randomAlphabetic(6)));
}
}

64
persistence-modules/spring-data-jpa-query-2/src/test/java/com/baeldung/persistence/service/FooServicePersistenceIntegrationTest.java Normal file
View File

@ -0,0 +1,64 @@
package com.baeldung.persistence.service;
import static org.apache.commons.lang3.RandomStringUtils.randomAlphabetic;
import org.junit.Ignore;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.dao.DataAccessException;
import org.springframework.dao.DataIntegrityViolationException;
import org.springframework.dao.InvalidDataAccessApiUsageException;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.springframework.test.context.support.AnnotationConfigContextLoader;
import com.baeldung.persistence.model.Foo;
import com.baeldung.spring.config.PersistenceTestConfig;
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = { PersistenceTestConfig.class }, loader = AnnotationConfigContextLoader.class)
public class FooServicePersistenceIntegrationTest {
@Autowired
@Qualifier("fooHibernateService")
private IFooService service;
// tests
@Test
public final void whenContextIsBootstrapped_thenNoExceptions() {
//
}
@Test
public final void whenEntityIsCreated_thenNoExceptions() {
service.create(new Foo(randomAlphabetic(6)));
}
@Test(expected = DataIntegrityViolationException.class)
@Ignore("work in progress")
public final void whenInvalidEntityIsCreated_thenDataException() {
service.create(new Foo());
}
@Test(expected = DataIntegrityViolationException.class)
public final void whenEntityWithLongNameIsCreated_thenDataException() {
service.create(new Foo(randomAlphabetic(2048)));
}
@Test(expected = InvalidDataAccessApiUsageException.class)
@Ignore("Right now, persist has saveOrUpdate semantics, so this will no longer fail")
public final void whenSameEntityIsCreatedTwice_thenDataException() {
final Foo entity = new Foo(randomAlphabetic(8));
service.create(entity);
service.create(entity);
}
@Test(expected = DataAccessException.class)
public final void temp_whenInvalidEntityIsCreated_thenDataException() {
service.create(new Foo(randomAlphabetic(2048)));
}
}

121
persistence-modules/spring-data-jpa-query-2/src/test/java/com/baeldung/persistence/service/FooStoredProceduresLiveTest.java Normal file
View File

@ -0,0 +1,121 @@
package com.baeldung.persistence.service;
import java.util.List;
import static org.apache.commons.lang3.RandomStringUtils.randomAlphabetic;
import static org.junit.Assert.assertEquals;
import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.exception.SQLGrammarException;
import org.junit.After;
import org.junit.Assume;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.springframework.test.context.support.AnnotationConfigContextLoader;
import com.baeldung.config.PersistenceConfig;
import com.baeldung.persistence.model.Foo;
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = { PersistenceConfig.class }, loader = AnnotationConfigContextLoader.class)
public class FooStoredProceduresLiveTest {
private static final Logger LOGGER = LoggerFactory.getLogger(FooStoredProceduresLiveTest.class);
@Autowired
private SessionFactory sessionFactory;
@Autowired
private IFooService fooService;
private Session session;
@Before
public final void before() {
session = sessionFactory.openSession();
Assume.assumeTrue(getAllFoosExists());
Assume.assumeTrue(getFoosByNameExists());
}
private boolean getFoosByNameExists() {
try {
Query sqlQuery = session.createSQLQuery("CALL GetAllFoos()").addEntity(Foo.class);
sqlQuery.list();
return true;
} catch (SQLGrammarException e) {
LOGGER.error("WARNING : GetFoosByName() Procedure is may be missing ", e);
return false;
}
}
private boolean getAllFoosExists() {
try {
Query sqlQuery = session.createSQLQuery("CALL GetAllFoos()").addEntity(Foo.class);
sqlQuery.list();
return true;
} catch (SQLGrammarException e) {
LOGGER.error("WARNING : GetAllFoos() Procedure is may be missing ", e);
return false;
}
}
@After
public final void after() {
session.close();
}
@Test
public final void getAllFoosUsingStoredProcedures() {
fooService.create(new Foo(randomAlphabetic(6)));
// Stored procedure getAllFoos using createSQLQuery
Query sqlQuery = session.createSQLQuery("CALL GetAllFoos()").addEntity(Foo.class);
@SuppressWarnings("unchecked")
List<Foo> allFoos = sqlQuery.list();
for (Foo foo : allFoos) {
LOGGER.info("getAllFoos() SQL Query result : {}", foo.getName());
}
assertEquals(allFoos.size(), fooService.findAll().size());
// Stored procedure getAllFoos using a Named Query
Query namedQuery = session.getNamedQuery("callGetAllFoos");
@SuppressWarnings("unchecked")
List<Foo> allFoos2 = namedQuery.list();
for (Foo foo : allFoos2) {
LOGGER.info("getAllFoos() NamedQuery result : {}", foo.getName());
}
assertEquals(allFoos2.size(), fooService.findAll().size());
}
@Test
public final void getFoosByNameUsingStoredProcedures() {
fooService.create(new Foo("NewFooName"));
// Stored procedure getFoosByName using createSQLQuery()
Query sqlQuery = session.createSQLQuery("CALL GetFoosByName(:fooName)").addEntity(Foo.class).setParameter("fooName", "NewFooName");
@SuppressWarnings("unchecked")
List<Foo> allFoosByName = sqlQuery.list();
for (Foo foo : allFoosByName) {
LOGGER.info("getFoosByName() using SQL Query : found => {}", foo.toString());
}
// Stored procedure getFoosByName using getNamedQuery()
Query namedQuery = session.getNamedQuery("callGetFoosByName").setParameter("fooName", "NewFooName");
@SuppressWarnings("unchecked")
List<Foo> allFoosByName2 = namedQuery.list();
for (Foo foo : allFoosByName2) {
LOGGER.info("getFoosByName() using Native Query : found => {}", foo.toString());
}
}
}

70
persistence-modules/spring-data-jpa-query-2/src/test/java/com/baeldung/persistence/service/ParentServicePersistenceIntegrationTest.java Normal file
View File

@ -0,0 +1,70 @@
package com.baeldung.persistence.service;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.dao.DataIntegrityViolationException;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.springframework.test.context.support.AnnotationConfigContextLoader;
import com.baeldung.persistence.model.Child;
import com.baeldung.persistence.model.Parent;
import com.baeldung.spring.config.PersistenceTestConfig;
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = { PersistenceTestConfig.class }, loader = AnnotationConfigContextLoader.class)
public class ParentServicePersistenceIntegrationTest {
@Autowired
private IParentService service;
@Autowired
private IChildService childService;
// tests
@Test
public final void whenContextIsBootstrapped_thenNoExceptions() {
//
}
@Test
public final void whenOneToOneEntitiesAreCreated_thenNoExceptions() {
final Child childEntity = new Child();
childService.create(childEntity);
final Parent parentEntity = new Parent(childEntity);
service.create(parentEntity);
System.out.println("Child = " + childService.findOne(childEntity.getId()));
System.out.println("Child - parent = " + childService.findOne(childEntity.getId()).getParent());
System.out.println("Parent = " + service.findOne(parentEntity.getId()));
System.out.println("Parent - child = " + service.findOne(parentEntity.getId()).getChild());
}
@Test(expected = DataIntegrityViolationException.class)
public final void whenChildIsDeletedWhileParentStillHasForeignKeyToIt_thenDataException() {
final Child childEntity = new Child();
childService.create(childEntity);
final Parent parentEntity = new Parent(childEntity);
service.create(parentEntity);
childService.delete(childEntity);
}
@Test
public final void whenChildIsDeletedAfterTheParent_thenNoExceptions() {
final Child childEntity = new Child();
childService.create(childEntity);
final Parent parentEntity = new Parent(childEntity);
service.create(parentEntity);
service.delete(parentEntity);
childService.delete(childEntity);
}
}

179
persistence-modules/spring-data-jpa-query-2/src/test/java/com/baeldung/spring/config/PersistenceTestConfig.java Normal file
View File

@ -0,0 +1,179 @@
package com.baeldung.spring.config;
import java.util.Properties;
import javax.sql.DataSource;
import org.apache.tomcat.dbcp.dbcp2.BasicDataSource;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.PropertySource;
import org.springframework.core.env.Environment;
import org.springframework.dao.annotation.PersistenceExceptionTranslationPostProcessor;
import org.springframework.data.jpa.repository.config.EnableJpaAuditing;
import org.springframework.data.jpa.repository.config.EnableJpaRepositories;
import org.springframework.orm.hibernate5.HibernateTransactionManager;
import org.springframework.orm.hibernate5.LocalSessionFactoryBean;
import org.springframework.orm.jpa.JpaTransactionManager;
import org.springframework.orm.jpa.JpaVendorAdapter;
import org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean;
import org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter;
import org.springframework.transaction.PlatformTransactionManager;
import org.springframework.transaction.annotation.EnableTransactionManagement;
import com.baeldung.persistence.dao.IBarAuditableDao;
import com.baeldung.persistence.dao.IBarDao;
import com.baeldung.persistence.dao.IFooAuditableDao;
import com.baeldung.persistence.dao.IFooDao;
import com.baeldung.persistence.dao.impl.BarAuditableDao;
import com.baeldung.persistence.dao.impl.BarDao;
import com.baeldung.persistence.dao.impl.BarJpaDao;
import com.baeldung.persistence.dao.impl.FooAuditableDao;
import com.baeldung.persistence.dao.impl.FooDao;
import com.baeldung.persistence.service.IBarAuditableService;
import com.baeldung.persistence.service.IBarService;
import com.baeldung.persistence.service.IFooAuditableService;
import com.baeldung.persistence.service.IFooService;
import com.baeldung.persistence.service.impl.BarAuditableService;
import com.baeldung.persistence.service.impl.BarJpaService;
import com.baeldung.persistence.service.impl.BarSpringDataJpaService;
import com.baeldung.persistence.service.impl.FooAuditableService;
import com.baeldung.persistence.service.impl.FooService;
import com.google.common.base.Preconditions;
@Configuration
@EnableTransactionManagement
@EnableJpaRepositories(basePackages = { "com.baeldung.persistence" }, transactionManagerRef = "jpaTransactionManager", entityManagerFactoryRef = "jpaEntityManager")
@EnableJpaAuditing
@PropertySource({ "classpath:persistence-h2.properties" })
@ComponentScan({ "com.baeldung.persistence" })
public class PersistenceTestConfig {
@Autowired
private Environment env;
public PersistenceTestConfig() {
super();
}
@Bean
public LocalSessionFactoryBean sessionFactory() {
final LocalSessionFactoryBean sessionFactory = new LocalSessionFactoryBean();
sessionFactory.setDataSource(restDataSource());
sessionFactory.setPackagesToScan(new String[] { "com.baeldung.persistence.model" });
sessionFactory.setHibernateProperties(hibernateProperties());
return sessionFactory;
}
@Bean("jpaEntityManager")
public LocalContainerEntityManagerFactoryBean entityManagerFactory() {
final LocalContainerEntityManagerFactoryBean emf = new LocalContainerEntityManagerFactoryBean();
emf.setDataSource(restDataSource());
emf.setPackagesToScan(new String[] { "com.baeldung.persistence.model" });
final JpaVendorAdapter vendorAdapter = new HibernateJpaVendorAdapter();
emf.setJpaVendorAdapter(vendorAdapter);
emf.setJpaProperties(hibernateProperties());
return emf;
}
@Bean
public DataSource restDataSource() {
final BasicDataSource dataSource = new BasicDataSource();
dataSource.setDriverClassName(Preconditions.checkNotNull(env.getProperty("jdbc.driverClassName")));
dataSource.setUrl(Preconditions.checkNotNull(env.getProperty("jdbc.url")));
dataSource.setUsername(Preconditions.checkNotNull(env.getProperty("jdbc.user")));
dataSource.setPassword(Preconditions.checkNotNull(env.getProperty("jdbc.pass")));
return dataSource;
}
@Bean
public PlatformTransactionManager hibernateTransactionManager() {
final HibernateTransactionManager transactionManager = new HibernateTransactionManager();
transactionManager.setSessionFactory(sessionFactory().getObject());
return transactionManager;
}
@Bean
public PlatformTransactionManager jpaTransactionManager() {
final JpaTransactionManager transactionManager = new JpaTransactionManager();
transactionManager.setEntityManagerFactory(entityManagerFactory().getObject());
return transactionManager;
}
@Bean
public PersistenceExceptionTranslationPostProcessor exceptionTranslation() {
return new PersistenceExceptionTranslationPostProcessor();
}
@Bean
public IBarService barJpaService() {
return new BarJpaService();
}
@Bean
public IBarService barSpringDataJpaService() {
return new BarSpringDataJpaService();
}
@Bean
public IFooService fooHibernateService() {
return new FooService();
}
@Bean
public IBarAuditableService barHibernateAuditableService() {
return new BarAuditableService();
}
@Bean
public IFooAuditableService fooHibernateAuditableService() {
return new FooAuditableService();
}
@Bean
public IBarDao barJpaDao() {
return new BarJpaDao();
}
@Bean
public IBarDao barHibernateDao() {
return new BarDao();
}
@Bean
public IBarAuditableDao barHibernateAuditableDao() {
return new BarAuditableDao();
}
@Bean
public IFooDao fooHibernateDao() {
return new FooDao();
}
@Bean
public IFooAuditableDao fooHibernateAuditableDao() {
return new FooAuditableDao();
}
private final Properties hibernateProperties() {
final Properties hibernateProperties = new Properties();
hibernateProperties.setProperty("hibernate.hbm2ddl.auto", env.getProperty("hibernate.hbm2ddl.auto"));
hibernateProperties.setProperty("hibernate.dialect", env.getProperty("hibernate.dialect"));
hibernateProperties.setProperty("hibernate.show_sql", "true");
// hibernateProperties.setProperty("hibernate.format_sql", "true");
// hibernateProperties.setProperty("hibernate.globally_quoted_identifiers", "true");
// Envers properties
hibernateProperties.setProperty("org.hibernate.envers.audit_table_suffix", env.getProperty("envers.audit_table_suffix"));
return hibernateProperties;
}
}

3
persistence-modules/spring-data-jpa-query-2/src/test/java/com/baeldung/spring/data/jpa/query/datetime/ArticleRepositoryIntegrationTest.java
View File

@ -6,6 +6,9 @@ import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.orm.jpa.DataJpaTest;
import org.springframework.test.context.junit4.SpringRunner;
import com.baeldung.spring.data.jpa.query.datetime.Article;
import com.baeldung.spring.data.jpa.query.datetime.ArticleRepository;
import java.text.SimpleDateFormat;
import java.util.Arrays;
import java.util.List;

19
persistence-modules/spring-data-jpa-query-2/src/test/resources/fetching.cfg.xml Normal file
View File

@ -0,0 +1,19 @@
<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE hibernate-configuration PUBLIC
"-//Hibernate/Hibernate Configuration DTD 3.0//EN"
"http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
<session-factory>
<property name="hibernate.connection.driver_class">org.h2.Driver</property>
<property name="hibernate.connection.url">jdbc:h2:mem:testdb</property>
<property name="hibernate.connection.username">sa</property>
<property name="hibernate.connection.password"></property>
<property name="hibernate.dialect">org.hibernate.dialect.H2Dialect</property>
<property name="hibernate.hbm2ddl.auto">update</property>
<property name="show_sql">true</property>
<mapping class="com.baeldung.hibernate.fetching.model.UserEager" />
<mapping class="com.baeldung.hibernate.fetching.model.OrderDetail" />
</session-factory>
</hibernate-configuration>

19
persistence-modules/spring-data-jpa-query-2/src/test/resources/fetchingLazy.cfg.xml Normal file
View File

@ -0,0 +1,19 @@
<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE hibernate-configuration PUBLIC
"-//Hibernate/Hibernate Configuration DTD 3.0//EN"
"http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
<session-factory>
<property name="hibernate.connection.driver_class">org.h2.Driver</property>
<property name="hibernate.connection.url">jdbc:h2:mem:testdb</property>
<property name="hibernate.connection.username">sa</property>
<property name="hibernate.connection.password"></property>
<property name="hibernate.dialect">org.hibernate.dialect.H2Dialect</property>
<property name="hibernate.hbm2ddl.auto">update</property>
<property name="show_sql">true</property>
<mapping class="com.baeldung.hibernate.fetching.model.UserLazy" />
<mapping class="com.baeldung.hibernate.fetching.model.OrderDetail" />
</session-factory>
</hibernate-configuration>

13
persistence-modules/spring-data-jpa-query-2/src/test/resources/persistence-h2.properties Normal file
View File

@ -0,0 +1,13 @@
# jdbc.X
jdbc.driverClassName=org.h2.Driver
jdbc.url=jdbc:h2:mem:test
jdbc.user=sa
jdbc.pass=
# hibernate.X
hibernate.dialect=org.hibernate.dialect.H2Dialect
hibernate.show_sql=false
hibernate.hbm2ddl.auto=create-drop
# envers.X
envers.audit_table_suffix=_audit_log